@yagni-app/code 0.1.0

package/dist/launch.js

@@ -0,0 +1,106 @@
+/**
+ * Build the configured pi launch. `buildLaunch` is pure (no spawn, no fs) so it
+ * is fully unit-testable: it returns the child environment and the pi argv that
+ * registers pi-extension-yagni and defaults the provider to `yagni`.
+ */
+import { agentDirEnvVar } from "./branding.js";
+/**
+ * How close to expiry the token can be before launch warns. A coding session
+ * easily outlives a token, so warn early enough that re-logging in before a long
+ * task is worthwhile, without nagging on every launch.
+ */
+export const EXPIRY_WARNING_THRESHOLD_MS = 30 * 60 * 1000;
+/**
+ * Pure classifier for a token's ISO `expiresAt` against the current time. A
+ * missing or unparseable expiry is "unknown" (older profiles predate the field,
+ * so we proceed rather than block). Never throws.
+ */
+export function classifyTokenExpiry(expiresAt, nowMs, thresholdMs = EXPIRY_WARNING_THRESHOLD_MS) {
+    if (!expiresAt)
+        return { kind: "unknown" };
+    const expiryMs = Date.parse(expiresAt);
+    if (Number.isNaN(expiryMs))
+        return { kind: "unknown" };
+    const remaining = expiryMs - nowMs;
+    if (remaining <= 0)
+        return { kind: "expired" };
+    if (remaining <= thresholdMs) {
+        return { kind: "approaching", minutesRemaining: Math.max(1, Math.ceil(remaining / 60_000)) };
+    }
+    return { kind: "valid" };
+}
+export function buildLaunch(creds, passthroughArgs, opts) {
+    if (!creds?.token) {
+        throw new Error("Not logged in. Run `yagni login` first.");
+    }
+    // Launch-time expiry preflight. An already-expired token would spawn a session
+    // that 401s on its very first completion and on every grounding tool, so block
+    // it here with an actionable login prompt instead. An approaching expiry is a
+    // non-fatal warning the caller surfaces; the session still launches.
+    const nowMs = opts.now ? opts.now() : Date.now();
+    const expiry = classifyTokenExpiry(creds.expiresAt, nowMs);
+    if (expiry.kind === "expired") {
+        throw new Error("Your YAGNI Code session has expired. Run `yagni login` to re-authenticate.");
+    }
+    const warnings = [];
+    if (expiry.kind === "approaching") {
+        const m = expiry.minutesRemaining;
+        warnings.push(`Your YAGNI Code session expires in about ${m} minute${m === 1 ? "" : "s"}. ` +
+            "Run `yagni login` to refresh it before it lapses.");
+    }
+    const env = {
+        ...(opts.baseEnv ?? {}),
+        YAGNI_TOKEN: creds.token,
+        YAGNI_BASE_URL: creds.baseUrl,
+        // Forward the token's expiry (when known) so the extension can surface a
+        // single in-session "expiring soon" notice. Read-only signal: no refresh.
+        ...(creds.expiresAt ? { YAGNI_TOKEN_EXPIRES_AT: creds.expiresAt } : {}),
+        // Forward the bound workspace id (when known) so the extension can key its
+        // one-time init-pass marker per workspace (Onramp Door B idempotency).
+        ...(creds.workspaceId ? { YAGNI_WORKSPACE_ID: creds.workspaceId } : {}),
+        // Forward the active profile's file path (when known) so the extension can
+        // atomically persist a mid-session token rotation back to the same profile
+        // the launcher read (0600). Absent when the caller can't resolve it.
+        ...(opts.profilePath ? { YAGNI_PROFILE_PATH: opts.profilePath } : {}),
+        // Rebrand pi's chrome ("pi"/"π" → "YAGNI Code"): pi reads piConfig.name from
+        // the package at PI_PACKAGE_DIR (a shadow package the launcher generates).
+        ...(opts.piPackageDir ? { PI_PACKAGE_DIR: opts.piPackageDir } : {}),
+        // Hermetic config: pin pi's agent dir to a YAGNI-owned location so the
+        // user's machine-wide ~/.pi/agent (providers, stored keys, saved default
+        // model, theme) can't bleed in or bypass the YAGNI proxy. The model scope
+        // is then exactly the backend catalog under the `yagni` provider.
+        //
+        // pi derives the env var NAME from its app name
+        // (`${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`), so once rebranded it reads
+        // "YAGNI_CODING_AGENT_DIR". We set that key AND the plain
+        // PI_CODING_AGENT_DIR as defense-in-depth: if the rebrand ever fails the app
+        // name stays "pi", and the plain key keeps the hermetic boundary intact
+        // instead of silently falling back to ~/.pi/agent.
+        [agentDirEnvVar()]: opts.agentDir,
+        PI_CODING_AGENT_DIR: opts.agentDir,
+        // Match the e2b harness defaults: skip pi's update check + telemetry.
+        PI_SKIP_VERSION_CHECK: "1",
+        PI_TELEMETRY: "0",
+    };
+    // Always load our extension. Default the provider to `yagni` unless the user
+    // explicitly chose one (so power users can still point pi elsewhere).
+    const userChoseProvider = passthroughArgs.some(arg => arg === "--provider" || arg.startsWith("--provider="));
+    // Default the model to the `advanced` tier — the strongest judgment-grade
+    // model, so interactive sessions get the best reasoning by default. A user
+    // `--model` (e.g. `standard` or `efficient`) still wins. Without this, pi's
+    // default-model heuristic could land an interactive session on a weaker tier.
+    // Detect if the user explicitly set a model, whether via "--model" as a separate
+    // argument or using the equals form "--model=efficient". The previous check only
+    // caught the separate form, causing a duplicate "--model advanced" to be added
+    // when the equals form was used.
+    const userChoseModel = passthroughArgs.some(arg => arg === "--model" || arg.startsWith("--model="));
+    const argv = [
+        "-e",
+        opts.extensionPath,
+        ...(userChoseProvider ? [] : ["--provider", "yagni"]),
+        ...(userChoseModel ? [] : ["--model", "advanced"]),
+        ...passthroughArgs,
+    ];
+    return { env, argv, warnings };
+}
+//# sourceMappingURL=launch.js.map

