@c0sc0s/codex-tags 0.5.0

package/runtime/src/cdp-client.mjs

@@ -0,0 +1,100 @@
+export class CdpClient {
+  static async connect(target) {
+    const socket = new WebSocket(target.webSocketDebuggerUrl);
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        socket.close();
+        reject(new Error(`CDP websocket open timed out for target ${target.id}`));
+      }, 3000);
+      socket.addEventListener("open", () => {
+        clearTimeout(timer);
+        resolve();
+      }, { once: true });
+      socket.addEventListener("error", () => {
+        clearTimeout(timer);
+        reject(new Error(`CDP websocket open failed for target ${target.id}`));
+      }, { once: true });
+    });
+    return new CdpClient(target, socket);
+  }
+
+  constructor(target, socket) {
+    this.target = target;
+    this.socket = socket;
+    this.nextCommandId = 1;
+    this.pendingCommands = new Map();
+    this.bindingHandlers = new Map();
+    socket.addEventListener("message", (event) => this.#handleMessage(event.data));
+    socket.addEventListener("close", () => this.#rejectPending(new Error(`CDP target ${target.id} disconnected`)));
+    socket.addEventListener("error", () => this.#rejectPending(new Error(`CDP target ${target.id} failed`)));
+  }
+
+  get connected() {
+    return this.socket.readyState === WebSocket.OPEN;
+  }
+
+  async command(method, params = {}, timeoutMs = 15_000) {
+    if (!this.connected) throw new Error(`CDP target ${this.target.id} is not connected`);
+    const id = this.nextCommandId;
+    this.nextCommandId += 1;
+    return await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingCommands.delete(id);
+        reject(new Error(`${method} timed out for target ${this.target.id}`));
+      }, timeoutMs);
+      this.pendingCommands.set(id, { resolve, reject, timer, method });
+      this.socket.send(JSON.stringify({ id, method, params }));
+    });
+  }
+
+  async evaluate(expression, executionContextId) {
+    const params = { expression, awaitPromise: true, returnByValue: true };
+    if (Number.isSafeInteger(executionContextId)) params.contextId = executionContextId;
+    const response = await this.command("Runtime.evaluate", params);
+    if (response?.exceptionDetails) {
+      const description = response.exceptionDetails.exception?.description ?? response.exceptionDetails.text;
+      throw new Error(description ?? `Runtime.evaluate failed for target ${this.target.id}`);
+    }
+    return response?.result?.value;
+  }
+
+  async addBinding(name, handler) {
+    this.bindingHandlers.set(name, handler);
+    await this.command("Runtime.enable");
+    await this.command("Runtime.addBinding", { name });
+  }
+
+  close() {
+    this.socket.close();
+  }
+
+  #handleMessage(rawMessage) {
+    let message;
+    try {
+      message = JSON.parse(rawMessage);
+    } catch {
+      return;
+    }
+    if (message.id !== undefined) {
+      const pending = this.pendingCommands.get(message.id);
+      if (!pending) return;
+      this.pendingCommands.delete(message.id);
+      clearTimeout(pending.timer);
+      if (message.error) pending.reject(new Error(`${pending.method} failed: ${message.error.message ?? "unknown CDP error"}`));
+      else pending.resolve(message.result);
+      return;
+    }
+    if (message.method !== "Runtime.bindingCalled") return;
+    const handler = this.bindingHandlers.get(message.params?.name);
+    if (!handler) return;
+    Promise.resolve(handler(message.params)).catch(() => {});
+  }
+
+  #rejectPending(error) {
+    for (const { reject, timer } of this.pendingCommands.values()) {
+      clearTimeout(timer);
+      reject(error);
+    }
+    this.pendingCommands.clear();
+  }
+}

package/runtime/src/codex-process.mjs

