codex-to-im 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+
+// src/service-manager.ts
+import fs2 from "node:fs";
+import os2 from "node:os";
+import path2 from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+// src/config.ts
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var LEGACY_CTI_HOME = path.join(os.homedir(), ".claude-to-im");
+var DEFAULT_CTI_HOME = path.join(os.homedir(), ".codex-to-im");
+function resolveDefaultCtiHome() {
+  if (fs.existsSync(DEFAULT_CTI_HOME)) return DEFAULT_CTI_HOME;
+  if (fs.existsSync(LEGACY_CTI_HOME)) return LEGACY_CTI_HOME;
+  return DEFAULT_CTI_HOME;
+}
+var CTI_HOME = process.env.CTI_HOME || resolveDefaultCtiHome();
+var CONFIG_PATH = path.join(CTI_HOME, "config.env");
+
+// src/service-manager.ts
+var moduleDir = path2.dirname(fileURLToPath(import.meta.url));
+var packageRoot = path2.resolve(moduleDir, "..");
+var runtimeDir = path2.join(CTI_HOME, "runtime");
+var logsDir = path2.join(CTI_HOME, "logs");
+var bridgePidFile = path2.join(runtimeDir, "bridge.pid");
+var bridgeStatusFile = path2.join(runtimeDir, "status.json");
+var uiStatusFile = path2.join(runtimeDir, "ui-server.json");
+var uiPort = 4781;
+function ensureDirs() {
+  fs2.mkdirSync(runtimeDir, { recursive: true });
+  fs2.mkdirSync(logsDir, { recursive: true });
+}
+function readJsonFile(filePath, fallback) {
+  try {
+    return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function isProcessAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getUiServerUrl(port = uiPort) {
+  return `http://127.0.0.1:${port}`;
+}
+function getCurrentUiServerUrl() {
+  const status = readJsonFile(uiStatusFile, null);
+  if (!status?.port) return void 0;
+  return getUiServerUrl(status.port);
+}
+function getUiServerStatus() {
+  const status = readJsonFile(uiStatusFile, { running: false, port: uiPort });
+  if (!isProcessAlive(status.pid)) {
+    return {
+      ...status,
+      running: false,
+      port: status.port ?? uiPort
+    };
+  }
+  return {
+    ...status,
+    running: true,
+    port: status.port ?? uiPort
+  };
+}
+async function waitForUiServer(timeoutMs = 15e3) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const status = getUiServerStatus();
+    if (status.running) {
+      try {
+        const response = await fetch(`${getUiServerUrl(status.port)}/api/ping`);
+        if (response.ok) return status;
+      } catch {
+      }
+    }
+    await sleep(300);
+  }
+  return getUiServerStatus();
+}
+async function ensureUiServerRunning() {
+  ensureDirs();
+  const current = getUiServerStatus();
+  if (current.running) return current;
+  const serverEntry = path2.join(packageRoot, "dist", "ui-server.mjs");
+  if (!fs2.existsSync(serverEntry)) {
+    throw new Error(`UI server bundle not found at ${serverEntry}. Run npm run build first.`);
+  }
+  const stdoutFd = fs2.openSync(path2.join(logsDir, "ui-server.out.log"), "a");
+  const stderrFd = fs2.openSync(path2.join(logsDir, "ui-server.err.log"), "a");
+  const child = spawn(process.execPath, [serverEntry], {
+    cwd: packageRoot,
+    detached: true,
+    env: {
+      ...process.env,
+      CTI_HOME
+    },
+    stdio: ["ignore", stdoutFd, stderrFd]
+  });
+  child.unref();
+  const status = await waitForUiServer();
+  if (!status.running) {
+    throw new Error("UI server failed to start.");
+  }
+  return status;
+}
+function openBrowser(url) {
+  if (process.platform === "win32") {
+    const child2 = spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" });
+    child2.unref();
+    return;
+  }
+  if (process.platform === "darwin") {
+    const child2 = spawn("open", [url], { detached: true, stdio: "ignore" });
+    child2.unref();
+    return;
+  }
+  const child = spawn("xdg-open", [url], { detached: true, stdio: "ignore" });
+  child.unref();
+}
+
+// src/cli.ts
+async function main() {
+  const command = process.argv[2] || "open";
+  switch (command) {
+    case "open": {
+      const status = await ensureUiServerRunning();
+      const url = getUiServerUrl(status.port);
+      openBrowser(url);
+      process.stdout.write(`Codex to IM is available at ${url}
+`);
+      return;
+    }
+    case "url": {
+      const status = getUiServerStatus();
+      const url = getCurrentUiServerUrl();
+      if (status.running && url) {
+        process.stdout.write(`${url}
+`);
+        return;
+      }
+      if (url) {
+        process.stdout.write(`UI server is not running. Last known URL: ${url}
+`);
+        process.exitCode = 1;
+        return;
+      }
+      process.stdout.write("UI server is not running and no known URL is available.\n");
+      process.exitCode = 1;
+      return;
+    }
+    case "share-feishu": {
+      const status = await ensureUiServerRunning();
+      const url = `${getUiServerUrl(status.port)}/#desktop`;
+      openBrowser(url);
+      process.stdout.write(`Opened Feishu handoff entry at ${url}
+`);
+      return;
+    }
+    default:
+      process.stdout.write("Usage: codex-to-im [open|url|share-feishu]\n");
+  }
+}
+main().catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+  process.exit(1);
+});