@moda-ai/cli 1.1.1 → 1.2.0

package/dist/command-context.d.ts

@@ -0,0 +1,34 @@
+import { type CliOutput, type CliOutputMode } from './output.js';
+export interface CommandContextInput {
+    command: string;
+    positional: string | undefined;
+    positionals: string[];
+    flags: Record<string, string>;
+}
+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;
+}
+export declare function createCommandContext(input: CommandContextInput, options?: {
+    commandName?: string;
+    commandFlags?: Record<string, string>;
+    rawFlags?: Record<string, string>;
+    startedAt?: number;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): CommandContext;
+//# sourceMappingURL=command-context.d.ts.map

package/dist/command-context.js

@@ -0,0 +1,38 @@
+import { createCliOutput, outputModeFromFlags } from './output.js';
+function flagEnabled(flags, key) {
+    return flags[key] === 'true';
+}
+export function createCommandContext(input, options = {}) {
+    const flags = options.commandFlags ?? input.flags;
+    const rawFlags = options.rawFlags ?? input.flags;
+    const outputMode = outputModeFromFlags(flags);
+    const quiet = flagEnabled(flags, 'quiet');
+    const interactive = outputMode === 'human' &&
+        !quiet &&
+        !flagEnabled(flags, 'yes') &&
+        process.stdin.isTTY === true &&
+        process.stderr.isTTY === true;
+    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,
+    };
+}
+//# sourceMappingURL=command-context.js.map

package/dist/command-registry.d.ts

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

@@ -0,0 +1,15 @@
+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,5 +1,44 @@
+import { type ProfileIOOptions } from './profiles.js';
 export declare const VERSION: string;
-export declare const MODA_API_KEY: string | undefined;
 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).
+ */
+export declare function saveCliConfig(update: CliConfig): 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;
+/**
+ * Resolve the ingest worker base URL used by `moda workspace snapshot`.
+ * Env override -> persisted config -> production default.
+ */
+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,13 +1,80 @@
 import { readFileSync } from 'node:fs';
+import { DEFAULT_INGEST_URL, PROD_BASE_URL, getLegacyConfigPath, loadLegacyCliConfig, resolveApiKeyFromActiveProfile, resolveBaseUrl, resolveIngestUrlFromActiveProfile, resolveTenantIdFromActiveProfile, syncLegacyConfigToProfile, writeLegacyCliConfig, } from './profiles.js';
 const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 export const VERSION = pkg.version;
+// Canonical host is www.moda.dev. The apex `moda.dev` 308-redirects to it, and
+// cross-host redirects strip the Authorization header (fetch/undici), so using
+// the apex breaks `moda init`'s authenticated calls with a 401. Default to the
+// canonical host directly.
+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).
+ */
+export function saveCliConfig(update) {
+    const merged = writeLegacyCliConfig(update);
+    try {
+        syncLegacyConfigToProfile(merged);
+    }
+    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);
+}
+/**
+ * Resolve the ingest worker base URL used by `moda workspace snapshot`.
+ * Env override -> persisted config -> production default.
+ */
+export function resolveIngestUrl(options = {}) {
+    const env = options.env ?? process.env;
+    return (env.MODA_INGEST_URL ||
+        resolveIngestUrlFromActiveProfile(options) ||
+        loadCliConfig(options).ingest_url ||
+        DEFAULT_INGEST_URL);
+}
+/**
+ * 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_BASE_URL = process.env.MODA_BASE_URL || 'https://moda.dev';
+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 (!MODA_API_KEY) {
-        console.error('Error: MODA_API_KEY environment variable is required');
+    if (!resolveApiKey()) {
+        console.error('Error: no Moda API key found. Set MODA_API_KEY or run "moda init".');
         console.error('Get your API key from https://moda.dev/settings');
         process.exit(1);
     }
 }
+// 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

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