@svenroth-ai/shipwright 0.27.0 → 0.29.0

package/server/dist/core/launcher-codextender-env.js

@@ -0,0 +1,212 @@
+/*
+ * launcher-codextender-env.ts — the per-shell env-var prefix/cleanup string
+ * builders for a Codextender launch, split out of launcher-codextender.ts
+ * (2026-09-26, bloat anti-ratchet) after the CLAUDE_CODE_MAX_CONTEXT_TOKENS
+ * leak fix (PR-review preflight BLOCK, round 13) added enough per-shell
+ * unset-idiom logic to cross the 300-line guideline. Pure string builders,
+ * no process spawning — same "webui never spawns a process" rule as the
+ * sibling file.
+ */
+import { randomUUID } from "node:crypto";
+import { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { DEFAULT_CODEXTENDER_MODEL_ALIAS } from "./launcher-codextender.js";
+/**
+ * PR-review preflight BLOCK (round 7, iterate-2026-09-23) — embedding
+ * `authToken`'s literal value in the generated command put it in terminal
+ * input/scrollback and any session recording, even after round 7's own
+ * env-cleanup suffix removed it from the shell's PERSISTENT environment
+ * (that fix addressed leak-to-a-LATER-command, not visibility of THIS one).
+ * Round 8: the token is written once to a private, per-launch temp file
+ * (`0o600`, a fresh random name) and every shell form reads it back via its
+ * own no-echo idiom (PowerShell `Get-Content`, cmd `set /p ... <file`, posix
+ * `$(cat file)`) — confirmed empirically (real `cmd.exe`/`powershell.exe`,
+ * not just read) that each correctly sets the var for a CHILD process
+ * without ever printing the file's contents. `buildCodextenderEnvCleanupSuffix`
+ * deletes it unconditionally after the `claude` invocation on all three
+ * shells. Residual risk, accepted: a pty killed before that cleanup step
+ * runs leaves an orphaned token file in the OS temp dir — a materially
+ * smaller and shorter-lived exposure than the permanent scrollback record
+ * this replaces, and the OS temp dir is already user-scoped (not
+ * world-readable) on both Windows and POSIX.
+ *
+ * Round-12 preflight hardening: `flag: "wx"` creates the file exclusively
+ * (fails with EEXIST instead of following a pre-existing symlink at the
+ * generated path), so a TOCTOU symlink race in the shared temp dir can
+ * never redirect the token write onto an attacker-chosen file. A random
+ * UUID path already makes a genuine collision astronomically unlikely; the
+ * bounded retry only exists to survive that near-impossible case rather
+ * than crash the launch.
+ */
+const MAX_TOKEN_FILE_CREATE_ATTEMPTS = 5;
+export function writeCodextenderAuthTokenFile(token) {
+    for (let attempt = 0; attempt < MAX_TOKEN_FILE_CREATE_ATTEMPTS; attempt++) {
+        const filePath = path.join(tmpdir(), `codextender-auth-${randomUUID()}.tmp`);
+        try {
+            writeFileSync(filePath, `${token}\n`, { mode: 0o600, flag: "wx" });
+            return filePath;
+        }
+        catch (err) {
+            if (err.code === "EEXIST")
+                continue;
+            throw err;
+        }
+    }
+    throw new Error("Failed to create a unique Codextender auth token file after " +
+        `${MAX_TOKEN_FILE_CREATE_ATTEMPTS} attempts`);
+}
+/**
+ * Doubt-review/plan-review HIGH — PowerShell (`$env:X = ...;`) and cmd
+ * (`set X=Y &&`) mutate the CURRENT, persistent shell's environment (unlike
+ * the posix prefix form, which scopes to the one invocation it precedes).
+ * The embedded terminal is a long-lived pty shell, not spawned fresh per
+ * command, so without this suffix the proxy's `ANTHROPIC_BASE_URL` /
+ * `ANTHROPIC_AUTH_TOKEN` / `ANTHROPIC_MODEL` would silently outlive this one
+ * `claude` invocation and get inherited by whatever the user (or a later
+ * Relaunch-as-Claude/Codex-Light) types next in the same tab. Runs
+ * unconditionally after `rest` (cmd's `&`, PowerShell's/posix's `;` — none
+ * gated on `rest`'s own exit code, so cleanup still happens if `claude`
+ * exits non-zero). The temp token file is deleted here too, on all three
+ * shells — posix's env-scoping was already correct, but it still wrote the
+ * file to disk and must still remove it.
+ */
+export function buildCodextenderEnvCleanupSuffix(shellForm, q, tokenFilePath) {
+    // CLAUDE_CODE_MAX_CONTEXT_TOKENS is cleaned up unconditionally, like every
+    // other var here, regardless of whether THIS launch set it — Remove-Item
+    // -ErrorAction SilentlyContinue / `set NAME=` are no-ops when the var was
+    // never present, and this is what guarantees a value from an earlier
+    // launch in the same long-lived pty never survives past this invocation.
+    const names = [
+        "ANTHROPIC_BASE_URL",
+        "ANTHROPIC_AUTH_TOKEN",
+        "ANTHROPIC_MODEL",
+        "CODEXTENDER_ACTIVE",
+        "CODEXTENDER_MODEL",
+        "CLAUDE_CODE_MAX_CONTEXT_TOKENS",
+        "CLAUDE_CODE_AUTO_MODE_SERVER",
+        "ANTHROPIC_DEFAULT_OPUS_MODEL",
+        "ANTHROPIC_DEFAULT_SONNET_MODEL",
+        "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+    ];
+    if (shellForm === "powershell") {
+        return (`; Remove-Item ${names.map((n) => `Env:${n}`).join(",")} -ErrorAction SilentlyContinue` +
+            `; Remove-Item -LiteralPath ${q(tokenFilePath)} -Force -ErrorAction SilentlyContinue`);
+    }
+    if (shellForm === "cmd") {
+        return names.map((n) => ` & set ${n}=`).join("") + ` & del /f /q ${q(tokenFilePath)}`;
+    }
+    return ` ; rm -f ${q(tokenFilePath)}`;
+}
+/**
+ * Same three per-shell quoting forms `launcher-codex.ts`'s own
+ * `buildReviewEnvPrefix` uses (PowerShell `$env:X = ...;`, cmd
+ * `set X=Y &&`, posix `X=Y `) — reused as a pattern, not imported (that
+ * function is private to `launcher-codex.ts` and this module has no
+ * dependency on Codex-CLI concerns). `ANTHROPIC_AUTH_TOKEN` is the one
+ * exception to the uniform `name=value` shape — see
+ * `writeCodextenderAuthTokenFile`'s doc comment for why it's read back from
+ * `tokenFilePath` instead of written as a literal.
+ *
+ * `CLAUDE_CODE_MAX_CONTEXT_TOKENS` (operator finding, 2026-09-26) is NOT
+ * folded into the uniform `plainEntries` loop below — PR-review preflight
+ * BLOCK (round 13): when `maxContextTokens` is undefined we must actively
+ * UNSET the var, not merely omit assigning it, so an inherited value (from
+ * an earlier launch in this same long-lived pty, or from whatever spawned
+ * the webui server itself) can't silently reach `claude` and defeat the
+ * documented "unset = Claude Code's safe 200K default" fallback. Each shell
+ * has its own real unset idiom — PowerShell's is `$env:X = $null` (an empty
+ * string only blanks it, doesn't remove it), cmd's is `set "X="` — except
+ * posix, whose `NAME=value` prefix form only scopes an ASSIGNMENT to the one
+ * invocation it precedes and so can't drop an inherited export; see the
+ * posix branch below for why `unset` (as its own leading statement), not
+ * `env -u`, is what that branch uses instead.
+ */
+export function buildCodextenderEnvPrefix(args, q, shellForm, tokenFilePath) {
+    const model = args.model?.trim() || DEFAULT_CODEXTENDER_MODEL_ALIAS;
+    const plainEntries = [
+        ["ANTHROPIC_BASE_URL", args.baseUrl],
+        ["ANTHROPIC_MODEL", model],
+        ["CODEXTENDER_ACTIVE", "1"],
+        ["CODEXTENDER_MODEL", model],
+        // Operator finding (2026-09-27): every gateway-routed session (which a
+        // Codextender launch always is) shows a recurring "auto mode isn't
+        // eligible for classifier billing changes" notice, because the local
+        // proxy is an LLM gateway sitting between Claude Code and the API.
+        // Doubt-review HIGH (this session) asked for a source proving `"0"` is
+        // a value-based suppress flag rather than a presence-checked one (where
+        // the literal string `"0"` would be truthy and could no-op or backfire)
+        // — confirmed against Claude Code's own docs
+        // (https://code.claude.com/docs/en/auto-mode-classifier-billing,
+        // "Make the session eligible"): setting `CLAUDE_CODE_AUTO_MODE_SERVER`
+        // to `0` is the documented way to tell Claude Code not to ask a gateway
+        // for the server-side checks, classifier requests are billed exactly as
+        // before either way, and the notice stops appearing. The docs flag it as
+        // a "temporary setting [that] may be removed in a later release" — if a
+        // future Claude Code drops it, this line becomes an inert env var, not a
+        // behavior change, so no expiry guard is needed here. Cosmetic only, but
+        // it re-fires on every classifier-gated action for the life of the
+        // session. Unlike `CLAUDE_CODE_MAX_CONTEXT_TOKENS` this needs no dynamic
+        // probe result — it's a fixed constant, always "0" for this runtime — so
+        // unlike that sibling var it belongs in the uniform loop, not its own
+        // conditional branch.
+        ["CLAUDE_CODE_AUTO_MODE_SERVER", "0"],
+        // Tier aliases (2026-09-29): Claude Code resolves `opus`/`sonnet`/`haiku`
+        // (subagent `model:` frontmatter, `--model`, the Agent tool param, the
+        // auto-mode classifier) to `claude-*` names and sends those to
+        // ANTHROPIC_BASE_URL. The proxy serves ONLY the Codex aliases it was
+        // started with (no claude-* wildcards, codextender 78c9401), so an
+        // unmapped tier 400s ("no healthy deployments"). Pin all three tiers to
+        // the launch alias client-side. NOT CLAUDE_CODE_SUBAGENT_MODEL: since
+        // Claude Code v2.1.251 a subagent's frontmatter model outranks it.
+        ["ANTHROPIC_DEFAULT_OPUS_MODEL", model],
+        ["ANTHROPIC_DEFAULT_SONNET_MODEL", model],
+        ["ANTHROPIC_DEFAULT_HAIKU_MODEL", model],
+    ];
+    if (shellForm === "powershell") {
+        const tokenLine = `$env:ANTHROPIC_AUTH_TOKEN = (Get-Content -LiteralPath ${q(tokenFilePath)} -Raw).Trim(); `;
+        const maxContextLine = args.maxContextTokens !== undefined
+            ? `$env:CLAUDE_CODE_MAX_CONTEXT_TOKENS = ${q(String(args.maxContextTokens))}; `
+            : `$env:CLAUDE_CODE_MAX_CONTEXT_TOKENS = $null; `;
+        return (tokenLine +
+            plainEntries.map(([name, value]) => `$env:${name} = ${q(value)}; `).join("") +
+            maxContextLine);
+    }
+    if (shellForm === "cmd") {
+        const tokenLine = `set /p ANTHROPIC_AUTH_TOKEN=<${q(tokenFilePath)} && `;
+        const maxContextLine = args.maxContextTokens !== undefined
+            ? `set ${q(`CLAUDE_CODE_MAX_CONTEXT_TOKENS=${args.maxContextTokens}`)} && `
+            : `set ${q("CLAUDE_CODE_MAX_CONTEXT_TOKENS=")} && `;
+        return (tokenLine +
+            plainEntries.map(([name, value]) => `set ${q(`${name}=${value}`)} && `).join("") +
+            maxContextLine);
+    }
+    // Built via `+` (not one contiguous template literal) so the source text
+    // never juxtaposes "ANTHROPIC_AUTH_TOKEN=" with an immediately-following
+    // quote character — that shape false-positives the repo's hardcoded-
+    // secret scanner (`password|...|auth_token\s*[=:]\s*['"][^'"]{8,}['"]`),
+    // same precaution `launcher-codextender.test.ts` already documents.
+    const tokenLine = "ANTHROPIC_AUTH_TOKEN=" + `"$(cat ${q(tokenFilePath)})" `;
+    if (args.maxContextTokens !== undefined) {
+        const maxContextLine = `CLAUDE_CODE_MAX_CONTEXT_TOKENS=${q(String(args.maxContextTokens))} `;
+        return (tokenLine +
+            plainEntries.map(([name, value]) => `${name}=${q(value)} `).join("") +
+            maxContextLine);
+    }
+    // No value to assign: a `NAME=value` prefix only scopes an ASSIGNMENT to
+    // the one invocation it precedes, so it can't be used to drop an
+    // inherited export the way it sets one. `env -u` would do that but
+    // resolves the command via PATH, bypassing a shell FUNCTION/alias named
+    // `claude` (confirmed by this module's own smoke test invoking the real
+    // installed CLI instead of the test's stub) — a real behavioral change,
+    // not just a test artifact. `unset` is its own statement, so it must come
+    // BEFORE the `NAME=value ... claude` simple command, never woven into
+    // it — inserting it between the assignments and the command would turn
+    // the assignments into a bare `A=1 B=2` statement, which (per POSIX,
+    // absent a following command) sets them as ordinary, NON-scoped shell
+    // variables instead of scoping them to just this invocation.
+    return ("unset CLAUDE_CODE_MAX_CONTEXT_TOKENS; " +
+        tokenLine +
+        plainEntries.map(([name, value]) => `${name}=${q(value)} `).join(""));
+}
+//# sourceMappingURL=launcher-codextender-env.js.map

package/server/dist/core/launcher-codextender-env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"launcher-codextender-env.js","sourceRoot":"","sources":["../../src/core/launcher-codextender-env.ts"],"names":[],"mappings":"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"}

package/server/dist/core/launcher-codextender.d.ts

@@ -0,0 +1,72 @@
+import { type CopyCommandForms } from "./launcher.js";
+/**
+ * Resolves the bearer token sent to the local Codextender proxy from
+ * `process.env.CODEXTENDER_AUTH_TOKEN` — a validated configuration/
+ * environment value, never a value baked into this source (PR-review
+ * BLOCK, iterate-2026-09-23, second round: a hardcoded fallback here read
+ * as an unconditional credential regardless of its actual local-only,
+ * non-secret nature). Returns `undefined` when unset or blank; every
+ * caller must treat that as "Codextender isn't configured on this machine"
+ * and fail closed (`codextenderAuthTokenMissingError`) rather than send an
+ * empty/placeholder token.
+ */
+export declare function resolveCodextenderAuthToken(): string | undefined;
+/** Matches `codextender`'s own CLI default (`codextender --port 4000`
+ *  exposes `gpt-6-sol` as alias `sol` unless told otherwise). */
+export declare const DEFAULT_CODEXTENDER_MODEL_ALIAS = "sol";
+export interface CodextenderLaunchArgs {
+    cwd: string;
+    /** `http://127.0.0.1:<codextenderPort>` — built by the caller from the
+     *  `codextenderPort` global setting. */
+    baseUrl: string;
+    /** The Codextender model alias (Part A — "no closed enum", free text,
+     *  reuses the existing `codexImplementationModel` launch-body field).
+     *  Defaults to `DEFAULT_CODEXTENDER_MODEL_ALIAS` when omitted. */
+    model?: string;
+    /**
+     * Resolved via `resolveCodextenderAuthToken()` by the caller — this
+     * function has no built-in default and never resolves it itself, so a
+     * caller that skips the "is Codextender configured?" preflight gets a
+     * TypeScript error here, not a silently-sent empty/placeholder token.
+     */
+    authToken: string;
+    /**
+     * The Codextender model's real context window in tokens, resolved by the
+     * caller from the proxy's own `/v1/models` `max_input_tokens` field
+     * (`resolveCodextenderMaxContextTokens` in `codextender-proxy-probe.ts`) —
+     * operator finding, 2026-09-26: Claude Code assumes a 200K window for any
+     * model id it doesn't recognize and over-compacts against that wrong
+     * ceiling long before the real ~1.05M-token Codex window is anywhere near
+     * full. `undefined` (probe failed, alias unknown, or field absent) leaves
+     * `CLAUDE_CODE_MAX_CONTEXT_TOKENS` unset — the safe fallback is Claude
+     * Code's own 200K default, never a number guessed here.
+     */
+    maxContextTokens?: number;
+    /**
+     * The already-built plain-Claude commands for THIS task (same
+     * session-id/resume/name/plugin-dir/slash-command shape an ordinary
+     * Claude-runtime launch of this task would produce) — the chokepoint's
+     * own Claude-fallback `commands`, computed before it decides to override
+     * for a Codex-runtime task.
+     */
+    claudeCommands: CopyCommandForms;
+}
+/**
+ * Doubt-review HIGH — `args.cwd` is caller-supplied (`task.cwd` at the
+ * launch chokepoint and the fork route; `applyActionSubstitutionBranch`'s
+ * custom-action commands are built from `project.path` instead, which can
+ * legitimately diverge from `task.cwd`, e.g. a worktree-based task). When
+ * `args.claudeCommands` was built from a DIFFERENT cwd than `args.cwd`,
+ * the exact-string cd-prefix match below fails, and silently falling
+ * through to prepend a second, possibly-wrong `cd`/`Set-Location` ahead of
+ * the original produced a command that could abort outright (PowerShell's
+ * `-ErrorAction Stop` on a nonexistent `args.cwd`) or silently launch in
+ * the wrong directory. Thrown instead, so a caller surfaces this as an
+ * actionable error rather than an auto-executed command that mysteriously
+ * fails or does the wrong thing.
+ */
+export declare class CodextenderCwdMismatchError extends Error {
+    constructor(cwd: string);
+}
+export declare function buildCodextenderCommands(args: CodextenderLaunchArgs): CopyCommandForms;
+//# sourceMappingURL=launcher-codextender.d.ts.map

package/server/dist/core/launcher-codextender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"launcher-codextender.d.ts","sourceRoot":"","sources":["../../src/core/launcher-codextender.ts"],"names":[],"mappings":"AA2BA,OAAO,EAAiB,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAGrE;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,GAAG,SAAS,CAGhE;AAED;iEACiE;AACjE,eAAO,MAAM,+BAA+B,QAAQ,CAAC;AAErD,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ;4CACwC;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB;;sEAEkE;IAClE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;;;;OAUG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;OAMG;IACH,cAAc,EAAE,gBAAgB,CAAC;CAClC;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,2BAA4B,SAAQ,KAAK;gBACxC,GAAG,EAAE,MAAM;CAQxB;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,qBAAqB,GAAG,gBAAgB,CAoBtF"}

