@moda-ai/cli 1.22.1 → 1.22.2

package/dist/cli-session.d.ts

@@ -1,26 +0,0 @@
-import { CliAuthError } from './errors.js';
-import { type AuthSessionOptions, type StoredAuth } from './auth-storage.js';
-/**
- * Fire-and-forget sliding-expiry renewal, invoked on every authenticated
- * request: a no-op unless the session is a moda_ct token inside the renewal
- * window. Never awaited by callers, never throws, never holds the process
- * open (unref'd socket); on success the stored expires_at is rewritten in
- * place.
- */
-export declare function scheduleRenewalIfNearExpiry(session: StoredAuth, authOptions: AuthSessionOptions): void;
-/** The CliAuthError thrown whenever a stored moda_ct session has expired. */
-export declare function cliSessionExpiredError(): CliAuthError;
-/**
- * Classify a 401 for a moda_ct session. Returns the CliAuthError to throw,
- * or null when the renew probe says the token is actually alive (the caller
- * then surfaces the original response unchanged).
- */
-export declare function classifyModaCtUnauthorized(session: StoredAuth, authOptions: AuthSessionOptions): Promise<CliAuthError | null>;
-/**
- * Best-effort server-side revocation of a stored moda_ct session token,
- * called by `moda auth logout` before local deletion. No-op for legacy
- * auth0-kind sessions; all failures are swallowed (the local deletion is
- * the contract).
- */
-export declare function revokeCliSessionToken(options?: AuthSessionOptions): Promise<void>;
-//# sourceMappingURL=cli-session.d.ts.map

package/dist/cli-session.js

