@yagni-app/code-staging 1.1.4-staging.1392.1 → 1.1.4-staging.1404.1

package/dist/credentials.js

@@ -17,7 +17,11 @@ export function _setYagniCodeHomeForTest(dir) {
     homeOverride = dir;
 }
 export function credentialsDir() {
-    return homeOverride ?? join(homedir(), DISTRIBUTION.stateDirName);
+    // `YAGNI_CODE_HOME` env override (mirrors the extension's stateHome):
+    // the hermetic-e2e lane — a sandboxed run seeds a temp home with copied
+    // credentials and never writes to the real `~/.yagni-code`, so e2e needs
+    // no unsandboxed prompts and cannot corrupt the live profile state.
+    return homeOverride ?? process.env.YAGNI_CODE_HOME ?? join(homedir(), DISTRIBUTION.stateDirName);
 }
 export function credentialsPath() {
     return join(credentialsDir(), "credentials.json");

package/dist/extension/bgJobs.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Background jobs: a Claude-Code-style mechanism for
+ * long-running commands that must never block the conversation.
+ *
+ * A background job is a `bash` call with `run_in_background: true`. The tool
+ * returns IMMEDIATELY with a task id + an on-disk output path; the process
+ * keeps running with piped stdio while the agent (and the user) continue
+ * talking. On exit, a `<task-notification>` arrives as a synthetic user
+ * message via pi.sendUserMessage — the model reads the output file with the
+ * normal Read tool. The user sees a footer pill (`1 shell · shift+↓ to
+ * view`, the label owned by bgJobsPanel.ts) and manages jobs through the
+ * /bg panel (view output, kill).
+ *
+ * Architecture notes (the invariants that matter):
+ *
+ *  - ONE registry is the single source of truth: pill, panel and
+ *    notifications all read it — no derived counters to drift stale.
+ *  - The `notified` latch is check-and-set inside one synchronous
+ *    transition function, so a kill racing a natural exit produces exactly
+ *    one terminal status and at most one notification.
+ *  - `killJob` flips the state to `killed` synchronously BEFORE the signal,
+ *    so the exit handler sees `killed` and never rewrites it — the same
+ *    ordering trick Claude Code uses.
+ *  - Output goes to a per-session file written by THIS process (the child
+ *    keeps pipes, not file handles), capped at 64MB with a marker line.
+ *  - The stall watchdog ports Claude Code's: 45s of no output growth PLUS a
+ *    prompt-looking tail (`(y/n)` etc.) fires ONE statusless notification
+ *    telling the model to kill the task. Statusless because a `<status>`
+ *    tag reads as terminal and would falsely close the job.
+ *  - Module-level state like sessionRuns.ts: one CLI process is one driver
+ *    session. Subagents are separate pi processes; their own
+ *    session_shutdown → killAll covers them (no agentId scoping needed).
+ */
+import { spawn } from "node:child_process";
+export type BgJobStatus = "running" | "completed" | "failed" | "killed";
+export interface BgJob {
+    id: string;
+    command: string;
+    description: string;
+    cwd: string;
+    status: BgJobStatus;
+    startedAt: number;
+    endedAt?: number;
+    exitCode?: number;
+    /** Signal that killed the process when status is "killed". */
+    killedBy?: "user" | "timeout" | "shutdown";
+    outputFile: string;
+    outputBytes: number;
+    /** True once the completion notification has been enqueued (the latch). */
+    notified: boolean;
+    /** True once the stall watchdog has fired (fires at most once per job). */
+    stallNotified: boolean;
+    /** True once the no-progress lane has fired (the deadlocked-silent ping). */
+    noProgressNotified: boolean;
+    /** Whether the composed bash path sandboxed this job (a start-time field). */
+    sandboxed: boolean;
+    /** True once output capture hit an I/O failure (disk full etc.) — the
+     * output file is incomplete; surfaced in the notification + panel. */
+    captureDegraded: boolean;
+}
+/** How a caller wants to be told about registry changes (pill repaints). */
+export type BgJobsListener = () => void;
+export interface StartBgJobInput {
+    /** The already-sandbox-wrapped command string (same prewrap as foreground). */
+    command: string;
+    /** The shell binary to run it with (the composed bash's shellPath). */
+    shellPath: string;
+    cwd: string;
+    description?: string;
+    /** Seconds; when set, the job is killed and reported as timed out. */
+    timeoutSec?: number;
+    env?: NodeJS.ProcessEnv;
+    /** Sandbox decision of the composed bash path, for the WAL trail. */
+    sandboxed: boolean;
+}
+export interface BgJobsHandle {
+    id: string;
+    outputFile: string;
+}
+/** Test seam: wipe all state (mirrors _resetSessionRunsForTest). */
+export declare function _resetBgJobsForTest(): void;
+export declare function _setSpawnForTest(fn: typeof spawn | null): void;
+export declare function _setNowForTest(fn: (() => number) | null): void;
+/** Wiring: how a notification reaches the session (pi.sendUserMessage wrapper). */
+export declare function setNotifySink(notify: (text: string) => Promise<void> | void): void;
+export declare function setUiNotify(notify: (message: string, kind: "info" | "warning" | "error") => void): void;
+export declare function setBgJobOutcomeReporter(fn: ((status: string, sandboxed: boolean) => void) | null): void;
+/** Test seam for the output-file dir (mirrors _setErrorSinkHomeForTest). */
+export declare function _setBgJobsHomeForTest(dir: string | null): void;
+export declare function subscribeBgJobs(listener: BgJobsListener): () => void;
+export declare function listBgJobs(): BgJob[];
+export declare function getBgJob(id: string): BgJob | undefined;
+export declare function runningBgJobCount(): number;
+export declare function escapeXml(s: string): string;
+/** PURE: the summary line Claude Code uses for bash completions. */
+export declare function bgJobSummary(job: BgJob): string;
+/** PURE: the completion notification. tool-use-id deliberately omitted (v1). */
+export declare function bgJobNotification(job: BgJob): string;
+/** PURE: does the tail look like an interactive prompt? (Claude Code's patterns.) */
+export declare const PROMPT_PATTERNS: RegExp[];
+export declare function looksLikePrompt(tail: string): boolean;
+/**
+ * One stall-watchdog evaluation. Exported for tests: the interval calls it;
+ * tests drive it directly with a controlled clock, no real 5s wait.
+ */
+export declare function _checkStallOnce(id: string): Promise<void>;
+/**
+ * Test seam: wait for every in-flight output-file write to settle, so a
+ * teardown can rmSync the output dir deterministically (no ENOTEMPTY race
+ * with a pending append). Bounded by `deadlineMs` — a wedged fs write
+ * degrades to today's fire-and-forget behavior rather than hanging a test.
+ */
+export declare function _drainBgJobsAppendsForTest(deadlineMs?: number): Promise<void>;
+export declare function startBackgroundJob(input: StartBgJobInput, sessionId: string): Promise<BgJobsHandle>;
+/**
+ * Kill a running job. Synchronous state flip FIRST (so the panel repaints
+ * immediately and the exit handler never rewrites `killed`), then the signal.
+ */
+export declare function killJob(id: string, by?: BgJob["killedBy"]): boolean;
+/**
+ * The win32 kill lane: taskkill the whole tree. Routed through the
+ * spawnFn seam (testable like the rest of the engine), with stderr captured
+ * so the log carries taskkill's own cause ("Access is denied." vs "not
+ * found"), and close codes distinguished — code === null means taskkill
+ * itself died to a signal, which is not "exit code null".
+ */
+export declare function spawnTaskKill(taskId: string, pid: number): void;
+/** Kill everything still running (session_shutdown + process-exit sweep). */
+export declare function killAllBgJobs(): number;
+/** PURE-ish (reads the registry): the tool result text for a bg launch. */
+export declare function bgLaunchResult(handle: BgJobsHandle, timeoutSec?: number): string;
+//# sourceMappingURL=bgJobs.d.ts.map