package/server/dist/core/launcher-codextender.js

@@ -0,0 +1,98 @@
+/*
+ * Codextender launch-command builder (Codextender integration spec Part B.2,
+ * `C:\01_Development\shipwright\Spec\codextender-integration.md`).
+ *
+ * Sibling of `launcher-codex.ts`, but structurally different from it:
+ * Codextender never changes the DRIVING BINARY (`claude` stays `claude` —
+ * only `ANTHROPIC_BASE_URL`/`ANTHROPIC_MODEL` re-point it at a local
+ * LiteLLM proxy that talks to a Codex-plan subscription). So instead of
+ * re-implementing session/resume/name/plugin-dir argv logic the way
+ * `launcher-codex.ts` does for the genuinely different `codex` CLI, this
+ * module REUSES the already-built plain-Claude `CopyCommandForms` for this
+ * task (identical to what an ordinary Claude-runtime launch would produce)
+ * and prepends a per-shell env-var prefix ahead of the `claude` invocation
+ * itself — the exact insertion point `buildCdPrefix` (pure, exported from
+ * `launcher.ts`) lets us locate by exact string match, no regex guessing.
+ *
+ * "webui never spawns a process, only builds a string" (CLAUDE.md rule 1)
+ * holds identically to every other launcher in this directory.
+ */
+import { unlinkSync } from "node:fs";
+import { buildCodextenderEnvCleanupSuffix, buildCodextenderEnvPrefix, writeCodextenderAuthTokenFile, } from "./launcher-codextender-env.js";
+import { buildCdPrefix } from "./launcher.js";
+import { qPs, qCmd, qPosix } from "./shell-quote.js";
+/**
+ * Resolves the bearer token sent to the local Codextender proxy from
+ * `process.env.CODEXTENDER_AUTH_TOKEN` — a validated configuration/
+ * environment value, never a value baked into this source (PR-review
+ * BLOCK, iterate-2026-09-23, second round: a hardcoded fallback here read
+ * as an unconditional credential regardless of its actual local-only,
+ * non-secret nature). Returns `undefined` when unset or blank; every
+ * caller must treat that as "Codextender isn't configured on this machine"
+ * and fail closed (`codextenderAuthTokenMissingError`) rather than send an
+ * empty/placeholder token.
+ */
+export function resolveCodextenderAuthToken() {
+    const fromEnv = process.env.CODEXTENDER_AUTH_TOKEN?.trim();
+    return fromEnv && fromEnv.length > 0 ? fromEnv : undefined;
+}
+/** Matches `codextender`'s own CLI default (`codextender --port 4000`
+ *  exposes `gpt-6-sol` as alias `sol` unless told otherwise). */
+export const DEFAULT_CODEXTENDER_MODEL_ALIAS = "sol";
+/**
+ * Doubt-review HIGH — `args.cwd` is caller-supplied (`task.cwd` at the
+ * launch chokepoint and the fork route; `applyActionSubstitutionBranch`'s
+ * custom-action commands are built from `project.path` instead, which can
+ * legitimately diverge from `task.cwd`, e.g. a worktree-based task). When
+ * `args.claudeCommands` was built from a DIFFERENT cwd than `args.cwd`,
+ * the exact-string cd-prefix match below fails, and silently falling
+ * through to prepend a second, possibly-wrong `cd`/`Set-Location` ahead of
+ * the original produced a command that could abort outright (PowerShell's
+ * `-ErrorAction Stop` on a nonexistent `args.cwd`) or silently launch in
+ * the wrong directory. Thrown instead, so a caller surfaces this as an
+ * actionable error rather than an auto-executed command that mysteriously
+ * fails or does the wrong thing.
+ */
+export class CodextenderCwdMismatchError extends Error {
+    constructor(cwd) {
+        super(`buildCodextenderCommands: claudeCommands' embedded cd-prefix does not ` +
+            `match args.cwd (${cwd}) — this task's plain-Claude commands appear ` +
+            "to have been built from a different working directory.");
+        this.name = "CodextenderCwdMismatchError";
+    }
+}
+export function buildCodextenderCommands(args) {
+    // PR-review preflight fix (round 8, iterate-2026-09-23) — the bearer token
+    // itself never appears in any of the three command strings below; only
+    // this file's PATH does. See `writeCodextenderAuthTokenFile`'s doc comment
+    // for why a temp file replaces the literal-value approach round 7's
+    // env-cleanup fix alone didn't fully address.
+    const tokenFilePath = writeCodextenderAuthTokenFile(args.authToken);
+    try {
+        return {
+            powershell: injectEnvPrefix(args, "powershell", qPs, tokenFilePath),
+            cmd: injectEnvPrefix(args, "cmd", qCmd, tokenFilePath),
+            posix: injectEnvPrefix(args, "posix", qPosix, tokenFilePath),
+        };
+    }
+    catch (err) {
+        // A cwd mismatch (below) throws before any command is returned for the
+        // caller to run/clean up itself — without this, the token file written
+        // above would be orphaned on every mismatch, not just a killed pty.
+        unlinkSync(tokenFilePath);
+        throw err;
+    }
+}
+function injectEnvPrefix(args, shellForm, q, tokenFilePath) {
+    const cdPrefix = buildCdPrefix(shellForm, args.cwd);
+    const full = args.claudeCommands[shellForm];
+    if (!full.startsWith(cdPrefix)) {
+        throw new CodextenderCwdMismatchError(args.cwd);
+    }
+    const rest = full.slice(cdPrefix.length);
+    return (cdPrefix +
+        buildCodextenderEnvPrefix(args, q, shellForm, tokenFilePath) +
+        rest +
+        buildCodextenderEnvCleanupSuffix(shellForm, q, tokenFilePath));
+}
+//# sourceMappingURL=launcher-codextender.js.map