@@ -1,169 +0,0 @@
-// src/cli-session.ts — moda_ct CLI session token lifecycle: renewal
-// (sliding expiry), revocation, and 401 classification against the
-// /api/cli/auth/* endpoints.
-import { request as httpRequest } from 'node:http';
-import { request as httpsRequest } from 'node:https';
-import { resolveModaBaseUrl } from './config.js';
-import { CliAuthError } from './errors.js';
-import { isModaCtSession, loadAuthSession, persistAuthSession, } from './auth-storage.js';
-// Background sliding-expiry renewal fires when a moda_ct session has less
-// than this long left.
-const RENEW_WINDOW_SECONDS = 7 * 86_400;
-const RENEW_TIMEOUT_MS = 10_000;
-// Synchronous renew probe used to classify a 401, and best-effort revoke on
-// logout: both must never stall a command, so they get a tight budget.
-const RENEW_PROBE_TIMEOUT_MS = 2_000;
-const REVOKE_TIMEOUT_MS = 2_000;
-/**
- * POST an Authorization-bearer request to a CLI session lifecycle endpoint
- * (/api/cli/auth/renew or /api/cli/auth/revoke) over raw node http/https.
- * Not fetch: the background renewal must never delay process exit, and only
- * a raw socket can be unref'd. Rejects on network failure or timeout.
- */
-function postCliSessionEndpoint(path, token, timeoutMs, opts = {}) {
-    return new Promise((resolve, reject) => {
-        let url;
-        try {
-            // Resolve the origin from the same profile/env context the session was
-            // loaded with: a `--profile staging` session's renew/revoke must hit the
-            // staging backend that minted it, not the active/default profile's.
-            url = new URL(`${resolveModaBaseUrl(opts.authOptions)}${path}`);
-        }
-        catch (err) {
-            reject(err instanceof Error ? err : new Error(String(err)));
-            return;
-        }
-        const requestFn = url.protocol === 'https:' ? httpsRequest : httpRequest;
-        const req = requestFn(url, {
-            method: 'POST',
-            headers: { Authorization: `Bearer ${token}` },
-            timeout: timeoutMs,
-        }, (res) => {
-            const chunks = [];
-            res.on('data', (chunk) => chunks.push(chunk));
-            res.on('end', () => {
-                resolve({
-                    status: res.statusCode ?? 0,
-                    body: Buffer.concat(chunks).toString('utf8'),
-                });
-            });
-            res.on('error', reject);
-        });
-        if (opts.unrefSocket) {
-            req.on('socket', (socket) => {
-                socket.unref();
-            });
-        }
-        req.on('timeout', () => {
-            req.destroy(new Error(`CLI session request timed out after ${timeoutMs}ms`));
-        });
-        req.on('error', reject);
-        req.end();
-    });
-}
-/**
- * Parse a renew response body and rewrite the stored session's expiry in
- * place, preserving the profile scoping the session was loaded with.
- * Best-effort: an unreadable or incomplete body is simply ignored.
- */
-function persistRenewedExpiry(session, body, authOptions) {
-    try {
-        const parsed = JSON.parse(body);
-        const expiresAtMs = typeof parsed.expires_at === 'string' ? Date.parse(parsed.expires_at) : NaN;
-        if (!Number.isFinite(expiresAtMs))
-            return;
-        persistAuthSession({ ...session, expires_at: Math.floor(expiresAtMs / 1000) }, authOptions);
-    }
-    catch {
-        // Best-effort persistence only.
-    }
-}
-// Stampede guard: at most one background renewal in flight per process.
-let renewInFlight = false;
-/**
- * Fire-and-forget sliding-expiry renewal, invoked on every authenticated
- * request: a no-op unless the session is a moda_ct token inside the renewal
- * window. Never awaited by callers, never throws, never holds the process
- * open (unref'd socket); on success the stored expires_at is rewritten in
- * place.
- */
-export function scheduleRenewalIfNearExpiry(session, authOptions) {
-    if (!isModaCtSession(session))
-        return;
-    if (session.expires_at - Date.now() / 1000 >= RENEW_WINDOW_SECONDS)
-        return;
-    if (renewInFlight)
-        return;
-    renewInFlight = true;
-    void (async () => {
-        try {
-            const result = await postCliSessionEndpoint('/api/cli/auth/renew', session.access_token, RENEW_TIMEOUT_MS, { unrefSocket: true, authOptions });
-            if (result.status !== 200)
-                return;
-            persistRenewedExpiry(session, result.body, authOptions);
-        }
-        catch {
-            // Silent by design: renewal is opportunistic, the command result must
-            // not depend on it.
-        }
-        finally {
-            renewInFlight = false;
-        }
-    })();
-}
-/** The CliAuthError thrown whenever a stored moda_ct session has expired. */
-export function cliSessionExpiredError() {
-    return new CliAuthError('The stored CLI session token has expired. Run "moda auth login" to sign in again.', { reason: 'token_expired', login_command: ['moda', 'auth', 'login'] });
-}
-/**
- * Classify a 401 for a moda_ct session. Returns the CliAuthError to throw,
- * or null when the renew probe says the token is actually alive (the caller
- * then surfaces the original response unchanged).
- */
-export async function classifyModaCtUnauthorized(session, authOptions) {
-    const loginCommand = ['moda', 'auth', 'login'];
-    if (Date.now() / 1000 > session.expires_at) {
-        return cliSessionExpiredError();
-    }
-    let probe;
-    try {
-        probe = await postCliSessionEndpoint('/api/cli/auth/renew', session.access_token, RENEW_PROBE_TIMEOUT_MS, { authOptions });
-    }
-    catch {
-        return new CliAuthError('The Moda API rejected the stored CLI session token, and the renewal check could not reach the server. ' +
-            'The token has not expired, so this is likely transient: retry the command instead of logging in again.', { reason: 'renew_failed', login_command: loginCommand });
-    }
-    if (probe.status === 401) {
-        return new CliAuthError('The stored CLI session token has been revoked. Run "moda auth login" to sign in again.', { reason: 'token_revoked', login_command: loginCommand });
-    }
-    if (probe.status === 200) {
-        // The token is demonstrably alive (the probe just slid its expiry) but
-        // the original request still 401'd; persist the fresh expiry and let the
-        // caller see the original response.
-        persistRenewedExpiry(session, probe.body, authOptions);
-        return null;
-    }
-    // Any other renew status (e.g. a 5xx) is indistinguishable from a
-    // transient server problem: same retry guidance as a network failure.
-    return new CliAuthError('The Moda API rejected the stored CLI session token, and the renewal check failed ' +
-        `(HTTP ${probe.status}). The token has not expired, so this is likely transient: ` +
-        'retry the command instead of logging in again.', { reason: 'renew_failed', login_command: loginCommand });
-}
-/**
- * Best-effort server-side revocation of a stored moda_ct session token,
- * called by `moda auth logout` before local deletion. No-op for legacy
- * auth0-kind sessions; all failures are swallowed (the local deletion is
- * the contract).
- */
-export async function revokeCliSessionToken(options = {}) {
-    const session = loadAuthSession({ ...options, includeExpired: true });
-    if (!session || !isModaCtSession(session))
-        return;
-    try {
-        await postCliSessionEndpoint('/api/cli/auth/revoke', session.access_token, REVOKE_TIMEOUT_MS, { authOptions: options });
-    }
-    catch {
-        // Best-effort: logout proceeds with local deletion regardless.
-    }
-}
-//# sourceMappingURL=cli-session.js.map

