@yagni-app/code-staging 0.1.0-staging.997.1 → 0.2.0-staging.1025.1

package/dist/extension/crashReport.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Crash reporting for the pi extension: a sanitized, fire-and-forget POST to
+ * the YAGNI backend's /api/yagni-code/crash. No third-party telemetry SDK —
+ * crash reports are the only thing that phones home, they contain no code and
+ * no prompts, and `YAGNI_DISABLE_CRASH_REPORTS=1` turns them off.
+ *
+ * Two report paths use this module:
+ *   - `uncaughtExceptionMonitor` (installed by index.ts): the MONITOR hook is
+ *     chosen deliberately — unlike an `uncaughtException` listener it never
+ *     changes crash semantics in pi's process (which YAGNI does not own); it
+ *     only observes the crash that is already happening. This is also the
+ *     "tool error that indicates a crash, not a user error" discriminator:
+ *     a user-visible tool failure is caught and rendered by pi, while
+ *     anything reaching the monitor was about to kill the session.
+ *   - the /go pipeline's terminal catch (goCommand.ts), where a thrown error
+ *     — not a verdict-shaped failure — ends the run.
+ *
+ * Everything is fail-soft: never throws, never retries, single short-timeout
+ * attempt, and reporting can never affect the user's session.
+ *
+ * The sanitizer (env-value redaction + path collapse + caps around the shared
+ * scrubSecrets patterns) is kept in sync with
+ * `yagni-code-cli/src/crashReport.ts`; the backend re-runs its own copy in
+ * `backend/src/yagniCode/crashReports.ts`. Spec:
+ * docs/superpowers/specs/2026-08-08-crash-reporting-design.md
+ */
+export declare const CRASH_REPORT_DISABLE_ENV = "YAGNI_DISABLE_CRASH_REPORTS";
+export declare const CRASH_REPORT_TIMEOUT_MS = 1500;
+export declare const MAX_CRASH_MESSAGE = 512;
+export declare const MAX_CRASH_ERROR_CLASS = 128;
+export declare const MAX_CRASH_STACK = 8000;
+export declare const MAX_CRASH_STACK_FRAMES = 40;
+export declare const MAX_CRASH_PAYLOAD_BYTES = 16384;
+/** Same truthiness rule as the CLI's YAGNI_DISABLE_* family. */
+export declare function crashReportsDisabled(env?: NodeJS.ProcessEnv): boolean;
+export interface SanitizeCrashOptions {
+    env?: NodeJS.ProcessEnv;
+    repoRoot?: string;
+}
+/** Env values → [ENV:NAME], scrubSecrets patterns, ~-collapse, repo-relative, basename. */
+export declare function sanitizeCrashText(text: string, opts?: SanitizeCrashOptions): string;
+export interface SanitizedCrash {
+    errorClass: string;
+    message: string;
+    stack?: string;
+}
+/** Reads ONLY name/message/stack; custom error fields are never touched. */
+export declare function sanitizeCrashError(err: unknown, opts?: SanitizeCrashOptions): SanitizedCrash;
+export interface CrashReporterOpts {
+    baseUrl: string;
+    getToken: () => string | undefined;
+    fetchImpl?: typeof fetch;
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+}
+export type CrashReporter = (error: unknown, context?: string, repoRoot?: string) => Promise<void>;
+/**
+ * Build the fail-soft reporter. The extension runs inside pi's process, so
+ * the client label follows the surface: `desktop` under the desktop shell
+ * (YAGNI_SURFACE=desktop), `cli` in the terminal. Version comes from
+ * `YAGNI_CODE_VERSION` (forwarded by the launcher; the bundled extension has
+ * no package.json on disk). Resolves on every outcome; never throws.
+ */
+export declare function makeCrashReporter(opts: CrashReporterOpts): CrashReporter;
+export type SpawnLike = (command: string, args: string[], options: {
+    detached: boolean;
+    stdio: "ignore";
+    env: Record<string, string | undefined>;
+}) => {
+    unref: () => void;
+};
+export interface FatalCrashOpts extends CrashReporterOpts {
+    /** Spawn seam for tests (defaults to node:child_process spawn). */
+    spawnImpl?: SpawnLike;
+}
+/**
+ * Deliver a crash report from a process that is about to die: build the
+ * sanitized payload in-process (cheap, synchronous), then spawn a detached
+ * one-shot sender that outlives the crash. Never throws.
+ */
+export declare function reportFatalCrash(error: unknown, opts: FatalCrashOpts, context?: string): void;
+/**
+ * Observe (never alter) a fatal crash in pi's process. Uses
+ * `uncaughtExceptionMonitor`, which fires before the process dies without
+ * installing a handler that would change node's default crash behavior —
+ * YAGNI does not own pi's process, so crash semantics must stay untouched.
+ */
+export declare function installUncaughtExceptionMonitor(opts: FatalCrashOpts, proc?: Pick<NodeJS.Process, "on">): void;
+//# sourceMappingURL=crashReport.d.ts.map

