@bitkyc08/opencodex 0.1.0 → 0.2.1

package/README.md

@@ -30,6 +30,16 @@ Codex CLI / App / SDK ──/v1/responses──▶ opencodex ──▶ Any provi
               OpenRouter · Azure · DeepSeek · GLM · …and OpenAI itself
 ```
 
+## Supported platforms
+
+| OS | Status | Service manager |
+|---|---|---|
+| macOS (arm64 / x64) | Fully supported | launchd |
+| Linux (x64 / arm64) | Fully supported | systemd (user unit) |
+| Windows (x64) | Fully supported | Task Scheduler |
+
+Requires [Bun](https://bun.sh) 1.1+. All three platforms work natively (no WSL needed on Windows).
+
 ## Quick start
 
 ```bash
@@ -110,7 +120,7 @@ ocx status                     # is the proxy running?
 ocx login <xai|anthropic|kimi> # OAuth login
 ocx logout <provider>          # remove a stored login
 ocx gui                        # open the web dashboard
-ocx service <install|start|stop|status|uninstall>   # run as a background service
+ocx service <install|start|stop|status|uninstall>   # background service (launchd/systemd/schtasks)
 ocx update                     # update opencodex to the latest published version
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitkyc08/opencodex",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Universal provider proxy for OpenAI Codex — use any LLM with Codex CLI/App/SDK",
   "type": "module",
   "main": "src/index.ts",

package/src/cli.ts

@@ -84,11 +84,22 @@ function handleStart() {
   process.on("SIGTERM", shutdown);
 }
 
+function killProxy(pid: number): void {
+  if (process.platform === "win32") {
+    try {
+      (require("node:child_process") as typeof import("node:child_process"))
+        .execSync(`taskkill /PID ${pid} /T /F`, { stdio: "pipe" });
+    } catch { /* process already gone */ }
+  } else {
+    process.kill(pid, "SIGTERM");
+  }
+}
+
 function handleStop() {
   const pid = readPid();
   if (pid) {
     try {
-      process.kill(pid, "SIGTERM");
+      killProxy(pid);
       console.log(`✅ Proxy (PID ${pid}) stopped.`);
     } catch {
       console.log("Proxy process not found.");
@@ -159,7 +170,8 @@ switch (command) {
       await new Promise(r => setTimeout(r, 1000));
     }
     console.log(`Opening ${guiUrl}`);
-    (await import("node:child_process")).exec(`open ${guiUrl}`);
+    const { openUrl } = await import("./open-url");
+    openUrl(guiUrl);
     break;
   }
   case "service":

package/src/config.ts

@@ -94,7 +94,13 @@ export function readPid(): number | null {
     const raw = readFileSync(PID_PATH, "utf-8").trim();
     const pid = parseInt(raw, 10);
     if (isNaN(pid)) return null;
-    try { process.kill(pid, 0); return pid; } catch { return null; }
+    try {
+      process.kill(pid, 0);
+      return pid;
+    } catch (e: unknown) {
+      if ((e as NodeJS.ErrnoException).code === "EPERM") return pid;
+      return null;
+    }
   } catch {
     return null;
   }

package/src/oauth/anthropic.ts

@@ -135,7 +135,11 @@ export async function loginAnthropic(
         }
       }
     } else if (importLocal === "only") {
-      throw new Error("No Claude Code token found in the keychain. Run 'ocx login anthropic' for browser OAuth.");
+      throw new Error(
+        process.platform === "darwin"
+          ? "No Claude Code token found in the keychain. Run 'ocx login anthropic' for browser OAuth."
+          : "Claude Code auto-import is macOS-only. Run 'ocx login anthropic' for browser OAuth.",
+      );
     }
   }
   return new AnthropicOAuthFlow(ctrl).login();

package/src/oauth/local-token-detect.ts

@@ -38,20 +38,13 @@ export function detectGrokCliToken(): OAuthCredentials | null {
   }
 }
 
