@openai-lite/codex-feishu 0.1.0

package/src/lib/paths.js

@@ -0,0 +1,59 @@
+import os from "node:os";
+import path from "node:path";
+
+const WINDOWS_DEFAULT_RPC_ENDPOINT = "tcp://127.0.0.1:9765";
+
+export function getCodexHome() {
+  return process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+}
+
+export function getBridgeHome() {
+  return process.env.CODEX_FEISHU_HOME || path.join(os.homedir(), ".codex-feishu");
+}
+
+export function getCodexConfigPath() {
+  return path.join(getCodexHome(), "config.toml");
+}
+
+export function getPromptsDir() {
+  return path.join(getCodexHome(), "prompts");
+}
+
+export function getBridgeConfigPath() {
+  return path.join(getBridgeHome(), "config.json");
+}
+
+export function getBridgeStatePath() {
+  return path.join(getBridgeHome(), "state.json");
+}
+
+export function getRunDir() {
+  return path.join(getBridgeHome(), "run");
+}
+
+export function getBridgeSocketPath() {
+  return path.join(getRunDir(), "bridge.sock");
+}
+
+export function getDefaultBridgeRpcEndpoint() {
+  if (process.platform === "win32") {
+    return WINDOWS_DEFAULT_RPC_ENDPOINT;
+  }
+  return getBridgeSocketPath();
+}
+
+export function getBridgeRpcEndpoint() {
+  const fromEnv = process.env.CODEX_FEISHU_RPC_ENDPOINT;
+  if (typeof fromEnv === "string" && fromEnv.trim().length > 0) {
+    return fromEnv.trim();
+  }
+  return getDefaultBridgeRpcEndpoint();
+}
+
+export function getDaemonPidPath() {
+  return path.join(getRunDir(), "daemon.pid");
+}
+
+export function getDaemonLogPath() {
+  return path.join(getRunDir(), "daemon.log");
+}

package/src/lib/state_store.js

@@ -0,0 +1,146 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import { readTextIfExists, writeJson } from "./fs_utils.js";
+
+const STATE_VERSION = 1;
+const MAX_RECENT_EVENTS = 500;
+
+function nowTs() {
+  return Date.now();
+}
+
+function defaultState() {
+  const ts = nowTs();
+  return {
+    version: STATE_VERSION,
+    created_at: ts,
+    updated_at: ts,
+    active_thread_id: null,
+    pending_requests: {},
+    bindings: {},
+    pending_bind_codes: {},
+    last_qrcode_cwd: null,
+    thread_titles: {},
+    thread_buffers: {},
+    recent_events: [],
+  };
+}
+
+function normalizeObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+function normalizeArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function normalizeState(raw) {
+  const base = defaultState();
+  if (!raw || typeof raw !== "object") {
+    return base;
+  }
+  return {
+    ...base,
+    ...raw,
+    version: STATE_VERSION,
+    pending_requests: normalizeObject(raw.pending_requests),
+    bindings: normalizeObject(raw.bindings),
+    pending_bind_codes: normalizeObject(raw.pending_bind_codes),
+    last_qrcode_cwd: typeof raw.last_qrcode_cwd === "string" ? raw.last_qrcode_cwd : null,
+    thread_titles: normalizeObject(raw.thread_titles),
+    thread_buffers: normalizeObject(raw.thread_buffers),
+    recent_events: normalizeArray(raw.recent_events).slice(-MAX_RECENT_EVENTS),
+  };
+}
+
+function toPersistedState(state) {
+  return {
+    version: STATE_VERSION,
+    created_at: state.created_at ?? nowTs(),
+    updated_at: state.updated_at ?? nowTs(),
+    active_thread_id: state.active_thread_id ?? null,
+    bindings: normalizeObject(state.bindings),
+    pending_bind_codes: normalizeObject(state.pending_bind_codes),
+    last_qrcode_cwd: typeof state.last_qrcode_cwd === "string" ? state.last_qrcode_cwd : null,
+    thread_titles: normalizeObject(state.thread_titles),
+  };
+}
+
+export class StateStore {
+  constructor(statePath) {
+    this.statePath = statePath;
+    this.state = defaultState();
+    this.queue = Promise.resolve();
+  }
+
+  async load() {
+    const text = await readTextIfExists(this.statePath);
+    if (!text) {
+      this.state = defaultState();
+      return this.state;
+    }
+    try {
+      const raw = JSON.parse(text);
+      this.state = normalizeState(raw);
+    } catch (err) {
+      const backupPath = `${this.statePath}.corrupt-${Date.now()}`;
+      try {
+        await fs.rename(this.statePath, backupPath);
+      } catch {
+        // noop
+      }
+      this.state = defaultState();
+      pushRecentEvent(this.state, {
+        source: "daemon",
+        type: "state_recovered_from_corrupt_json",
+        backup_path: backupPath,
+        error: err?.message ?? String(err),
+      });
+      await this.save();
+    }
+    return this.state;
+  }
+
+  snapshot() {
+    return this.state;
+  }
+
+  async save() {
+    this.state.updated_at = nowTs();
+    await writeJson(this.statePath, toPersistedState(this.state));
+  }
+
+  async mutate(mutator) {
+    const run = async () => {
+      const maybeNext = await mutator(this.state);
+      if (maybeNext) {
+        this.state = normalizeState(maybeNext);
+      } else {
+        this.state = normalizeState(this.state);
+      }
+      await this.save();
+      return this.state;
+    };
+    const next = this.queue.then(run, run);
+    this.queue = next.then(
+      () => undefined,
+      () => undefined,
+    );
+    return next;
+  }
+}
+
+export function createBindCode() {
+  return `CF-${crypto.randomBytes(4).toString("hex").toUpperCase()}`;
+}
+
+export function pushRecentEvent(state, event) {
+  const next = {
+    ts: nowTs(),
+    ...event,
+  };
+  const recent = normalizeArray(state.recent_events);
+  recent.push(next);
+  state.recent_events = recent.slice(-MAX_RECENT_EVENTS);
+  return next;
+}

