codex-copilot-dx 0.9.23 → 0.9.25

package/src/network-route.mjs

@@ -0,0 +1,102 @@
+import net from "node:net";
+
+const OFFICIAL_API = "https://chatgpt.com/backend-api";
+
+function proxy(value, source) {
+  if (!value) return null;
+  let url;
+  try { url = new URL(value); } catch { throw new Error(`Invalid proxy address in ${source}`); }
+  if (!["http:", "https:", "socks5:", "socks5h:"].includes(url.protocol)
+    || !url.hostname || !["", "/"].includes(url.pathname) || url.search || url.hash) {
+    throw new Error(`Unsupported proxy address in ${source}; expected HTTP, HTTPS or SOCKS5`);
+  }
+  return { url, source };
+}
+
+function variable(env, lower, upper) {
+  const key = String(env[lower] || "").trim() ? lower : upper;
+  return { value: String(env[key] || "").trim(), source: key };
+}
+
+export function resolveNetworkRoute({ env = process.env, systemProxy = "", checkApi = true } = {}) {
+  const api = String(env.CODEX_API_BASE_URL || "").trim().replace(/\/+$/, "");
+  if (checkApi && api && api !== OFFICIAL_API) {
+    throw new Error("Native prediction setup skipped: CODEX_API_BASE_URL selects a custom API route; it was preserved");
+  }
+  const settings = Object.fromEntries([...systemProxy.matchAll(/^\s*([A-Za-z]+)\s*:\s*(.+?)\s*$/gm)].map((m) => [m[1], m[2]]));
+  for (const key of ["ProxyAutoConfigEnable", "ProxyAutoDiscoveryEnable"]) {
+    if (settings[key] === "1") throw new Error(`Native prediction setup skipped: system ${key === "ProxyAutoConfigEnable" ? "PAC" : "WPAD"} (${key}) needs dynamic routing; its rules were preserved`);
+  }
+  const system = (prefix, scheme) => {
+    if (settings[`${prefix}Enable`] !== "1") return null;
+    const host = settings[`${prefix}Proxy`], port = settings[`${prefix}Port`];
+    if (!host || !/^\d+$/.test(port || "") || Number(port) < 1 || Number(port) > 65535) {
+      throw new Error(`Invalid system ${prefix} proxy settings`);
+    }
+    return proxy(`${scheme}://${net.isIP(host) === 6 ? `[${host}]` : host}:${port}`, `system ${prefix}`);
+  };
+  const httpEnv = variable(env, "http_proxy", "HTTP_PROXY"), httpsEnv = variable(env, "https_proxy", "HTTPS_PROXY");
+  const allEnv = variable(env, "all_proxy", "ALL_PROXY");
+  const all = proxy(allEnv.value, allEnv.source);
+  const systemSocks = system("SOCKS", "socks5");
+  const systemHttp = system("HTTP", "http"), systemHttps = system("HTTPS", "http");
+  const http = proxy(httpEnv.value, httpEnv.source) || all || systemHttp || systemSocks;
+  const https = proxy(httpsEnv.value, httpsEnv.source) || all || systemHttps || systemSocks;
+  const noProxy = variable(env, "no_proxy", "NO_PROXY").value;
+  const exceptions = /ExceptionsList\s*:\s*<array>\s*\{([^}]+)\}/.exec(systemProxy)?.[1] || "";
+  const bypass = [...new Set([...noProxy.split(","), ...[...exceptions.matchAll(/\d+\s*:\s*([^\n]+)/g)].map((m) => m[1])]
+    .map((s) => s.trim().toLowerCase()).filter(Boolean))];
+  if (bypass.some((rule) => rule.includes("/"))) throw new Error("Unsupported proxy bypass CIDR rule in NO_PROXY or system exceptions; existing routes were preserved");
+  return { http, https, bypass, excludeSimple: settings.ExcludeSimpleHostnames === "1" };
+}
+
+export function bypassNetworkProxy(hostname, port, plan) {
+  const host = hostname.replace(/^\[|\]$/g, "").toLowerCase();
+  if (["localhost", "127.0.0.1", "::1"].includes(host) || (plan.excludeSimple && !host.includes("."))) return true;
+  return plan.bypass.some((raw) => {
+    if (raw === "*") return true;
+    const match = /^(.*):(\d+)$/.exec(raw);
+    const rule = match ? match[1] : raw;
+    if (match && Number(match[2]) !== Number(port)) return false;
+    const suffix = rule.replace(/^\*?\./, "");
+    if (rule.includes("*")) {
+      const expression = rule.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", ".*");
+      return new RegExp(`^${expression}$`).test(host);
+    }
+    return host === suffix || host.endsWith(`.${suffix}`);
+  });
+}
+
+export function networkProxyFor(url, plan) {
+  if (bypassNetworkProxy(url.hostname, url.port || (url.protocol === "https:" ? 443 : 80), plan)) return null;
+  return url.protocol === "https:" ? plan.https : plan.http;
+}
+
+export function networkRouteSnapshot(plan) {
+  const route = plan.https;
+  return { source: route?.source || "direct", type: route?.url.protocol.replace(":", "") || "direct",
+    bypass_rules: plan.bypass.length, proxy_credentials: Boolean(route?.url.username || route?.url.password) };
+}
+
+function pacProxy(route) {
+  if (!route) return "DIRECT";
+  const type = route.url.protocol.startsWith("socks5") ? "SOCKS5" : route.url.protocol === "https:" ? "HTTPS" : "PROXY";
+  const port = route.url.port || (type === "HTTPS" ? 443 : type === "SOCKS5" ? 1080 : 80);
+  return `${type} ${route.url.hostname}:${port}`;
+}
+
+export function networkPredictionPac(port, plan) {
+  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error("Invalid prediction proxy port");
+  // Embed only routing rules, never proxy passwords or API credentials.
+  return `var ccdxRoute=${JSON.stringify({ http: pacProxy(plan.http), https: pacProxy(plan.https), bypass: plan.bypass, excludeSimple: plan.excludeSimple })};
+function FindProxyForURL(url,host) {
+  var secure=url.indexOf('https:')===0, p=secure?443:80;
+  var authority=url.split('/')[2]||'', explicit=/:([0-9]+)$/.exec(authority);if(explicit)p=Number(explicit[1]);
+  var skip=host==='localhost'||host==='127.0.0.1'||host==='::1'||(ccdxRoute.excludeSimple&&host.indexOf('.')<0);
+  for(var i=0;i<ccdxRoute.bypass.length&&!skip;i++){var raw=ccdxRoute.bypass[i],m=/^(.*):([0-9]+)$/.exec(raw),r=m?m[1]:raw;if(m&&Number(m[2])!==p)continue;
+    var suffix=r.indexOf('*.')===0?r.slice(2):r[0]==='.'?r.slice(1):r;skip=r==='*'||(r.indexOf('*')>=0?shExpMatch(host,r):host===suffix||dnsDomainIs(host,'.'+suffix));}
+  var original=skip?'DIRECT':secure?ccdxRoute.https:ccdxRoute.http;
+  if(secure&&(host==='chatgpt.com'||host==='ab.chatgpt.com'))return 'PROXY 127.0.0.1:${port}; '+original;
+  return original;
+}\n`;
+}

