@youdie006/prodex 0.40.6 → 0.40.9

package/dist/safe-file.js

@@ -1,11 +1,62 @@
 import { randomUUID } from "node:crypto";
 import { constants } from "node:fs";
-import { lstat, open, realpath, rename, rm } from "node:fs/promises";
+import { chmod, link, lstat, mkdir, open, realpath, rename, rm } from "node:fs/promises";
 import path from "node:path";
 let testHooks = {};
 export function setSafeFileTestHooks(hooks) {
     testHooks = hooks;
 }
+/**
+ * Serialize cooperating processes through a complete, atomically published
+ * lock record. A live process is never evicted based on elapsed time: callers
+ * must cancel their own work before releasing the lease.
+ */
+export async function withCrossProcessFileLock(filePath, options, fn) {
+    const parentSnapshot = await prepareFileLockParent(filePath, options.privateParent === true);
+    const deadline = Date.now() + Math.max(0, options.waitMs);
+    const retryMs = Math.max(1, options.retryMs ?? 50);
+    let waited = false;
+    let retriedMissingAtDeadline = false;
+    let lease;
+    for (;;) {
+        lease = await tryAcquireFileLock(filePath, parentSnapshot);
+        if (lease)
+            break;
+        const snapshot = await readFileLockSnapshot(filePath, parentSnapshot);
+        if (!snapshot) {
+            // The holder commonly disappears between our failed link and inspection.
+            // Retry that acquisition once even at the deadline, but do not let a
+            // rapidly flapping path bypass a bounded caller's wait budget forever.
+            if (Date.now() >= deadline) {
+                if (retriedMissingAtDeadline)
+                    throw options.unavailableError();
+                retriedMissingAtDeadline = true;
+            }
+            else {
+                await delay(Math.min(10, Math.max(1, deadline - Date.now())));
+            }
+            continue;
+        }
+        retriedMissingAtDeadline = false;
+        const holderAlive = snapshot.holder.pid !== undefined && processIsAlive(snapshot.holder.pid);
+        if (!holderAlive && (await reapFileLockSnapshot(filePath, snapshot, parentSnapshot)))
+            continue;
+        if (Date.now() >= deadline) {
+            throw holderAlive ? options.busyError(snapshot.holder) : options.unavailableError();
+        }
+        if (!waited) {
+            waited = true;
+            options.onWait?.(snapshot.holder);
+        }
+        await delay(Math.min(retryMs, Math.max(1, deadline - Date.now())));
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        await releaseFileLockLease(filePath, lease, parentSnapshot);
+    }
+}
 export async function readVerifiedUtf8File(filePath, validate, options = {}) {
     await validate();
     const parentSnapshot = await captureParentSnapshot(filePath);
@@ -286,9 +337,206 @@ async function openNoFollow(filePath, flags, operation, mode) {
         throw error;
     }
 }