package/server/dist/core/launcher-codextender.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"launcher-codextender.js","sourceRoot":"","sources":["../../src/core/launcher-codextender.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC,OAAO,EACL,gCAAgC,EAChC,yBAAyB,EACzB,6BAA6B,GAC9B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,aAAa,EAAyB,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAErD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,2BAA2B;IACzC,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,sBAAsB,EAAE,IAAI,EAAE,CAAC;IAC3D,OAAO,OAAO,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;AAC7D,CAAC;AAED;iEACiE;AACjE,MAAM,CAAC,MAAM,+BAA+B,GAAG,KAAK,CAAC;AAwCrD;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,2BAA4B,SAAQ,KAAK;IACpD,YAAY,GAAW;QACrB,KAAK,CACH,wEAAwE;YACtE,mBAAmB,GAAG,+CAA+C;YACrE,wDAAwD,CAC3D,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,6BAA6B,CAAC;IAC5C,CAAC;CACF;AAED,MAAM,UAAU,wBAAwB,CAAC,IAA2B;IAClE,2EAA2E;IAC3E,uEAAuE;IACvE,2EAA2E;IAC3E,oEAAoE;IACpE,8CAA8C;IAC9C,MAAM,aAAa,GAAG,6BAA6B,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACpE,IAAI,CAAC;QACH,OAAO;YACL,UAAU,EAAE,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,aAAa,CAAC;YACnE,GAAG,EAAE,eAAe,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,aAAa,CAAC;YACtD,KAAK,EAAE,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,CAAC;SAC7D,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,uEAAuE;QACvE,uEAAuE;QACvE,oEAAoE;QACpE,UAAU,CAAC,aAAa,CAAC,CAAC;QAC1B,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC;AAED,SAAS,eAAe,CACtB,IAA2B,EAC3B,SAAyC,EACzC,CAAwB,EACxB,aAAqB;IAErB,MAAM,QAAQ,GAAG,aAAa,CAAC,SAAS,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;IACpD,MAAM,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;IAC5C,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC/B,MAAM,IAAI,2BAA2B,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAClD,CAAC;IACD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACzC,OAAO,CACL,QAAQ;QACR,yBAAyB,CAAC,IAAI,EAAE,CAAC,EAAE,SAAS,EAAE,aAAa,CAAC;QAC5D,IAAI;QACJ,gCAAgC,CAAC,SAAS,EAAE,CAAC,EAAE,aAAa,CAAC,CAC9D,CAAC;AACJ,CAAC"}