@@ -0,0 +1,115 @@
+import { execFile, execFileSync, spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+const defaultRun = promisify(execFile);
+const wait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+
+export function findCodexApp() {
+  for (const appPath of ["/Applications/Codex.app", join(homedir(), "Applications", "Codex.app"), "/Applications/ChatGPT.app"]) {
+    try {
+      const plist = join(appPath, "Contents", "Info.plist");
+      const read = (key) => execFileSync("/usr/bin/plutil", ["-extract", key, "raw", plist], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 2000 }).trim();
+      if (read("CFBundleIdentifier") !== "com.openai.codex") continue;
+      const executable = read("CFBundleExecutable");
+      if (!/^[A-Za-z0-9_-]+$/u.test(executable)) continue;
+      return { appPath, executable: join(appPath, "Contents", "MacOS", executable) };
+    } catch { /* Uninstalled or unrelated applications are not candidates. */ }
+  }
+  return null;
+}
+
+export class CodexProcess {
+  constructor(options = {}) {
+    this.port = options.port ?? 9341;
+    const detected = options.appPath ? null : findCodexApp();
+    this.appPath = options.appPath ?? detected?.appPath ?? "/Applications/Codex.app";
+    this.executable = options.executable ?? detected?.executable ?? join(this.appPath, "Contents", "MacOS", "ChatGPT");
+    this.run = options.run ?? defaultRun;
+    this.spawn = options.spawn ?? spawn;
+  }
+
+  async isRunning() {
+    const { stdout } = await this.run("/bin/ps", ["-axo", "command="]);
+    return stdout.split("\n").some((command) => {
+      const value = command.trim();
+      return value === this.executable || value.startsWith(`${this.executable} `);
+    });
+  }
+
+  async hasCdpLaunchArguments() {
+    const { stdout } = await this.run("/bin/ps", ["-axo", "command="]);
+    return stdout.split("\n").some((command) => {
+      const value = command.trim();
+      const isCodex = value === this.executable || value.startsWith(`${this.executable} `);
+      return isCodex && value.includes(`--remote-debugging-port=${this.port}`);
+    });
+  }
+
+  async ownsCdpEndpoint() {
+    let stdout;
+    try {
+      ({ stdout } = await this.run("/usr/sbin/lsof", [
+        "-nP", `-iTCP:${this.port}`, "-sTCP:LISTEN", "-t",
+      ]));
+    } catch (error) {
+      if (error.code === 1) return false;
+      throw error;
+    }
+
+    for (const value of stdout.trim().split(/\s+/u)) {
+      let pid = Number(value);
+      for (let depth = 0; Number.isSafeInteger(pid) && pid > 0 && depth < 8; depth += 1) {
+        try {
+          const [{ stdout: command }, { stdout: parent }] = await Promise.all([
+            this.run("/bin/ps", ["-p", String(pid), "-o", "command="]),
+            this.run("/bin/ps", ["-p", String(pid), "-o", "ppid="]),
+          ]);
+          if (command.trim() === this.executable || command.trim().startsWith(`${this.executable} `)) return true;
+          pid = Number(parent.trim());
+        } catch {
+          break;
+        }
+      }
+    }
+    return false;
+  }
+
+  async portIsListening() {
+    try {
+      const { stdout } = await this.run("/usr/sbin/lsof", ["-nP", `-iTCP:${this.port}`, "-sTCP:LISTEN", "-t"]);
+      return stdout.trim().length > 0;
+    } catch (error) {
+      if (error.code === 1) return false;
+      throw error;
+    }
+  }
+
+  async cdpIsReady(discoverTargets) {
+    try {
+      return await this.ownsCdpEndpoint() && (await discoverTargets()).length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  async waitForCdp(discoverTargets, timeoutMs = 30_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (await this.cdpIsReady(discoverTargets)) return;
+      await wait(250);
+    }
+    throw new Error("等待 Codex CDP 端口超时");
+  }
+
+  async launchWithCdp(discoverTargets) {
+    if (await this.isRunning()) throw new Error("Codex is already running without Tags. Quit Codex completely, then open Codex Tags.app. The running app was not restarted.");
+    const child = this.spawn(this.executable, [
+      "--remote-debugging-address=127.0.0.1",
+      `--remote-debugging-port=${this.port}`,
+    ], { detached: true, stdio: "ignore" });
+    child.unref();
+    await this.waitForCdp(discoverTargets);
+  }
+}

package/runtime/src/content-index.mjs

@@ -0,0 +1,138 @@
+import { createReadStream } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+
+const SESSION_ROOTS = [
+  join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "sessions"),
+  join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "archived_sessions"),
+];
+const TEXT_FIELD = '"text":"';
+const MAX_FIELD_LENGTH = 24_000;
+const MAX_THREAD_LENGTH = 500_000;
+const SESSION_FILE_DISCOVERY_TTL_MS = 30_000;
+let sessionFiles = null;
+let sessionFilesScannedAt = 0;
+
+export async function discoverSessionFiles(force = false) {
+  if (!force && sessionFiles && Date.now() - sessionFilesScannedAt < SESSION_FILE_DISCOVERY_TTL_MS) return sessionFiles;
+  const files = new Map();
+  for (const root of SESSION_ROOTS) {
+    let paths = [];
+    try { paths = await readdir(root, { recursive: true }); } catch { continue; }
+    for (const relativePath of paths) {
+      if (!relativePath.endsWith(".jsonl")) continue;
+      const match = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i.exec(basename(relativePath));
+      if (match) files.set(match[1], join(root, relativePath));
+    }
+  }
+  sessionFiles = files;
+  sessionFilesScannedAt = Date.now();
+  return files;
+}
+
+function decodeJsonString(value) {
+  try { return JSON.parse(`"${value}"`); } catch {
+    return value.replace(/\\n/g, " ").replace(/\\r/g, " ").replace(/\\t/g, " ").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+}
+
+export async function extractConversationText(path) {
+  const chunks = [];
+  let totalLength = 0;
+  let prefix = "";
+  let eligible = false;
+  let role = "";
+  let inText = false;
+  let escaped = false;
+  let rawText = "";
+  let fieldTruncated = false;
+  let patternCarry = "";
+
+  const resetLine = () => {
+    prefix = "";
+    eligible = false;
+    role = "";
+    inText = false;
+    escaped = false;
+    rawText = "";
+    fieldTruncated = false;
+    patternCarry = "";
+  };
+
+  const finishText = () => {
+    let text = decodeJsonString(rawText).replace(/\s+/gu, " ").trim();
+    const requestMarker = text.lastIndexOf("## My request:");
+    if (requestMarker !== -1) text = text.slice(requestMarker + "## My request:".length).trim();
+    if (text) {
+      const clipped = text.slice(0, MAX_THREAD_LENGTH - totalLength);
+      chunks.push({ role, text: clipped + (fieldTruncated ? "…" : "") });
+      totalLength += clipped.length;
+    }
+    inText = false;
+    escaped = false;
+    rawText = "";
+    fieldTruncated = false;
+  };
+
+  const scanEligibleSegment = (segment) => {
+    let offset = 0;
+    while (offset < segment.length && totalLength < MAX_THREAD_LENGTH) {
+      if (!inText) {
+        const searchable = patternCarry + segment.slice(offset);
+        const fieldIndex = searchable.indexOf(TEXT_FIELD);
+        if (fieldIndex === -1) {
+          patternCarry = searchable.slice(-(TEXT_FIELD.length - 1));
+          return;
+        }
+        offset += Math.max(0, fieldIndex + TEXT_FIELD.length - patternCarry.length);
+        patternCarry = "";
+        inText = true;
+      }
+
+      let cursor = offset;
+      for (; cursor < segment.length; cursor += 1) {
+        const character = segment[cursor];
+        if (escaped) {
+          if (!fieldTruncated) rawText += character;
+          escaped = false;
+          continue;
+        }
+        if (character === "\\") {
+          if (!fieldTruncated) rawText += character;
+          escaped = true;
+          continue;
+        }
+        if (character === '"') {
+          finishText();
+          offset = cursor + 1;
+          break;
+        }
+        if (!fieldTruncated) {
+          rawText += character;
+          if (rawText.length >= MAX_FIELD_LENGTH) fieldTruncated = true;
+        }
+      }
+      if (cursor >= segment.length) return;
+    }
+  };
+
+  for await (const block of createReadStream(path, { encoding: "utf8", highWaterMark: 64 * 1024 })) {
+    let blockOffset = 0;
+    while (blockOffset < block.length) {
+      const newline = block.indexOf("\n", blockOffset);
+      const lineEnds = newline !== -1;
+      const segment = block.slice(blockOffset, lineEnds ? newline : block.length);
+      if (!eligible) {
+        if (prefix.length < 4096) prefix += segment.slice(0, 4096 - prefix.length);
+        if (prefix.includes('"type":"UserMessage"')) { eligible = true; role = "你"; }
+        else if (prefix.includes('"type":"response_item"') && prefix.includes('"role":"user"')) { eligible = true; role = "你"; }
+        else if (prefix.includes('"type":"response_item"') && prefix.includes('"role":"assistant"')) { eligible = true; role = "Codex"; }
+      }
+      if (eligible) scanEligibleSegment(segment);
+      if (lineEnds) resetLine();
+      blockOffset = lineEnds ? newline + 1 : block.length;
+    }
+  }
+  return chunks;
+}

package/runtime/src/controller-router.mjs

@@ -0,0 +1,84 @@
+import { createRuntimeMessage, parseRuntimeMessage, RuntimeMessageType } from "./protocol.mjs";
+
+export class ControllerRouter {
+  constructor(options) {
+    this.searchIndex = options.searchIndex;
+    this.settingsRepository = options.settingsRepository;
+    this.getSettings = options.getSettings;
+    this.onSettingsChanged = options.onSettingsChanged;
+    this.waitForIndex = options.waitForIndex;
+    this.getIndexStatus = options.getIndexStatus;
+    this.send = options.send;
+    this.openSession = options.openSession;
+    this.latestSearchRequestIds = new Map();
+    this.handlers = new Map([
+      [RuntimeMessageType.settingsGet, this.handleSettingsGet.bind(this)],
+      [RuntimeMessageType.settingsUpdate, this.handleSettingsUpdate.bind(this)],
+      [RuntimeMessageType.searchRequest, this.handleSearchRequest.bind(this)],
+      [RuntimeMessageType.navigationOpen, async (_client, request) => {
+        const threadId = typeof request.payload.threadId === "string" ? request.payload.threadId.replace(/^local:/u, "") : "";
+        if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(threadId)) await this.openSession?.(threadId);
+      }],
+    ]);
+  }
+
+  async handle(client, params) {
+    const parsed = parseRuntimeMessage(params.payload);
+    if (!parsed.ok) return false;
+    const handler = this.handlers.get(parsed.message.type);
+    if (!handler) return false;
+    await handler(client, parsed.message, params.executionContextId);
+    return true;
+  }
+
+  forgetTarget(targetId) {
+    this.latestSearchRequestIds.delete(targetId);
+  }
+
+  async sendSettingsSnapshot(client, executionContextId) {
+    await this.send(
+      client,
+      createRuntimeMessage(RuntimeMessageType.settingsSnapshot, { settings: this.getSettings() }),
+      executionContextId,
+    );
+  }
+
+  async handleSettingsGet(client, _request, executionContextId) {
+    await this.sendSettingsSnapshot(client, executionContextId);
+  }
+
+  async handleSettingsUpdate(client, request, executionContextId) {
+    try {
+      if (!Array.isArray(request.payload.tags) || request.payload.tags.length > 32) throw new Error("Invalid tag definitions");
+      const result = await this.settingsRepository.write(request.payload.tags);
+      await this.onSettingsChanged(result.settings);
+    } catch {
+      await this.sendSettingsSnapshot(client, executionContextId);
+      await this.send(client, createRuntimeMessage(RuntimeMessageType.settingsError, {}), executionContextId);
+    }
+  }
+
+  async handleSearchRequest(client, request, executionContextId) {
+    if (!Number.isSafeInteger(request.requestId)) return;
+    const targetId = client.target.id;
+    this.latestSearchRequestIds.set(targetId, request.requestId);
+    await this.waitForIndex();
+    if (this.latestSearchRequestIds.get(targetId) !== request.requestId) return;
+
+    try {
+      const items = this.searchIndex.search(request.payload);
+      await this.send(client, createRuntimeMessage(RuntimeMessageType.searchResult, {
+        query: request.payload.query,
+        items,
+        indexStatus: this.getIndexStatus(),
+      }, request.requestId), executionContextId);
+    } catch (error) {
+      await this.send(client, createRuntimeMessage(RuntimeMessageType.searchResult, {
+        query: request.payload.query,
+        items: [],
+        indexStatus: this.getIndexStatus(),
+        error: error instanceof Error ? error.message : "Search failed",
+      }, request.requestId), executionContextId).catch(() => {});
+    }
+  }
+}

package/runtime/src/controller-state.mjs

@@ -0,0 +1,17 @@
+export function parseControllerPid(raw) {
+  const trimmed = typeof raw === "string" ? raw.trim() : "";
+  if (!trimmed) return null;
+  let value;
+  try {
+    const parsed = JSON.parse(trimmed);
+    value = typeof parsed === "number" ? parsed : parsed?.pid;
+  } catch {
+    value = Number(trimmed);
+  }
+  return Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+
+export function isOwnedControllerCommand(command, scriptPath) {
+  if (typeof command !== "string" || typeof scriptPath !== "string" || !scriptPath) return false;
+  return command.trim().endsWith(`${scriptPath} watch`);
+}