praxis-agent 0.43.1 → 0.45.0

package/README.md

@@ -27,7 +27,9 @@ sessions, configuration, or compatibility directories.
 - macOS or Linux
 - Node.js 24 or newer
 - [`ripgrep`](https://github.com/BurntSushi/ripgrep) (`rg`) for the Grep tool
-- an API key and model ID for an Anthropic or OpenAI-compatible provider
+- an API key and model ID for an Anthropic or OpenAI-compatible provider (the
+  stable setup), or the explicitly enabled experimental ChatGPT-backed Codex
+  subscription integration
 
 Praxis does not use Claude subscription authentication. Claude-shaped message,
 tool, and CLI protocol forms remain supported where they are part of the
@@ -61,6 +63,15 @@ cd /path/to/project
 praxis
 ```
 
+Praxis also has an experimental `openai-codex` provider for ChatGPT-backed
+Codex subscriptions. It is separate from OpenAI API-key access, requires
+`experimental.codexSubscription: true`, and stores OAuth credentials in the
+native Vault. Start with `praxis auth login openai-codex`; see [Getting
+Started](docs/GETTING_STARTED.md) for the browser/device flow and limitations.
+This uses an undocumented third-party subscription/backend contract and may
+change; it is not Claude subscription authentication. Subscription runs retain
+token usage but do not provide API-dollar cost or enforce USD budgets.
+
 For Anthropic Messages:
 
 ```sh
@@ -90,7 +101,8 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
 ## What Praxis provides
 
 - **Local agent runtime** — C+ Quiet Operator responsive TUI with a linear
-  `you>`/`praxis>` conversation, compact stable tool rows, responsive density,
+  `❯` user / `⏺` assistant conversation, `✻` thinking activity, and `!` shell
+  composer grammar, compact stable tool rows, responsive density,
   terminal-native background, and a minimal composer/status row. Interactive
   surfaces share the same presentation across terminals, with English
   permission/configuration choices and a taught `❯` / Up/Down / Enter / Esc
@@ -128,8 +140,9 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   provider-free `/terminal-setup` diagnostics and repeatable Shift+Enter setup
   for supported local terminals,
   `Ctrl+V` text/image clipboard paste, `Ctrl+Z` shell suspension and `fg`
-  recovery, permission-gated `!` shell turns, navigable current/per-turn Git
-  diff views, semantic plan/question decision panels with complete
+  recovery, permission-gated provider-free `!` shell turns that persist shell
+  input/output for later ordinary prompts without creating an assistant turn,
+  navigable current/per-turn Git diff views, semantic plan/question decision panels with complete
   screen-reader actions, semantic screen projection across selectable surfaces,
   deterministic resize-aware URL/form elicitation rendering, and measured
   context budgets; print mode,
@@ -154,11 +167,11 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   isolation, explicit ask/deny precedence, sandbox-only auto-allow,
   write-allowlist/deny-within-allow enforcement, per-command overrides and
   exclusions, violation reporting, and bare-repository control-file cleanup,
-  safe-property Skill auto-allow, interactive
-  workspace-directory add/remove controls, path confinement, credential
-  redaction, sanitized child processes, and exact-fingerprint workspace trust
-  that blocks automatically discovered project/local hooks and MCP servers
-  until the canonical workspace configuration is explicitly accepted.
+  safe-property Skill auto-allow, interactive workspace-directory add/remove
+  controls, path confinement, credential redaction, sanitized child processes,
+  and exact-fingerprint workspace trust that blocks automatically discovered
+  project/local provider selection, hooks, and MCP until the canonical
+  workspace configuration is accepted.
 - **Durable local work** — resumable sessions, full-history forks, file
   checkpoints, tasks, foreground/background subagents, top-level agents, and
   Claude-compatible main-thread agent definitions with native prompt, model,
@@ -187,9 +200,10 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   plugins, and append-only `praxis.transcript` JSONL sessions under `~/.praxis`,
   with bounded MCP connection, discovery, and tool operations plus safe
   disconnect recovery that never replays an already-dispatched call.
-- **Provider-neutral models** — native Anthropic Messages and OpenAI-compatible
-  streaming adapters with explicit capability checks, metering controls, and
-  a bounded absolute deadline for every provider attempt.
+- **Provider-neutral models** — native Provider Registry/Vault routing, API
+  adapters, an experimental Codex OAuth adapter, explicit capability checks,
+  per-attempt bounded deadlines, and token-only/no-API-dollar accounting for
+  subscription runs.
 - **Transactional self-update** — `praxis update` verifies the package before
   installing it, rejects concurrent updates, and can roll back after an
   interruption or crash.
@@ -198,6 +212,22 @@ Detailed feature status and executable evidence live in the
 [parity matrix](https://github.com/Forest-Isle/Praxis/blob/main/docs/PARITY_MATRIX.md),
 not in this entry-point README.
 
+## Native data plane
+
+Praxis defaults to an independent local native data plane:
+
+```text
+Praxis ─── ~/.praxis (or PRAXIS_HOME)
+```
+
+All sessions, memory, tasks, scheduled tasks, resources, and private state live
+under `~/.praxis` (or `PRAXIS_HOME`). The authoritative transcript is
+append-only `praxis.transcript` v1 JSONL; legacy Claude transcripts, indexes,
+sidechains, and migration/recovery paths have been removed. `CLAUDE_CONFIG_DIR`
+does not participate in native runs, and legacy directories are neither read
+nor written. Claude-shaped messages and tool fields describe protocol shape
+only; they do not change Praxis data ownership.
+
 ## Documentation
 
 | Need                                       | Document                                                                                         |
@@ -216,7 +246,7 @@ not in this entry-point README.
 
 Praxis targets one local OS user working across multiple repositories and
 sessions. It is CLI-only and provider-capability-aware. Organization, tenant,
-RBAC, subscription authentication and billing, enterprise gateway,
+RBAC, billing, enterprise gateway,
 IDE/Desktop/mobile clients, Remote Control, Claude Desktop import, and hosted
 review-product surfaces are permanent non-goals.
 
@@ -251,6 +281,8 @@ implemented profile checks, not qualification of the full native package.
 injected regression protection, plus Quiet Operator input echo `<50 ms` and
 normal/low-capability full-frame p95 budgets of `<16.7/<33 ms`.
 `npm run check` also enforces the corresponding source dependency direction.
+`npm run test:coverage` measures all production code under `src/**` with V8 and
+enforces global floors of 79% statements, 70% branches, 85% functions, and 81% lines.
 `npm run test:core-completion` runs the 56-story #402 audit and reports
 implemented, qualified, blocked, deferred, and out-of-scope states separately;
 it never treats missing live prerequisites as a pass.

package/dist/application/session-service.js

@@ -2592,7 +2592,9 @@ export class ClaudeSessionService {
                     });
                 }
                 const initialPricing = this.options.pricing?.resolve(provider.model ?? 'praxis/provider');