package/dist/extension/crashReport.js

@@ -0,0 +1,241 @@
+/**
+ * Crash reporting for the pi extension: a sanitized, fire-and-forget POST to
+ * the YAGNI backend's /api/yagni-code/crash. No third-party telemetry SDK —
+ * crash reports are the only thing that phones home, they contain no code and
+ * no prompts, and `YAGNI_DISABLE_CRASH_REPORTS=1` turns them off.
+ *
+ * Two report paths use this module:
+ *   - `uncaughtExceptionMonitor` (installed by index.ts): the MONITOR hook is
+ *     chosen deliberately — unlike an `uncaughtException` listener it never
+ *     changes crash semantics in pi's process (which YAGNI does not own); it
+ *     only observes the crash that is already happening. This is also the
+ *     "tool error that indicates a crash, not a user error" discriminator:
+ *     a user-visible tool failure is caught and rendered by pi, while
+ *     anything reaching the monitor was about to kill the session.
+ *   - the /go pipeline's terminal catch (goCommand.ts), where a thrown error
+ *     — not a verdict-shaped failure — ends the run.
+ *
+ * Everything is fail-soft: never throws, never retries, single short-timeout
+ * attempt, and reporting can never affect the user's session.
+ *
+ * The sanitizer (env-value redaction + path collapse + caps around the shared
+ * scrubSecrets patterns) is kept in sync with
+ * `yagni-code-cli/src/crashReport.ts`; the backend re-runs its own copy in
+ * `backend/src/yagniCode/crashReports.ts`. Spec:
+ * docs/superpowers/specs/2026-08-08-crash-reporting-design.md
+ */
+import { spawn } from "node:child_process";
+import { scrubSecrets } from "./pipeline/scrubSecrets.js";
+import { isDesktopSurface } from "./surface.js";
+const defaultSpawn = (command, args, options) => spawn(command, args, options);
+export const CRASH_REPORT_DISABLE_ENV = "YAGNI_DISABLE_CRASH_REPORTS";
+export const CRASH_REPORT_TIMEOUT_MS = 1_500;
+export const MAX_CRASH_MESSAGE = 512;
+export const MAX_CRASH_ERROR_CLASS = 128;
+export const MAX_CRASH_STACK = 8_000;
+export const MAX_CRASH_STACK_FRAMES = 40;
+export const MAX_CRASH_PAYLOAD_BYTES = 16_384;
+/** Same truthiness rule as the CLI's YAGNI_DISABLE_* family. */
+export function crashReportsDisabled(env = process.env) {
+    const value = env[CRASH_REPORT_DISABLE_ENV];
+    return value !== undefined && value !== "" && value !== "0";
+}
+const HOME_DIR_RE = /(?:\/(?:Users|home)\/|[A-Za-z]:\\Users\\)[^\s/\\]+/g;
+// Spaces deliberately allowed inside the token (real directories contain
+// them); prose after a path may fold into the kept basename — over-redacts
+// rather than under-redacts. Keep in sync with the CLI copy.
+const PATH_TOKEN_RE = /(?<![\w.~/\\])(?:~\/|\/|[A-Za-z]:\\)[^\n():'",]+/g;
+const MIN_ENV_VALUE_LENGTH = 8;
+function isPathLikeValue(value) {
+    return value.startsWith("/") || value.startsWith("~") || /^[A-Za-z]:\\/.test(value);
+}
+function collapsePathToken(token) {
+    const nm = token.lastIndexOf("node_modules/");
+    if (nm >= 0)
+        return token.slice(nm);
+    const cut = Math.max(token.lastIndexOf("/"), token.lastIndexOf("\\"));
+    const base = cut >= 0 ? token.slice(cut + 1) : token;
+    return base.length > 0 ? base : token;
+}
+/** Env values → [ENV:NAME], scrubSecrets patterns, ~-collapse, repo-relative, basename. */
+export function sanitizeCrashText(text, opts = {}) {
+    let out = text;
+    const env = opts.env ?? process.env;
+    const entries = Object.entries(env)
+        .filter((entry) => typeof entry[1] === "string" &&
+        entry[1].length >= MIN_ENV_VALUE_LENGTH &&
+        !isPathLikeValue(entry[1]))
+        .sort((a, b) => b[1].length - a[1].length);
+    for (const [name, value] of entries) {
+        if (out.includes(value))
+            out = out.split(value).join(`[ENV:${name}]`);
+    }
+    out = scrubSecrets(out);
+    out = out.replace(HOME_DIR_RE, "~");
+    if (opts.repoRoot) {
+        const root = opts.repoRoot.replace(HOME_DIR_RE, "~").replace(/\/+$/, "");
+        if (root.length > 1)
+            out = out.split(`${root}/`).join("");
+    }
+    out = out.replace(PATH_TOKEN_RE, collapsePathToken);
+    return out;
+}
+/** Reads ONLY name/message/stack; custom error fields are never touched. */
+export function sanitizeCrashError(err, opts = {}) {
+    let errorClass = "Error";
+    let message;
+    let stack;
+    if (err instanceof Error) {
+        errorClass = err.name || "Error";
+        message = err.message;
+        stack = typeof err.stack === "string" ? err.stack : undefined;
+    }
+    else {
+        try {
+            message = String(err);
+        }
+        catch {
+            message = "unstringifiable thrown value";
+        }
+    }
+    const cappedStack = stack !== undefined
+        ? sanitizeCrashText(stack, opts)
+            .split("\n")
+            .slice(0, MAX_CRASH_STACK_FRAMES)
+            .join("\n")
+            .slice(0, MAX_CRASH_STACK)
+        : undefined;
+    return {
+        errorClass: sanitizeCrashText(errorClass, opts).slice(0, MAX_CRASH_ERROR_CLASS),
+        message: sanitizeCrashText(message, opts).slice(0, MAX_CRASH_MESSAGE),
+        ...(cappedStack !== undefined ? { stack: cappedStack } : {}),
+    };
+}
+/**
+ * Build the fail-soft reporter. The extension runs inside pi's process, so
+ * the client label follows the surface: `desktop` under the desktop shell
+ * (YAGNI_SURFACE=desktop), `cli` in the terminal. Version comes from
+ * `YAGNI_CODE_VERSION` (forwarded by the launcher; the bundled extension has
+ * no package.json on disk). Resolves on every outcome; never throws.
+ */
+export function makeCrashReporter(opts) {
+    return async (error, context, repoRoot) => {
+        try {
+            const env = opts.env ?? process.env;
+            if (crashReportsDisabled(env))
+                return;
+            const token = opts.getToken();
+            if (!token)
+                return;
+            const sanitized = sanitizeCrashError(error, { env, repoRoot });
+            const payload = {
+                client: isDesktopSurface() ? "desktop" : "cli",
+                clientVersion: env.YAGNI_CODE_VERSION?.trim() || "unknown",
+                platform: `${process.platform} ${process.arch}`,
+                ...sanitized,
+                ...(context !== undefined ? { context } : {}),
+                timestamp: new Date().toISOString(),
+            };
+            if (JSON.stringify(payload).length > MAX_CRASH_PAYLOAD_BYTES) {
+                delete payload.stack;
+            }
+            const fetchImpl = opts.fetchImpl ?? fetch;
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? CRASH_REPORT_TIMEOUT_MS);
+            timer.unref?.();
+            try {
+                await fetchImpl(`${opts.baseUrl.replace(/\/$/, "")}/api/yagni-code/crash`, {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json",
+                        authorization: `Bearer ${token}`,
+                    },
+                    body: JSON.stringify(payload),
+                    signal: controller.signal,
+                });
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        }
+        catch {
+            // fail-soft by contract
+        }
+    };
+}
+/**
+ * One-shot sender source for the detached delivery child. A fatal uncaught
+ * exception kills pi's process before any in-process fetch could connect, so
+ * the monitor path hands the (already sanitized) payload to a detached
+ * `node -e` child that survives the parent's death, POSTs once with a hard
+ * timeout, and exits. No retries, nothing written to disk. The payload, URL
+ * and token travel via the child's env — the same channel the launcher
+ * already uses to hand pi its YAGNI_TOKEN.
+ */
+const DETACHED_SENDER_SRC = [
+    "const done = () => process.exit(0);",
+    "setTimeout(done, 5000).unref?.();",
+    "fetch(process.env.YAGNI_CRASH_URL, {",
+    "  method: 'POST',",
+    "  headers: {",
+    "    'content-type': 'application/json',",
+    "    authorization: 'Bearer ' + process.env.YAGNI_CRASH_TOKEN,",
+    "  },",
+    "  body: process.env.YAGNI_CRASH_PAYLOAD,",
+    "  signal: AbortSignal.timeout(4000),",
+    "}).catch(() => {}).finally(done);",
+].join("\n");
+/**
+ * Deliver a crash report from a process that is about to die: build the
+ * sanitized payload in-process (cheap, synchronous), then spawn a detached
+ * one-shot sender that outlives the crash. Never throws.
+ */
+export function reportFatalCrash(error, opts, context) {
+    try {
+        const env = opts.env ?? process.env;
+        if (crashReportsDisabled(env))
+            return;
+        const token = opts.getToken();
+        if (!token)
+            return;
+        const sanitized = sanitizeCrashError(error, { env });
+        const payload = {
+            client: isDesktopSurface() ? "desktop" : "cli",
+            clientVersion: env.YAGNI_CODE_VERSION?.trim() || "unknown",
+            platform: `${process.platform} ${process.arch}`,
+            ...sanitized,
+            ...(context !== undefined ? { context } : {}),
+            timestamp: new Date().toISOString(),
+        };
+        if (JSON.stringify(payload).length > MAX_CRASH_PAYLOAD_BYTES) {
+            delete payload.stack;
+        }
+        const spawnImpl = opts.spawnImpl ?? defaultSpawn;
+        const child = spawnImpl(process.execPath, ["-e", DETACHED_SENDER_SRC], {
+            detached: true,
+            stdio: "ignore",
+            env: {
+                // Minimal env: the sender needs nothing from the parent beyond these.
+                YAGNI_CRASH_URL: `${opts.baseUrl.replace(/\/$/, "")}/api/yagni-code/crash`,
+                YAGNI_CRASH_TOKEN: token,
+                YAGNI_CRASH_PAYLOAD: JSON.stringify(payload),
+            },
+        });
+        child.unref();
+    }
+    catch {
+        // a crash reporter must never add its own crash
+    }
+}
+/**
+ * Observe (never alter) a fatal crash in pi's process. Uses
+ * `uncaughtExceptionMonitor`, which fires before the process dies without
+ * installing a handler that would change node's default crash behavior —
+ * YAGNI does not own pi's process, so crash semantics must stay untouched.
+ */
+export function installUncaughtExceptionMonitor(opts, proc = process) {
+    proc.on("uncaughtExceptionMonitor", (err) => {
+        reportFatalCrash(err, opts, "uncaught-exception");
+    });
+}
+//# sourceMappingURL=crashReport.js.map