package/dist/cli.d.ts

@@ -1,44 +0,0 @@
-#!/usr/bin/env node
-import { type TelemetryErrorType } from './telemetry.js';
-import { type CommandContext } from './command-context.js';
-import { type CommandDefinition } from './command-registry.js';
-export { CliInputError } from './errors.js';
-export interface ParsedArgs {
-    command: string;
-    positional: string | undefined;
-    positionals: string[];
-    flags: Record<string, string>;
-}
-export declare function parseArgs(argv: string[]): ParsedArgs;
-export declare function flagsToArgs(flags: Record<string, string>, positionalKey?: string, positionalValue?: string): Record<string, unknown>;
-/**
- * Build the argv the caller should re-run to resume an interrupted command,
- * echoing back the raw flags exactly as parsed (so per-invocation opt-outs
- * like --no-telemetry survive). Treats `--flag` and `--flag=true` identically.
- *
- * Limitation: positional arguments are not included — the current callers
- * (`moda init`, `moda provision`) take none. Extend the signature before
- * reusing this for a command with positionals.
- */
-export declare function buildResumeCommand(command: string, flags: Record<string, string>): string[];
-/**
- * Coarse caller identity for the feedback body's `agent` field. Same
- * truthy-env semantics as the agent-environment detection in output.ts;
- * never sourced from flags, because `--agent` is the output-mode flag.
- */
-export declare function detectCallerAgent(env: NodeJS.ProcessEnv): string;
-export declare function runCommand(command: string, positional: string | undefined, flags: Record<string, string>, positionals?: string[], context?: CommandContext): Promise<number>;
-interface CommandDispatchResult {
-    exitCode: number;
-    apiKey?: string;
-}
-interface CliCommandDefinition extends CommandDefinition<CommandContext, CommandDispatchResult> {
-    validateConfigBeforeRun: boolean;
-    resetApiRequestCountBeforeRun: boolean;
-    telemetry: 'none' | 'result' | 'result-and-error';
-}
-export declare const commandRegistry: import("./command-registry.js").CommandRegistry<CommandContext, CommandDispatchResult, CliCommandDefinition>;
-export declare function classifyCliError(error: unknown): TelemetryErrorType;
-export declare function printCliError(error: unknown): void;
-export declare function dispatchParsedCommand(parsed: ParsedArgs, startedAt?: number): Promise<number>;
-//# sourceMappingURL=cli.d.ts.map

package/dist/command-context.d.ts