-                if (this.options.maxBudgetUsd !== undefined && !initialPricing) {
+                if (shellCommand === undefined &&
+                    this.options.maxBudgetUsd !== undefined &&
+                    !initialPricing) {
                     throw new Error(`Cannot enforce --max-budget-usd: no pricing is configured for model ${provider.model ?? 'praxis/provider'}`);
                 }
                 const shellInputUuid = shellCommand === undefined ? null : randomUUID();
@@ -3699,7 +3701,9 @@ export class ClaudeSessionService {
                             };
                         },
                     });
-                    await contextEngine.prepare(contextTransitionPort(pendingUserMessages), signal);
+                    if (shellCommand === undefined) {
+                        await contextEngine.prepare(contextTransitionPort(pendingUserMessages), signal);
+                    }
                     for (const [index, message] of expandedMessages.entries()) {
                         if (shellCommand !== undefined)
                             break;
@@ -3783,6 +3787,9 @@ export class ClaudeSessionService {
                     }
                     let shellUsage = { inputTokens: 0, outputTokens: 0 };
                     let shellModelUsage;
+                    let shellDurationApiMs;
+                    let shellDurationApiWithoutRetriesMs;
+                    let shellToolDurationMs;
                     if (shellCommand !== undefined) {
                         const call = {
                             id: `shell_${randomUUID().replaceAll('-', '')}`,
@@ -3822,6 +3829,10 @@ export class ClaudeSessionService {
                             throw error;
                         }
                         shellUsage = shellResult.usage ?? shellUsage;
+                        shellDurationApiMs = shellResult.durationApiMs;
+                        shellDurationApiWithoutRetriesMs =
+                            shellResult.durationApiWithoutRetriesMs;
+                        shellToolDurationMs = shellResult.durationToolMs;
                         if (!shellResult.isError) {
                             shellModelUsage = shellResult.modelUsage;
                             foregroundLineChanges.add(shellResult);
@@ -3872,7 +3883,74 @@ export class ClaudeSessionService {
                             isError: shellResult.isError,
                         });
                     }
-                    if (budget) {
+                    if (shellCommand !== undefined) {
+                        const tracker = this.sessionCostTrackers.get(sessionId);
+                        if (!tracker) {
+                            throw new Error(`Session cost tracker is not active for session ${sessionId}`);
+                        }
+                        const totalUsage = mergeUsage(recoveryUsage, shellUsage);
+                        const turnModelUsage = mergeSessionRawModelUsage(recoveryModelUsage, shellModelUsage);
+                        let rawCostUsd;
+                        if (turnModelUsage) {
+                            for (const [model, usage] of Object.entries(turnModelUsage)) {
+                                const pricing = this.options.pricing?.resolve(model);
+                                const costUsd = pricing
+                                    ? usageCostUsd(usage, pricing)
+                                    : undefined;
+                                if (costUsd !== undefined)
+                                    rawCostUsd = (rawCostUsd ?? 0) + costUsd;
+                                tracker.recordTurn({
+                                    model,
+                                    usage,
+                                    ...(costUsd === undefined ? {} : { costUsd }),
+                                    ...(usage.webSearchRequests === undefined
+                                        ? {}
+                                        : { webSearchRequests: usage.webSearchRequests }),
+                                });
+                            }
+                        }
+                        let combinedToolDurationMs = 0;
+                        for (const recoveryResult of recoveryResults) {
+                            combinedToolDurationMs = addToolDuration(recoveryResult.durationToolMs, combinedToolDurationMs);
+                        }
+                        combinedToolDurationMs = addToolDuration(shellToolDurationMs, combinedToolDurationMs);
+                        tracker.recordDurations({
+                            ...(shellDurationApiMs === undefined
+                                ? {}
+                                : { apiDurationMs: shellDurationApiMs }),
+                            ...(shellDurationApiWithoutRetriesMs === undefined
+                                ? {}
+                                : {
+                                    apiDurationWithoutRetriesMs: shellDurationApiWithoutRetriesMs,
+                                }),
+                            ...(combinedToolDurationMs === 0
+                                ? {}
+                                : { toolDurationMs: combinedToolDurationMs }),
+                        });
+                        if (foregroundLineChanges.linesAdded !== 0 ||
+                            foregroundLineChanges.linesRemoved !== 0) {
+                            tracker.recordLineChanges({
+                                ...(foregroundLineChanges.linesAdded === 0
+                                    ? {}
+                                    : { linesAdded: foregroundLineChanges.linesAdded }),
+                                ...(foregroundLineChanges.linesRemoved === 0
+                                    ? {}
+                                    : { linesRemoved: foregroundLineChanges.linesRemoved }),
+                            });
+                        }
+                        turnCompleted = true;
+                        return {
+                            sessionId,
+                            text: '',
+                            usage: totalUsage,
+                            ...(rawCostUsd === undefined ? {} : { costUsd: rawCostUsd }),
+                            ...(turnModelUsage ? { modelUsage: { ...turnModelUsage } } : {}),
+                            ...(shellDurationApiMs === undefined
+                                ? {}
+                                : { durationApiMs: shellDurationApiMs }),
+                        };
+                    }
+                    if (shellCommand === undefined && budget) {
                         await contextEngine.prepare(contextTransitionPort([], currentTurnUserMessages ?? []), signal);
                         budget.assertFits(budget.evaluate([
                             ...contextMessages,
@@ -3911,7 +3989,9 @@ export class ClaudeSessionService {
                                 ];
                             }
                             await refreshRuntimeContext?.();
-                            await contextEngine.prepare(contextTransitionPort([], currentTurnUserMessages ?? []), signal);
+                            if (shellCommand === undefined) {
+                                await contextEngine.prepare(contextTransitionPort([], currentTurnUserMessages ?? []), signal);
+                            }
                             runtimeRequest.stableSystemMessageCount = stableSystemMessageCount;
                             return [
                                 ...contextMessages,

package/dist/application/top-level-agent-manager.d.ts

@@ -35,8 +35,15 @@ export interface TopLevelAgentManagerOptions {
     cliPath: string;
     executablePath?: string;
     environment?: NodeJS.ProcessEnv;
+    resolveProviderEnvironment?: (request: {
+        cwd: string;
+        argv: readonly string[];
+    }) => Promise<ProviderEnvironmentOverride>;
     version: string;
 }
+export interface ProviderEnvironmentOverride {
+    PRAXIS_API_KEY?: string;
+}
 export declare function topLevelAgentProcessRegistryRoot(configRoot: string, dataPlane?: DataPlane): string;
 export declare class TopLevelAgentManager {
     private readonly options;

package/dist/application/top-level-agent-manager.js

@@ -24,8 +24,11 @@ const SOCKET_RETRY_INTERVAL_MS = 25;
 // own provider from the same CLI/environment contract.
 const WORKER_RUNTIME_ENVIRONMENT = [
     'PRAXIS_API_KEY',
+    'CLAUDE_CODE_SIMPLE',
     'PRAXIS_MODEL',
     'PRAXIS_PROVIDER',
+    'PRAXIS_PROVIDER_PROFILE',
+    'PRAXIS_PROVIDER_DEADLINE_MS',
     'PRAXIS_BASE_URL',
     'PRAXIS_MAX_OUTPUT_TOKENS',
     'PRAXIS_ANTHROPIC_VERSION',
@@ -38,10 +41,11 @@ const WORKER_RUNTIME_ENVIRONMENT = [
     'PRAXIS_FILES_BASE_URL',
     'PRAXIS_FILES_BEARER_TOKEN',
     'PRAXIS_FILES_API_KEY',
+    'PRAXIS_PROVIDER_CREDENTIAL_STORE',
     'PRAXIS_MCP_OAUTH_STORE',
     'CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING',
 ];
-function workerEnvironment(source, configRoot) {
+function workerEnvironment(source, configRoot, resolved) {
     const environment = sanitizeChildEnvironment({ PATH: source.PATH }, {});
     for (const name of WORKER_RUNTIME_ENVIRONMENT) {
         const value = source[name];
@@ -50,6 +54,8 @@ function workerEnvironment(source, configRoot) {
     }
     environment.PRAXIS_DATA_PLANE = 'native';
     environment.PRAXIS_HOME = configRoot;
+    if (resolved?.PRAXIS_API_KEY !== undefined)
+        environment.PRAXIS_API_KEY = resolved.PRAXIS_API_KEY;
     return environment;
 }
 function socketPath(configRoot, id) {
@@ -285,8 +291,15 @@ export class TopLevelAgentManager {
             throw new Error('Could not allocate agent ID');
         const allocatedExecution = execution;
         let child;
+        let resolvedProviderEnvironment;
         const failLaunch = async (error) => {
-            const message = redactSensitiveText(error instanceof Error ? error.message : String(error), sensitiveEnvironmentValues(this.options.environment ?? process.env));
+            const sensitiveValues = [
+                ...sensitiveEnvironmentValues(this.options.environment ?? process.env),
+                ...(resolvedProviderEnvironment?.PRAXIS_API_KEY === undefined
+                    ? []
+                    : [resolvedProviderEnvironment.PRAXIS_API_KEY]),
+            ];
+            const message = redactSensitiveText(error instanceof Error ? error.message : String(error), sensitiveValues);
             const secondary = [];
             if (child?.pid !== undefined) {
                 try {
@@ -321,9 +334,14 @@ export class TopLevelAgentManager {
             throw new AggregateError([error, ...secondary], 'Could not start background agent');
         };
         try {
+            resolvedProviderEnvironment =
+                await this.options.resolveProviderEnvironment?.({
+                    cwd,
+                    argv: options.argv,
+                });
             child = spawn(this.options.executablePath ?? process.execPath, [this.options.cliPath, '__background-worker', identity.id], {
                 cwd,
-                env: workerEnvironment(this.options.environment ?? process.env, this.options.configRoot),
+                env: workerEnvironment(this.options.environment ?? process.env, this.options.configRoot, resolvedProviderEnvironment),
                 detached: true,
                 stdio: 'ignore',
             });

package/dist/cli/controls.js

@@ -206,6 +206,10 @@ export async function resolveCliControls(controls, cwd) {
         name: controls.name,
         sessionPersistence: controls.sessionPersistence,
         ...(controls.model === undefined ? {} : { model: controls.model }),
+        ...(controls.provider === undefined ? {} : { provider: controls.provider }),
+        ...(controls.providerProfile === undefined
+            ? {}
+            : { providerProfile: controls.providerProfile }),
         ...(controls.effort === undefined ? {} : { effort: controls.effort }),
         ...(controls.thinking === undefined ? {} : { thinking: controls.thinking }),
         ...(controls.maxThinkingTokens === undefined

package/dist/cli/interactive.js

@@ -3240,7 +3240,9 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             streamingFrameRef.current?.resetText();
             streamingFrameRef.current?.resetThinking();
             streamingFrameRef.current?.flush();
-            append({ kind: 'assistant', text: result.text });
+            if (shellCommand === undefined) {
+                append({ kind: 'assistant', text: result.text });
+            }
             if (turnMutatedFilesRef.current) {
                 try {
                     const snapshot = await loadDiffSnapshot();

package/dist/cli/protocol.d.ts

@@ -52,6 +52,8 @@ export interface CliControls {
     rewindFiles?: string;
     name: string | undefined;
     sessionPersistence: boolean;
+    provider?: string;
+    providerProfile?: string;
     model?: string;
     effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     thinking?: CliThinkingMode;
@@ -114,6 +116,9 @@ export interface CliInvocation extends CliControls {
     mcpClientSecret: boolean;
     mcpNoBrowser: boolean;
     mcpDebug: boolean;
+    /** Auth-command-only profile selector; distinct from providerProfile. */
+    authProfile?: string;
+    authDevice: boolean;
 }
 export interface StreamUserMessage {
     message: {

package/dist/cli/protocol.js

@@ -387,6 +387,8 @@ export function parseCliInvocation(argv) {
     let worktreeRequested = false;
     let tmux;
     let model;
+    let provider;
+    let providerProfile;
     let effort;
     let thinking;
     let maxThinkingTokens;
@@ -404,6 +406,8 @@ export function parseCliInvocation(argv) {
     let mcpClientSecret = false;
     let mcpNoBrowser = false;
     let mcpDebug = false;
+    let authProfile;
+    let authDevice = false;
     for (let index = 0; index < argv.length; index += 1) {
         const value = argv[index];
         if (value === undefined)
@@ -444,6 +448,30 @@ export function parseCliInvocation(argv) {
             index += selectedModel.consumed;
             continue;
         }
+        const selectedProvider = optionValue(argv, index, '--provider');
+        if (selectedProvider) {
+            if (provider !== undefined)
+                throw new Error('--provider may only be specified once');
+            provider = selectedProvider.value;
+            index += selectedProvider.consumed;
+            continue;
+        }
+        const selectedProviderProfile = optionValue(argv, index, '--provider-profile');
+        if (selectedProviderProfile) {
+            if (providerProfile !== undefined)
+                throw new Error('--provider-profile may only be specified once');
+            providerProfile = selectedProviderProfile.value;
+            index += selectedProviderProfile.consumed;
+            continue;
+        }
+        const selectedAuthProfile = optionValue(argv, index, '--profile');
+        if (selectedAuthProfile) {
+            if (authProfile !== undefined)
+                throw new Error('--profile may only be specified once');
+            authProfile = selectedAuthProfile.value;
+            index += selectedAuthProfile.consumed;
+            continue;
+        }
         const selectedAutocompact = optionValue(argv, index, '--autocompact');
         if (selectedAutocompact) {
             if (autocompact !== undefined)
@@ -1123,6 +1151,10 @@ export function parseCliInvocation(argv) {
             mcpNoBrowser = true;
             continue;
         }
+        if (value === '--device') {
+            authDevice = true;
+            continue;
+        }
         if (value === '--json') {
             legacyJson = true;
             continue;
@@ -1174,6 +1206,14 @@ export function parseCliInvocation(argv) {
     if (debug !== undefined && args[0] === 'mcp' && args[1] === 'serve') {
         mcpDebug = true;
     }
+    if (authProfile !== undefined && args[0] !== 'auth')
+        throw new Error('--profile is only valid with auth commands');
+    if (authDevice && !(args[0] === 'auth' && args[1] === 'login'))
+        throw new Error('--device is only valid with auth login');
+    if (mcpNoBrowser &&
+        !((args[0] === 'mcp' && args[1] === 'login') ||
+            (args[0] === 'auth' && args[1] === 'login')))
+        throw new Error('--no-browser is only valid with mcp login or auth login');
     if (background && print) {
         throw new Error("--bg and --print conflict: --print never starts the interactive session that `claude agents` attaches to, so the job would be unattachable. The prompt is the positional — drop --print: `claude --bg '<task>'`.");
     }
@@ -1215,6 +1255,7 @@ export function parseCliInvocation(argv) {
         'plugin',
         'doctor',
         'import',
+        'auth',
     ].includes(args[0] ?? '');
     if (promptSuggestions &&
         !managementCommand &&
@@ -1385,6 +1426,8 @@ export function parseCliInvocation(argv) {
         ...(worktreeRequested ? { worktreeRequested: true } : {}),
         ...(tmux === undefined ? {} : { tmux }),
         ...(model === undefined ? {} : { model }),
+        ...(provider === undefined ? {} : { provider }),
+        ...(providerProfile === undefined ? {} : { providerProfile }),
         ...(effort === undefined ? {} : { effort }),
         ...(thinking === undefined ? {} : { thinking }),
         ...(maxThinkingTokens === undefined ? {} : { maxThinkingTokens }),
@@ -1402,6 +1445,8 @@ export function parseCliInvocation(argv) {
         mcpClientSecret,
         mcpNoBrowser,
         mcpDebug,
+        ...(authProfile === undefined ? {} : { authProfile }),
+        authDevice,
     };
 }
 function parseUserMessage(value, lineNumber) {

package/dist/cli/provider-auth-command.d.ts

@@ -0,0 +1,32 @@
+import { type ProviderCredentialKey, type ProviderCredentialMetadata, type ProviderCredentialInput, type ProviderCredentialRecord } from '../persistence/provider-credential-vault.js';
+import { deviceLoginWithCodexOAuth, loginWithCodexOAuth } from '../providers/codex-oauth.js';
+export interface ProviderAuthCommandIO {
+    stdout(message: string): void;
+    stderr?(message: string): void;
+    readSecret?(prompt: string, signal?: AbortSignal): Promise<string>;
+}
+export interface ProviderAuthVault {
+    read(key: ProviderCredentialKey): Promise<ProviderCredentialRecord | undefined>;
+    list(): Promise<ProviderCredentialMetadata[]>;
+    modify(key: ProviderCredentialKey, callback: (current: ProviderCredentialRecord | undefined) => ProviderCredentialInput | undefined | Promise<ProviderCredentialInput | undefined>): Promise<ProviderCredentialRecord | undefined>;
+    delete(key: ProviderCredentialKey): Promise<void>;
+}
+export interface ProviderAuthCommandOptions {
+    io: ProviderAuthCommandIO;
+    vault?: ProviderAuthVault;
+    configRoot?: string;
+    cwd?: string;
+    environment?: Readonly<Record<string, string | undefined>>;
+    signal?: AbortSignal;
+    profile?: string;
+    providerProfile?: string;
+    noBrowser?: boolean;
+    json?: boolean;
+    device?: boolean;
+    loginWithCodexOAuth?: typeof loginWithCodexOAuth;
+    deviceLoginWithCodexOAuth?: typeof deviceLoginWithCodexOAuth;
+    assertCodexLoginEnabled?: (profileId: string) => Promise<void>;
+}
+export declare function secretLine(value: string): string;
+export declare function executeProviderAuthCommand(args: readonly string[], options: ProviderAuthCommandOptions): Promise<number>;
+//# sourceMappingURL=provider-auth-command.d.ts.map