package/src/observability.mjs

@@ -159,6 +159,7 @@ export function runtimeStatusPayload({
   codexClient,
   codexModelRegistry,
   codexModelCatalog,
+  clientIntegrations,
 } = {}) {
   const memory = process.memoryUsage();
   const codexRuntime = safeClientRuntimeStatus(codexClient);
@@ -196,6 +197,7 @@ export function runtimeStatusPayload({
     response_history: history,
     image_optimization: imageOptimizationStats(),
     image_generation: imageGeneration || null,
+    client_integrations: clientIntegrations || null,
     logging: { usage: usageLoggingStats(), debug: debugLoggingStats() },
     image_history_pressure: imagePressure?.snapshot?.() || null,
     response_failures: responseFailures?.snapshot?.() || null,

package/src/operation-error.mjs

@@ -0,0 +1,37 @@
+import { redactDiagnosticText } from "./diagnostic-text.mjs";
+
+export function operationError(code, message, { status = null, retryAt = null } = {}) {
+  return Object.assign(new Error(message), { code, status, retryAt });
+}
+
+export function operationErrorDetails(error) {
+  const code = String(error?.code || error?.cause?.code || "unknown");
+  let source = "unknown";
+  if (/proxy/i.test(code)) source = "proxy";
+  else if (/cert|tls|ssl/i.test(code)) source = "tls";
+  else if (/timeout|abort/i.test(code) || error?.name === "AbortError" || error?.name === "TimeoutError") source = "timeout";
+  else if (/limit|429/.test(code)) source = "rate_limit";
+  else if (/config|format|route|redirect/.test(code)) source = "configuration";
+  else if (/HTTP|http/.test(code)) source = "upstream";
+  else if (/ENOTFOUND|ECONN|EAI_/.test(code)) source = "network";
+  return { code: /^[A-Za-z0-9_-]{1,80}$/.test(code) ? code : "unknown", source,
+    message: redactDiagnosticText(String(error?.message || "Operation failed")).slice(0, 400),
+    status: Number.isInteger(error?.status) ? error.status : null };
+}
+
+// Error classifiers consume decoded string fields; responses retain their
+// original bytes. Only escaped, bounded JSON errors need this extra work.
+export function errorEvidenceText(value) {
+  const text = String(value || "");
+  if (!text.includes("\\u") || text.length > 16 * 1024) return text;
+  try {
+    const strings = [];
+    const visit = (node, depth) => {
+      if (depth > 4 || strings.length >= 32) return;
+      if (typeof node === "string") strings.push(node);
+      else if (node && typeof node === "object") for (const child of Object.values(node)) visit(child, depth + 1);
+    };
+    visit(JSON.parse(text), 0);
+    return `${text}\n${strings.join("\n")}`;
+  } catch { return text; }
+}

package/src/package-update.mjs

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline/promises";
-import { fetchLatestRelease, githubReleaseVersion } from "./version.mjs";
+import { lookupLatestRelease, githubReleaseVersion } from "./version.mjs";
 
 const PACKAGE_NAME = "codex-copilot-dx";
 const UPDATE_SPECS = {
@@ -95,8 +95,7 @@ export async function runPackageUpdateCommand({
   let release;
   if (selectedSource === "github") {
     output.write("Checking the latest stable GitHub release...\n");
-    release = await fetchLatestRelease({ fetchImpl, timeoutMs: 10000 });
-    if (!release) throw new Error("Could not read the latest stable GitHub release. No update was installed.");
+    release = await lookupLatestRelease({ fetchImpl, timeoutMs: 10000 });
   }
   const update = globalUpdateCommand(selectedSource, { platform, releaseTag: release?.tagName });
   const sourceLabel = selectedSource === "npm" ? "npm registry" : `GitHub release ${release.tagName}`;

package/src/prediction-retirement.mjs

@@ -0,0 +1,86 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { isDeepStrictEqual } from "node:util";
+import { atomicWriteFileIfChangedSync, atomicWriteFilePairSync } from "./atomic-file.mjs";
+import { codexTomlStatements, parseCodexToml, validateManagedConfigEdit } from "./config-toml.mjs";
+import { userSettingsPath } from "./user-settings.mjs";
+import { codexPaths } from "./codex-paths.mjs";
+import { withFileLockSync } from "./lock.mjs";
+
+const SERVER_PATH = ["mcp_servers", "ccdx_suggestion"];
+const same = (left, right) => isDeepStrictEqual(left, right);
+
+export function computeRetiredPredictionConfig(content, filePath) {
+  const before = parseCodexToml(content);
+  const expected = {
+    command: process.execPath,
+    args: [fileURLToPath(new URL("./suggestion-mcp.mjs", import.meta.url))],
+    env: { CCDX_SUGGESTION_CONFIG: filePath },
+    tool_timeout_sec: 40n,
+  };
+  const existing = before.mcp_servers?.ccdx_suggestion;
+  const owned = existing && typeof existing.enabled === "boolean"
+    && same({ ...existing, enabled: undefined }, { ...expected, enabled: undefined });
+  const statements = codexTomlStatements(content);
+  const declarations = statements.filter(item => ["table", "value"].includes(item.kind)
+    && same(item.keys.slice(0, 2), SERVER_PATH));
+  const ranges = owned ? declarations.map(item => {
+    const start = content.lastIndexOf("\n", item.start - 1) + 1;
+    const end = content.indexOf("\n", item.end);
+    return [start, end < 0 ? content.length : end + 1];
+  }) : [];
+  // Only remove the exact block emitted by 0.9.23. Modified handlers and
+  // Codex's own trust records remain untouched.
+  const quote = value => `'${value.replaceAll("'", "'\\''")}'`;
+  const command = `CCDX_SUGGESTION_CONFIG=${quote(filePath)} ${quote(process.execPath)} ${quote(fileURLToPath(new URL("./suggestion-auto.mjs", import.meta.url)))}`;
+  const block = `# ccdx:suggestion-auto:start\n[[hooks.Stop]]\n[[hooks.Stop.hooks]]\ntype = "command"\ncommand = ${JSON.stringify(command)}\nasync = true\ntimeout = 35\n# ccdx:suggestion-auto:end\n`;
+  const hookStart = content.indexOf(block);
+  const hookOwned = hookStart >= 0 && content.indexOf(block, hookStart + block.length) < 0
+    && statements.some(item => item.kind === "comment" && item.start === hookStart && item.source === "# ccdx:suggestion-auto:start");
+  if (hookOwned) ranges.push([hookStart, hookStart + block.length]);
+  let updated = content;
+  for (const [start, end] of ranges.sort((a, b) => b[0] - a[0])) updated = updated.slice(0, start) + updated.slice(end);
+  validateManagedConfigEdit(before, updated, [SERVER_PATH, ["hooks", "Stop"]]);
+  const after = parseCodexToml(updated);
+  const remaining = [...(before.hooks?.Stop || [])];
+  if (hookOwned) {
+    const index = remaining.findIndex(group => same(group, { hooks: [{ type: "command", command, async: true, timeout: 35n }] }));
+    if (index < 0) throw new Error("Retired prediction hook could not be safely removed");
+    remaining.splice(index, 1);
+  }
+  if (!same(after.hooks?.Stop || [], remaining)) throw new Error("Unrelated hooks changed; prediction cleanup was skipped");
+  return { content: updated, changed: updated !== content, preserved: Boolean(existing && !owned) || (content.includes("# ccdx:suggestion-auto:start") && !hookOwned) };
+}
+
+export function retirePredictionIntegration(options = {}) {
+  if (options.dryRun) return retirePredictionIntegrationUnlocked(options);
+  const { config } = codexPaths(options);
+  // No registration/settings means no lock directory or other write on startup.
+  const env = options.env || process.env;
+  const settings = path.resolve(env.CCDX_SUGGESTION_CONFIG || path.join(path.dirname(userSettingsPath(options)), "suggestion.json"));
+  if (!fs.existsSync(config) && !fs.existsSync(settings)) return { changed: false, preserved: false };
+  return withFileLockSync(`${config}.ccdx.lock`, () => retirePredictionIntegrationUnlocked(options));
+}
+function retirePredictionIntegrationUnlocked({ env = process.env, home = os.homedir(), dryRun = false } = {}) {
+  const settings = path.resolve(env.CCDX_SUGGESTION_CONFIG || path.join(path.dirname(userSettingsPath({ env, home })), "suggestion.json"));
+  const codex = codexPaths({ env, home }).config;
+  let content;
+  try { content = new TextDecoder("utf-8", { fatal: true }).decode(fs.readFileSync(codex)); }
+  catch (error) { if (error.code !== "ENOENT") throw new Error("Cannot safely read prediction configuration"); }
+  let serialized;
+  try {
+    const preference = JSON.parse(fs.readFileSync(settings, "utf8"));
+    if (!preference || typeof preference !== "object" || Array.isArray(preference)
+      || typeof preference.enabled !== "boolean" || typeof preference.model !== "string") throw new Error();
+    if (preference.enabled || preference.automatic) serialized = JSON.stringify({ ...preference, enabled: false, automatic: false }, null, 2) + "\n";
+  } catch (error) { if (error.code !== "ENOENT") throw new Error("Prediction settings are invalid; cleanup was skipped"); }
+  const result = content?.includes("ccdx_suggestion") || content?.includes("ccdx:suggestion-auto:start")
+    ? computeRetiredPredictionConfig(content, settings) : { content, changed: false, preserved: false };
+  if (dryRun) return { changed: result.changed || Boolean(serialized), preserved: result.preserved };
+  if (result.changed && serialized) atomicWriteFilePairSync(codex, result.content, settings, serialized);
+  else if (result.changed) atomicWriteFileIfChangedSync(codex, result.content);
+  else if (serialized) atomicWriteFileIfChangedSync(settings, serialized);
+  return { changed: result.changed || Boolean(serialized), preserved: result.preserved };
+}

package/src/proxy-tunnel.mjs

@@ -0,0 +1,102 @@
+import net from "node:net";
+import tls from "node:tls";
+import https from "node:https";
+import { networkProxyFor } from "./network-route.mjs";
+
+// A bounded read preserves bytes following the handshake for the TLS parser.
+function readSocket(socket, ready, maxBytes = 16 * 1024) {
+  return new Promise((resolve, reject) => {
+    let chunks = [], size = 0;
+    const cleanup = () => { socket.off("data", data); socket.off("error", error); socket.off("close", closed); };
+    const error = (e) => { cleanup(); reject(e); };
+    const closed = () => error(new Error("Proxy closed the connection"));
+    const data = (chunk) => {
+      chunks.push(chunk); size += chunk.length;
+      if (size > maxBytes) { error(new Error("Proxy handshake exceeds its limit")); return; }
+      const bytes = Buffer.concat(chunks, size), end = ready(bytes);
+      if (end !== null) {
+        socket.pause(); cleanup();
+        if (bytes.length > end) socket.unshift(bytes.subarray(end));
+        resolve(bytes.subarray(0, end));
+      }
+    };
+    socket.on("data", data); socket.once("error", error); socket.once("close", closed); socket.resume();
+  });
+}
+
+async function connectProxy(target, route, timeoutMs, pending) {
+  const proxy = route.url;
+  const proxyHost = proxy.hostname.replace(/^\[|\]$/g, "");
+  const socket = proxy.protocol === "https:"
+    ? tls.connect({ host: proxyHost, port: Number(proxy.port || 443), servername: net.isIP(proxyHost) ? undefined : proxyHost, rejectUnauthorized: true })
+    : net.connect({ host: proxyHost, port: Number(proxy.port || (proxy.protocol.startsWith("socks") ? 1080 : 80)) });
+  pending.add(socket);
+  const timer = setTimeout(() => socket.destroy(new Error("Proxy connection timed out")), timeoutMs);
+  socket.once("close", () => pending.delete(socket));
+  try {
+    await new Promise((resolve, reject) => {
+      const event = proxy.protocol === "https:" ? "secureConnect" : "connect";
+      const failed = (error) => { socket.off(event, connected); reject(error); };
+      const connected = () => { socket.off("error", failed); resolve(); };
+      socket.once(event, connected); socket.once("error", failed);
+    });
+    if (proxy.protocol.startsWith("socks5")) {
+      const user = Buffer.from(decodeURIComponent(proxy.username)), password = Buffer.from(decodeURIComponent(proxy.password));
+      if (user.length > 255 || password.length > 255) throw new Error("SOCKS5 proxy credentials are too long");
+      const greeting = readSocket(socket, b => b.length >= 2 ? 2 : null);
+      socket.write(user.length ? Buffer.from([5, 2, 0, 2]) : Buffer.from([5, 1, 0]));
+      const choice = await greeting;
+      if (choice[0] !== 5 || ![0, 2].includes(choice[1]) || (choice[1] === 2 && !user.length)) throw new Error("SOCKS5 proxy authentication is unsupported");
+      if (choice[1] === 2) {
+        const auth = readSocket(socket, b => b.length >= 2 ? 2 : null);
+        socket.write(Buffer.concat([Buffer.from([1, user.length]), user, Buffer.from([password.length]), password]));
+        const result = await auth; if (result[0] !== 1 || result[1] !== 0) throw new Error("SOCKS5 proxy authentication failed");
+      }
+      const host = Buffer.from(target.hostname);
+      if (host.length > 255) throw new Error("Proxy target hostname is too long");
+      const response = readSocket(socket, b => {
+        if (b.length < 5) return null;
+        const size = b[3] === 1 ? 10 : b[3] === 4 ? 22 : b[3] === 3 ? 7 + b[4] : 5;
+        return b.length >= size ? size : null;
+      });
+      socket.write(Buffer.concat([Buffer.from([5, 1, 0, 3, host.length]), host, Buffer.from([1, 187])]));
+      const result = await response;
+      if (result[0] !== 5 || result[1] !== 0 || ![1, 3, 4].includes(result[3])) throw new Error("SOCKS5 proxy rejected the connection");
+    } else {
+      const response = readSocket(socket, b => { const end = b.indexOf("\r\n\r\n"); return end < 0 ? null : end + 4; });
+      const credentials = proxy.username || proxy.password
+        ? `Proxy-Authorization: Basic ${Buffer.from(`${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`).toString("base64")}\r\n` : "";
+      socket.write(`CONNECT ${target.hostname}:443 HTTP/1.1\r\nHost: ${target.hostname}:443\r\n${credentials}\r\n`);
+      const headers = (await response).toString("latin1");
+      const status = /^HTTP\/1\.[01] (\d{3})/.exec(headers)?.[1];
+      if (status !== "200") throw new Error(`HTTP proxy rejected CONNECT (${status || "invalid response"})`);
+    }
+    clearTimeout(timer); pending.delete(socket);
+    return socket;
+  } catch (error) { clearTimeout(timer); socket.destroy(); throw error; }
+}
+
+export function createProxyAgent(plan, { timeoutMs = 30_000 } = {}) {
+  const pending = new Set();
+  let closed = false;
+  const agent = new https.Agent({ keepAlive: true, maxSockets: 32, maxFreeSockets: 4 });
+  const direct = agent.createConnection.bind(agent);
+  agent.createConnection = (options, callback) => {
+    if (closed) { queueMicrotask(() => callback(new Error("Proxy agent is closed"))); return undefined; }
+    const target = new URL(`https://${options.host}`), route = networkProxyFor(target, plan);
+    if (!route) return direct(options, callback);
+    void connectProxy(target, route, timeoutMs, pending).then(socket => {
+      if (closed) { socket.destroy(); callback(new Error("Proxy agent is closed")); return; }
+      const secure = tls.connect({ ...options, socket, rejectUnauthorized: true });
+      pending.add(secure);
+      const timer = setTimeout(() => secure.destroy(new Error("Proxy target TLS timed out")), timeoutMs);
+      const fail = (error) => { clearTimeout(timer); pending.delete(secure); secure.off("secureConnect", done); callback(error); };
+      const done = () => { clearTimeout(timer); pending.delete(secure); secure.off("error", fail); callback(null, secure); };
+      secure.once("error", fail); secure.once("secureConnect", done); secure.resume();
+    }, callback);
+    return undefined;
+  };
+  const destroy = agent.destroy.bind(agent);
+  agent.destroy = () => { closed = true; for (const socket of pending) socket.destroy(new Error("Proxy agent closed")); pending.clear(); destroy(); };
+  return agent;
+}

package/src/responses-request.mjs

@@ -309,7 +309,8 @@ export function prepareResponsesRequest(reqBody, {
   assertActive?.();
   const body = mutate ? reqBody : cloneJson(reqBody);
   assertActive?.();
-  const currentInputItems = responsesInputItems(body.input, { assertActive, clone: !mutate });
+  // body is already an owned clone unless the caller explicitly allows mutation.
+  const currentInputItems = responsesInputItems(body.input, { assertActive, clone: false });
   const currentInputRefs = new Set(
     currentInputItems.filter((item) => item && typeof item === "object"),
   );
@@ -359,7 +360,9 @@ export function prepareResponsesRequest(reqBody, {
   // concrete Copilot RoutePlan.
   if (copilotBoundary) applyCopilotResponsesRequestPolicies(body);
   stripInternalResponsesInputFields(body.input, { assertActive });
-  stripInternalResponsesInputFields(historyInputItems, { assertActive });
+  // The first pass already covers shared current items. Only an independent
+  // pre-adaptation snapshot needs another pass.
+  if (historyInputItems !== currentInputItems) stripInternalResponsesInputFields(historyInputItems, { assertActive });
   assertActive?.();
   const retainedCurrentInputStart = body.input.findIndex((item) => currentInputRefs.has(item));
 

package/src/suggestion-auto.mjs

@@ -1,107 +1,7 @@
-import fs from "node:fs";
-import path from "node:path";
-import { createHash, randomUUID } from "node:crypto";
 import { pathToFileURL } from "node:url";
-import { atomicWriteFileIfChangedSync } from "./atomic-file.mjs";
-import { readSuggestionConfig, suggestionConfigPath } from "./suggestion-config.mjs";
-import { readSuggestionContext } from "./suggestion-context.mjs";
-import { generateSuggestion } from "./suggestion-provider.mjs";
 
-const UUID = /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i;
-const RETENTION_MS = 10 * 60_000;
-function storeDirectory(filePath) { return path.join(path.dirname(filePath), "suggestion-state"); }
-function keyFile(filePath, threadId) {
-  if (!UUID.test(threadId)) throw new Error("Invalid suggestion conversation ID");
-  return path.join(storeDirectory(filePath), `${createHash("sha256").update(threadId).digest("hex")}.json`);
-}
-function readRecord(file) {
-  try {
-    const stat=fs.lstatSync(file);
-    if (!stat.isFile() || stat.size > 8192) return null;
-    const record = JSON.parse(fs.readFileSync(file,"utf8"));
-    return record && typeof record === "object" && !Array.isArray(record) ? record : null;
-  } catch { return null; }
-}
-export function readAutomaticSuggestion(filePath, threadId) { return readRecord(keyFile(filePath, threadId)); }
-function save(filePath, threadId, record) { atomicWriteFileIfChangedSync(keyFile(filePath,threadId),JSON.stringify(record)+"\n"); }
-function cleanup(directory, now) {
-  const files = fs.readdirSync(directory).filter(name=>/^[a-f0-9]{64}\.json$/.test(name));
-  const retained = [];
-  for (const name of files) {
-    const file=path.join(directory,name),record=readRecord(file);
-    if (!record || !Number.isFinite(record.at) || now-record.at>RETENTION_MS) fs.unlinkSync(file);
-    else retained.push({file,at:record.at});
-  }
-  retained.sort((a,b)=>b.at-a.at);
-  for(const record of retained.slice(31))fs.unlinkSync(record.file);
-}
-export function automaticSuggestionStatus(filePath, now = Date.now()) {
-  try {
-    const directory=storeDirectory(filePath);
-    const records=fs.readdirSync(directory).filter(name=>/^[a-f0-9]{64}\.json$/.test(name)).slice(0,64)
-      .map(name=>readRecord(path.join(directory,name))).filter(record=>record && Number.isFinite(record.at)&&now-record.at<=RETENTION_MS);
-    const recent=records.sort((a,b)=>b.at-a.at)[0];
-    return recent ? { state:["generating","ready","empty","failed","cancelled"].includes(recent.state)?recent.state:"unknown",
-      at:new Date(recent.at).toISOString(),reason:["context_unavailable","model_failed","settings_changed","turn_changed","timeout"].includes(recent.reason)?recent.reason:null } : {state:"idle",at:null,reason:null};
-  } catch { return {state:"idle",at:null,reason:null}; }
-}
-
-export async function runAutomaticSuggestion(event, {
-  filePath = suggestionConfigPath(), readContext = readSuggestionContext, generate = generateSuggestion,
-  now = Date.now, timeoutMs = 30_000,
-} = {}) {
-  const config=readSuggestionConfig({filePath});
-  if(!config.enabled || !config.automatic || event?.hook_event_name!=="Stop" || event.stop_hook_active===true
-    || !UUID.test(event.session_id||"") || !UUID.test(event.turn_id||"")) return {skipped:true};
-  const threadId=event.session_id,turnId=event.turn_id,directory=storeDirectory(filePath);
-  fs.mkdirSync(directory,{recursive:true,mode:0o700});
-  if(!fs.lstatSync(directory).isDirectory())return {skipped:true};
-  cleanup(directory,now());
-  const prior=readAutomaticSuggestion(filePath,threadId);
-  if(prior?.turnId===turnId)return {skipped:true};
-  // One local slot bounds independent asynchronous hook processes. Only owned
-  // lock files are reclaimed after their 30-second operation deadline.
-  let lock;
-  for(let slot=0;slot<1;slot++){
-    const file=path.join(directory,`slot-${slot}.lock`);
-    try{if(now()-fs.statSync(file).mtimeMs>60_000)fs.unlinkSync(file)}catch(error){if(error.code!=="ENOENT")return {skipped:true}}
-    try{const fd=fs.openSync(file,"wx",0o600);fs.closeSync(fd);lock=file;break}catch(error){if(error.code!=="EEXIST")return {skipped:true}}
-  }
-  if(!lock)return {skipped:true,busy:true};
-  const abort=new AbortController(),timer=setTimeout(()=>abort.abort(),timeoutMs);
-  let stage="context_unavailable";
-  try {
-    // The slot acquisition and marker commit are synchronous within this process.
-    if(readAutomaticSuggestion(filePath,threadId)?.turnId===turnId)return {skipped:true};
-    save(filePath,threadId,{state:"generating",at:now(),turnId,model:config.model});
-    const page=await readContext(threadId,config,{signal:abort.signal,includePage:true});
-    if(page.latestTurnId!==turnId){save(filePath,threadId,{state:"cancelled",at:now(),turnId,model:config.model,reason:"turn_changed"});return {skipped:true};}
-    const current=readSuggestionConfig({filePath});
-    if(!current.enabled||!current.automatic||current.model!==config.model||current.adapter_url!==config.adapter_url){stage="settings_changed";throw new Error();}
-    stage="model_failed";
-    const suggestion=await generate(page.messages,config,{signal:abort.signal});
-    abort.signal.throwIfAborted();
-    const latest=readSuggestionConfig({filePath});
-    if(!latest.enabled||!latest.automatic||latest.model!==config.model||latest.adapter_url!==config.adapter_url){stage="settings_changed";throw new Error();}
-    stage="context_unavailable";
-    const finalPage=await readContext(threadId,config,{signal:abort.signal,includePage:true});
-    if(finalPage.latestTurnId!==turnId){stage="turn_changed";throw new Error();}
-    const result={state:suggestion?"ready":"empty",at:now(),turnId,model:config.model,suggestion,candidate_id:suggestion?randomUUID():null};
-    save(filePath,threadId,result);return result;
-  } catch {
-    const result={state:abort.signal.aborted?"cancelled":"failed",at:now(),turnId,model:config.model,reason:abort.signal.aborted?"timeout":stage};
-    // Don't overwrite a newer hook's marker.
-    if(readAutomaticSuggestion(filePath,threadId)?.turnId===turnId)save(filePath,threadId,result);
-    return result;
-  } finally {clearTimeout(timer);try{fs.unlinkSync(lock)}catch{}}
-}
-
-async function main(){
-  let chunks=[],bytes=0;
-  for await(const chunk of process.stdin){bytes+=chunk.length;if(bytes>64*1024)return;chunks.push(chunk)}
-  let event;try{event=JSON.parse(Buffer.concat(chunks).toString("utf8"))}catch{return}
-  // Informational hook: no continuation, warnings, approval or user messages.
-  await runAutomaticSuggestion(event);
+// Older configurations may still invoke this retired hook after an upgrade.
+// Do not consume stdin, read session data, or request another model response.
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   process.stdout.write("{}\n");
 }
-if(process.argv[1]&&import.meta.url===pathToFileURL(process.argv[1]).href)main().catch(()=>{process.stdout.write("{}\n")});