package/dist/login.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Device-code login flow (RFC 8628 client side):
+ *   1. POST /api/yagni-code/auth/device → show the user_code + verification URL.
+ *   2. Poll POST /api/yagni-code/auth/token until the human approves in the
+ *      web app, then store the returned token.
+ */
+import type { Credentials } from "./credentials.js";
+export interface LoginDeps {
+    baseUrl?: string;
+    /** Which profile to store the minted token in. Defaults to the active one. */
+    profileName?: string;
+    fetchImpl?: typeof fetch;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+    log?: (msg: string) => void;
+    persist?: (creds: Credentials) => Promise<void>;
+    /** Open a URL in the user's default browser. Defaults to cross-platform open. */
+    openUrl?: (url: string) => Promise<void>;
+}
+/** Spawns a binary with a literal arg vector (no shell). */
+type OpenRunner = (cmd: string, args: string[]) => Promise<void>;
+/**
+ * Resolve the OS-native command + argv to open `url` in the default browser,
+ * cross-platform. The URL is always a standalone argv element so it is handed
+ * to the OS verbatim — it is NEVER interpolated into a shell string, where
+ * `$(...)` / backticks in a hostile verification URL could execute commands.
+ *
+ *   macOS:   open <url>
+ *   Linux:   xdg-open <url>
+ *   Windows: cmd /c start "" <url>   (the empty "" is start's window-title slot;
+ *            without it `start` swallows the URL as the title and opens nothing)
+ */
+export declare function resolveOpenCommand(url: string, platform?: NodeJS.Platform): {
+    cmd: string;
+    args: string[];
+};
+/**
+ * Open a URL in the user's default browser, best-effort. Uses `execFile` (no
+ * shell) so a hostile URL cannot inject commands. Failures are swallowed — the
+ * URL is still printed for manual copy. `runner` is injectable for tests.
+ */
+export declare const realOpenUrl: (url: string, runner?: OpenRunner) => Promise<void>;
+export declare function login(deps?: LoginDeps): Promise<Credentials>;
+export {};
+//# sourceMappingURL=login.d.ts.map

package/dist/login.js