package/dist/extension/index.d.ts

@@ -1,5 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type SpendResponse } from "./costHud.js";
 import { runInitPass as defaultRunInitPass } from "./initPass.js";
+import { fetchMcpServers as defaultFetchMcpServers } from "./mcpTools.js";
 import { type FlushOutcome, type SpoolClientOpts } from "./spool.js";
 import { type TokenProvider } from "./tokenProvider.js";
 import { type ContextBrief, type ModelEntry } from "./config.js";
@@ -35,6 +37,12 @@ export interface RegisterYagniDeps {
         getToken: () => string | undefined;
         fetchImpl?: typeof fetch;
     }) => Promise<ContextBrief | null>;
+    /**
+     * Workspace MCP server list seam (YAG-446). The default hits
+     * `/api/yagni-code/mcp/servers` and is fail-soft: older backends and
+     * un-rescoped tokens yield `[]`, never a startup error.
+     */
+    fetchMcpServers?: typeof defaultFetchMcpServers;
     /**
      * The CLI init pass (Onramp Door B). Injectable so tests assert it fires on a
      * fresh-workspace first-run and is skipped otherwise, without a network or disk.
@@ -57,6 +65,35 @@ export interface RegisterYagniDeps {
     flushSpool?: (opts: SpoolClientOpts) => Promise<FlushOutcome>;
     env?: NodeJS.ProcessEnv;
 }
+/**
+ * Build GET /api/yagni-code/spend's URL. Pure (no fetch), exported for tests.
+ *
+ * YAG-383: a `/go` run's dispatches bill under its OWN run id
+ * (`llm_usage.session_id` holds the run id, not the driver session id — see
+ * attributionHeaders in config.ts), so `sessionId=` alone misses every run
+ * this session launched. `runIds` (comma-separated) widens the same query to
+ * include them; empty is omitted entirely rather than sent as `runIds=`.
+ */
+export declare function buildSpendUrl(baseUrl: string, sessionId: string, runIds: readonly string[]): string;
+/**
+ * Build GET /api/yagni-code/spend's URL for ONE `/go` run's own spend
+ * (`?runId=`, the sibling of {@link buildSpendUrl}'s session-wide
+ * `?sessionId=&runIds=`). Pure (no fetch), exported for tests. The backend
+ * route treats `runId` and `sessionId` as aliases into the same lookup (see
+ * routes/yagniCode.ts's `/spend` handler), so this is just the more honest
+ * query param name for "this one run" rather than reusing `buildSpendUrl`
+ * with the run id awkwardly standing in for a session id.
+ */
+export declare function buildRunSpendUrl(baseUrl: string, runId: string): string;
+/**
+ * Validate + narrow a `GET /api/yagni-code/spend` response body before
+ * trusting it as a {@link SpendResponse}. A network response is untyped at
+ * runtime, so this is the ONE shared guard both the session-wide `/cost`
+ * fetch and the per-run `/go` fetch rely on (drift-risk fix: they used to
+ * each carry their own copy of this same check). Pure, exported for tests.
+ * Returns null on anything that doesn't look like the real shape.
+ */
+export declare function parseSpendResponse(data: unknown): SpendResponse | null;
 export declare function registerYagni(pi: ExtensionAPI, deps?: RegisterYagniDeps): Promise<void>;
 export default function (pi: ExtensionAPI): Promise<void>;
 export { makeAskYagniTool } from "./askYagniTool.js";