+async function prepareFileLockParent(filePath, makePrivate) {
+    const parentPath = path.dirname(filePath);
+    await mkdir(parentPath, { recursive: true, mode: 0o700 });
+    const parentStat = await lstat(parentPath);
+    if (parentStat.isSymbolicLink() || !parentStat.isDirectory()) {
+        throw new Error("Lock parent must be a real directory and must not be a symlink");
+    }
+    if (makePrivate)
+        await chmod(parentPath, 0o700);
+    const snapshot = await captureParentSnapshot(filePath);
+    if (!snapshot)
+        throw new Error("Lock files cannot use a descriptor-backed parent path");
+    await assertParentSnapshotStable(snapshot);
+    return snapshot;
+}
+async function tryAcquireFileLock(filePath, parentSnapshot) {
+    const owner = {
+        pid: process.pid,
+        nonce: randomUUID(),
+        started_at: new Date().toISOString()
+    };
+    const tokenPath = fileLockTokenPath(filePath, owner);
+    const handle = await openStableNoFollow(tokenPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, "write", parentSnapshot, 0o600);
+    try {
+        await handle.writeFile(`${JSON.stringify(owner)}\n`, "utf8");
+        await handle.chmod(0o600);
+    }
+    finally {
+        await handle.close();
+    }
+    try {
+        await assertParentSnapshotStable(parentSnapshot);
+        await link(tokenPath, filePath);
+        return { owner, tokenPath };
+    }
+    catch (error) {
+        await rm(tokenPath, { force: true }).catch(() => undefined);
+        if (isErrorCode(error, "EEXIST"))
+            return undefined;
+        throw error;
+    }
+}
+async function readFileLockSnapshot(filePath, parentSnapshot) {
+    let pathIdentity;
+    try {
+        const pathStat = await lstat(filePath, { bigint: true });
+        pathIdentity = { dev: pathStat.dev, ino: pathStat.ino };
+        if (pathStat.isSymbolicLink() || !pathStat.isFile()) {
+            return { identity: pathIdentity, holder: {}, unsafe: true };
+        }
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return undefined;
+        throw error;
+    }
+    let handle;
+    try {
+        handle = await openStableNoFollow(filePath, constants.O_RDONLY, "read", parentSnapshot);
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return undefined;
+        return { identity: pathIdentity, holder: {}, unsafe: true };
+    }
+    try {
+        const stat = await handle.stat({ bigint: true });
+        if (!stat.isFile())
+            return { identity: pathIdentity, holder: {}, unsafe: true };
+        const identity = { dev: stat.dev, ino: stat.ino };
+        if (stat.size > 16384n)
+            return { identity, holder: {} };
+        const content = await handle.readFile({ encoding: "utf8" });
+        const holder = parseFileLockHolder(content);
+        return { identity, holder, owner: parseFileLockOwner(holder) };
+    }
+    catch {
+        return { identity: pathIdentity, holder: {} };
+    }
+    finally {
+        await handle.close();
+    }
+}
+function parseFileLockHolder(content) {
+    try {
+        const parsed = JSON.parse(content);
+        return {
+            pid: Number.isSafeInteger(parsed.pid) && Number(parsed.pid) > 0 ? Number(parsed.pid) : undefined,
+            nonce: typeof parsed.nonce === "string" && /^[A-Za-z0-9-]{1,128}$/.test(parsed.nonce) ? parsed.nonce : undefined,
+            started_at: typeof parsed.started_at === "string" ? parsed.started_at : undefined
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function parseFileLockOwner(holder) {
+    if (holder.pid === undefined || holder.nonce === undefined)
+        return undefined;
+    return { pid: holder.pid, nonce: holder.nonce, started_at: holder.started_at };
+}
+async function releaseFileLockLease(filePath, lease, parentSnapshot) {
+    try {
+        const [current, tokenIdentity] = await Promise.all([
+            readFileLockSnapshot(filePath, parentSnapshot),
+            readRegularFileIdentity(lease.tokenPath)
+        ]);
+        if (current?.owner?.pid === lease.owner.pid &&
+            current.owner.nonce === lease.owner.nonce &&
+            tokenIdentity &&
+            sameFileIdentity(current.identity, tokenIdentity)) {
+            await rm(filePath, { force: true });
+        }
+    }
+    catch {
+        // A release is best-effort; the unique token cleanup below cannot affect a successor.
+    }
+    finally {
+        await rm(lease.tokenPath, { force: true }).catch(() => undefined);
+    }
+}
+async function reapFileLockSnapshot(filePath, snapshot, parentSnapshot) {
+    if (snapshot.unsafe)
+        return false;
+    return reapClaimedFileLock(filePath, snapshot, parentSnapshot);
+}
+async function reapClaimedFileLock(filePath, snapshot, parentSnapshot) {
+    const claimPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.reap`);
+    try {
+        await link(filePath, claimPath);
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return true;
+        // An interrupted reaper requires manual cleanup after all users stop.
+        // Reaping this claim recursively would reintroduce successor-unlink races.
+        if (isErrorCode(error, "EEXIST"))
+            return false;
+        throw error;
+    }
+    try {
+        await testHooks.afterLockReapClaim?.(filePath);
+        const [claimIdentity, current, ownerTokenIdentity] = await Promise.all([
+            readRegularFileIdentity(claimPath),
+            readFileLockSnapshot(filePath, parentSnapshot),
+            snapshot.owner ? readRegularFileIdentity(fileLockTokenPath(filePath, snapshot.owner)) : undefined
+        ]);
+        if (!claimIdentity ||
+            !current ||
+            !sameFileIdentity(claimIdentity, snapshot.identity) ||
+            !sameFileIdentity(current.identity, snapshot.identity)) {
+            return false;
+        }
+        await rm(filePath, { force: true });
+        if (snapshot.owner && ownerTokenIdentity && sameFileIdentity(ownerTokenIdentity, snapshot.identity)) {
+            await rm(fileLockTokenPath(filePath, snapshot.owner), { force: true }).catch(() => undefined);
+        }
+        return true;
+    }
+    finally {
+        await rm(claimPath, { force: true }).catch(() => undefined);
+    }
+}
+async function readRegularFileIdentity(filePath) {
+    try {
+        const stat = await lstat(filePath, { bigint: true });
+        if (stat.isSymbolicLink() || !stat.isFile())
+            return undefined;
+        return { dev: stat.dev, ino: stat.ino };
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return undefined;
+        throw error;
+    }
+}
+function fileLockTokenPath(filePath, owner) {
+    return path.join(path.dirname(filePath), `.${path.basename(filePath)}.${owner.pid}.${owner.nonce}.owner`);
+}
+function sameFileIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function procFdPath(fd) {
     return `/proc/self/fd/${fd}`;
 }
 function isMissingFileError(error) {
     return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
+function isErrorCode(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}

package/dist/schema.js

@@ -1,5 +1,12 @@
 import { z } from "zod";
 export const SCHEMA_VERSION = 1;
+export const SessionKeySchema = z
+    .string()
+    .trim()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._:@/-]*$/, "Session key must be an identifier, not prompt text");
+export const ProdexRequestIdSchema = z.string().regex(/^[a-f0-9]{32}$/);
 export const AdapterSchema = z.enum(["cli", "mcp", "manual", "oracle", "chatgpt-control"]);
 export const TaskStatusSchema = z.enum(["new", "claimed", "done", "blocked"]);
 export const ResultStatusSchema = z.enum(["done", "blocked"]);
@@ -83,6 +90,7 @@ export const SessionSchema = z.object({
     id: z.string().regex(/^sess_\d{8}_\d{6}_[a-z0-9-]+$/),
     direction: z.enum(["codex_to_chatgpt", "chatgpt_to_codex", "claude_to_codex"]),
     backend: AdapterSchema,
+    session_key: SessionKeySchema.optional(),
     project: z.string().optional(),
     thread: z.string().optional(),
     task_id: z.string().optional(),

package/dist/store.js

@@ -389,7 +389,13 @@ export class BridgeStore {
         if (artifact.sha256 && sha256(content) !== artifact.sha256) {
             throw new Error(`Result artifact changed after finalization for ${taskId}: ${artifact.path} sha256 mismatch`);
         }
-        return { artifact, content };
+        return {
+            artifact,
+            content,
+            ...(!artifact.sha256 ? {
+                warnings: ["legacy_artifact_unverified: this artifact has no recorded sha256; its current contents cannot be verified against finalization."]
+            } : {})
+        };
     }
     async withResultArtifactHashes(artifacts) {
         const withHashes = [];
@@ -436,6 +442,7 @@ export class BridgeStore {
                 id,
                 direction: input.direction,
                 backend: input.backend,
+                session_key: input.session_key,
                 project: input.project,
                 thread: input.thread,
                 task_id: input.task_id,
@@ -452,6 +459,7 @@ export class BridgeStore {
             id: input.id,
             direction: input.direction,
             backend: input.backend,
+            session_key: input.session_key ?? existing?.session_key,
             project: input.project,
             thread: input.thread,
             task_id: input.task_id,
@@ -476,6 +484,7 @@ export class BridgeStore {
             id: existing.id,
             direction: existing.direction,
             backend: existing.backend,
+            session_key: existing.session_key,
             project: existing.project,
             thread: existing.thread,
             task_id: existing.task_id,

package/dist/tui-flow.js

@@ -10,7 +10,6 @@
  */
 export const SEND_KINDS = [
     { id: "chat", label: "Normal chat", hint: "ordinary Pro answer", tools: [] },
-    { id: "deep-research", label: "Deep research", hint: "browsed report, runs about 10 minutes", tools: ["deep-research"] },
     { id: "web-search", label: "Web search", hint: "current facts, with sources", tools: ["web-search"] },
     { id: "create-image", label: "Create image", tools: ["create-image"] }
 ];

package/dist/tui-run.js

@@ -8,6 +8,7 @@
  */
 import readline from "node:readline";
 import { renderBanner } from "./banner.js";
+import { shellQuote } from "./cli-args.js";
 import { destinationChoices, effortChoices, SEND_KINDS } from "./tui-flow.js";
 import { consultArgsFromChoices, conversationsInProject, conversationThreadUrl, moveCursor, parseAttachmentLine, progressLabel, renderContextPanel, renderProgressBar, renderSelectList } from "./tui.js";
 const ESC = "";
@@ -32,11 +33,18 @@ class KeyQueue {
     input;
     pending = [];
     waiting;
+    ended = false;
     constructor(input) {
         this.input = input;
         this.input.on("keypress", this.onKey);
+        this.input.on("end", this.onEnd);
+        this.input.on("close", this.onEnd);
+        if (this.input.readableEnded || this.input.destroyed)
+            this.onEnd();
     }
     onKey = (_str, key) => {
+        if (this.ended)
+            return;
         const value = key ?? {};
         if (this.waiting) {
             const resolve = this.waiting;
@@ -46,7 +54,16 @@ class KeyQueue {
         }
         this.pending.push(value);
     };
+    onEnd = () => {
+        this.ended = true;
+        this.pending.length = 0;
+        const resolve = this.waiting;
+        this.waiting = undefined;
+        resolve?.({ name: "c", ctrl: true });
+    };
     next() {
+        if (this.ended)
+            return Promise.resolve({ name: "c", ctrl: true });
         const buffered = this.pending.shift();
         if (buffered)
             return Promise.resolve(buffered);
@@ -60,6 +77,8 @@ class KeyQueue {
     }
     dispose() {
         this.input.off("keypress", this.onKey);
+        this.input.off("end", this.onEnd);
+        this.input.off("close", this.onEnd);
     }
 }
 let keys;
@@ -69,7 +88,7 @@ function readKey(_io) {
     return keys.next();
 }
 function isCancel(key) {
-    return (key.ctrl === true && key.name === "c") || key.name === "escape" || key.name === "q";
+    return (key.ctrl === true && (key.name === "c" || key.name === "d")) || key.name === "escape" || key.name === "q";
 }
 // Terminals disagree about the Enter key: a carriage return arrives as
 // "return", a line feed as "enter". Accept either, or the picker looks frozen.
@@ -121,15 +140,38 @@ function numericChoice(key, length) {
 async function askLine(io, question) {
     io.input.setRawMode?.(false);
     const rl = readline.createInterface({ input: io.input, output: process.stdout, terminal: true });
-    const answer = await new Promise((resolve) => rl.question(question, resolve));
-    rl.close();
-    // Closing the line reader detaches the keypress plumbing and pauses the
-    // stream, so the next picker would sit there ignoring every key. Re-arm both.
-    io.input.setRawMode?.(true);
-    readline.emitKeypressEvents(io.input);
-    io.input.resume();
-    keys?.drain();
-    return answer.trim();
+    try {
+        const answer = await new Promise((resolve) => {
+            let settled = false;
+            function settle(value) {
+                if (settled)
+                    return;
+                settled = true;
+                rl.off("SIGINT", onInterrupt);
+                rl.off("close", onClose);
+                resolve(value);
+            }
+            function onInterrupt() {
+                settle(undefined);
+            }
+            function onClose() {
+                settle(undefined);
+            }
+            rl.once("SIGINT", onInterrupt);
+            rl.once("close", onClose);
+            rl.question(question, (value) => settle(value));
+        });
+        return answer?.trim();
+    }
+    finally {
+        rl.close();
+        // Closing the line reader detaches the keypress plumbing and pauses the
+        // stream, so the next picker would sit there ignoring every key. Re-arm both.
+        io.input.setRawMode?.(true);
+        readline.emitKeypressEvents(io.input);
+        io.input.resume();
+        keys?.drain();
+    }
 }
 /**
  * Walk the questions a send needs, then run it with a moving progress bar.
@@ -253,6 +295,8 @@ export async function runInteractiveConsult(io, deps) {
         }
         else if (destination === "project-new") {
             projectName = await askLine(io, `${CLEAR}${header}New project\n\n  name: `);
+            if (projectName === undefined)
+                return cancel(io);
             if (!projectName)
                 return cancel(io);
             projectMode = "new";
@@ -265,6 +309,8 @@ export async function runInteractiveConsult(io, deps) {
         const kindLabel = SEND_KINDS[kindChoice].label;
         const prompt = await askLine(io, `${kindLabel}   Step ${steps} of ${steps}\n\n  prompt: `);
         io.write(HIDE_CURSOR);
+        if (prompt === undefined)
+            return cancel(io);
         if (prompt.length === 0) {
             io.write("Nothing to ask.\n");
             return 1;
@@ -273,8 +319,11 @@ export async function runInteractiveConsult(io, deps) {
         // image, and the picker had no way to say so. Asked after the prompt, and
         // skipped by pressing enter, so the common case costs one keystroke.
         io.write(SHOW_CURSOR);
-        const attachments = parseAttachmentLine(await askLine(io, "\n  attach files? repo-relative paths, space separated, enter to skip\n  files: "));
+        const attachmentLine = await askLine(io, "\n  attach files? repo-relative paths, space separated, enter to skip\n  files: ");
         io.write(HIDE_CURSOR);
+        if (attachmentLine === undefined)
+            return cancel(io);
+        const attachments = parseAttachmentLine(attachmentLine);
         const choices = {
             prompt,
             projectMode,
@@ -295,20 +344,8 @@ export async function runInteractiveConsult(io, deps) {
         // stop", and under raw mode that promise was false for the whole ten
         // minutes a deep research send runs. No key is read from here on.
         io.input.setRawMode?.(false);
-        // --target-url confirms which conversation a send means; it deliberately
-        // does not navigate. Picking one from a list IS a request to go there, so
-        // move the tab first and let the flag confirm it landed.
-        if (targetUrl && deps.openThread) {
-            io.write("Opening the conversation you picked...\n");
-            if (!(await deps.openThread(targetUrl))) {
-                io.write(`Could not open ${targetUrl} in the dedicated browser.\n`);
-                return 1;
-            }
-        }
         io.write(`Sending. Equivalent command:\n  prodex ${formatCommand(args)}\n\n`);
-        // Deep research runs about ten minutes; an ordinary Pro answer, minutes.
-        // Fill the bar against that so the wait has a shape.
-        const budgetMs = tools.includes("deep-research") ? 30 * 60_000 : 20 * 60_000;
+        const budgetMs = 20 * 60_000;
         const startedAt = now();
         let label = "starting";
         let tick = 0;
@@ -345,5 +382,5 @@ function cancel(io) {
 }
 /** Quote only what a shell would need quoted, so the echo can be pasted. */
 export function formatCommand(args) {
-    return args.map((arg) => (/^[A-Za-z0-9._\-/:=]+$/.test(arg) ? arg : JSON.stringify(arg))).join(" ");
+    return args.map(shellQuote).join(" ");
 }

package/dist/tui.js

@@ -75,35 +75,33 @@ export function parseAttachmentLine(line) {
 /**
  * Projects with the id their conversations are tagged with.
  *
- * The sidebar gives names only, which is enough to ENTER a project but not to
- * tell which chats live in it - and "open the project, then pick the session
- * inside it" needs exactly that link.
+ * Read only rendered links. A project id is accepted only when the visible
+ * anchor itself has a canonical ChatGPT project URL.
  */
 export function projectsWithIdsExpression() {
-    return `(async () => {
-  let token = "";
-  try {
-    const session = await fetch("/api/auth/session", { credentials: "include" });
-    if (!session.ok) return [];
-    const parsed = await session.json();
-    token = (parsed && parsed.accessToken) || "";
-  } catch (error) {
-    return [];
-  }
-  try {
-    const response = await fetch("/backend-api/gizmos/snorlax/sidebar", {
-      credentials: "include",
-      headers: token ? { Authorization: "Bearer " + token } : {}
-    });
-    if (!response.ok) return [];
-    const listed = await response.json();
-    return ((listed && listed.items) || [])
-      .map((item) => item && item.gizmo)
-      .filter((gizmo) => gizmo && gizmo.id)
-      .map((gizmo) => ({ id: gizmo.id, name: ((gizmo.display && gizmo.display.name) || gizmo.name || "").trim() || gizmo.id }));
-  } catch (error) {
-    return [];
+    return `(() => {
+  const out = [];
+  const seen = new Set();
+  for (const anchor of document.querySelectorAll("a[href]")) {
+    if (out.length >= 100) break;
+    if (typeof anchor.getClientRects !== "function" || anchor.getClientRects().length === 0) continue;
+    let url;
+    try {
+      url = new URL(anchor.getAttribute("href") || "", "https://chatgpt.com");
+    } catch (error) {
+      continue;
+    }
+    if (url.protocol !== "https:" || url.hostname !== "chatgpt.com" || url.port || url.username || url.password) continue;
+    const match = /^\\/g\\/g-p-([0-9a-f]{1,128})(?:-[^/]+)?\\/project\\/?$/i.exec(url.pathname);
+    if (!match) continue;
+    const id = "g-p-" + match[1].toLowerCase();
+    if (seen.has(id)) continue;
+    const name = ((anchor.textContent || anchor.getAttribute("aria-label") || "").replace(/\\s+/g, " ").trim()).slice(0, 200);
+    if (!name) continue;
+    seen.add(id);
+    out.push({ id, name });
   }
+  return out;
 })()`;
 }
 /** The conversations that live inside a project, or all of them without one. */
@@ -114,37 +112,53 @@ export function conversationsInProject(conversations, projectId) {
 }
 /**
  * Recent conversations with their titles, for the "continue an existing chat"
- * list. Only the sidebar listing is fetched - the transcripts themselves are
- * large and nothing here needs them.
+ * list. This is deliberately limited to rendered links; no account API or
+ * transcript is read. A project association is included only when that same
+ * visible conversation URL carries the project id.
  */
 export function recentConversationTitlesExpression(limit = 10) {
-    return `(async () => {
-  let token = "";
-  try {
-    const session = await fetch("/api/auth/session", { credentials: "include" });
-    if (!session.ok) return [];
-    const parsed = await session.json();
-    token = (parsed && parsed.accessToken) || "";
-  } catch (error) {
-    return [];
-  }
-  try {
-    const response = await fetch("/backend-api/conversations?offset=0&limit=${limit}&order=updated", {
-      credentials: "include",
-      headers: token ? { Authorization: "Bearer " + token } : {}
-    });
-    if (!response.ok) return [];
-    const listed = await response.json();
-    return ((listed && listed.items) || [])
-      .filter((item) => item && item.id)
-      .map((item) => ({
-        id: item.id,
-        title: (item.title || "").trim() || "Untitled",
-        ...(item.gizmo_id ? { gizmoId: item.gizmo_id } : {})
-      }));
-  } catch (error) {
-    return [];
+    const boundedLimit = Number.isFinite(limit) ? Math.max(0, Math.min(100, Math.floor(limit))) : 10;
+    return `(() => {
+  const out = [];
+  const seen = new Map();
+  const ambiguousProjects = new Set();
+  let inspected = 0;
+  for (const anchor of document.querySelectorAll("a[href]")) {
+    if (++inspected > 2000) break;
+    if (typeof anchor.getClientRects !== "function" || anchor.getClientRects().length === 0) continue;
+    let url;
+    try {
+      url = new URL(anchor.getAttribute("href") || "", "https://chatgpt.com");
+    } catch (error) {
+      continue;
+    }
+    if (url.protocol !== "https:" || url.hostname !== "chatgpt.com" || url.port || url.username || url.password) continue;
+    const projectMatch = /^\\/g\\/g-p-([0-9a-f]{1,128})(?:-[^/]+)?\\/c\\/([0-9a-f-]{16,128})\\/?$/i.exec(url.pathname);
+    const plainMatch = /^\\/c\\/([0-9a-f-]{16,128})\\/?$/i.exec(url.pathname);
+    const id = (projectMatch && projectMatch[2]) || (plainMatch && plainMatch[1]);
+    if (!id) continue;
+    const gizmoId = projectMatch ? "g-p-" + projectMatch[1].toLowerCase() : undefined;
+    const existing = seen.get(id);
+    if (existing) {
+      if (gizmoId && !ambiguousProjects.has(id)) {
+        if (existing.gizmoId && existing.gizmoId !== gizmoId) {
+          delete existing.gizmoId;
+          ambiguousProjects.add(id);
+        } else existing.gizmoId = gizmoId;
+      }
+      continue;
+    }
+    if (out.length >= ${boundedLimit}) continue;
+    const title = ((anchor.textContent || anchor.getAttribute("aria-label") || "").replace(/\\s+/g, " ").trim()).slice(0, 300) || "Untitled";
+    const entry = {
+      id,
+      title,
+      ...(gizmoId ? { gizmoId } : {})
+    };
+    seen.set(id, entry);
+    out.push(entry);
   }
+  return out;
 })()`;
 }
 const ESC = "";