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

package/dist/claudePlugins.js

@@ -0,0 +1,336 @@
+/**
+ * Claude Code plugin + marketplace discovery (local content only).
+ *
+ * Finds the plugin content a Claude Code user already has on disk and exposes
+ * it as asset paths the launcher can feed through the existing compat seams:
+ * skills → `--skill`, commands → `--prompt-template`, agents → the subagent
+ * discovery env var. Two sources:
+ *
+ * 1. Installed plugins: `~/.claude/plugins/installed_plugins.json` (version-2
+ *    ledger of `name@marketplace` → cache checkouts), enabled through
+ *    `enabledPlugins` in the user's `~/.claude/settings.json` (user scope) or
+ *    the repo's `.claude/settings{,.local}.json` (project scope). When a
+ *    ledger entry is gone, the marketplace checkout recorded in
+ *    `known_marketplaces.json` is tried as a fallback.
+ * 2. The repo's own `.claude-plugin/marketplace.json` (the internal-
+ *    marketplace pattern): every plugin it defines with a locally-present
+ *    relative-path source loads on the project side, unless explicitly
+ *    disabled via `enabledPlugins`.
+ *
+ * Deliberately NOT here: network installation of any kind, plugin hooks, MCP
+ * servers, LSP servers, themes, output styles. Discovery is read-only.
+ *
+ * Everything is fail-soft: malformed JSON, missing dirs, or hostile path
+ * entries degrade to "that plugin absent" — never a failed launch. Path
+ * entries from marketplace/plugin manifests are containment-checked (realpath
+ * inside the expected root) so a malicious `source` or component override
+ * cannot reach outside its repo/plugin.
+ */
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { isAbsolute, join, resolve, sep } from "node:path";
+// ── fail-soft fs/json primitives ────────────────────────────────────────────
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function isFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function readJsonObject(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function realOrNull(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve `candidate` (a relative path from untrusted JSON) against `root` and
+ * return its realpath only when it exists AND stays inside `root` after
+ * symlink resolution. Absolute candidates and any `../` escape are rejected.
+ */
+export function containedExistingPath(root, candidate) {
+    if (typeof candidate !== "string" || candidate.length === 0)
+        return null;
+    if (isAbsolute(candidate))
+        return null;
+    const realRoot = realOrNull(root);
+    if (!realRoot)
+        return null;
+    const real = realOrNull(resolve(root, candidate));
+    if (!real)
+        return null;
+    if (real !== realRoot && !real.startsWith(realRoot + sep))
+        return null;
+    return real;
+}
+/** `~/.claude/plugins/installed_plugins.json` → `name@marketplace` → entries. */
+export function readInstalledPlugins(homeDir) {
+    const out = new Map();
+    const parsed = readJsonObject(join(homeDir, ".claude", "plugins", "installed_plugins.json"));
+    const plugins = parsed?.plugins;
+    if (!plugins || typeof plugins !== "object" || Array.isArray(plugins))
+        return out;
+    for (const [key, value] of Object.entries(plugins)) {
+        if (!Array.isArray(value))
+            continue;
+        const entries = [];
+        for (const item of value) {
+            if (!item || typeof item !== "object")
+                continue;
+            const installPath = item.installPath;
+            if (typeof installPath !== "string" || installPath.length === 0)
+                continue;
+            const projectPath = item.projectPath;
+            entries.push({
+                installPath,
+                ...(typeof projectPath === "string" ? { projectPath } : {}),
+            });
+        }
+        if (entries.length > 0)
+            out.set(key, entries);
+    }
+    return out;
+}
+function collectEnabled(path, scope, into) {
+    const parsed = readJsonObject(path);
+    const enabled = parsed?.enabledPlugins;
+    if (!enabled || typeof enabled !== "object" || Array.isArray(enabled))
+        return;
+    for (const [key, value] of Object.entries(enabled)) {
+        if (value === true || value === false)
+            into.set(key, { enabled: value, scope });
+    }
+}
+/**
+ * `enabledPlugins` merged across scopes, later (more specific) winning:
+ * user `~/.claude/settings.json` < project `.claude/settings.json` <
+ * project `.claude/settings.local.json`.
+ */
+export function readEnabledPlugins(cwd, homeDir) {
+    const out = new Map();
+    collectEnabled(join(homeDir, ".claude", "settings.json"), "user", out);
+    collectEnabled(join(cwd, ".claude", "settings.json"), "project", out);
+    collectEnabled(join(cwd, ".claude", "settings.local.json"), "project", out);
+    return out;
+}
+/** `~/.claude/plugins/known_marketplaces.json` → marketplace name → checkout dir. */
+export function readKnownMarketplaces(homeDir) {
+    const out = new Map();
+    const parsed = readJsonObject(join(homeDir, ".claude", "plugins", "known_marketplaces.json"));
+    if (!parsed)
+        return out;
+    for (const [name, value] of Object.entries(parsed)) {
+        if (!value || typeof value !== "object")
+            continue;
+        const loc = value.installLocation;
+        if (typeof loc === "string" && loc.length > 0)
+            out.set(name, loc);
+    }
+    return out;
+}
+/** Parse `<root>/.claude-plugin/marketplace.json`; null when absent/unusable. */
+export function readMarketplace(root) {
+    const parsed = readJsonObject(join(root, ".claude-plugin", "marketplace.json"));
+    if (!parsed || typeof parsed.name !== "string" || parsed.name.length === 0)
+        return null;
+    if (!Array.isArray(parsed.plugins))
+        return null;
+    const metadata = parsed.metadata && typeof parsed.metadata === "object" && !Array.isArray(parsed.metadata)
+        ? parsed.metadata
+        : {};
+    const pluginRoot = typeof metadata.pluginRoot === "string" ? metadata.pluginRoot : null;
+    const plugins = [];
+    for (const item of parsed.plugins) {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const name = item.name;
+        if (typeof name !== "string" || name.length === 0)
+            continue;
+        plugins.push({ name, source: item.source });
+    }
+    return { name: parsed.name, root, pluginRoot, plugins };
+}
+/**
+ * The local directory a marketplace entry's source points at, when it is a
+ * relative-path source that exists inside the marketplace root. Object
+ * sources (github/url/npm/...) are network installs → null here.
+ */
+export function resolveLocalPluginRoot(mp, entry) {
+    const src = entry.source;
+    if (typeof src !== "string" || src.length === 0)
+        return null;
+    if (isAbsolute(src))
+        return null;
+    // Docs: `metadata.pluginRoot` lets a bare "formatter" mean "./plugins/formatter".
+    // Try the pluginRoot-prefixed form first, then the source as written.
+    const candidates = [];
+    if (mp.pluginRoot)
+        candidates.push(`${mp.pluginRoot}/${src}`);
+    candidates.push(src);
+    for (const candidate of candidates) {
+        const contained = containedExistingPath(mp.root, candidate);
+        if (contained && isDirectory(contained))
+            return contained;
+    }
+    return null;
+}
+// ── plugin component assets ─────────────────────────────────────────────────
+function asStringArray(value) {
+    if (typeof value === "string")
+        return [value];
+    if (Array.isArray(value))
+        return value.filter((v) => typeof v === "string");
+    return [];
+}
+/**
+ * The bridgeable assets inside one plugin checkout, per Claude Code's
+ * component rules: `skills/` (manifest `skills` ADDS dirs), `commands/`
+ * (manifest REPLACES), `agents/` (manifest REPLACES; dirs only — pi's
+ * discovery reads whole dirs), root `SKILL.md` fallback. Null when the plugin
+ * has nothing we can bridge.
+ */
+export function pluginAssets(root, name) {
+    if (!isDirectory(root))
+        return null;
+    const manifest = readJsonObject(join(root, ".claude-plugin", "plugin.json")) ?? {};
+    const skillPaths = [];
+    const defaultSkills = join(root, "skills");
+    if (isDirectory(defaultSkills))
+        skillPaths.push(defaultSkills);
+    const manifestSkills = asStringArray(manifest.skills);
+    for (const rel of manifestSkills) {
+        const contained = containedExistingPath(root, rel);
+        if (contained)
+            skillPaths.push(contained);
+    }
+    if (skillPaths.length === 0 && manifestSkills.length === 0) {
+        const rootSkill = join(root, "SKILL.md");
+        if (isFile(rootSkill))
+            skillPaths.push(rootSkill);
+    }
+    const componentPaths = (manifestValue, defaultDir) => {
+        const entries = asStringArray(manifestValue);
+        if (entries.length > 0) {
+            const out = [];
+            for (const rel of entries) {
+                const contained = containedExistingPath(root, rel);
+                if (contained)
+                    out.push(contained);
+            }
+            return out;
+        }
+        const def = join(root, defaultDir);
+        return isDirectory(def) ? [def] : [];
+    };
+    const commandPaths = componentPaths(manifest.commands, "commands");
+    const agentDirs = componentPaths(manifest.agents, "agents").filter(isDirectory);
+    if (skillPaths.length === 0 && commandPaths.length === 0 && agentDirs.length === 0)
+        return null;
+    return { name, root, skillPaths, commandPaths, agentDirs };
+}
+function resolveInstalledRoot(key, installed, marketplaces, realCwd) {
+    const entries = (installed.get(key) ?? []).filter((e) => isDirectory(e.installPath));
+    const projectMatch = entries.find((e) => {
+        if (typeof e.projectPath !== "string")
+            return false;
+        const real = realOrNull(e.projectPath);
+        if (!real)
+            return false;
+        return realCwd === real || realCwd.startsWith(real + sep);
+    });
+    if (projectMatch)
+        return projectMatch.installPath;
+    if (entries[0])
+        return entries[0].installPath;
+    // Cache entry gone: try the marketplace checkout's own copy of the plugin.
+    const at = key.lastIndexOf("@");
+    if (at <= 0)
+        return null;
+    const pluginName = key.slice(0, at);
+    const marketplaceName = key.slice(at + 1);
+    const location = marketplaces.get(marketplaceName);
+    if (!location)
+        return null;
+    const mp = readMarketplace(location);
+    if (!mp)
+        return null;
+    const entry = mp.plugins.find((p) => p.name === pluginName);
+    if (!entry)
+        return null;
+    return resolveLocalPluginRoot(mp, entry);
+}
+/**
+ * All locally-present Claude Code plugin content relevant to `cwd`, split by
+ * the trust posture the launcher must apply. Never throws.
+ */
+export function discoverClaudePlugins(deps) {
+    try {
+        const installed = readInstalledPlugins(deps.homeDir);
+        const enabled = readEnabledPlugins(deps.cwd, deps.homeDir);
+        const marketplaces = readKnownMarketplaces(deps.homeDir);
+        const realCwd = realOrNull(deps.cwd) ?? resolve(deps.cwd);
+        const user = [];
+        const project = [];
+        const seen = new Set();
+        for (const [key, state] of enabled) {
+            if (!state.enabled)
+                continue;
+            const root = resolveInstalledRoot(key, installed, marketplaces, realCwd);
+            if (!root)
+                continue;
+            const at = key.lastIndexOf("@");
+            const assets = pluginAssets(root, at > 0 ? key.slice(0, at) : key);
+            if (!assets)
+                continue;
+            seen.add(key);
+            (state.scope === "user" ? user : project).push(assets);
+        }
+        // The internal-marketplace pattern: working inside the marketplace repo
+        // itself, its locally-present plugins load (trust-gated) with zero config.
+        const repoMarketplace = readMarketplace(deps.cwd);
+        if (repoMarketplace) {
+            for (const entry of repoMarketplace.plugins) {
+                const key = `${entry.name}@${repoMarketplace.name}`;
+                if (seen.has(key))
+                    continue;
+                if (enabled.get(key)?.enabled === false)
+                    continue;
+                const root = resolveLocalPluginRoot(repoMarketplace, entry) ??
+                    resolveInstalledRoot(key, installed, marketplaces, realCwd);
+                if (!root)
+                    continue;
+                const assets = pluginAssets(root, entry.name);
+                if (!assets)
+                    continue;
+                seen.add(key);
+                project.push(assets);
+            }
+        }
+        return { user, project };
+    }
+    catch {
+        return { user: [], project: [] };
+    }
+}
+//# sourceMappingURL=claudePlugins.js.map

package/dist/cli.js

@@ -24,6 +24,7 @@ import { login } from "./login.js";
 import { logout } from "./logout.js";
 import { buildLaunch } from "./launch.js";
 import { runDoctor } from "./doctor.js";
+import { installProcessCrashHandlers } from "./crashReport.js";
 import { currentCliVersion, maybeNudgeAndRefresh, upgradeCommand } from "./upgrade.js";
 import { maybeRefreshAtLaunch } from "./refresh.js";
 import { ensureShadowPiPackage } from "./piPackage.js";
@@ -89,16 +90,16 @@ async function runDefault(passthroughArgs) {
     // .claude/skills and .claude/commands into the agent, asking the one-time
     // per-folder trust question when needed. Fail-soft: compat can only add
     // flags, never block a launch.
-    let compatArgs = [];
+    let compat = { argv: [], env: {} };
     try {
-        compatArgs = await claudeCompatArgs({
+        compat = await claudeCompatArgs({
             cwd: process.cwd(),
             agentDir: piAgentDir,
             confirm: confirmOnTty,
         });
     }
     catch {
-        compatArgs = [];
+        compat = { argv: [], env: {} };
     }
     // buildLaunch runs the token-expiry preflight: it throws (with an actionable
     // login prompt) on an already-expired token so we never spawn a session that
@@ -111,11 +112,13 @@ async function runDefault(passthroughArgs) {
             extensionPath: resolveExtensionPath(),
             agentDir: piAgentDir,
             piPackageDir: shadowPiDir,
-            extraAgentArgs: compatArgs,
+            extraAgentArgs: compat.argv,
+            extraEnv: compat.env,
             // Forward the active profile's file path so the extension can persist a
             // mid-session token rotation back to the same profile the launcher read.
             profilePath: profilePath(profile.name),
             stateDir: credentialsDir(),
+            cliVersion: cliVersion(),
             baseEnv: process.env,
         });
     }
@@ -173,6 +176,8 @@ export const HELP_TEXT = [
     "Set YAGNI_BASE_URL to override the base URL for a single run.",
     "Set YAGNI_DISABLE_UPDATE_CHECK=1 to silence the new-version notice.",
     "Set YAGNI_DISABLE_CLAUDE_COMPAT=1 to skip loading .claude assets.",
+    "Set YAGNI_DISABLE_BRANDING=1 to pass the system prompt through unmodified.",
+    "Set YAGNI_DISABLE_CRASH_REPORTS=1 to turn off sanitized crash reports.",
 ].join("\n");
 /** Parse `use <name> [--base-url <url>]` argv into its parts. */
 export function parseUseArgs(args) {
@@ -316,6 +321,11 @@ export function isEntrypoint(argv1, moduleUrl) {
 // Only auto-run when invoked as the CLI entry, so tests can import this module
 // (e.g. to exercise wantsHelp) without spawning the agent.
 if (isEntrypoint(process.argv[1], import.meta.url)) {
+    // Crash reporting for the LAUNCHER process only (pi runs as a child and the
+    // extension covers the session side). Fire-and-forget, sanitized, bounded;
+    // YAGNI_DISABLE_CRASH_REPORTS=1 turns it off. Registered before main() so a
+    // crash anywhere in the launcher is covered.
+    installProcessCrashHandlers({ client: "cli", clientVersion: cliVersion() });
     main(process.argv.slice(2))
         .then((code) => process.exit(code))
         .catch((err) => {

package/dist/crashReport.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Crash reporting for the YAGNI Code launcher (and, via deep import, the
+ * desktop driver): a sanitized, fire-and-forget POST to the customer's own
+ * YAGNI backend at /api/yagni-code/crash. Deliberately no third-party
+ * telemetry SDK — crash reports are the ONLY thing this CLI phones home, they
+ * contain no code and no prompts, and `YAGNI_DISABLE_CRASH_REPORTS=1` turns
+ * them off entirely (same switch family as YAGNI_DISABLE_UPDATE_CHECK).
+ *
+ * Everything here is fail-soft: reporting never throws, never retries, never
+ * blocks longer than the short timeout, and never changes how the process
+ * would otherwise crash.
+ *
+ * The sanitizer core (scrub patterns + env-value redaction + path collapse +
+ * caps) is duplicated in `pi-extension-yagni/src/crashReport.ts` (the
+ * extension is bundled standalone and cannot import across packages) and
+ * re-run server-side in `backend/src/yagniCode/crashReports.ts`. Keep the
+ * three in sync. 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;
+/** Hard ceiling the process-exit path waits for a report before exiting. */
+export declare const CRASH_REPORT_EXIT_RACE_MS = 1600;
+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;
+/** If the serialized payload would exceed this, the stack is dropped. */
+export declare const MAX_CRASH_PAYLOAD_BYTES = 16384;
+/** Same truthiness rule as updateChecksDisabled: set and not "" / "0". */
+export declare function crashReportsDisabled(env?: NodeJS.ProcessEnv): boolean;
+export interface SanitizeCrashOptions {
+    /** Environment whose values get redacted (defaults to process.env). */
+    env?: NodeJS.ProcessEnv;
+    /** Repo root; paths under it become repo-relative instead of basenames. */
+    repoRoot?: string;
+}
+/**
+ * Sanitize one piece of crash text. Order matters:
+ *   1. env-value redaction (non-path values, length >= 8) → `[ENV:NAME]`
+ *   2. secret patterns (keys, connection strings, base64 blobs)
+ *   3. home-dir collapse to `~`
+ *   4. repo-root strip (repo files stay readable as relative paths)
+ *   5. every remaining absolute/`~` path → basename (node_modules kept from
+ *      `node_modules/` on, so dependency frames stay diagnosable)
+ * Over-redacts rather than under-redacts; pure; never throws.
+ */
+export declare function sanitizeCrashText(text: string, opts?: SanitizeCrashOptions): string;
+export interface SanitizedCrash {
+    errorClass: string;
+    message: string;
+    stack?: string;
+}
+/**
+ * Reduce an arbitrary thrown value to sanitized error facts. Reads ONLY
+ * `name`, `message`, and `stack` — custom fields (response bodies, request
+ * payloads…) are never touched.
+ */
+export declare function sanitizeCrashError(err: unknown, opts?: SanitizeCrashOptions): SanitizedCrash;
+export type CrashClient = "cli" | "desktop" | "desktop-driver";
+export interface CrashReportInput {
+    client: CrashClient;
+    clientVersion: string;
+    error: unknown;
+    /** Command/phase label, e.g. "uncaught-exception" or "go:implement". */
+    context?: string;
+    baseUrl: string;
+    token: string;
+    env?: NodeJS.ProcessEnv;
+    repoRoot?: string;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+}
+/**
+ * Pre-extracted crash facts (e.g. relayed from the desktop webview or the
+ * Rust panic hook, where no live Error object crosses the boundary). Each
+ * text field is sanitized and capped before sending.
+ */
+export interface CrashFieldsInput {
+    client: CrashClient;
+    clientVersion: string;
+    errorClass: string;
+    message: string;
+    stack?: string;
+    context?: string;
+    baseUrl: string;
+    token: string;
+    env?: NodeJS.ProcessEnv;
+    repoRoot?: string;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+}
+/**
+ * Sanitize + POST one crash report from pre-extracted fields. Resolves on
+ * every outcome — timeout, network error, non-2xx, disabled — and never
+ * throws; there is nobody upstream who could act on a failure, and a
+ * reporting bug must never re-crash the process.
+ */
+export declare function sendCrashReport(input: CrashFieldsInput): Promise<void>;
+/**
+ * Fire one crash report from a live thrown value. Same never-throws contract
+ * as {@link sendCrashReport}, which does the sending.
+ */
+export declare function reportCrash(input: CrashReportInput): Promise<void>;
+export interface InstallCrashHandlersOptions {
+    client: CrashClient;
+    clientVersion: string;
+    /** Credentials source; defaults to the active profile. Fail-soft. */
+    resolveTarget?: () => Promise<{
+        baseUrl: string;
+        token: string;
+    } | null>;
+    env?: NodeJS.ProcessEnv;
+    repoRoot?: string;
+    fetchImpl?: typeof fetch;
+    /** Ceiling on how long the exit path waits for the report. */
+    raceMs?: number;
+    /** Test seams. */
+    exit?: (code: number) => void;
+    writeStderr?: (text: string) => void;
+    proc?: Pick<NodeJS.Process, "on">;
+}
+/**
+ * The handler behind uncaughtException/unhandledRejection: report (bounded by
+ * `raceMs`), then preserve today's crash behavior — print the error to stderr
+ * and exit 1. Exposed for tests; `installProcessCrashHandlers` registers it.
+ */
+export declare function makeProcessCrashHandler(context: "uncaught-exception" | "unhandled-rejection", opts: InstallCrashHandlersOptions): (err: unknown) => void;
+/**
+ * Install process-level crash reporting. Call once, before main() runs, from
+ * a process YAGNI owns (the launcher, the desktop driver) — never from inside
+ * pi's process, where adding these listeners would change crash semantics.
+ */
+export declare function installProcessCrashHandlers(opts: InstallCrashHandlersOptions): void;
+//# sourceMappingURL=crashReport.d.ts.map