@moda-ai/cli 1.1.1 → 1.2.0

package/dist/profile-commands.d.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,252 @@
+import { authFetch, clearAuthSession, loadAuthSession, login } from './auth.js';
+import { KEY_LIFECYCLE_ENDPOINT_REQUIREMENTS, createLocalKeyDescriptor, loadLocalKeyDescriptors, upsertLocalKeyDescriptor, writeLocalApiKeySecret, } from './keys.js';
+import { DEFAULT_INGEST_URL, PROD_BASE_URL, ensureSecretFilePermissions, getActiveProfile, getModaPaths, loadProfileConfig, resolveApiKeyFromActiveProfile, resolveSecretReference, secretFilePathFromRef, setActiveProfile, upsertProfile, } from './profiles.js';
+import { CliInputError } from './errors.js';
+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);
+            context.output.writeData({
+                status: 'authenticated',
+                profile: context.profile ?? process.env.MODA_PROFILE ?? null,
+            });
+            return { exitCode: 0 };
+        }
+        case 'logout': {
+            clearAuthSession({ profile: context.profile, env: context.env });
+            context.output.writeData({
+                status: 'logged_out',
+                profile: context.profile ?? process.env.MODA_PROFILE ?? null,
+            });
+            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 };
+        }
+        default:
+            throw new CliInputError('Unknown auth command.', 'Usage: moda auth <login|logout|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

@@ -0,0 +1,90 @@
+export declare const PROFILE_CONFIG_VERSION = 1;
+export declare const PROD_BASE_URL = "https://www.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 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;
+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;
+export declare function resolveBaseUrl(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