feishu-codex-connector 0.1.6

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+declare function main(argv?: string[]): Promise<void>;
+
+export { main };

package/dist/cli.js

@@ -0,0 +1,454 @@
+import {
+  ProfileStore,
+  RuntimeRegistry,
+  profilePaths,
+  resolveWorkspace,
+  runBridge,
+  runnerForProfile
+} from "./chunk-AOVT2UMM.js";
+
+// src/cli.ts
+import { Command } from "commander";
+import { createRequire } from "module";
+
+// src/daemon/service-adapter.ts
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { homedir, platform } from "os";
+import { basename, join } from "path";
+import { mkdir, rm, writeFile } from "fs/promises";
+function serviceAdapter(home) {
+  const os = platform();
+  if (os === "darwin") return new LaunchdServiceAdapter(home);
+  if (os === "linux") return new SystemdServiceAdapter(home);
+  if (os === "win32") return new WindowsTaskServiceAdapter(home);
+  return new UnsupportedServiceAdapter(os);
+}
+var LaunchdServiceAdapter = class {
+  constructor(home) {
+    this.home = home;
+  }
+  home;
+  async install(profile, cliPath) {
+    const path = launchdPath(profile);
+    await mkdir(join(path, ".."), { recursive: true });
+    const logs = profilePaths(profile, this.home).logsDir;
+    await mkdir(logs, { recursive: true });
+    await writeFile(path, plist(profile, cliPath, logs), { mode: 420 });
+  }
+  async start(profile, cliPath) {
+    await stopLaunchdLabels([legacyLabel(profile)]);
+    await rm(launchdPathForLabel(legacyLabel(profile)), { force: true });
+    await this.install(profile, cliPath);
+    const result = run("launchctl", ["bootstrap", launchdDomain(), launchdPath(profile)]);
+    if (!result.ok && !/already bootstrapped|service already loaded/i.test(result.stderr)) throw new Error(result.stderr || "launchctl bootstrap failed");
+    const kick = run("launchctl", ["kickstart", "-k", `${launchdDomain()}/${label(profile)}`]);
+    if (!kick.ok) throw new Error(kick.stderr || "launchctl kickstart failed");
+  }
+  async stop(profile) {
+    await stopLaunchdLabels(serviceLabels(profile));
+  }
+  async restart(profile, cliPath) {
+    await stopLaunchdLabels([legacyLabel(profile)]);
+    await rm(launchdPathForLabel(legacyLabel(profile)), { force: true });
+    await this.install(profile, cliPath);
+    const result = run("launchctl", ["kickstart", "-k", `${launchdDomain()}/${label(profile)}`]);
+    if (!result.ok) {
+      await this.start(profile, cliPath);
+    }
+  }
+  async unregister(profile) {
+    await this.stop(profile).catch(() => void 0);
+    await Promise.all(serviceLabels(profile).map((serviceLabel) => rm(launchdPathForLabel(serviceLabel), { force: true })));
+  }
+  async status(profile) {
+    const states = serviceLabels(profile).map((serviceLabel) => {
+      const path = launchdPathForLabel(serviceLabel);
+      const result = run("launchctl", ["print", `${launchdDomain()}/${serviceLabel}`]);
+      return { serviceLabel, path, result };
+    });
+    const running = states.some((state) => state.result.ok);
+    const installed = states.some((state) => existsSync(state.path));
+    const visibleStates = states.filter((state) => state.result.ok || existsSync(state.path));
+    const detail = (visibleStates.length > 0 ? visibleStates : states).map((state) => `${state.serviceLabel}: ${state.result.stdout || state.result.stderr}`).join("\n");
+    return { installed, running, detail, servicePath: launchdPath(profile) };
+  }
+};
+var SystemdServiceAdapter = class {
+  constructor(home) {
+    this.home = home;
+  }
+  home;
+  async install(profile, cliPath) {
+    const path = systemdPath(profile);
+    await mkdir(join(path, ".."), { recursive: true });
+    const logs = profilePaths(profile, this.home).logsDir;
+    await mkdir(logs, { recursive: true });
+    await writeFile(path, systemdUnit(profile, cliPath, logs), { mode: 420 });
+    run("systemctl", ["--user", "daemon-reload"]);
+  }
+  async start(profile, cliPath) {
+    stopSystemdUnits([legacySystemdUnitName(profile)]);
+    await rm(systemdPathForUnit(legacySystemdUnitName(profile)), { force: true });
+    run("systemctl", ["--user", "daemon-reload"]);
+    await this.install(profile, cliPath);
+    const result = run("systemctl", ["--user", "enable", "--now", systemdUnitName(profile)]);
+    if (!result.ok) throw new Error(result.stderr || "systemctl enable --now failed");
+  }
+  async stop(profile) {
+    stopSystemdUnits(serviceUnitNames(profile));
+  }
+  async restart(profile, cliPath) {
+    stopSystemdUnits([legacySystemdUnitName(profile)]);
+    await rm(systemdPathForUnit(legacySystemdUnitName(profile)), { force: true });
+    run("systemctl", ["--user", "daemon-reload"]);
+    await this.install(profile, cliPath);
+    const result = run("systemctl", ["--user", "restart", systemdUnitName(profile)]);
+    if (!result.ok) throw new Error(result.stderr || "systemctl restart failed");
+  }
+  async unregister(profile) {
+    for (const unit of serviceUnitNames(profile)) run("systemctl", ["--user", "disable", "--now", unit]);
+    await Promise.all(serviceUnitNames(profile).map((unit) => rm(systemdPathForUnit(unit), { force: true })));
+    run("systemctl", ["--user", "daemon-reload"]);
+  }
+  async status(profile) {
+    const states = serviceUnitNames(profile).map((unit) => {
+      const active = run("systemctl", ["--user", "is-active", unit]);
+      const detail = run("systemctl", ["--user", "status", unit, "--no-pager"]);
+      const path = systemdPathForUnit(unit);
+      return { unit, active, detail, path };
+    });
+    const visibleStates = states.filter((state) => existsSync(state.path) || state.active.stdout.trim() === "active");
+    return {
+      installed: states.some((state) => existsSync(state.path)),
+      running: states.some((state) => state.active.stdout.trim() === "active"),
+      detail: (visibleStates.length > 0 ? visibleStates : states).map((state) => `${state.unit}: ${state.detail.stdout || state.detail.stderr}`).join("\n"),
+      servicePath: systemdPath(profile)
+    };
+  }
+};
+var WindowsTaskServiceAdapter = class {
+  constructor(home) {
+    this.home = home;
+  }
+  home;
+  async install(profile, cliPath) {
+    const task = windowsTaskName(profile);
+    const logs = profilePaths(profile, this.home).logsDir;
+    await mkdir(logs, { recursive: true });
+    const command = `"${process.execPath}" "${cliPath}" run --profile "${profile}"`;
+    run("schtasks", ["/Create", "/TN", task, "/SC", "ONLOGON", "/TR", command, "/F"]);
+  }
+  async start(profile, cliPath) {
+    run("schtasks", ["/End", "/TN", legacyWindowsTaskName(profile)]);
+    run("schtasks", ["/Delete", "/TN", legacyWindowsTaskName(profile), "/F"]);
+    await this.install(profile, cliPath);
+    const result = run("schtasks", ["/Run", "/TN", windowsTaskName(profile)]);
+    if (!result.ok) throw new Error(result.stderr || "schtasks run failed");
+  }
+  async stop(profile) {
+    for (const task of serviceTaskNames(profile)) run("schtasks", ["/End", "/TN", task]);
+  }
+  async restart(profile, cliPath) {
+    await this.stop(profile);
+    await this.start(profile, cliPath);
+  }
+  async unregister(profile) {
+    for (const task of serviceTaskNames(profile)) {
+      run("schtasks", ["/End", "/TN", task]);
+      run("schtasks", ["/Delete", "/TN", task, "/F"]);
+    }
+  }
+  async status(profile) {
+    const states = serviceTaskNames(profile).map((task) => {
+      const result = run("schtasks", ["/Query", "/TN", task, "/V", "/FO", "LIST"]);
+      return { task, result };
+    });
+    const visibleStates = states.filter((state) => state.result.ok);
+    return {
+      installed: states.some((state) => state.result.ok),
+      running: states.some((state) => /Status:\s+Running/i.test(state.result.stdout)),
+      detail: (visibleStates.length > 0 ? visibleStates : states).map((state) => `${state.task}: ${state.result.stdout || state.result.stderr}`).join("\n"),
+      servicePath: windowsTaskName(profile)
+    };
+  }
+};
+var UnsupportedServiceAdapter = class {
+  constructor(os) {
+    this.os = os;
+  }
+  os;
+  async install() {
+    throw new Error(`service management is not supported on ${this.os}`);
+  }
+  async start() {
+    throw new Error(`service management is not supported on ${this.os}`);
+  }
+  async stop() {
+    throw new Error(`service management is not supported on ${this.os}`);
+  }
+  async restart() {
+    throw new Error(`service management is not supported on ${this.os}`);
+  }
+  async unregister() {
+    throw new Error(`service management is not supported on ${this.os}`);
+  }
+  async status() {
+    return { installed: false, running: false, detail: `unsupported platform ${this.os}` };
+  }
+};
+function run(command, args) {
+  const result = spawnSync(command, args, { encoding: "utf8" });
+  return {
+    ok: result.status === 0,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? result.error?.message ?? ""
+  };
+}
+function label(profile) {
+  return `com.feishu-codex-connector.${safeName(profile)}`;
+}
+function legacyLabel(profile) {
+  return `com.feishu-codex-bridge.${safeName(profile)}`;
+}
+function serviceLabels(profile) {
+  return [label(profile), legacyLabel(profile)];
+}
+function safeName(value) {
+  return value.replace(/[^a-zA-Z0-9_.-]/g, "-");
+}
+function launchdDomain() {
+  const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
+  return uid === void 0 ? "gui/501" : `gui/${uid}`;
+}
+function launchdPath(profile) {
+  return launchdPathForLabel(label(profile));
+}
+function launchdPathForLabel(serviceLabel) {
+  return join(homedir(), "Library", "LaunchAgents", `${serviceLabel}.plist`);
+}
+async function stopLaunchdLabels(labels) {
+  for (const serviceLabel of labels) {
+    const path = launchdPathForLabel(serviceLabel);
+    const targetResult = run("launchctl", ["bootout", `${launchdDomain()}/${serviceLabel}`]);
+    if (targetResult.ok || launchdStopIsMissing(targetResult)) continue;
+    const pathResult = existsSync(path) ? run("launchctl", ["bootout", launchdDomain(), path]) : { ok: false, stdout: "", stderr: "No such file" };
+    if (pathResult.ok || launchdStopIsMissing(pathResult)) continue;
+    throw new Error(pathResult.stderr || targetResult.stderr || "launchctl bootout failed");
+  }
+}
+function launchdStopIsMissing(result) {
+  return /No such process|Could not find service|No such file|does not exist|not found/i.test(result.stderr);
+}
+function plist(profile, cliPath, logs) {
+  return `<?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>Label</key><string>${xml(label(profile))}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xml(process.execPath)}</string>
+    <string>${xml(cliPath)}</string>
+    <string>run</string>
+    <string>--profile</string>
+    <string>${xml(profile)}</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${xml(join(logs, "daemon.out.log"))}</string>
+  <key>StandardErrorPath</key><string>${xml(join(logs, "daemon.err.log"))}</string>
+</dict>
+</plist>
+`;
+}
+function systemdUnitName(profile) {
+  return `${label(profile)}.service`;
+}
+function legacySystemdUnitName(profile) {
+  return `${legacyLabel(profile)}.service`;
+}
+function serviceUnitNames(profile) {
+  return [systemdUnitName(profile), legacySystemdUnitName(profile)];
+}
+function systemdPath(profile) {
+  return systemdPathForUnit(systemdUnitName(profile));
+}
+function systemdPathForUnit(unit) {
+  return join(homedir(), ".config", "systemd", "user", unit);
+}
+function stopSystemdUnits(units) {
+  for (const unit of units) {
+    const result = run("systemctl", ["--user", "stop", unit]);
+    if (!result.ok && !/not loaded|not-found|could not be found/i.test(result.stderr)) throw new Error(result.stderr || "systemctl stop failed");
+  }
+}
+function systemdUnit(profile, cliPath, logs) {
+  return `[Unit]
+Description=Feishu Codex Connector (${profile})
+
+[Service]
+ExecStart=${process.execPath} ${cliPath} run --profile ${profile}
+Restart=always
+RestartSec=5
+StandardOutput=append:${join(logs, "daemon.out.log")}
+StandardError=append:${join(logs, "daemon.err.log")}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function windowsTaskName(profile) {
+  return `FeishuCodexConnector-${safeName(profile)}-${basename(homedir())}`;
+}
+function legacyWindowsTaskName(profile) {
+  return `FeishuCodexBridge-${safeName(profile)}-${basename(homedir())}`;
+}
+function serviceTaskNames(profile) {
+  return [windowsTaskName(profile), legacyWindowsTaskName(profile)];
+}
+function xml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+// src/cli.ts
+async function main(argv = process.argv) {
+  const program = new Command();
+  program.name("feishu-codex").description("Feishu/Lark connector for Codex").version(packageVersion());
+  program.command("run").option("--profile <name>").option("--workspace <path>").option("--home <path>").option("--preflight", "run checks and exit").option("--bootstrap-owner", "make the first private sender an admin when no access list exists").option("--tenant <tenant>", "feishu or lark").option("--app-id <id>", "use an existing PersonalAgent app and skip QR creation").option("--app-secret <secret>", "App Secret for --app-id").option("--codex-auth <mode>", "api-key, codex-home, or inherit-user").option("--codex-api-key <key>", "OpenAI API key for api-key auth").option("--codex-path <path>", "Codex binary path override").option("--poll-chat <chatId...>", "poll specific chat IDs as a fallback when long-connection events are not configured").action(async (opts) => {
+    if (opts.tenant) opts.tenant = normalizeTenant(opts.tenant);
+    if (opts.codexAuth) opts.codexAuth = normalizeAuth(opts.codexAuth);
+    await runBridge(opts);
+    if (!opts.preflight) process.exit(0);
+  });
+  program.command("start").option("--profile <name>").option("--home <path>").action(async (opts) => {
+    const store = new ProfileStore(opts.home);
+    const profile2 = await store.read(opts.profile);
+    await serviceAdapter(store.paths.home).start(profile2.name, process.argv[1] ?? "feishu-codex");
+    console.log(`service started for ${profile2.name}`);
+  });
+  program.command("stop").option("--profile <name>").option("--home <path>").action(async (opts) => {
+    const store = new ProfileStore(opts.home);
+    const profile2 = await store.read(opts.profile);
+    await serviceAdapter(store.paths.home).stop(profile2.name);
+    console.log(`service stopped for ${profile2.name}`);
+  });
+  program.command("restart").option("--profile <name>").option("--home <path>").action(async (opts) => {
+    const store = new ProfileStore(opts.home);
+    const profile2 = await store.read(opts.profile);
+    await serviceAdapter(store.paths.home).restart(profile2.name, process.argv[1] ?? "feishu-codex");
+    console.log(`service restarted for ${profile2.name}`);
+  });
+  program.command("status").option("--profile <name>").option("--home <path>").action(async (opts) => {
+    const store = new ProfileStore(opts.home);
+    const profile2 = await store.read(opts.profile);
+    console.log(JSON.stringify(await serviceAdapter(store.paths.home).status(profile2.name), null, 2));
+  });
+  program.command("unregister").option("--profile <name>").option("--home <path>").action(async (opts) => {
+    const store = new ProfileStore(opts.home);
+    const profile2 = await store.read(opts.profile);
+    await serviceAdapter(store.paths.home).unregister(profile2.name);
+    console.log(`service unregistered for ${profile2.name}`);
+  });
+  program.command("ps").option("--home <path>").action(async (opts) => {
+    const rows = await new RuntimeRegistry(new ProfileStore(opts.home).paths.home).list();
+    if (rows.length === 0) {
+      console.log("no running connector processes");
+      return;
+    }
+    for (const row of rows) {
+      console.log(`${row.id}	pid:${row.pid}	profile:${row.profile}	app:*${row.appId.slice(-6)}	log:${row.logPath ?? "-"}`);
+    }
+  });
+  program.command("kill <target>").option("--home <path>").action(async (target, opts) => {
+    const registry = new RuntimeRegistry(new ProfileStore(opts.home).paths.home);
+    const killed = await registry.kill(target);
+    if (!killed) throw new Error(`process not found: ${target}`);
+    console.log(`sent SIGTERM to ${killed.id} pid:${killed.pid}`);
+  });
+  program.command("doctor").option("--profile <name>").option("--home <path>").option("--json").action(async (opts) => {
+    const store = new ProfileStore(opts.home);
+    const profile2 = await store.read(opts.profile);
+    const runner = runnerForProfile(profile2);
+    const availability = await runner.checkAvailability();
+    const workspace = await resolveWorkspace(profile2.workspaces.default);
+    const processes = await new RuntimeRegistry(store.paths.home).list();
+    const report = {
+      profile: profile2.name,
+      tenant: profile2.tenant,
+      appIdSuffix: profile2.app.id.slice(-6),
+      backend: availability,
+      workspace,
+      service: await serviceAdapter(store.paths.home).status(profile2.name),
+      processes,
+      codexAuth: profile2.codex.auth.mode,
+      larkCli: profile2.feishuCli.identityPreset
+    };
+    if (opts.json) console.log(JSON.stringify(report, null, 2));
+    else {
+      console.log(`Profile: ${report.profile}`);
+      console.log(`Tenant: ${report.tenant}`);
+      console.log(`Backend: ${availability.label} (${availability.ok ? "ok" : "failed"})`);
+      console.log(`Workspace: ${workspace.ok ? workspace.cwdRealpath : workspace.userVisible}`);
+      console.log(`Service: ${report.service.installed ? "installed" : "not installed"} / ${report.service.running ? "running" : "stopped"}`);
+      console.log(`Processes: ${processes.length}`);
+    }
+  });
+  const profile = program.command("profile").description("Manage local profiles");
+  profile.command("create <name>").option("--tenant <tenant>", "feishu or lark", "feishu").requiredOption("--app-id <id>").requiredOption("--app-secret <secret>").option("--codex-auth <mode>", "api-key, codex-home, or inherit-user", "api-key").option("--codex-api-key <key>").option("--codex-backend <backend>", "sdk or exec-json", "sdk").option("--codex-path <path>").option("--workspace <path>").option("--home <path>").action(async (name, opts) => {
+    const tenant = normalizeTenant(opts.tenant);
+    const auth = normalizeAuth(opts.codexAuth);
+    const store = new ProfileStore(opts.home);
+    const created = await store.create({
+      name,
+      tenant,
+      appId: opts.appId,
+      appSecret: opts.appSecret,
+      codexAuthMode: auth,
+      codexApiKey: opts.codexApiKey,
+      workspace: opts.workspace,
+      codexBackend: opts.codexBackend,
+      codexPath: opts.codexPath
+    });
+    console.log(`created profile ${created.name}`);
+  });
+  profile.command("list").option("--home <path>").action(async (opts) => {
+    const store = new ProfileStore(opts.home);
+    const rows = await store.list();
+    for (const row of rows) {
+      console.log(`${row.active ? "*" : " "} ${row.name}	${row.tenant}	app:*${row.appIdSuffix}	workspace:${row.workspaceStatus}	${row.backend}	${row.codexAuthMode}	lark-cli:${row.feishuCliIdentity}`);
+    }
+  });
+  profile.command("use <name>").option("--home <path>").action(async (name, opts) => {
+    await new ProfileStore(opts.home).use(name);
+    console.log(`active profile: ${name}`);
+  });
+  profile.command("remove <name>").option("--purge").option("--yes").option("--home <path>").action(async (name, opts) => {
+    const result = await new ProfileStore(opts.home).remove(name, { purge: opts.purge, yes: opts.yes });
+    console.log(result);
+  });
+  profile.command("export <name>").option("--include-secrets").option("--yes").option("--home <path>").action(async (name, opts) => {
+    if (opts.includeSecrets && !opts.yes) throw new Error("--include-secrets requires --yes");
+    console.log(JSON.stringify(await new ProfileStore(opts.home).export(name, { includeSecrets: opts.includeSecrets }), null, 2));
+  });
+  await program.parseAsync(argv);
+}
+function packageVersion() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    return require2("../package.json").version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function normalizeTenant(value) {
+  if (value === "feishu" || value === "lark") return value;
+  throw new Error("tenant must be feishu or lark");
+}
+function normalizeAuth(value) {
+  if (value === "api-key" || value === "codex-home" || value === "inherit-user") return value;
+  throw new Error("codex auth must be api-key, codex-home, or inherit-user");
+}
+export {
+  main
+};