ompclaw 0.3.0

package/src/rpc-client.ts

@@ -0,0 +1,308 @@
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { setTimeout as sleep } from "node:timers/promises";
+import { RpcFrameDecoder, type RpcCommand, type RpcInboundFrame, type RpcResponse, isRpcReady, isRpcResponse } from "./rpc-protocol";
+import { isRecord } from "./type-guards";
+
+export interface OmpRpcClientOptions {
+  argv: string[];
+  cwd: string;
+  env: Record<string, string | undefined>;
+  readyTimeoutMs?: number;
+  commandTimeoutMs?: number;
+  maxStderrBytes?: number;
+}
+
+export interface RpcCommandInput {
+  type: string;
+  [key: string]: unknown;
+}
+
+export type RpcFrameListener = (frame: Record<string, unknown>) => void | Promise<void>;
+export type RpcExitListener = (error: Error) => void | Promise<void>;
+
+interface PendingRequest {
+  command: string;
+  resolve(response: RpcResponse): void;
+  reject(error: Error): void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+export class RpcCommandError extends Error {
+  constructor(
+    message: string,
+    readonly command: string,
+    readonly code?: string,
+  ) {
+    super(message);
+    this.name = "RpcCommandError";
+  }
+}
+
+/** Process-backed OMP RPC client with v2 negotiation, lossless frames, and restart-safe teardown. */
+export class OmpRpcClient {
+  readonly #options: Required<Pick<OmpRpcClientOptions, "readyTimeoutMs" | "commandTimeoutMs" | "maxStderrBytes">> & OmpRpcClientOptions;
+  readonly #frameListeners = new Set<RpcFrameListener>();
+  readonly #exitListeners = new Set<RpcExitListener>();
+  readonly #pending = new Map<string, PendingRequest>();
+  #eventQueue: Promise<void> = Promise.resolve();
+  #child: ChildProcessWithoutNullStreams | undefined;
+  #exited: Promise<void> | undefined;
+  #requestId = 0;
+  #stderr = "";
+  #protocolVersion = 1;
+  #stopping = false;
+  #ready = false;
+
+  constructor(options: OmpRpcClientOptions) {
+    if (options.argv.length === 0) throw new Error("OMP RPC argv must not be empty");
+    this.#options = {
+      readyTimeoutMs: options.readyTimeoutMs ?? 30_000,
+      commandTimeoutMs: options.commandTimeoutMs ?? 30_000,
+      maxStderrBytes: options.maxStderrBytes ?? 32 * 1024,
+      ...options,
+    };
+  }
+
+  get running(): boolean {
+    return this.#child !== undefined && this.#ready;
+  }
+
+  get protocolVersion(): number {
+    return this.#protocolVersion;
+  }
+
+  get stderr(): string {
+    return this.#stderr;
+  }
+
+  onFrame(listener: RpcFrameListener): () => void {
+    this.#frameListeners.add(listener);
+    return () => this.#frameListeners.delete(listener);
+  }
+
+  onExit(listener: RpcExitListener): () => void {
+    this.#exitListeners.add(listener);
+    return () => this.#exitListeners.delete(listener);
+  }
+
+  async start(): Promise<void> {
+    if (this.#child) throw new Error("OMP RPC client is already started");
+    this.#stopping = false;
+    this.#ready = false;
+    this.#protocolVersion = 1;
+    this.#stderr = "";
+
+    const [executable, ...args] = this.#options.argv;
+    const child = spawn(executable, args, {
+      cwd: this.#options.cwd,
+      env: this.#options.env,
+      stdio: "pipe",
+    });
+    this.#child = child;
+
+    const ready = Promise.withResolvers<Record<string, unknown>>();
+    let readySettled = false;
+    const settleReady = (frame: Record<string, unknown>): void => {
+      if (readySettled) return;
+      readySettled = true;
+      ready.resolve(frame);
+    };
+    const rejectReady = (error: Error): void => {
+      if (readySettled) return;
+      readySettled = true;
+      ready.reject(error);
+    };
+
+    child.once("error", (cause) => {
+      rejectReady(cause);
+      if (!this.#stopping) void this.#handleUnexpectedExit(cause);
+    });
+    const exited = Promise.withResolvers<void>();
+    this.#exited = exited.promise;
+    child.once("close", (code, signal) => {
+      const error = new Error(`OMP RPC process exited with ${signal ? `signal ${signal}` : `code ${code}`}${this.#stderr ? `: ${this.#stderr}` : ""}`);
+      rejectReady(error);
+      if (!this.#stopping) void this.#handleUnexpectedExit(error);
+      exited.resolve();
+    });
+    void this.#readStderr(child);
+    void this.#readStdout(child, settleReady).catch((cause: unknown) => {
+      const error = cause instanceof Error ? cause : new Error(String(cause));
+      rejectReady(error);
+      if (!this.#stopping) void this.#handleUnexpectedExit(error);
+    });
+
+    const timer = setTimeout(() => {
+      rejectReady(new Error(`Timed out waiting for OMP RPC readiness${this.#stderr ? `: ${this.#stderr}` : ""}`));
+    }, this.#options.readyTimeoutMs);
+    timer.unref?.();
+
+    try {
+      const frame = await ready.promise;
+      this.#ready = true;
+      const versions = Array.isArray(frame.supportedProtocolVersions) ? frame.supportedProtocolVersions : [];
+      if (versions.includes(2)) {
+        const advertised = frame.maxReassembledFrameBytes;
+        if (!Number.isSafeInteger(advertised) || Number(advertised) <= 0) throw new Error("OMP advertised an invalid RPC reassembly limit");
+        const response = await this.send({ type: "negotiate_protocol", protocolVersion: 2 });
+        if (!response.success || !isRecord(response.data) || response.data.protocolVersion !== 2) {
+          throw new Error("OMP RPC protocol-v2 negotiation failed");
+        }
+        this.#protocolVersion = 2;
+      }
+    } catch (error) {
+      await this.stop();
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  async stop(): Promise<void> {
+    const child = this.#child;
+    if (!child) return;
+    this.#stopping = true;
+    this.#child = undefined;
+    this.#ready = false;
+    const error = new Error("OMP RPC client stopped");
+    for (const pending of this.#pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.#pending.clear();
+
+    child.stdin.end();
+    const exited = this.#exited ?? Promise.resolve();
+    if (!(await Promise.race([exited.then(() => true), sleep(1_500, false)]))) {
+      child.kill("SIGTERM");
+      if (!(await Promise.race([exited.then(() => true), sleep(1_500, false)]))) child.kill("SIGKILL");
+    }
+    await exited;
+    this.#exited = undefined;
+  }
+
+  send(command: RpcCommandInput, timeoutMs = this.#options.commandTimeoutMs): Promise<RpcResponse> {
+    const child = this.#child;
+    if (!child) throw new Error("OMP RPC client is not started");
+    const id = `tg_${++this.#requestId}`;
+    const frame = { ...command, id } as RpcCommand;
+    const pending = Promise.withResolvers<RpcResponse>();
+    const timer = setTimeout(() => {
+      this.#pending.delete(id);
+      pending.reject(new Error(`Timed out waiting for OMP RPC ${command.type}${this.#stderr ? `: ${this.#stderr}` : ""}`));
+    }, timeoutMs);
+    timer.unref?.();
+    this.#pending.set(id, {
+      command: command.type,
+      timer,
+      resolve: pending.resolve,
+      reject: pending.reject,
+    });
+    try {
+      this.write(frame);
+    } catch (error) {
+      clearTimeout(timer);
+      this.#pending.delete(id);
+      pending.reject(error instanceof Error ? error : new Error(String(error)));
+    }
+    return pending.promise;
+  }
+
+  write(frame: RpcInboundFrame): void {
+    const child = this.#child;
+    if (!child) throw new Error("OMP RPC client is not started");
+    child.stdin.write(`${JSON.stringify(frame)}\n`);
+  }
+
+  async #readStdout(child: ChildProcessWithoutNullStreams, onReady: (frame: Record<string, unknown>) => void): Promise<void> {
+    const textDecoder = new TextDecoder();
+    const frameDecoder = new RpcFrameDecoder();
+    let buffer = "";
+    let maxFrameBytes = 1024 * 1024;
+    for await (const chunk of child.stdout) {
+      buffer += textDecoder.decode(chunk, { stream: true });
+      while (true) {
+        const newline = buffer.indexOf("\n");
+        if (newline < 0) break;
+        const line = buffer.slice(0, newline).trim();
+        buffer = buffer.slice(newline + 1);
+        if (!line) continue;
+        if (Buffer.byteLength(line) > maxFrameBytes) throw new Error("OMP RPC physical frame exceeded the advertised limit");
+        const parsed: unknown = JSON.parse(line);
+        if (!isRecord(parsed)) throw new Error("OMP RPC frame is not an object");
+        if (isRpcReady(parsed)) {
+          if (typeof parsed.maxFrameBytes === "number" && Number.isSafeInteger(parsed.maxFrameBytes) && parsed.maxFrameBytes > 0) {
+            maxFrameBytes = parsed.maxFrameBytes;
+          }
+          if (
+            typeof parsed.maxReassembledFrameBytes === "number" &&
+            Number.isSafeInteger(parsed.maxReassembledFrameBytes) &&
+            parsed.maxReassembledFrameBytes > 0
+          ) {
+            frameDecoder.setMaxBytes(parsed.maxReassembledFrameBytes);
+          }
+          onReady(parsed);
+          continue;
+        }
+        if (parsed.type === "rpc_chunk" && this.#protocolVersion !== 2) {
+          throw new Error("OMP sent an RPC chunk before protocol-v2 negotiation");
+        }
+        const decoded = frameDecoder.push(parsed);
+        if (decoded === undefined) continue;
+        if (!isRecord(decoded)) throw new Error("Decoded OMP RPC frame is not an object");
+        this.#handleFrame(decoded);
+      }
+      if (Buffer.byteLength(buffer) > maxFrameBytes) throw new Error("OMP RPC unterminated frame exceeded the advertised limit");
+    }
+    buffer += textDecoder.decode();
+    if (buffer.trim().length > 0) throw new Error("OMP RPC stdout ended with an incomplete frame");
+  }
+
+  async #readStderr(child: ChildProcessWithoutNullStreams): Promise<void> {
+    const decoder = new TextDecoder();
+    for await (const chunk of child.stderr) {
+      this.#stderr += decoder.decode(chunk, { stream: true });
+      if (Buffer.byteLength(this.#stderr) > this.#options.maxStderrBytes) {
+        this.#stderr = this.#stderr.slice(-this.#options.maxStderrBytes);
+      }
+    }
+    this.#stderr += decoder.decode();
+  }
+
+  #handleFrame(frame: Record<string, unknown>): void {
+    if (isRpcResponse(frame) && frame.id) {
+      const pending = this.#pending.get(frame.id);
+      if (pending) {
+        this.#pending.delete(frame.id);
+        clearTimeout(pending.timer);
+        if (frame.success) pending.resolve(frame);
+        else pending.reject(new RpcCommandError(frame.error ?? `${pending.command} failed`, frame.command, frame.code));
+        return;
+      }
+    }
+    const delivery = this.#eventQueue.then(async () => {
+      for (const listener of this.#frameListeners) await listener(frame);
+    });
+    this.#eventQueue = delivery.catch(() => {});
+  }
+
+  async #handleUnexpectedExit(error: Error): Promise<void> {
+    const child = this.#child;
+    if (this.#stopping || !child) return;
+    this.#child = undefined;
+    this.#ready = false;
+    for (const pending of this.#pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.#pending.clear();
+
+    if (child.exitCode == null && child.signalCode == null) {
+      child.kill("SIGTERM");
+      const exited = this.#exited ?? Promise.resolve();
+      if (!(await Promise.race([exited.then(() => true), sleep(1_500, false)]))) child.kill("SIGKILL");
+      await exited;
+    }
+    for (const listener of this.#exitListeners) await listener(error);
+  }
+}

package/src/rpc-config.ts

@@ -0,0 +1,70 @@
+import { lstatSync, readFileSync } from "node:fs";
+
+export interface RpcRuntimeConfig {
+  cwd: string;
+  stateDir: string;
+  profile: string;
+  ompCommand: string;
+  model?: string;
+  resume?: string;
+  sessionDir?: string;
+  configFiles: string[];
+  ompArgs: string[];
+  authBrokerTokenFile?: string;
+  allowRpcBash: boolean;
+  inheritHarness: boolean;
+  autoRestart: boolean;
+}
+
+export function buildOmpRpcArgv(config: RpcRuntimeConfig, resume = config.resume): string[] {
+  const argv = [config.ompCommand, "--mode", "rpc-ui", "--cwd", config.cwd, "--profile", config.profile, "--no-title"];
+  if (resume) argv.push("--resume", resume);
+  if (config.model) argv.push("--model", config.model);
+  if (config.sessionDir) argv.push("--session-dir", config.sessionDir);
+  for (const file of config.configFiles) argv.push("--config", file);
+  argv.push(...config.ompArgs);
+  return argv;
+}
+
+function readPrivateFile(path: string, label: string): string {
+  const info = lstatSync(path);
+  if (info.isSymbolicLink() || !info.isFile()) throw new Error(`${label} must be a regular file, not a symlink`);
+  if (process.platform !== "win32") {
+    const uid = process.getuid?.();
+    if (uid != null && info.uid !== uid) throw new Error(`${label} must be owned by the current user`);
+    if ((info.mode & 0o077) !== 0) throw new Error(`${label} permissions must be 0600 or stricter`);
+  }
+  return readFileSync(path, "utf8");
+}
+
+/** OMP gets the normal harness environment without the Telegram transport token. */
+export function buildOmpChildEnv(
+  env: NodeJS.ProcessEnv = process.env,
+  config?: Pick<RpcRuntimeConfig, "authBrokerTokenFile">,
+): Record<string, string | undefined> {
+  const childEnv: Record<string, string | undefined> = { ...env };
+  delete childEnv.TELEGRAM_BOT_TOKEN;
+  if (config?.authBrokerTokenFile) {
+    childEnv.OMP_AUTH_BROKER_TOKEN = readPrivateFile(config.authBrokerTokenFile, "Auth broker token file").trim();
+    if (!childEnv.OMP_AUTH_BROKER_TOKEN) throw new Error("Auth broker token file is empty");
+  }
+  return childEnv;
+}
+/** Load literal KEY=VALUE pairs. Existing process variables always win. */
+export function loadLiteralEnvFile(path: string, env: NodeJS.ProcessEnv = process.env): void {
+  const content = readPrivateFile(path, "Environment file");
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const normalized = line.startsWith("export ") ? line.slice(7).trim() : line;
+    const split = normalized.indexOf("=");
+    if (split <= 0) continue;
+    const key = normalized.slice(0, split).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) || env[key] !== undefined) continue;
+    let value = normalized.slice(split + 1).trim();
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    env[key] = value;
+  }
+}

package/src/rpc-profile.ts

@@ -0,0 +1,215 @@
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readlinkSync,
+  readdirSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import type { RpcRuntimeConfig } from "./rpc-config";
+import type { GatewayConfig } from "./gateway-config";
+
+const SNAPSHOT_DIRECTORIES = ["skills", "rules", "commands", "agents", "docs", "bin"] as const;
+const COPIED_FILES = ["AGENTS.md", "RULES.md", "SYSTEM.md", "WATCHDOG.md", "APPEND_SYSTEM.md", "config.yml", "mcp.json", "models.yml", "ssh.json"] as const;
+const SNAPSHOT_IGNORED_DIRECTORIES = new Set([
+  ".git",
+  ".venv",
+  ".venv_old",
+  ".cache",
+  ".mypy_cache",
+  ".pytest_cache",
+  ".ruff_cache",
+  "__pycache__",
+  "node_modules",
+  "logs",
+  "browser_profile",
+  "browser_profile_old",
+  "browser-profile",
+  "chrome_profile",
+  "chrome-profile",
+]);
+
+/** Materialize OMP's experimental memory and auto-learn settings in OmpClaw-owned state. */
+export function prepareLearningOverlay(config: Pick<GatewayConfig, "stateDir" | "learning">): string | undefined {
+  if (!config.learning.enabled) return undefined;
+  const memoryDirectory = join(config.stateDir, "memory");
+  mkdirSync(memoryDirectory, { recursive: true, mode: 0o700 });
+  const path = join(config.stateDir, "omp-learning.json");
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  const content = {
+    memory: { backend: "mnemopi" },
+    mnemopi: {
+      dbPath: join(memoryDirectory, "mnemopi.sqlite"),
+      bank: "gateway",
+      scoping: "global",
+      autoRecall: true,
+      autoRetain: true,
+    },
+    autolearn: {
+      enabled: true,
+      autoContinue: config.learning.autoCapture,
+      minToolCalls: config.learning.minToolCalls,
+    },
+    providers: { memoryModel: config.learning.memoryModel },
+  };
+  writeFileSync(temporary, `${JSON.stringify(content, null, 2)}\n`, { mode: 0o600 });
+  renameSync(temporary, path);
+  if (process.platform !== "win32") chmodSync(path, 0o600);
+  return path;
+}
+
+/**
+ * Seed a named transport profile with a read-only snapshot of the default
+ * profile's harness surface. The gateway's writable managed skills, memories,
+ * configuration, databases, sessions, blobs, credentials, and environment
+ * remain in its named profile and never flow back into the default profile.
+ */
+export function prepareInheritedHarness(config: RpcRuntimeConfig): string | undefined {
+  if (!config.inheritHarness) return undefined;
+  if (!/^[A-Za-z0-9._-]+$/.test(config.profile)) throw new Error("Profile name contains unsupported characters");
+  const root = process.env.OMP_HOME ?? join(homedir(), ".omp");
+  const source = join(root, "agent");
+  const target = join(root, "profiles", config.profile, "agent");
+  if (!existsSync(source)) throw new Error(`Default OMP agent directory not found: ${source}`);
+  mkdirSync(target, { recursive: true, mode: 0o700 });
+  const snapshotRoot = join(target, ".gateway-inherited");
+  mkdirSync(snapshotRoot, { recursive: true, mode: 0o700 });
+
+  for (const name of SNAPSHOT_DIRECTORIES) {
+    const from = join(source, name);
+    const to = join(target, name);
+    if (!existsSync(from)) continue;
+    snapshotDirectory(from, to, snapshotRoot, name);
+  }
+  for (const name of COPIED_FILES) {
+    const from = join(source, name);
+    const to = join(target, name);
+    if (!existsSync(from)) continue;
+    snapshotFile(from, to);
+  }
+  return target;
+}
+
+function snapshotFile(from: string, to: string): void {
+  const temporary = `${to}.gateway-next-${process.pid}-${randomUUID()}`;
+  try {
+    copyFileSync(from, temporary);
+    if (process.platform !== "win32") chmodSync(temporary, 0o444);
+    renameSync(temporary, to);
+  } catch (error) {
+    rmSync(temporary, { force: true });
+    throw error;
+  }
+}
+
+function snapshotDirectory(from: string, to: string, snapshotRoot: string, name: string): void {
+  let existing: ReturnType<typeof lstatSync> | undefined;
+  try {
+    existing = lstatSync(to);
+  } catch {
+    existing = undefined;
+  }
+
+  let previousSnapshot: string | undefined;
+  if (existing !== undefined) {
+    if (!existing.isSymbolicLink()) return;
+    const destination = resolve(dirname(to), readlinkSync(to));
+    const ownedPrefix = `${resolve(snapshotRoot, name)}-`;
+    if (destination !== resolve(from) && !destination.startsWith(ownedPrefix)) return;
+    if (destination.startsWith(ownedPrefix)) previousSnapshot = destination;
+  }
+
+  const snapshot = join(snapshotRoot, `${name}-${randomUUID()}`);
+  const nextLink = `${to}.gateway-next-${process.pid}-${randomUUID()}`;
+  try {
+    copySnapshotTree(from, snapshot);
+    makeTreeReadOnly(snapshot);
+    symlinkSync(relative(dirname(to), snapshot), nextLink, "dir");
+    renameSync(nextLink, to);
+  } catch (error) {
+    rmSync(nextLink, { force: true });
+    makeTreeRemovable(snapshot);
+    rmSync(snapshot, { force: true, recursive: true });
+    throw error;
+  }
+  if (previousSnapshot !== undefined) {
+    makeTreeRemovable(previousSnapshot);
+    rmSync(previousSnapshot, { force: true, recursive: true });
+  }
+}
+
+function copySnapshotTree(source: string, destination: string, ancestors: ReadonlySet<string> = new Set()): void {
+  const name = basename(source);
+  if (name === ".DS_Store" || name.startsWith(".env") || name.startsWith(".chrome")) return;
+
+  let resolved: string;
+  let info: ReturnType<typeof lstatSync>;
+  try {
+    resolved = realpathSync(source);
+    info = lstatSync(resolved);
+  } catch (error) {
+    if (isMissingPath(error)) return;
+    throw error;
+  }
+
+  if (info.isDirectory()) {
+    if (isIgnoredSnapshotDirectory(name) || ancestors.has(resolved)) return;
+    mkdirSync(destination, { mode: 0o700 });
+    const nestedAncestors = new Set(ancestors);
+    nestedAncestors.add(resolved);
+    let entries: string[];
+    try {
+      entries = readdirSync(source);
+    } catch (error) {
+      if (isMissingPath(error)) return;
+      throw error;
+    }
+    for (const entry of entries) copySnapshotTree(join(source, entry), join(destination, entry), nestedAncestors);
+    return;
+  }
+  if (!info.isFile()) return;
+  try {
+    copyFileSync(source, destination);
+  } catch (error) {
+    if (!isMissingPath(error)) throw error;
+  }
+}
+
+function isIgnoredSnapshotDirectory(name: string): boolean {
+  return SNAPSHOT_IGNORED_DIRECTORIES.has(name)
+    || name.startsWith("browser_profile")
+    || name.startsWith("browser-profile")
+    || name.startsWith("chrome_profile")
+    || name.startsWith("chrome-profile");
+}
+
+function isMissingPath(error: unknown): boolean {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+function makeTreeReadOnly(path: string): void {
+  const info = lstatSync(path);
+  if (info.isDirectory()) {
+    for (const entry of readdirSync(path)) makeTreeReadOnly(join(path, entry));
+    if (process.platform !== "win32") chmodSync(path, 0o555);
+    return;
+  }
+  if (process.platform !== "win32") chmodSync(path, (info.mode & 0o111) === 0 ? 0o444 : 0o555);
+}
+
+function makeTreeRemovable(path: string): void {
+  if (!existsSync(path) || process.platform === "win32") return;
+  const info = lstatSync(path);
+  if (!info.isDirectory()) return;
+  chmodSync(path, 0o700);
+  for (const entry of readdirSync(path)) makeTreeRemovable(join(path, entry));
+}