package/src/lib/uds_rpc.js

@@ -0,0 +1,195 @@
+import net from "node:net";
+import readline from "node:readline";
+
+function jsonrpcResult(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+
+function jsonrpcError(id, code, message, data) {
+  const payload = {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code,
+      message,
+    },
+  };
+  if (data !== undefined) {
+    payload.error.data = data;
+  }
+  return payload;
+}
+
+function writeJsonLine(socket, value) {
+  socket.write(`${JSON.stringify(value)}\n`);
+}
+
+export function parseRpcEndpoint(endpoint) {
+  if (typeof endpoint !== "string" || endpoint.length === 0) {
+    throw new Error("rpc endpoint is required");
+  }
+
+  if (endpoint.startsWith("tcp://")) {
+    const raw = endpoint.slice("tcp://".length);
+    const [host, portText] = raw.split(":");
+    const port = Number.parseInt(portText, 10);
+    if (!host || !Number.isFinite(port) || port <= 0) {
+      throw new Error(`invalid tcp rpc endpoint: ${endpoint}`);
+    }
+    return { kind: "tcp", host, port };
+  }
+
+  return { kind: "unix", path: endpoint };
+}
+
+export async function createJsonRpcServer({ endpoint, onRequest, onNotification }) {
+  const parsedEndpoint = parseRpcEndpoint(endpoint);
+  const server = net.createServer((socket) => {
+    const rl = readline.createInterface({ input: socket, crlfDelay: Infinity });
+
+    rl.on("line", async (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        return;
+      }
+
+      let msg;
+      try {
+        msg = JSON.parse(trimmed);
+      } catch (err) {
+        writeJsonLine(socket, jsonrpcError(null, -32700, "Parse error", String(err)));
+        return;
+      }
+
+      const isRequest = msg && typeof msg === "object" && "method" in msg && "id" in msg;
+      const isNotification = msg && typeof msg === "object" && "method" in msg && !("id" in msg);
+      if (!isRequest && !isNotification) {
+        writeJsonLine(socket, jsonrpcError(msg?.id ?? null, -32600, "Invalid Request"));
+        return;
+      }
+
+      if (isNotification) {
+        if (onNotification) {
+          try {
+            await onNotification(msg.method, msg.params ?? null, { socket });
+          } catch {
+            // Notifications do not carry response.
+          }
+        }
+        return;
+      }
+
+      try {
+        const result = await onRequest(msg.method, msg.params ?? null, {
+          id: msg.id,
+          socket,
+        });
+        writeJsonLine(socket, jsonrpcResult(msg.id, result ?? null));
+      } catch (err) {
+        writeJsonLine(socket, jsonrpcError(msg.id, -32000, err?.message ?? "Internal error"));
+      }
+    });
+  });
+
+  await new Promise((resolve, reject) => {
+    const onError = (err) => {
+      server.off("listening", onListening);
+      reject(err);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+
+    if (parsedEndpoint.kind === "unix") {
+      server.listen(parsedEndpoint.path);
+    } else {
+      server.listen(parsedEndpoint.port, parsedEndpoint.host);
+    }
+  });
+
+  return server;
+}
+
+export function callJsonRpc(endpoint, method, params = {}, options = {}) {
+  const parsedEndpoint = parseRpcEndpoint(endpoint);
+  const timeoutMs = options.timeoutMs ?? 5000;
+  const requestId = `${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
+
+  return new Promise((resolve, reject) => {
+    const socket =
+      parsedEndpoint.kind === "unix"
+        ? net.createConnection(parsedEndpoint.path)
+        : net.createConnection(parsedEndpoint.port, parsedEndpoint.host);
+    const rl = readline.createInterface({ input: socket, crlfDelay: Infinity });
+
+    let settled = false;
+    const timeout = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      socket.destroy();
+      reject(new Error(`rpc timeout after ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    function done(fn, value) {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      rl.close();
+      socket.destroy();
+      fn(value);
+    }
+
+    socket.on("connect", () => {
+      writeJsonLine(socket, {
+        jsonrpc: "2.0",
+        id: requestId,
+        method,
+        params,
+      });
+    });
+
+    socket.on("error", (err) => {
+      done(reject, err);
+    });
+    socket.on("close", () => {
+      if (!settled) {
+        done(reject, new Error("rpc connection closed"));
+      }
+    });
+
+    rl.on("error", (err) => {
+      done(reject, err);
+    });
+
+    rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        return;
+      }
+      let msg;
+      try {
+        msg = JSON.parse(trimmed);
+      } catch {
+        return;
+      }
+      if (msg?.id !== requestId) {
+        return;
+      }
+      if (msg.error) {
+        const err = new Error(msg.error.message || "rpc error");
+        err.code = msg.error.code;
+        err.data = msg.error.data;
+        done(reject, err);
+        return;
+      }
+      done(resolve, msg.result);
+    });
+  });
+}