agent-anywhere-gateway 0.1.0

package/src/lib/local-discovery.js

@@ -0,0 +1,322 @@
+const { execFileSync } = require("node:child_process");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { DEFAULT_REASONING_EFFORT, MODEL_OPTIONS, MODE_OPTIONS, REASONING_EFFORT_OPTIONS } = require("./capabilities");
+const { isInside } = require("./path-policy");
+
+const DEFAULT_CODEX_DB = path.join(os.homedir(), ".codex", "state_5.sqlite");
+
+function shouldSkipDir(name) {
+  return [".git", "node_modules", ".venv", "venv", "dist", "build", ".next"].includes(name);
+}
+
+function discoverGitProjects(allowedRoots, { maxDepth = 2 } = {}) {
+  const projects = [];
+  const seen = new Set();
+
+  function visit(dir, depth) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    if (entries.some((entry) => entry.isDirectory() && entry.name === ".git")) {
+      const resolved = path.resolve(dir);
+      if (!seen.has(resolved)) {
+        seen.add(resolved);
+        projects.push({
+          name: path.basename(resolved),
+          path: resolved
+        });
+      }
+      return;
+    }
+
+    if (depth >= maxDepth) {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory() || shouldSkipDir(entry.name)) {
+        continue;
+      }
+      visit(path.join(dir, entry.name), depth + 1);
+    }
+  }
+
+  for (const root of allowedRoots) {
+    visit(root, 0);
+  }
+
+  return projects.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function normalizeModeFromSandbox(sandboxPolicy) {
+  try {
+    const parsed = JSON.parse(sandboxPolicy || "{}");
+    if (parsed.type === "danger-full-access") {
+      return "full-access";
+    }
+    if (parsed.type === "read-only") {
+      return "auto-review";
+    }
+  } catch {
+    return "default";
+  }
+  return "default";
+}
+
+function normalizeCodexThread(row) {
+  const model = MODEL_OPTIONS.includes(row.model) ? row.model : MODEL_OPTIONS[0];
+  const reasoning_effort = REASONING_EFFORT_OPTIONS.includes(row.reasoning_effort)
+    ? row.reasoning_effort
+    : DEFAULT_REASONING_EFFORT;
+  const mode = MODE_OPTIONS.includes(row.mode) ? row.mode : "default";
+  const updatedAt = row.updated_at_ms ? new Date(Number(row.updated_at_ms)).toISOString() : row.updated_at;
+  const createdAt = row.created_at_ms ? new Date(Number(row.created_at_ms)).toISOString() : updatedAt;
+
+  return {
+    runtime_session_id: row.id,
+    rollout_path: row.rollout_path || null,
+    title: row.title || row.first_user_message || row.id,
+    provider: "codex",
+    model,
+    reasoning_effort,
+    approval_policy: row.approval_mode === "never" ? "never" : "on-request",
+    mode,
+    status: "idle",
+    created_at: createdAt,
+    updated_at: updatedAt,
+    external_source: "codex",
+    external_updated_at: updatedAt
+  };
+}
+
+function parseSqliteJsonLines(raw) {
+  return String(raw || "")
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => JSON.parse(line));
+}
+
+function renderRolloutContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content
+    .map((item) => {
+      if (typeof item === "string") {
+        return item;
+      }
+      return item?.text || "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+
+function isFinalRolloutAgentMessage(payload = {}) {
+  const phase = String(payload.phase || payload.kind || "").toLowerCase();
+  if (!phase) {
+    return true;
+  }
+  return ["final", "answer", "assistant", "output"].includes(phase);
+}
+
+function readCodexRolloutTranscript(rolloutPath, { maxMessages = 200 } = {}) {
+  if (!rolloutPath || !fs.existsSync(rolloutPath) || !fs.statSync(rolloutPath).isFile()) {
+    return [];
+  }
+
+  const transcript = [];
+  const fallback = [];
+  const lines = fs.readFileSync(rolloutPath, "utf8").split(/\r?\n/).filter(Boolean);
+  for (const line of lines) {
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const timestamp = row.timestamp || null;
+    const payload = row.payload || {};
+    if (row.type === "event_msg" && payload.type === "user_message") {
+      transcript.push({ role: "user", text: String(payload.message || "").trim(), timestamp });
+    } else if (row.type === "event_msg" && payload.type === "agent_message") {
+      if (!isFinalRolloutAgentMessage(payload)) {
+        continue;
+      }
+      transcript.push({ role: "assistant", text: String(payload.message || "").trim(), timestamp });
+    } else if (row.type === "response_item" && payload.type === "message") {
+      const text = renderRolloutContent(payload.content).trim();
+      if (["user", "assistant"].includes(payload.role) && text && !text.includes("<environment_context>")) {
+        fallback.push({ role: payload.role, text, timestamp });
+      }
+    }
+  }
+
+  const messages = transcript.length ? transcript : fallback;
+  return messages.filter((message) => message.text).slice(-maxMessages);
+}
+
+function codexTranscriptToSessionHistory(sessionId, transcript) {
+  const turns = [];
+  const events = [];
+  let currentTurn = null;
+  let assistantParts = [];
+
+  function flushAssistant(timestamp) {
+    if (!currentTurn || !assistantParts.length) {
+      return;
+    }
+    events.push({
+      id: `${currentTurn.id}:assistant`,
+      session_id: sessionId,
+      turn_id: currentTurn.id,
+      type: "delta",
+      payload: { text: assistantParts.join("\n\n") },
+      created_at: timestamp || currentTurn.completed_at || currentTurn.started_at
+    });
+    assistantParts = [];
+  }
+
+  for (const message of transcript) {
+    if (message.role === "user") {
+      flushAssistant(message.timestamp);
+      const turn = {
+        id: `${sessionId}:external-turn-${turns.length + 1}`,
+        session_id: sessionId,
+        prompt: message.text,
+        status: "completed",
+        started_at: message.timestamp,
+        completed_at: message.timestamp,
+        error: null
+      };
+      turns.push(turn);
+      currentTurn = turn;
+    } else if (message.role === "assistant") {
+      if (!currentTurn) {
+        currentTurn = {
+          id: `${sessionId}:external-turn-${turns.length + 1}`,
+          session_id: sessionId,
+          prompt: "历史对话",
+          status: "completed",
+          started_at: message.timestamp,
+          completed_at: message.timestamp,
+          error: null
+        };
+        turns.push(currentTurn);
+      }
+      currentTurn.completed_at = message.timestamp || currentTurn.completed_at;
+      assistantParts.push(message.text);
+    }
+  }
+  flushAssistant(transcript.at(-1)?.timestamp || null);
+
+  return { turns, events };
+}
+
+function readCodexRolloutHistory(sessionId, rolloutPath) {
+  return codexTranscriptToSessionHistory(sessionId, readCodexRolloutTranscript(rolloutPath));
+}
+
+function discoverCodexThreadsForProject(projectPath, {
+  dbPath = process.env.CODEX_STATE_DB_PATH || DEFAULT_CODEX_DB,
+  allowedRoots = []
+} = {}) {
+  const resolvedProjectPath = path.resolve(projectPath);
+  if (allowedRoots.length && !allowedRoots.some((root) => isInside(resolvedProjectPath, root))) {
+    return [];
+  }
+  if (!fs.existsSync(dbPath)) {
+    return [];
+  }
+
+  let output;
+  try {
+    const escapedPath = resolvedProjectPath.replaceAll("'", "''");
+    output = execFileSync("sqlite3", [
+      "-json",
+      dbPath,
+      `select id, cwd, rollout_path, title, first_user_message, model, reasoning_effort, approval_mode,
+              sandbox_policy, created_at_ms, updated_at_ms, datetime(updated_at, 'unixepoch') as updated_at
+       from threads
+       where cwd = '${escapedPath}'
+         and archived = 0
+       order by coalesce(updated_at_ms, updated_at * 1000) desc
+       limit 100;`
+    ], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return [];
+  }
+
+  const rows = JSON.parse(output || "[]");
+  return rows.map((row) => normalizeCodexThread({
+    ...row,
+    mode: normalizeModeFromSandbox(row.sandbox_policy)
+  }));
+}
+
+function findCodexThreadById(threadId, {
+  dbPath = process.env.CODEX_STATE_DB_PATH || DEFAULT_CODEX_DB,
+  allowedRoots = []
+} = {}) {
+  const id = String(threadId || "").trim();
+  if (!id || !fs.existsSync(dbPath)) {
+    return null;
+  }
+
+  let output;
+  try {
+    const escapedId = id.replaceAll("'", "''");
+    output = execFileSync("sqlite3", [
+      "-json",
+      dbPath,
+      `select id, cwd, rollout_path, title, first_user_message, model, reasoning_effort, approval_mode,
+              sandbox_policy, created_at_ms, updated_at_ms, datetime(updated_at, 'unixepoch') as updated_at
+       from threads
+       where id = '${escapedId}'
+         and archived = 0
+       limit 1;`
+    ], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return null;
+  }
+
+  const row = JSON.parse(output || "[]")[0];
+  if (!row) {
+    return null;
+  }
+  const cwd = path.resolve(row.cwd || "");
+  if (allowedRoots.length && !allowedRoots.some((root) => isInside(cwd, root))) {
+    return null;
+  }
+  return normalizeCodexThread({
+    ...row,
+    mode: normalizeModeFromSandbox(row.sandbox_policy)
+  });
+}
+
+module.exports = {
+  DEFAULT_CODEX_DB,
+  codexTranscriptToSessionHistory,
+  discoverCodexThreadsForProject,
+  discoverGitProjects,
+  findCodexThreadById,
+  normalizeCodexThread,
+  normalizeModeFromSandbox,
+  parseSqliteJsonLines,
+  readCodexRolloutHistory,
+  readCodexRolloutTranscript
+};

package/src/lib/path-policy.js

@@ -0,0 +1 @@
+module.exports = require("../shared/path-policy");