androdex 1.1.3

package/src/codex-transport.js

@@ -0,0 +1,218 @@
+// FILE: codex-transport.js
+// Purpose: Abstracts the Codex-side transport so the bridge can talk to either a spawned app-server or an existing WebSocket endpoint.
+// Layer: CLI helper
+// Exports: createCodexTransport
+// Depends on: child_process, ws
+
+const { spawn } = require("child_process");
+const WebSocket = require("ws");
+
+function createCodexTransport({ endpoint = "", env = process.env, cwd = "" } = {}) {
+  if (endpoint) {
+    return createWebSocketTransport({ endpoint });
+  }
+
+  return createSpawnTransport({ env, cwd });
+}
+
+function createSpawnTransport({ env, cwd }) {
+  const launch = createCodexLaunchPlan({ env, cwd });
+  const codex = spawn(launch.command, launch.args, launch.options);
+
+  let stdoutBuffer = "";
+  let stderrBuffer = "";
+  let didRequestShutdown = false;
+  let didReportError = false;
+  const listeners = createListenerBag();
+
+  codex.on("error", (error) => {
+    didReportError = true;
+    listeners.emitError(error);
+  });
+  codex.on("close", (code, signal) => {
+    if (!didRequestShutdown && !didReportError && code !== 0) {
+      didReportError = true;
+      listeners.emitError(createCodexCloseError({
+        code,
+        signal,
+        stderrBuffer,
+        launchDescription: launch.description,
+      }));
+      return;
+    }
+
+    listeners.emitClose(code, signal);
+  });
+  // Keep stderr muted during normal operation, but preserve enough output to
+  // explain launch failures when the child exits before the bridge can use it.
+  codex.stderr.on("data", (chunk) => {
+    stderrBuffer = appendOutputBuffer(stderrBuffer, chunk.toString("utf8"));
+  });
+
+  codex.stdout.on("data", (chunk) => {
+    stdoutBuffer += chunk.toString("utf8");
+    const lines = stdoutBuffer.split("\n");
+    stdoutBuffer = lines.pop() || "";
+
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (trimmedLine) {
+        listeners.emitMessage(trimmedLine);
+      }
+    }
+  });
+
+  return {
+    mode: "spawn",
+    describe() {
+      return launch.description;
+    },
+    send(message) {
+      if (!codex.stdin.writable) {
+        return;
+      }
+
+      codex.stdin.write(message.endsWith("\n") ? message : `${message}\n`);
+    },
+    onMessage(handler) {
+      listeners.onMessage = handler;
+    },
+    onClose(handler) {
+      listeners.onClose = handler;
+    },
+    onError(handler) {
+      listeners.onError = handler;
+    },
+    shutdown() {
+      didRequestShutdown = true;
+      shutdownCodexProcess(codex);
+    },
+  };
+}
+
+// Builds a single, platform-aware launch path so the bridge never "guesses"
+// between multiple commands and accidentally starts duplicate runtimes.
+function createCodexLaunchPlan({ env, cwd }) {
+  const sharedOptions = {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...env },
+    cwd: cwd || process.cwd(),
+  };
+
+  if (process.platform === "win32") {
+    return {
+      command: env.ComSpec || "cmd.exe",
+      args: ["/d", "/c", "codex app-server"],
+      options: {
+        ...sharedOptions,
+        windowsHide: true,
+      },
+      description: "`cmd.exe /d /c codex app-server`",
+    };
+  }
+
+  return {
+    command: "codex",
+    args: ["app-server"],
+    options: sharedOptions,
+    description: "`codex app-server`",
+  };
+}
+
+// Stops the exact process tree we launched on Windows so the shell wrapper
+// does not leave a child Codex process running in the background.
+function shutdownCodexProcess(codex) {
+  if (codex.killed || codex.exitCode !== null) {
+    return;
+  }
+
+  if (process.platform === "win32" && codex.pid) {
+    const killer = spawn("taskkill", ["/pid", String(codex.pid), "/t", "/f"], {
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    killer.on("error", () => {
+      codex.kill();
+    });
+    return;
+  }
+
+  codex.kill("SIGTERM");
+}
+
+function createCodexCloseError({ code, signal, stderrBuffer, launchDescription }) {
+  const details = stderrBuffer.trim();
+  const reason = details || `Process exited with code ${code}${signal ? ` (signal: ${signal})` : ""}.`;
+  return new Error(`Codex launcher ${launchDescription} failed: ${reason}`);
+}
+
+function appendOutputBuffer(buffer, chunk) {
+  const next = `${buffer}${chunk}`;
+  return next.slice(-4_096);
+}
+
+function createWebSocketTransport({ endpoint }) {
+  const socket = new WebSocket(endpoint);
+  const listeners = createListenerBag();
+
+  socket.on("message", (chunk) => {
+    const message = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    if (message.trim()) {
+      listeners.emitMessage(message);
+    }
+  });
+
+  socket.on("close", (code, reason) => {
+    const safeReason = reason ? reason.toString("utf8") : "no reason";
+    listeners.emitClose(code, safeReason);
+  });
+
+  socket.on("error", (error) => listeners.emitError(error));
+
+  return {
+    mode: "websocket",
+    describe() {
+      return endpoint;
+    },
+    send(message) {
+      if (socket.readyState !== WebSocket.OPEN) {
+        return;
+      }
+
+      socket.send(message);
+    },
+    onMessage(handler) {
+      listeners.onMessage = handler;
+    },
+    onClose(handler) {
+      listeners.onClose = handler;
+    },
+    onError(handler) {
+      listeners.onError = handler;
+    },
+    shutdown() {
+      if (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING) {
+        socket.close();
+      }
+    },
+  };
+}
+
+function createListenerBag() {
+  return {
+    onMessage: null,
+    onClose: null,
+    onError: null,
+    emitMessage(message) {
+      this.onMessage?.(message);
+    },
+    emitClose(...args) {
+      this.onClose?.(...args);
+    },
+    emitError(error) {
+      this.onError?.(error);
+    },
+  };
+}
+
+module.exports = { createCodexTransport };

package/src/daemon-control.js

@@ -0,0 +1,191 @@
+// FILE: daemon-control.js
+// Purpose: CLI-facing helpers for starting, stopping, and talking to the background daemon.
+// Layer: CLI helper
+// Exports: daemon control actions used by the androdex CLI.
+// Depends on: child_process, http, path, ./daemon-store
+
+const fs = require("fs");
+const http = require("http");
+const path = require("path");
+const { spawn } = require("child_process");
+const {
+  clearDaemonControlState,
+  getDaemonLogPath,
+  readDaemonControlState,
+} = require("./daemon-store");
+
+const CONTROL_HOST = "127.0.0.1";
+const DAEMON_START_TIMEOUT_MS = 8_000;
+
+async function startBridge() {
+  const response = await activateWorkspace(process.cwd());
+  return response.status;
+}
+
+async function activateWorkspace(cwd) {
+  await ensureDaemonRunning();
+  return requestDaemon("POST", "/activate", { cwd });
+}
+
+async function createPairing() {
+  await ensureDaemonRunning();
+  return requestDaemon("POST", "/pair", {});
+}
+
+async function getDaemonStatus() {
+  const control = readDaemonControlState();
+  if (!control) {
+    return {
+      ok: true,
+      status: {
+        relayStatus: "stopped",
+        workspaceActive: false,
+        currentCwd: null,
+      },
+    };
+  }
+
+  try {
+    return await requestDaemon("GET", "/status");
+  } catch {
+    clearDaemonControlState();
+    return {
+      ok: true,
+      status: {
+        relayStatus: "stopped",
+        workspaceActive: false,
+        currentCwd: null,
+      },
+    };
+  }
+}
+
+async function startDaemonCli() {
+  await ensureDaemonRunning();
+  return getDaemonStatus();
+}
+
+async function stopDaemonCli() {
+  const control = readDaemonControlState();
+  if (!control) {
+    return {
+      ok: true,
+      status: {
+        relayStatus: "stopped",
+      },
+    };
+  }
+
+  try {
+    return await requestDaemon("POST", "/stop", {});
+  } finally {
+    clearDaemonControlState();
+  }
+}
+
+async function ensureDaemonRunning() {
+  const existingState = readDaemonControlState();
+  if (existingState) {
+    try {
+      await requestDaemon("GET", "/status");
+      return;
+    } catch {
+      clearDaemonControlState();
+    }
+  }
+
+  const daemonScriptPath = path.join(__dirname, "..", "bin", "androdex.js");
+  const logPath = getDaemonLogPath();
+  const stdoutFd = fs.openSync(logPath, "a");
+  const stderrFd = fs.openSync(logPath, "a");
+  const child = spawn(
+    process.execPath,
+    [daemonScriptPath, "__daemon-run"],
+    {
+      detached: true,
+      stdio: ["ignore", stdoutFd, stderrFd],
+      windowsHide: true,
+    }
+  );
+  child.unref();
+  fs.closeSync(stdoutFd);
+  fs.closeSync(stderrFd);
+
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < DAEMON_START_TIMEOUT_MS) {
+    const controlState = readDaemonControlState();
+    if (controlState) {
+      try {
+        await requestDaemon("GET", "/status");
+        return;
+      } catch {
+        // Keep polling until the daemon finishes booting or times out.
+      }
+    }
+    await sleep(200);
+  }
+
+  throw new Error("Timed out while starting the Androdex daemon.");
+}
+
+function requestDaemon(method, requestPath, body = null) {
+  const controlState = readDaemonControlState();
+  if (!controlState?.port || !controlState?.token) {
+    return Promise.reject(new Error("The Androdex daemon is not running."));
+  }
+
+  return new Promise((resolve, reject) => {
+    const payload = body == null ? "" : JSON.stringify(body);
+    const request = http.request(
+      {
+        hostname: CONTROL_HOST,
+        port: controlState.port,
+        path: requestPath,
+        method,
+        headers: {
+          "x-androdex-token": controlState.token,
+          "content-type": "application/json; charset=utf-8",
+          "content-length": Buffer.byteLength(payload),
+        },
+      },
+      (response) => {
+        let raw = "";
+        response.setEncoding("utf8");
+        response.on("data", (chunk) => {
+          raw += chunk;
+        });
+        response.on("end", () => {
+          try {
+            const parsed = raw.trim() ? JSON.parse(raw) : {};
+            if (response.statusCode >= 400) {
+              reject(new Error(parsed.error || `Daemon request failed with status ${response.statusCode}.`));
+              return;
+            }
+            resolve(parsed);
+          } catch (error) {
+            reject(error);
+          }
+        });
+      }
+    );
+
+    request.on("error", reject);
+    if (payload) {
+      request.write(payload);
+    }
+    request.end();
+  });
+}
+
+function sleep(timeoutMs) {
+  return new Promise((resolve) => setTimeout(resolve, timeoutMs));
+}
+
+module.exports = {
+  activateWorkspace,
+  createPairing,
+  getDaemonStatus,
+  startBridge,
+  startDaemonCli,
+  stopDaemonCli,
+};

package/src/daemon-runtime.js

@@ -0,0 +1,135 @@
+// FILE: daemon-runtime.js
+// Purpose: Runs the persistent host daemon and exposes a localhost control API for CLI commands.
+// Layer: CLI service
+// Exports: runDaemonProcess
+// Depends on: http, ./daemon-store, ./host-runtime
+
+const http = require("http");
+const { clearDaemonControlState, createDaemonControlToken, writeDaemonControlState } = require("./daemon-store");
+const { HostRuntime } = require("./host-runtime");
+
+async function runDaemonProcess() {
+  const runtime = new HostRuntime();
+  const controlToken = createDaemonControlToken();
+  let isShuttingDown = false;
+
+  runtime.start();
+
+  const server = http.createServer(async (req, res) => {
+    try {
+      if (!authorizeRequest(req, controlToken)) {
+        writeJson(res, 401, { error: "Unauthorized" });
+        return;
+      }
+
+      const url = new URL(req.url || "/", "http://127.0.0.1");
+      if (req.method === "GET" && url.pathname === "/status") {
+        writeJson(res, 200, { ok: true, status: runtime.getStatus() });
+        return;
+      }
+
+      if (req.method === "POST" && url.pathname === "/activate") {
+        const body = await readJsonBody(req);
+        const status = await runtime.activateWorkspace({ cwd: body?.cwd });
+        writeJson(res, 200, { ok: true, status });
+        return;
+      }
+
+      if (req.method === "POST" && url.pathname === "/pair") {
+        writeJson(res, 200, {
+          ok: true,
+          pairingPayload: runtime.getPairingPayload(),
+          status: runtime.getStatus(),
+        });
+        return;
+      }
+
+      if (req.method === "POST" && url.pathname === "/stop") {
+        writeJson(res, 200, { ok: true });
+        setTimeout(() => {
+          void shutdown();
+        }, 25);
+        return;
+      }
+
+      writeJson(res, 404, { error: "Not found" });
+    } catch (error) {
+      writeJson(res, 500, { error: error.message || "Daemon request failed." });
+    }
+  });
+
+  server.on("clientError", (error, socket) => {
+    socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+    if (error?.message) {
+      console.error(`[androdex] Daemon control client error: ${error.message}`);
+    }
+  });
+
+  await new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", resolve);
+  });
+
+  const address = server.address();
+  writeDaemonControlState({
+    pid: process.pid,
+    port: typeof address === "object" && address ? address.port : 0,
+    token: controlToken,
+    startedAt: Date.now(),
+  });
+
+  async function shutdown() {
+    if (isShuttingDown) {
+      return;
+    }
+    isShuttingDown = true;
+    clearDaemonControlState();
+    await runtime.stop();
+    await new Promise((resolve) => server.close(resolve));
+    process.exit(0);
+  }
+
+  process.on("SIGINT", () => {
+    void shutdown();
+  });
+  process.on("SIGTERM", () => {
+    void shutdown();
+  });
+}
+
+function authorizeRequest(req, controlToken) {
+  return req.headers["x-androdex-token"] === controlToken;
+}
+
+function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    let raw = "";
+    req.setEncoding("utf8");
+    req.on("data", (chunk) => {
+      raw += chunk;
+      if (raw.length > 1024 * 1024) {
+        reject(new Error("Request body too large."));
+      }
+    });
+    req.on("end", () => {
+      if (!raw.trim()) {
+        resolve({});
+        return;
+      }
+      try {
+        resolve(JSON.parse(raw));
+      } catch {
+        reject(new Error("Invalid JSON request body."));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+function writeJson(res, statusCode, body) {
+  res.writeHead(statusCode, { "content-type": "application/json; charset=utf-8" });
+  res.end(JSON.stringify(body));
+}
+
+module.exports = {
+  runDaemonProcess,
+};

package/src/daemon-store.js

@@ -0,0 +1,92 @@
+// FILE: daemon-store.js
+// Purpose: Persists daemon control metadata and stable runtime preferences under ~/.androdex.
+// Layer: CLI helper
+// Exports: read/write helpers for daemon control and runtime state.
+// Depends on: fs, os, path, crypto
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { randomBytes } = require("crypto");
+
+const STORE_DIR = path.join(os.homedir(), ".androdex");
+const CONTROL_FILE = path.join(STORE_DIR, "daemon-control.json");
+const RUNTIME_FILE = path.join(STORE_DIR, "daemon-runtime.json");
+const LOG_FILE = path.join(STORE_DIR, "daemon.log");
+
+function ensureStoreDir() {
+  fs.mkdirSync(STORE_DIR, { recursive: true });
+}
+
+function readDaemonControlState() {
+  return readJsonFile(CONTROL_FILE);
+}
+
+function writeDaemonControlState(state) {
+  writeJsonFile(CONTROL_FILE, state);
+}
+
+function clearDaemonControlState() {
+  try {
+    fs.rmSync(CONTROL_FILE, { force: true });
+  } catch {
+    // Ignore cleanup failures for stale daemon metadata.
+  }
+}
+
+function readDaemonRuntimeState() {
+  const runtimeState = readJsonFile(RUNTIME_FILE);
+  return {
+    lastActiveCwd: normalizeNonEmptyString(runtimeState?.lastActiveCwd),
+  };
+}
+
+function writeDaemonRuntimeState(state) {
+  writeJsonFile(RUNTIME_FILE, {
+    lastActiveCwd: normalizeNonEmptyString(state?.lastActiveCwd),
+  });
+}
+
+function createDaemonControlToken() {
+  return randomBytes(24).toString("hex");
+}
+
+function getDaemonLogPath() {
+  ensureStoreDir();
+  return LOG_FILE;
+}
+
+function readJsonFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeJsonFile(filePath, value) {
+  ensureStoreDir();
+  fs.writeFileSync(filePath, JSON.stringify(value, null, 2), { mode: 0o600 });
+  try {
+    fs.chmodSync(filePath, 0o600);
+  } catch {
+    // Best effort only.
+  }
+}
+
+function normalizeNonEmptyString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+module.exports = {
+  clearDaemonControlState,
+  createDaemonControlToken,
+  getDaemonLogPath,
+  readDaemonControlState,
+  readDaemonRuntimeState,
+  writeDaemonControlState,
+  writeDaemonRuntimeState,
+};