codeep 3.4.0 → 3.5.0

package/dist/acp/transport.js

@@ -1,29 +1,124 @@
 // acp/transport.ts
 // Newline-delimited JSON-RPC over stdio
-import { appendFileSync, mkdirSync } from 'node:fs';
+import { appendFileSync, chmodSync, mkdirSync, renameSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 // Debug log destination — when CODEEP_ACP_DEBUG is set we mirror every
 // inbound and outbound JSON-RPC frame here. Using a file (not stderr) because
 // most ACP clients (Zed included) do not pipe agent stderr to anywhere the
 // user can easily read; a known on-disk path is reliable everywhere.
+//
+// WHAT IS IN IT, because a user asked for it in a bug report will attach the
+// whole file: every frame of the session. That is the prompts, the model's
+// replies, the contents of every file read or written through fs/*, the
+// commands run in the client's terminal and their output, and the `env` of
+// every terminal/create. redactCredentials() blanks the obvious credential
+// shapes on the way in, but it is a filter over text and not a guarantee — a
+// secret that does not look like one survives it. So: session-private, 0600
+// in a 0700 directory, and not something to paste anywhere unread.
 const ACP_DEBUG_PATH = process.env.CODEEP_ACP_DEBUG_FILE
     || join(homedir(), '.cache', 'codeep', 'acp-debug.log');
 const ACP_DEBUG = !!process.env.CODEEP_ACP_DEBUG;
+/**
+ * Roll the log over at 8MB, keeping one previous file.
+ *
+ * It had no limit at all: every frame was appended and nothing ever truncated
+ * or removed the file, and a frame carries whole file contents and whole
+ * command outputs — so a user who left CODEEP_ACP_DEBUG set grew it until the
+ * disk stopped them. One previous file rather than a truncate because the
+ * frames that explain a broken session are usually the handshake at the top,
+ * which is exactly what a truncate throws away. Bounded at twice this, then.
+ */
+const ACP_DEBUG_MAX_BYTES = 8 * 1024 * 1024;
 if (ACP_DEBUG) {
+    // 0700: the directory holds a file with the whole session in it.
     try {
-        mkdirSync(dirname(ACP_DEBUG_PATH), { recursive: true });
+        mkdirSync(dirname(ACP_DEBUG_PATH), { recursive: true, mode: 0o700 });
     }
     catch { /* ignore */ }
 }
+/** Bytes written so far, so the size check costs no syscall per frame. Null
+ *  until the first write reads what an earlier run left on disk. */
+let acpDebugBytes = null;
 function debugLog(direction, payload) {
     if (!ACP_DEBUG)
         return;
+    const line = `${new Date().toISOString()} [ACP${direction}client] ${redactCredentials(payload)}\n`;
+    const bytes = Buffer.byteLength(line);
     try {
-        appendFileSync(ACP_DEBUG_PATH, `${new Date().toISOString()} [ACP${direction}client] ${payload}\n`);
+        if (acpDebugBytes === null)
+            acpDebugBytes = adoptExistingLog();
+        if (acpDebugBytes > 0 && acpDebugBytes + bytes > ACP_DEBUG_MAX_BYTES) {
+            renameSync(ACP_DEBUG_PATH, `${ACP_DEBUG_PATH}.1`);
+            acpDebugBytes = 0;
+        }
+        // `mode` applies only when the file is created, which after the rename
+        // above is every rollover as well as the first frame of the first run.
+        appendFileSync(ACP_DEBUG_PATH, line, { mode: 0o600 });
+        acpDebugBytes += bytes;
     }
     catch { /* swallow — never break the protocol over a logging failure */ }
 }
+/** The size of the log already on disk, 0 when there is none. */
+function adoptExistingLog() {
+    try {
+        const stat = statSync(ACP_DEBUG_PATH);
+        // A log this build did not create is one an older Codeep created 0644 —
+        // world-readable, with everything listed above in it. Tighten it, but
+        // only at our own path: CODEEP_ACP_DEBUG_FILE may name something whose
+        // mode is not ours to change (a fifo, a tty, a shared file).
+        if (!process.env.CODEEP_ACP_DEBUG_FILE && (stat.mode & 0o077) !== 0) {
+            chmodSync(ACP_DEBUG_PATH, 0o600);
+        }
+        return stat.size;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Credential shapes blanked before a frame is mirrored to the debug log.
+ *
+ * The log exists to debug the protocol, so this is deliberately narrow: it
+ * blanks what is unmistakably a secret and leaves everything else readable.
+ * Matched on the frame TEXT rather than on a parsed object because an inbound
+ * frame is logged before it is parsed and may not be JSON at all.
+ *
+ * Nothing here changes the frame on the wire — only the copy on disk.
+ */
+const ACP_DEBUG_REDACTIONS = [
+    // `"apiKey": "…"`, `"authorization": "…"` — the MEMBER NAME says it is a
+    // secret, whatever the value looks like.
+    [/("[A-Za-z0-9_.-]*(?:api[_-]?key|access[_-]?key|secret|token|password|passwd|credential|authorization|cookie|private[_-]?key)[A-Za-z0-9_.-]*"\s*:\s*)"(?:[^"\\]|\\.)*"/gi, '$1"[redacted]"'],
+    // ACP spells an environment as `{"name":…,"value":…}`, so the secret-looking
+    // string is the VALUE of `name` and the rule above cannot see it. This is
+    // the shape terminal/create used to leak the whole of process.env in.
+    [/("name"\s*:\s*"[A-Za-z0-9_.-]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|AUTH|COOKIE)[A-Za-z0-9_.-]*"\s*,\s*"value"\s*:\s*)"(?:[^"\\]|\\.)*"/gi, '$1"[redacted]"'],
+    // And the shapes that are a credential wherever they turn up — a command
+    // line the agent ran, a terminal's own output, a file it read.
+    [/\bsk-[A-Za-z0-9_-]{16,}/g, '[redacted]'], // OpenAI / Anthropic
+    [/\bgh[pousr]_[A-Za-z0-9]{20,}/g, '[redacted]'], // GitHub
+    [/\bgithub_pat_[A-Za-z0-9_]{20,}/g, '[redacted]'],
+    [/\bglpat-[A-Za-z0-9_-]{16,}/g, '[redacted]'], // GitLab
+    [/\bxox[abprs]-[A-Za-z0-9-]{10,}/g, '[redacted]'], // Slack
+    [/\bAKIA[0-9A-Z]{16}\b/g, '[redacted]'], // AWS access key id
+    [/\bAIza[0-9A-Za-z_-]{20,}/g, '[redacted]'], // Google
+    [/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, '[redacted]'], // JWT
+    [/\bBearer\s+[A-Za-z0-9._~+/-]{16,}={0,2}/gi, 'Bearer [redacted]'],
+    // `https://user:password@host` — keep the structure, drop the password.
+    [/((?:https?|ssh|git):\/\/[^\s"'/@]+:)[^\s"'/@]+@/g, '$1[redacted]@'],
+];
+/**
+ * A frame with its obvious credentials blanked.
+ *
+ * Exported for unit testing (see transport.test.ts).
+ */
+export function redactCredentials(frame) {
+    let out = frame;
+    for (const [pattern, replacement] of ACP_DEBUG_REDACTIONS)
+        out = out.replace(pattern, replacement);
+    return out;
+}
 const MAX_BUFFER_SIZE = 10 * 1024 * 1024; // 10MB
 const REQUEST_TIMEOUT_MS = 30_000; // 30s
 /** The client answered one of our requests with a JSON-RPC error. */

package/dist/api/index.js

@@ -3,7 +3,7 @@ import * as https from 'node:https';
 import { config, getApiKey, resolveBaseUrl, describeUnsendableKey } from '../config/index.js';
 import { withRetry, isNetworkError } from '../utils/retry.js';
 import { checkApiRateLimit } from '../utils/ratelimit.js';
-import { getProvider, getProviderBaseUrl, getProviderAuthHeader, usesMaxCompletionTokens, requiresDefaultTemperature, modelRejectsSamplingParams, reasoningParamsFor } from '../config/providers.js';
+import { getProvider, getProviderBaseUrl, getProviderAuthHeader, usesMaxCompletionTokens, requiresDefaultTemperature, modelRejectsSamplingParams, reasoningParamsFor, minResponseTokensFor } from '../config/providers.js';
 import { logApiRequest, logApiResponse } from '../utils/logger.js';
 import { loadProjectIntelligence, generateContextFromIntelligence } from '../utils/projectIntelligence.js';
 import { loadProjectRules } from '../utils/agent.js';
@@ -366,7 +366,8 @@ async function chatOpenAI(message, history, model, apiKey, onChunk, abortSignal)
     const stream = Boolean(onChunk);
     const timeout = config.get('apiTimeout');
     const temperature = config.get('temperature');
-    const maxTokens = config.get('maxTokens');
+    // Never below the model's floor (Opus 5.5 on OpenRouter — see minResponseTokensFor).
+    const maxTokens = Math.max(config.get('maxTokens'), minResponseTokensFor(model, config.get('reasoningEffort')));
     // Get provider-specific URL and auth. resolveBaseUrl applies user
     // overrides: Ollama (ollamaUrl), Custom (customBaseUrl), and OpenAI
     // (OPENAI_BASE_URL env) — so self-hosted / OpenAI-compatible endpoints work.
@@ -647,7 +648,9 @@ async function chatAnthropic(message, history, model, apiKey, onChunk, abortSign
     const stream = Boolean(onChunk);
     const timeout = config.get('apiTimeout');
     const temperature = config.get('temperature');
-    const maxTokens = config.get('maxTokens');
+    // Never below the model's floor: Opus 5.5's always-on thinking spends the
+    // same limit as the answer (see minResponseTokensFor).
+    const maxTokens = Math.max(config.get('maxTokens'), minResponseTokensFor(model, config.get('reasoningEffort')));
     const baseUrl = getProviderBaseUrl(providerId, 'anthropic');
     const authHeader = getProviderAuthHeader(providerId, 'anthropic');
     if (!baseUrl) {

package/dist/config/index.js

@@ -280,10 +280,18 @@ if (currentMigrationVersion < 1) {
         config.set('rateLimitCommands', 10000);
     }
 }
-if (currentMigrationVersion < 4) {
-    // Vendor aliases below were removed from Codeep's curated catalogue after
-    // their replacements became available. Migrate only exact known aliases:
-    // OpenRouter/Ollama/custom model ids remain user-controlled.
+// Retired model ids: on EVERY load, not once. This sat inside
+// `currentMigrationVersion < 4` until 2026-09-23, and MIGRATION_VERSION had
+// been 4 since 2026-08-15 — so every RETIRED_MODEL_REPLACEMENTS entry added
+// after that (the GPT-5.5/5.4, Grok, DeepSeek and Gemini ones) reached only
+// fresh configs and profile loads, never an existing user's active model. The
+// lookup is exact and idempotent, it touches only ids a vendor retired or
+// rerouted (never OpenRouter/Ollama/custom ids, which the map does not key),
+// and it is what applyProfile and the macOS app already do on every load. The
+// one-shot rule above protects settings a user chooses; the ids in that map are
+// ones the vendor retired or reroutes, or that cannot work from Codeep (GPT-6
+// Astra's tool calls), so rewriting them again cannot undo a working choice.
+{
     const provider = config.get('provider');
     const model = config.get('model');
     const replacement = replacementModelFor(provider, model);

package/dist/config/providers.d.ts

@@ -49,7 +49,14 @@ export interface ProviderConfig {
 export declare const PROVIDERS: Record<string, ProviderConfig>;
 export type ProviderId = keyof typeof PROVIDERS;
 export declare function getProvider(id: string): ProviderConfig | null;
+/**
+ * One exact lookup, never followed further: every target must already be a
+ * model its own provider offers (providers.test.ts holds the map to that), so a
+ * chain can never be needed and the macOS mirror stays a flat table too.
+ */
 export declare function replacementModelFor(providerId: string, modelId: string): string | undefined;
+/** The whole map, read-only — for the invariant test and nothing else. */
+export declare function retiredModelReplacements(): Readonly<Record<string, Readonly<Record<string, string>>>>;
 export declare function getProviderList(): {
     id: string;
     name: string;
@@ -94,6 +101,21 @@ export declare function modelRejectsSamplingParams(model: string): boolean;
  * Falls back to the requested value if no provider limit is set.
  */
 export declare function getEffectiveMaxTokens(providerId: string, requested: number): number;
+/**
+ * The smallest response budget (`max_tokens`) worth sending this model, or 0
+ * for no floor. Callers take the larger of this and whatever they would have
+ * sent, then apply getEffectiveMaxTokens as usual.
+ *
+ * Claude Opus 5.5 thinks on every request — adaptive thinking cannot be turned
+ * off — and "tends to think more per turn than Claude Opus 5" at the same
+ * effort; Anthropic's notes say to "leave room in max_tokens for the thinking",
+ * which spends the same limit as the answer. The task planner's 2048, or a
+ * maxTokens lowered in /settings, could go on thinking alone and cut the reply
+ * off. 32K is Codeep's own default; the Max tier gets 64K, where Anthropic's
+ * advice for max effort on Opus 5 is "starting at 64k tokens". Matched on the
+ * canonical id, so `anthropic/claude-opus-5.5` on OpenRouter is covered too.
+ */
+export declare function minResponseTokensFor(model: string, tier: ReasoningTier | undefined): number;
 /**
  * Unified, user-facing thinking-effort tiers (the `/thinking` setting).
  *
@@ -102,7 +124,7 @@ export declare function getEffectiveMaxTokens(providerId: string, requested: num
  *
  * The four tiers are CONCEPTUAL. `reasoningParamsFor()` clamps each one to the
  * nearest level the active provider+model actually accepts, so we never send a
- * value that would 400 (e.g. Gemini rejects "medium"; OpenAI has no "max").
+ * value that would 400 (e.g. Gemini has no "max"; GPT-5.5 tops out at "xhigh").
  * The control is a pure DEPTH knob on models that already think — it never
  * toggles thinking on/off, which keeps us clear of the reasoning_content-replay
  * contract that DeepSeek/GLM impose when thinking mode is flipped.
@@ -116,6 +138,21 @@ export declare const REASONING_TIERS: ReasoningTier[];
  * `claude-opus-4.8` → `claude-opus-4-8`). Mirrors macOS `ModelTuning.canonicalModelID`.
  */
 export declare function canonicalModelId(model: string): string;
+/**
+ * GPT-6 Sol and Luna on Chat Completions support function calling "only with
+ * `reasoning_effort` set to `none`" (developers.openai.com models/gpt-6-sol,
+ * guides/latest-model). So a request that carries tools to them must send
+ * "none", whatever /thinking says. Direct `openai` only: OpenRouter may reach
+ * OpenAI through the Responses API, where the rule does not apply, and Astra
+ * rejects "none" with a 400 (it is not offered on `openai` at all).
+ */
+export declare function toolsForceReasoningOff(providerId: string, model: string): boolean;
+/**
+ * What /thinking must tell the user when the tier does not reach every request
+ * for this model, or null. Without it the setting would look applied while
+ * agent turns quietly ran at "none".
+ */
+export declare function agentTurnReasoningNote(providerId: string, model: string): string | null;
 /**
  * Does this provider+model expose a GRADED thinking-effort control we can drive?
  * Used to gate the `/thinking` UI — hidden entirely for models without one.
@@ -128,12 +165,19 @@ export declare function modelSupportsReasoningEffort(providerId: string, model:
  * models, or providers without a graded knob — so callers can spread it
  * unconditionally. Keep in lockstep with macOS `ModelTuning.reasoningParams`.
  */
-export declare function reasoningParamsFor(providerId: string, model: string, tier: ReasoningTier): Record<string, unknown>;
+export declare function reasoningParamsFor(providerId: string, model: string, tier: ReasoningTier, 
+/** The request carries a non-empty `tools` array (native tool calling). */
+opts?: {
+    tools?: boolean;
+}): Record<string, unknown>;
 /**
  * The DISTINCT tiers a given provider+model actually exposes — used to build a
  * per-model picker that only offers levels the model can tell apart (e.g.
- * GLM-5.2/DeepSeek grade only high|max; Gemini via the OpenAI-compat layer only
- * low|high). Always leads with 'auto'. `[]` for models with no graded knob.
+ * GLM-5.2 grades only high|max; Gemini via the OpenAI-compat layer has no max).
+ * Always leads with 'auto'. `[]` for models with no graded knob.
+ *
+ * GPT-6 Sol/Luna list their full set: it is what they run on plain chat. Agent
+ * turns send "none" regardless (toolsForceReasoningOff), and /thinking says so.
  *
  * Kept in lockstep with `reasoningParamsFor` (the providers-test asserts every
  * listed tier yields a DISTINCT param, so this can't silently drift). Mirrors