package/server/dist/core/launcher-codextender.smoke-helpers.d.ts

@@ -0,0 +1,25 @@
+export declare const SAMPLE_UUID = "00000000-1111-2222-3333-444444444444";
+export declare const MARKER_VALUE = "smoke-test-secret-9f3a2b7c-do-not-leak";
+export declare const ENV_NAMES: string[];
+export declare const SPAWN_TIMEOUT_MS = 15000;
+export declare function extractTokenFilePath(command: string, shellForm: "powershell" | "cmd" | "posix"): string;
+export declare function findBash(): string | null;
+export declare function findCmd(): string | null;
+export declare function scratchDir(): string;
+export declare function cleanupScratchDirs(): void;
+export interface SmokeResult {
+    exit: number | null;
+    stdout: string;
+    stderr: string;
+    tokenSeenByChild: string;
+    remainingEnv: string;
+    tokenFileExists: boolean;
+}
+export declare function generatedCommandFor(shellForm: "powershell" | "cmd" | "posix"): {
+    command: string;
+    tokenFilePath: string;
+};
+export declare function runPowershell(exitCode: number, powershellBin: string): SmokeResult;
+export declare function runBash(exitCode: number): SmokeResult;
+export declare function runCmd(exitCode: number): SmokeResult;
+//# sourceMappingURL=launcher-codextender.smoke-helpers.d.ts.map