-/** Read the Claude Code OAuth credential from the OS secure store (macOS keychain / linux secret-tool). */
+/** Read the Claude Code OAuth credential from macOS Keychain. Windows/Linux: use `ocx login`. */
 function readClaudeSecureStorage(): string | null {
+  if (process.platform !== "darwin") return null;
   try {
-    if (process.platform === "darwin") {
-      return execSync(`security find-generic-password -s "${CLAUDE_KEYCHAIN_SERVICE}" -w`, {
-        encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
-      }).trim();
-    }
-    if (process.platform === "linux") {
-      return execSync(`secret-tool lookup service "${CLAUDE_KEYCHAIN_SERVICE}"`, {
-        encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
-      }).trim();
-    }
-    return null;
+    return execSync(`security find-generic-password -s "${CLAUDE_KEYCHAIN_SERVICE}" -w`, {
+      encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
   } catch {
     return null;
   }

package/src/oauth/login-cli.ts

@@ -1,15 +1,9 @@
 import * as readline from "node:readline";
-import { exec } from "node:child_process";
+import { openUrl } from "../open-url";
 import { loadConfig, readPid, saveConfig } from "../config";
 import { OAUTH_PROVIDERS, runLogin } from "./index";
 import { KEY_LOGIN_PROVIDERS, isKeyLoginProvider, validateApiKey } from "./key-providers";
 
-function openBrowser(url: string): void {
-  const cmd =
-    process.platform === "darwin" ? "open" : process.platform === "win32" ? 'start ""' : "xdg-open";
-  exec(`${cmd} "${url}"`, () => {});
-}
-
 /** Push the new provider into a running proxy's live config so it routes without a restart. */
 async function notifyRunningProxy(name: string, provider: unknown): Promise<void> {
   if (!readPid()) return;
@@ -44,7 +38,7 @@ async function handleOAuthLogin(name: string): Promise<void> {
       onAuth: ({ url, instructions }) => {
         console.log(`\n🔐 Opening browser for ${name} login...\n${url}\n`);
         if (instructions) console.log(instructions);
-        openBrowser(url);
+        openUrl(url);
       },
       onProgress: (m) => console.log(`   ${m}`),
       onManualCodeInput: () =>
@@ -60,7 +54,7 @@ async function handleOAuthLogin(name: string): Promise<void> {
 async function handleKeyLogin(name: string): Promise<void> {
   const def = KEY_LOGIN_PROVIDERS[name];
   console.log(`\n🔑 ${def.label} — opening ${def.dashboardUrl} so you can create/copy an API key...`);
-  openBrowser(def.dashboardUrl);
+  openUrl(def.dashboardUrl);
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   const key = (await new Promise<string>((res) => rl.question(`Paste your ${def.label} API key: `, res))).trim();
   rl.close();

package/src/open-url.ts

@@ -0,0 +1,9 @@
+import { exec } from "node:child_process";
+
+export function openUrl(url: string): void {
+  const cmd =
+    process.platform === "darwin" ? "open"
+    : process.platform === "win32" ? 'start ""'
+    : "xdg-open";
+  exec(`${cmd} ${JSON.stringify(url)}`);
+}

package/src/server.ts

@@ -403,8 +403,8 @@ async function handleManagementAPI(req: Request, url: URL, config: OcxConfig): P
       if (authUrl) {
         // Open the browser server-side (the proxy runs on the user's machine) — the GUI's
         // window.open is popup-blocked because it runs after an await, not a direct click.
-        const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? 'start ""' : "xdg-open";
-        (await import("node:child_process")).exec(`${cmd} "${authUrl}"`, () => {});
+        const { openUrl } = await import("./open-url");
+        openUrl(authUrl);
       }
       return jsonResponse({ url: authUrl, instructions });
     } catch (err) {

package/src/service.ts

@@ -1,7 +1,7 @@
 /**
  * `ocx service` — run the proxy as a background service that auto-starts on login and
- * auto-restarts on crash. macOS → launchd LaunchAgent; Windows → Task Scheduler.
- * The plist/task sets OCX_SERVICE=1 so the proxy's shutdown handler does NOT restore native
+ * auto-restarts on crash. macOS → launchd; Windows → Task Scheduler; Linux → systemd user unit.
+ * The service sets OCX_SERVICE=1 so the proxy's shutdown handler does NOT restore native
  * Codex on a service-managed restart (the restarted instance re-injects); explicit stop/uninstall
  * restore it via the command.
  */
@@ -91,35 +91,113 @@ function stopWindows(): void { try { sh(`schtasks /end /tn ${TASK}`); } catch {
 function statusWindows(): string { try { return sh(`schtasks /query /tn ${TASK}`); } catch { return ""; } }
 function uninstallWindows(): void { try { sh(`schtasks /delete /tn ${TASK} /f`); } catch { /* absent */ } }
 
+// ── Linux (systemd user unit) ──
+function unitDir(): string {
+  return join(homedir(), ".config", "systemd", "user");
+}
+
+function unitPath(): string {
+  return join(unitDir(), `${TASK}.service`);
+}
+
+export function buildUnit(): string {
+  const { bun, cli } = cliEntry();
+  const log = logPath();
+  const path = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
+  return `[Unit]
+Description=OpenCodex Proxy Server
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${bun} ${cli} start
+Restart=on-failure
+RestartSec=5
+Environment=OCX_SERVICE=1
+Environment=PATH=${path}
+StandardOutput=append:${log}
+StandardError=append:${log}
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+function isSystemd(): boolean {
+  try { execSync("systemctl --version", { stdio: "pipe" }); return true; } catch { return false; }
+}
+
+function installSystemd(): void {
+  const dir = unitDir();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  if (!existsSync(getConfigDir())) mkdirSync(getConfigDir(), { recursive: true });
+  writeFileSync(unitPath(), buildUnit(), "utf8");
+  sh("systemctl --user daemon-reload");
+  sh(`systemctl --user enable --now ${TASK}`);
+}
+function startSystemd(): void { sh(`systemctl --user start ${TASK}`); }
+function stopSystemd(): void { try { sh(`systemctl --user stop ${TASK}`); } catch { /* not running */ } }
+function statusSystemd(): string { try { return sh(`systemctl --user status ${TASK}`); } catch { return ""; } }
+function uninstallSystemd(): void {
+  try { sh(`systemctl --user disable --now ${TASK}`); } catch { /* absent */ }
+  if (existsSync(unitPath())) unlinkSync(unitPath());
+  try { sh("systemctl --user daemon-reload"); } catch { /* best-effort */ }
+}
+
+type ServiceOps = {
+  install: () => void; start: () => void; stop: () => void;
+  status: () => string; uninstall: () => void;
+};
+
+function platformOps(): ServiceOps | null {
+  if (process.platform === "darwin")
+    return { install: installLaunchd, start: startLaunchd, stop: stopLaunchd, status: statusLaunchd, uninstall: uninstallLaunchd };
+  if (process.platform === "win32")
+    return { install: installWindows, start: startWindows, stop: stopWindows, status: statusWindows, uninstall: uninstallWindows };
+  if (process.platform === "linux") {
+    if (existsSync("/.dockerenv")) {
+      console.error("Docker detected. Run 'ocx start' directly instead of using the service manager.");
+      process.exit(1);
+    }
+    if (!isSystemd()) {
+      console.error("systemd not found. Run 'ocx start' under your process supervisor.");
+      process.exit(1);
+    }
+    return { install: installSystemd, start: startSystemd, stop: stopSystemd, status: statusSystemd, uninstall: uninstallSystemd };
+  }
+  return null;
+}
+
 export function serviceCommand(sub?: string): void {
-  const mac = process.platform === "darwin";
-  const win = process.platform === "win32";
-  if (!mac && !win) {
-    console.error("ocx service supports macOS (launchd) and Windows (Task Scheduler). On Linux, run 'ocx start' under systemd or your process supervisor.");
+  const ops = platformOps();
+  if (!ops) {
+    console.error("ocx service supports macOS (launchd), Windows (Task Scheduler), and Linux (systemd).");
     process.exit(1);
   }
   switch (sub) {
     case "install":
-      mac ? installLaunchd() : installWindows();
+      ops.install();
       console.log("✅ opencodex service installed + started (auto-starts on login, auto-restarts on crash).");
+      if (process.platform === "linux") console.log("   For auto-start on boot: loginctl enable-linger $USER");
       break;
     case "start":
-      mac ? startLaunchd() : startWindows();
+      ops.start();
       console.log("✅ service started.");
       break;
     case "stop":
-      mac ? stopLaunchd() : stopWindows();
+      ops.stop();
       restoreNativeCodex();
       console.log("✅ service stopped + native Codex restored.");
       break;
     case "status": {
-      const s = mac ? statusLaunchd() : statusWindows();
+      const s = ops.status();
       console.log(s ? `✅ running:\n${s}` : "❌ service not installed/running.");
       break;
     }
     case "uninstall":
     case "remove":
-      mac ? uninstallLaunchd() : uninstallWindows();
+      ops.uninstall();
       restoreNativeCodex();
       console.log("✅ service uninstalled + native Codex restored.");
       break;