@alphafox/cli 0.1.5 → 0.3.2

package/dist/install/package-root.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findAlphafoxPackageRoot = findAlphafoxPackageRoot;
+exports.packageHasSkills = packageHasSkills;
+exports.globalPackageRoot = globalPackageRoot;
+exports.globalBinPath = globalBinPath;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const version_1 = require("../version");
+function findAlphafoxPackageRoot(startDirs) {
+    for (const start of startDirs) {
+        const found = walkForPackage(start);
+        if (found)
+            return found;
+    }
+    return null;
+}
+function packageHasSkills(packageRoot) {
+    const skillsDir = (0, node_path_1.join)(packageRoot, "skills");
+    if (!(0, node_fs_1.existsSync)(skillsDir))
+        return false;
+    try {
+        return (0, node_fs_1.readdirSync)(skillsDir, { withFileTypes: true }).some((entry) => entry.isDirectory() &&
+            (0, node_fs_1.existsSync)((0, node_path_1.join)(skillsDir, entry.name, "SKILL.md")));
+    }
+    catch {
+        return false;
+    }
+}
+function globalPackageRoot(npmRootGlobal) {
+    return (0, node_path_1.join)(npmRootGlobal, "@alphafox", "cli");
+}
+function globalBinPath(npmPrefixGlobal, platform = process.platform) {
+    if (platform === "win32") {
+        return (0, node_path_1.join)(npmPrefixGlobal, "alphafox.cmd");
+    }
+    return (0, node_path_1.join)(npmPrefixGlobal, "bin", "alphafox");
+}
+function walkForPackage(startDir) {
+    let dir = startDir;
+    for (let i = 0; i < 10; i += 1) {
+        const pkgPath = (0, node_path_1.join)(dir, "package.json");
+        if ((0, node_fs_1.existsSync)(pkgPath) && packageHasSkills(dir)) {
+            try {
+                const parsed = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, "utf8"));
+                if (parsed.name === version_1.CLI_PACKAGE)
+                    return dir;
+            }
+            catch {
+                // keep walking
+            }
+        }
+        const parent = (0, node_path_1.dirname)(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}

package/dist/install/types.d.ts