@@ -1,62 +0,0 @@
-import { type CliOutput, type CliOutputMode } from './output.js';
-export interface CommandContextInput {
-    command: string;
-    positional: string | undefined;
-    positionals: string[];
-    flags: Record<string, string>;
-}
-/**
- * Response-derived telemetry a handler can surface back to the dispatcher after
- * the API call completes. Static fields (surface, requested mode, query length,
- * etc.) are derived from the command + flags in the dispatcher and don't belong
- * here — only values that require the runtime response are recorded.
- */
-export interface CommandTelemetryMeta {
-    search_mode_effective?: 'na' | 'keyword' | 'semantic' | 'hybrid';
-    result_count?: number;
-    has_more?: 'na' | 'no' | 'yes';
-}
-export interface CommandContext {
-    command: string;
-    positional: string | undefined;
-    positionals: string[];
-    flags: Record<string, string>;
-    rawFlags: Record<string, string>;
-    startedAt: number;
-    cwd: string;
-    env: NodeJS.ProcessEnv;
-    outputMode: CliOutputMode;
-    output: CliOutput;
-    profile: string | undefined;
-    dryRun: boolean;
-    yes: boolean;
-    quiet: boolean;
-    verbose: boolean;
-    interactive: boolean;
-    /** Merge response-derived telemetry; safe to call multiple times. */
-    recordTelemetry(meta: Partial<CommandTelemetryMeta>): void;
-    /** Snapshot of telemetry recorded so far by the handler. */
-    getTelemetryMeta(): CommandTelemetryMeta;
-}
-/**
- * Normalize a raw flag/env value to a trimmed non-empty string. Accepts
- * non-string values because flagsToArgs number-coerces numeric-looking flag
- * values (which must never happen to tenant ids, profile names, or labels);
- * empty values (`--label=`) become undefined so defaults apply.
- */
-export declare function stringOption(value: unknown): string | undefined;
-export declare function createCommandContext(input: CommandContextInput, options?: {
-    commandName?: string;
-    commandFlags?: Record<string, string>;
-    rawFlags?: Record<string, string>;
-    startedAt?: number;
-    cwd?: string;
-    env?: NodeJS.ProcessEnv;
-    /**
-     * Pre-resolved output mode from the dispatcher (TTY/env auto-detection).
-     * When omitted we fall back to flag-only resolution so direct callers
-     * (tests, internal helpers) keep their explicit behavior.
-     */
-    outputMode?: CliOutputMode;
-}): CommandContext;
-//# sourceMappingURL=command-context.d.ts.map

package/dist/command-context.js

@@ -1,57 +0,0 @@
-import { createCliOutput, outputModeFromFlags } from './output.js';
-function flagEnabled(flags, key) {
-    return flags[key] === 'true';
-}
-/**
- * Normalize a raw flag/env value to a trimmed non-empty string. Accepts
- * non-string values because flagsToArgs number-coerces numeric-looking flag
- * values (which must never happen to tenant ids, profile names, or labels);
- * empty values (`--label=`) become undefined so defaults apply.
- */
-export function stringOption(value) {
-    if (value === undefined || value === null)
-        return undefined;
-    const text = String(value).trim();
-    return text.length > 0 ? text : undefined;
-}
-export function createCommandContext(input, options = {}) {
-    const flags = options.commandFlags ?? input.flags;
-    const rawFlags = options.rawFlags ?? input.flags;
-    const outputMode = options.outputMode ?? outputModeFromFlags(flags);
-    const quiet = flagEnabled(flags, 'quiet');
-    const interactive = outputMode === 'human' &&
-        !quiet &&
-        !flagEnabled(flags, 'yes') &&
-        process.stdin.isTTY === true &&
-        process.stderr.isTTY === true;
-    const telemetryMeta = {};
-    return {
-        command: options.commandName ?? input.command,
-        positional: input.positional,
-        positionals: input.positionals,
-        flags,
-        rawFlags,
-        startedAt: options.startedAt ?? Date.now(),
-        cwd: options.cwd ?? process.cwd(),
-        env: options.env ?? process.env,
-        outputMode,
-        output: createCliOutput({
-            command: options.commandName ?? input.command,
-            mode: outputMode,
-            quiet,
-        }),
-        profile: flags.profile,
-        dryRun: flagEnabled(flags, 'dry-run'),
-        yes: flagEnabled(flags, 'yes'),
-        quiet,
-        verbose: flagEnabled(flags, 'verbose'),
-        interactive,
-        recordTelemetry(meta) {
-            Object.assign(telemetryMeta, meta);
-        },
-        getTelemetryMeta() {
-            return telemetryMeta;
-        },
-    };
-}
-//# sourceMappingURL=command-context.js.map

package/dist/command-registry.d.ts

