@coolclaw/clawtopia-connector 0.1.0 → 0.2.0

package/dist/cli.js

@@ -1,750 +0,0 @@
-#!/usr/bin/env node
-import {
-  ChannelClient,
-  JsonFileStateStore,
-  RuntimeConnector,
-  WorkerClient,
-  activeFlavor,
-  assertEnvironmentMatches,
-  bundledWorkerPath,
-  defaultConfig,
-  loadConfig,
-  normalizeProfileId,
-  profileConfigPath,
-  profileEnvironment,
-  saveConfig
-} from "./chunk-5OV44BPP.js";
-
-// src/cli.ts
-import { chmod, copyFile, mkdir as mkdir3, open, readFile as readFile2, rename, rm as rm2, stat, writeFile as writeFile3 } from "fs/promises";
-import { existsSync as existsSync4, realpathSync } from "fs";
-import { createHash, randomUUID as randomUUID2 } from "crypto";
-import { execFile as execFile2, spawn as spawn2 } from "child_process";
-import { promisify as promisify2 } from "util";
-
-// src/openclaw-executor.ts
-import { spawn } from "child_process";
-import { randomUUID } from "crypto";
-var OpenClawExecutor = class {
-  constructor(executable = "openclaw", cwd, env) {
-    this.executable = executable;
-    this.cwd = cwd;
-    this.env = env;
-  }
-  executable;
-  cwd;
-  env;
-  handler;
-  sessions = /* @__PURE__ */ new Set();
-  setEventHandler(handler) {
-    this.handler = handler;
-  }
-  async initialize(runtime) {
-    if (runtime !== "openclaw") throw new Error(`OpenClaw executor cannot initialize ${runtime}`);
-    return { workerVersion: "openclaw-adapter.v1", protocolVersion: 1, runtime, agents: ["openclaw"], capabilities: { sessions: true, attachments: false } };
-  }
-  async startSession(input) {
-    const id = input.sessionId ?? `openclaw-${randomUUID()}`;
-    this.sessions.add(id);
-    return { sessionId: id, agentSessionId: input.agentSessionId ?? id, runtime: "openclaw", alive: true };
-  }
-  async resumeSession(input) {
-    this.sessions.add(input.sessionId);
-    return { sessionId: input.sessionId, agentSessionId: input.agentSessionId ?? input.sessionId, runtime: "openclaw", alive: true, resumed: true };
-  }
-  async send(input) {
-    if (!this.sessions.has(input.sessionId)) throw new Error(`unknown OpenClaw session ${input.sessionId}`);
-    const args = ["agent", "--json", "--session-id", input.sessionId, "--message", input.prompt];
-    const child = spawn(this.executable, args, { cwd: this.cwd, env: { ...process.env, ...this.env }, stdio: ["ignore", "pipe", "pipe"] });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-    });
-    child.stderr.setEncoding("utf8");
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk;
-    });
-    await new Promise((resolve2, reject) => {
-      child.once("error", reject);
-      child.once("close", (code) => code === 0 ? resolve2() : reject(new Error(stderr.trim() || `openclaw exited with code ${code}`)));
-    });
-    let parsed;
-    try {
-      parsed = JSON.parse(stdout);
-    } catch {
-      parsed = void 0;
-    }
-    const text = typeof parsed?.result === "string" ? parsed.result : typeof parsed?.reply === "string" ? parsed.reply : typeof parsed?.text === "string" ? parsed.text : stdout.trim();
-    if (text) await this.handler?.({ event: "text", sessionId: input.sessionId, content: text });
-    await this.handler?.({ event: "result", sessionId: input.sessionId, done: true });
-    return { accepted: true };
-  }
-  async respondPermission(_input) {
-    return { accepted: false };
-  }
-  async cancel(_sessionId) {
-    return { accepted: false };
-  }
-  async closeSession(sessionId) {
-    this.sessions.delete(sessionId);
-    return { accepted: true };
-  }
-  async health() {
-    return { ok: true, sessions: this.sessions.size, runtime: "openclaw", version: "openclaw-adapter.v1" };
-  }
-  async shutdown() {
-    this.sessions.clear();
-  }
-};
-
-// src/openclaw-profile.ts
-import { existsSync } from "fs";
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { homedir } from "os";
-import { join } from "path";
-var COPIED_KEYS = ["models", "auth"];
-var EXCLUDED_KEY_PATTERN = /channel|plugin|extension|coolclaw|clawtopia|binding|token/iu;
-function defaultOpenClawHome(env = process.env) {
-  if (env.OPENCLAW_HOME) return env.OPENCLAW_HOME;
-  if (process.platform === "win32") return join(env.APPDATA ?? join(homedir(), "AppData", "Roaming"), "openclaw");
-  return join(homedir(), ".openclaw");
-}
-function filterOpenClawConfig(source) {
-  const result = {};
-  for (const key of COPIED_KEYS) {
-    if (EXCLUDED_KEY_PATTERN.test(key)) continue;
-    if (source[key] !== void 0) result[key] = source[key];
-  }
-  const agents = source.agents;
-  if (agents && typeof agents === "object" && !Array.isArray(agents)) {
-    const defaults = agents.defaults;
-    if (defaults !== void 0) result.agents = { defaults };
-  }
-  return result;
-}
-async function prepareOpenClawProfile(workDir, sourceHome = defaultOpenClawHome()) {
-  const home = join(workDir, "openclaw");
-  await mkdir(join(home, "workspace"), { recursive: true, mode: 448 });
-  const configPath = join(home, "openclaw.json");
-  const sourceConfigPath = join(sourceHome, "openclaw.json");
-  let inherited = {};
-  if (sourceHome !== home && existsSync(sourceConfigPath)) {
-    try {
-      inherited = filterOpenClawConfig(JSON.parse(await readFile(sourceConfigPath, "utf8")));
-    } catch {
-      inherited = {};
-    }
-  }
-  let current = {};
-  if (existsSync(configPath)) {
-    try {
-      current = JSON.parse(await readFile(configPath, "utf8"));
-    } catch {
-      current = {};
-    }
-  }
-  const merged = { ...inherited, ...current };
-  await writeFile(configPath, `${JSON.stringify(merged, null, 2)}
-`, { mode: 384 });
-  return { home, configPath, inheritedKeys: Object.keys(inherited) };
-}
-
-// src/cli.ts
-import { dirname, join as join4, resolve } from "path";
-import { fileURLToPath } from "url";
-
-// src/diagnostics.ts
-import { appendFileSync, chmodSync, existsSync as existsSync2, renameSync, statSync } from "fs";
-import { join as join2 } from "path";
-function redactDiagnostic(text, secrets = []) {
-  let safe = text;
-  for (const secret of secrets.filter(Boolean)) safe = safe.split(secret).join("[REDACTED]");
-  return safe.replace(/(Bearer\s+)[^\s"',]+/giu, "$1[REDACTED]").replace(/((?:[\w-]*(?:token|secret|password|api[_-]?key|pairing[_-]?code))\s*["']?\s*(?:[=:]|\s)\s*["']?)[^\s"',}&]+/giu, "$1[REDACTED]").replace(/\b[a-f0-9]{32,64}\b/giu, "[REDACTED]").slice(0, 4e3);
-}
-function createDiagnosticLogger(workDir, identity, secrets = []) {
-  const path = join2(workDir, "connector.log");
-  return (entry) => {
-    const record = { time: (/* @__PURE__ */ new Date()).toISOString(), ...identity, ...entry };
-    for (const [key, value] of Object.entries(record)) {
-      if (typeof value === "string") Object.assign(record, { [key]: redactDiagnostic(value, secrets) });
-    }
-    const line = `${JSON.stringify(record)}
-`;
-    try {
-      if (existsSync2(path) && statSync(path).size > 5 * 1024 * 1024) renameSync(path, `${path}.1`);
-      appendFileSync(path, line, { mode: 384 });
-      chmodSync(path, 384);
-    } catch {
-      process.stderr.write("connector diagnostic file unavailable\n");
-    }
-    process.stderr.write(line);
-  };
-}
-
-// src/service-manager.ts
-import { execFile } from "child_process";
-import { existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir2, rm, writeFile as writeFile2 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-function serviceSupported(platform = process.platform) {
-  return platform === "darwin" || platform === "linux";
-}
-function serviceDefinition(profileId, executable = process.argv[1]) {
-  if (process.platform === "darwin") {
-    const label = `com.clawtopia.connector.${profileId}`;
-    const logPath = join3(homedir2(), "Library", "Logs", `${label}.log`);
-    const content = `<?xml version="1.0" encoding="UTF-8"?><plist version="1.0"><dict><key>Label</key><string>${label}</string><key>ProgramArguments</key><array><string>${process.execPath}</string><string>${executable}</string><string>_start</string><string>--profile</string><string>${profileId}</string></array><key>RunAtLoad</key><true/><key>KeepAlive</key><true/><key>ProcessType</key><string>Background</string><key>StandardOutPath</key><string>${logPath}</string><key>StandardErrorPath</key><string>${logPath}</string></dict></plist>
-`;
-    return { path: join3(homedir2(), "Library", "LaunchAgents", `${label}.plist`), content, label, logPath, logHint: `tail -f ${logPath}` };
-  }
-  if (process.platform === "linux") {
-    const label = `clawtopia-connector-${profileId}.service`;
-    const content = `[Unit]
-Description=Clawtopia Agent Connector (${profileId})
-After=network-online.target
-
-[Service]
-ExecStart=${process.execPath} ${executable} _start --profile ${profileId}
-Restart=always
-RestartSec=5
-
-[Install]
-WantedBy=default.target
-`;
-    const path = join3(process.env.XDG_CONFIG_HOME ?? join3(homedir2(), ".config"), "systemd", "user", label);
-    return { path, content, label, logPath: "journald", logHint: `journalctl --user -u ${label} -f` };
-  }
-  throw new Error(`automatic startup is unsupported on ${process.platform}; use clawtopia start --foreground`);
-}
-function serviceInstalled(profileId) {
-  if (!serviceSupported()) return false;
-  try {
-    return existsSync3(serviceDefinition(profileId).path);
-  } catch {
-    return false;
-  }
-}
-async function run(command, args, { optional = false } = {}) {
-  try {
-    await execFileAsync(command, args);
-  } catch (error) {
-    if (optional) return;
-    const detail = error instanceof Error ? error.message : String(error);
-    throw new Error(`${command} ${args.join(" ")} failed: ${detail}`);
-  }
-}
-function domainTarget() {
-  return `gui/${process.getuid?.() ?? 0}`;
-}
-async function installService(profileId) {
-  const definition = serviceDefinition(profileId);
-  await mkdir2(join3(definition.path, ".."), { recursive: true, mode: 448 });
-  await writeFile2(definition.path, definition.content, { mode: 384 });
-  if (process.platform === "darwin") {
-    await mkdir2(join3(definition.logPath, ".."), { recursive: true });
-    await run("launchctl", ["bootout", `${domainTarget()}/${definition.label}`], { optional: true });
-    await run("launchctl", ["enable", `${domainTarget()}/${definition.label}`], { optional: true });
-    await run("launchctl", ["bootstrap", domainTarget(), definition.path]);
-    return definition.path;
-  }
-  await run("systemctl", ["--user", "daemon-reload"]);
-  await run("systemctl", ["--user", "enable", "--now", definition.label]);
-  return definition.path;
-}
-async function stopService(profileId) {
-  const definition = serviceDefinition(profileId);
-  if (process.platform === "darwin") {
-    await run("launchctl", ["bootout", `${domainTarget()}/${definition.label}`], { optional: true });
-    return;
-  }
-  await run("systemctl", ["--user", "stop", definition.label], { optional: true });
-}
-async function startService(profileId) {
-  const definition = serviceDefinition(profileId);
-  if (process.platform === "darwin") {
-    await run("launchctl", ["enable", `${domainTarget()}/${definition.label}`], { optional: true });
-    await run("launchctl", ["bootstrap", domainTarget(), definition.path]);
-    return;
-  }
-  await run("systemctl", ["--user", "start", definition.label]);
-}
-async function restartService(profileId) {
-  const definition = serviceDefinition(profileId);
-  if (process.platform === "darwin") {
-    await run("launchctl", ["kickstart", "-k", `${domainTarget()}/${definition.label}`]);
-    return;
-  }
-  await run("systemctl", ["--user", "restart", definition.label]);
-}
-async function disableService(profileId) {
-  const definition = serviceDefinition(profileId);
-  if (process.platform === "darwin") {
-    await run("launchctl", ["bootout", `${domainTarget()}/${definition.label}`], { optional: true });
-    await run("launchctl", ["disable", `${domainTarget()}/${definition.label}`]);
-    return;
-  }
-  await run("systemctl", ["--user", "disable", "--now", definition.label], { optional: true });
-}
-async function uninstallService(profileId) {
-  const definition = serviceDefinition(profileId);
-  if (process.platform === "darwin") {
-    await run("launchctl", ["bootout", `${domainTarget()}/${definition.label}`], { optional: true });
-    await run("launchctl", ["disable", `${domainTarget()}/${definition.label}`], { optional: true });
-  } else if (process.platform === "linux") {
-    await run("systemctl", ["--user", "disable", "--now", definition.label], { optional: true });
-  }
-  await rm(definition.path, { force: true });
-  if (process.platform === "linux") await run("systemctl", ["--user", "daemon-reload"], { optional: true });
-  return definition.path;
-}
-function serviceLogHint(profileId) {
-  return serviceDefinition(profileId).logHint;
-}
-
-// src/cli.ts
-var execFileAsync2 = promisify2(execFile2);
-async function main(argv = process.argv.slice(2)) {
-  const command = argv[0] ?? "status";
-  const flags = parseFlags(argv.slice(1));
-  if (command === "help" || command === "--help" || flags.help === "true") {
-    printHelp();
-    return 0;
-  }
-  const profile = flags.profile ? normalizeProfileId(flags.profile) : void 0;
-  const path = profileConfigPath(profile);
-  if (command === "connect") {
-    const pairingCode = flags.pairing_code ?? flags.code ?? process.env.CLAWTOPIA_PAIRING_CODE;
-    if (!pairingCode || pairingCode === "true") throw new Error("connect requires --pairing-code <code>");
-    const base = defaultConfig(profile);
-    const overrides = configOverrides(flags);
-    const requestedRuntime = overrides.runtime ?? base.runtime;
-    const gatewayUrl = overrides.gatewayUrl ?? base.gatewayUrl;
-    const endpoint = flags.pairing_endpoint ?? process.env.CLAWTOPIA_PAIRING_ENDPOINT ?? base.pairingEndpoint ?? "/api/agent/pairing/exchange";
-    const exchangeId = process.env.CLAWTOPIA_EXCHANGE_ID ?? randomUUID2();
-    const response = await fetch(`${gatewayUrl.replace(/\/+$/u, "")}${endpoint.startsWith("/") ? endpoint : `/${endpoint}`}`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ pairingCode, code: pairingCode, runtime: requestedRuntime, profileId: profile, exchangeId }) });
-    const responseBody = await response.json().catch(() => ({}));
-    const data = isRecord(responseBody.data) ? responseBody.data : responseBody;
-    if (!response.ok || typeof data.agentId !== "string" && typeof data.agentId !== "number" || typeof data.token !== "string" || !data.token) {
-      const message = typeof responseBody.message === "string" ? responseBody.message : `pairing exchange failed: HTTP ${response.status}`;
-      throw new Error(message);
-    }
-    const agentId = String(data.agentId);
-    assertEnvironmentMatches(activeFlavor(), data.environment);
-    if (typeof data.runtime === "string" && normalizeRuntime(data.runtime) !== requestedRuntime) throw new Error(`pairing runtime mismatch: requested ${requestedRuntime}, server returned ${data.runtime}`);
-    if (profile && typeof data.profileId === "string" && data.profileId !== profile) throw new Error(`pairing profile mismatch: requested ${profile}, server returned ${data.profileId}`);
-    const id = normalizeProfileId(profile ?? (typeof data.profileId === "string" ? data.profileId : `agent-${agentId}-${createHash("sha256").update(gatewayUrl).digest("hex").slice(0, 8)}`));
-    let config = { ...defaultConfig(id), ...overrides, profileId: id, gatewayUrl: typeof data.gatewayUrl === "string" ? data.gatewayUrl : gatewayUrl, environment: typeof data.environment === "string" ? data.environment : base.environment, agentId, token: data.token, runtime: normalizeRuntime(typeof data.runtime === "string" ? data.runtime : overrides.runtime ?? base.runtime) ?? base.runtime, pairingEndpoint: endpoint };
-    const target = profileConfigPath(id);
-    const previous = await loadConfig(target).catch(() => void 0);
-    if (previous?.agentId && previous.agentId !== agentId) throw new Error(`profile ${id} already belongs to Agent ${previous.agentId}; select a different --profile`);
-    if (previous?.agentId && previous.gatewayUrl.replace(/\/+$/u, "") !== config.gatewayUrl.replace(/\/+$/u, "")) throw new Error(`profile ${id} already belongs to a different platform environment; select a different --profile`);
-    await mkdir3(config.workDir, { recursive: true, mode: 448 });
-    config = await materializeBundledWorker(config);
-    await saveConfig(config, target);
-    let servicePath;
-    if (flags.foreground !== "true" && flags.daemon !== "false" && serviceSupported()) {
-      try {
-        servicePath = await installService(id);
-      } catch (error) {
-        console.error(`user service setup failed, falling back to a detached process: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
-    console.log(JSON.stringify({ profileId: id, agentId, config: target, paired: true, service: servicePath ?? null }, null, 2));
-    if (servicePath) {
-      console.log(`connector service started for profile ${id}; logs: ${serviceLogHint(id)}`);
-      return 0;
-    }
-    if (flags.foreground !== "true" && flags.daemon !== "false") {
-      const child = spawn2(process.execPath, [process.argv[1], "_start", "--profile", id], {
-        cwd: process.cwd(),
-        env: process.env,
-        detached: true,
-        stdio: "ignore"
-      });
-      child.unref();
-      console.log(`connector started in background for profile ${id}`);
-      return 0;
-    }
-    return runStart(config, target);
-  }
-  if (["status", "doctor"].includes(command)) {
-    let config;
-    try {
-      config = await loadConfig(path);
-    } catch {
-      console.log(`not configured: run clawtopia connect --pairing-code <code> (${path})`);
-      return command === "doctor" ? 1 : 0;
-    }
-    if (command === "doctor") {
-      const migrated = await materializeBundledWorker(config);
-      if (migrated.workerPath !== config.workerPath) {
-        config = migrated;
-        await saveConfig(config, path);
-      }
-    }
-    if (command === "status") {
-      console.log(JSON.stringify({ configured: Boolean(config.agentId && config.token), gatewayUrl: config.gatewayUrl, runtime: config.runtime, workerPath: config.workerPath, workerSha256: config.workerSha256 ?? null }, null, 2));
-      return 0;
-    }
-    const report = await diagnose(config);
-    console.log(JSON.stringify({ config: path, ...report }, null, 2));
-    return report.ok ? 0 : 1;
-  }
-  if (command === "install" || command === "enable") {
-    const id = profile ?? process.env.CLAWTOPIA_AGENT_PROFILE ?? "default";
-    const servicePath = await installService(id);
-    console.log(`enabled user service ${servicePath}; logs: ${serviceLogHint(id)}`);
-    return 0;
-  }
-  if (command === "disable") {
-    const id = profile ?? process.env.CLAWTOPIA_AGENT_PROFILE ?? "default";
-    if (!serviceInstalled(id)) {
-      console.log("no user service installed");
-      return 0;
-    }
-    await disableService(id);
-    console.log(`disabled user service for profile ${id}; it will not be restarted until clawtopia enable`);
-    return 0;
-  }
-  if (command === "restart") {
-    const id = profile ?? process.env.CLAWTOPIA_AGENT_PROFILE ?? "default";
-    if (!serviceInstalled(id)) throw new Error(`no user service for profile ${id}; run clawtopia install first`);
-    await restartService(id);
-    console.log(`restarted user service for profile ${id}`);
-    return 0;
-  }
-  if (command === "logs") {
-    const id = profile ?? process.env.CLAWTOPIA_AGENT_PROFILE ?? "default";
-    const config = await loadConfig(path).catch(() => void 0);
-    console.log(JSON.stringify({ service: serviceInstalled(id) ? serviceLogHint(id) : null, diagnostics: config ? join4(config.workDir, "diagnostics.log") : null }, null, 2));
-    return 0;
-  }
-  if (command === "start") {
-    let config = await loadConfig(path);
-    config = await materializeBundledWorker(config);
-    await saveConfig(config, path);
-    if (!config.agentId || !config.token) throw new Error("agentId and token are required; run connect --pairing-code <code> first");
-    const report = await diagnose(config);
-    if (!report.ok) throw new Error(`doctor failed; run clawtopia doctor for details`);
-    if (flags.foreground !== "true" && serviceInstalled(config.profileId)) {
-      await startService(config.profileId);
-      console.log(`started user service for profile ${config.profileId}; logs: ${serviceLogHint(config.profileId)}`);
-      return 0;
-    }
-    return runStart(config, path);
-  }
-  if (command === "_start") {
-    const config = await loadConfig(path);
-    return runStart(config, path);
-  }
-  if (command === "start-foreground") {
-    const config = await loadConfig(path);
-    return runStart(config, path);
-  }
-  async function runStart(config, configPath) {
-    const migrated = await materializeBundledWorker(config);
-    if (migrated.workerPath !== config.workerPath) {
-      config = migrated;
-      await saveConfig(config, configPath);
-    }
-    if (!config.agentId || !config.token) throw new Error("agentId and token are required; run connect --pairing-code <code> first");
-    const report = await diagnose(config);
-    if (!report.ok) throw new Error(`doctor failed; run clawtopia doctor for details`);
-    await mkdir3(config.workDir, { recursive: true, mode: 448 });
-    const log = createDiagnosticLogger(config.workDir, { profileId: config.profileId, agentId: config.agentId, runtime: config.runtime }, [config.token]);
-    const runtimeEnv = profileEnvironment(config, configPath);
-    if (config.runtime === "openclaw") {
-      const openclaw = await prepareOpenClawProfile(config.workDir);
-      runtimeEnv.OPENCLAW_HOME = openclaw.home;
-      log({ event: "openclaw.profile", home: openclaw.home, inherited: openclaw.inheritedKeys.join(",") || "none" });
-    }
-    const worker = config.runtime === "openclaw" ? new OpenClawExecutor(config.runtimePath || "openclaw", config.workDir, runtimeEnv) : new WorkerClient({
-      executable: config.workerPath,
-      args: [],
-      cwd: config.workDir,
-      env: runtimeEnv,
-      requestTimeoutMs: 6e4,
-      onStderr: (error) => log({ event: "worker.stderr", error }),
-      onEvent: (event) => {
-        if (event.event === "error") log({ event: "worker.error", sessionId: event.sessionId, error: event.error ?? event.content ?? "worker error (no detail)" });
-      }
-    });
-    const channel = new ChannelClient({
-      gatewayUrl: config.gatewayUrl,
-      agentId: config.agentId,
-      token: config.token,
-      connectorVersion: config.connectorVersion,
-      onError: (error) => log({ event: "channel.error", error: error.message }),
-      onStateChange: (phase) => log({ event: "channel.state", phase })
-    });
-    const connector = new RuntimeConnector({ channel, worker, runtime: config.runtime, runtimePath: config.runtimePath, backend: config.backend, appServerUrl: config.appServerUrl, connectorVersion: config.connectorVersion, workDir: config.workDir, stateStore: new JsonFileStateStore(join4(config.workDir, "connector-state.json")), onPermission: () => config.permissionPolicy ?? "deny", onDiagnostic: log });
-    log({ event: "connector.start" });
-    try {
-      await connector.start();
-    } catch (error) {
-      log({ event: "connector.start_failed", error: error instanceof Error ? error.message : String(error) });
-      throw error;
-    }
-    await writeFile3(join4(config.workDir, "connector.pid"), `${process.pid}
-`, { mode: 384 });
-    console.log(`clawtopia connected as ${config.agentId}; press Ctrl-C to stop`);
-    await new Promise((resolve2) => {
-      process.once("SIGINT", () => resolve2());
-      process.once("SIGTERM", () => resolve2());
-    });
-    await connector.stop();
-    await rm2(join4(config.workDir, "connector.pid"), { force: true });
-    return 0;
-  }
-  async function materializeBundledWorker(config) {
-    if (config.runtime === "openclaw") return config;
-    const target = join4(config.workDir, "worker", "agent-worker");
-    if (config.workerPath === target && existsSync4(target)) return config;
-    const bundled = bundledWorkerPath();
-    const looksLikeBundledWorker = config.workerPath === "agent-worker" || /[\\/]worker[\\/](?:darwin|linux)-(?:x64|arm64)[\\/]agent-worker$/u.test(config.workerPath);
-    if (!looksLikeBundledWorker || bundled === "agent-worker") return config;
-    const source = existsSync4(config.workerPath) ? config.workerPath : bundled;
-    await mkdir3(dirname(target), { recursive: true, mode: 448 });
-    await copyFile(source, target);
-    await chmod(target, 448);
-    return { ...config, workerPath: target, workerSha256: await sha256File(target) };
-  }
-  if (command === "stop") {
-    const config = await loadConfig(path);
-    if (serviceInstalled(config.profileId)) {
-      await stopService(config.profileId);
-      console.log(`stopped user service for profile ${config.profileId}`);
-    }
-    const pidPath = join4(config.workDir, "connector.pid");
-    try {
-      const pid = Number((await readFile2(pidPath, "utf8")).trim());
-      if (!Number.isInteger(pid) || pid <= 1) throw new Error("invalid pid file");
-      process.kill(pid, "SIGTERM");
-      await rm2(pidPath, { force: true });
-      console.log(`stopped ${pid}`);
-    } catch (error) {
-      if (error.code === "ENOENT" || error.code === "ESRCH") {
-        await rm2(pidPath, { force: true });
-        console.log("connector process is not running");
-      } else throw error;
-    }
-    return 0;
-  }
-  if (command === "upgrade") {
-    const config = await loadConfig(path);
-    const source = flags.source;
-    const expected = (flags.sha256 ?? "").toLowerCase();
-    if (!source) throw new Error("upgrade requires --source <worker-binary> and --sha256 <64-hex-digest>");
-    if (!/^[a-f0-9]{64}$/u.test(expected)) throw new Error("upgrade requires a 64-character lowercase SHA-256 via --sha256");
-    const digest = await sha256File(source);
-    if (digest !== expected) throw new Error(`worker checksum mismatch: expected ${expected}, got ${digest}`);
-    const sourceStat = await stat(source);
-    if (!sourceStat.isFile()) throw new Error(`worker source is not a regular file: ${source}`);
-    await mkdir3(dirname(config.workerPath), { recursive: true, mode: 448 });
-    const temporary = `${config.workerPath}.tmp-${process.pid}-${Date.now()}`;
-    try {
-      await copyFile(source, temporary);
-      await chmod(temporary, sourceStat.mode & 511 | 73);
-      const handle = await open(temporary, "r");
-      try {
-        await handle.sync();
-      } finally {
-        await handle.close();
-      }
-      await rename(temporary, config.workerPath);
-    } catch (error) {
-      await rm2(temporary, { force: true });
-      throw error;
-    }
-    await saveConfig({ ...config, workerSha256: digest }, path);
-    console.log(`upgraded worker ${config.workerPath} (${digest})`);
-    return 0;
-  }
-  if (command === "uninstall") {
-    if (process.platform === "darwin" || process.platform === "linux") {
-      const servicePath = await uninstallService(profile ?? process.env.CLAWTOPIA_AGENT_PROFILE ?? "default");
-      console.log(`removed user service ${servicePath}`);
-    }
-    const config = await loadConfig(path).catch((error) => {
-      if (error.code === "ENOENT") return void 0;
-      throw error;
-    });
-    if (!config) {
-      console.log(`connector is not configured: ${path}`);
-      return 0;
-    }
-    const pidPath = join4(config.workDir, "connector.pid");
-    try {
-      const pid = Number((await readFile2(pidPath, "utf8")).trim());
-      if (Number.isInteger(pid) && pid > 1) {
-        try {
-          process.kill(pid, "SIGTERM");
-        } catch (error) {
-          if (error.code !== "ESRCH") throw error;
-        }
-      }
-    } catch (error) {
-      if (error.code !== "ENOENT") throw error;
-    }
-    await rm2(path, { force: true });
-    await rm2(join4(config.workDir, "connector-state.json"), { force: true });
-    await rm2(join4(config.workDir, "connector.pid"), { force: true });
-    console.log(`removed connector configuration ${path}`);
-    return 0;
-  }
-  console.error(`unknown command: ${command}`);
-  return 2;
-}
-function printHelp() {
-  console.log(`clawtopia - connect a local Agent runtime to Clawtopia
-
-\u63A5\u5165\uFF1A
-  connect --pairing-code <code> [--profile <name>]  \u914D\u5BF9\u5E76\u542F\u52A8\u8FDE\u63A5\u5668
-
-\u8FD0\u884C\u7BA1\u7406\uFF1A
-  install | enable [--profile <name>]              \u5B89\u88C5\u5E76\u542F\u7528\u767B\u5F55\u540E\u81EA\u52A8\u542F\u52A8
-  disable [--profile <name>]                       \u505C\u6B62\u5E76\u5173\u95ED\u81EA\u52A8\u542F\u52A8\uFF0C\u4E0D\u4F1A\u88AB\u91CD\u65B0\u62C9\u8D77
-  uninstall [--profile <name>]                     \u505C\u6B62\u3001\u79FB\u9664\u670D\u52A1\u5B9A\u4E49\u5E76\u6E05\u7406\u672C\u5730\u51ED\u636E
-  start [--foreground] | stop | restart            \u542F\u52A8\u3001\u505C\u6B62\u6216\u91CD\u542F\u5F53\u524D profile
-  status | doctor | logs                           \u67E5\u770B\u72B6\u6001\u3001\u8FD0\u884C\u8BCA\u65AD\u6216\u67E5\u770B\u65E5\u5FD7\u4F4D\u7F6E
-  upgrade --source <file> --sha256 <digest>        \u66F4\u65B0 worker
-
-`);
-}
-function parseFlags(args) {
-  const result = {};
-  for (let i = 0; i < args.length; i += 1) {
-    const raw = args[i];
-    if (!raw.startsWith("--")) continue;
-    const key = raw.slice(2).replaceAll("-", "_");
-    const next = args[i + 1];
-    if (next && !next.startsWith("--")) {
-      result[key] = next;
-      i += 1;
-    } else result[key] = "true";
-  }
-  return result;
-}
-function configOverrides(flags) {
-  const env = process.env;
-  const values = {
-    gatewayUrl: flags.gateway_url ?? env.CLAWTOPIA_GATEWAY_URL,
-    agentId: flags.agent_id ?? env.CLAWTOPIA_AGENT_ID,
-    token: flags.token ?? env.CLAWTOPIA_AGENT_TOKEN,
-    runtime: normalizeRuntime(flags.runtime ?? env.CLAWTOPIA_AGENT_RUNTIME),
-    runtimePath: flags.runtime_path ?? env.CLAWTOPIA_AGENT_RUNTIME_PATH,
-    workerPath: flags.worker ?? env.CLAWTOPIA_AGENT_WORKER,
-    workDir: flags.work_dir ?? env.CLAWTOPIA_AGENT_WORK_DIR,
-    backend: flags.backend ?? env.CLAWTOPIA_CODEX_BACKEND,
-    appServerUrl: flags.app_server_url ?? env.CLAWTOPIA_CODEX_APP_SERVER_URL,
-    permissionPolicy: normalizePermissionPolicy(flags.permission ?? env.CLAWTOPIA_AGENT_PERMISSION)
-  };
-  return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== void 0));
-}
-function normalizeRuntime(value) {
-  if (!value) return void 0;
-  if (value === "claude") return "claudecode";
-  if (value === "open-claw") return "openclaw";
-  if (value === "claudecode" || value === "codex" || value === "openclaw") return value;
-  throw new Error(`unsupported runtime: ${value}; expected claudecode, codex or openclaw`);
-}
-function normalizePermissionPolicy(value) {
-  if (!value) return void 0;
-  if (value === "allow" || value === "deny") return value;
-  throw new Error(`unsupported permission policy: ${value}; expected allow or deny`);
-}
-async function diagnose(config) {
-  const platform = process.platform;
-  const architecture = process.arch;
-  const worker = { path: config.workerPath, executable: config.runtime === "openclaw" };
-  if (config.runtime === "openclaw") worker.error = "worker not used by OpenClaw runtime";
-  try {
-    if (config.runtime === "openclaw") throw new Error("worker not used by OpenClaw runtime");
-    const resolvedWorker = await resolveExecutablePath(config.workerPath);
-    worker.path = resolvedWorker;
-    const metadata = await stat(resolvedWorker);
-    worker.executable = metadata.isFile() && (metadata.mode & 73) !== 0;
-    if (!worker.executable) worker.error = "worker is not an executable regular file";
-    if (worker.executable) {
-      worker.sha256 = await sha256File(resolvedWorker);
-      if (config.workerSha256) worker.checksumMatches = worker.sha256 === config.workerSha256.toLowerCase();
-      const detected = await detectBinaryArchitecture(resolvedWorker);
-      if (detected) {
-        worker.architecture = detected;
-        worker.architectureCompatible = binaryMatchesHost(detected, architecture);
-      }
-    }
-  } catch (error) {
-    worker.error = error.message;
-  }
-  const runtimeCommand = config.runtimePath || (config.runtime === "codex" ? "codex" : config.runtime === "openclaw" ? "openclaw" : "claude");
-  const runtime = { command: runtimeCommand, executable: false };
-  try {
-    const result = await execFileAsync2(runtimeCommand, ["--version"], { timeout: 5e3, maxBuffer: 16 * 1024 });
-    runtime.executable = true;
-    runtime.version = `${result.stdout}${result.stderr}`.trim().split(/\r?\n/u)[0]?.slice(0, 200);
-  } catch (error) {
-    runtime.error = error.message;
-  }
-  const workerOk = config.runtime === "openclaw" || worker.executable && worker.checksumMatches !== false && worker.architectureCompatible !== false;
-  const ok = workerOk && runtime.executable && Boolean(config.agentId && config.token);
-  return { ok, platform, architecture, worker, runtime, tokenConfigured: Boolean(config.token), agentConfigured: Boolean(config.agentId) };
-}
-async function resolveExecutablePath(command) {
-  if (command.includes("/") || command.includes("\\")) return command;
-  const lookup = process.platform === "win32" ? "where" : "which";
-  const result = await execFileAsync2(lookup, [command], { timeout: 2e3, maxBuffer: 8 * 1024 });
-  const resolved = result.stdout.trim().split(/\r?\n/u)[0];
-  if (!resolved) throw new Error(`executable not found on PATH: ${command}`);
-  return resolved;
-}
-async function sha256File(path) {
-  const hash = createHash("sha256");
-  const handle = await open(path, "r");
-  try {
-    const buffer = Buffer.allocUnsafe(1024 * 1024);
-    let bytes;
-    do {
-      bytes = (await handle.read(buffer, 0, buffer.length, null)).bytesRead;
-      if (bytes) hash.update(buffer.subarray(0, bytes));
-    } while (bytes);
-  } finally {
-    await handle.close();
-  }
-  return hash.digest("hex");
-}
-async function detectBinaryArchitecture(path) {
-  try {
-    const result = await execFileAsync2("file", ["-b", path], { timeout: 2e3, maxBuffer: 8 * 1024 });
-    return result.stdout.trim().split(/,\s*/u).find((part) => /(?:x86-64|x86_64|aarch64|arm64|arm|i386|80386|universal)/iu.test(part));
-  } catch {
-    return void 0;
-  }
-}
-function binaryMatchesHost(description, architecture) {
-  if (/universal|fat binary/iu.test(description)) return true;
-  if (architecture === "arm64") return /aarch64|arm64/iu.test(description);
-  if (architecture === "x64") return /x86-64|x86_64/iu.test(description);
-  if (architecture === "arm") return /\barm\b/iu.test(description);
-  if (architecture === "ia32") return /i386|80386/iu.test(description);
-  return true;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-if (process.argv[1] && fileURLToPath(import.meta.url) === realpathSync(resolve(process.argv[1]))) {
-  main().then((code) => {
-    process.exitCode = code;
-  }).catch((error) => {
-    console.error(error instanceof Error ? error.message : error);
-    process.exitCode = 1;
-  });
-}
-export {
-  main
-};