@alphafox/cli 0.1.5 → 0.3.2

package/dist/engine-backtest/types.d.ts

@@ -0,0 +1,249 @@
+export type SubscriptionTier = "free" | "pro" | "pro_max";
+export type DataQualityMode = "strict" | "basic";
+export type PricePath = "ohlc_path_4" | "close_only";
+export interface ExecutionModel {
+    readonly pricePath: PricePath;
+    readonly makerFeeRate: number;
+    readonly takerFeeRate: number;
+    readonly slippageRate: number;
+}
+export interface InclusiveUtcDateRange {
+    readonly rangeStart: string;
+    readonly rangeEnd: string;
+    readonly fromMs: number;
+    readonly toMs: number;
+}
+export interface EngineBacktestRunArgs {
+    readonly help: boolean;
+    readonly experimentId?: string;
+    readonly createExperiment: boolean;
+    readonly name?: string;
+    readonly definitionId?: string;
+    readonly definitionLabelZh?: string;
+    readonly definitionLabelEn?: string;
+    readonly configRaw?: string;
+    readonly exchange?: string;
+    readonly range?: InclusiveUtcDateRange;
+    readonly initialEquity?: number;
+    /** Explicit --tier value. Persisted runs otherwise use the account tier. */
+    readonly tier?: SubscriptionTier;
+    readonly dataQualityMode: DataQualityMode;
+    readonly configSchemaVersion?: number;
+    readonly executionModelOverride?: Partial<ExecutionModel>;
+    readonly persist: boolean;
+    /** Replay/download bar. Defaults to 1m; never finer. */
+    readonly replayTimeframe: string;
+}
+export interface EngineBacktestSeriesRequirement {
+    readonly symbol: string;
+    readonly timeframe: string;
+    readonly minWarmupCandles: number;
+}
+export interface EngineBacktestTapeSeriesRef {
+    readonly symbol: string;
+    readonly timeframe: string;
+    readonly buffer: string;
+    readonly rows: number;
+}
+export interface EngineBacktestTapeInput {
+    readonly from: string;
+    readonly to: string;
+    readonly baseTimeframe: string;
+    readonly markets: Readonly<Record<string, unknown>>;
+    readonly series: readonly EngineBacktestTapeSeriesRef[];
+    readonly fundingRates?: Readonly<Record<string, readonly unknown[]>>;
+    readonly lowLiquiditySymbols?: readonly string[];
+}
+export interface EngineBacktestScenario {
+    readonly version: 1;
+    readonly runId: string;
+    readonly trader: {
+        readonly id?: string;
+        readonly name?: string;
+        readonly strategyDefinitionId: string;
+        readonly configSchemaVersion: number;
+        readonly subscriptionTier: SubscriptionTier;
+        readonly config: unknown;
+    };
+    readonly exchange: {
+        readonly positionSideDual: boolean;
+        readonly initialEquity: number;
+    };
+    readonly executionModel: ExecutionModel;
+    readonly tape: EngineBacktestTapeInput;
+}
+export interface EngineBacktestMetrics {
+    readonly initialEquity: number;
+    readonly finalEquity: number;
+    readonly netPnl: number;
+    readonly returnPct: number;
+    readonly maxDrawdownPct: number;
+    readonly sharpeRatio: number;
+    readonly orderCount: number;
+    readonly filledOrderCount: number;
+    readonly canceledOrderCount: number;
+    readonly tradeCount: number;
+    readonly winningTrades: number;
+    readonly losingTrades: number;
+    readonly winRatePct: number;
+    readonly feesPaid: number;
+    readonly slippagePaid: number;
+    readonly liquidated: boolean;
+}
+export interface EngineBacktestResult {
+    readonly runId: string;
+    readonly status: "completed" | "failed";
+    readonly engineVersion?: string;
+    readonly metrics: EngineBacktestMetrics;
+    readonly equityCurve?: unknown[];
+    readonly orders?: unknown[];
+    readonly openPositions?: unknown[];
+    readonly errors?: Array<{
+        code: string;
+        message: string;
+        path?: string;
+    }>;
+    readonly warnings?: string[];
+}
+export interface EngineBacktestSupportReason {
+    readonly code: string;
+    readonly message: string;
+}
+export interface EngineSupportedBacktestPlan {
+    readonly definitionId: string;
+    readonly configSchemaVersion: number;
+    readonly support: {
+        readonly status: "supported";
+    };
+    readonly effectiveConfig: Record<string, unknown>;
+    readonly universe: {
+        readonly kind: "fixed";
+        readonly symbols: string[];
+    };
+    readonly symbols: string[];
+    readonly timeframes: string[];
+    readonly seriesRequirements: EngineBacktestSeriesRequirement[];
+    readonly needsFunding: boolean;
+    readonly auxiliaryDataRequirements: Array<{
+        readonly kind: string;
+        readonly parameters?: Record<string, unknown>;
+    }>;
+    readonly configFingerprint: string;
+}
+export interface EngineUnsupportedBacktestPlan {
+    readonly definitionId: string;
+    readonly configSchemaVersion: number;
+    readonly support: {
+        readonly status: "unsupported";
+        readonly reason: EngineBacktestSupportReason;
+    };
+    readonly needsFunding: false;
+}
+export interface EngineBacktestFailure {
+    readonly status: "failed";
+    readonly errors: Array<{
+        readonly code: string;
+        readonly message: string;
+    }>;
+}
+export type EngineBacktestPlan = EngineSupportedBacktestPlan | EngineUnsupportedBacktestPlan;
+export interface TapeLoadProgress {
+    readonly stage: "markets" | "ohlcv" | "validation" | string;
+    readonly detail: string;
+    readonly fraction: number;
+}
+export interface TapeExchangeDefinition {
+    readonly id: string;
+    readonly label: string;
+    readonly ccxtId: string;
+    readonly marketType: string;
+    readonly quoteAsset: string;
+}
+export interface TapeLoadResult {
+    readonly tape: EngineBacktestTapeInput;
+    readonly buffers: Record<string, ArrayBuffer>;
+    readonly coverageWarnings: readonly string[];
+}
+export interface BacktestClientLike {
+    init(): Promise<string>;
+    version(): Promise<string>;
+    strategyDefinitions(): Promise<{
+        readonly engineVersion: string;
+        readonly definitions: Array<Record<string, unknown> & {
+            readonly id: string;
+            readonly configSchemaVersion?: number;
+        }>;
+    }>;
+    planBacktest(request: {
+        readonly definitionId: string;
+        readonly configSchemaVersion: number;
+        readonly config: unknown;
+    }): Promise<EngineBacktestPlan | EngineBacktestFailure>;
+    runBacktest(scenario: EngineBacktestScenario, buffers: Record<string, ArrayBuffer>, onProgress?: (fraction: number) => void): Promise<EngineBacktestResult>;
+    terminate(): void;
+}
+export interface BacktestWasmModule {
+    createNodeBacktestClient(options?: unknown): BacktestClientLike;
+}
+export interface BacktestRunnerModule {
+    loadTape(request: {
+        readonly exchangeId?: string;
+        readonly exchange?: TapeExchangeDefinition;
+        readonly symbols: readonly string[];
+        readonly baseTimeframe?: string;
+        readonly timeframes: readonly string[];
+        readonly seriesRequirements?: readonly EngineBacktestSeriesRequirement[];
+        readonly needsFunding?: boolean;
+        readonly auxiliaryDataRequirements?: readonly unknown[];
+        readonly fromMs: number;
+        readonly toMs: number;
+        readonly dataQualityMode?: DataQualityMode;
+        readonly onProgress?: (progress: TapeLoadProgress) => void;
+    }, options?: unknown): Promise<TapeLoadResult>;
+    assembleScenario(input: {
+        readonly runId: string;
+        readonly definitionId: string;
+        readonly configSchemaVersion: number;
+        readonly config: unknown;
+        readonly subscriptionTier: SubscriptionTier;
+        readonly initialEquity: number;
+        readonly tape?: EngineBacktestTapeInput;
+        readonly executionModel?: Partial<ExecutionModel>;
+    }): EngineBacktestScenario;
+    resolveTapeExchange(exchangeId: string | TapeExchangeDefinition): TapeExchangeDefinition;
+    DEFAULT_EXECUTION_MODEL: ExecutionModel;
+}
+export interface PersistedSnapshot {
+    readonly snapshotSchemaVersion: 1;
+    readonly strategyDefinitionId: string;
+    readonly configSchemaVersion: number;
+    readonly config: unknown;
+    readonly exchangeId: string;
+    readonly rangeStart: string;
+    readonly rangeEnd: string;
+    readonly initialEquity: number;
+    readonly subscriptionTier: SubscriptionTier;
+    readonly dataQualityMode: DataQualityMode;
+    readonly symbols: string[];
+    readonly timeframes: string[];
+    readonly baseTimeframe: string;
+    readonly executionModel: ExecutionModel;
+    readonly positionSideDual: boolean;
+    readonly engineVersion: string;
+}
+export interface CreateRunRequestBody {
+    readonly clientRunId: string;
+    readonly snapshot: PersistedSnapshot;
+    readonly metrics: EngineBacktestMetrics;
+    readonly engineVersion: string;
+    readonly configSchemaVersion: number;
+}
+export interface EngineBacktestRunSuccess {
+    readonly metrics: EngineBacktestMetrics;
+    readonly engineVersion: string;
+    readonly experimentId: string;
+    readonly runId?: string;
+    readonly experimentUrl: string;
+    readonly persisted: boolean;
+    readonly coverageWarnings: readonly string[];
+}

