Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

extensions/signal/src/client.ts

@@ -0,0 +1,449 @@
+// Signal plugin module implements client behavior.
+import { Buffer } from "node:buffer";
+import http, { type ClientRequest, type IncomingMessage } from "node:http";
+import https from "node:https";
+import { generateSecureUuid } from "openclaw/plugin-sdk/core";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+
+export type SignalRpcOptions = {
+  baseUrl: string;
+  timeoutMs?: number;
+  maxResponseBytes?: number;
+};
+
+export type SignalRpcError = {
+  code?: number;
+  message?: string;
+  data?: unknown;
+};
+
+export type SignalRpcResponse<T> = {
+  jsonrpc?: string;
+  result?: T;
+  error?: SignalRpcError;
+  id?: string | number | null;
+};
+
+export type SignalSseEvent = {
+  event?: string;
+  data?: string;
+  id?: string;
+};
+
+const DEFAULT_TIMEOUT_MS = 10_000;
+const DEFAULT_SIGNAL_HTTP_RESPONSE_MAX_BYTES = 1_048_576;
+const MAX_SIGNAL_SSE_BUFFER_BYTES = 1_048_576;
+const MAX_SIGNAL_SSE_EVENT_DATA_BYTES = 1_048_576;
+
+type SignalHttpResponse = {
+  status: number;
+  statusText: string;
+  text: string;
+};
+
+function createSignalSseAbortError(): Error {
+  const error = new Error("Signal SSE aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+function normalizeBaseUrl(url: string): string {
+  const trimmed = url.trim();
+  if (!trimmed) {
+    throw new Error("Signal base URL is required");
+  }
+  if (/^https?:\/\//i.test(trimmed)) {
+    return trimmed.replace(/\/+$/, "");
+  }
+  return `http://${trimmed}`.replace(/\/+$/, "");
+}
+
+function parseSignalBaseUrl(url: string): URL {
+  const parsed = new URL(normalizeBaseUrl(url));
+  if (parsed.username || parsed.password) {
+    throw new Error("Signal base URL must not include credentials");
+  }
+  return parsed;
+}
+
+function resolveSignalEndpointUrl(baseUrl: string, pathname: string): URL {
+  return new URL(pathname, parseSignalBaseUrl(baseUrl));
+}
+
+function parseSignalRpcResponse<T>(text: string, status: number): SignalRpcResponse<T> {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch (err) {
+    throw new Error(`Signal RPC returned malformed JSON (status ${status})`, { cause: err });
+  }
+
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error(`Signal RPC returned invalid response envelope (status ${status})`);
+  }
+
+  const rpc = parsed as SignalRpcResponse<T>;
+  const hasResult = Object.hasOwn(rpc, "result");
+  if (!rpc.error && !hasResult) {
+    throw new Error(`Signal RPC returned invalid response envelope (status ${status})`);
+  }
+  return rpc;
+}
+
+function assertSignalHttpProtocol(url: URL, label: string): void {
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`Signal ${label} unsupported protocol: ${url.protocol}`);
+  }
+}
+
+function normalizeSignalHttpResponseMaxBytes(value: number | undefined): number {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return DEFAULT_SIGNAL_HTTP_RESPONSE_MAX_BYTES;
+  }
+  return Math.floor(value);
+}
+
+function normalizeSignalSseTimeoutMs(timeoutMs: number): number | null {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return null;
+  }
+  return resolveTimerTimeoutMs(timeoutMs, DEFAULT_TIMEOUT_MS);
+}
+
+function requestSignalHttpText(
+  url: URL,
+  options: {
+    method: "GET" | "POST";
+    headers?: Record<string, string>;
+    body?: string;
+    timeoutMs: number;
+    maxResponseBytes?: number;
+  },
+): Promise<SignalHttpResponse> {
+  assertSignalHttpProtocol(url, "HTTP");
+  const timeoutMs = resolveTimerTimeoutMs(options.timeoutMs, DEFAULT_TIMEOUT_MS);
+  const client = url.protocol === "https:" ? https : http;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const deadline = setTimeout(() => {
+      request?.destroy(new Error(`Signal HTTP exceeded deadline after ${timeoutMs}ms`));
+    }, timeoutMs);
+    deadline.unref?.();
+    const cleanup = () => {
+      clearTimeout(deadline);
+      request?.setTimeout(0);
+    };
+    const rejectOnce = (error: unknown) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      reject(toLintErrorObject(error, "Non-Error rejection"));
+    };
+    const resolveOnce = (response: SignalHttpResponse) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      resolve(response);
+    };
+    const maxResponseBytes = normalizeSignalHttpResponseMaxBytes(options.maxResponseBytes);
+    const request: ClientRequest | undefined = client.request(
+      url,
+      {
+        method: options.method,
+        headers: options.headers,
+      },
+      (res) => {
+        const chunks: Buffer[] = [];
+        let totalBytes = 0;
+        res.on("data", (chunk: Buffer | string) => {
+          const next = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+          totalBytes += next.byteLength;
+          if (totalBytes > maxResponseBytes) {
+            const error = new Error("Signal HTTP response exceeded size limit");
+            request?.destroy(error);
+            res.destroy(error);
+            rejectOnce(error);
+            return;
+          }
+          chunks.push(next);
+        });
+        res.on("error", rejectOnce);
+        res.on("end", () => {
+          resolveOnce({
+            status: res.statusCode ?? 0,
+            statusText: res.statusMessage || "error",
+            text: Buffer.concat(chunks).toString("utf8"),
+          });
+        });
+      },
+    );
+    request.setTimeout(timeoutMs, () => {
+      request?.destroy(new Error(`Signal HTTP timed out after ${timeoutMs}ms`));
+    });
+    request.on("error", rejectOnce);
+    if (options.body !== undefined) {
+      request.write(options.body);
+    }
+    request.end();
+  });
+}
+
+export async function signalRpcRequest<T = unknown>(
+  method: string,
+  params: Record<string, unknown> | undefined,
+  opts: SignalRpcOptions,
+): Promise<T> {
+  const id = generateSecureUuid();
+  const body = JSON.stringify({
+    jsonrpc: "2.0",
+    method,
+    params,
+    id,
+  });
+  const res = await requestSignalHttpText(resolveSignalEndpointUrl(opts.baseUrl, "/api/v1/rpc"), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Content-Length": String(Buffer.byteLength(body)),
+    },
+    body,
+    timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    maxResponseBytes: opts.maxResponseBytes,
+  });
+  if (res.status === 201) {
+    return undefined as T;
+  }
+  if (!res.text) {
+    throw new Error(`Signal RPC empty response (status ${res.status})`);
+  }
+  const parsed = parseSignalRpcResponse<T>(res.text, res.status);
+  if (parsed.error) {
+    const code = parsed.error.code ?? "unknown";
+    const msg = parsed.error.message ?? "Signal RPC error";
+    throw new Error(`Signal RPC ${code}: ${msg}`);
+  }
+  return parsed.result as T;
+}
+
+export async function signalCheck(
+  baseUrl: string,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+): Promise<{ ok: boolean; status?: number | null; error?: string | null }> {
+  try {
+    const res = await requestSignalHttpText(resolveSignalEndpointUrl(baseUrl, "/api/v1/check"), {
+      method: "GET",
+      timeoutMs,
+    });
+    if (res.status < 200 || res.status >= 300) {
+      return { ok: false, status: res.status, error: `HTTP ${res.status}` };
+    }
+    return { ok: true, status: res.status, error: null };
+  } catch (err) {
+    return {
+      ok: false,
+      status: null,
+      error: formatErrorMessage(err),
+    };
+  }
+}
+
+function openSignalEventStream(
+  url: URL,
+  abortSignal?: AbortSignal,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+): Promise<{ response: IncomingMessage; cleanup: () => void }> {
+  assertSignalHttpProtocol(url, "SSE");
+  if (abortSignal?.aborted) {
+    throw createSignalSseAbortError();
+  }
+
+  const client = url.protocol === "https:" ? https : http;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let response: IncomingMessage | undefined;
+    let onAbort: () => void = () => {};
+    const effectiveTimeoutMs = normalizeSignalSseTimeoutMs(timeoutMs);
+    const headerDeadline =
+      effectiveTimeoutMs === null
+        ? undefined
+        : setTimeout(() => {
+            const error = new Error(
+              `Signal SSE connection timed out after ${effectiveTimeoutMs}ms`,
+            );
+            response?.destroy(error);
+            request.destroy(error);
+            rejectOnce(error);
+          }, effectiveTimeoutMs);
+    headerDeadline?.unref?.();
+    const cleanup = () => {
+      if (headerDeadline) {
+        clearTimeout(headerDeadline);
+      }
+      abortSignal?.removeEventListener("abort", onAbort);
+    };
+    const rejectOnce = (error: unknown) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      reject(toLintErrorObject(error, "Non-Error rejection"));
+    };
+    const request: ClientRequest = client.request(
+      url,
+      {
+        method: "GET",
+        headers: { Accept: "text/event-stream" },
+      },
+      (res) => {
+        const status = res.statusCode ?? 0;
+        if (status < 200 || status >= 300) {
+          res.resume();
+          rejectOnce(new Error(`Signal SSE failed (${status} ${res.statusMessage || "error"})`));
+          return;
+        }
+        if (settled) {
+          res.destroy();
+          return;
+        }
+        if (headerDeadline) {
+          clearTimeout(headerDeadline);
+        }
+        settled = true;
+        response = res;
+        resolve({ response: res, cleanup });
+      },
+    );
+    onAbort = () => {
+      const error = createSignalSseAbortError();
+      response?.destroy(error);
+      request.destroy(error);
+      rejectOnce(error);
+    };
+
+    abortSignal?.addEventListener("abort", onAbort, { once: true });
+    request.on("error", rejectOnce);
+    request.end();
+  });
+}
+
+export async function streamSignalEvents(params: {
+  baseUrl: string;
+  account?: string;
+  abortSignal?: AbortSignal;
+  timeoutMs?: number;
+  onEvent: (event: SignalSseEvent) => void;
+}): Promise<void> {
+  const url = resolveSignalEndpointUrl(params.baseUrl, "/api/v1/events");
+  if (params.account) {
+    url.searchParams.set("account", params.account);
+  }
+
+  const { response, cleanup } = await openSignalEventStream(
+    url,
+    params.abortSignal,
+    params.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+  );
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let bufferedBytes = 0;
+  let currentEvent: SignalSseEvent = {};
+  let currentEventDataBytes = 0;
+
+  const flushEvent = () => {
+    if (!currentEvent.data && !currentEvent.event && !currentEvent.id) {
+      return;
+    }
+    params.onEvent({
+      event: currentEvent.event,
+      data: currentEvent.data,
+      id: currentEvent.id,
+    });
+    currentEvent = {};
+    currentEventDataBytes = 0;
+  };
+
+  const processLine = (line: string) => {
+    if (line === "") {
+      flushEvent();
+      return;
+    }
+    if (line.startsWith(":")) {
+      return;
+    }
+    const [rawField, ...rest] = line.split(":");
+    const field = rawField.trim();
+    const rawValue = rest.join(":");
+    const value = rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue;
+    if (field === "event") {
+      currentEvent.event = value;
+    } else if (field === "data") {
+      const segment = currentEvent.data ? `\n${value}` : value;
+      currentEventDataBytes += Buffer.byteLength(segment, "utf8");
+      if (currentEventDataBytes > MAX_SIGNAL_SSE_EVENT_DATA_BYTES) {
+        throw new Error("Signal SSE event data exceeded size limit");
+      }
+      currentEvent.data = currentEvent.data ? `${currentEvent.data}${segment}` : segment;
+    } else if (field === "id") {
+      currentEvent.id = value;
+    }
+  };
+
+  const drainCompleteLines = () => {
+    let lineEnd = buffer.indexOf("\n");
+    while (lineEnd !== -1) {
+      let line = buffer.slice(0, lineEnd);
+      buffer = buffer.slice(lineEnd + 1);
+      if (line.endsWith("\r")) {
+        line = line.slice(0, -1);
+      }
+      processLine(line);
+      lineEnd = buffer.indexOf("\n");
+    }
+    bufferedBytes = Buffer.byteLength(buffer, "utf8");
+  };
+
+  try {
+    for await (const chunk of response as AsyncIterable<Buffer | string>) {
+      const value = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+      bufferedBytes += value.byteLength;
+      if (bufferedBytes > MAX_SIGNAL_SSE_BUFFER_BYTES) {
+        throw new Error("Signal SSE buffer exceeded size limit");
+      }
+      buffer += decoder.decode(value, { stream: true });
+      drainCompleteLines();
+    }
+    const tail = decoder.decode();
+    if (tail) {
+      buffer += tail;
+      bufferedBytes = Buffer.byteLength(buffer, "utf8");
+    }
+    if (bufferedBytes > MAX_SIGNAL_SSE_BUFFER_BYTES) {
+      throw new Error("Signal SSE buffer exceeded size limit");
+    }
+    drainCompleteLines();
+  } finally {
+    cleanup();
+  }
+
+  flushEvent();
+}
+
+function toLintErrorObject(value: unknown, fallbackMessage: string): Error {
+  if (value instanceof Error) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return new Error(value);
+  }
+  const error = new Error(fallbackMessage, { cause: value });
+  if ((typeof value === "object" && value !== null) || typeof value === "function") {
+    Object.assign(error, value);
+  }
+  return error;
+}