@moda-ai/cli 1.1.1 → 1.2.0

package/dist/profiles.js

@@ -0,0 +1,432 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, normalize, relative } from 'node:path';
+export const PROFILE_CONFIG_VERSION = 1;
+export const PROD_BASE_URL = 'https://www.moda.dev';
+export const DEFAULT_INGEST_URL = 'https://moda-ingest.modas.workers.dev';
+export const DEFAULT_PROFILE_NAME = 'prod';
+function getEnv(options = {}) {
+    return options.env ?? process.env;
+}
+export function resolveModaHome(options = {}) {
+    const env = getEnv(options);
+    return options.home || env.HOME || env.USERPROFILE || homedir();
+}
+export function getModaPaths(options = {}) {
+    const home = resolveModaHome(options);
+    const dir = join(home, '.moda');
+    return {
+        home,
+        dir,
+        legacyConfigPath: join(dir, 'config.json'),
+        legacyAuthPath: join(dir, 'auth.json'),
+        profileConfigPath: join(dir, 'profiles.json'),
+        secretsDir: join(dir, 'secrets'),
+    };
+}
+export function getModaDir(options = {}) {
+    return getModaPaths(options).dir;
+}
+export function getLegacyConfigPath(options = {}) {
+    return getModaPaths(options).legacyConfigPath;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function optionalString(value) {
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+function readJsonFile(path) {
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+function safeReadRecord(path) {
+    try {
+        if (!existsSync(path))
+            return undefined;
+        const parsed = readJsonFile(path);
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function loadLegacyCliConfig(options = {}) {
+    const parsed = safeReadRecord(getModaPaths(options).legacyConfigPath);
+    if (!parsed)
+        return {};
+    return {
+        api_key: optionalString(parsed.api_key),
+        ingest_url: optionalString(parsed.ingest_url),
+        tenant_id: optionalString(parsed.tenant_id),
+    };
+}
+export function writeLegacyCliConfig(update, options = {}) {
+    const paths = getModaPaths(options);
+    mkdirSync(paths.dir, { recursive: true });
+    const merged = { ...loadLegacyCliConfig(options), ...update };
+    writeSecretJsonFile(paths.legacyConfigPath, merged);
+    return merged;
+}
+function profileDefaults(name, environment, now) {
+    const local = environment === 'local';
+    const staging = environment === 'staging';
+    return {
+        name,
+        environment,
+        base_url: local
+            ? 'http://localhost:3000'
+            : staging
+                ? 'https://staging.moda.dev'
+                : PROD_BASE_URL,
+        ingest_url: local ? 'http://localhost:8787' : DEFAULT_INGEST_URL,
+        metadata: {
+            created_at: now.toISOString(),
+            source: 'default',
+        },
+    };
+}
+export function createDefaultProfiles(options = {}) {
+    const now = options.now ?? new Date();
+    return {
+        local: profileDefaults('local', 'local', now),
+        staging: profileDefaults('staging', 'staging', now),
+        prod: profileDefaults('prod', 'prod', now),
+    };
+}
+function normalizeEnvironment(value) {
+    if (value === 'local' ||
+        value === 'dev' ||
+        value === 'staging' ||
+        value === 'prod') {
+        return value;
+    }
+    return 'prod';
+}
+function isSecretReference(value) {
+    return (value.startsWith('env:') ||
+        value.startsWith('file:') ||
+        value === 'legacy:config.api_key' ||
+        value === 'legacy:auth.access_token');
+}
+function normalizeSecretReference(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    return isSecretReference(value) ? value : undefined;
+}
+export function assertValidProfileName(name) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(name)) {
+        throw new Error(`Invalid profile name '${name}'. Use letters, numbers, dots, dashes, or underscores.`);
+    }
+}
+function normalizeProfile(fallbackName, value, options) {
+    if (!isRecord(value))
+        return undefined;
+    const name = optionalString(value.name) ?? fallbackName;
+    try {
+        assertValidProfileName(name);
+    }
+    catch {
+        return undefined;
+    }
+    const defaults = profileDefaults(name, normalizeEnvironment(value.environment), options.now ?? new Date());
+    return {
+        ...defaults,
+        base_url: optionalString(value.base_url) ?? defaults.base_url,
+        ingest_url: optionalString(value.ingest_url) ?? defaults.ingest_url,
+        tenant_id: optionalString(value.tenant_id),
+        workspace_id: optionalString(value.workspace_id),
+        api_key_ref: normalizeSecretReference(value.api_key_ref),
+        auth_token_ref: normalizeSecretReference(value.auth_token_ref),
+        metadata: isRecord(value.metadata) ? value.metadata : defaults.metadata,
+    };
+}
+function inspectLegacyAuth(path) {
+    const parsed = safeReadRecord(path);
+    const expiresAt = typeof parsed?.expires_at === 'number' ? parsed.expires_at : undefined;
+    return {
+        path,
+        present: Boolean(parsed),
+        has_access_token: typeof parsed?.access_token === 'string',
+        expires_at: expiresAt,
+        expired: expiresAt === undefined ? undefined : Date.now() / 1000 > expiresAt - 60,
+    };
+}
+export function inspectProfileMigrationState(options = {}) {
+    const paths = getModaPaths(options);
+    const legacyConfig = loadLegacyCliConfig(options);
+    return {
+        legacy_config: {
+            path: paths.legacyConfigPath,
+            present: existsSync(paths.legacyConfigPath),
+            has_api_key: Boolean(legacyConfig.api_key),
+            has_ingest_url: Boolean(legacyConfig.ingest_url),
+            has_tenant_id: Boolean(legacyConfig.tenant_id),
+        },
+        legacy_auth: inspectLegacyAuth(paths.legacyAuthPath),
+    };
+}
+function applyLegacyAwareness(config, options) {
+    const legacy = loadLegacyCliConfig(options);
+    const migration = inspectProfileMigrationState(options);
+    const prod = config.profiles.prod;
+    if (prod && (legacy.api_key || legacy.ingest_url || legacy.tenant_id)) {
+        config.profiles.prod = {
+            ...prod,
+            ingest_url: legacy.ingest_url ?? prod.ingest_url,
+            tenant_id: legacy.tenant_id ?? prod.tenant_id,
+            api_key_ref: legacy.api_key ? 'legacy:config.api_key' : prod.api_key_ref,
+            auth_token_ref: migration.legacy_auth.has_access_token
+                ? 'legacy:auth.access_token'
+                : prod.auth_token_ref,
+            metadata: {
+                ...prod.metadata,
+                source: 'migration',
+                legacy_config_path: migration.legacy_config.path,
+                legacy_auth_path: migration.legacy_auth.path,
+            },
+        };
+    }
+    return {
+        ...config,
+        migrations: migration,
+    };
+}
+function normalizeProfileConfig(raw, options = {}) {
+    const profiles = createDefaultProfiles(options);
+    let activeProfile = DEFAULT_PROFILE_NAME;
+    if (isRecord(raw)) {
+        if (isRecord(raw.profiles)) {
+            for (const [name, profile] of Object.entries(raw.profiles)) {
+                const normalized = normalizeProfile(name, profile, options);
+                if (normalized)
+                    profiles[normalized.name] = normalized;
+            }
+        }
+        const configuredActive = optionalString(raw.active_profile);
+        if (configuredActive && profiles[configuredActive]) {
+            activeProfile = configuredActive;
+        }
+    }
+    return applyLegacyAwareness({
+        version: PROFILE_CONFIG_VERSION,
+        active_profile: activeProfile,
+        profiles,
+        migrations: inspectProfileMigrationState(options),
+    }, options);
+}
+export function loadProfileConfig(options = {}) {
+    const path = getModaPaths(options).profileConfigPath;
+    const parsed = safeReadRecord(path);
+    return normalizeProfileConfig(parsed, options);
+}
+export function saveProfileConfig(config, options = {}) {
+    const active = config.active_profile || DEFAULT_PROFILE_NAME;
+    if (!config.profiles[active]) {
+        throw new Error(`Cannot activate missing profile '${active}'.`);
+    }
+    const path = getModaPaths(options).profileConfigPath;
+    writeSecretJsonFile(path, {
+        version: PROFILE_CONFIG_VERSION,
+        active_profile: active,
+        profiles: config.profiles,
+        migrations: inspectProfileMigrationState(options),
+    });
+}
+export function getActiveProfile(options = {}) {
+    const config = loadProfileConfig(options);
+    const envProfile = optionalString(getEnv(options).MODA_PROFILE);
+    const requested = options.profile || envProfile || config.active_profile;
+    const profile = config.profiles[requested];
+    if (!profile) {
+        throw new Error(`Moda profile '${requested}' does not exist.`);
+    }
+    return profile;
+}
+export function setActiveProfile(name, options = {}) {
+    assertValidProfileName(name);
+    const config = loadProfileConfig(options);
+    if (!config.profiles[name]) {
+        throw new Error(`Moda profile '${name}' does not exist.`);
+    }
+    const next = { ...config, active_profile: name };
+    saveProfileConfig(next, options);
+    return next;
+}
+export function upsertProfile(profile, options = {}) {
+    assertValidProfileName(profile.name);
+    const config = loadProfileConfig(options);
+    const next = {
+        ...config,
+        profiles: {
+            ...config.profiles,
+            [profile.name]: {
+                ...profile,
+                metadata: {
+                    ...profile.metadata,
+                    updated_at: (options.now ?? new Date()).toISOString(),
+                },
+            },
+        },
+    };
+    saveProfileConfig(next, options);
+    return next;
+}
+export function syncLegacyConfigToProfile(legacy, options = {}) {
+    const active = getActiveProfile(options);
+    return upsertProfile({
+        ...active,
+        ingest_url: legacy.ingest_url ?? active.ingest_url,
+        tenant_id: legacy.tenant_id ?? active.tenant_id,
+        api_key_ref: legacy.api_key ? 'legacy:config.api_key' : active.api_key_ref,
+        metadata: {
+            ...active.metadata,
+            source: 'migration',
+            legacy_config_path: getModaPaths(options).legacyConfigPath,
+        },
+    }, options);
+}
+function resolveFileSecretPath(reference, options) {
+    if (!reference.startsWith('file:'))
+        return undefined;
+    const rawPath = reference.slice('file:'.length);
+    if (!rawPath)
+        return undefined;
+    const paths = getModaPaths(options);
+    const secretPath = isAbsolute(rawPath)
+        ? normalize(rawPath)
+        : normalize(join(paths.dir, rawPath));
+    const rel = relative(paths.dir, secretPath);
+    if (rel.startsWith('..') || isAbsolute(rel)) {
+        throw new Error(`Secret reference escapes the Moda directory: ${reference}`);
+    }
+    return secretPath;
+}
+export function secretFilePathFromRef(reference, options = {}) {
+    return resolveFileSecretPath(reference, options);
+}
+export function resolveSecretReference(reference, options = {}) {
+    if (!reference)
+        return undefined;
+    const env = getEnv(options);
+    if (reference.startsWith('env:')) {
+        return env[reference.slice('env:'.length)] || undefined;
+    }
+    if (reference === 'legacy:config.api_key') {
+        return loadLegacyCliConfig(options).api_key;
+    }
+    if (reference === 'legacy:auth.access_token') {
+        const parsed = safeReadRecord(getModaPaths(options).legacyAuthPath);
+        return optionalString(parsed?.access_token);
+    }
+    const filePath = resolveFileSecretPath(reference, options);
+    if (!filePath)
+        return undefined;
+    const parsed = safeReadRecord(filePath);
+    if (parsed) {
+        return (optionalString(parsed.value) ??
+            optionalString(parsed.api_key) ??
+            optionalString(parsed.access_token));
+    }
+    try {
+        const raw = readFileSync(filePath, 'utf8').trim();
+        return raw || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resolveApiKeyFromActiveProfile(options = {}) {
+    try {
+        return resolveSecretReference(getActiveProfile(options).api_key_ref, options);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resolveBaseUrl(options = {}) {
+    const envBase = optionalString(getEnv(options).MODA_BASE_URL);
+    if (envBase)
+        return envBase;
+    try {
+        return getActiveProfile(options).base_url || PROD_BASE_URL;
+    }
+    catch {
+        return PROD_BASE_URL;
+    }
+}
+export function resolveIngestUrlFromActiveProfile(options = {}) {
+    try {
+        return getActiveProfile(options).ingest_url;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resolveTenantIdFromActiveProfile(options = {}) {
+    try {
+        return getActiveProfile(options).tenant_id;
+    }
+    catch {
+        return undefined;
+    }
+}
+function modeString(mode) {
+    return `0${(mode & 0o777).toString(8).padStart(3, '0')}`;
+}
+export function ensureSecretFilePermissions(path, repair = true) {
+    if (!existsSync(path)) {
+        return { path, exists: false, secure: false, repaired: false };
+    }
+    const before = statSync(path);
+    if (!before.isFile()) {
+        return {
+            path,
+            exists: true,
+            secure: false,
+            repaired: false,
+            mode: modeString(before.mode),
+            reason: 'not_file',
+        };
+    }
+    if ((before.mode & 0o077) !== 0 && repair) {
+        try {
+            chmodSync(path, 0o600);
+            const after = statSync(path);
+            return {
+                path,
+                exists: true,
+                secure: (after.mode & 0o077) === 0,
+                repaired: true,
+                mode: modeString(after.mode),
+            };
+        }
+        catch {
+            return {
+                path,
+                exists: true,
+                secure: false,
+                repaired: false,
+                mode: modeString(before.mode),
+                reason: 'chmod_failed',
+            };
+        }
+    }
+    return {
+        path,
+        exists: true,
+        secure: (before.mode & 0o077) === 0,
+        repaired: false,
+        mode: modeString(before.mode),
+    };
+}
+export function writeSecretJsonFile(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        // Some filesystems do not support chmod; write mode covers the common case.
+    }
+}
+//# sourceMappingURL=profiles.js.map

package/dist/prompts.d.ts

@@ -0,0 +1,6 @@
+import type { ProfileIOOptions } from './profiles.js';
+export declare function runPromptsCommand(positionals: string[], flags: Record<string, string>, profileOptions?: ProfileIOOptions): Promise<void>;
+export declare function initPrompts(options?: {
+    silent?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=prompts.d.ts.map