@@ -73,11 +110,11 @@ export { makeSuggestNextWorkTool, defaultNextAction } from "./nextWorkTool.js";
 export type { MakeNextWorkToolOptions, DefaultNextAction, NextActionOption, } from "./nextWorkTool.js";
 export { recordDecision } from "./recordDecisionTool.js";
 export type { RecordDecisionParams } from "./recordDecisionTool.js";
-export { runInitPass, isFreshWorkspace, readRepoIntake, draftEngineering, summarizeDraft, FRESH_BRIEF_MIN_CHARS, } from "./initPass.js";
-export type { RunInitPassDeps, InitPassOutcome, RepoIntake, RepoIntakeFs, RepoAdr, EngineeringDraft, DraftTeam, } from "./initPass.js";
+export { runInitPass, runTeamSetup, registerTeamSetupCommand, isFreshWorkspace, readRepoIntake, draftEngineering, summarizeDraft, FRESH_BRIEF_MIN_CHARS, } from "./initPass.js";
+export type { RunInitPassDeps, InitPassOutcome, RunTeamSetupDeps, TeamSetupOutcome, RepoIntake, RepoIntakeFs, EngineeringDraft, DraftTeam, } from "./initPass.js";
 export { isInitDone, markInitDone, initDoneMarkerFile, _setInitDoneHomeForTest } from "./initDone.js";
