@yagni-app/code-staging 0.3.0-staging.1091.1 → 0.3.0-staging.1096.1

package/dist/cli.js

@@ -21,8 +21,10 @@ import { PI_CONFIG_NAME } from "./branding.js";
 import { claudeCompatArgs } from "./claudeCompat.js";
 import { agentDir, credentialsDir, piPackageDir } from "./credentials.js";
 import { DISTRIBUTION } from "./distribution.js";
+import { connectCommand } from "./connectClaudeCode.js";
 import { login } from "./login.js";
 import { logout } from "./logout.js";
+import { tokenCommand } from "./token.js";
 import { buildLaunch } from "./launch.js";
 import { runDoctor } from "./doctor.js";
 import { installProcessCrashHandlers } from "./crashReport.js";
@@ -286,6 +288,10 @@ export const HELP_TEXT = [
     "  yagni login              Authorize the active environment (device-code flow).",
     "  yagni logout             Revoke and clear the active environment's token.",
     "  yagni doctor             Check that everything is ready (green/red checklist).",
+    "  yagni connect claude-code  Route Claude Code through the YAGNI model proxy",
+    "                           (--project scopes to this repo; --off disconnects).",
+    "  yagni connect codex      Route Codex CLI through the YAGNI model proxy.",
+    "  yagni token              Output the active environment's API token (for helpers).",
     "  yagni use <name>         Switch the active environment (sticky).",
     "                           Presets: prod, local. Others need --base-url <url>.",
     "  yagni profiles           List saved environments; the active one is marked.",
@@ -415,6 +421,12 @@ export async function main(argv) {
     if (command === "doctor") {
         return runDoctor();
     }
+    if (command === "connect") {
+        return connectCommand(rest);
+    }
+    if (command === "token") {
+        return tokenCommand();
+    }
     if (command === "upgrade") {
         return upgradeCommand(rest, { current: cliVersion() });
     }

package/dist/connectClaudeCode.d.ts

@@ -0,0 +1,77 @@
+/**
+ * `yagni connect claude-code` — point Claude Code at the YAGNI model proxy.
+ *
+ * Writes the three settings Claude Code needs into `~/.claude/settings.json`
+ * (or `.claude/settings.local.json` with `--project`):
+ *
+ *   env.ANTHROPIC_BASE_URL      the active environment's base URL (Claude Code
+ *                               appends /v1/messages — the proxy's Anthropic-
+ *                               dialect route)
+ *   env.ANTHROPIC_CUSTOM_HEADERS  `x-yagni-caller: claude-code`, the
+ *                               attribution label the usage report rolls up on
+ *   apiKeyHelper                `yagni token` — the credential comes from the
+ *                               profile at call time, so nothing secret is
+ *                               ever baked into a settings file and a rotated
+ *                               token is picked up automatically
+ *
+ * Everything else in the file is preserved verbatim. `--off` removes exactly
+ * the managed keys (the helper only when it is ours). The planner is pure and
+ * the writer is atomic (temp + rename, symlink-refusing) — the same guard
+ * rails as the launcher's settings seeding, except a corrupt file is an ERROR
+ * here rather than a silent back-off: the user asked for a config change, so
+ * failing quietly would be lying.
+ */
+import { type Profile } from "./profiles.js";
+export declare const CALLER_HEADER_LINE = "x-yagni-caller: claude-code";
+export interface ConnectPlanInput {
+    /** The active environment's base URL (no trailing slash). */
+    baseUrl: string;
+    /** The apiKeyHelper command, e.g. `yagni token`. */
+    helperCommand: string;
+}
+export interface ConnectPlan {
+    settings: Record<string, unknown>;
+    /** Human-readable `key: old → new` lines for the summary. */
+    changes: string[];
+    /** Keys that belonged to something else and were replaced — surfaced loudly. */
+    replaced: string[];
+}
+type Settings = Record<string, unknown>;
+/**
+ * Merge our caller header into an existing ANTHROPIC_CUSTOM_HEADERS value:
+ * foreign header lines are preserved, a stale x-yagni-caller line is replaced,
+ * ours lands last. Newline-separated per the Claude Code contract.
+ */
+export declare function mergeCustomHeaders(existing: unknown): string;
+/** Pure: the settings object after connecting, plus what changed. */
+export declare function planConnect(existing: Settings, input: ConnectPlanInput): ConnectPlan;
+export interface DisconnectPlan {
+    settings: Settings;
+    removed: string[];
+    /** A foreign apiKeyHelper we refused to touch, if any. */
+    keptForeignHelper?: string;
+}
+/** Pure: the settings object after `--off` — managed keys out, all else kept. */
+export declare function planDisconnect(existing: Settings, helperCommand: string): DisconnectPlan;
+export declare function settingsPathFor(scope: "user" | "project", cwd: string, home?: string): string;
+/** Read + parse a settings file. Missing → {}. Corrupt/symlink/non-object → throws. */
+export declare function readSettings(path: string): Settings;
+/** Atomic write (temp + rename), preserving an existing file's permissions. */
+export declare function writeSettings(path: string, settings: Settings): void;
+export interface ConnectArgs {
+    target?: string;
+    project: boolean;
+    off: boolean;
+}
+export declare function parseConnectArgs(args: string[]): ConnectArgs;
+export interface ConnectDeps {
+    readProfile?: () => Promise<Profile>;
+    cwd?: string;
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    stdout?: (text: string) => void;
+    stderr?: (text: string) => void;
+}
+export declare function connectCommand(args: string[], deps?: ConnectDeps): Promise<number>;
+export {};
+//# sourceMappingURL=connectClaudeCode.d.ts.map

package/dist/connectClaudeCode.js

@@ -0,0 +1,228 @@
+/**
+ * `yagni connect claude-code` — point Claude Code at the YAGNI model proxy.
+ *
+ * Writes the three settings Claude Code needs into `~/.claude/settings.json`
+ * (or `.claude/settings.local.json` with `--project`):
+ *
+ *   env.ANTHROPIC_BASE_URL      the active environment's base URL (Claude Code
+ *                               appends /v1/messages — the proxy's Anthropic-
+ *                               dialect route)
+ *   env.ANTHROPIC_CUSTOM_HEADERS  `x-yagni-caller: claude-code`, the
+ *                               attribution label the usage report rolls up on
+ *   apiKeyHelper                `yagni token` — the credential comes from the
+ *                               profile at call time, so nothing secret is
+ *                               ever baked into a settings file and a rotated
+ *                               token is picked up automatically
+ *
+ * Everything else in the file is preserved verbatim. `--off` removes exactly
+ * the managed keys (the helper only when it is ours). The planner is pure and
+ * the writer is atomic (temp + rename, symlink-refusing) — the same guard
+ * rails as the launcher's settings seeding, except a corrupt file is an ERROR
+ * here rather than a silent back-off: the user asked for a config change, so
+ * failing quietly would be lying.
+ */
+import { existsSync, lstatSync, readFileSync, renameSync, rmSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { DISTRIBUTION } from "./distribution.js";
+import { credentialsFromProfile, readActiveProfile } from "./profiles.js";
+export const CALLER_HEADER_LINE = "x-yagni-caller: claude-code";
+function envOf(settings) {
+    const env = settings.env;
+    return env && typeof env === "object" && !Array.isArray(env) ? { ...env } : {};
+}
+/**
+ * Merge our caller header into an existing ANTHROPIC_CUSTOM_HEADERS value:
+ * foreign header lines are preserved, a stale x-yagni-caller line is replaced,
+ * ours lands last. Newline-separated per the Claude Code contract.
+ */
+export function mergeCustomHeaders(existing) {
+    const lines = typeof existing === "string" && existing.length > 0 ? existing.split("\n") : [];
+    const kept = lines.filter((l) => l.trim() !== "" && !/^x-yagni-caller\s*:/i.test(l));
+    return [...kept, CALLER_HEADER_LINE].join("\n");
+}
+/** Pure: the settings object after connecting, plus what changed. */
+export function planConnect(existing, input) {
+    const env = envOf(existing);
+    const changes = [];
+    const replaced = [];
+    const note = (key, prior, next) => {
+        if (prior === next)
+            return;
+        changes.push(prior === undefined ? `${key} = ${next}` : `${key}: ${String(prior)} → ${next}`);
+        if (prior !== undefined)
+            replaced.push(key);
+    };
+    note("env.ANTHROPIC_BASE_URL", env.ANTHROPIC_BASE_URL, input.baseUrl);
+    env.ANTHROPIC_BASE_URL = input.baseUrl;
+    const headers = mergeCustomHeaders(env.ANTHROPIC_CUSTOM_HEADERS);
+    if (env.ANTHROPIC_CUSTOM_HEADERS !== headers) {
+        changes.push(`env.ANTHROPIC_CUSTOM_HEADERS = ${headers.replaceAll("\n", " | ")}`);
+    }
+    env.ANTHROPIC_CUSTOM_HEADERS = headers;
+    note("apiKeyHelper", existing.apiKeyHelper, input.helperCommand);
+    return {
+        settings: { ...existing, env, apiKeyHelper: input.helperCommand },
+        changes,
+        replaced,
+    };
+}
+/** Pure: the settings object after `--off` — managed keys out, all else kept. */
+export function planDisconnect(existing, helperCommand) {
+    const env = envOf(existing);
+    const removed = [];
+    const out = { ...existing };
+    if (env.ANTHROPIC_BASE_URL !== undefined) {
+        removed.push("env.ANTHROPIC_BASE_URL");
+        delete env.ANTHROPIC_BASE_URL;
+    }
+    if (typeof env.ANTHROPIC_CUSTOM_HEADERS === "string") {
+        const kept = env.ANTHROPIC_CUSTOM_HEADERS
+            .split("\n")
+            .filter((l) => l.trim() !== "" && !/^x-yagni-caller\s*:/i.test(l));
+        if (kept.length !== env.ANTHROPIC_CUSTOM_HEADERS.split("\n").filter((l) => l.trim() !== "").length) {
+            removed.push("env.ANTHROPIC_CUSTOM_HEADERS (x-yagni-caller line)");
+        }
+        if (kept.length === 0)
+            delete env.ANTHROPIC_CUSTOM_HEADERS;
+        else
+            env.ANTHROPIC_CUSTOM_HEADERS = kept.join("\n");
+    }
+    let keptForeignHelper;
+    if (typeof out.apiKeyHelper === "string") {
+        // Only remove a helper that is ours — `yagni token` under any install path
+        // (npx wrapper, absolute bin). Someone else's gateway helper stays.
+        if (new RegExp(`(^|[/\\s])${helperCommand.split(" ")[0]}\\s+token\\s*$`).test(out.apiKeyHelper)) {
+            removed.push("apiKeyHelper");
+            delete out.apiKeyHelper;
+        }
+        else {
+            keptForeignHelper = out.apiKeyHelper;
+        }
+    }
+    if (Object.keys(env).length === 0 && out.env !== undefined)
+        delete out.env;
+    else
+        out.env = env;
+    return { settings: out, removed, ...(keptForeignHelper ? { keptForeignHelper } : {}) };
+}
+// ---------------------------------------------------------------------------
+// File I/O
+// ---------------------------------------------------------------------------
+export function settingsPathFor(scope, cwd, home = homedir()) {
+    return scope === "project"
+        ? join(cwd, ".claude", "settings.local.json")
+        : join(home, ".claude", "settings.json");
+}
+/** Read + parse a settings file. Missing → {}. Corrupt/symlink/non-object → throws. */
+export function readSettings(path) {
+    if (!existsSync(path))
+        return {};
+    if (lstatSync(path).isSymbolicLink()) {
+        throw new Error(`${path} is a symlink; refusing to rewrite it. Point yagni at the real file.`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        throw new Error(`${path} is not valid JSON. Fix or remove it, then re-run.`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`${path} does not hold a JSON object. Fix or remove it, then re-run.`);
+    }
+    return parsed;
+}
+/** Atomic write (temp + rename), preserving an existing file's permissions. */
+export function writeSettings(path, settings) {
+    const existingMode = existsSync(path) ? lstatSync(path).mode & 0o777 : undefined;
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = join(dirname(path), `.${DISTRIBUTION.commandName}-connect-${process.pid}.tmp`);
+    try {
+        writeFileSync(tmp, `${JSON.stringify(settings, null, 2)}\n`);
+        renameSync(tmp, path);
+    }
+    finally {
+        rmSync(tmp, { force: true });
+    }
+    if (existingMode !== undefined)
+        chmodSync(path, existingMode);
+}
+export function parseConnectArgs(args) {
+    let target;
+    let project = false;
+    let off = false;
+    for (const a of args) {
+        if (a === "--project")
+            project = true;
+        else if (a === "--off")
+            off = true;
+        else if (!a.startsWith("-") && target === undefined)
+            target = a;
+    }
+    return { target, project, off };
+}
+export async function connectCommand(args, deps = {}) {
+    const stdout = deps.stdout ?? ((t) => process.stdout.write(t));
+    const stderr = deps.stderr ?? ((t) => process.stderr.write(t));
+    const { target, project, off } = parseConnectArgs(args);
+    if (target === "codex") {
+        if (project) {
+            stderr("`connect codex` has no --project scope: Codex reads one user-level config.toml.\n");
+            return 1;
+        }
+        const { connectCodexCommand } = await import("./connectCodex.js");
+        return connectCodexCommand({ off }, deps);
+    }
+    if (target !== "claude-code") {
+        stderr(target
+            ? `Unknown connect target "${target}". Supported: claude-code, codex.\n`
+            : `Usage: ${DISTRIBUTION.commandName} connect <claude-code|codex> [--project] [--off]\n`);
+        return 1;
+    }
+    const profile = await (deps.readProfile ?? readActiveProfile)();
+    const helperCommand = `${DISTRIBUTION.commandName} token`;
+    const path = settingsPathFor(project ? "project" : "user", deps.cwd ?? process.cwd(), deps.home);
+    let existing;
+    try {
+        existing = readSettings(path);
+    }
+    catch (err) {
+        stderr(`${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    if (off) {
+        const plan = planDisconnect(existing, DISTRIBUTION.commandName);
+        writeSettings(path, plan.settings);
+        stdout(plan.removed.length > 0
+            ? `✓ Claude Code disconnected from YAGNI.\n  ${path}\n  Removed: ${plan.removed.join(", ")}\n`
+            : `Nothing to disconnect in ${path}.\n`);
+        if (plan.keptForeignHelper) {
+            stdout(`  Kept apiKeyHelper (${plan.keptForeignHelper}) since it is not YAGNI's.\n`);
+        }
+        return 0;
+    }
+    const creds = credentialsFromProfile(profile);
+    if (!creds?.token) {
+        stderr(`Not logged in to environment "${profile.name}" (${profile.baseUrl}). Run \`${DISTRIBUTION.commandName} login\` first.\n`);
+        return 1;
+    }
+    const plan = planConnect(existing, { baseUrl: profile.baseUrl, helperCommand });
+    writeSettings(path, plan.settings);
+    stdout(`✓ Claude Code connected to YAGNI (${profile.name} → ${profile.baseUrl}).\n`);
+    stdout(`  ${path}\n`);
+    for (const change of plan.changes)
+        stdout(`    ${change}\n`);
+    for (const key of plan.replaced) {
+        stdout(`  Replaced an existing ${key}. \`connect claude-code --off\` removes YAGNI's value but cannot restore the old one.\n`);
+    }
+    const shellEnv = deps.env ?? process.env;
+    for (const key of ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"]) {
+        if (shellEnv[key]) {
+            stdout(`  ⚠ ${key} is set in your shell and OUTRANKS the settings written here. Unset it or Claude Code will keep using it.\n`);
+        }
+    }
+    stdout(`  Restart Claude Code to pick this up. Model picks map to YAGNI tiers (fable→peak, opus→advanced, sonnet→standard, haiku→efficient).\n`);
+    return 0;
+}
+//# sourceMappingURL=connectClaudeCode.js.map

package/dist/connectCodex.d.ts

@@ -0,0 +1,75 @@
+/**
+ * `yagni connect codex` — point Codex CLI at the YAGNI model proxy.
+ *
+ * Writes into `~/.codex/config.toml` (respecting CODEX_HOME):
+ *
+ *   model_provider = "yagni"               the active provider
+ *   model = "advanced"                     a YAGNI tier — Codex sends it
+ *                                          verbatim and the proxy's catalog
+ *                                          enforcement validates it
+ *   [model_providers.yagni]                base_url → `<base>/v1` (Codex
+ *                                          appends /responses — the proxy's
+ *                                          Responses-dialect route),
+ *                                          wire_api "responses" (the only
+ *                                          wire current Codex speaks),
+ *                                          x-yagni-caller: codex attribution,
+ *                                          and auth.command = `yagni token` —
+ *                                          Codex's command-backed bearer
+ *                                          token, so no secret is ever baked
+ *                                          into the config and rotation rides
+ *                                          the same refresh client as
+ *                                          everything else.
+ *
+ * TOML cannot be comment-preservingly round-tripped by a parser, so when the
+ * existing config carries comments we save a one-time `config.toml.yagni-backup`
+ * next to it before rewriting and say so — never silently eat a user's notes.
+ * Everything else follows the claude-code connector's contract: managed keys
+ * only, atomic write, symlink refusal, corrupt file is a loud error, `--off`
+ * removes exactly what we own.
+ */
+import { type Profile } from "./profiles.js";
+export declare const CODEX_PROVIDER_ID = "yagni";
+export declare const CODEX_DEFAULT_TIER = "advanced";
+type TomlTable = Record<string, unknown>;
+export declare function codexConfigPath(home?: string, env?: NodeJS.ProcessEnv): string;
+export interface CodexConnectPlan {
+    config: TomlTable;
+    changes: string[];
+    replaced: string[];
+}
+/** Pure: the config after connecting, plus what changed. */
+export declare function planConnectCodex(existing: TomlTable, input: {
+    baseUrl: string;
+    commandName: string;
+}): CodexConnectPlan;
+export interface CodexDisconnectPlan {
+    config: TomlTable;
+    removed: string[];
+}
+/** Pure: the config after `--off` — our provider and its selection out. */
+export declare function planDisconnectCodex(existing: TomlTable): CodexDisconnectPlan;
+export interface CodexConfigFile {
+    config: TomlTable;
+    /** The raw text, kept so a comment-carrying file can be backed up. */
+    raw: string | null;
+}
+/** Read + parse the Codex config. Missing → {}. Corrupt/symlink → throws. */
+export declare function readCodexConfig(path: string): CodexConfigFile;
+/**
+ * Atomic write; when the original text carried comments (which a parse →
+ * stringify round-trip cannot preserve), a `config.toml.yagni-backup` copy of
+ * the original is written first. Returns the backup path when one was made.
+ */
+export declare function writeCodexConfig(path: string, config: TomlTable, originalRaw: string | null): string | null;
+export interface ConnectCodexDeps {
+    readProfile?: () => Promise<Profile>;
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    stdout?: (text: string) => void;
+    stderr?: (text: string) => void;
+}
+export declare function connectCodexCommand(opts: {
+    off: boolean;
+}, deps?: ConnectCodexDeps): Promise<number>;
+export {};
+//# sourceMappingURL=connectCodex.d.ts.map

package/dist/connectCodex.js

@@ -0,0 +1,201 @@
+/**
+ * `yagni connect codex` — point Codex CLI at the YAGNI model proxy.
+ *
+ * Writes into `~/.codex/config.toml` (respecting CODEX_HOME):
+ *
+ *   model_provider = "yagni"               the active provider
+ *   model = "advanced"                     a YAGNI tier — Codex sends it
+ *                                          verbatim and the proxy's catalog
+ *                                          enforcement validates it
+ *   [model_providers.yagni]                base_url → `<base>/v1` (Codex
+ *                                          appends /responses — the proxy's
+ *                                          Responses-dialect route),
+ *                                          wire_api "responses" (the only
+ *                                          wire current Codex speaks),
+ *                                          x-yagni-caller: codex attribution,
+ *                                          and auth.command = `yagni token` —
+ *                                          Codex's command-backed bearer
+ *                                          token, so no secret is ever baked
+ *                                          into the config and rotation rides
+ *                                          the same refresh client as
+ *                                          everything else.
+ *
+ * TOML cannot be comment-preservingly round-tripped by a parser, so when the
+ * existing config carries comments we save a one-time `config.toml.yagni-backup`
+ * next to it before rewriting and say so — never silently eat a user's notes.
+ * Everything else follows the claude-code connector's contract: managed keys
+ * only, atomic write, symlink refusal, corrupt file is a loud error, `--off`
+ * removes exactly what we own.
+ */
+import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { DISTRIBUTION } from "./distribution.js";
+import { credentialsFromProfile, readActiveProfile } from "./profiles.js";
+export const CODEX_PROVIDER_ID = "yagni";
+export const CODEX_DEFAULT_TIER = "advanced";
+export function codexConfigPath(home = homedir(), env = process.env) {
+    const codexHome = env.CODEX_HOME?.trim() ? env.CODEX_HOME.trim() : join(home, ".codex");
+    return join(codexHome, "config.toml");
+}
+function providersOf(config) {
+    const providers = config.model_providers;
+    return providers && typeof providers === "object" && !Array.isArray(providers)
+        ? { ...providers }
+        : {};
+}
+/** Pure: the config after connecting, plus what changed. */
+export function planConnectCodex(existing, input) {
+    const changes = [];
+    const replaced = [];
+    const note = (key, prior, next) => {
+        if (prior === next)
+            return;
+        changes.push(prior === undefined ? `${key} = ${next}` : `${key}: ${String(prior)} → ${next}`);
+        if (prior !== undefined)
+            replaced.push(key);
+    };
+    note("model_provider", existing.model_provider, CODEX_PROVIDER_ID);
+    note("model", existing.model, CODEX_DEFAULT_TIER);
+    const providers = providersOf(existing);
+    if (providers[CODEX_PROVIDER_ID] === undefined) {
+        changes.push(`model_providers.${CODEX_PROVIDER_ID} = (provider block)`);
+    }
+    providers[CODEX_PROVIDER_ID] = {
+        name: "YAGNI",
+        base_url: `${input.baseUrl}/v1`,
+        wire_api: "responses",
+        http_headers: { "x-yagni-caller": "codex" },
+        auth: { command: input.commandName, args: ["token"] },
+    };
+    return {
+        config: {
+            ...existing,
+            model_provider: CODEX_PROVIDER_ID,
+            model: CODEX_DEFAULT_TIER,
+            model_providers: providers,
+        },
+        changes,
+        replaced,
+    };
+}
+/** Pure: the config after `--off` — our provider and its selection out. */
+export function planDisconnectCodex(existing) {
+    const removed = [];
+    const out = { ...existing };
+    const providers = providersOf(existing);
+    if (providers[CODEX_PROVIDER_ID] !== undefined) {
+        removed.push(`model_providers.${CODEX_PROVIDER_ID}`);
+        delete providers[CODEX_PROVIDER_ID];
+    }
+    if (Object.keys(providers).length === 0)
+        delete out.model_providers;
+    else
+        out.model_providers = providers;
+    // The model selection is only ours when it points at our provider — a
+    // foreign model_provider (and its paired model) is left untouched.
+    if (out.model_provider === CODEX_PROVIDER_ID) {
+        removed.push("model_provider");
+        delete out.model_provider;
+        if (typeof out.model === "string") {
+            removed.push("model");
+            delete out.model;
+        }
+    }
+    return { config: out, removed };
+}
+/** Read + parse the Codex config. Missing → {}. Corrupt/symlink → throws. */
+export function readCodexConfig(path) {
+    if (!existsSync(path))
+        return { config: {}, raw: null };
+    if (lstatSync(path).isSymbolicLink()) {
+        throw new Error(`${path} is a symlink; refusing to rewrite it. Point yagni at the real file.`);
+    }
+    const raw = readFileSync(path, "utf8");
+    let parsed;
+    try {
+        parsed = parseToml(raw);
+    }
+    catch {
+        throw new Error(`${path} is not valid TOML. Fix or remove it, then re-run.`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`${path} does not hold a TOML table. Fix or remove it, then re-run.`);
+    }
+    return { config: parsed, raw };
+}
+const COMMENT_RE = /^\s*#|\s#/m;
+/**
+ * Atomic write; when the original text carried comments (which a parse →
+ * stringify round-trip cannot preserve), a `config.toml.yagni-backup` copy of
+ * the original is written first. Returns the backup path when one was made.
+ */
+export function writeCodexConfig(path, config, originalRaw) {
+    mkdirSync(dirname(path), { recursive: true });
+    let backupPath = null;
+    if (originalRaw !== null && COMMENT_RE.test(originalRaw)) {
+        backupPath = `${path}.yagni-backup`;
+        writeFileSync(backupPath, originalRaw);
+    }
+    const existingMode = existsSync(path) ? lstatSync(path).mode & 0o777 : undefined;
+    const tmp = join(dirname(path), `.${DISTRIBUTION.commandName}-connect-codex-${process.pid}.tmp`);
+    try {
+        writeFileSync(tmp, `${stringifyToml(config)}\n`, existingMode !== undefined ? { mode: existingMode } : {});
+        renameSync(tmp, path);
+    }
+    finally {
+        rmSync(tmp, { force: true });
+    }
+    return backupPath;
+}
+export async function connectCodexCommand(opts, deps = {}) {
+    const stdout = deps.stdout ?? ((t) => process.stdout.write(t));
+    const stderr = deps.stderr ?? ((t) => process.stderr.write(t));
+    const env = deps.env ?? process.env;
+    const path = codexConfigPath(deps.home, env);
+    const profile = await (deps.readProfile ?? readActiveProfile)();
+    let file;
+    try {
+        file = readCodexConfig(path);
+    }
+    catch (err) {
+        stderr(`${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    if (opts.off) {
+        const plan = planDisconnectCodex(file.config);
+        if (plan.removed.length === 0) {
+            stdout(`Nothing to disconnect in ${path}.\n`);
+            return 0;
+        }
+        const backup = writeCodexConfig(path, plan.config, file.raw);
+        stdout(`✓ Codex disconnected from YAGNI.\n  ${path}\n  Removed: ${plan.removed.join(", ")}\n`);
+        if (backup)
+            stdout(`  Comments in the original were preserved at ${backup}.\n`);
+        return 0;
+    }
+    const creds = credentialsFromProfile(profile);
+    if (!creds?.token) {
+        stderr(`Not logged in to environment "${profile.name}" (${profile.baseUrl}). Run \`${DISTRIBUTION.commandName} login\` first.\n`);
+        return 1;
+    }
+    const plan = planConnectCodex(file.config, {
+        baseUrl: profile.baseUrl,
+        commandName: DISTRIBUTION.commandName,
+    });
+    const backup = writeCodexConfig(path, plan.config, file.raw);
+    stdout(`✓ Codex connected to YAGNI (${profile.name} → ${profile.baseUrl}).\n`);
+    stdout(`  ${path}\n`);
+    for (const change of plan.changes)
+        stdout(`    ${change}\n`);
+    for (const key of plan.replaced) {
+        stdout(`  Replaced an existing ${key}. \`connect codex --off\` removes YAGNI's value but cannot restore the old one.\n`);
+    }
+    if (backup) {
+        stdout(`  Your config had comments, which a rewrite cannot keep. The original is at ${backup}.\n`);
+    }
+    stdout(`  Restart Codex to pick this up. It runs \`${DISTRIBUTION.commandName} token\` for credentials and serves the "${CODEX_DEFAULT_TIER}" tier; edit \`model\` to any YAGNI tier to change that.\n`);
+    return 0;
+}
+//# sourceMappingURL=connectCodex.js.map

package/dist/extension/execPolicy.d.ts

@@ -35,7 +35,18 @@
  * bundler), and external dependencies aren't resolvable from the bundled path.
  */
 export type TokenEntry = string | {
-    op: "pipe" | "and" | "or" | "semi" | "redirect" | "substitution";
+    op: "pipe" | "and" | "or" | "semi" | "substitution";
+} | {
+    op: "redirect";
+    direction: "out";
+    fd: "stdout" | "stderr";
+    target: string;
+    append: boolean;
+} | {
+    op: "redirect";
+    direction: "in";
+} | {
+    op: "background";
 };
 /**
  * Parse a shell command string into tokens and control operators.
@@ -48,6 +59,11 @@ export type TokenEntry = string | {
  * - `#` comments (start-of-word to end-of-line, outside quotes)
  * - Shell constructs we flag as unanalyzable: $(), backticks (INCLUDING
  *   inside double quotes — bash executes those), >, <, background &
+ * - Redirect metadata: stdout/stderr redirects carry fd + target so that
+ *   safe redirects (2>/dev/null, 2>&1) can be distinguished from unsafe ones
+ *   (> file.txt). Stdin redirects (<, <<) carry no metadata — they always
+ *   floor. Background & emits a distinct `background` op (not `semi`) so
+ *   hasUnhandledConstructs can always catch it.
  *
  * Does NOT handle: variable expansion, glob patterns, heredocs beyond the
  * redirect flag, nested subshells beyond depth tracking. Commands using

package/dist/extension/execPolicy.js

@@ -45,6 +45,11 @@
  * - `#` comments (start-of-word to end-of-line, outside quotes)
  * - Shell constructs we flag as unanalyzable: $(), backticks (INCLUDING
  *   inside double quotes — bash executes those), >, <, background &
+ * - Redirect metadata: stdout/stderr redirects carry fd + target so that
+ *   safe redirects (2>/dev/null, 2>&1) can be distinguished from unsafe ones
+ *   (> file.txt). Stdin redirects (<, <<) carry no metadata — they always
+ *   floor. Background & emits a distinct `background` op (not `semi`) so
+ *   hasUnhandledConstructs can always catch it.
  *
  * Does NOT handle: variable expansion, glob patterns, heredocs beyond the
  * redirect flag, nested subshells beyond depth tracking. Commands using
@@ -149,11 +154,13 @@ export function shellParse(command) {
                     i += 2;
                 }
                 else {
-                    // Single & — background operator. A construct (floor: prompt), but
-                    // the command before it must still be rule-matched: `rm -rf / &`
-                    // has to stay forbidden, so emit a separator rather than gluing.
+                    // Single & — background operator. Emits a distinct `background` op
+                    // (not `semi`) so hasUnhandledConstructs can always catch it and
+                    // floor the command. The command before it must still be rule-
+                    // matched: `rm -rf / &` has to stay forbidden, so emit a separator
+                    // rather than gluing.
                     pushCurrent();
-                    tokens.push({ op: "semi" });
+                    tokens.push({ op: "background" });
                     hasConstruct = true;
                     i++;
                 }
@@ -163,18 +170,124 @@ export function shellParse(command) {
                 tokens.push({ op: "semi" });
                 i++;
                 continue;
-            case ">":
-            case "<":
+            case ">": {
                 pushCurrent();
-                tokens.push({ op: "redirect" });
+                // Check for a preceding fd digit: `2>` → stderr, `1>` → stdout.
+                // The digit was emitted as a string token — pop it and use as fd.
+                let fd = "stdout";
+                if (tokens.length > 0 && typeof tokens[tokens.length - 1] === "string") {
+                    const last = tokens[tokens.length - 1];
+                    if (last === "2") {
+                        fd = "stderr";
+                        tokens.pop();
+                    }
+                    else if (last === "1") {
+                        fd = "stdout";
+                        tokens.pop();
+                    }
+                }
+                let append = false;
+                i++;
+                if (command[i] === ">") {
+                    append = true;
+                    i++;
+                }
+                while (command[i] === " " || command[i] === "\t")
+                    i++;
+                // Read the target — handles quoted targets (mirrors the main loop's
+                // quote logic), fd merges (&N), and bare words.
+                let target = "";
+                if (command[i] === "&") {
+                    // fd merge: &1, &2, etc.
+                    i++;
+                    let digits = "";
+                    while (command[i] >= "0" && command[i] <= "9") {
+                        digits += command[i];
+                        i++;
+                    }
+                    target = "&" + digits;
+                }
+                else if (command[i] === "'") {
+                    i++;
+                    while (i < command.length && command[i] !== "'") {
+                        target += command[i];
+                        i++;
+                    }
+                    if (i < command.length)
+                        i++;
+                }
+                else if (command[i] === '"') {
+                    i++;
+                    while (i < command.length && command[i] !== '"') {
+                        if (command[i] === "\\" && i + 1 < command.length) {
+                            target += command[i + 1];
+                            i += 2;
+                        }
+                        else {
+                            target += command[i];
+                            i++;
+                        }
+                    }
+                    if (i < command.length)
+                        i++;
+                }
+                else {
+                    while (i < command.length &&
+                        command[i] !== " " && command[i] !== "\t" &&
+                        command[i] !== "\n" && command[i] !== "\r" &&
+                        command[i] !== "|" && command[i] !== "&" &&
+                        command[i] !== ";" && command[i] !== ">" &&
+                        command[i] !== "<") {
+                        target += command[i];
+                        i++;
+                    }
+                }
+                tokens.push({ op: "redirect", direction: "out", fd, target, append });
                 hasConstruct = true;
-                // Skip the operator char(s) and any following space
+                continue;
+            }
+            case "<": {
+                pushCurrent();
+                // Stdin redirect — always floors (changes program behavior).
                 i++;
-                if (command[i] === ch)
-                    i++; // >> or <<
+                if (command[i] === "<")
+                    i++; // << heredoc — skip delimiter
                 while (command[i] === " " || command[i] === "\t")
                     i++;
+                // Consume the target (filename or heredoc delimiter) so it doesn't
+                // appear as a segment token — mirrors the > case's target reading.
+                if (command[i] === "'") {
+                    i++;
+                    while (i < command.length && command[i] !== "'")
+                        i++;
+                    if (i < command.length)
+                        i++;
+                }
+                else if (command[i] === '"') {
+                    i++;
+                    while (i < command.length && command[i] !== '"') {
+                        if (command[i] === "\\" && i + 1 < command.length)
+                            i += 2;
+                        else
+                            i++;
+                    }
+                    if (i < command.length)
+                        i++;
+                }
+                else {
+                    while (i < command.length &&
+                        command[i] !== " " && command[i] !== "\t" &&
+                        command[i] !== "\n" && command[i] !== "\r" &&
+                        command[i] !== "|" && command[i] !== "&" &&
+                        command[i] !== ";" && command[i] !== ">" &&
+                        command[i] !== "<") {
+                        i++;
+                    }
+                }
+                tokens.push({ op: "redirect", direction: "in" });
+                hasConstruct = true;
                 continue;
+            }
             case "$":
                 if (command[i + 1] === "(") {
                     pushCurrent();
@@ -213,9 +326,10 @@ export function shellParse(command) {
     }
     pushCurrent();
     // If we detected constructs but didn't emit them as operator tokens
-    // (e.g. background & or double-quoted substitution), surface that via a
-    // trailing substitution token so hasUnhandledConstructs sees it.
-    if (hasConstruct && !tokens.some((t) => typeof t === "object" && (t.op === "redirect" || t.op === "substitution"))) {
+    // (e.g. double-quoted substitution), surface that via a trailing
+    // substitution token so hasUnhandledConstructs sees it. Background & now
+    // emits its own distinct op, so it no longer relies on this fallback.
+    if (hasConstruct && !tokens.some((t) => typeof t === "object" && (t.op === "redirect" || t.op === "substitution" || t.op === "background"))) {
         tokens.push({ op: "substitution" });
     }
     return tokens;
@@ -294,47 +408,58 @@ const ENV_ASSIGNMENT_RE = /^[A-Za-z_][A-Za-z0-9_]*=/;
 export function tokenize(command) {
     return shellParse(command).filter((t) => typeof t === "string");
 }
-/** Operator tokens we can safely split on (compound command segments). */
-const SPLIT_OPS = new Set(["pipe", "and", "or", "semi"]);
+/** Ops that split compound commands into segments (pipe, &&, ||, ;, background &). */
+const SPLIT_OPS = new Set(["pipe", "and", "or", "semi", "background"]);
+/** Ops that are safe splittable separators — they do NOT trigger the construct floor.
+ * Background & is in SPLIT_OPS (splits segments) but NOT here (always floors). */
+const SAFE_SPLIT_OPS = new Set(["pipe", "and", "or", "semi"]);
+/** A redirect to /dev/null (discard) or &N (fd merge) is safe — no file created. */
+function isSafeRedirect(t) {
+    if (typeof t === "string")
+        return false;
+    if (t.op !== "redirect")
+        return false;
+    if (t.direction === "in")
+        return false; // stdin redirect — always floor
+    if (t.target === "/dev/null")
+        return true; // discard stderr/stdout — safe
+    if (t.target.startsWith("&") && t.target.length > 1)
+        return true; // fd merge (2>&1, 1>&2) — safe; bare "&" (>& with no digit) is NOT safe
+    return false; // > file.txt, >> file.txt — unsafe
+}
 /**
  * Detect whether the command uses shell constructs we can't statically
- * classify (command substitution, redirects, background &) — anything that
- * is NOT a splittable operator. These impose a floor of `prompt`: a command
- * carrying them is never auto-allowed, but forbidden matches still win.
+ * classify (command substitution, unsafe redirects, background &) — anything
+ * that is NOT a safe splittable operator or a safe redirect. These impose a
+ * floor of `prompt`: a command carrying them is never auto-allowed, but
+ * forbidden matches still win.
  */
 function hasUnhandledConstructs(command) {
-    return shellParse(command).some((t) => typeof t === "object" && "op" in t && !SPLIT_OPS.has(t.op));
+    return shellParse(command).some((t) => typeof t === "object" && !SAFE_SPLIT_OPS.has(t.op) && !isSafeRedirect(t));
 }
 /**
  * Split a command into token-array segments at control operators (|, &&, ||,
- * ;, newline). Redirect targets (the token after > or <) are dropped from the
- * segment — they are filenames, not arguments to rule-match. Token arrays are
- * carried through (never re-joined into strings) so quoting survives.
+ * ;, newline, background &). Redirect targets are consumed inside the
+ * tokenizer's > / < cases (stored on the redirect op), so no skipNext logic
+ * is needed. Token arrays are carried through (never re-joined into strings)
+ * so quoting survives.
  */
 function splitSegmentsTokens(command) {
     const parsed = shellParse(command);
     const segments = [];
     let current = [];
-    let skipNext = false;
     for (const t of parsed) {
         if (typeof t === "object") {
             if (SPLIT_OPS.has(t.op)) {
                 if (current.length > 0)
                     segments.push(current);
                 current = [];
-                skipNext = false;
-            }
-            else if (t.op === "redirect") {
-                skipNext = true;
             }
-            // substitution ops are construct markers; the inner text is handled
-            // by dangerScan via extractSubstitutions.
+            // redirect and substitution ops are construct markers; their targets
+            // are consumed inside the tokenizer, and the inner text of $(...) is
+            // handled by dangerScan via extractSubstitutions.
         }
         else {
-            if (skipNext) {
-                skipNext = false;
-                continue;
-            }
             current.push(t);
         }
     }
@@ -510,6 +635,9 @@ function classifySegmentTokens(rawTokens, policy, opts) {
             const tailResult = classifySegmentTokens(tail, policy, { ...opts, depth: opts.depth + 1 });
             if (tailResult.decision === "forbidden")
                 return tailResult;
+            if (tailResult.decision === "allow" && !neverAllow) {
+                return { decision: "allow", justification: "xargs forwards to a read-only command" };
+            }
         }
         if (opts.forbiddenOnly)
             return { decision: "allow", justification: "no forbidden match" };
@@ -727,6 +855,7 @@ export const DEFAULT_EXEC_POLICY = {
         { pattern: ["jq"], decision: "allow", justification: "filter JSON to stdout" },
         { pattern: ["stat"], decision: "allow", justification: "show file metadata" },
         { pattern: ["file"], decision: "allow", justification: "identify file type" },
+        { pattern: ["strings"], decision: "allow", justification: "extract printable strings from binary files (read-only)" },
         { pattern: ["basename"], decision: "allow", justification: "strip directory from path" },
         { pattern: ["dirname"], decision: "allow", justification: "extract directory from path" },
         { pattern: ["realpath"], decision: "allow", justification: "resolve a path" },
@@ -760,7 +889,9 @@ export const DEFAULT_EXEC_POLICY = {
         { pattern: ["node", "--version"], decision: "allow", justification: "check node version" },
         { pattern: ["node", "-v"], decision: "allow", justification: "check node version" },
         { pattern: ["npm", "ls"], decision: "allow", justification: "list installed packages" },
+        { pattern: ["npm", "list"], decision: "allow", justification: "list installed packages" },
         { pattern: ["pnpm", "ls"], decision: "allow", justification: "list installed packages" },
+        { pattern: ["pnpm", "list"], decision: "allow", justification: "list installed packages" },
         { pattern: ["pnpm", "--version"], decision: "allow", justification: "check pnpm version" },
         { pattern: ["tsc", "--version"], decision: "allow", justification: "check typescript version" },
         // --- prompt: potentially destructive but context-dependent ---

package/dist/extension/guardian.js

@@ -29,7 +29,7 @@
  */
 import { runStage as defaultRunStage } from "./pipeline/runner.js";
 export const DEFAULT_GUARDIAN_LIMITS = {
-    maxReviews: 30,
+    maxReviews: 120,
     maxConsecutiveDenials: 3,
     timeoutMs: 15_000,
 };

package/dist/login.d.ts

@@ -34,8 +34,10 @@ type OpenRunner = (cmd: string, args: string[]) => Promise<void>;
  *
  *   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)
+ *   Windows: rundll32 url.dll,FileProtocolHandler <url>   (opens the default
+ *            browser without going through cmd.exe — `cmd /c start <url>`
+ *            re-parses its arguments as a shell line, so a hostile URL with
+ *            `&`/`^` metacharacters could execute commands)
  */
 export declare function resolveOpenCommand(url: string, platform?: NodeJS.Platform): {
     cmd: string;

package/dist/login.js

@@ -31,14 +31,17 @@ function isTimeoutError(err) {
  *
  *   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)
+ *   Windows: rundll32 url.dll,FileProtocolHandler <url>   (opens the default
+ *            browser without going through cmd.exe — `cmd /c start <url>`
+ *            re-parses its arguments as a shell line, so a hostile URL with
+ *            `&`/`^` metacharacters could execute commands)
  */
 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] };
+    if (platform === "win32") {
+        return { cmd: "rundll32", args: ["url.dll,FileProtocolHandler", url] };
+    }
     return { cmd: "xdg-open", args: [url] };
 }
 const spawnRunner = (cmd, args) => new Promise((resolve, reject) => {
@@ -50,6 +53,18 @@ const spawnRunner = (cmd, args) => new Promise((resolve, reject) => {
  * URL is still printed for manual copy. `runner` is injectable for tests.
  */
 export const realOpenUrl = (url, runner = spawnRunner) => {
+    // Only ever hand http(s) URLs to the OS opener — refuse file:, javascript:,
+    // or custom schemes a compromised server response could try to smuggle in.
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return Promise.resolve();
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        return Promise.resolve();
+    }
     const { cmd, args } = resolveOpenCommand(url);
     return runner(cmd, args).catch(() => {
         // Silently fail — the user can still copy the URL manually.

package/dist/token.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `yagni token` — print the active environment's API token to stdout.
+ *
+ * This is the credential feed for `yagni connect claude-code`: Claude Code's
+ * `apiKeyHelper` runs this command (re-running on 401 and on a TTL), so the
+ * contract is strict — stdout carries the TOKEN AND NOTHING ELSE (Claude Code
+ * v2.1.227+ rejects helpers that print banners), and every notice goes to
+ * stderr. Riding the same refresh-at-launch client as the launcher means a
+ * token that enters the 7-day rotation window is rotated and persisted here
+ * too, so a Claude Code session keeps working without the user ever running
+ * `yagni` itself.
+ */
+import { maybeRefreshAtLaunch } from "./refresh.js";
+import type { Credentials } from "./credentials.js";
+import { type Profile } from "./profiles.js";
+export interface TokenCommandDeps {
+    readProfile?: () => Promise<Profile>;
+    refresh?: typeof maybeRefreshAtLaunch;
+    persist?: (name: string, creds: Credentials) => Promise<void>;
+    now?: () => number;
+    stdout?: (text: string) => void;
+    stderr?: (text: string) => void;
+}
+export declare function tokenCommand(deps?: TokenCommandDeps): Promise<number>;
+//# sourceMappingURL=token.d.ts.map

package/dist/token.js

@@ -0,0 +1,45 @@
+/**
+ * `yagni token` — print the active environment's API token to stdout.
+ *
+ * This is the credential feed for `yagni connect claude-code`: Claude Code's
+ * `apiKeyHelper` runs this command (re-running on 401 and on a TTL), so the
+ * contract is strict — stdout carries the TOKEN AND NOTHING ELSE (Claude Code
+ * v2.1.227+ rejects helpers that print banners), and every notice goes to
+ * stderr. Riding the same refresh-at-launch client as the launcher means a
+ * token that enters the 7-day rotation window is rotated and persisted here
+ * too, so a Claude Code session keeps working without the user ever running
+ * `yagni` itself.
+ */
+import { classifyTokenExpiry } from "./launch.js";
+import { maybeRefreshAtLaunch } from "./refresh.js";
+import { credentialsFromProfile, persistProfileTokenRotation, readActiveProfile, } from "./profiles.js";
+export async function tokenCommand(deps = {}) {
+    const readProfile = deps.readProfile ?? readActiveProfile;
+    const refresh = deps.refresh ?? maybeRefreshAtLaunch;
+    const persist = deps.persist ?? persistProfileTokenRotation;
+    const stdout = deps.stdout ?? ((t) => process.stdout.write(t));
+    const stderr = deps.stderr ?? ((t) => process.stderr.write(t));
+    const profile = await readProfile();
+    let creds = credentialsFromProfile(profile);
+    if (!creds?.token) {
+        stderr(`Not logged in to environment "${profile.name}" (${profile.baseUrl}). Run \`yagni login\` first.\n`);
+        return 1;
+    }
+    const outcome = await refresh(creds, {
+        persist: (c) => persist(profile.name, c),
+        ...(deps.now ? { now: deps.now } : {}),
+    });
+    for (const warning of outcome.warnings)
+        stderr(`${warning}\n`);
+    creds = outcome.creds;
+    // An expired token would send the consumer into a silent 401 loop — fail
+    // loudly instead so Claude Code surfaces a helper error the user can act on.
+    const nowMs = deps.now ? deps.now() : Date.now();
+    if (classifyTokenExpiry(creds.expiresAt, nowMs).kind === "expired") {
+        stderr("Your YAGNI Code session has expired. Run `yagni login` to re-authenticate.\n");
+        return 1;
+    }
+    stdout(`${creds.token}\n`);
+    return 0;
+}
+//# sourceMappingURL=token.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "0.3.0-staging.1091.1",
+  "version": "0.3.0-staging.1096.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -36,7 +36,8 @@
   "dependencies": {
     "@earendil-works/pi-coding-agent": "0.84.1",
     "@earendil-works/pi-tui": "0.84.1",
+    "smol-toml": "^1.8.0",
     "typebox": "^1.3.11"
   },
-  "yagniSourceSha": "50ccbb69838d6ee20a0b0d7a7b7259105158f215"
+  "yagniSourceSha": "04ba3799e7c6310f337b80067ba44ee257d69df3"
 }