@moda-ai/cli 1.22.1 → 1.23.0

package/dist/profile-commands.d.ts

@@ -1,10 +0,0 @@
-import type { CommandContext } from './command-context.js';
-type CommandResult = {
-    exitCode: number;
-};
-export declare function runAuthCommand(context: CommandContext): Promise<CommandResult>;
-export declare function runProfilesCommand(context: CommandContext): Promise<CommandResult>;
-export declare function runConfigCommand(context: CommandContext): Promise<CommandResult>;
-export declare function runKeysCommand(context: CommandContext): Promise<CommandResult>;
-export {};
-//# sourceMappingURL=profile-commands.d.ts.map

package/dist/profile-commands.js

@@ -1,342 +0,0 @@
-import { authFetch, clearAuthSession, isAuthSessionValid, loadAuthSession, login, revokeCliSessionToken, } from './auth.js';
-import { EXIT_AUTH_REQUIRED, EXIT_OK } from './output.js';
-import { KEY_LIFECYCLE_ENDPOINT_REQUIREMENTS, createLocalKeyDescriptor, loadLocalKeyDescriptors, upsertLocalKeyDescriptor, writeLocalApiKeySecret, } from './keys.js';
-import { DEFAULT_INGEST_URL, PROD_BASE_URL, clearStoredApiKeyCredentials, ensureSecretFilePermissions, getActiveProfile, getModaPaths, loadProfileConfig, resolveApiKeyFromActiveProfile, resolveSecretReference, secretFilePathFromRef, setActiveProfile, upsertProfile, } from './profiles.js';
-import { CliInputError } from './errors.js';
-// Bound the `auth status --online` probe: without a signal, undici's defaults
-// can stall a status check for minutes on a black-holed connection.
-const ONLINE_PROBE_TIMEOUT_MS = 5_000;
-function subcommand(context) {
-    return context.positionals[0];
-}
-function requirePositional(context, index, usage) {
-    const value = context.positionals[index];
-    if (!value)
-        throw new CliInputError('Missing required argument.', usage);
-    return value;
-}
-function flag(context, name) {
-    const value = context.flags[name];
-    return value && value !== 'true' ? value : undefined;
-}
-function boolFlag(context, name) {
-    return context.flags[name] === 'true';
-}
-function normalizeEnvironment(value) {
-    if (value === 'local' || value === 'dev' || value === 'staging' || value === 'prod') {
-        return value;
-    }
-    return 'prod';
-}
-function defaultBaseUrl(environment) {
-    if (environment === 'local')
-        return 'http://localhost:3000';
-    if (environment === 'staging')
-        return 'https://staging.moda.dev';
-    return PROD_BASE_URL;
-}
-function defaultIngestUrl(environment) {
-    if (environment === 'local')
-        return 'http://localhost:8787';
-    return DEFAULT_INGEST_URL;
-}
-function redactSecret(value) {
-    if (!value)
-        return undefined;
-    if (value.length <= 12)
-        return '<redacted>';
-    return `${value.slice(0, 8)}...${value.slice(-4)}`;
-}
-function serializeProfile(profile, activeProfile) {
-    return {
-        name: profile.name,
-        active: profile.name === activeProfile,
-        environment: profile.environment,
-        base_url: profile.base_url,
-        ingest_url: profile.ingest_url,
-        tenant_id: profile.tenant_id,
-        workspace_id: profile.workspace_id,
-        api_key_ref: profile.api_key_ref,
-        auth_token_ref: profile.auth_token_ref,
-    };
-}
-export async function runAuthCommand(context) {
-    switch (subcommand(context)) {
-        case 'login': {
-            const screen = flag(context, 'screen') === 'signup' ? 'signup' : 'login';
-            await login(screen, { profile: context.profile, env: context.env });
-            context.output.writeData({
-                status: 'authenticated',
-                profile: context.profile ?? process.env.MODA_PROFILE ?? null,
-            });
-            return { exitCode: 0 };
-        }
-        case 'logout': {
-            // moda_ct session tokens are server-side revocable: best-effort revoke
-            // (bounded, catch-all inside) before the local deletion. Legacy
-            // auth0-kind sessions have nothing to revoke.
-            await revokeCliSessionToken({ profile: context.profile, env: context.env });
-            clearAuthSession({ profile: context.profile, env: context.env });
-            // The session token is only the control-plane credential. Data commands
-            // authenticate with the moda_sk_ API key written by `moda init`
-            // (~/.moda/config.json + profile api_key_ref), so logout must clear it
-            // too or the next login keeps acting as the old tenant.
-            const apiKeyCleared = clearStoredApiKeyCredentials({
-                profile: context.profile,
-                env: context.env,
-            });
-            if (context.env.MODA_API_KEY) {
-                console.error('Note: MODA_API_KEY is set in the environment and still takes precedence. Unset it to fully sign out.');
-            }
-            context.output.writeData({
-                status: 'logged_out',
-                profile: context.profile ?? process.env.MODA_PROFILE ?? null,
-                api_key_cleared: apiKeyCleared,
-            });
-            return { exitCode: 0 };
-        }
-        case 'whoami': {
-            const session = loadAuthSession({ profile: context.profile, env: context.env });
-            if (!session) {
-                throw new CliInputError('Not authenticated.', 'Run "moda auth login" or "moda init".');
-            }
-            const response = await authFetch('/api/cli/context', {}, { profile: context.profile, env: context.env });
-            if (!response.ok) {
-                const body = await response.text();
-                throw new Error(`Failed to fetch auth context (${response.status}): ${body}`);
-            }
-            const data = await response.json();
-            context.output.writeData({
-                profile: context.profile ?? process.env.MODA_PROFILE ?? null,
-                session: {
-                    expires_at: session.expires_at,
-                    token_type: session.token_type ?? 'bearer',
-                },
-                context: data,
-            });
-            return { exitCode: 0 };
-        }
-        case 'status': {
-            // Being logged out is an expected state for `auth status`, not a
-            // failure: it must never throw CliAuthError (no error block, no error
-            // telemetry classification) and must never trigger a browser open. It
-            // reports clean data in every mode and signals session validity purely
-            // through the exit code (0 valid, 4 auth required).
-            const authOptions = { profile: context.profile, env: context.env };
-            const session = loadAuthSession({ ...authOptions, includeExpired: true });
-            const loggedIn = isAuthSessionValid(session);
-            const data = {
-                loggedIn,
-                profile: context.profile ??
-                    context.env.MODA_PROFILE ??
-                    session?.profile ??
-                    null,
-                expiresAt: session
-                    ? new Date(session.expires_at * 1000).toISOString()
-                    : null,
-            };
-            // `user` is emitted only when the stored session carries an email —
-            // the PKCE exchange path persists user_email; legacy sessions lack it.
-            if (session?.user_email) {
-                data.user = { email: session.user_email };
-            }
-            if (boolFlag(context, 'online')) {
-                let online = { reachable: false };
-                try {
-                    const response = await authFetch('/api/cli/context', { signal: AbortSignal.timeout(ONLINE_PROBE_TIMEOUT_MS) }, authOptions);
-                    // Any HTTP response means the server was reached; `ok` separates a
-                    // healthy 2xx from e.g. a 401/500.
-                    online = { reachable: true, ok: response.ok };
-                    if (response.ok) {
-                        const body = await response.json();
-                        if (Array.isArray(body.tenants)) {
-                            online.tenantCount = body.tenants.length;
-                        }
-                    }
-                }
-                catch {
-                    // Network failure, probe timeout, or no stored token to send: report
-                    // reachable: false; the exit code still follows local session
-                    // validity, never the online probe.
-                }
-                data.online = online;
-            }
-            context.output.writeData(data);
-            return { exitCode: loggedIn ? EXIT_OK : EXIT_AUTH_REQUIRED };
-        }
-        case 'token': {
-            const session = loadAuthSession({ profile: context.profile, env: context.env });
-            if (!session) {
-                if (context.flags.json === 'true') {
-                    // An explicit --json caller gets a parseable failure on stdout.
-                    process.stdout.write(`${JSON.stringify({ error: 'not_authenticated' })}\n`);
-                }
-                else {
-                    console.error('Not authenticated. Run "moda auth login".');
-                }
-                return { exitCode: EXIT_AUTH_REQUIRED };
-            }
-            // `auth token` exists to compose as $(moda auth token) and in pipes.
-            // Command substitution IS a pipe, so stdout is a non-TTY and this CLI
-            // would auto-select agent mode and wrap the token in a JSON envelope,
-            // breaking every composition. This command therefore deliberately
-            // bypasses the CliOutput envelope machinery in EVERY output mode
-            // (human/json/agent/agent-stream) and writes exactly the bare token plus
-            // a trailing newline to stdout — nothing else.
-            process.stdout.write(`${session.access_token}\n`);
-            return { exitCode: EXIT_OK };
-        }
-        default:
-            throw new CliInputError('Unknown auth command.', 'Usage: moda auth <login|logout|status|token|whoami>');
-    }
-}
-export async function runProfilesCommand(context) {
-    switch (subcommand(context)) {
-        case 'list': {
-            const config = loadProfileConfig({ env: context.env });
-            context.output.writeData({
-                active_profile: config.active_profile,
-                profiles: Object.values(config.profiles).map((profile) => serializeProfile(profile, config.active_profile)),
-                migrations: config.migrations,
-            });
-            return { exitCode: 0 };
-        }
-        case 'use': {
-            const name = requirePositional(context, 1, 'Usage: moda profiles use <name>');
-            const config = setActiveProfile(name, { env: context.env });
-            context.output.writeData({
-                active_profile: config.active_profile,
-                profile: serializeProfile(config.profiles[name], config.active_profile),
-            });
-            return { exitCode: 0 };
-        }
-        case 'create': {
-            const name = requirePositional(context, 1, 'Usage: moda profiles create <name>');
-            const environment = normalizeEnvironment(flag(context, 'environment') ?? name);
-            const profile = {
-                name,
-                environment,
-                base_url: flag(context, 'base-url') ?? defaultBaseUrl(environment),
-                ingest_url: flag(context, 'ingest-url') ?? defaultIngestUrl(environment),
-                tenant_id: flag(context, 'tenant-id'),
-                workspace_id: flag(context, 'workspace-id'),
-                api_key_ref: flag(context, 'api-key-ref'),
-                metadata: {
-                    created_at: new Date().toISOString(),
-                    source: 'profiles.create',
-                },
-            };
-            const config = upsertProfile(profile, { env: context.env });
-            const next = boolFlag(context, 'use')
-                ? setActiveProfile(name, { env: context.env })
-                : config;
-            context.output.writeData({
-                active_profile: next.active_profile,
-                profile: serializeProfile(next.profiles[name], next.active_profile),
-            });
-            return { exitCode: 0 };
-        }
-        case 'doctor': {
-            const requested = context.positionals[1];
-            const config = loadProfileConfig({ env: context.env });
-            const activeName = requested ?? context.profile ?? config.active_profile;
-            const profile = config.profiles[activeName];
-            if (!profile)
-                throw new CliInputError(`Moda profile '${activeName}' does not exist.`);
-            const secretPath = profile.api_key_ref ? secretFilePathFromRef(profile.api_key_ref) : undefined;
-            const permission = secretPath ? ensureSecretFilePermissions(secretPath) : undefined;
-            context.output.writeData({
-                profile: serializeProfile(profile, config.active_profile),
-                checks: [
-                    { id: 'profile_exists', status: 'pass' },
-                    {
-                        id: 'api_key_available',
-                        status: resolveSecretReference(profile.api_key_ref) ? 'pass' : 'warning',
-                    },
-                    {
-                        id: 'tenant_selected',
-                        status: profile.tenant_id ? 'pass' : 'warning',
-                    },
-                    ...(permission
-                        ? [{
-                                id: 'secret_file_permissions',
-                                status: permission.secure ? 'pass' : 'fail',
-                                details: permission,
-                            }]
-                        : []),
-                ],
-            });
-            return { exitCode: 0 };
-        }
-        default:
-            throw new CliInputError('Unknown profiles command.', 'Usage: moda profiles <list|use|create|doctor>');
-    }
-}
-export async function runConfigCommand(context) {
-    if (subcommand(context) !== 'show') {
-        throw new CliInputError('Unknown config command.', 'Usage: moda config show');
-    }
-    const config = loadProfileConfig({ env: context.env });
-    const profile = getActiveProfile({ profile: context.profile, env: context.env });
-    context.output.writeData({
-        moda_dir: getModaPaths({ env: context.env }).dir,
-        active_profile: profile.name,
-        profile: serializeProfile(profile, config.active_profile),
-        resolved: {
-            api_key: redactSecret(resolveApiKeyFromActiveProfile({ profile: profile.name, env: context.env })),
-            base_url: profile.base_url,
-            ingest_url: profile.ingest_url,
-            tenant_id: profile.tenant_id,
-            workspace_id: profile.workspace_id,
-        },
-        migrations: config.migrations,
-    });
-    return { exitCode: 0 };
-}
-export async function runKeysCommand(context) {
-    switch (subcommand(context)) {
-        case 'list': {
-            const profile = context.profile ?? loadProfileConfig({ env: context.env }).active_profile;
-            const keys = loadLocalKeyDescriptors({ env: context.env })
-                .filter((key) => !profile || key.profile === profile);
-            context.output.writeData({
-                profile,
-                keys,
-                endpoint_requirements: KEY_LIFECYCLE_ENDPOINT_REQUIREMENTS,
-            });
-            return { exitCode: 0 };
-        }
-        case 'create': {
-            const active = getActiveProfile({ profile: context.profile, env: context.env });
-            const name = flag(context, 'name') ?? `${active.name}-${Date.now()}`;
-            const descriptor = createLocalKeyDescriptor({
-                profile: active.name,
-                environment: active.environment,
-                name,
-                purpose: 'data_api',
-                tenant_id: active.tenant_id,
-                workspace_id: active.workspace_id,
-            });
-            const value = flag(context, 'value');
-            const secretPath = value
-                ? writeLocalApiKeySecret(descriptor, value, { env: context.env })
-                : undefined;
-            upsertLocalKeyDescriptor(descriptor, { env: context.env });
-            context.output.writeData({
-                key: descriptor,
-                secret_path: secretPath,
-                endpoint_requirements: KEY_LIFECYCLE_ENDPOINT_REQUIREMENTS.create,
-            });
-            return { exitCode: 0 };
-        }
-        case 'rotate':
-        case 'revoke': {
-            const action = subcommand(context);
-            const keyId = requirePositional(context, 1, `Usage: moda keys ${action} <key_id>`);
-            throw new CliInputError(`moda keys ${action} is waiting on Moda Cloud key lifecycle support for ${keyId}.`, `Required endpoint: ${KEY_LIFECYCLE_ENDPOINT_REQUIREMENTS[action]}`);
-        }
-        default:
-            throw new CliInputError('Unknown keys command.', 'Usage: moda keys <list|create|rotate|revoke>');
-    }
-}
-//# sourceMappingURL=profile-commands.js.map