package/dist/engine-backtest/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/envelope.d.ts

@@ -1,3 +1,4 @@
+import { spawnSync } from "node:child_process";
 export type ExitCode = 0 | 1 | 2 | 3 | 4 | 10 | 64 | 65 | 66 | 69 | 70 | 75 | 77 | 78;
 export interface SuccessEnvelope<T = unknown> {
     readonly ok: true;
@@ -28,7 +29,9 @@ export declare function writeSuccess(data: unknown, options?: {
     readonly meta?: Record<string, unknown>;
     readonly requestId?: string;
     readonly format?: "json" | "jsonl" | "text";
+    readonly jq?: string;
 }): void;
+export declare function applyJqFilter(value: unknown, filter: string, spawn?: typeof spawnSync): string;
 export declare function writeError(error: ErrorBody, options?: {
     readonly requestId?: string;
     readonly exitCode?: number;

package/dist/envelope.js

@@ -4,10 +4,12 @@ exports.newRequestId = newRequestId;
 exports.successEnvelope = successEnvelope;
 exports.errorEnvelope = errorEnvelope;
 exports.writeSuccess = writeSuccess;
+exports.applyJqFilter = applyJqFilter;
 exports.writeError = writeError;
 exports.mapErrorToExitCode = mapErrorToExitCode;
 exports.parseJsonEnvelope = parseJsonEnvelope;
 const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
 function newRequestId() {
     return (0, node_crypto_1.randomUUID)();
 }
@@ -28,11 +30,49 @@ function errorEnvelope(error, requestId) {
 }
 function writeSuccess(data, options = {}) {
     const envelope = successEnvelope(data, options.meta, options.requestId);
-    if (options.format === "text" && data && typeof data === "object") {
-        process.stdout.write(`${JSON.stringify(envelope, null, 2)}\n`);
+    const rendered = options.format === "text" && data && typeof data === "object"
+        ? `${JSON.stringify(envelope, null, 2)}\n`
+        : `${JSON.stringify(envelope)}\n`;
+    if (options.jq?.trim()) {
+        const filtered = applyJqFilter(envelope, options.jq.trim());
+        process.stdout.write(filtered.endsWith("\n") ? filtered : `${filtered}\n`);
         return;
     }
-    process.stdout.write(`${JSON.stringify(envelope)}\n`);
+    process.stdout.write(rendered);
+}
+function applyJqFilter(value, filter, spawn = node_child_process_1.spawnSync) {
+    if (!filter.trim()) {
+        throw Object.assign(new Error("--jq filter must be non-empty"), {
+            type: "usage",
+            subtype: "jq_empty",
+            status: 64,
+        });
+    }
+    const result = spawn(process.env.ALPHAFOX_JQ?.trim() || "jq", ["-c", filter], {
+        input: JSON.stringify(value),
+        encoding: "utf8",
+        timeout: 10_000,
+    });
+    if (result.error) {
+        const code = result.error.code;
+        if (code === "ENOENT") {
+            throw Object.assign(new Error("jq is not installed; --jq requires the jq binary on PATH"), { type: "usage", subtype: "jq_not_installed", status: 64 });
+        }
+        throw Object.assign(new Error(result.error.message), {
+            type: "usage",
+            subtype: "jq_failed",
+            status: 64,
+        });
+    }
+    if (result.status !== 0) {
+        const errText = (result.stderr || "jq filter failed").trim();
+        throw Object.assign(new Error(errText), {
+            type: "usage",
+            subtype: "jq_failed",
+            status: 64,
+        });
+    }
+    return result.stdout;
 }
 function writeError(error, options = {}) {
     const envelope = errorEnvelope(error, options.requestId);

package/dist/http/client.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.apiRequest = apiRequest;
 const envelope_1 = require("../envelope");
+const version_1 = require("../version");
 const refresh_1 = require("../auth/refresh");
 const store_1 = require("../keychain/store");
 const allowlist_1 = require("../catalog/allowlist");
@@ -17,15 +18,15 @@ async function apiRequest(options, env = process.env, fetchImpl = fetch) {
     }
     // Product raw API: /api/v1 only. Auth AS paths under /api/auth/oauth are allowed.
     const isOAuthAsPath = path.startsWith("/api/auth/oauth");
-    if (!isOAuthAsPath &&
-        !(0, allowlist_1.isFacadeAllowlistedPath)(path) &&
-        path.startsWith("/api/") &&
-        !path.startsWith("/api/v1")) {
-        throw Object.assign(new Error(`Path is outside Public API facade: ${path}`), {
-            status: 403,
-            type: "authorization",
-            subtype: "facade_only",
-        });
+    if (!isOAuthAsPath && path.startsWith("/api/")) {
+        // Unknown /api/v1/* is denied (finite facility/catalog allowlist).
+        if (!(0, allowlist_1.isFacadeAllowlistedPath)(path)) {
+            throw Object.assign(new Error(`Path is outside Public API facade: ${path}`), {
+                status: 403,
+                type: "authorization",
+                subtype: "facade_only",
+            });
+        }
     }
     const requestId = options.requestId ?? (0, envelope_1.newRequestId)();
     const base = options.profile.apiBaseUrl.replace(/\/$/, "");
@@ -46,17 +47,19 @@ async function apiRequest(options, env = process.env, fetchImpl = fetch) {
         Accept: "application/json",
         "X-Request-Id": requestId,
         "X-Alphafox-Client": "alphafox-cli",
-        "X-Alphafox-Client-Version": env.ALPHAFOX_CLI_VERSION ?? "0.1.0",
+        "X-Alphafox-Client-Version": env.ALPHAFOX_CLI_VERSION ?? version_1.CLI_VERSION,
         ...(options.headers ?? {}),
     };
     if (!options.skipAuth) {
         let tokens = (0, store_1.loadTokens)(options.profile.name, env);
         // Proactive refresh before the access token expires (or once already expired).
         if (tokens && (0, refresh_1.accessTokenNeedsRefresh)(tokens)) {
-            const renewed = await (0, refresh_1.refreshStoredTokens)(options.profile, env, fetchImpl, { force: true });
-            if (renewed) {
-                tokens = renewed;
+            const outcome = await (0, refresh_1.refreshStoredTokens)(options.profile, env, fetchImpl, { force: true });
+            if (outcome.status === "refreshed" || outcome.status === "unchanged") {
+                tokens = outcome.tokens;
             }
+            // On failed refresh keep prior tokens only for the request; do not treat
+            // failure as a successful renewal.
         }
         if (tokens) {
             // Never send tokens to a different site than the profile audience.
@@ -110,8 +113,8 @@ async function apiRequest(options, env = process.env, fetchImpl = fetch) {
         !isOAuthAsPath) {
         const tokens = (0, store_1.loadTokens)(options.profile.name, env);
         if (tokens?.refreshToken?.trim()) {
-            const renewed = await (0, refresh_1.refreshStoredTokens)(options.profile, env, fetchImpl, { force: true });
-            if (renewed) {
+            const outcome = await (0, refresh_1.refreshStoredTokens)(options.profile, env, fetchImpl, { force: true });
+            if (outcome.status === "refreshed") {
                 return apiRequest({ ...options, requestId, _refreshRetried: true }, env, fetchImpl);
             }
         }

package/dist/index.d.ts

@@ -1,8 +1,19 @@
 export { runCli, parseGlobalFlags } from "./commands/run";
-export { successEnvelope, errorEnvelope, parseJsonEnvelope, writeSuccess, writeError, } from "./envelope";
+export { successEnvelope, errorEnvelope, parseJsonEnvelope, writeSuccess, writeError, applyJqFilter, } from "./envelope";
 export { resolveProfile, loadConfigFile, saveConfigFile, assertNoTokenFields, } from "./config/profiles";
-export { saveTokens, loadTokens, deleteTokens, tokenFingerprint, } from "./keychain/store";
-export { isFacadeAllowlistedPath, isInternalDisallowedPath, normalizeApiPath, } from "./catalog/allowlist";
-export { assertHighRiskConfirmation } from "./safety/confirmation";
-export { CATALOG_OPERATIONS, findCatalogOperation, buildCapabilityManifest, } from "./catalog/operations";
+export { saveTokens, loadTokens, deleteTokens, tokenFingerprint, getLastTokenSaveResult, probeOsKeychain, keychainPlatform, } from "./keychain/store";
+export { linuxSecretServiceArgs, linuxSecretToolBin, } from "./keychain/linux-secret-service";
+export { windowsCredentialTarget, WINDOWS_CRED_MAX_BYTES, } from "./keychain/windows-credential";
+export { isFacadeAllowlistedPath, isInternalDisallowedPath, normalizeApiPath, pathTemplateMatches, } from "./catalog/allowlist";
+export { checkCliCompatibility, type CompatibilityRange, type CompatibilityResult, } from "./catalog/compatibility";
+export { resolveTypedCommand } from "./catalog/command-tree";
+export { assertHighRiskConfirmation, inferRawApiRisk, requiresHighRiskConfirmation, } from "./safety/confirmation";
+export { refreshStoredTokens, refreshStoredTokensOrNull, accessTokenNeedsRefresh, } from "./auth/refresh";
+export { runBrowserPkceLogin } from "./auth/browser-login";
+export { startLoopbackCallbackServer } from "./auth/loopback-callback";
+export { CATALOG_OPERATIONS, CATALOG_SOURCE, CATALOG_VERSION, COMPATIBILITY_RANGE, findCatalogOperation, findCatalogOperationByRoute, getOperationSchemaDocument, buildCapabilityManifest, checkGeneratedCatalogCompatibility, } from "./catalog/operations";
 export { CLI_VERSION, CLI_PACKAGE, CLI_CONTRACT_VERSION } from "./version";
+export { validateCatalogWriteBody } from "./catalog/validate-body";
+export { parseRequestBodyFlags, loadJsonArg } from "./commands/request-body";
+export { parseInstallArgs, runInstallWizard, semverLessThan, skillsListHasAlphafox, } from "./install/wizard";
+export { AGENT_INSTALL_GUIDE_BLOB_URL, AGENT_INSTALL_GUIDE_URL, SKILLS_GITHUB_SOURCE, } from "./install/types";

package/dist/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLI_CONTRACT_VERSION = exports.CLI_PACKAGE = exports.CLI_VERSION = exports.buildCapabilityManifest = exports.findCatalogOperation = exports.CATALOG_OPERATIONS = exports.assertHighRiskConfirmation = exports.normalizeApiPath = exports.isInternalDisallowedPath = exports.isFacadeAllowlistedPath = exports.tokenFingerprint = exports.deleteTokens = exports.loadTokens = exports.saveTokens = exports.assertNoTokenFields = exports.saveConfigFile = exports.loadConfigFile = exports.resolveProfile = exports.writeError = exports.writeSuccess = exports.parseJsonEnvelope = exports.errorEnvelope = exports.successEnvelope = exports.parseGlobalFlags = exports.runCli = void 0;
+exports.validateCatalogWriteBody = exports.CLI_CONTRACT_VERSION = exports.CLI_PACKAGE = exports.CLI_VERSION = exports.checkGeneratedCatalogCompatibility = exports.buildCapabilityManifest = exports.getOperationSchemaDocument = exports.findCatalogOperationByRoute = exports.findCatalogOperation = exports.COMPATIBILITY_RANGE = exports.CATALOG_VERSION = exports.CATALOG_SOURCE = exports.CATALOG_OPERATIONS = exports.startLoopbackCallbackServer = exports.runBrowserPkceLogin = exports.accessTokenNeedsRefresh = exports.refreshStoredTokensOrNull = exports.refreshStoredTokens = exports.requiresHighRiskConfirmation = exports.inferRawApiRisk = exports.assertHighRiskConfirmation = exports.resolveTypedCommand = exports.checkCliCompatibility = exports.pathTemplateMatches = exports.normalizeApiPath = exports.isInternalDisallowedPath = exports.isFacadeAllowlistedPath = exports.WINDOWS_CRED_MAX_BYTES = exports.windowsCredentialTarget = exports.linuxSecretToolBin = exports.linuxSecretServiceArgs = exports.keychainPlatform = exports.probeOsKeychain = exports.getLastTokenSaveResult = exports.tokenFingerprint = exports.deleteTokens = exports.loadTokens = exports.saveTokens = exports.assertNoTokenFields = exports.saveConfigFile = exports.loadConfigFile = exports.resolveProfile = exports.applyJqFilter = exports.writeError = exports.writeSuccess = exports.parseJsonEnvelope = exports.errorEnvelope = exports.successEnvelope = exports.parseGlobalFlags = exports.runCli = void 0;
+exports.SKILLS_GITHUB_SOURCE = exports.AGENT_INSTALL_GUIDE_URL = exports.AGENT_INSTALL_GUIDE_BLOB_URL = exports.skillsListHasAlphafox = exports.semverLessThan = exports.runInstallWizard = exports.parseInstallArgs = exports.loadJsonArg = exports.parseRequestBodyFlags = void 0;
 var run_1 = require("./commands/run");
 Object.defineProperty(exports, "runCli", { enumerable: true, get: function () { return run_1.runCli; } });
 Object.defineProperty(exports, "parseGlobalFlags", { enumerable: true, get: function () { return run_1.parseGlobalFlags; } });
@@ -10,6 +11,7 @@ Object.defineProperty(exports, "errorEnvelope", { enumerable: true, get: functio
 Object.defineProperty(exports, "parseJsonEnvelope", { enumerable: true, get: function () { return envelope_1.parseJsonEnvelope; } });
 Object.defineProperty(exports, "writeSuccess", { enumerable: true, get: function () { return envelope_1.writeSuccess; } });
 Object.defineProperty(exports, "writeError", { enumerable: true, get: function () { return envelope_1.writeError; } });
+Object.defineProperty(exports, "applyJqFilter", { enumerable: true, get: function () { return envelope_1.applyJqFilter; } });
 var profiles_1 = require("./config/profiles");
 Object.defineProperty(exports, "resolveProfile", { enumerable: true, get: function () { return profiles_1.resolveProfile; } });
 Object.defineProperty(exports, "loadConfigFile", { enumerable: true, get: function () { return profiles_1.loadConfigFile; } });
@@ -20,17 +22,61 @@ Object.defineProperty(exports, "saveTokens", { enumerable: true, get: function (
 Object.defineProperty(exports, "loadTokens", { enumerable: true, get: function () { return store_1.loadTokens; } });
 Object.defineProperty(exports, "deleteTokens", { enumerable: true, get: function () { return store_1.deleteTokens; } });
 Object.defineProperty(exports, "tokenFingerprint", { enumerable: true, get: function () { return store_1.tokenFingerprint; } });
+Object.defineProperty(exports, "getLastTokenSaveResult", { enumerable: true, get: function () { return store_1.getLastTokenSaveResult; } });
+Object.defineProperty(exports, "probeOsKeychain", { enumerable: true, get: function () { return store_1.probeOsKeychain; } });
+Object.defineProperty(exports, "keychainPlatform", { enumerable: true, get: function () { return store_1.keychainPlatform; } });
+var linux_secret_service_1 = require("./keychain/linux-secret-service");
+Object.defineProperty(exports, "linuxSecretServiceArgs", { enumerable: true, get: function () { return linux_secret_service_1.linuxSecretServiceArgs; } });
+Object.defineProperty(exports, "linuxSecretToolBin", { enumerable: true, get: function () { return linux_secret_service_1.linuxSecretToolBin; } });
+var windows_credential_1 = require("./keychain/windows-credential");
+Object.defineProperty(exports, "windowsCredentialTarget", { enumerable: true, get: function () { return windows_credential_1.windowsCredentialTarget; } });
+Object.defineProperty(exports, "WINDOWS_CRED_MAX_BYTES", { enumerable: true, get: function () { return windows_credential_1.WINDOWS_CRED_MAX_BYTES; } });
 var allowlist_1 = require("./catalog/allowlist");
 Object.defineProperty(exports, "isFacadeAllowlistedPath", { enumerable: true, get: function () { return allowlist_1.isFacadeAllowlistedPath; } });
 Object.defineProperty(exports, "isInternalDisallowedPath", { enumerable: true, get: function () { return allowlist_1.isInternalDisallowedPath; } });
 Object.defineProperty(exports, "normalizeApiPath", { enumerable: true, get: function () { return allowlist_1.normalizeApiPath; } });
+Object.defineProperty(exports, "pathTemplateMatches", { enumerable: true, get: function () { return allowlist_1.pathTemplateMatches; } });
+var compatibility_1 = require("./catalog/compatibility");
+Object.defineProperty(exports, "checkCliCompatibility", { enumerable: true, get: function () { return compatibility_1.checkCliCompatibility; } });
+var command_tree_1 = require("./catalog/command-tree");
+Object.defineProperty(exports, "resolveTypedCommand", { enumerable: true, get: function () { return command_tree_1.resolveTypedCommand; } });
 var confirmation_1 = require("./safety/confirmation");
 Object.defineProperty(exports, "assertHighRiskConfirmation", { enumerable: true, get: function () { return confirmation_1.assertHighRiskConfirmation; } });
+Object.defineProperty(exports, "inferRawApiRisk", { enumerable: true, get: function () { return confirmation_1.inferRawApiRisk; } });
+Object.defineProperty(exports, "requiresHighRiskConfirmation", { enumerable: true, get: function () { return confirmation_1.requiresHighRiskConfirmation; } });
+var refresh_1 = require("./auth/refresh");
+Object.defineProperty(exports, "refreshStoredTokens", { enumerable: true, get: function () { return refresh_1.refreshStoredTokens; } });
+Object.defineProperty(exports, "refreshStoredTokensOrNull", { enumerable: true, get: function () { return refresh_1.refreshStoredTokensOrNull; } });
+Object.defineProperty(exports, "accessTokenNeedsRefresh", { enumerable: true, get: function () { return refresh_1.accessTokenNeedsRefresh; } });
+var browser_login_1 = require("./auth/browser-login");
+Object.defineProperty(exports, "runBrowserPkceLogin", { enumerable: true, get: function () { return browser_login_1.runBrowserPkceLogin; } });
+var loopback_callback_1 = require("./auth/loopback-callback");
+Object.defineProperty(exports, "startLoopbackCallbackServer", { enumerable: true, get: function () { return loopback_callback_1.startLoopbackCallbackServer; } });
 var operations_1 = require("./catalog/operations");
 Object.defineProperty(exports, "CATALOG_OPERATIONS", { enumerable: true, get: function () { return operations_1.CATALOG_OPERATIONS; } });
+Object.defineProperty(exports, "CATALOG_SOURCE", { enumerable: true, get: function () { return operations_1.CATALOG_SOURCE; } });
+Object.defineProperty(exports, "CATALOG_VERSION", { enumerable: true, get: function () { return operations_1.CATALOG_VERSION; } });
+Object.defineProperty(exports, "COMPATIBILITY_RANGE", { enumerable: true, get: function () { return operations_1.COMPATIBILITY_RANGE; } });
 Object.defineProperty(exports, "findCatalogOperation", { enumerable: true, get: function () { return operations_1.findCatalogOperation; } });
+Object.defineProperty(exports, "findCatalogOperationByRoute", { enumerable: true, get: function () { return operations_1.findCatalogOperationByRoute; } });
+Object.defineProperty(exports, "getOperationSchemaDocument", { enumerable: true, get: function () { return operations_1.getOperationSchemaDocument; } });
 Object.defineProperty(exports, "buildCapabilityManifest", { enumerable: true, get: function () { return operations_1.buildCapabilityManifest; } });
+Object.defineProperty(exports, "checkGeneratedCatalogCompatibility", { enumerable: true, get: function () { return operations_1.checkGeneratedCatalogCompatibility; } });
 var version_1 = require("./version");
 Object.defineProperty(exports, "CLI_VERSION", { enumerable: true, get: function () { return version_1.CLI_VERSION; } });
 Object.defineProperty(exports, "CLI_PACKAGE", { enumerable: true, get: function () { return version_1.CLI_PACKAGE; } });
 Object.defineProperty(exports, "CLI_CONTRACT_VERSION", { enumerable: true, get: function () { return version_1.CLI_CONTRACT_VERSION; } });
+var validate_body_1 = require("./catalog/validate-body");
+Object.defineProperty(exports, "validateCatalogWriteBody", { enumerable: true, get: function () { return validate_body_1.validateCatalogWriteBody; } });
+var request_body_1 = require("./commands/request-body");
+Object.defineProperty(exports, "parseRequestBodyFlags", { enumerable: true, get: function () { return request_body_1.parseRequestBodyFlags; } });
+Object.defineProperty(exports, "loadJsonArg", { enumerable: true, get: function () { return request_body_1.loadJsonArg; } });
+var wizard_1 = require("./install/wizard");
+Object.defineProperty(exports, "parseInstallArgs", { enumerable: true, get: function () { return wizard_1.parseInstallArgs; } });
+Object.defineProperty(exports, "runInstallWizard", { enumerable: true, get: function () { return wizard_1.runInstallWizard; } });
+Object.defineProperty(exports, "semverLessThan", { enumerable: true, get: function () { return wizard_1.semverLessThan; } });
+Object.defineProperty(exports, "skillsListHasAlphafox", { enumerable: true, get: function () { return wizard_1.skillsListHasAlphafox; } });
+var types_1 = require("./install/types");
+Object.defineProperty(exports, "AGENT_INSTALL_GUIDE_BLOB_URL", { enumerable: true, get: function () { return types_1.AGENT_INSTALL_GUIDE_BLOB_URL; } });
+Object.defineProperty(exports, "AGENT_INSTALL_GUIDE_URL", { enumerable: true, get: function () { return types_1.AGENT_INSTALL_GUIDE_URL; } });
+Object.defineProperty(exports, "SKILLS_GITHUB_SOURCE", { enumerable: true, get: function () { return types_1.SKILLS_GITHUB_SOURCE; } });

package/dist/install/exec.d.ts

@@ -0,0 +1,13 @@
+import type { ExecResult, InstallRunner } from "./types";
+export declare function wrapWindowsCommand(command: string, args: readonly string[], platform?: NodeJS.Platform): {
+    readonly file: string;
+    readonly argv: string[];
+};
+export declare function execCommand(command: string, args: readonly string[], options?: {
+    readonly timeoutMs?: number;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly inherit?: boolean;
+    readonly platform?: NodeJS.Platform;
+}): Promise<ExecResult>;
+export declare function confirmTty(message: string): Promise<boolean>;
+export declare function createDefaultInstallRunner(env: NodeJS.ProcessEnv, searchDirs: readonly string[]): InstallRunner;

package/dist/install/exec.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapWindowsCommand = wrapWindowsCommand;
+exports.execCommand = execCommand;
+exports.confirmTty = confirmTty;
+exports.createDefaultInstallRunner = createDefaultInstallRunner;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:readline/promises");
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function wrapWindowsCommand(command, args, platform = process.platform) {
+    if (platform === "win32") {
+        return { file: "cmd.exe", argv: ["/c", command, ...args] };
+    }
+    return { file: command, argv: [...args] };
+}
+async function execCommand(command, args, options = {}) {
+    const { file, argv } = wrapWindowsCommand(command, args, options.platform ?? process.platform);
+    const timeout = options.timeoutMs ?? 120_000;
+    if (options.inherit) {
+        await new Promise((resolve, reject) => {
+            const child = (0, node_child_process_1.spawn)(file, argv, {
+                stdio: "inherit",
+                env: options.env,
+                timeout,
+            });
+            child.on("error", reject);
+            child.on("exit", (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`${command} exited ${code ?? "null"}`));
+            });
+        });
+        return { stdout: "", stderr: "" };
+    }
+    const { stdout, stderr } = await execFileAsync(file, argv, {
+        timeout,
+        encoding: "utf8",
+        env: options.env,
+        maxBuffer: 10 * 1024 * 1024,
+    });
+    return { stdout, stderr };
+}
+async function confirmTty(message) {
+    const rl = (0, promises_1.createInterface)({
+        input: process.stdin,
+        output: process.stderr,
+    });
+    try {
+        const answer = await rl.question(`${message} [Y/n] `);
+        const token = answer.trim().toLowerCase();
+        return token === "" || token === "y" || token === "yes";
+    }
+    finally {
+        rl.close();
+    }
+}
+function createDefaultInstallRunner(env, searchDirs) {
+    return {
+        env,
+        packageSearchDirs: () => searchDirs,
+        isTty: () => Boolean(process.stdin.isTTY && process.stderr.isTTY),
+        log: (message) => {
+            process.stderr.write(`${message}\n`);
+        },
+        confirm: confirmTty,
+        exec: (command, args, options) => execCommand(command, args, { ...options, env }),
+        execInherit: async (command, args, options) => {
+            await execCommand(command, args, { ...options, env, inherit: true });
+        },
+    };
+}

package/dist/install/package-root.d.ts

@@ -0,0 +1,4 @@
+export declare function findAlphafoxPackageRoot(startDirs: readonly string[]): string | null;
+export declare function packageHasSkills(packageRoot: string): boolean;
+export declare function globalPackageRoot(npmRootGlobal: string): string;
+export declare function globalBinPath(npmPrefixGlobal: string, platform?: NodeJS.Platform): string;