codex-copilot-dx 0.9.23 → 0.9.25

package/src/suggestion-mcp.mjs

@@ -1,145 +1,77 @@
-import fs from "node:fs";
-import { pathToFileURL } from "node:url";
-import { randomUUID } from "node:crypto";
 import { StringDecoder } from "node:string_decoder";
-import { readSuggestionConfig, suggestionConfigPath } from "./suggestion-config.mjs";
-import { readSuggestionContext, suggestionThreadId } from "./suggestion-context.mjs";
-import { generateSuggestion } from "./suggestion-provider.mjs";
-import { readAutomaticSuggestion } from "./suggestion-auto.mjs";
+import { pathToFileURL } from "node:url";
+
+const MAX_LINE_BYTES = 64 * 1024;
+const PROTOCOL_VERSIONS = new Set(["2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"]);
+const RETIRED = "CCDX next-message MCP has been retired. Remove the old ccdx_suggestion MCP configuration.";
 
-const URI = "ui://ccdx-suggestion/panel.html";
-const protocolVersions = new Set(["2024-11-05", "2025-03-26", "2025-06-18", "2025-11-25", "2026-07-28"]);
-export const SUGGESTION_TOOLS = [
-  {
-    name: "suggest_next_message", title: "Next message / 下一句",
-    description: "Open an optional next-message suggestion for this local conversation. Use only when the user asks for a suggestion. Reads a bounded page of recent user/assistant text and makes one request to the user's selected model through local CCDX. Does not send a message, modify a draft, execute tools, or grant approval. The user can add the suggestion to their ordinary draft in the panel.",
-    inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    annotations: { readOnlyHint: true, openWorldHint: true, destructiveHint: false },
-    _meta: { ui: { resourceUri: URI }, "openai/ui": { entrypoints: [{ type: "thread" }] } },
-  },
-  {
-    name: "prepare_suggestion_draft", title: "Check draft destination",
-    description: "Validate a suggestion's originating conversation before the user explicitly adds it to their draft. Does not send or write anything.",
-    inputSchema: { type: "object", properties: { candidate_id: { type: "string" } }, required: ["candidate_id"], additionalProperties: false },
-    annotations: { readOnlyHint: true, openWorldHint: false, destructiveHint: false },
-    _meta: { ui: { visibility: ["app"] } },
-  },
-  {
-    name:"latest_suggestion",title:"Read latest suggestion",
-    description:"Read an already-generated candidate for this local conversation. Does not invoke a model or edit a draft.",
-    inputSchema:{type:"object",properties:{},additionalProperties:false},
-    annotations:{readOnlyHint:true,openWorldHint:false,destructiveHint:false},_meta:{ui:{visibility:["app"]}},
-  },
-];
+function reply(request) {
+  const id = request?.id;
+  const validId = id === null || typeof id === "string" || (typeof id === "number" && Number.isFinite(id));
+  if (!request || Array.isArray(request) || request.jsonrpc !== "2.0" || typeof request.method !== "string"
+    || (id !== undefined && !validId)) {
+    return { jsonrpc: "2.0", id: validId ? id : null, error: { code: -32600, message: "Invalid JSON-RPC request" } };
+  }
+  if (id === undefined) return null;
+  let result;
+  switch (request.method) {
+    case "initialize":
+      result = {
+        protocolVersion: PROTOCOL_VERSIONS.has(request.params?.protocolVersion) ? request.params.protocolVersion : "2025-11-25",
+        capabilities: { tools: { listChanged: false }, resources: {} },
+        serverInfo: { name: "ccdx-suggestion", version: "1" },
+        instructions: RETIRED,
+      };
+      break;
+    case "ping": result = {}; break;
+    case "tools/list": result = { tools: [] }; break;
+    case "resources/list": result = { resources: [] }; break;
+    case "resources/templates/list": result = { resourceTemplates: [] }; break;
+    case "tools/call": result = { isError: true, content: [{ type: "text", text: RETIRED }] }; break;
+    default: return { jsonrpc: "2.0", id, error: { code: -32601, message: RETIRED } };
+  }
+  return { jsonrpc: "2.0", id, result };
+}
 