-export { brandSystemPrompt, YAGNI_IDENTITY, BRAND_NAME } from "./branding.js";
-export { fetchCatalog, getToken, getWorkspaceId, resolveBaseUrl } from "./config.js";
+export { brandSystemPrompt, YAGNI_IDENTITY, YAGNI_IDENTITY_DRIVER, BRAND_NAME } from "./branding.js";
+export { attributionHeaders, isDriverCaller, fetchCatalog, getToken, getWorkspaceId, resolveBaseUrl, sanitizeCallerSegment, } from "./config.js";
 export type { FetchCatalogOptions, ModelEntry } from "./config.js";
 export { buildYagniProvider } from "./provider.js";
 export { registerGoCommand } from "./pipeline/goCommand.js";
@@ -113,4 +150,6 @@ export { makeTokenProvider, makeAuthedFetch, persistRotationToProfile, PROACTIVE
 export type { TokenProvider, TokenProviderDeps, ScheduleFn } from "./tokenProvider.js";
 export { appendToSpool, loadSpool, flushSpool, sendOrSpool, spoolFile, MAX_SPOOL_AGE_MS, _setSpoolHomeForTest, } from "./spool.js";
 export type { SpoolEntry, SpoolClientOpts, FlushOutcome, JudgmentWriteOutcome } from "./spool.js";
+export { crashReportsDisabled, installUncaughtExceptionMonitor, makeCrashReporter, reportFatalCrash, sanitizeCrashError, sanitizeCrashText, } from "./crashReport.js";
+export type { CrashReporter, CrashReporterOpts, FatalCrashOpts, SanitizedCrash } from "./crashReport.js";
 //# sourceMappingURL=index.d.ts.map