codex-link 0.1.0

package/dist/index.js

@@ -0,0 +1,997 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { watch as watch2 } from "fs";
+import { join as join4 } from "path";
+import { Command } from "commander";
+
+// ../shared/src/env.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, parse, resolve } from "path";
+var envLoaded = false;
+function findEnvDirectory(startDir) {
+  let currentDir = resolve(startDir);
+  const rootDir = parse(currentDir).root;
+  while (true) {
+    if (existsSync(join(currentDir, ".env")) || existsSync(join(currentDir, ".env.local"))) {
+      return currentDir;
+    }
+    if (currentDir === rootDir) {
+      return null;
+    }
+    currentDir = dirname(currentDir);
+  }
+}
+function decodeQuotedValue(input) {
+  if (input.startsWith('"') && input.endsWith('"')) {
+    return input.slice(1, -1).replace(/\\n/g, "\n").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+  if (input.startsWith("'") && input.endsWith("'")) {
+    return input.slice(1, -1);
+  }
+  const commentIndex = input.search(/\s#/);
+  return (commentIndex >= 0 ? input.slice(0, commentIndex) : input).trim();
+}
+function parseEnvFile(path) {
+  const content = readFileSync(path, "utf8");
+  const entries = {};
+  for (const rawLine of content.split(/\r?\n/)) {
+    const trimmedLine = rawLine.trim();
+    if (!trimmedLine || trimmedLine.startsWith("#")) {
+      continue;
+    }
+    const line = trimmedLine.startsWith("export ") ? trimmedLine.slice("export ".length).trim() : trimmedLine;
+    const separatorIndex = line.indexOf("=");
+    if (separatorIndex < 0) {
+      continue;
+    }
+    const key = line.slice(0, separatorIndex).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      continue;
+    }
+    const rawValue = line.slice(separatorIndex + 1).trim();
+    entries[key] = decodeQuotedValue(rawValue);
+  }
+  return entries;
+}
+function loadEnvFile(path, override = false) {
+  if (!existsSync(path)) {
+    return;
+  }
+  const parsed = parseEnvFile(path);
+  for (const [key, value] of Object.entries(parsed)) {
+    if (!override && process.env[key] !== void 0) {
+      continue;
+    }
+    process.env[key] = value;
+  }
+}
+function loadCodexLinkEnv() {
+  if (envLoaded) {
+    return;
+  }
+  const candidates = [
+    process.env["INIT_CWD"],
+    process.cwd()
+  ].filter((value) => Boolean(value));
+  for (const candidate of candidates) {
+    const envDir = findEnvDirectory(candidate);
+    if (!envDir) {
+      continue;
+    }
+    loadEnvFile(join(envDir, ".env"));
+    loadEnvFile(join(envDir, ".env.local"), true);
+    envLoaded = true;
+    return;
+  }
+  envLoaded = true;
+}
+function expandHomePath(value) {
+  if (!value) {
+    return value;
+  }
+  if (value === "~") {
+    return homedir();
+  }
+  if (value.startsWith("~/")) {
+    return join(homedir(), value.slice(2));
+  }
+  return value;
+}
+
+// ../shared/src/parser.ts
+import { createHash } from "crypto";
+import { gzipSync } from "zlib";
+
+// ../shared/src/redaction.ts
+var ABSOLUTE_PATH_PATTERNS = [
+  /(?:\/Users\/|\/home\/|\/var\/|\/tmp\/|\/private\/|\/opt\/|\/Applications\/)[^\s'"`]+/g,
+  /[A-Za-z]:\\[^\s'"`]+/g
+];
+var SECRET_PATTERNS = [
+  /\b(?:sk|rk|pk)_[A-Za-z0-9_-]{16,}\b/g,
+  /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/g,
+  /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g,
+  /\bsess_[A-Za-z0-9]{16,}\b/g,
+  /\b(?:token|secret|password|authorization|api[_-]?key)\b\s*[:=]\s*["']?[^\s"']+/gi,
+  /\b(?:Bearer)\s+[A-Za-z0-9._-]{12,}/gi
+];
+var SIGNED_URL_PATTERN = /https?:\/\/[^\s'"`]+(?:X-Amz-Signature|Signature=|sig=|token=)[^\s'"`]*/gi;
+var TOOL_OUTPUT_LIMIT = 4e3;
+function replaceAbsolutePaths(input) {
+  return ABSOLUTE_PATH_PATTERNS.reduce(
+    (text, pattern) => text.replace(pattern, "<redacted-path>"),
+    input
+  );
+}
+function replaceSecrets(input) {
+  return SECRET_PATTERNS.reduce(
+    (text, pattern) => text.replace(pattern, "<redacted-secret>"),
+    input
+  );
+}
+function replaceSignedUrls(input) {
+  return input.replace(SIGNED_URL_PATTERN, "<redacted-signed-url>");
+}
+function redactText(input) {
+  return replaceSecrets(replaceSignedUrls(replaceAbsolutePaths(input)));
+}
+function truncateText(input, maxLength = TOOL_OUTPUT_LIMIT) {
+  if (input.length <= maxLength) {
+    return { text: input, truncated: false };
+  }
+  const head = input.slice(0, Math.floor(maxLength * 0.75));
+  const tail = input.slice(-Math.floor(maxLength * 0.15));
+  return {
+    text: `${head}
+
+\u2026 output truncated \u2026
+
+${tail}`,
+    truncated: true
+  };
+}
+function sanitizeToolOutput(input) {
+  return truncateText(redactText(input));
+}
+function shouldSkipUserMessage(input) {
+  const trimmed = input.trimStart();
+  return trimmed.startsWith("# AGENTS.md instructions") || trimmed.startsWith("<environment_context>") || trimmed.startsWith("<permissions instructions>");
+}
+
+// ../shared/src/parser.ts
+function normalizeTextForDedup(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function normalizeTextSegment(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return "";
+  }
+  if (/^<image\b[^>]*>$/i.test(trimmed) || /^<\/image>$/i.test(trimmed)) {
+    return "";
+  }
+  return trimmed.replace(/\[Image #\d+\]/g, "").trim();
+}
+function sanitizeImageSrc(src) {
+  const trimmed = src.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (/^data:image\//i.test(trimmed)) {
+    return trimmed;
+  }
+  if (!/^https?:\/\//i.test(trimmed)) {
+    return null;
+  }
+  if (/[?&](?:sig|signature|token|x-amz-|expires|awsaccesskeyid)=/i.test(trimmed)) {
+    return null;
+  }
+  return trimmed;
+}
+function extractImageUrl(item) {
+  const directImageUrl = asString(item.image_url);
+  if (directImageUrl) {
+    return sanitizeImageSrc(directImageUrl);
+  }
+  const nestedImageUrl = item.image_url;
+  if (nestedImageUrl && typeof nestedImageUrl === "object") {
+    const candidate = asString(nestedImageUrl.url) ?? asString(nestedImageUrl.uri);
+    if (candidate) {
+      return sanitizeImageSrc(candidate);
+    }
+  }
+  const directUrl = asString(item.url);
+  if (directUrl) {
+    return sanitizeImageSrc(directUrl);
+  }
+  return null;
+}
+function extractMessageContent(content) {
+  if (!Array.isArray(content)) {
+    return {
+      images: [],
+      text: ""
+    };
+  }
+  const images = [];
+  const text = content.flatMap((item) => {
+    if (!item || typeof item !== "object") {
+      return [];
+    }
+    const typedItem = item;
+    const itemType = asString(typedItem.type);
+    const imageUrl = extractImageUrl(typedItem);
+    if (imageUrl && (itemType === "input_image" || itemType === "output_image" || itemType === "image" || itemType === "image_url")) {
+      images.push({
+        alt: `Image ${images.length + 1}`,
+        src: imageUrl
+      });
+      return [];
+    }
+    const itemText = typedItem.text;
+    if (typeof itemText !== "string") {
+      return [];
+    }
+    const normalizedText = normalizeTextSegment(itemText);
+    return normalizedText ? [normalizedText] : [];
+  }).join("\n\n").trim();
+  return {
+    images,
+    text
+  };
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function createEntryId(prefix, counter) {
+  return `${prefix}-${counter}`;
+}
+function createStats(entries) {
+  return entries.reduce(
+    (stats, entry) => {
+      if (entry.kind === "message" && entry.role === "user") {
+        stats.userMessages += 1;
+      }
+      if (entry.kind === "message" && entry.role === "assistant") {
+        stats.assistantMessages += 1;
+      }
+      if (entry.kind === "tool_call") {
+        stats.toolCalls += 1;
+      }
+      if (entry.kind === "tool_output") {
+        stats.toolOutputs += 1;
+      }
+      return stats;
+    },
+    {
+      assistantMessages: 0,
+      toolCalls: 0,
+      toolOutputs: 0,
+      userMessages: 0
+    }
+  );
+}
+function areEquivalentImages(left, right) {
+  const leftImages = left ?? [];
+  const rightImages = right ?? [];
+  if (leftImages.length !== rightImages.length) {
+    return false;
+  }
+  return leftImages.every((image, index) => image.src === rightImages[index]?.src);
+}
+function canDeduplicateMessages(previousEntry, nextEntry) {
+  if (normalizeTextForDedup(previousEntry.text) !== normalizeTextForDedup(nextEntry.text)) {
+    return false;
+  }
+  const previousImageCount = previousEntry.images?.length ?? 0;
+  const nextImageCount = nextEntry.images?.length ?? 0;
+  return areEquivalentImages(previousEntry.images, nextEntry.images) || previousImageCount === 0 || nextImageCount === 0;
+}
+function scoreMessageEntry(entry) {
+  return (entry.images?.length ?? 0) * 1e3 + entry.text.length;
+}
+function mergeDuplicateMessageEntries(previousEntry, nextEntry) {
+  const preferred = scoreMessageEntry(nextEntry) > scoreMessageEntry(previousEntry) ? nextEntry : previousEntry;
+  return {
+    ...preferred,
+    id: previousEntry.id
+  };
+}
+function isCloseDuplicateTimestamp(left, right, maxDeltaMs = 5e3) {
+  const leftTime = Date.parse(left);
+  const rightTime = Date.parse(right);
+  if (Number.isNaN(leftTime) || Number.isNaN(rightTime)) {
+    return left === right;
+  }
+  return Math.abs(leftTime - rightTime) <= maxDeltaMs;
+}
+function pushEntry(state, nextEntry) {
+  const previousEntry = state.entries.at(-1);
+  if (!previousEntry) {
+    state.entries.push(nextEntry);
+    return;
+  }
+  if (nextEntry.kind === "commentary" && previousEntry.kind === "commentary" && normalizeTextForDedup(previousEntry.text) === normalizeTextForDedup(nextEntry.text) && isCloseDuplicateTimestamp(previousEntry.createdAt, nextEntry.createdAt)) {
+    return;
+  }
+  if (nextEntry.kind === "message" && previousEntry.kind === "message" && previousEntry.role === nextEntry.role && canDeduplicateMessages(previousEntry, nextEntry) && isCloseDuplicateTimestamp(previousEntry.createdAt, nextEntry.createdAt)) {
+    state.entries[state.entries.length - 1] = mergeDuplicateMessageEntries(
+      previousEntry,
+      nextEntry
+    );
+    return;
+  }
+  state.entries.push(nextEntry);
+}
+function pushCommentaryEntry(state, createdAt, text) {
+  pushEntry(state, {
+    createdAt,
+    id: createEntryId("commentary", ++state.commentaryCount),
+    kind: "commentary",
+    text
+  });
+}
+function pushMessageEntry(state, createdAt, role, text, images = []) {
+  pushEntry(state, {
+    createdAt,
+    id: createEntryId("message", ++state.messageCount),
+    images: images.length > 0 ? images : void 0,
+    kind: "message",
+    role,
+    text
+  });
+}
+function createExcerpt(entries) {
+  const firstMessage = entries.find((entry) => entry.kind === "message");
+  if (!firstMessage || firstMessage.kind !== "message") {
+    return "Shared Codex session";
+  }
+  return firstMessage.text.replace(/\s+/g, " ").slice(0, 180);
+}
+function parseJsonLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function parseRecordText(record) {
+  if (!record.payload) {
+    return null;
+  }
+  return (asString(record.payload.message) ? normalizeTextSegment(asString(record.payload.message) ?? "") : null) ?? (asString(record.payload.text) ? normalizeTextSegment(asString(record.payload.text) ?? "") : null) ?? extractMessageContent(record.payload.content).text;
+}
+function parseRecordImages(record) {
+  if (!record.payload) {
+    return [];
+  }
+  if (Array.isArray(record.payload.images)) {
+    return record.payload.images.flatMap((item, index) => {
+      if (typeof item !== "string") {
+        return [];
+      }
+      const src = sanitizeImageSrc(item);
+      if (!src) {
+        return [];
+      }
+      return [{
+        alt: `Image ${index + 1}`,
+        src
+      }];
+    });
+  }
+  return extractMessageContent(record.payload.content).images;
+}
+function parseSessionJsonl(rawText, options) {
+  const state = {
+    commentaryCount: 0,
+    entries: [],
+    messageCount: 0,
+    toolCallCount: 0,
+    toolOutputCount: 0
+  };
+  let createdAt = options.sourceUpdatedAt;
+  for (const line of rawText.split("\n")) {
+    if (!line.trim()) {
+      continue;
+    }
+    const record = parseJsonLine(line);
+    if (!record?.type) {
+      continue;
+    }
+    if (record.type === "session_meta" && record.timestamp) {
+      createdAt = record.timestamp;
+      continue;
+    }
+    if (record.type === "turn_context" || !record.payload) {
+      continue;
+    }
+    const payloadType = asString(record.payload.type);
+    const createdAtValue = record.timestamp ?? options.sourceUpdatedAt;
+    if (record.type === "event_msg") {
+      if (payloadType === "user_message" || payloadType === "agent_message") {
+        const role = payloadType === "user_message" ? "user" : "assistant";
+        const text = redactText(parseRecordText(record) ?? "");
+        const images = parseRecordImages(record);
+        if (!text && images.length === 0) {
+          continue;
+        }
+        if (role === "user" && shouldSkipUserMessage(text)) {
+          continue;
+        }
+        pushMessageEntry(state, createdAtValue, role, text, images);
+        continue;
+      }
+      if (payloadType === "agent_reasoning") {
+        const text = redactText(parseRecordText(record) ?? "");
+        if (!text) {
+          continue;
+        }
+        pushCommentaryEntry(state, createdAtValue, text);
+      }
+      continue;
+    }
+    if (record.type !== "response_item") {
+      continue;
+    }
+    if (payloadType === "message") {
+      const role = asString(record.payload.role);
+      if (role !== "user" && role !== "assistant") {
+        continue;
+      }
+      const parsedContent = extractMessageContent(record.payload.content);
+      const text = redactText(parsedContent.text);
+      if (!text && parsedContent.images.length === 0) {
+        continue;
+      }
+      if (role === "user" && shouldSkipUserMessage(text)) {
+        continue;
+      }
+      pushMessageEntry(state, createdAtValue, role, text, parsedContent.images);
+      continue;
+    }
+    if (payloadType === "function_call" || payloadType === "custom_tool_call") {
+      const toolName = asString(record.payload.name) ?? "tool";
+      const input = asString(record.payload.arguments) ?? asString(record.payload.input) ?? "{}";
+      state.entries.push({
+        createdAt: createdAtValue,
+        id: createEntryId("tool-call", ++state.toolCallCount),
+        input: redactText(input),
+        kind: "tool_call",
+        toolName
+      });
+      continue;
+    }
+    if (payloadType === "function_call_output" || payloadType === "custom_tool_call_output") {
+      const output = asString(record.payload.output) ?? asString(record.payload.text) ?? "";
+      if (!output) {
+        continue;
+      }
+      const toolName = asString(record.payload.name) ?? "tool";
+      const sanitized = sanitizeToolOutput(output);
+      state.entries.push({
+        createdAt: createdAtValue,
+        id: createEntryId("tool-output", ++state.toolOutputCount),
+        kind: "tool_output",
+        output: sanitized.text,
+        toolName,
+        truncated: sanitized.truncated
+      });
+    }
+  }
+  return {
+    createdAt,
+    entries: state.entries,
+    excerpt: createExcerpt(state.entries),
+    id: options.title,
+    sourceUpdatedAt: options.sourceUpdatedAt,
+    stats: createStats(state.entries),
+    title: options.title
+  };
+}
+function hashContent(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+function buildShareSnapshot(input) {
+  const renderPayload = parseSessionJsonl(input.rawText, {
+    sourceUpdatedAt: input.sourceUpdatedAt,
+    title: input.title
+  });
+  const rawJsonlGzip = gzipSync(input.rawText);
+  const contentHash = hashContent(input.rawText);
+  return {
+    contentHash,
+    rawJsonlGzip,
+    renderPayload: {
+      ...renderPayload,
+      id: input.sessionId
+    },
+    sourceSessionId: input.sessionId,
+    sourceUpdatedAt: input.sourceUpdatedAt,
+    stats: renderPayload.stats,
+    title: input.title
+  };
+}
+
+// ../shared/src/public-url.ts
+function trimTrailingSlash(input) {
+  return input.endsWith("/") ? input.slice(0, -1) : input;
+}
+function getSharePath(shareId) {
+  return `/c/${shareId}`;
+}
+function buildPublicShareUrl(siteUrl, shareId) {
+  return `${trimTrailingSlash(siteUrl)}${getSharePath(shareId)}`;
+}
+
+// ../shared/src/session-resolution.ts
+import { readFile, readdir, stat } from "fs/promises";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getCodexHome(explicitCodexHome) {
+  return explicitCodexHome ?? process.env["CODEX_HOME"] ?? join2(homedir2(), ".codex");
+}
+function parseJsonLine2(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+async function readSessionIndex(explicitCodexHome) {
+  const codexHome = getCodexHome(explicitCodexHome);
+  const indexPath = join2(codexHome, "session_index.jsonl");
+  if (!await pathExists(indexPath)) {
+    return [];
+  }
+  const raw = await readFile(indexPath, "utf8");
+  return raw.split("\n").flatMap((line) => {
+    if (!line.trim()) {
+      return [];
+    }
+    const entry = parseJsonLine2(line);
+    return entry ? [entry] : [];
+  });
+}
+async function findSessionFileById(directory, sessionId) {
+  const entries = await readdir(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join2(directory, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await findSessionFileById(fullPath, sessionId);
+      if (nested) {
+        return nested;
+      }
+      continue;
+    }
+    if (!entry.name.endsWith(".jsonl")) {
+      continue;
+    }
+    if (entry.name.includes(sessionId)) {
+      return fullPath;
+    }
+    const firstLine = (await readFile(fullPath, "utf8")).split("\n", 1)[0] ?? "";
+    if (firstLine.includes(sessionId)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+async function resolveSessionById(sessionId, explicitCodexHome) {
+  const codexHome = getCodexHome(explicitCodexHome);
+  const index = await readSessionIndex(codexHome);
+  const indexEntry = index.find((entry) => entry.id === sessionId);
+  const sessionsRoot = join2(codexHome, "sessions");
+  const filePath = await findSessionFileById(sessionsRoot, sessionId);
+  if (!filePath) {
+    throw new Error(`Could not find session file for ${sessionId}`);
+  }
+  const fileStat = await stat(filePath);
+  const rawText = await readFile(filePath, "utf8");
+  return {
+    filePath,
+    id: sessionId,
+    rawText,
+    sourceUpdatedAt: indexEntry?.updated_at ?? fileStat.mtime.toISOString(),
+    title: indexEntry?.thread_name ?? "Untitled Codex Session"
+  };
+}
+
+// src/tracker.ts
+import { watch } from "fs";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { platform as platform2 } from "os";
+
+// src/api-client.ts
+import { Buffer } from "buffer";
+var ApiRequestError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "ApiRequestError";
+  }
+  status;
+  body;
+};
+function createFormData(snapshot) {
+  const formData = new FormData();
+  formData.set(
+    "metadata",
+    JSON.stringify({
+      contentHash: snapshot.contentHash,
+      renderPayload: snapshot.renderPayload,
+      sourceSessionId: snapshot.sourceSessionId,
+      sourceUpdatedAt: snapshot.sourceUpdatedAt,
+      stats: snapshot.stats,
+      title: snapshot.title
+    })
+  );
+  formData.set(
+    "sessionFile",
+    new File([Buffer.from(snapshot.rawJsonlGzip)], `${snapshot.sourceSessionId}.jsonl.gz`, {
+      type: "application/gzip"
+    })
+  );
+  return formData;
+}
+var CodexLinkApiClient = class {
+  constructor(baseUrl, fetchImpl) {
+    this.baseUrl = baseUrl;
+    this.fetchImpl = fetchImpl;
+  }
+  baseUrl;
+  fetchImpl;
+  async createShare(snapshot) {
+    const response = await this.fetchImpl(`${this.baseUrl}/v1/shares`, {
+      body: createFormData(snapshot),
+      method: "POST"
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new ApiRequestError(`Failed to create share: ${body}`, response.status, body);
+    }
+    return await response.json();
+  }
+  async getShare(shareId) {
+    const response = await this.fetchImpl(`${this.baseUrl}/v1/shares/${shareId}`, {
+      method: "GET"
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new ApiRequestError(`Failed to fetch share: ${body}`, response.status, body);
+    }
+    return await response.json();
+  }
+  async updateShare(shareId, manageToken, snapshot) {
+    const response = await this.fetchImpl(`${this.baseUrl}/v1/shares/${shareId}`, {
+      body: createFormData(snapshot),
+      headers: {
+        authorization: `Bearer ${manageToken}`
+      },
+      method: "PUT"
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new ApiRequestError(`Failed to update share: ${body}`, response.status, body);
+    }
+  }
+  async revokeShare(shareId, manageToken) {
+    const response = await this.fetchImpl(`${this.baseUrl}/v1/shares/${shareId}`, {
+      headers: {
+        authorization: `Bearer ${manageToken}`
+      },
+      method: "DELETE"
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new ApiRequestError(`Failed to revoke share: ${body}`, response.status, body);
+    }
+  }
+};
+
+// src/state.ts
+import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+import { homedir as homedir3, platform } from "os";
+var EMPTY_STATE = {
+  seenSessionIds: [],
+  trackedSessions: {}
+};
+function getDefaultStateRoot() {
+  if (process.env["CODEXLINK_STATE_DIR"]) {
+    return expandHomePath(process.env["CODEXLINK_STATE_DIR"]) ?? process.env["CODEXLINK_STATE_DIR"];
+  }
+  if (platform() === "darwin") {
+    return join3(homedir3(), "Library", "Application Support", "CodexLink");
+  }
+  return join3(
+    process.env["XDG_STATE_HOME"] ?? join3(homedir3(), ".local", "state"),
+    "codexlink"
+  );
+}
+function getStatePath(stateRoot) {
+  return join3(stateRoot, "state.json");
+}
+async function loadAppState(stateRoot) {
+  try {
+    const raw = await readFile2(getStatePath(stateRoot), "utf8");
+    const parsed = JSON.parse(raw);
+    return { ...EMPTY_STATE, ...parsed };
+  } catch {
+    return EMPTY_STATE;
+  }
+}
+async function saveAppState(stateRoot, state) {
+  await mkdir(stateRoot, { recursive: true });
+  await writeFile(getStatePath(stateRoot), JSON.stringify(state, null, 2));
+}
+
+// src/tracker.ts
+var execFileAsync = promisify(execFile);
+var DEFAULT_API_BASE_URL = "https://api.codexl.ink";
+function shouldRecreateShare(error) {
+  return error instanceof ApiRequestError && [401, 403, 404, 410].includes(error.status);
+}
+function createCliContext(overrides = {}) {
+  loadCodexLinkEnv();
+  return {
+    apiBaseUrl: overrides.apiBaseUrl ?? process.env["CODEXLINK_API_URL"] ?? process.env["API_BASE_URL"] ?? DEFAULT_API_BASE_URL,
+    codexHome: expandHomePath(overrides.codexHome) ?? expandHomePath(process.env["CODEX_HOME"]),
+    fetchImpl: overrides.fetchImpl ?? fetch,
+    logger: overrides.logger ?? console,
+    stateRoot: expandHomePath(overrides.stateRoot) ?? getDefaultStateRoot()
+  };
+}
+async function upsertTrackedSession(context, snapshot, resolvedFilePath) {
+  const state = await loadAppState(context.stateRoot);
+  const existing = state.trackedSessions[snapshot.sourceSessionId];
+  const client = new CodexLinkApiClient(context.apiBaseUrl, context.fetchImpl);
+  if (existing) {
+    try {
+      if (existing.lastContentHash !== snapshot.contentHash) {
+        await client.updateShare(existing.shareId, existing.manageToken, snapshot);
+      } else {
+        await client.getShare(existing.shareId);
+      }
+    } catch (error) {
+      if (!shouldRecreateShare(error)) {
+        throw error;
+      }
+      const created2 = await client.createShare(snapshot);
+      const recreatedTracked = {
+        filePath: resolvedFilePath,
+        lastContentHash: snapshot.contentHash,
+        manageToken: created2.manageToken,
+        sessionId: snapshot.sourceSessionId,
+        shareId: created2.shareId,
+        title: snapshot.title
+      };
+      state.trackedSessions[snapshot.sourceSessionId] = recreatedTracked;
+      await saveAppState(context.stateRoot, state);
+      return recreatedTracked;
+    }
+    const tracked2 = {
+      ...existing,
+      filePath: resolvedFilePath,
+      lastContentHash: snapshot.contentHash,
+      title: snapshot.title
+    };
+    state.trackedSessions[snapshot.sourceSessionId] = tracked2;
+    await saveAppState(context.stateRoot, state);
+    return tracked2;
+  }
+  const created = await client.createShare(snapshot);
+  const tracked = {
+    filePath: resolvedFilePath,
+    lastContentHash: snapshot.contentHash,
+    manageToken: created.manageToken,
+    sessionId: snapshot.sourceSessionId,
+    shareId: created.shareId,
+    title: snapshot.title
+  };
+  state.trackedSessions[snapshot.sourceSessionId] = tracked;
+  await saveAppState(context.stateRoot, state);
+  return tracked;
+}
+async function syncSession(sessionId, context) {
+  const resolved = await resolveSessionById(sessionId, context.codexHome);
+  const snapshot = buildShareSnapshot({
+    rawText: resolved.rawText,
+    sessionId: resolved.id,
+    sourceUpdatedAt: resolved.sourceUpdatedAt,
+    title: resolved.title
+  });
+  return upsertTrackedSession(context, snapshot, resolved.filePath);
+}
+var SessionTracker = class {
+  constructor(sessionId, context, debounceMs = 800) {
+    this.sessionId = sessionId;
+    this.context = context;
+    this.debounceMs = debounceMs;
+  }
+  sessionId;
+  context;
+  debounceMs;
+  debounceHandle = null;
+  filePath = "";
+  watcher = null;
+  async start() {
+    const tracked = await syncSession(this.sessionId, this.context);
+    this.filePath = tracked.filePath;
+    this.watcher = watch(this.filePath, () => {
+      this.scheduleSync();
+    });
+  }
+  scheduleSync() {
+    if (this.debounceHandle) {
+      clearTimeout(this.debounceHandle);
+    }
+    this.debounceHandle = setTimeout(() => {
+      void this.runSync().catch((error) => this.context.logger.error(error));
+    }, this.debounceMs);
+  }
+  async runSync() {
+    const state = await loadAppState(this.context.stateRoot);
+    const existing = state.trackedSessions[this.sessionId];
+    if (!existing) {
+      await syncSession(this.sessionId, this.context);
+      return;
+    }
+    const nextTracked = await syncSession(this.sessionId, this.context);
+    this.filePath = nextTracked.filePath;
+  }
+  async dispose() {
+    if (this.debounceHandle) {
+      clearTimeout(this.debounceHandle);
+      this.debounceHandle = null;
+    }
+    this.watcher?.close();
+    this.watcher = null;
+  }
+};
+async function revokeTrackedSession(target, context) {
+  const state = await loadAppState(context.stateRoot);
+  const tracked = state.trackedSessions[target] ?? Object.values(state.trackedSessions).find((entry) => entry.shareId === target);
+  if (!tracked) {
+    throw new Error(`No tracked session or share found for ${target}`);
+  }
+  const client = new CodexLinkApiClient(context.apiBaseUrl, context.fetchImpl);
+  await client.revokeShare(tracked.shareId, tracked.manageToken);
+  delete state.trackedSessions[tracked.sessionId];
+  await saveAppState(context.stateRoot, state);
+}
+async function defaultPromptHandler(input) {
+  if (platform2() !== "darwin") {
+    return false;
+  }
+  const script = `
+    set response to button returned of (display dialog "Track this Codex chat on codexl.ink?
+
+${input.title}
+${input.sessionId}" buttons {"Ignore", "Track"} default button "Track")
+    return response
+  `;
+  const { stdout } = await execFileAsync("osascript", ["-e", script]);
+  return stdout.trim() === "Track";
+}
+var MonitorService = class {
+  constructor(context, prompt = defaultPromptHandler) {
+    this.context = context;
+    this.prompt = prompt;
+  }
+  context;
+  prompt;
+  trackers = /* @__PURE__ */ new Map();
+  async handleSessionIndex(indexEntries) {
+    const state = await loadAppState(this.context.stateRoot);
+    const seen = new Set(state.seenSessionIds);
+    for (const entry of indexEntries) {
+      if (seen.has(entry.id)) {
+        continue;
+      }
+      seen.add(entry.id);
+      const accepted = await this.prompt({
+        sessionId: entry.id,
+        title: entry.thread_name ?? "Untitled Codex Session"
+      });
+      if (accepted) {
+        const tracker = new SessionTracker(entry.id, this.context);
+        await tracker.start();
+        this.trackers.set(entry.id, tracker);
+      }
+    }
+    const nextState = {
+      ...state,
+      seenSessionIds: [...seen]
+    };
+    await saveAppState(this.context.stateRoot, nextState);
+  }
+  async dispose() {
+    await Promise.all([...this.trackers.values()].map((tracker) => tracker.dispose()));
+    this.trackers.clear();
+  }
+};
+
+// src/index.ts
+var DEFAULT_SITE_URL = "https://codexl.ink";
+async function waitForExit() {
+  await new Promise((resolve2) => {
+    const handler = () => resolve2();
+    process.once("SIGINT", handler);
+    process.once("SIGTERM", handler);
+  });
+}
+async function runShare(sessionId, apiUrl) {
+  const context = createCliContext({ apiBaseUrl: apiUrl });
+  const tracked = await syncSession(sessionId, context);
+  const siteUrl = process.env["SITE_URL"] ?? DEFAULT_SITE_URL;
+  context.logger.log(`Share URL: ${buildPublicShareUrl(siteUrl, tracked.shareId)}`);
+  context.logger.log(`Manage token: ${tracked.manageToken}`);
+}
+async function runTrack(sessionId, apiUrl) {
+  const context = createCliContext({ apiBaseUrl: apiUrl });
+  const tracker = new SessionTracker(sessionId, context);
+  await tracker.start();
+  context.logger.log(`Tracking ${sessionId}`);
+  await waitForExit();
+  await tracker.dispose();
+}
+async function runMonitor(apiUrl) {
+  const context = createCliContext({ apiBaseUrl: apiUrl });
+  const service = new MonitorService(context);
+  const codexHome = context.codexHome ?? process.env["CODEX_HOME"];
+  const indexPath = join4(codexHome ?? join4(process.env["HOME"] ?? "", ".codex"), "session_index.jsonl");
+  const syncIndex = async () => {
+    const entries = await readSessionIndex(context.codexHome);
+    await service.handleSessionIndex(entries);
+  };
+  await syncIndex();
+  const watcher = watch2(indexPath, () => {
+    void syncIndex().catch((error) => context.logger.error(error));
+  });
+  context.logger.log(`Monitoring ${indexPath}`);
+  await waitForExit();
+  watcher.close();
+  await service.dispose();
+}
+async function runUnshare(target, apiUrl) {
+  const context = createCliContext({ apiBaseUrl: apiUrl });
+  await revokeTrackedSession(target, context);
+  context.logger.log(`Revoked ${target}`);
+}
+var program = new Command();
+program.name("cdxl").description("Publish and track Codex chats");
+program.command("share").argument("<sessionId>").option("--api-url <url>").action(async (sessionId, options) => {
+  await runShare(sessionId, options.apiUrl);
+});
+program.command("track").argument("<sessionId>").option("--api-url <url>").action(async (sessionId, options) => {
+  await runTrack(sessionId, options.apiUrl);
+});
+program.command("monitor").option("--api-url <url>").action(async (options) => {
+  await runMonitor(options.apiUrl);
+});
+program.command("unshare").argument("<shareOrSessionId>").option("--api-url <url>").action(async (target, options) => {
+  await runUnshare(target, options.apiUrl);
+});
+program.parseAsync(process.argv).catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});
+export {
+  runMonitor,
+  runShare,
+  runTrack,
+  runUnshare
+};

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "codex-link",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "cdxl": "dist/index.js"
+  },
+  "description": "Publish and track Codex chats",
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "commander": "^14.0.1"
+  }
+}