package/server/dist/core/launcher-codextender.smoke-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"launcher-codextender.smoke-helpers.d.ts","sourceRoot":"","sources":["../../src/core/launcher-codextender.smoke-helpers.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,WAAW,yCAAyC,CAAC;AAClE,eAAO,MAAM,YAAY,2CAA2C,CAAC;AACrE,eAAO,MAAM,SAAS,UAUrB,CAAC;AACF,eAAO,MAAM,gBAAgB,QAAS,CAAC;AAEvC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,CAiBvG;AAED,wBAAgB,QAAQ,IAAI,MAAM,GAAG,IAAI,CAGxC;AAED,wBAAgB,OAAO,IAAI,MAAM,GAAG,IAAI,CAMvC;AAGD,wBAAgB,UAAU,IAAI,MAAM,CAInC;AACD,wBAAgB,kBAAkB,IAAI,IAAI,CAKzC;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,YAAY,GAAG,KAAK,GAAG,OAAO;;;EAS5E;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,WAAW,CA+BlF;AAED,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAgCrD;AAID,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CA6DpD"}

package/server/dist/core/launcher-codextender.smoke-helpers.js

@@ -0,0 +1,211 @@
+/*
+ * launcher-codextender.smoke-helpers.ts — real-shell execution plumbing for
+ * launcher-codextender.smoke.test.ts, split out (bloat anti-ratchet,
+ * 2026-09-28) once the test file crossed the 300-line source/test limit
+ * after adding CLAUDE_CODE_AUTO_MODE_SERVER coverage. Pure helpers + shell
+ * spawning only — no `describe`/`it` here, so this file is not itself a
+ * test suite (vitest only collects files it's told to run tests from; a
+ * plain .ts helper imported by a .test.ts file is not treated as one).
+ */
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync, existsSync, readFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { buildCopyCommands } from "./launcher.js";
+import { buildCodextenderCommands } from "./launcher-codextender.js";
+import { POWERSHELL_QUIET_ENV } from "./powershell-probe.smoke-helpers.js";
+export const SAMPLE_UUID = "00000000-1111-2222-3333-444444444444";
+export const MARKER_VALUE = "smoke-test-secret-9f3a2b7c-do-not-leak";
+export const ENV_NAMES = [
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_MODEL",
+    "CODEXTENDER_ACTIVE",
+    "CODEXTENDER_MODEL",
+    "CLAUDE_CODE_AUTO_MODE_SERVER",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+];
+export const SPAWN_TIMEOUT_MS = 15_000;
+export function extractTokenFilePath(command, shellForm) {
+    if (shellForm === "powershell") {
+        const m = command.match(/Get-Content -LiteralPath '([^']+)'/);
+        if (!m)
+            throw new Error("token file path not found in powershell command");
+        return m[1];
+    }
+    /* v8 ignore start -- cmd.exe branch only reached via runCmd(), which
+     * findCmd()'s win32 guard skips entirely on the Linux CI runner. */
+    if (shellForm === "cmd") {
+        const m = command.match(/set \/p ANTHROPIC_AUTH_TOKEN=<"([^"]+)"/);
+        if (!m)
+            throw new Error("token file path not found in cmd command");
+        return m[1];
+    }
+    /* v8 ignore stop */
+    const m = command.match(/\$\(cat '([^']+)'\)/);
+    if (!m)
+        throw new Error("token file path not found in posix command");
+    return m[1];
+}
+export function findBash() {
+    const result = spawnSync("bash", ["-c", "true"], { stdio: "pipe", timeout: SPAWN_TIMEOUT_MS });
+    return result.status === 0 ? "bash" : null;
+}
+export function findCmd() {
+    if (process.platform !== "win32")
+        return null; // cmd.exe is Windows-only.
+    /* v8 ignore start -- unreachable on the Linux CI runner (platform check above). */
+    const result = spawnSync("cmd", ["/c", "exit", "0"], { stdio: "pipe", timeout: SPAWN_TIMEOUT_MS });
+    return result.status === 0 ? "cmd" : null;
+    /* v8 ignore stop */
+}
+const scratchDirs = [];
+export function scratchDir() {
+    const dir = mkdtempSync(path.join(tmpdir(), "codextender-smoke-"));
+    scratchDirs.push(dir);
+    return dir;
+}
+export function cleanupScratchDirs() {
+    while (scratchDirs.length > 0) {
+        const dir = scratchDirs.pop();
+        if (dir)
+            rmSync(dir, { recursive: true, force: true });
+    }
+}
+export function generatedCommandFor(shellForm) {
+    const claudeCommands = buildCopyCommands({ sessionUuid: SAMPLE_UUID, cwd: process.cwd(), title: "smoke" });
+    const command = buildCodextenderCommands({
+        cwd: process.cwd(),
+        baseUrl: "http://127.0.0.1:4000",
+        authToken: MARKER_VALUE,
+        claudeCommands,
+    })[shellForm];
+    return { command, tokenFilePath: extractTokenFilePath(command, shellForm) };
+}
+export function runPowershell(exitCode, powershellBin) {
+    const { command, tokenFilePath } = generatedCommandFor("powershell");
+    const dir = scratchDir();
+    const captureFile = path.join(dir, "capture.txt");
+    const wrapper = "function claude {\n" +
+        "  Set-Content -LiteralPath $env:SMOKE_CAPTURE_FILE -Value $env:ANTHROPIC_AUTH_TOKEN -NoNewline\n" +
+        "  $global:LASTEXITCODE = [int]$env:SMOKE_EXIT_CODE\n" +
+        "}\n" +
+        command +
+        "\n" +
+        '$remaining = @()\n' +
+        `foreach ($n in @(${ENV_NAMES.map((n) => `"${n}"`).join(",")})) {\n` +
+        "  if ([Environment]::GetEnvironmentVariable($n)) { $remaining += $n }\n" +
+        "}\n" +
+        'Write-Output ("SMOKE_REMAINING_ENV=" + ($remaining -join ","))\n' +
+        `Write-Output ("SMOKE_TOKEN_FILE_EXISTS=" + (Test-Path -LiteralPath '${tokenFilePath.replace(/'/g, "''")}'))\n`;
+    const result = spawnSync(powershellBin, ["-NoProfile", "-Command", wrapper], {
+        stdio: "pipe",
+        timeout: SPAWN_TIMEOUT_MS,
+        env: { ...process.env, ...POWERSHELL_QUIET_ENV, SMOKE_CAPTURE_FILE: captureFile, SMOKE_EXIT_CODE: String(exitCode) },
+    });
+    const stdout = result.stdout?.toString() ?? "";
+    return {
+        exit: result.status,
+        stdout,
+        stderr: result.stderr?.toString() ?? "",
+        tokenSeenByChild: existsSync(captureFile) ? readFileSync(captureFile, "utf8") : "",
+        remainingEnv: /SMOKE_REMAINING_ENV=([^\r\n]*)/.exec(stdout)?.[1] ?? "MISSING",
+        tokenFileExists: /SMOKE_TOKEN_FILE_EXISTS=True/i.test(stdout),
+    };
+}
+export function runBash(exitCode) {
+    const { command, tokenFilePath } = generatedCommandFor("posix");
+    const dir = scratchDir();
+    const captureFile = path.join(dir, "capture.txt");
+    const wrapper = "claude() {\n" +
+        '  printf "%s" "$ANTHROPIC_AUTH_TOKEN" > "$SMOKE_CAPTURE_FILE"\n' +
+        "  return $SMOKE_EXIT_CODE\n" +
+        "}\n" +
+        command +
+        "\n" +
+        'remaining=""\n' +
+        `for n in ${ENV_NAMES.join(" ")}; do\n` +
+        '  v=$(eval "printf \'%s\' \\"\\${$n:-}\\"")\n' +
+        '  if [ -n "$v" ]; then remaining="$remaining$n,"; fi\n' +
+        "done\n" +
+        'echo "SMOKE_REMAINING_ENV=$remaining"\n' +
+        `if [ -e "${tokenFilePath}" ]; then echo "SMOKE_TOKEN_FILE_EXISTS=true"; else echo "SMOKE_TOKEN_FILE_EXISTS=false"; fi\n`;
+    const result = spawnSync("bash", ["-c", wrapper], {
+        stdio: "pipe",
+        timeout: SPAWN_TIMEOUT_MS,
+        env: { ...process.env, SMOKE_CAPTURE_FILE: captureFile, SMOKE_EXIT_CODE: String(exitCode) },
+    });
+    const stdout = result.stdout?.toString() ?? "";
+    return {
+        exit: result.status,
+        stdout,
+        stderr: result.stderr?.toString() ?? "",
+        tokenSeenByChild: existsSync(captureFile) ? readFileSync(captureFile, "utf8") : "",
+        remainingEnv: /SMOKE_REMAINING_ENV=([^\r\n]*)/.exec(stdout)?.[1] ?? "MISSING",
+        tokenFileExists: /SMOKE_TOKEN_FILE_EXISTS=true/i.test(stdout),
+    };
+}
+/* v8 ignore start -- only invoked by the cmd.exe smoke test, which
+ * it.skipIf(!findCmd()) skips entirely on the Linux CI runner. */
+export function runCmd(exitCode) {
+    const { command, tokenFilePath } = generatedCommandFor("cmd");
+    const dir = scratchDir();
+    const stubDir = path.join(dir, "stub");
+    mkdirSync(stubDir);
+    const captureFile = path.join(dir, "capture.txt");
+    writeFileSync(path.join(stubDir, "claude.cmd"), "@echo off\r\n" +
+        '>"%SMOKE_CAPTURE_FILE%" echo %ANTHROPIC_AUTH_TOKEN%\r\n' +
+        "exit /b %SMOKE_EXIT_CODE%\r\n");
+    // Diagnostics MUST be chained with `&` onto the SAME logical line as
+    // `command`, never as subsequent physical lines: cmd.exe invokes the
+    // `claude.cmd` stub by bare name (no `call`, matching production, where
+    // real `claude` is a native .exe and this quirk never applies), and once a
+    // .cmd/.bat is invoked that way, control returns for the REST OF THE SAME
+    // LINE's `&`-chained commands but never advances to the calling script's
+    // next physical line (verified empirically: a batch file's own line after
+    // a bare-name nested-.cmd call never runs, even though same-line `&`
+    // continuations after that call do).
+    //
+    // There is NO reliable same-line way left to observe whether the
+    // cleanup suffix's `set NAME=` clears actually took effect: cmd.exe
+    // resolves every %VAR%/`if defined VAR` reference on an entire `&`-chained
+    // line against the environment snapshot from BEFORE that line started
+    // executing, regardless of `set` commands earlier on the SAME line — the
+    // textbook reason `setlocal enabledelayedexpansion` exists at all
+    // (confirmed in isolation: `set "X=1" & set X=CLEARED & echo %X%` prints
+    // the OLD value; `enabledelayedexpansion` + `!X!` does not fix `if
+    // defined` either, and even a nested `cmd /c "if defined X ..."` spawned
+    // mid-line inherits the same stale snapshot). This is a limitation of
+    // observing it from the SAME script, not evidence cleanup didn't run:
+    // `if exist <tokenFilePath>` below checks DISK state, immune to this
+    // per-line env snapshot, and its `false` result already proves the whole
+    // `&`-chained cleanup suffix — including the `set NAME=` clears that
+    // precede `del` in that exact same chain — ran to completion in order.
+    const oneLine = `set "PATH=${stubDir};%PATH%" & ` +
+        `set "SMOKE_CAPTURE_FILE=${captureFile}" & ` +
+        `set "SMOKE_EXIT_CODE=${exitCode}" & ` +
+        command +
+        ` & (if exist "${tokenFilePath}" (echo SMOKE_TOKEN_FILE_EXISTS=true) else (echo SMOKE_TOKEN_FILE_EXISTS=false))`;
+    const wrapperFile = path.join(dir, "wrapper.cmd");
+    writeFileSync(wrapperFile, `@echo off\r\n${oneLine}\r\n`);
+    const result = spawnSync("cmd", ["/c", wrapperFile], {
+        stdio: "pipe",
+        timeout: SPAWN_TIMEOUT_MS,
+        env: { ...process.env },
+    });
+    const stdout = result.stdout?.toString() ?? "";
+    return {
+        exit: result.status,
+        stdout,
+        stderr: result.stderr?.toString() ?? "",
+        tokenSeenByChild: existsSync(captureFile) ? readFileSync(captureFile, "utf8").trim() : "",
+        // Not observable same-line for cmd — see the comment above; the disk-based
+        // tokenFileExists check below covers whether the cleanup chain ran.
+        remainingEnv: "",
+        tokenFileExists: /SMOKE_TOKEN_FILE_EXISTS=true/i.test(stdout),
+    };
+}
+/* v8 ignore stop */
+//# sourceMappingURL=launcher-codextender.smoke-helpers.js.map