ompclaw 0.3.0

package/src/rpc-service.ts

@@ -0,0 +1,191 @@
+import { accessSync, constants, lstatSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import type { GatewayConfig } from "./gateway-config";
+
+export interface ServiceInstallResult {
+  path: string;
+  manager: "launchd" | "systemd";
+}
+
+export interface GatewayServicePaths {
+  readonly configPath: string;
+  readonly envFile: string;
+}
+
+const SERVICE_NAME = "com.ompclaw";
+const SYSTEMD_UNIT = "ompclaw.service";
+const GATEWAY_COMMAND = "ompclaw";
+
+function xml(value: string): string {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+
+function systemdQuote(value: string): string {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+
+function resolveCommand(command: string): string {
+  if (command.includes("/")) return command;
+  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+    if (!directory) continue;
+    const candidate = join(directory, command);
+    try {
+      accessSync(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+      // Keep searching.
+    }
+  }
+  return command;
+}
+
+export function resolveGatewayServicePaths(
+  configPath: string | undefined,
+  envFile: string | undefined,
+): GatewayServicePaths {
+  return {
+    configPath: requireAbsoluteRegularFile(configPath, "--config"),
+    envFile: requireAbsoluteRegularFile(envFile, "--env-file", 0o600),
+  };
+}
+
+function requireAbsoluteRegularFile(value: string | undefined, flag: string, mode?: number): string {
+  if (value === undefined) throw new Error(`service-install requires ${flag}`);
+  if (!isAbsolute(value)) throw new Error(`${flag} must be an absolute path`);
+  const path = resolve(value);
+  const info = lstatSync(path);
+  if (!info.isFile() || info.isSymbolicLink()) throw new Error(`${flag} must be a regular file, not a symlink`);
+  if (mode !== undefined && (info.mode & 0o777) !== mode) {
+    throw new Error(`${flag} must have mode ${mode.toString(8)}`);
+  }
+  return path;
+}
+
+function servicePath(program: string): string {
+  const programDirectory = program.includes("/") ? dirname(program) : undefined;
+  return [...new Set([
+    dirname(process.execPath),
+    ...(programDirectory === undefined ? [] : [programDirectory]),
+    ...(process.env.PATH ?? "").split(delimiter).filter(Boolean),
+  ])].join(delimiter);
+}
+
+function serviceArguments(paths: GatewayServicePaths): string[] {
+  return [resolveCommand(GATEWAY_COMMAND), "run", "--config", paths.configPath, "--env-file", paths.envFile];
+}
+
+const MANAGER_RETRY_WAIT = new Int32Array(new SharedArrayBuffer(4));
+
+function runManager(executable: string, args: string[], retries = 0): void {
+  let failure = "";
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    const result = spawnSync(executable, args, { encoding: "utf8" });
+    if (result.status === 0) return;
+    failure = (result.stderr || result.stdout).trim();
+    if (attempt < retries) Atomics.wait(MANAGER_RETRY_WAIT, 0, 0, 100);
+  }
+  throw new Error(`${executable} ${args.join(" ")} failed: ${failure}`);
+}
+
+export function installRpcService(
+  config: GatewayConfig,
+  configPath: string,
+  envFile: string,
+): ServiceInstallResult {
+  const paths = resolveGatewayServicePaths(configPath, envFile);
+  const args = serviceArguments(paths);
+  const logs = join(config.stateDir, "logs");
+  mkdirSync(logs, { recursive: true, mode: 0o700 });
+
+  if (process.platform === "darwin") {
+    const path = join(homedir(), "Library", "LaunchAgents", `${SERVICE_NAME}.plist`);
+    mkdirSync(join(homedir(), "Library", "LaunchAgents"), { recursive: true });
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>EnvironmentVariables</key>
+  <dict><key>PATH</key><string>${xml(servicePath(args[0]!))}</string></dict>
+  <key>Label</key><string>${SERVICE_NAME}</string>
+  <key>ProgramArguments</key>
+  <array>${args.map((arg) => `\n    <string>${xml(arg)}</string>`).join("")}\n  </array>
+  <key>WorkingDirectory</key><string>${xml(config.workspace)}</string>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>
+  <key>ThrottleInterval</key><integer>10</integer>
+  <key>StandardOutPath</key><string>${xml(join(logs, "stdout.log"))}</string>
+  <key>ExitTimeOut</key><integer>15</integer>
+  <key>StandardErrorPath</key><string>${xml(join(logs, "stderr.log"))}</string>
+  <key>ProcessType</key><string>Background</string>
+</dict>
+</plist>
+`;
+    writeFileSync(path, plist, { mode: 0o644 });
+    const domain = `gui/${process.getuid?.() ?? 0}`;
+    spawnSync("launchctl", ["bootout", "--wait", `${domain}/${SERVICE_NAME}`], { encoding: "utf8", timeout: 10_000 });
+    runManager("launchctl", ["bootstrap", domain, path], 20);
+    runManager("launchctl", ["enable", `${domain}/${SERVICE_NAME}`]);
+    return { path, manager: "launchd" };
+  }
+
+  if (process.platform === "linux") {
+    const dir = join(homedir(), ".config", "systemd", "user");
+    const path = join(dir, SYSTEMD_UNIT);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const unit = `[Unit]
+Description=OmpClaw authenticated OMP gateway
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+WorkingDirectory=${systemdQuote(config.workspace)}
+ExecStart=${args.map(systemdQuote).join(" ")}
+Environment=${systemdQuote(`PATH=${servicePath(args[0]!)}`)}
+Restart=on-failure
+RestartSec=5
+UMask=0077
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=read-only
+ReadWritePaths=${systemdQuote(config.stateDir)} ${systemdQuote(config.workspace)}
+
+[Install]
+WantedBy=default.target
+`;
+    writeFileSync(path, unit, { mode: 0o600 });
+    runManager("systemctl", ["--user", "daemon-reload"]);
+    runManager("systemctl", ["--user", "enable", "--now", SYSTEMD_UNIT]);
+    return { path, manager: "systemd" };
+  }
+
+  throw new Error(`Service installation is not supported on ${process.platform}`);
+}
+
+export function uninstallRpcService(): ServiceInstallResult {
+  if (process.platform === "darwin") {
+    const path = join(homedir(), "Library", "LaunchAgents", `${SERVICE_NAME}.plist`);
+    const domain = `gui/${process.getuid?.() ?? 0}`;
+    spawnSync("launchctl", ["bootout", `${domain}/${SERVICE_NAME}`], { encoding: "utf8" });
+    try {
+      unlinkSync(path);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+    return { path, manager: "launchd" };
+  }
+  if (process.platform === "linux") {
+    const path = join(homedir(), ".config", "systemd", "user", SYSTEMD_UNIT);
+    spawnSync("systemctl", ["--user", "disable", "--now", SYSTEMD_UNIT], { encoding: "utf8" });
+    try {
+      unlinkSync(path);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+    runManager("systemctl", ["--user", "daemon-reload"]);
+    return { path, manager: "systemd" };
+  }
+  throw new Error(`Service removal is not supported on ${process.platform}`);
+}

package/src/rpc-ui.ts

@@ -0,0 +1,218 @@
+import type {
+  ConversationAddress,
+  DeliveryContext,
+  UiRequest,
+  UiResponse,
+} from "./gateway-types";
+import type { GatewayDelivery } from "./gateway-tools";
+import type { RpcExtensionUiRequest, RpcExtensionUiResponse } from "./rpc-protocol";
+
+export interface RpcUiLogger {
+  warn(message: string): void;
+}
+
+export interface RpcGatewayUiTarget {
+  readonly address: ConversationAddress;
+  readonly deliveryContext: DeliveryContext;
+}
+
+export interface RpcGatewayUiBrokerOptions {
+  readonly delivery: GatewayDelivery;
+  readonly sendResponse: (response: RpcExtensionUiResponse) => void;
+  readonly getTarget: () => RpcGatewayUiTarget | undefined;
+  readonly log: RpcUiLogger;
+}
+
+interface PendingUi {
+  readonly rpcId: string;
+  readonly request: Exclude<RpcExtensionUiRequest, { method: "cancel" }>;
+  readonly controller: AbortController;
+  timer?: NodeJS.Timeout;
+  timedOut: boolean;
+}
+
+/** Bridges OMP RPC UI requests to the active authenticated gateway delivery context. */
+export class RpcGatewayUiBroker {
+  readonly #options: RpcGatewayUiBrokerOptions;
+  readonly #pendingByRpcId = new Map<string, PendingUi>();
+  readonly #statuses: Record<string, string> = {};
+  readonly #widgets: Record<string, string[]> = {};
+  #title = "OMP";
+  #editorText = "";
+
+  constructor(options: RpcGatewayUiBrokerOptions) {
+    this.#options = options;
+  }
+
+  statusText(): string {
+    const lines = [`Surface: ${this.#title}`];
+    for (const [key, value] of Object.entries(this.#statuses)) lines.push(`${key}: ${value}`);
+    for (const [key, value] of Object.entries(this.#widgets)) lines.push(`${key}: ${value.join(" | ")}`);
+    if (this.#editorText) lines.push(`Suggested input: ${this.#editorText}`);
+    return lines.join("\n");
+  }
+
+  async handle(request: RpcExtensionUiRequest): Promise<void> {
+    if (request.method === "cancel") {
+      this.cancel(request.targetId);
+      return;
+    }
+
+    this.#rememberDisplayState(request);
+    const target = this.#options.getTarget();
+    if (!target) {
+      this.#logMissingTarget(request);
+      return;
+    }
+
+    this.cancel(request.id);
+    const pending: PendingUi = {
+      rpcId: request.id,
+      request: request,
+      controller: new AbortController(),
+      timedOut: false,
+    };
+    this.#pendingByRpcId.set(pending.rpcId, pending);
+    const timeout = this.#timeoutFor(request);
+    if (timeout != null) {
+      pending.timer = setTimeout(() => {
+        pending.timedOut = true;
+        this.cancel(pending.rpcId);
+      }, timeout);
+      pending.timer.unref?.();
+    }
+    void this.#present(pending, target);
+  }
+
+  cancel(rpcId: string): void {
+    const pending = this.#pendingByRpcId.get(rpcId);
+    if (!pending || !this.#pendingByRpcId.delete(rpcId)) return;
+    clearTimeout(pending.timer);
+    pending.controller.abort();
+    this.#sendCancelled(pending);
+  }
+
+  shutdown(): void {
+    for (const rpcId of [...this.#pendingByRpcId.keys()]) this.cancel(rpcId);
+  }
+
+  async #present(pending: PendingUi, target: RpcGatewayUiTarget): Promise<void> {
+    try {
+      const response = await this.#options.delivery.presentUi(
+        target.address,
+        this.#toGatewayRequest(pending.request),
+        target.deliveryContext,
+        pending.controller.signal,
+      );
+      if (!this.#pendingByRpcId.delete(pending.rpcId)) return;
+      clearTimeout(pending.timer);
+      this.#sendResponse(pending.request, response);
+    } catch (error) {
+      if (!this.#pendingByRpcId.delete(pending.rpcId)) return;
+      clearTimeout(pending.timer);
+      if (pending.controller.signal.aborted) return;
+      this.#options.log.warn(`[ompclaw rpc] UI ${pending.request.method} failed: ${error instanceof Error ? error.message : String(error)}`);
+      this.#sendCancelled(pending);
+    }
+  }
+
+  #toGatewayRequest(request: Exclude<RpcExtensionUiRequest, { method: "cancel" }>): UiRequest {
+    switch (request.method) {
+      case "select":
+        return {
+          type: "select",
+          title: request.title,
+          options: request.options.map((value, index) => {
+            const description = request.optionDetails?.[index]?.description;
+            return { value, label: value, ...(description ? { description } : {}) };
+          }),
+        };
+      case "confirm":
+        return { type: "confirm", title: request.title, message: request.message };
+      case "input":
+        return {
+          type: "input",
+          title: request.title,
+          ...(request.placeholder ? { prompt: request.placeholder, placeholder: request.placeholder } : {}),
+        };
+      case "editor":
+        return { type: "editor", title: request.title, initialValue: request.prefill ?? "" };
+      case "notify":
+        return { type: "notify", message: request.message, ...(request.notifyType ? { level: request.notifyType } : {}) };
+      case "setStatus":
+        return { type: "status", key: request.statusKey, ...(request.statusText ? { text: request.statusText } : {}) };
+      case "setWidget":
+        return {
+          type: "widget",
+          key: request.widgetKey,
+          ...(request.widgetLines ? { lines: request.widgetLines } : {}),
+          ...(request.widgetPlacement ? { placement: request.widgetPlacement } : {}),
+        };
+      case "setTitle":
+        return { type: "title", title: request.title };
+      case "set_editor_text":
+        return { type: "editor_text", text: request.text };
+      case "open_url":
+        return { type: "open_url", url: request.launchUrl ?? request.url, ...(request.instructions ? { label: request.instructions } : {}) };
+    }
+  }
+
+  #sendResponse(request: RpcExtensionUiRequest, response: UiResponse): void {
+    switch (request.method) {
+      case "select":
+        if (response.type === "select") this.#options.sendResponse({ type: "extension_ui_response", id: request.id, value: response.selected[0] ?? "" });
+        return;
+      case "confirm":
+        if (response.type === "confirm") this.#options.sendResponse({ type: "extension_ui_response", id: request.id, confirmed: response.confirmed });
+        return;
+      case "input":
+      case "editor":
+        if (response.type === request.method) {
+          if (response.cancelled) this.#options.sendResponse({ type: "extension_ui_response", id: request.id, cancelled: true });
+          else this.#options.sendResponse({ type: "extension_ui_response", id: request.id, value: response.value });
+        }
+        return;
+      default:
+        return;
+    }
+  }
+
+  #sendCancelled(pending: PendingUi): void {
+    if (pending.request.method === "select" || pending.request.method === "confirm" || pending.request.method === "input" || pending.request.method === "editor") {
+      this.#options.sendResponse({
+        type: "extension_ui_response",
+        id: pending.rpcId,
+        cancelled: true,
+        ...(pending.timedOut ? { timedOut: true } : {}),
+      });
+    }
+  }
+
+  #rememberDisplayState(request: Exclude<RpcExtensionUiRequest, { method: "cancel" }>): void {
+    if (request.method === "setStatus") {
+      if (request.statusText) this.#statuses[request.statusKey] = request.statusText;
+      else delete this.#statuses[request.statusKey];
+    } else if (request.method === "setWidget") {
+      if (request.widgetLines) this.#widgets[request.widgetKey] = request.widgetLines;
+      else delete this.#widgets[request.widgetKey];
+    } else if (request.method === "setTitle") this.#title = request.title;
+    else if (request.method === "set_editor_text") this.#editorText = request.text;
+  }
+
+  #timeoutFor(request: Exclude<RpcExtensionUiRequest, { method: "cancel" }>): number | undefined {
+    return "timeout" in request && typeof request.timeout === "number" && request.timeout > 0 ? request.timeout : undefined;
+  }
+
+  #logMissingTarget(request: Exclude<RpcExtensionUiRequest, { method: "cancel" }>): void {
+    if (
+      request.method === "setStatus"
+      || request.method === "setWidget"
+      || request.method === "setTitle"
+      || request.method === "set_editor_text"
+    ) return;
+    this.#options.log.warn(`[ompclaw rpc] Cannot present ${request.method}: no active delivery context`);
+    if (request.method === "select" || request.method === "confirm" || request.method === "input" || request.method === "editor") {
+      this.#options.sendResponse({ type: "extension_ui_response", id: request.id, cancelled: true });
+    }
+  }
+}