@btatum5/codex-bridge 0.1.0

package/README.md

@@ -0,0 +1,39 @@
+# Codex Desktop Companion
+
+This is the Windows-side HTTP stub that the iOS `Codex` app can talk to.
+
+## Run
+
+The publishable npm package for this scaffold is `@btatum5/codex-bridge`. After publishing, you can install and run it with:
+
+```bash
+npm install -g @btatum5/codex-bridge
+codex-bridge up
+```
+
+You can also run the in-repo companion directly:
+
+```bash
+cd desktop-companion
+npm start
+```
+
+From the repo root on Windows, you can also use:
+
+```powershell
+.\run-local-codex.ps1
+```
+
+The server listens on `http://127.0.0.1:8787` by default.
+
+## Endpoints
+
+- `GET /health`
+- `GET /v1/companion/session`
+- `POST /v1/companion/settings`
+- `POST /v1/companion/actions`
+- `POST /v1/companion/chat`
+
+## Important limitation
+
+This server does not automate the real ChatGPT Codex Windows app yet. It mirrors session state, approvals, workspace files, terminal lines, and accepts remote actions so the iOS controller has a concrete desktop companion shape to target.

package/bin/codex-bridge.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+
+const args = process.argv.slice(2);
+const command = resolveCommand(args[0]);
+const commandArgs = command === "up" ? args : args.slice(1);
+
+switch (command) {
+  case "up":
+  case "start":
+    runServer(commandArgs);
+    break;
+  case "help":
+  case "--help":
+  case "-h":
+    printHelp();
+    break;
+  case "version":
+  case "--version":
+  case "-v":
+    printVersion();
+    break;
+  default:
+    console.error(`[codex-bridge] Unknown command: ${command}`);
+    printHelp(1);
+    break;
+}
+
+function runServer(args) {
+  const options = parseArgs(args);
+
+  if (options.port) {
+    process.env.PORT = String(options.port);
+  }
+
+  if (options.host) {
+    process.env.HOST = options.host;
+  }
+
+  import(new URL("../server.mjs", import.meta.url).href);
+}
+
+function parseArgs(args) {
+  const options = {
+    host: "",
+    port: ""
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const value = args[index];
+
+    if (value === "up" || value === "start") {
+      continue;
+    }
+
+    if (value === "--host" && args[index + 1]) {
+      options.host = args[index + 1];
+      index += 1;
+      continue;
+    }
+
+    if ((value === "--port" || value === "-p") && args[index + 1]) {
+      options.port = args[index + 1];
+      index += 1;
+    }
+  }
+
+  return options;
+}
+
+function resolveCommand(firstArg) {
+  if (!firstArg) {
+    return "up";
+  }
+
+  switch (firstArg) {
+    case "help":
+    case "--help":
+    case "-h":
+      return "help";
+    case "version":
+    case "--version":
+    case "-v":
+      return "version";
+    default:
+      return firstArg.startsWith("-") ? "up" : firstArg;
+  }
+}
+
+function printHelp(exitCode = 0) {
+  const lines = [
+    "Usage:",
+    "  codex-bridge up [--host 127.0.0.1] [--port 8787]",
+    "  codex-bridge start [--host 127.0.0.1] [--port 8787]",
+    "  codex-bridge help",
+    "  codex-bridge version"
+  ];
+
+  const stream = exitCode === 0 ? process.stdout : process.stderr;
+  stream.write(`${lines.join("\n")}\n`);
+  process.exit(exitCode);
+}
+
+function printVersion() {
+  process.stdout.write("0.1.0\n");
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@btatum5/codex-bridge",
+  "version": "0.1.0",
+  "description": "Codex desktop companion bridge for the iOS controller app.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "codex-bridge": "bin/codex-bridge.js"
+  },
+  "files": [
+    "bin",
+    "server.mjs",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "start": "node ./bin/codex-bridge.js up"
+  }
+}

package/server.mjs