@@ -1,22 +0,0 @@
-import type { CliOutputMode } from './output.js';
-export type CommandAuthRequirement = 'none' | 'api-key';
-export type CommandMutability = 'read' | 'write';
-export interface CommandMetadata {
-    name: string;
-    aliases?: string[];
-    description: string;
-    examples: string[];
-    auth: CommandAuthRequirement;
-    outputModes: readonly CliOutputMode[];
-    mutability: CommandMutability;
-}
-export interface CommandDefinition<TContext, TResult> extends CommandMetadata {
-    handler: (context: TContext) => Promise<TResult>;
-}
-export interface CommandRegistry<TContext, TResult, TDefinition extends CommandDefinition<TContext, TResult> = CommandDefinition<TContext, TResult>> {
-    all(): TDefinition[];
-    find(name: string): TDefinition | undefined;
-    has(name: string): boolean;
-}
-export declare function createCommandRegistry<TContext, TResult, TDefinition extends CommandDefinition<TContext, TResult>>(definitions: TDefinition[]): CommandRegistry<TContext, TResult, TDefinition>;
-//# sourceMappingURL=command-registry.d.ts.map

package/dist/command-registry.js

@@ -1,15 +0,0 @@
-export function createCommandRegistry(definitions) {
-    const lookup = new Map();
-    for (const definition of definitions) {
-        lookup.set(definition.name, definition);
-        for (const alias of definition.aliases ?? []) {
-            lookup.set(alias, definition);
-        }
-    }
-    return {
-        all: () => [...definitions],
-        find: (name) => lookup.get(name),
-        has: (name) => lookup.has(name),
-    };
-}
-//# sourceMappingURL=command-registry.js.map

package/dist/config.d.ts