package/dist/profiles.d.ts

@@ -1,112 +0,0 @@
-export declare const PROFILE_CONFIG_VERSION = 1;
-export declare const PROD_BASE_URL = "https://moda.dev";
-export declare const DEFAULT_INGEST_URL = "https://moda-ingest.modas.workers.dev";
-export declare const DEFAULT_PROFILE_NAME = "prod";
-export type ModaEnvironment = 'local' | 'dev' | 'staging' | 'prod';
-export type SecretReference = `env:${string}` | `file:${string}` | 'legacy:config.api_key' | 'legacy:auth.access_token';
-export interface LegacyCliConfig {
-    api_key?: string;
-    ingest_url?: string;
-    tenant_id?: string;
-}
-export interface ModaProfile {
-    name: string;
-    environment: ModaEnvironment;
-    base_url: string;
-    ingest_url?: string;
-    tenant_id?: string;
-    workspace_id?: string;
-    api_key_ref?: SecretReference;
-    auth_token_ref?: SecretReference;
-    metadata?: Record<string, unknown>;
-}
-export interface ProfileMigrationState {
-    legacy_config: {
-        path: string;
-        present: boolean;
-        has_api_key: boolean;
-        has_ingest_url: boolean;
-        has_tenant_id: boolean;
-    };
-    legacy_auth: {
-        path: string;
-        present: boolean;
-        has_access_token: boolean;
-        expires_at?: number;
-        expired?: boolean;
-    };
-}
-export interface ProfileConfig {
-    version: typeof PROFILE_CONFIG_VERSION;
-    active_profile: string;
-    profiles: Record<string, ModaProfile>;
-    migrations: ProfileMigrationState;
-}
-export interface ProfileIOOptions {
-    home?: string;
-    profile?: string;
-    now?: Date;
-    env?: NodeJS.ProcessEnv;
-}
-export interface ModaPaths {
-    home: string;
-    dir: string;
-    legacyConfigPath: string;
-    legacyAuthPath: string;
-    profileConfigPath: string;
-    secretsDir: string;
-}
-export interface SecretFilePermissionStatus {
-    path: string;
-    exists: boolean;
-    secure: boolean;
-    repaired: boolean;
-    mode?: string;
-    reason?: string;
-}
-export declare function resolveModaHome(options?: ProfileIOOptions): string;
-export declare function getModaPaths(options?: ProfileIOOptions): ModaPaths;
-export declare function getModaDir(options?: ProfileIOOptions): string;
-export declare function getLegacyConfigPath(options?: ProfileIOOptions): string;
-export declare function loadLegacyCliConfig(options?: ProfileIOOptions): LegacyCliConfig;
-export declare function writeLegacyCliConfig(update: LegacyCliConfig, options?: ProfileIOOptions): LegacyCliConfig;
-export declare function createDefaultProfiles(options?: ProfileIOOptions): Record<string, ModaProfile>;
-export declare function isLoopbackBaseUrl(url: string): boolean;
-export declare function assertValidProfileName(name: string): void;
-export declare function inspectProfileMigrationState(options?: ProfileIOOptions): ProfileMigrationState;
-export declare function loadProfileConfig(options?: ProfileIOOptions): ProfileConfig;
-export declare function saveProfileConfig(config: ProfileConfig, options?: ProfileIOOptions): void;
-export declare function getActiveProfile(options?: ProfileIOOptions): ModaProfile;
-export declare function setActiveProfile(name: string, options?: ProfileIOOptions): ProfileConfig;
-export declare function upsertProfile(profile: ModaProfile, options?: ProfileIOOptions): ProfileConfig;
-export declare function syncLegacyConfigToProfile(legacy: LegacyCliConfig, options?: ProfileIOOptions): ProfileConfig;
-/**
- * Forget the stored data-plane credentials (`moda_sk_` API key + tenant
- * binding written by `moda init`): the legacy config's api_key/tenant_id and
- * the target profile's api_key_ref/tenant_id, deleting `file:` key secrets
- * under ~/.moda. Called by `moda auth logout` — without this, analytics
- * commands keep authenticating as the old tenant after a re-login, because
- * they use the x-api-key plane, not the session token. MODA_API_KEY in the
- * environment still wins at resolve time.
- *
- * The legacy config must be cleared BEFORE reading the profile config:
- * applyLegacyAwareness re-derives api_key_ref onto the prod profile on every
- * load while config.json still holds an api_key.
- */
-export declare function clearStoredApiKeyCredentials(options?: ProfileIOOptions): boolean;
-export declare function secretFilePathFromRef(reference: SecretReference, options?: ProfileIOOptions): string | undefined;
-export declare function resolveSecretReference(reference: SecretReference | undefined, options?: ProfileIOOptions): string | undefined;
-export declare function resolveApiKeyFromActiveProfile(options?: ProfileIOOptions): string | undefined;
-/**
- * Vercel serves moda.dev as canonical and 308-redirects www to the apex. Node
- * fetch strips Authorization on cross-host redirects, which breaks moda init
- * step 3 when the base URL still points at www.
- */
-export declare function normalizeModaBaseUrl(url: string): string;
-export declare function resolveBaseUrl(options?: ProfileIOOptions): string;
-export declare function resolveIngestUrl(options?: ProfileIOOptions): string;
-export declare function resolveIngestUrlFromActiveProfile(options?: ProfileIOOptions): string | undefined;
-export declare function resolveTenantIdFromActiveProfile(options?: ProfileIOOptions): string | undefined;
-export declare function ensureSecretFilePermissions(path: string, repair?: boolean): SecretFilePermissionStatus;
-export declare function writeSecretJsonFile(path: string, value: unknown): void;
-//# sourceMappingURL=profiles.d.ts.map