@@ -0,0 +1,142 @@
+/**
+ * Device-code login flow (RFC 8628 client side):
+ *   1. POST /api/yagni-code/auth/device → show the user_code + verification URL.
+ *   2. Poll POST /api/yagni-code/auth/token until the human approves in the
+ *      web app, then store the returned token.
+ */
+import { execFile } from "node:child_process";
+import { resolveBaseUrl } from "./config.js";
+import { getActiveProfileName, persistProfileCredentials } from "./profiles.js";
+const realSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * Per-poll wall-clock cap so a single hung token request can't stall the whole
+ * device-code wait. A timed-out poll is swallowed and the loop tries again until
+ * the device code's own deadline.
+ */
+const POLL_REQUEST_TIMEOUT_MS = 10_000;
+/**
+ * RFC 8628 `slow_down`: when the server signals we are polling too fast (HTTP
+ * 429), lengthen the interval by 5s and keep waiting rather than failing.
+ */
+const SLOW_DOWN_INCREMENT_MS = 5_000;
+/** Whether an error is a per-request timeout/abort (vs. a real network error). */
+function isTimeoutError(err) {
+    return err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError");
+}
+/**
+ * Resolve the OS-native command + argv to open `url` in the default browser,
+ * cross-platform. The URL is always a standalone argv element so it is handed
+ * to the OS verbatim — it is NEVER interpolated into a shell string, where
+ * `$(...)` / backticks in a hostile verification URL could execute commands.
+ *
+ *   macOS:   open <url>
+ *   Linux:   xdg-open <url>
+ *   Windows: cmd /c start "" <url>   (the empty "" is start's window-title slot;
+ *            without it `start` swallows the URL as the title and opens nothing)
+ */
+export function resolveOpenCommand(url, platform = process.platform) {
+    if (platform === "darwin")
+        return { cmd: "open", args: [url] };
+    if (platform === "win32")
+        return { cmd: "cmd", args: ["/c", "start", "", url] };
+    return { cmd: "xdg-open", args: [url] };
+}
+const spawnRunner = (cmd, args) => new Promise((resolve, reject) => {
+    execFile(cmd, args, (err) => (err ? reject(err) : resolve()));
+});
+/**
+ * Open a URL in the user's default browser, best-effort. Uses `execFile` (no
+ * shell) so a hostile URL cannot inject commands. Failures are swallowed — the
+ * URL is still printed for manual copy. `runner` is injectable for tests.
+ */
+export const realOpenUrl = (url, runner = spawnRunner) => {
+    const { cmd, args } = resolveOpenCommand(url);
+    return runner(cmd, args).catch(() => {
+        // Silently fail — the user can still copy the URL manually.
+    });
+};
+export async function login(deps = {}) {
+    const baseUrl = deps.baseUrl ?? resolveBaseUrl();
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const now = deps.now ?? Date.now;
+    const sleep = deps.sleep ?? realSleep;
+    const log = deps.log ?? ((m) => process.stdout.write(`${m}\n`));
+    // By default the token lands in the active profile; tests inject `persist`.
+    const persist = deps.persist ??
+        (async (creds) => {
+            const profileName = deps.profileName ?? (await getActiveProfileName());
+            await persistProfileCredentials(profileName, creds);
+        });
+    // Open the verification URL automatically; failures are swallowed so the
+    // user can still copy it manually.
+    const openUrl = deps.openUrl ?? realOpenUrl;
+    const startRes = await fetchImpl(`${baseUrl}/api/yagni-code/auth/device`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: "{}",
+        signal: AbortSignal.timeout(POLL_REQUEST_TIMEOUT_MS),
+    });
+    if (!startRes.ok) {
+        throw new Error(`Could not start login (HTTP ${startRes.status}). Is YAGNI Code enabled for your workspace?`);
+    }
+    const start = (await startRes.json());
+    log("");
+    log("Opening your browser to authorize YAGNI Code…");
+    log(`    ${start.verification_url}`);
+    log("If it doesn't open automatically, copy the URL above and enter the code:");
+    log(`    ${start.user_code}`);
+    log("");
+    log("Waiting for approval…");
+    // Best-effort auto-open; the URL is already printed above.
+    await openUrl(start.verification_url).catch(() => { });
+    const deadline = now() + start.expires_in * 1000;
+    // Interval can grow across the loop when the server asks us to slow down, so
+    // it's mutable rather than a one-shot constant.
+    let intervalMs = Math.max(1, start.interval) * 1000;
+    while (now() < deadline) {
+        await sleep(intervalMs);
+        let res;
+        try {
+            res = await fetchImpl(`${baseUrl}/api/yagni-code/auth/token`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ device_code: start.device_code }),
+                signal: AbortSignal.timeout(POLL_REQUEST_TIMEOUT_MS),
+            });
+        }
+        catch (err) {
+            // A per-request timeout (or transient blip) must not abandon a long
+            // device-code wait — keep polling until the code's own deadline. A
+            // genuine, non-timeout error still propagates.
+            if (isTimeoutError(err))
+                continue;
+            throw err;
+        }
+        if (res.status === 200) {
+            const data = (await res.json());
+            const creds = {
+                token: data.token,
+                baseUrl,
+                workspaceId: data.workspaceId,
+                expiresAt: data.expiresAt,
+            };
+            await persist(creds);
+            log("✓ Logged in. Run `yagni` in a repo to start.");
+            return creds;
+        }
+        if (res.status === 428) {
+            continue; // authorization_pending — keep polling
+        }
+        if (res.status === 429) {
+            // slow_down — back off by 5s (RFC 8628) and keep polling.
+            intervalMs += SLOW_DOWN_INCREMENT_MS;
+            continue;
+        }
+        if (res.status === 410) {
+            throw new Error("The login code expired before approval. Run `yagni login` again.");
+        }
+        throw new Error(`Login failed (HTTP ${res.status}).`);
+    }
+    throw new Error("Login timed out before approval. Run `yagni login` again.");
+}
+//# sourceMappingURL=login.js.map