@@ -1,60 +0,0 @@
-import { type ProfileIOOptions } from './profiles.js';
-export declare const VERSION: string;
-export declare const MODA_BASE_URL: string;
-/**
- * Persisted CLI configuration written by `moda init` to `~/.moda/config.json`
- * (mode 0600). This lets the snapshot/session-end hook authenticate without
- * the user having to export MODA_API_KEY into whatever shell launched Claude
- * (e.g. via Infisical, a login shell, or a `.claude/settings.json` env block).
- * Mirrors the existing token persistence in `auth.ts`.
- */
-export interface CliConfig {
-    api_key?: string;
-    ingest_url?: string;
-    tenant_id?: string;
-}
-export declare function loadCliConfig(options?: ProfileIOOptions): CliConfig;
-/**
- * Merge-and-write the persisted config. Always chmod 0600 since it holds the
- * API key. Best-effort: never throws on chmod failure (some filesystems).
- * `options.profile` scopes the best-effort profile sync (e.g. `moda init
- * --profile staging`), so the key is synced to the requested profile rather
- * than whatever profile happens to be active.
- */
-export declare function saveCliConfig(update: CliConfig, options?: ProfileIOOptions): void;
-/**
- * Resolve the API key: prefer the environment (so CI / explicit exports win),
- * then fall back to the persisted `~/.moda/config.json`. Read lazily so a
- * long-lived process (or a test) sees the current value.
- */
-export declare function resolveApiKey(options?: ProfileIOOptions): string | undefined;
-/**
- * Signed CLI keys embed their tenant: the format is
- * moda_sk_<base64url("v1:keyId:tenantId:timestamp:signature")> — see
- * createApiKey/parseAndVerifySignedKey in
- * apps/moda-backend/src/api-keys/api-keys.service.ts. The server derives the
- * upload destination tenant from the key alone, so this is the only
- * client-side tenant source that matches where data actually lands
- * (config / MODA_TENANT_ID can disagree with a shadowing env key). The HMAC
- * signature can only be verified server-side; treat the result as
- * informational.
- */
-export declare function embeddedTenantIdFromApiKey(key: string): string | undefined;
-/**
- * Resolve the ingest worker base URL used by `moda workspace snapshot`.
- * Env override -> active profile -> legacy config -> production default.
- * Loopback URLs are rejected unless the active profile is `local`.
- */
-export declare function resolveIngestUrl(options?: ProfileIOOptions): string;
-/**
- * Resolve the active tenant id: env override first, then the persisted
- * `~/.moda/config.json` written by `moda init`. Used by the local dev
- * orchestrator hook so the user doesn't have to export MODA_TENANT_ID.
- */
-export declare function resolveTenantId(options?: ProfileIOOptions): string | undefined;
-export declare const MODA_API_KEY: string | undefined;
-export declare const MODA_INGEST_URL: string;
-export declare function resolveModaBaseUrl(options?: ProfileIOOptions): string;
-export declare function validateConfig(): void;
-export declare function legacyConfigPath(): string;
-//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -1,110 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { DEFAULT_INGEST_URL, PROD_BASE_URL, getLegacyConfigPath, loadLegacyCliConfig, resolveApiKeyFromActiveProfile, resolveBaseUrl, resolveIngestUrl as resolveProfileIngestUrl, resolveTenantIdFromActiveProfile, syncLegacyConfigToProfile, writeLegacyCliConfig, } from './profiles.js';
-import { CliAuthError } from './errors.js';
-const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
-export const VERSION = pkg.version;
-// Canonical host is moda.dev. The www host 308-redirects to the apex, and
-// cross-host redirects strip the Authorization header (fetch/undici), so using
-// www breaks `moda init`'s authenticated calls with a 401. Default to the
-// canonical host directly; resolveBaseUrl() also rewrites legacy www URLs.
-export const MODA_BASE_URL = resolveBaseUrl();
-export function loadCliConfig(options = {}) {
-    return loadLegacyCliConfig(options);
-}
-/**
- * Merge-and-write the persisted config. Always chmod 0600 since it holds the
- * API key. Best-effort: never throws on chmod failure (some filesystems).
- * `options.profile` scopes the best-effort profile sync (e.g. `moda init
- * --profile staging`), so the key is synced to the requested profile rather
- * than whatever profile happens to be active.
- */
-export function saveCliConfig(update, options = {}) {
-    const merged = writeLegacyCliConfig(update, options);
-    try {
-        syncLegacyConfigToProfile(merged, options);
-    }
-    catch {
-        // The legacy config write is the compatibility contract; profile sync is a
-        // best-effort migration aid until profile commands own the flow.
-    }
-}
-/**
- * Resolve the API key: prefer the environment (so CI / explicit exports win),
- * then fall back to the persisted `~/.moda/config.json`. Read lazily so a
- * long-lived process (or a test) sees the current value.
- */
-export function resolveApiKey(options = {}) {
-    const env = options.env ?? process.env;
-    return (env.MODA_API_KEY ||
-        resolveApiKeyFromActiveProfile(options) ||
-        loadCliConfig(options).api_key ||
-        undefined);
-}
-const SIGNED_API_KEY_PREFIX = 'moda_sk_';
-const SIGNED_API_KEY_VERSION = 'v1';
-/**
- * Signed CLI keys embed their tenant: the format is
- * moda_sk_<base64url("v1:keyId:tenantId:timestamp:signature")> — see
- * createApiKey/parseAndVerifySignedKey in
- * apps/moda-backend/src/api-keys/api-keys.service.ts. The server derives the
- * upload destination tenant from the key alone, so this is the only
- * client-side tenant source that matches where data actually lands
- * (config / MODA_TENANT_ID can disagree with a shadowing env key). The HMAC
- * signature can only be verified server-side; treat the result as
- * informational.
- */
-export function embeddedTenantIdFromApiKey(key) {
-    if (!key.startsWith(SIGNED_API_KEY_PREFIX))
-        return undefined;
-    try {
-        const decoded = Buffer.from(key.slice(SIGNED_API_KEY_PREFIX.length), 'base64url').toString('utf8');
-        // Expected format: version:keyId:tenantId:timestamp:signature
-        const parts = decoded.split(':');
-        if (parts.length !== 5 || parts[0] !== SIGNED_API_KEY_VERSION)
-            return undefined;
-        return parts[2] || undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Resolve the ingest worker base URL used by `moda workspace snapshot`.
- * Env override -> active profile -> legacy config -> production default.
- * Loopback URLs are rejected unless the active profile is `local`.
- */
-export function resolveIngestUrl(options = {}) {
-    return resolveProfileIngestUrl(options);
-}
-/**
- * Resolve the active tenant id: env override first, then the persisted
- * `~/.moda/config.json` written by `moda init`. Used by the local dev
- * orchestrator hook so the user doesn't have to export MODA_TENANT_ID.
- */
-export function resolveTenantId(options = {}) {
-    const env = options.env ?? process.env;
-    return (env.MODA_TENANT_ID ||
-        resolveTenantIdFromActiveProfile(options) ||
-        loadCliConfig(options).tenant_id ||
-        undefined);
-}
-// Back-compat exports. Prefer resolveApiKey()/resolveIngestUrl() for the lazy
-// file fallback; these only reflect the environment at module-load time.
-export const MODA_API_KEY = process.env.MODA_API_KEY;
-export const MODA_INGEST_URL = process.env.MODA_INGEST_URL || DEFAULT_INGEST_URL;
-export function resolveModaBaseUrl(options = {}) {
-    return resolveBaseUrl(options) || PROD_BASE_URL;
-}
-export function validateConfig() {
-    if (!resolveApiKey()) {
-        throw new CliAuthError('No Moda API key found. Set MODA_API_KEY or run "moda init".', {
-            reason: 'no_stored_credentials',
-            login_command: ['moda', 'init'],
-        }, 'Get your API key from https://moda.dev/settings');
-    }
-}
-// Kept for callers/tests that need the legacy path during migration.
-export function legacyConfigPath() {
-    return getLegacyConfigPath();
-}
-//# sourceMappingURL=config.js.map

package/dist/doctor.d.ts

@@ -1,79 +0,0 @@
-import type { CommandContext } from './command-context.js';
-export type DoctorCheckStatus = 'pass' | 'warning' | 'fail' | 'skipped';
-export type DoctorSeverity = 'info' | 'warning' | 'critical';
-export interface DoctorEvidence {
-    label: string;
-    value: string;
-}
-export interface DoctorCheck {
-    id: string;
-    group: string;
-    title: string;
-    status: DoctorCheckStatus;
-    severity: DoctorSeverity;
-    evidence: DoctorEvidence[];
-    remediation?: string;
-    nextCommand?: string;
-}
-export interface DoctorReport {
-    schemaVersion: 'doctor.v0.1';
-    generatedAt: string;
-    profile: {
-        active: string;
-        requested?: string;
-    };
-    summary: {
-        status: DoctorCheckStatus;
-        pass: number;
-        warning: number;
-        fail: number;
-        skipped: number;
-    };
-    checks: DoctorCheck[];
-    nextCommands: string[];
-    fixPlan: Array<{
-        checkId: string;
-        command?: string;
-        action: string;
-    }>;
-}
-export interface StatusPayload {
-    schemaVersion: 'status.v0.1';
-    generatedAt: string;
-    status: DoctorCheckStatus;
-    activeProfile: string;
-    auth: {
-        apiKey: 'configured' | 'missing';
-    };
-    workspace: {
-        tenantId: string | null;
-        baseUrl: string;
-        ingestUrl: string;
-    };
-    dataFlow: DoctorCheckStatus;
-    harness: DoctorCheckStatus;
-    harnessSync: DoctorCheckStatus;
-    harnessReport: DoctorCheckStatus;
-    shadowSpark: DoctorCheckStatus;
-    prompts: DoctorCheckStatus;
-    skills: DoctorCheckStatus;
-    topBrokenCheck: {
-        id: string;
-        status: DoctorCheckStatus;
-        severity: DoctorSeverity;
-        nextCommand?: string;
-    } | null;
-    nextCommands: string[];
-}
-interface DoctorOptions {
-    offline: boolean;
-}
-export declare function runDoctorCommand(context: CommandContext): Promise<{
-    exitCode: number;
-}>;
-export declare function runStatusCommand(context: CommandContext): Promise<{
-    exitCode: number;
-}>;
-export declare function buildDoctorReport(context: CommandContext, options: DoctorOptions): Promise<DoctorReport>;
-export {};
-//# sourceMappingURL=doctor.d.ts.map