-export function createSuggestionMcp({
-  loadConfig = () => readSuggestionConfig({ filePath: suggestionConfigPath() }),
-  readContext = readSuggestionContext, generate = generateSuggestion,
-  now = Date.now, timeoutMs = 30_000,
-  loadAutomatic = threadId => readAutomaticSuggestion(suggestionConfigPath(),threadId),
-} = {}) {
-  const candidates = new Map();
-  let active = 0;
-  const prune = () => { for (const [id, item] of candidates) if (now() - item.at > 10 * 60_000) candidates.delete(id); };
-  const result = data => ({ content: [{ type: "text", text: data.suggestion || "No suggestion available. Open the panel to try again." }], structuredContent: data });
-  return async function handle(request, { signal } = {}) {
-    const config = loadConfig();
-    if (request.method === "initialize") return {
-      protocolVersion: protocolVersions.has(request.params?.protocolVersion) ? request.params.protocolVersion : "2025-11-25",
-      capabilities: { tools: { listChanged: false }, resources: {} },
-      serverInfo: { name: "ccdx-suggestion", version: "1" },
-      instructions: "Optional next-message panel. Call only when requested by the user. No automatic messages, no client patch, no approvals implied. Disabled until the user runs ccdx suggestion on.",
-    };
-    if (request.method === "ping") return {};
-    if (request.method === "tools/list") return { tools: config.enabled ? SUGGESTION_TOOLS : [] };
-    if (request.method === "resources/list") return { resources: config.enabled ? [{ uri: URI, name: "Next message", mimeType: "text/html;profile=mcp-app" }] : [] };
-    if (request.method === "resources/templates/list") return { resourceTemplates: [] };
-    if (!config.enabled) { candidates.clear(); throw new Error("Next-message suggestions are disabled. Run ccdx suggestion on to enable them"); }
-    if (request.method === "resources/read" && request.params?.uri === URI) return {
-      contents: [{ uri: URI, mimeType: "text/html;profile=mcp-app", text: fs.readFileSync(new URL("./suggestion-ui.html", import.meta.url), "utf8") }],
-    };
-    if (request.method !== "tools/call") throw new Error("Unsupported suggestion method");
-    const threadId = suggestionThreadId(request.params?._meta);
-    const args = request.params?.arguments || {};
-    if (typeof args !== "object" || Array.isArray(args)) throw new Error("Invalid suggestion parameters");
-    prune();
-    const automatic = () => {
-      const item=loadAutomatic(threadId);
-      return item?.state==="ready" && typeof item.suggestion==="string" && item.suggestion.length<=300
-        && typeof item.candidate_id==="string" && item.model===config.model && Number.isFinite(item.at) && now()-item.at<=10*60_000 ? item : null;
-    };
-    if(request.params.name==="latest_suggestion"){
-      if(Object.keys(args).length)throw new Error("Invalid latest suggestion parameters");
-      const item=automatic();return result(item?{suggestion:item.suggestion,candidate_id:item.candidate_id,model:item.model}:{suggestion:null,candidate_id:null,model:config.model});
+export function runSuggestionStdio({ input = process.stdin, output = process.stdout } = {}) {
+  let decoder = new StringDecoder("utf8"), line = "", bytes = 0, closed = false;
+  const close = () => { closed = true; input.destroy(); };
+  const write = value => {
+    if (value && !closed && !output.destroyed && !output.writableEnded) {
+      if (!output.write(JSON.stringify(value) + "\n")) input.pause();
     }
-    if (request.params.name === "prepare_suggestion_draft") {
-      if (Object.keys(args).some(key => key !== "candidate_id")) throw new Error("Invalid draft parameters");
-      const stored=automatic();
-      const item = candidates.get(args.candidate_id) || (stored?.candidate_id===args.candidate_id?{...stored,threadId}:null);
-      if (!item || item.threadId !== threadId || item.model !== config.model) throw new Error("Suggestion expired or conversation changed; generate a new suggestion");
-      if(stored?.candidate_id===args.candidate_id){
-        const page=await readContext(threadId,config,{signal,includePage:true});
-        if(page.latestTurnId!==stored.turnId)throw new Error("Conversation changed; generate a new suggestion");
-      }
-      return result({ candidate_id: args.candidate_id, suggestion: item.suggestion, model: item.model });
+  };
+  const finishLine = () => {
+    line += decoder.end();
+    if (line.trim()) {
+      let request;
+      try { request = JSON.parse(line); }
+      catch { write({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Invalid JSON" } }); }
+      if (request !== undefined) write(reply(request));
     }
-    if (request.params.name !== "suggest_next_message" || Object.keys(args).length) throw new Error("Invalid suggestion tool or parameters");
-    if (active >= 2) throw new Error("Suggestions are busy. Wait for the current request; no extra model call was made");
-    active += 1;
-    const controller = new AbortController();
-    const abort = () => controller.abort(new Error("Suggestion cancelled"));
-    signal?.addEventListener("abort", abort, { once: true });
-    if (signal?.aborted) abort();
-    const timer = setTimeout(abort, timeoutMs);
-    try {
-      const messages = await readContext(threadId, config, { signal: controller.signal });
-      controller.signal.throwIfAborted();
-      const latest = loadConfig();
-      if (!latest.enabled || latest.model !== config.model || latest.adapter_url !== config.adapter_url) throw new Error("Suggestion settings changed; generate again with the current selection");
-      const suggestion = await generate(messages, config, { signal: controller.signal });
-      controller.signal.throwIfAborted();
-      if (!loadConfig().enabled) throw new Error("Suggestions were disabled");
-      const candidate_id = suggestion ? randomUUID() : null;
-      if (candidate_id) {
-        while (candidates.size >= 16) candidates.delete(candidates.keys().next().value);
-        candidates.set(candidate_id, { suggestion, model: config.model, threadId, at: now() });
-      }
-      return result({ suggestion, candidate_id, model: config.model });
-    } finally { active -= 1; clearTimeout(timer); signal?.removeEventListener("abort", abort); }
+    line = ""; bytes = 0; decoder = new StringDecoder("utf8");
   };
-}
-
-export function runSuggestionStdio({ input = process.stdin, output = process.stdout, handle = createSuggestionMcp() } = {}) {
-  const decoder = new StringDecoder("utf8"), pending = new Map();
-  let buffer = "";
-  const write = value => { if (!output.destroyed) output.write(JSON.stringify(value) + "\n"); };
-  const close = () => { for (const controller of pending.values()) controller.abort(); pending.clear(); };
-  input.on("end", close);
   input.on("error", close);
   output.on("error", close);
+  output.on("drain", () => { if (!closed) input.resume(); });
+  input.on("end", () => { if (!closed && bytes) finishLine(); });
   input.on("data", chunk => {
-    buffer += decoder.write(chunk);
-    if (Buffer.byteLength(buffer) > 64 * 1024) { close(); input.destroy(); return; }
-    let end;
-    while ((end = buffer.indexOf("\n")) >= 0) {
-      const line = buffer.slice(0, end); buffer = buffer.slice(end + 1);
-      let request;
-      try { request = JSON.parse(line); } catch { write({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Invalid JSON" } }); continue; }
-      if (request?.method === "notifications/cancelled") { pending.get(request.params?.requestId)?.abort(); continue; }
-      if (request?.id === undefined) continue;
-      const id = request.id;
-      if (request.jsonrpc !== "2.0" || !["string", "number"].includes(typeof id) || typeof request.method !== "string" || pending.has(id) || pending.size >= 16) {
-        write({ jsonrpc: "2.0", id: typeof id === "string" || typeof id === "number" ? id : null, error: { code: -32600, message: "Invalid or busy request" } }); continue;
+    if (closed) return;
+    const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    let start = 0;
+    while (start < data.length && !closed) {
+      const end = data.indexOf(10, start);
+      const limit = end < 0 ? data.length : end;
+      bytes += limit - start;
+      if (bytes > MAX_LINE_BYTES) {
+        write({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "MCP request exceeds 65536 bytes" } });
+        close();
+        return;
       }
-      const controller = new AbortController(); pending.set(id, controller);
-      Promise.resolve().then(() => handle(request, { signal: controller.signal }))
-        .then(result => write({ jsonrpc: "2.0", id, result }), error => {
-          // Never expose raw upstream responses, prompts, stack traces or config.
-          const message = String(error?.message || "Suggestion failed").replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").slice(0,300);
-          write({ jsonrpc: "2.0", id, ...(request.method === "tools/call"
-            ? { result: { isError: true, content: [{ type: "text", text: message }] } }
-            : { error: { code: -32603, message } }) });
-        }).finally(() => pending.delete(id));
+      line += decoder.write(data.subarray(start, limit));
+      if (end < 0) break;
+      finishLine();
+      start = end + 1;
     }
   });
 }

package/src/user-settings.mjs

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { atomicWriteFileIfChangedSync } from "./atomic-file.mjs";
+import { withFileLockSync } from "./lock.mjs";
 import { AUTO_REVIEW_REASONING_EFFORTS, DEFAULT_CODEX_AUTO_REVIEW_MODEL } from "./models.mjs";
 import { loadRuntimeConfig, RUNTIME_DEFAULTS } from "./runtime-config.mjs";
 import {
@@ -155,7 +156,10 @@ export function decodedBodyLimitPreference({ env = process.env, home = os.homedi
   return { bytes: RUNTIME_DEFAULTS.maxDecodedBodyBytes, mib: DECODED_BODY_LIMIT_MIN_MIB, source: "default" };
 }
 
-export function writeDecodedBodyLimitMib(mib, { env = process.env, home = os.homedir() } = {}) {
+export function writeDecodedBodyLimitMib(mib, options = {}) {
+  return withFileLockSync(`${userSettingsPath(options)}.lock`, () => writeDecodedBodyLimitMibUnlocked(mib, options));
+}
+function writeDecodedBodyLimitMibUnlocked(mib, { env = process.env, home = os.homedir() } = {}) {
   const filePath = userSettingsPath({ env, home });
   const settings = readUserSettings({ env, home, strict: true });
   const next = { ...settings };
@@ -177,7 +181,10 @@ export function writeDecodedBodyLimitMib(mib, { env = process.env, home = os.hom
   return { changed, filePath, ...decodedBodyLimitPreference({ env, home }) };
 }
 
-export function writeResponseHistoryLimitMib(mib, { env = process.env, home = os.homedir() } = {}) {
+export function writeResponseHistoryLimitMib(mib, options = {}) {
+  return withFileLockSync(`${userSettingsPath(options)}.lock`, () => writeResponseHistoryLimitMibUnlocked(mib, options));
+}
+function writeResponseHistoryLimitMibUnlocked(mib, { env = process.env, home = os.homedir() } = {}) {
   const filePath = userSettingsPath({ env, home });
   const settings = readUserSettings({ env, home, strict: true });
   const next = { ...settings };
@@ -199,7 +206,10 @@ export function writeResponseHistoryLimitMib(mib, { env = process.env, home = os
   return { changed, filePath, ...responseHistoryLimitPreference({ env, home }) };
 }
 
-export function writeAutoReviewModel(model, { env = process.env, home = os.homedir(), reasoningEffort } = {}) {
+export function writeAutoReviewModel(model, options = {}) {
+  return withFileLockSync(`${userSettingsPath(options)}.lock`, () => writeAutoReviewModelUnlocked(model, options));
+}
+function writeAutoReviewModelUnlocked(model, { env = process.env, home = os.homedir(), reasoningEffort } = {}) {
   if (reasoningEffort !== undefined && reasoningEffort !== null
     && !AUTO_REVIEW_REASONING_EFFORTS.includes(reasoningEffort)) {
     throw new Error("Auto-review reasoning effort is invalid");
@@ -220,7 +230,10 @@ export function writeAutoReviewModel(model, { env = process.env, home = os.homed
   return { changed, filePath, model: value || DEFAULT_CODEX_AUTO_REVIEW_MODEL };
 }
 
-export function writeTerminalAnimationTheme(theme, { env = process.env, home = os.homedir() } = {}) {
+export function writeTerminalAnimationTheme(theme, options = {}) {
+  return withFileLockSync(`${userSettingsPath(options)}.lock`, () => writeTerminalAnimationThemeUnlocked(theme, options));
+}
+function writeTerminalAnimationThemeUnlocked(theme, { env = process.env, home = os.homedir() } = {}) {
   if (!isTerminalAnimationTheme(theme)) {
     const choices = TERMINAL_ANIMATION_THEMES.map(({ id }) => id).join(", ");
     throw new Error(`Terminal animation must be one of: ${choices}`);

package/src/version.mjs

@@ -1,9 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { operationError } from "./operation-error.mjs";
 
-const GITHUB_LATEST_RELEASE_URL = "https://api.github.com/repos/DaleXiao/codex-copilot-dx/releases/latest";
-const MAX_RELEASE_BYTES = 256 * 1024;
+const GITHUB_LATEST_RELEASE_URL = "https://github.com/DaleXiao/codex-copilot-dx/releases/latest";
 
 export function localPackageVersion() {
   const here = path.dirname(fileURLToPath(import.meta.url));
@@ -37,62 +37,39 @@ export function githubReleaseVersion(tag) {
   return match.slice(1).join(".");
 }
 
-async function readReleaseJson(response, signal) {
-  const reader = response.body?.getReader?.();
-  if (!reader) throw new Error("GitHub release response has no readable body");
-  const cancel = () => { void reader.cancel().catch(() => {}); };
-  signal.addEventListener("abort", cancel, { once: true });
-  const chunks = [];
-  let bytes = 0;
-  let complete = false;
-  try {
-    if (Number(response.headers?.get?.("content-length")) > MAX_RELEASE_BYTES) {
-      throw new Error("GitHub release response is too large");
-    }
-    while (!signal.aborted) {
-      const { done, value } = await reader.read();
-      if (done) {
-        complete = true;
-        break;
-      }
-      bytes += value.byteLength;
-      if (bytes > MAX_RELEASE_BYTES) throw new Error("GitHub release response is too large");
-      chunks.push(Buffer.from(value));
-    }
-    if (signal.aborted) throw new Error("GitHub release request timed out");
-    return JSON.parse(Buffer.concat(chunks, bytes).toString("utf8"));
-  } finally {
-    signal.removeEventListener("abort", cancel);
-    if (!complete) cancel();
-    reader.releaseLock();
-  }
-}
-
-export async function fetchLatestRelease({ fetchImpl = fetch, timeoutMs = 2000 } = {}) {
+export async function lookupLatestRelease({ fetchImpl = fetch, timeoutMs = 2000 } = {}) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
     const resp = await fetchImpl(GITHUB_LATEST_RELEASE_URL, {
-      headers: { Accept: "application/vnd.github+json", "User-Agent": "codex-copilot-dx" },
-      redirect: "error",
+      headers: { Accept: "text/html", "User-Agent": "codex-copilot-dx" },
+      redirect: "manual",
       signal: controller.signal,
     });
-    if (!resp.ok) {
-      void resp.body?.cancel?.().catch(() => {});
-      return null;
+    void resp.body?.cancel?.().catch(() => {});
+    if ([403, 429].includes(resp.status)) throw operationError("github_rate_limit", `GitHub release lookup was refused (HTTP ${resp.status}); retry later. No update was installed.`, { status: resp.status });
+    if (![301, 302, 303, 307, 308].includes(resp.status)) throw operationError("github_http_error", `GitHub release lookup returned HTTP ${resp.status}; no stable release redirect was received. No update was installed.`, { status: resp.status });
+    let url;
+    try { url = new URL(resp.headers.get("location"), GITHUB_LATEST_RELEASE_URL); } catch {}
+    const match = url?.pathname.match(/^\/DaleXiao\/codex-copilot-dx\/releases\/tag\/([^/]+)$/i);
+    const tagName = match?.[1], version = githubReleaseVersion(tagName);
+    if (!url || url.origin !== "https://github.com" || url.username || url.password || url.search || url.hash || !version) {
+      throw operationError("github_invalid_redirect", "GitHub did not return a valid stable release tag for this repository. No update was installed.");
     }
-    const data = await readReleaseJson(resp, controller.signal);
-    const version = githubReleaseVersion(data?.tag_name);
-    return version && data.draft === false && data.prerelease === false
-      ? { version, tagName: data.tag_name }
-      : null;
-  } catch {
-    return null;
+    return { version, tagName };
+  } catch (error) {
+    if (error.code?.startsWith("github_")) throw error;
+    if (controller.signal.aborted) throw operationError("github_timeout", "GitHub release lookup timed out. No update was installed.");
+    throw operationError(error.cause?.code || "github_network_error", "Could not connect to the GitHub release page. Check your network or proxy. No update was installed.");
   } finally {
     clearTimeout(timer);
   }
 }
 
+export async function fetchLatestRelease(options = {}) {
+  try { return await lookupLatestRelease(options); } catch { return null; }
+}
+
 export async function fetchLatestVersion(options) {
   return (await fetchLatestRelease(options))?.version || null;
 }

package/src/cli-suggestion.mjs

@@ -1,120 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { createInterface } from "node:readline/promises";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { atomicWriteFileIfChangedSync, atomicWriteFilePairSync } from "./atomic-file.mjs";
-import { loadAutoReviewModelCatalog } from "./auto-review-model.mjs";
-import { parseAdapterAddressOptions } from "./cli-options.mjs";
-import { adapterBaseUrl } from "./running-adapter.mjs";
-import { terminalCell } from "./cli-table.mjs";
-import { resolveSuggestionCodexBinary } from "./suggestion-context.mjs";
-import { suggestionAdapterUrl } from "./suggestion-provider.mjs";
-import { computeSuggestionAutoHook, computeSuggestionMcpConfig, readSuggestionCodexConfig, readSuggestionConfig, suggestionCodexConfigPath, suggestionConfigPath } from "./suggestion-config.mjs";
-
-export async function supportsSuggestionHooks(binary) {
-  const directory=fs.mkdtempSync(path.join(os.tmpdir(),"ccdx-hook-probe-"));
-  try {
-    const {stdout}=await promisify(execFile)(binary,["features","list"],{cwd:directory,env:{CODEX_HOME:directory,PATH:process.env.PATH||""},timeout:1500,maxBuffer:128*1024,encoding:"utf8"});
-    return /^hooks\s+(?:stable|beta|experimental|under development)\s+true\s*$/m.test(stdout);
-  } catch {return false;} finally {fs.rmSync(directory,{recursive:true,force:true});}
-}
-
-export async function runSuggestionCommand({
-  action = "status", model, commandName = "ccdx", env = process.env, home = os.homedir(),
-  input = process.stdin, output = process.stdout, prompt,
-  loadCatalog = loadAutoReviewModelCatalog, resolveBinary = resolveSuggestionCodexBinary, probeHooks = supportsSuggestionHooks,
-} = {}) {
-  const filePath = suggestionConfigPath({ env, home });
-  const codexPath = suggestionCodexConfigPath({ env, home });
-  const current = readSuggestionConfig({ filePath, strict: true });
-  const original = readSuggestionCodexConfig(codexPath);
-  const preview = computeSuggestionMcpConfig(original, { filePath, enabled: action === "on" ? true : current.enabled });
-  if (action === "status") {
-    output.write(`Next-message suggestions: ${current.enabled ? "enabled" : "disabled"}\nModel: ${terminalCell(current.model)}\n`);
-    if (preview.skipped) output.write(`${preview.reason}\n`);
-    else if (current.enabled && preview.changed) output.write(`MCP registration is missing or disabled. Run ${commandName} suggestion on to repair it.\n`);
-    output.write(`Automatic generation: ${current.enabled && current.automatic ? "configured; Codex hook review is required before it can run" : "unavailable or not configured"}\nAutomatic draft insertion: unavailable; choose Add to draft.\n`);
-    return { ...current, configured: !preview.changed && !preview.skipped };
-  }
-  if (!["on", "off", "model"].includes(action)) throw new Error("Suggestion action must be on, off, model, or status");
-  if (preview.skipped && action !== "off") {
-    output.write(`${preview.reason}. No changes made.\n`);
-    return { changed: false, skipped: true };
-  }
-  const hookPreview=computeSuggestionAutoHook(original,{filePath,enabled:current.enabled&&current.automatic===true});
-  if (action === "on" && current.enabled && current.automatic !== undefined && !preview.changed && !hookPreview.changed) {
-    output.write("Suggestions are already configured; kept unchanged.\n");
-    return { changed: false, ...current };
-  }
-  if (action === "off" && !current.enabled && !fs.existsSync(filePath) && !preview.changed) {
-    output.write("Suggestions remain disabled; nothing installed.\n");
-    return { changed: false, ...current };
-  }
-  let selected = current.model, reasoning = current.reasoning_effort, catalog;
-  if (action !== "off") {
-    catalog = await loadCatalog({ env, home });
-    const choices = catalog.modelIds.filter(id => /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(id));
-    if (!choices.length) throw new Error("No selectable suggestion models are available");
-    if (action === "model" && !model) {
-      if (!prompt && (!input.isTTY || !output.isTTY)) throw new Error(`${commandName} suggestion model needs an interactive terminal or a model ID`);
-      output.write("Choose the suggestion model:\n");
-      choices.forEach((id, index) => output.write(`  ${index + 1}. ${terminalCell(id)}${id === current.model ? " [current]" : ""}\n`));
-      const rl = prompt ? null : createInterface({ input, output });
-      try {
-        const defaultIndex = Math.max(0, choices.indexOf(current.model));
-        while (true) {
-          const answer = String(await (prompt || (text => rl.question(text)))(`Select [${defaultIndex + 1}], or q to cancel: `)).trim();
-          if (answer.toLowerCase() === "q") return { changed: false, cancelled: true };
-          const index = answer ? Number(answer) - 1 : defaultIndex;
-          if (Number.isInteger(index) && index >= 0 && index < choices.length) { selected = choices[index]; break; }
-          output.write("Enter a listed number, or q to cancel.\n");
-        }
-      } finally { rl?.close(); }
-    } else if (action === "model") selected = model;
-    if (!choices.includes(selected)) throw new Error(`Model ${terminalCell(selected)} is not available. Use ${commandName} suggestion model to select an available model`);
-    reasoning = catalog.reasoningEfforts?.[selected]?.includes("low") ? "low" : null;
-  }
-  // Re-read both files after asynchronous model lookup/prompts; never overwrite
-  // concurrent user edits or unrelated shared settings.
-  let binary,hookSupported=false;
-  if(action==="on" || action==="model" && current.enabled){
-    binary=resolveBinary(env);
-    hookSupported=process.platform!=="win32"&&await probeHooks(binary);
-  }
-  const latest = readSuggestionConfig({ filePath, strict: true });
-  if (action !== "model") {
-    selected = latest.model;
-    if (action === "on" && !catalog.modelIds.includes(selected)) throw new Error("Suggestion model changed during setup; retry with the current selection");
-    reasoning = action === "off" ? latest.reasoning_effort : catalog.reasoningEfforts?.[selected]?.includes("low") ? "low" : null;
-  }
-  const before = readSuggestionCodexConfig(codexPath);
-  const enabled = action === "on" ? true : action === "off" ? false : latest.enabled;
-  const codex = computeSuggestionMcpConfig(before, { filePath, enabled });
-  if (codex.skipped && action !== "off") {
-    output.write(`${codex.reason}. No changes made.\n`);
-    return { changed: false, skipped: true };
-  }
-  const hook=computeSuggestionAutoHook(codex.content,{filePath,enabled:enabled&&hookSupported});
-  const next = { ...latest, enabled, model: selected, reasoning_effort: reasoning ?? null, automatic:enabled&&hookSupported&&!hook.skipped };
-  if (enabled) {
-    const address = parseAdapterAddressOptions(env);
-    const host = ["0.0.0.0", "localhost"].includes(address.adapterHost) ? "127.0.0.1" : address.adapterHost === "::" ? "::1" : address.adapterHost;
-    next.adapter_url = suggestionAdapterUrl(`${adapterBaseUrl(host, address.adapterPort)}/v1`);
-    next.codex_binary = binary;
-    next.codex_home = path.dirname(codexPath);
-  }
-  const serialized = `${JSON.stringify(next, null, 2)}\n`;
-  let changed;
-  if ((codex.changed || hook.changed) && !codex.skipped) {
-    atomicWriteFilePairSync(codexPath, hook.content, filePath, serialized, { writeFile: atomicWriteFileIfChangedSync });
-    changed = true;
-  } else changed = atomicWriteFileIfChangedSync(filePath, serialized);
-  output.write(`Suggestions: ${next.enabled ? "enabled" : "disabled"}\nModel: ${terminalCell(next.model)}\n`);
-  output.write(`Automatic generation: ${next.automatic?"configured; review this CCDX Stop hook in Codex before it can run":"unavailable or disabled"}\nDraft insertion: choose Add to draft; never sends automatically.\n`);
-  if(next.automatic)output.write("Use Codex's hook review screen (or /hooks in Codex CLI). Trust only the CCDX suggestion-auto.mjs command. CCDX never grants hook trust.\n");
-  if (codex.skipped) output.write(`${codex.reason}. CCDX suggestion requests are disabled.\n`);
-  if (enabled) output.write("Open Next message in the conversation panel, or ask Codex for a next-message suggestion. Add to draft never sends.\nIf the tool is not visible, restart Codex App once. Official prediction settings are not modified.\n");
-  return { ...next, changed };
-}

package/src/suggestion-config.mjs

@@ -1,98 +0,0 @@
-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 { parseCodexToml, codexTomlStatements, validateManagedConfigEdit } from "./config-toml.mjs";
-import { userSettingsPath } from "./user-settings.mjs";
-
-export const DEFAULT_SUGGESTION_MODEL = "gpt-6-luna";
-export const SUGGESTION_SERVER = "ccdx_suggestion";
-const sectionPath = ["mcp_servers", SUGGESTION_SERVER];
-
-export function suggestionConfigPath({ env = process.env, home = os.homedir() } = {}) {
-  return path.resolve(env.CCDX_SUGGESTION_CONFIG || path.join(path.dirname(userSettingsPath({ env, home })), "suggestion.json"));
-}
-
-export function readSuggestionConfig({ filePath = suggestionConfigPath(), strict = false } = {}) {
-  try {
-    const value = JSON.parse(fs.readFileSync(filePath, "utf8"));
-    if (!value || typeof value !== "object" || Array.isArray(value)
-      || typeof value.enabled !== "boolean"
-      || (value.automatic !== undefined && typeof value.automatic !== "boolean")
-      || typeof value.model !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(value.model)) throw new Error();
-    return value;
-  } catch (error) {
-    if (error.code === "ENOENT") return { enabled: false, model: DEFAULT_SUGGESTION_MODEL };
-    if (strict) throw new Error("Invalid suggestion settings; no changes were written");
-    return { enabled: false, model: DEFAULT_SUGGESTION_MODEL };
-  }
-}
-
-export function suggestionMcpSection(filePath) {
-  return {
-    enabled: true,
-    command: process.execPath,
-    args: [fileURLToPath(new URL("./suggestion-mcp.mjs", import.meta.url))],
-    env: { CCDX_SUGGESTION_CONFIG: filePath },
-    tool_timeout_sec: 40n,
-  };
-}
-
-export function computeSuggestionMcpConfig(content, { enabled, filePath }) {
-  const parsed = parseCodexToml(content);
-  if (Object.values(parsed.profiles || {}).some(profile => Object.hasOwn(profile?.mcp_servers || {}, SUGGESTION_SERVER))) {
-    return { content, changed: false, skipped: true, reason: "Existing profile-specific suggestion MCP configuration was preserved" };
-  }
-  const existing = parsed.mcp_servers?.[SUGGESTION_SERVER];
-  const expected = suggestionMcpSection(filePath);
-  if (existing !== undefined) {
-    if (typeof existing.enabled !== "boolean" || !isDeepStrictEqual({ ...existing, enabled: true }, expected)) {
-      return { content, changed: false, skipped: true, reason: "Existing suggestion MCP configuration is user-managed; kept unchanged" };
-    }
-    if (existing.enabled === enabled) return { content, changed: false };
-    const entry = codexTomlStatements(content).find(item => item.kind === "value"
-      && isDeepStrictEqual(item.keys, [...sectionPath, "enabled"]));
-    if (!entry) return { content, changed: false, skipped: true, reason: "Existing inline suggestion configuration was preserved" };
-    const updated = content.slice(0, entry.valueStart) + String(enabled) + content.slice(entry.valueEnd);
-    validateManagedConfigEdit(parsed, updated, [sectionPath]);
-    return { content: updated, changed: true };
-  }
-  if (!enabled) return { content, changed: false };
-  const block = `[mcp_servers.${SUGGESTION_SERVER}]\nenabled = true\ncommand = ${JSON.stringify(expected.command)}\nargs = ${JSON.stringify(expected.args)}\nenv = { CCDX_SUGGESTION_CONFIG = ${JSON.stringify(filePath)} }\ntool_timeout_sec = 40\n`;
-  const updated = content + (content.endsWith("\n") ? "\n" : "\n\n") + block;
-  validateManagedConfigEdit(parsed, updated, [sectionPath]);
-  return { content: updated, changed: true };
-}
-
-export function computeSuggestionAutoHook(content, { enabled, filePath }) {
-  const parsed=parseCodexToml(content);
-  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 start="# ccdx:suggestion-auto:start",end="# ccdx:suggestion-auto:end";
-  const block=`${start}\n[[hooks.Stop]]\n[[hooks.Stop.hooks]]\ntype = "command"\ncommand = ${JSON.stringify(command)}\nasync = true\ntimeout = 35\n${end}\n`;
-  const owned=content.indexOf(start);
-  if(owned>=0){
-    if(!content.includes(block)||content.indexOf(start,owned+start.length)!==-1)return {content,changed:false,skipped:true};
-    if(enabled)return {content,changed:false};
-    const updated=content.replace(block,"");validateManagedConfigEdit(parsed,updated,[["hooks","Stop"]]);return {content:updated,changed:true};
-  }
-  if(!enabled)return {content,changed:false};
-  if(process.platform==="win32")return {content,changed:false,skipped:true};
-  const statements=codexTomlStatements(content);
-  if(statements.some(item=>item.kind==="value"&&item.keys[0]==="hooks"&&(item.keys.length===1||item.keys.length===2&&item.keys[1]==="Stop")))return {content,changed:false,skipped:true};
-  const updated=content+(content.endsWith("\n")?"\n":"\n\n")+block;
-  validateManagedConfigEdit(parsed,updated,[["hooks","Stop"]]);return {content:updated,changed:true};
-}
-
-export function suggestionCodexConfigPath({ env = process.env, home = os.homedir() } = {}) {
-  return path.join(env.CODEX_HOME || path.join(home, ".codex"), "config.toml");
-}
-
-export function readSuggestionCodexConfig(filePath) {
-  try { return new TextDecoder("utf-8", { fatal: true }).decode(fs.readFileSync(filePath)); }
-  catch (error) {
-    if (error.code === "ENOENT") return "";
-    throw new Error("Cannot read Codex configuration; no changes were written");
-  }
-}