@@ -0,0 +1,290 @@
+import { createServer } from "node:http";
+
+const args = process.argv.slice(2);
+const host = resolveHost(args);
+const port = Number(process.env.PORT || 8787);
+
+const state = {
+  status: "ready",
+  desktopName: "Windows 11 Codex",
+  sessionName: "Primary Session",
+  workspacePath: "C:\\Users\\bobby\\source\\project",
+  model: "gpt-5.4",
+  reasoningEffort: "high",
+  approvalMode: "confirm_sensitive",
+  fileAccess: "workspace_only",
+  allowShellCommands: true,
+  networkAccess: true,
+  syncDesktopTranscript: true,
+  activeTask: "Waiting for instructions from iPhone.",
+  lastAssistantReply: "Desktop companion online.",
+  lastMessage: null,
+  lastUpdatedAt: new Date().toISOString(),
+  pendingApprovals: [
+    {
+      id: "approval-write-workspace",
+      title: "Approve Workspace Write",
+      summary: "Codex wants permission to write changes into the active workspace.",
+      command: "apply_patch workspace files",
+      risk: "medium"
+    }
+  ],
+  openFiles: [
+    { path: "C:\\Users\\bobby\\source\\project\\README.md", status: "active" },
+    { path: "C:\\Users\\bobby\\source\\project\\src\\App.tsx", status: "modified" },
+    { path: "C:\\Users\\bobby\\source\\project\\package.json", status: "tracked" }
+  ],
+  terminalLines: [
+    line("info", "$ codex --session \"Primary Session\""),
+    line("info", "Desktop companion booted."),
+    line("success", "Waiting for remote controller input.")
+  ]
+};
+
+const server = createServer(async (req, res) => {
+  try {
+    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+
+    if (req.method === "GET" && url.pathname === "/health") {
+      return sendJson(res, 200, {
+        status: state.status,
+        message: "desktop companion online",
+        session: state.sessionName,
+        desktopName: state.desktopName,
+        workspacePath: state.workspacePath,
+        activeTask: state.activeTask,
+        pendingApprovals: state.pendingApprovals.length
+      });
+    }
+
+    if (req.method === "GET" && url.pathname === "/v1/companion/session") {
+      return sendJson(res, 200, snapshot());
+    }
+
+    if (req.method === "POST" && url.pathname === "/v1/companion/settings") {
+      const body = await readJson(req);
+      applySettings(body);
+      state.status = "ready";
+      state.activeTask = "Desktop settings updated from iPhone.";
+      state.lastAssistantReply = "Settings synced to the desktop companion.";
+      appendTerminal("success", "Applied configuration update from iPhone.");
+
+      return sendJson(res, 200, {
+        message: "desktop companion applied the settings update",
+        state: snapshot()
+      });
+    }
+
+    if (req.method === "POST" && url.pathname === "/v1/companion/actions") {
+      const body = await readJson(req);
+      const result = applyAction(body);
+
+      return sendJson(res, 200, {
+        message: result,
+        state: snapshot()
+      });
+    }
+
+    if (req.method === "POST" && url.pathname === "/v1/companion/chat") {
+      const body = await readJson(req);
+      applySettings(body);
+
+      state.status = "working";
+      state.lastMessage = body.message || null;
+      state.activeTask = body.message || "Executing desktop task from iPhone.";
+      state.lastAssistantReply = "Desktop companion synced the latest controller instruction.";
+      state.lastUpdatedAt = new Date().toISOString();
+
+      if (body.message) {
+        appendTerminal("info", `$ codex prompt "${body.message}"`);
+      }
+
+      maybeQueueApproval(body.message);
+
+      const reply = [
+        `Desktop target: ${state.desktopName}`,
+        `Workspace: ${state.workspacePath}`,
+        `Model: ${state.model}`,
+        `Reasoning: ${state.reasoningEffort}`,
+        `Approval: ${state.approvalMode}`,
+        `Files: ${state.fileAccess}`,
+        `Shell: ${state.allowShellCommands ? "enabled" : "disabled"}`,
+        `Network: ${state.networkAccess ? "enabled" : "disabled"}`,
+        `Pending approvals: ${state.pendingApprovals.length}`,
+        "",
+        `Received: ${body.message || "No message"}`
+      ].join("\n");
+
+      return sendJson(res, 200, {
+        reply,
+        session: state.sessionName,
+        message: "desktop companion synced the live controller state",
+        state: snapshot()
+      });
+    }
+
+    sendJson(res, 404, { error: "not_found" });
+  } catch (error) {
+    sendJson(res, 500, {
+      error: "internal_error",
+      detail: error instanceof Error ? error.message : String(error)
+    });
+  }
+});
+
+server.listen(port, host, () => {
+  console.log(`Codex desktop companion listening on http://${host}:${port}`);
+});
+
+function resolveHost(args) {
+  const fromEnv = process.env.HOST?.trim();
+  if (fromEnv) {
+    return fromEnv;
+  }
+
+  const hostFlagIndex = args.findIndex((value) => value === "--host");
+  if (hostFlagIndex >= 0 && args[hostFlagIndex + 1]) {
+    return args[hostFlagIndex + 1];
+  }
+
+  return "127.0.0.1";
+}
+
+function snapshot() {
+  return {
+    status: state.status,
+    desktopName: state.desktopName,
+    sessionName: state.sessionName,
+    workspacePath: state.workspacePath,
+    model: state.model,
+    reasoningEffort: state.reasoningEffort,
+    approvalMode: state.approvalMode,
+    fileAccess: state.fileAccess,
+    allowShellCommands: state.allowShellCommands,
+    networkAccess: state.networkAccess,
+    syncDesktopTranscript: state.syncDesktopTranscript,
+    activeTask: state.activeTask,
+    lastAssistantReply: state.lastAssistantReply,
+    lastUpdatedAt: state.lastUpdatedAt,
+    pendingApprovals: state.pendingApprovals,
+    openFiles: state.openFiles,
+    terminalLines: state.terminalLines
+  };
+}
+
+function applySettings(body) {
+  state.desktopName = body.desktopName || state.desktopName;
+  state.sessionName = body.sessionName || state.sessionName;
+  state.workspacePath = body.workspacePath || state.workspacePath;
+  state.model = body.model || state.model;
+  state.reasoningEffort = body.reasoningEffort || state.reasoningEffort;
+  state.approvalMode = body.approvalMode || state.approvalMode;
+  state.fileAccess = body.fileAccess || state.fileAccess;
+  state.allowShellCommands = body.allowShellCommands ?? state.allowShellCommands;
+  state.networkAccess = body.networkAccess ?? state.networkAccess;
+  state.syncDesktopTranscript = body.syncDesktopTranscript ?? state.syncDesktopTranscript;
+  state.lastUpdatedAt = new Date().toISOString();
+}
+
+function applyAction(body) {
+  const action = body.action || "refresh";
+  const approvalId = body.approvalId || null;
+
+  switch (action) {
+    case "interrupt":
+      state.status = "interrupted";
+      state.activeTask = "Execution interrupted from iPhone.";
+      state.lastAssistantReply = "Desktop task interrupted.";
+      appendTerminal("warning", "Interrupt received from iPhone.");
+      break;
+    case "resume":
+      state.status = "working";
+      state.activeTask = "Execution resumed from iPhone.";
+      state.lastAssistantReply = "Desktop task resumed.";
+      appendTerminal("success", "Resume received from iPhone.");
+      break;
+    case "approve":
+      removeApproval(approvalId);
+      state.status = "working";
+      state.activeTask = "Sensitive action approved from iPhone.";
+      state.lastAssistantReply = "Approval granted.";
+      appendTerminal("success", `Approved request ${approvalId || "unknown"}.`);
+      break;
+    case "reject":
+      removeApproval(approvalId);
+      state.status = "ready";
+      state.activeTask = "Sensitive action rejected from iPhone.";
+      state.lastAssistantReply = "Approval rejected.";
+      appendTerminal("warning", `Rejected request ${approvalId || "unknown"}.`);
+      break;
+    default:
+      state.lastAssistantReply = "Desktop state refreshed.";
+      appendTerminal("info", "State refresh requested from iPhone.");
+      break;
+  }
+
+  state.lastUpdatedAt = new Date().toISOString();
+  return `desktop companion applied action: ${action}`;
+}
+
+function maybeQueueApproval(message) {
+  if (!message) {
+    return;
+  }
+
+  const lowered = String(message).toLowerCase();
+  if (!/(delete|remove|install|registry|system32|powershell)/.test(lowered)) {
+    return;
+  }
+
+  const id = `approval-${Date.now()}`;
+  state.pendingApprovals.unshift({
+    id,
+    title: "Approve Sensitive Command",
+    summary: "The desktop session wants to run a potentially sensitive command and is waiting for phone approval.",
+    command: message,
+    risk: "high"
+  });
+  state.pendingApprovals = state.pendingApprovals.slice(0, 4);
+  appendTerminal("warning", `Queued approval ${id} for sensitive instruction.`);
+}
+
+function removeApproval(approvalId) {
+  if (!approvalId) {
+    return;
+  }
+  state.pendingApprovals = state.pendingApprovals.filter((approval) => approval.id !== approvalId);
+}
+
+function appendTerminal(level, text) {
+  state.terminalLines.unshift(line(level, text));
+  state.terminalLines = state.terminalLines.slice(0, 8);
+}
+
+function line(level, text) {
+  return {
+    id: `${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+    level,
+    text
+  };
+}
+
+function sendJson(res, statusCode, body) {
+  res.writeHead(statusCode, { "Content-Type": "application/json; charset=utf-8" });
+  res.end(JSON.stringify(body, null, 2));
+}
+
+async function readJson(req) {
+  const chunks = [];
+
+  for await (const chunk of req) {
+    chunks.push(chunk);
+  }
+
+  if (chunks.length === 0) {
+    return {};
+  }
+
+  const raw = Buffer.concat(chunks).toString("utf8");
+  return JSON.parse(raw);
+}