@@ -0,0 +1,69 @@
+export declare const SKILLS_GITHUB_SOURCE = "alphafoxai/alphafox-cli";
+export declare const SKILLS_NAME_PREFIX = "alphafox-";
+export declare const AGENT_INSTALL_GUIDE_URL = "https://raw.githubusercontent.com/alphafoxai/alphafox-cli/main/docs/alphafox-cli-installation-guide.md";
+export declare const AGENT_INSTALL_GUIDE_BLOB_URL = "https://github.com/alphafoxai/alphafox-cli/blob/main/docs/alphafox-cli-installation-guide.md";
+export type InstallCliAction = "installed" | "upgraded" | "skipped" | "planned";
+export type InstallSkillsAction = "installed" | "skipped" | "planned" | "failed";
+export type InstallAuthAction = "completed" | "skipped" | "failed" | "planned";
+export interface InstallCliStep {
+    readonly action: InstallCliAction;
+    readonly version?: string;
+    readonly previousVersion?: string;
+    readonly latestVersion?: string;
+}
+export interface InstallSkillsStep {
+    readonly action: InstallSkillsAction;
+    readonly source?: string;
+    readonly scope: "global";
+    readonly alreadyPresent?: boolean;
+}
+export interface InstallAuthStep {
+    readonly action: InstallAuthAction;
+    readonly reason?: string;
+}
+export interface InstallResult {
+    readonly cli: InstallCliStep;
+    readonly skills: InstallSkillsStep;
+    readonly auth: InstallAuthStep;
+    readonly next: readonly string[];
+}
+export interface InstallFlags {
+    readonly format: "json" | "jsonl" | "text";
+    readonly yes: boolean;
+    readonly dryRun: boolean;
+    readonly noInput: boolean;
+    readonly jq?: string;
+    readonly noAuth: boolean;
+    readonly help: boolean;
+}
+export interface ExecResult {
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface InstallRunner {
+    readonly exec: (command: string, args: readonly string[], options?: {
+        readonly timeoutMs?: number;
+    }) => Promise<ExecResult>;
+    readonly execInherit: (command: string, args: readonly string[], options?: {
+        readonly timeoutMs?: number;
+    }) => Promise<void>;
+    readonly isTty: () => boolean;
+    readonly confirm: (message: string) => Promise<boolean>;
+    readonly log: (message: string) => void;
+    readonly packageSearchDirs: () => readonly string[];
+    readonly env: NodeJS.ProcessEnv;
+}
+export declare class InstallError extends Error {
+    readonly type: string;
+    readonly subtype?: string;
+    readonly hint?: string;
+    readonly details?: unknown;
+    constructor(input: {
+        readonly message: string;
+        readonly type?: string;
+        readonly subtype?: string;
+        readonly hint?: string;
+        readonly details?: unknown;
+    });
+}
+export declare function isInstallError(value: unknown): value is InstallError;

package/dist/install/types.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstallError = exports.AGENT_INSTALL_GUIDE_BLOB_URL = exports.AGENT_INSTALL_GUIDE_URL = exports.SKILLS_NAME_PREFIX = exports.SKILLS_GITHUB_SOURCE = void 0;
+exports.isInstallError = isInstallError;
+exports.SKILLS_GITHUB_SOURCE = "alphafoxai/alphafox-cli";
+exports.SKILLS_NAME_PREFIX = "alphafox-";
+exports.AGENT_INSTALL_GUIDE_URL = "https://raw.githubusercontent.com/alphafoxai/alphafox-cli/main/docs/alphafox-cli-installation-guide.md";
+exports.AGENT_INSTALL_GUIDE_BLOB_URL = "https://github.com/alphafoxai/alphafox-cli/blob/main/docs/alphafox-cli-installation-guide.md";
+class InstallError extends Error {
+    type;
+    subtype;
+    hint;
+    details;
+    constructor(input) {
+        super(input.message);
+        this.name = "InstallError";
+        this.type = input.type ?? "runtime";
+        this.subtype = input.subtype;
+        this.hint = input.hint;
+        this.details = input.details;
+    }
+}
+exports.InstallError = InstallError;
+function isInstallError(value) {
+    return value instanceof InstallError;
+}

package/dist/install/wizard.d.ts

@@ -0,0 +1,21 @@
+import { type InstallAuthStep, type InstallFlags, type InstallResult, type InstallRunner } from "./types";
+export declare function parseInstallArgs(args: readonly string[]): {
+    readonly noAuth: boolean;
+    readonly help: boolean;
+    readonly unknown: readonly string[];
+};
+export declare function semverLessThan(a: string, b: string): boolean;
+export declare function parseNpmListVersion(output: string): string | null;
+export declare function skillsListHasAlphafox(output: string): boolean;
+export declare function nextSteps(input: {
+    readonly auth: InstallAuthStep;
+    readonly dryRun: boolean;
+}): string[];
+export declare function runInstallWizard(flags: InstallFlags, env?: NodeJS.ProcessEnv, runner?: InstallRunner): Promise<InstallResult>;
+export declare function installHelpData(): {
+    readonly name: string;
+    readonly usage: readonly string[];
+    readonly description: string;
+    readonly agentGuide: string;
+};
+export declare function resolveLocalSkillsDir(searchDirs: readonly string[]): string | null;

package/dist/install/wizard.js

@@ -0,0 +1,332 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInstallArgs = parseInstallArgs;
+exports.semverLessThan = semverLessThan;
+exports.parseNpmListVersion = parseNpmListVersion;
+exports.skillsListHasAlphafox = skillsListHasAlphafox;
+exports.nextSteps = nextSteps;
+exports.runInstallWizard = runInstallWizard;
+exports.installHelpData = installHelpData;
+exports.resolveLocalSkillsDir = resolveLocalSkillsDir;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const version_1 = require("../version");
+const exec_1 = require("./exec");
+const package_root_1 = require("./package-root");
+const types_1 = require("./types");
+const NPM_TIMEOUT_MS = 120_000;
+const SKILLS_TIMEOUT_MS = 120_000;
+function parseInstallArgs(args) {
+    let noAuth = false;
+    let help = false;
+    const unknown = [];
+    for (const arg of args) {
+        if (arg === "--no-auth") {
+            noAuth = true;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            help = true;
+        }
+        else {
+            unknown.push(arg);
+        }
+    }
+    return { noAuth, help, unknown };
+}
+function semverLessThan(a, b) {
+    const pa = stripPrerelease(a).split(".").map((part) => Number(part) || 0);
+    const pb = stripPrerelease(b).split(".").map((part) => Number(part) || 0);
+    for (let i = 0; i < 3; i += 1) {
+        if ((pa[i] ?? 0) < (pb[i] ?? 0))
+            return true;
+        if ((pa[i] ?? 0) > (pb[i] ?? 0))
+            return false;
+    }
+    return false;
+}
+function parseNpmListVersion(output) {
+    const match = output.match(/@(\d+\.\d+\.\d+[^\s]*)/);
+    return match?.[1] ?? null;
+}
+function skillsListHasAlphafox(output) {
+    const prefix = types_1.SKILLS_NAME_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(^|\\s)${prefix}[\\w-]+`, "m").test(output);
+}
+function nextSteps(input) {
+    const steps = [
+        "Restart the AI tool so newly installed Skills are loaded.",
+    ];
+    if (input.auth.action === "skipped" || input.auth.action === "planned") {
+        steps.push("alphafox auth login --browser --format json --no-input", "alphafox auth login --no-wait --format json --no-input");
+    }
+    steps.push("alphafox doctor --format json --no-input", `Agent install guide: ${types_1.AGENT_INSTALL_GUIDE_BLOB_URL}`);
+    if (input.dryRun) {
+        steps.unshift("This was --dry-run; re-run without it to apply changes.");
+    }
+    return steps;
+}
+async function runInstallWizard(flags, env = process.env, runner = (0, exec_1.createDefaultInstallRunner)(env, defaultSearchDirs())) {
+    runner.log("Setting up Alphafox CLI...");
+    const installedVer = await readGloballyInstalledVersion(runner);
+    const latestVer = await readLatestVersion(runner);
+    const needsUpgrade = Boolean(installedVer) &&
+        Boolean(latestVer) &&
+        semverLessThan(installedVer, latestVer);
+    const cli = await stepInstallCli(flags, runner, {
+        installedVer,
+        latestVer,
+        needsUpgrade,
+    });
+    const skills = await stepInstallSkills(flags, runner);
+    const auth = await stepAuth(flags, runner);
+    return {
+        cli,
+        skills,
+        auth,
+        next: nextSteps({ auth, dryRun: flags.dryRun }),
+    };
+}
+function defaultSearchDirs() {
+    return [__dirname, process.cwd()];
+}
+function stripPrerelease(version) {
+    return version.replace(/-.*$/, "");
+}
+async function readGloballyInstalledVersion(runner) {
+    try {
+        const { stdout, stderr } = await runner.exec("npm", ["list", "-g", version_1.CLI_PACKAGE, "--depth=0"], { timeoutMs: 15_000 });
+        return parseNpmListVersion(`${stdout}\n${stderr}`);
+    }
+    catch {
+        return null;
+    }
+}
+async function readLatestVersion(runner) {
+    try {
+        const { stdout } = await runner.exec("npm", ["view", version_1.CLI_PACKAGE, "version"], {
+            timeoutMs: 15_000,
+        });
+        const ver = stdout.trim();
+        return /^\d+\.\d+\.\d+/.test(ver) ? ver : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function npmRootGlobal(runner) {
+    try {
+        const { stdout } = await runner.exec("npm", ["root", "-g"], {
+            timeoutMs: 15_000,
+        });
+        const root = stdout.trim();
+        return root.length > 0 ? root : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function npmPrefixGlobal(runner) {
+    try {
+        const { stdout } = await runner.exec("npm", ["prefix", "-g"], {
+            timeoutMs: 15_000,
+        });
+        const prefix = stdout.trim();
+        return prefix.length > 0 ? prefix : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function stepInstallCli(flags, runner, versions) {
+    const { installedVer, latestVer, needsUpgrade } = versions;
+    if (installedVer && !needsUpgrade) {
+        runner.log(`Already installed (${installedVer}). Skipped`);
+        return {
+            action: flags.dryRun ? "planned" : "skipped",
+            version: installedVer,
+            latestVersion: latestVer ?? undefined,
+        };
+    }
+    if (flags.dryRun) {
+        runner.log(needsUpgrade
+            ? `Would upgrade ${version_1.CLI_PACKAGE} (${installedVer} → ${latestVer ?? "latest"})`
+            : `Would install ${version_1.CLI_PACKAGE} globally`);
+        return {
+            action: "planned",
+            previousVersion: installedVer ?? undefined,
+            latestVersion: latestVer ?? undefined,
+        };
+    }
+    runner.log(needsUpgrade
+        ? `Upgrading ${version_1.CLI_PACKAGE} (${installedVer} → ${latestVer})...`
+        : `Installing ${version_1.CLI_PACKAGE} globally...`);
+    try {
+        await runner.exec("npm", ["install", "-g", version_1.CLI_PACKAGE], {
+            timeoutMs: NPM_TIMEOUT_MS,
+        });
+    }
+    catch (err) {
+        throw new types_1.InstallError({
+            type: "install",
+            subtype: "npm_global_failed",
+            message: `Failed to install ${version_1.CLI_PACKAGE} globally.`,
+            hint: `npm install -g ${version_1.CLI_PACKAGE}`,
+            details: err instanceof Error ? err.message : String(err),
+        });
+    }
+    const after = (await readGloballyInstalledVersion(runner)) ?? latestVer ?? version_1.CLI_VERSION;
+    runner.log(needsUpgrade ? `Upgraded to ${after}` : "Installed globally");
+    return {
+        action: needsUpgrade ? "upgraded" : "installed",
+        version: after,
+        previousVersion: installedVer ?? undefined,
+        latestVersion: latestVer ?? undefined,
+    };
+}
+async function resolveSkillsSources(runner) {
+    const override = runner.env.ALPHAFOX_SKILLS_SOURCE?.trim();
+    if (override)
+        return [override];
+    const sources = [];
+    const npmRoot = await npmRootGlobal(runner);
+    if (npmRoot) {
+        const globalRoot = (0, package_root_1.globalPackageRoot)(npmRoot);
+        if ((0, package_root_1.packageHasSkills)(globalRoot))
+            sources.push(globalRoot);
+    }
+    const localRoot = (0, package_root_1.findAlphafoxPackageRoot)(runner.packageSearchDirs());
+    if (localRoot && !sources.includes(localRoot) && (0, package_root_1.packageHasSkills)(localRoot)) {
+        sources.push(localRoot);
+    }
+    sources.push(types_1.SKILLS_GITHUB_SOURCE);
+    return sources;
+}
+async function skillsAlreadyInstalled(runner) {
+    try {
+        const { stdout, stderr } = await runner.exec("npx", ["-y", "skills", "ls", "-g"], { timeoutMs: SKILLS_TIMEOUT_MS });
+        return skillsListHasAlphafox(`${stdout}\n${stderr}`);
+    }
+    catch {
+        return false;
+    }
+}
+async function stepInstallSkills(flags, runner) {
+    const sources = await resolveSkillsSources(runner);
+    const already = flags.dryRun ? false : await skillsAlreadyInstalled(runner);
+    if (already) {
+        runner.log("Skills already installed. Skipped");
+        return {
+            action: "skipped",
+            source: sources[0],
+            scope: "global",
+            alreadyPresent: true,
+        };
+    }
+    if (flags.dryRun) {
+        runner.log(`Would install Skills from ${sources[0] ?? types_1.SKILLS_GITHUB_SOURCE}`);
+        return {
+            action: "planned",
+            source: sources[0] ?? types_1.SKILLS_GITHUB_SOURCE,
+            scope: "global",
+        };
+    }
+    runner.log("Installing AI Skills...");
+    let lastError;
+    for (const source of sources) {
+        try {
+            await runner.exec("npx", ["-y", "skills", "add", source, "-y", "-g"], { timeoutMs: SKILLS_TIMEOUT_MS });
+            runner.log(`Skills installed (${source})`);
+            return { action: "installed", source, scope: "global" };
+        }
+        catch (err) {
+            lastError = err;
+        }
+    }
+    throw new types_1.InstallError({
+        type: "install",
+        subtype: "skills_add_failed",
+        message: "Failed to install Agent Skills.",
+        hint: `npx skills add ${types_1.SKILLS_GITHUB_SOURCE} -y -g`,
+        details: lastError instanceof Error ? lastError.message : String(lastError),
+    });
+}
+async function resolveAlphafoxBin(runner) {
+    const prefix = await npmPrefixGlobal(runner);
+    if (prefix) {
+        const bin = (0, package_root_1.globalBinPath)(prefix);
+        if ((0, node_fs_1.existsSync)(bin))
+            return bin;
+    }
+    try {
+        const { stdout } = await runner.exec(process.platform === "win32" ? "where" : "which", ["alphafox"], { timeoutMs: 10_000 });
+        const first = stdout.split(/\r?\n/)[0]?.trim();
+        return first || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function stepAuth(flags, runner) {
+    if (flags.noAuth) {
+        return { action: "skipped", reason: "no-auth" };
+    }
+    if (flags.noInput || !runner.isTty()) {
+        if (flags.dryRun) {
+            return { action: "planned", reason: "non-interactive" };
+        }
+        runner.log("To finish setup, run:\n  alphafox auth login --browser\n  alphafox auth login --no-wait --format json --no-input");
+        return { action: "skipped", reason: "non-interactive" };
+    }
+    if (flags.dryRun) {
+        runner.log("Would prompt for alphafox auth login --browser");
+        return { action: "planned", reason: "tty" };
+    }
+    const yes = await runner.confirm("Log in now so Agents can call the public Application API?");
+    if (!yes) {
+        runner.log("Skipped login. Run alphafox auth login later.");
+        return { action: "skipped", reason: "declined" };
+    }
+    const bin = await resolveAlphafoxBin(runner);
+    if (!bin) {
+        throw new types_1.InstallError({
+            type: "install",
+            subtype: "cli_bin_missing",
+            message: "alphafox binary not found after install.",
+            hint: "Ensure the npm global bin directory is on PATH, then run alphafox auth login --browser.",
+        });
+    }
+    try {
+        await runner.execInherit(bin, ["auth", "login", "--browser"], {
+            timeoutMs: 10 * 60_000,
+        });
+        runner.log("Login complete");
+        return { action: "completed" };
+    }
+    catch (err) {
+        runner.log("Login failed. Run alphafox auth login --browser to retry.");
+        return {
+            action: "failed",
+            reason: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function installHelpData() {
+    return {
+        name: "install",
+        usage: [
+            "npx @alphafox/cli@latest install",
+            "alphafox install",
+            "alphafox install --no-auth",
+            "alphafox install --dry-run",
+        ],
+        description: "Install @alphafox/cli globally and copy co-versioned Agent Skills into detected agents (Cursor, Claude Code, Codex, …) via npx skills add.",
+        agentGuide: types_1.AGENT_INSTALL_GUIDE_BLOB_URL,
+    };
+}
+function resolveLocalSkillsDir(searchDirs) {
+    const root = (0, package_root_1.findAlphafoxPackageRoot)(searchDirs);
+    if (!root)
+        return null;
+    const skillsDir = (0, node_path_1.join)(root, "skills");
+    return (0, package_root_1.packageHasSkills)(root) ? skillsDir : null;
+}

package/dist/keychain/linux-secret-service.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Linux Secret Service via `secret-tool` (libsecret).
+ * Tokens travel on stdin/stdout, never as argv.
+ */
+export declare const LINUX_SECRET_LABEL_PREFIX = "alphafox-cli";
+export declare function linuxSecretServiceArgs(action: "store" | "lookup" | "clear", service: string, account: string): readonly string[];
+export declare function linuxSecretToolBin(env?: NodeJS.ProcessEnv): string;
+export declare function linuxSecretServiceWrite(service: string, account: string, payload: string, env?: NodeJS.ProcessEnv): boolean;
+export declare function linuxSecretServiceRead(service: string, account: string, env?: NodeJS.ProcessEnv): string | null;
+export declare function linuxSecretServiceDelete(service: string, account: string, env?: NodeJS.ProcessEnv): void;
+export declare function linuxSecretServiceAvailable(env?: NodeJS.ProcessEnv): boolean;

package/dist/keychain/linux-secret-service.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Linux Secret Service via `secret-tool` (libsecret).
+ * Tokens travel on stdin/stdout, never as argv.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LINUX_SECRET_LABEL_PREFIX = void 0;
+exports.linuxSecretServiceArgs = linuxSecretServiceArgs;
+exports.linuxSecretToolBin = linuxSecretToolBin;
+exports.linuxSecretServiceWrite = linuxSecretServiceWrite;
+exports.linuxSecretServiceRead = linuxSecretServiceRead;
+exports.linuxSecretServiceDelete = linuxSecretServiceDelete;
+exports.linuxSecretServiceAvailable = linuxSecretServiceAvailable;
+const node_child_process_1 = require("node:child_process");
+exports.LINUX_SECRET_LABEL_PREFIX = "alphafox-cli";
+function linuxSecretServiceArgs(action, service, account) {
+    if (action === "store") {
+        return [
+            "store",
+            "--label",
+            `${exports.LINUX_SECRET_LABEL_PREFIX} ${service}`,
+            "service",
+            service,
+            "account",
+            account,
+        ];
+    }
+    if (action === "lookup") {
+        return ["lookup", "service", service, "account", account];
+    }
+    return ["clear", "service", service, "account", account];
+}
+function linuxSecretToolBin(env = process.env) {
+    return env.ALPHAFOX_SECRET_TOOL?.trim() || "secret-tool";
+}
+function childEnv(env) {
+    return { ...process.env, ...env };
+}
+function linuxSecretServiceWrite(service, account, payload, env = process.env) {
+    try {
+        (0, node_child_process_1.execFileSync)(linuxSecretToolBin(env), [...linuxSecretServiceArgs("store", service, account)], {
+            input: payload,
+            encoding: "utf8",
+            stdio: ["pipe", "ignore", "ignore"],
+            timeout: 10_000,
+            env: childEnv(env),
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function linuxSecretServiceRead(service, account, env = process.env) {
+    try {
+        const out = (0, node_child_process_1.execFileSync)(linuxSecretToolBin(env), [...linuxSecretServiceArgs("lookup", service, account)], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 10_000,
+            env: childEnv(env),
+        });
+        const text = out.replace(/\n$/, "");
+        return text.length > 0 ? text : null;
+    }
+    catch {
+        return null;
+    }
+}
+function linuxSecretServiceDelete(service, account, env = process.env) {
+    try {
+        (0, node_child_process_1.execFileSync)(linuxSecretToolBin(env), [...linuxSecretServiceArgs("clear", service, account)], {
+            stdio: "ignore",
+            timeout: 10_000,
+            env: childEnv(env),
+        });
+    }
+    catch {
+        // none
+    }
+}
+function linuxSecretServiceAvailable(env = process.env) {
+    try {
+        (0, node_child_process_1.execFileSync)(linuxSecretToolBin(env), ["--help"], {
+            stdio: "ignore",
+            timeout: 5_000,
+            env: childEnv(env),
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/keychain/store.d.ts

@@ -13,7 +13,26 @@ export interface StoredTokens {
     readonly clientId: string;
     readonly scopes: readonly string[];
 }
-export declare function saveTokens(profile: string, tokens: StoredTokens, env?: NodeJS.ProcessEnv): void;
+export type TokenStorageBackend = "keychain" | "file" | "test-injection";
+export type OsKeychainKind = "macos-security" | "linux-secret-service" | "windows-credential-manager" | "none";
+export interface TokenStorageResult {
+    readonly backend: TokenStorageBackend;
+    readonly kind?: OsKeychainKind;
+    /** Absolute path when backend is file. */
+    readonly path?: string;
+    /** True when OS keychain failed/unavailable and file fallback was used. */
+    readonly degraded: boolean;
+}
+export declare function getLastTokenSaveResult(): TokenStorageResult | null;
+export declare function keychainServiceName(profile: string): string;
+export declare function keychainAccountName(): string;
+/** Test-only override. Production code uses process.platform. */
+export declare function keychainPlatform(env?: NodeJS.ProcessEnv): NodeJS.Platform;
+export declare function probeOsKeychain(env?: NodeJS.ProcessEnv): {
+    readonly kind: OsKeychainKind;
+    readonly available: boolean;
+};
+export declare function saveTokens(profile: string, tokens: StoredTokens, env?: NodeJS.ProcessEnv): TokenStorageResult;
 export declare function loadTokens(profile: string, env?: NodeJS.ProcessEnv): StoredTokens | null;
 export declare function deleteTokens(profile: string, env?: NodeJS.ProcessEnv): void;
 export declare function tokenFingerprint(token: string): string;