package/dist/logout.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Logout: revoke the active profile's token server-side (best-effort) and clear
+ * it locally. The environment binding (name + base URL) is kept so a later
+ * `yagni login` re-authenticates the same environment without re-`use`.
+ */
+import { type Credentials } from "./credentials.js";
+export interface LogoutDeps {
+    fetchImpl?: typeof fetch;
+    read?: () => Promise<Credentials | null>;
+    remove?: () => Promise<void>;
+    log?: (msg: string) => void;
+}
+export declare function logout(deps?: LogoutDeps): Promise<void>;
+//# sourceMappingURL=logout.d.ts.map

package/dist/logout.js

@@ -0,0 +1,34 @@
+/**
+ * Logout: revoke the active profile's token server-side (best-effort) and clear
+ * it locally. The environment binding (name + base URL) is kept so a later
+ * `yagni login` re-authenticates the same environment without re-`use`.
+ */
+import { clearProfileToken, credentialsFromProfile, getActiveProfileName, readActiveProfile, } from "./profiles.js";
+export async function logout(deps = {}) {
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const read = deps.read ?? (async () => credentialsFromProfile(await readActiveProfile()));
+    const remove = deps.remove ??
+        (async () => {
+            await clearProfileToken(await getActiveProfileName());
+        });
+    const log = deps.log ?? ((m) => process.stdout.write(`${m}\n`));
+    const creds = await read();
+    if (creds?.token) {
+        try {
+            await fetchImpl(`${creds.baseUrl}/api/yagni-code/auth/revoke`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${creds.token}`,
+                },
+                body: "{}",
+            });
+        }
+        catch {
+            // Best-effort: a network failure shouldn't block local logout.
+        }
+    }
+    await remove();
+    log("✓ Logged out.");
+}
+//# sourceMappingURL=logout.js.map

package/dist/paths.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Resolve the bundled dependency entry points the launcher needs: pi's CLI and
+ * the pi-extension-yagni extension. Both are package dependencies, so we resolve
+ * them from this module rather than assuming a global install.
+ *
+ * We use the ESM-native `import.meta.resolve` (NOT `createRequire().resolve`):
+ * pi is an ESM-only package whose `exports` map declares only the `import`
+ * condition, so the CommonJS `require` resolver throws ERR_PACKAGE_PATH_NOT_EXPORTED
+ * on it. pi's package.json is also not an exported subpath, so we read it from
+ * disk after resolving the package's main entry.
+ */
+/** Absolute path to pi-extension-yagni's built entry (dist/index.js). */
+export declare function resolveExtensionPath(): string;
+/**
+ * Absolute path to pi's package root — the dir whose package.json names the
+ * package. The shadow package dir is built from this (we read its package.json
+ * and symlink its `dist/`). Uses the same upward walk as resolvePiCliPath.
+ */
+export declare function resolvePiPackageDir(): string;
+/** Absolute path to pi's CLI entry (its package.json `bin.pi`). */
+export declare function resolvePiCliPath(): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/paths.js

@@ -0,0 +1,75 @@
+/**
+ * Resolve the bundled dependency entry points the launcher needs: pi's CLI and
+ * the pi-extension-yagni extension. Both are package dependencies, so we resolve
+ * them from this module rather than assuming a global install.
+ *
+ * We use the ESM-native `import.meta.resolve` (NOT `createRequire().resolve`):
+ * pi is an ESM-only package whose `exports` map declares only the `import`
+ * condition, so the CommonJS `require` resolver throws ERR_PACKAGE_PATH_NOT_EXPORTED
+ * on it. pi's package.json is also not an exported subpath, so we read it from
+ * disk after resolving the package's main entry.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveModulePath(specifier) {
+    return fileURLToPath(import.meta.resolve(specifier));
+}
+/** Absolute path to pi-extension-yagni's built entry (dist/index.js). */
+export function resolveExtensionPath() {
+    return resolveModulePath("pi-extension-yagni");
+}
+/**
+ * Absolute path to pi's package root — the dir whose package.json names the
+ * package. The shadow package dir is built from this (we read its package.json
+ * and symlink its `dist/`). Uses the same upward walk as resolvePiCliPath.
+ */
+export function resolvePiPackageDir() {
+    const mainEntry = resolveModulePath("@earendil-works/pi-coding-agent");
+    let dir = dirname(mainEntry);
+    for (let i = 0; i < 6; i++) {
+        try {
+            const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+            if (pkg.name === "@earendil-works/pi-coding-agent") {
+                return dir;
+            }
+        }
+        catch {
+            // No package.json here (or unreadable) — keep walking up.
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // Fallback: pi ships its main entry under <root>/dist/, so the root is two
+    // levels up from the resolved entry.
+    return dirname(dirname(mainEntry));
+}
+/** Absolute path to pi's CLI entry (its package.json `bin.pi`). */
+export function resolvePiCliPath() {
+    // Resolves pi's main entry (e.g. <root>/@earendil-works/pi-coding-agent/dist/index.js).
+    const mainEntry = resolveModulePath("@earendil-works/pi-coding-agent");
+    // Walk up to the package root (the dir whose package.json names the package)
+    // and read `bin.pi` from disk.
+    let dir = dirname(mainEntry);
+    for (let i = 0; i < 6; i++) {
+        try {
+            const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+            if (pkg.name === "@earendil-works/pi-coding-agent") {
+                const binRel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.pi ?? "dist/cli.js";
+                return join(dir, binRel);
+            }
+        }
+        catch {
+            // No package.json here (or unreadable) — keep walking up.
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // Fallback: pi ships its CLI alongside its main entry under dist/.
+    return join(dirname(mainEntry), "cli.js");
+}
+//# sourceMappingURL=paths.js.map

package/dist/piPackage.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shadow pi package dir.
+ *
+ * pi reads its identity (`piConfig.name`) and all bundled assets (theme, TUI
+ * assets, export-html, CHANGELOG) relative to the package dir returned by
+ * `getPackageDir()`, which honors the `PI_PACKAGE_DIR` env var. To rebrand
+ * "pi"/"π" out of the chrome WITHOUT modifying `node_modules` (lost on
+ * reinstall) or copying pi wholesale, we generate a tiny shadow dir that:
+ *
+ *   - owns its own `package.json` (pi's, with `piConfig.name` injected), and
+ *   - symlinks `dist/` (+ CHANGELOG/README/docs/examples) back to the real pi
+ *     package, so asset/theme resolution still finds the real files.
+ *
+ * The launcher points `PI_PACKAGE_DIR` at this dir. Regenerated every launch so
+ * a pi upgrade or store-path move can never leave a stale package.json or a
+ * dangling symlink behind.
+ */
+export interface ShadowPiPackageOptions {
+    /** The real pi package root (the dir whose package.json names the package). */
+    realPiDir: string;
+    /** Where to materialize the shadow package (a hermetic, YAGNI-owned dir). */
+    shadowDir: string;
+    /** The `piConfig.name` to inject — what pi shows as its app name. */
+    name: string;
+}
+/**
+ * Materialize (idempotently) the shadow pi package and return its path.
+ *
+ * @throws if the real pi package.json cannot be read — the launcher needs it to
+ * derive pi's version/name, and a silent fallback would re-leak "pi".
+ */
+export declare function ensureShadowPiPackage(opts: ShadowPiPackageOptions): string;
+//# sourceMappingURL=piPackage.d.ts.map

package/dist/piPackage.js

@@ -0,0 +1,71 @@
+/**
+ * Shadow pi package dir.
+ *
+ * pi reads its identity (`piConfig.name`) and all bundled assets (theme, TUI
+ * assets, export-html, CHANGELOG) relative to the package dir returned by
+ * `getPackageDir()`, which honors the `PI_PACKAGE_DIR` env var. To rebrand
+ * "pi"/"π" out of the chrome WITHOUT modifying `node_modules` (lost on
+ * reinstall) or copying pi wholesale, we generate a tiny shadow dir that:
+ *
+ *   - owns its own `package.json` (pi's, with `piConfig.name` injected), and
+ *   - symlinks `dist/` (+ CHANGELOG/README/docs/examples) back to the real pi
+ *     package, so asset/theme resolution still finds the real files.
+ *
+ * The launcher points `PI_PACKAGE_DIR` at this dir. Regenerated every launch so
+ * a pi upgrade or store-path move can never leave a stale package.json or a
+ * dangling symlink behind.
+ */
+import { existsSync, lstatSync, mkdirSync, readFileSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+// Entries pi resolves relative to its package dir. `dist` carries theme + TUI
+// assets + export templates (the load-bearing ones); the rest back /changelog,
+// /about, etc. Each is symlinked only if it exists in the real package.
+const LINKED_ENTRIES = ["dist", "CHANGELOG.md", "README.md", "docs", "examples"];
+function linkInto(shadowDir, realPiDir, entry) {
+    const target = join(realPiDir, entry);
+    if (!existsSync(target))
+        return;
+    const linkPath = join(shadowDir, entry);
+    // Clear any prior entry so we never stack or dangle. A symlink must be
+    // unlinked directly: rmSync stats THROUGH it, so on a dangling link (target
+    // checkout deleted) it sees ENOENT, force-swallows it, and leaves the link
+    // in place - then symlinkSync throws EEXIST and the rebrand silently drops.
+    if (isSymlink(linkPath)) {
+        unlinkSync(linkPath);
+    }
+    else if (existsSync(linkPath)) {
+        rmSync(linkPath, { recursive: true, force: true });
+    }
+    const type = statSync(target).isDirectory() ? "dir" : "file";
+    symlinkSync(target, linkPath, type);
+}
+function isSymlink(p) {
+    try {
+        return lstatSync(p).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Materialize (idempotently) the shadow pi package and return its path.
+ *
+ * @throws if the real pi package.json cannot be read — the launcher needs it to
+ * derive pi's version/name, and a silent fallback would re-leak "pi".
+ */
+export function ensureShadowPiPackage(opts) {
+    const { realPiDir, shadowDir, name } = opts;
+    const realPkgRaw = readFileSync(join(realPiDir, "package.json"), "utf8");
+    const realPkg = JSON.parse(realPkgRaw);
+    mkdirSync(shadowDir, { recursive: true });
+    const shadowPkg = {
+        ...realPkg,
+        piConfig: { ...(realPkg.piConfig ?? {}), name },
+    };
+    writeFileSync(join(shadowDir, "package.json"), `${JSON.stringify(shadowPkg, null, 2)}\n`);
+    for (const entry of LINKED_ENTRIES) {
+        linkInto(shadowDir, realPiDir, entry);
+    }
+    return shadowDir;
+}
+//# sourceMappingURL=piPackage.js.map

package/dist/profiles.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Environment profiles for the yagni-code CLI.
+ *
+ * A profile is a named binding of an environment (base URL) to its own stored
+ * credentials, so you can point YAGNI Code at prod, a local backend, or a
+ * staging host and switch between them with a sticky `yagni use <name>`.
+ *
+ * Storage (each file 0600, the dir 0700, since profiles hold live API tokens):
+ *   ~/.yagni-code/profiles/<name>.json   one profile (name, baseUrl, token, …)
+ *   ~/.yagni-code/config.json            { activeProfile }
+ *
+ * The model is deliberately small but multi-account-ready: a second login to a
+ * different workspace/host is just another profile file. `prod` is the default
+ * active profile and the only built-in preset that needs no `--base-url`.
+ */
+import { type Credentials } from "./credentials.js";
+export interface Profile {
+    name: string;
+    baseUrl: string;
+    token?: string;
+    workspaceId?: string;
+    expiresAt?: string;
+}
+/** The default active profile when nothing has been configured yet. */
+export declare const DEFAULT_PROFILE = "prod";
+export declare function isValidProfileName(name: string): boolean;
+export declare function profilesDir(): string;
+export declare function profilePath(name: string): string;
+export declare function configPath(): string;
+export declare function readProfile(name: string): Promise<Profile | null>;
+export declare function writeProfile(profile: Profile): Promise<void>;
+export declare function deleteProfile(name: string): Promise<void>;
+export declare function listProfileNames(): Promise<string[]>;
+export declare function listProfiles(): Promise<Profile[]>;
+export declare function getActiveProfileName(): Promise<string>;
+export declare function setActiveProfileName(name: string): Promise<void>;
+/** A profile is a superset of Credentials; this yields creds iff it has a token. */
+export declare function credentialsFromProfile(profile: Profile): Credentials | null;
+/**
+ * Resolve the active profile, with its base URL. Always returns a profile (so
+ * callers get a base URL even before a first login); `token` is undefined when
+ * the environment has not been authenticated. `YAGNI_BASE_URL` overrides the
+ * stored/preset base URL for this run only.
+ */
+export declare function readActiveProfile(env?: NodeJS.ProcessEnv): Promise<Profile>;
+/** Persist freshly-minted credentials into a profile (keeping the name). */
+export declare function persistProfileCredentials(name: string, creds: Credentials): Promise<void>;
+/**
+ * Persist a launch-time token ROTATION into an existing profile without
+ * touching its stored base URL. The refresh runs against `creds.baseUrl`, which
+ * may be a per-run `YAGNI_BASE_URL` override (readActiveProfile bakes that in);
+ * persisting it would make a documented single-run override sticky, silently
+ * retargeting every later `yagni` launch at the wrong host. So we rotate only
+ * the token fields and keep the profile's own stored base URL. Falls back to the
+ * passed base URL only when no profile file exists yet (nothing stored to keep).
+ */
+export declare function persistProfileTokenRotation(name: string, creds: Credentials): Promise<void>;
+/** Clear the stored token for a profile but keep the environment binding. */
+export declare function clearProfileToken(name: string): Promise<void>;
+export declare class UnknownEnvironmentError extends Error {
+    constructor(name: string);
+}
+/**
+ * Switch the sticky active profile to `name`, creating it if needed. Base URL
+ * is resolved from (in order): an explicit `--base-url`, the profile's existing
+ * stored URL, or a built-in preset. A name with none of those is an error
+ * rather than a silent default. When `--base-url` changes an existing profile's
+ * host, the stored token is dropped (it belonged to the old environment).
+ */
+export declare function useProfile(name: string, opts?: {
+    baseUrl?: string;
+}): Promise<Profile>;
+/**
+ * One-shot migration: adopt a pre-profiles `~/.yagni-code/credentials.json` as
+ * a named profile so existing logged-in users keep working. No-op once profiles
+ * exist (config.json present or any profile file on disk) or when there is no
+ * legacy file. The legacy file is removed only after the profile is written.
+ */
+export declare function migrateLegacyCredentials(): Promise<void>;
+//# sourceMappingURL=profiles.d.ts.map