@eve-horizon/cli 0.0.1 → 0.1.0

package/dist/commands/auth.js

@@ -1,12 +1,51 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleAuth = handleAuth;
 const args_1 = require("../lib/args");
 const config_1 = require("../lib/config");
 const client_1 = require("../lib/client");
 const output_1 = require("../lib/output");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const readline = __importStar(require("node:readline/promises"));
 async function handleAuth(subcommand, flags, context, credentials) {
     const json = Boolean(flags.json);
+    const noInteractive = (0, args_1.getBooleanFlag)(flags, ['no-interactive']) ?? false;
     switch (subcommand) {
         case 'login': {
             const status = await (0, client_1.requestRaw)(context, '/auth/me', { allowError: true, tokenOverride: '' });
@@ -17,58 +56,92 @@ async function handleAuth(subcommand, flags, context, credentials) {
                     return;
                 }
             }
-            const email = (0, args_1.getStringFlag)(flags, ['email']) ?? process.env.EVE_AUTH_EMAIL;
+            const email = (0, args_1.getStringFlag)(flags, ['email']) ?? process.env.EVE_AUTH_EMAIL ?? context.profile.default_email;
+            const userId = (0, args_1.getStringFlag)(flags, ['user-id']);
             const password = (0, args_1.getStringFlag)(flags, ['password']) ?? process.env.EVE_AUTH_PASSWORD;
-            if (!email || !password) {
-                throw new Error('Usage: eve auth login --email <email> --password <password>');
-            }
             const supabaseUrl = (0, args_1.getStringFlag)(flags, ['supabase-url']) ||
                 process.env.EVE_SUPABASE_URL ||
                 context.profile.supabase_url;
             const supabaseAnonKey = (0, args_1.getStringFlag)(flags, ['supabase-anon-key']) ||
                 process.env.EVE_SUPABASE_ANON_KEY ||
                 context.profile.supabase_anon_key;
-            if (!supabaseUrl || !supabaseAnonKey) {
-                throw new Error('Missing Supabase config. Provide --supabase-url and --supabase-anon-key.');
-            }
-            const loginResponse = await fetch(`${supabaseUrl}/auth/v1/token?grant_type=password`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    apikey: supabaseAnonKey,
-                    Authorization: `Bearer ${supabaseAnonKey}`,
-                },
-                body: JSON.stringify({ email, password }),
-            });
-            const loginText = await loginResponse.text();
-            let loginData = null;
-            if (loginText) {
-                try {
-                    loginData = JSON.parse(loginText);
+            const useSupabase = Boolean(password);
+            if (useSupabase) {
+                if (!email || !password) {
+                    throw new Error('Usage: eve auth login --email <email> --password <password>');
                 }
-                catch {
-                    loginData = loginText;
+                if (!supabaseUrl || !supabaseAnonKey) {
+                    throw new Error('Missing Supabase config. Provide --supabase-url and --supabase-anon-key.');
                 }
+                const loginResponse = await fetch(`${supabaseUrl}/auth/v1/token?grant_type=password`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        apikey: supabaseAnonKey,
+                        Authorization: `Bearer ${supabaseAnonKey}`,
+                    },
+                    body: JSON.stringify({ email, password }),
+                });
+                const loginText = await loginResponse.text();
+                let loginData = null;
+                if (loginText) {
+                    try {
+                        loginData = JSON.parse(loginText);
+                    }
+                    catch {
+                        loginData = loginText;
+                    }
+                }
+                if (!loginResponse.ok || !loginData || typeof loginData !== 'object') {
+                    throw new Error(`Supabase login failed: ${loginText}`);
+                }
+                const payload = loginData;
+                if (!payload.access_token) {
+                    throw new Error('Supabase login response missing access_token');
+                }
+                const expiresAt = payload.expires_in
+                    ? Math.floor(Date.now() / 1000) + payload.expires_in
+                    : undefined;
+                credentials.profiles[context.profileName] = {
+                    access_token: payload.access_token,
+                    refresh_token: payload.refresh_token,
+                    expires_at: expiresAt,
+                    token_type: payload.token_type,
+                };
+                (0, config_1.saveCredentials)(credentials);
+                (0, output_1.outputJson)({ profile: context.profileName, token_type: payload.token_type }, json, '✓ Logged in');
+                return;
             }
-            if (!loginResponse.ok || !loginData || typeof loginData !== 'object') {
-                throw new Error(`Supabase login failed: ${loginText}`);
+            if (!email && !userId) {
+                throw new Error('Usage: eve auth login --email <email> or --user-id <id>');
             }
-            const payload = loginData;
-            if (!payload.access_token) {
-                throw new Error('Supabase login response missing access_token');
+            // Attempt SSH key login with GitHub key auto-discovery on failure
+            const loginResult = await attemptSshLogin(context, credentials, flags, email, userId);
+            if (loginResult.success) {
+                (0, output_1.outputJson)({ profile: context.profileName, token_type: loginResult.tokenType }, json, '✓ Logged in');
+                return;
             }
-            const expiresAt = payload.expires_in
-                ? Math.floor(Date.now() / 1000) + payload.expires_in
-                : undefined;
-            credentials.profiles[context.profileName] = {
-                access_token: payload.access_token,
-                refresh_token: payload.refresh_token,
-                expires_at: expiresAt,
-                token_type: payload.token_type,
-            };
-            (0, config_1.saveCredentials)(credentials);
-            (0, output_1.outputJson)({ profile: context.profileName, token_type: payload.token_type }, json, '✓ Logged in');
-            return;
+            // Check if this is a verification failure that could benefit from key registration
+            const isVerificationFailure = loginResult.error && (loginResult.error.includes('Signature verification failed') ||
+                loginResult.error.includes('No matching identity') ||
+                loginResult.error.includes('Identity not found') ||
+                loginResult.error.includes('Public key not registered'));
+            if (!isVerificationFailure || noInteractive || json) {
+                throw new Error(loginResult.error ?? 'Auth verify failed');
+            }
+            // Offer GitHub key auto-discovery
+            const registered = await offerGitHubKeyRegistration(context, email);
+            if (!registered) {
+                throw new Error(loginResult.error ?? 'Auth verify failed');
+            }
+            // Retry login after key registration
+            console.log('\nRetrying login with registered keys...');
+            const retryResult = await attemptSshLogin(context, credentials, flags, email, userId);
+            if (retryResult.success) {
+                (0, output_1.outputJson)({ profile: context.profileName, token_type: retryResult.tokenType }, json, '✓ Logged in');
+                return;
+            }
+            throw new Error(retryResult.error ?? 'Auth verify failed after key registration');
         }
         case 'logout': {
             if (credentials.profiles[context.profileName]) {
@@ -93,7 +166,361 @@ async function handleAuth(subcommand, flags, context, credentials) {
             (0, output_1.outputJson)(data, json);
             return;
         }
+        case 'bootstrap': {
+            const statusOnly = (0, args_1.getBooleanFlag)(flags, ['status']) ?? false;
+            // Check bootstrap status first
+            const statusResponse = await (0, client_1.requestRaw)(context, '/auth/bootstrap/status', {
+                allowError: true,
+                tokenOverride: '',
+            });
+            let status = null;
+            if (statusResponse.ok) {
+                status = statusResponse.data;
+            }
+            // Handle --status subcommand
+            if (statusOnly) {
+                if (!status) {
+                    throw new Error('Failed to fetch bootstrap status');
+                }
+                if (json) {
+                    (0, output_1.outputJson)(status, json);
+                    return;
+                }
+                console.log('Bootstrap Status:');
+                console.log(`  Mode: ${status.mode}`);
+                if (status.completed) {
+                    console.log('  Status: completed');
+                }
+                else if (status.window_open) {
+                    const closesAt = status.window_closes_at ? new Date(status.window_closes_at) : null;
+                    const remaining = closesAt ? Math.max(0, Math.round((closesAt.getTime() - Date.now()) / 60000)) : null;
+                    console.log(`  Window: open${remaining !== null ? ` (closes in ${remaining} minutes)` : ''}`);
+                }
+                else {
+                    console.log('  Window: closed');
+                }
+                console.log(`  Token required: ${status.requires_token ? 'yes' : 'no'}`);
+                return;
+            }
+            const email = (0, args_1.getStringFlag)(flags, ['email']);
+            const token = (0, args_1.getStringFlag)(flags, ['token']) ?? process.env.EVE_BOOTSTRAP_TOKEN;
+            const sshKeyPath = (0, args_1.getStringFlag)(flags, ['ssh-key']) ??
+                (0, node_path_1.join)((0, node_os_1.homedir)(), '.ssh', 'id_ed25519.pub');
+            const displayName = (0, args_1.getStringFlag)(flags, ['display-name']);
+            if (!email) {
+                throw new Error('Usage: eve auth bootstrap --email <email> [--token <token>] [--ssh-key <path>] [--display-name <name>]');
+            }
+            // Check status and handle accordingly
+            if (status) {
+                if (status.completed) {
+                    throw new Error('Bootstrap already completed. Use eve auth login instead.');
+                }
+                if (!status.requires_token && status.window_open) {
+                    console.log(`Bootstrap window open (${status.mode} mode). Token not required.`);
+                }
+                else if (status.requires_token && !token) {
+                    throw new Error('Bootstrap token required. Use --token <token> or set EVE_BOOTSTRAP_TOKEN');
+                }
+            }
+            else if (!token) {
+                // Could not fetch status, require token as fallback
+                throw new Error('Bootstrap token required. Use --token <token> or set EVE_BOOTSTRAP_TOKEN');
+            }
+            // Read SSH public key
+            if (!(0, node_fs_1.existsSync)(sshKeyPath)) {
+                throw new Error(`SSH public key not found: ${sshKeyPath}`);
+            }
+            const publicKey = (0, node_fs_1.readFileSync)(sshKeyPath, 'utf8').trim();
+            // POST to /auth/bootstrap
+            const bootstrapResponse = await (0, client_1.requestRaw)(context, '/auth/bootstrap', {
+                method: 'POST',
+                body: {
+                    token: token ?? undefined,
+                    email,
+                    public_key: publicKey,
+                    display_name: displayName,
+                },
+            });
+            if (!bootstrapResponse.ok) {
+                const message = typeof bootstrapResponse.data === 'string'
+                    ? bootstrapResponse.data
+                    : bootstrapResponse.text;
+                throw new Error(`Bootstrap failed: ${message}`);
+            }
+            const payload = bootstrapResponse.data;
+            if (!payload.access_token) {
+                throw new Error('Bootstrap response missing access_token');
+            }
+            credentials.profiles[context.profileName] = {
+                access_token: payload.access_token,
+                expires_at: payload.expires_at,
+                token_type: payload.token_type,
+            };
+            (0, config_1.saveCredentials)(credentials);
+            (0, output_1.outputJson)({ profile: context.profileName, user_id: payload.user_id, token_type: payload.token_type }, json, `✓ Bootstrapped admin user (user_id: ${payload.user_id})`);
+            return;
+        }
+        case 'sync': {
+            const claudeOnly = (0, args_1.getBooleanFlag)(flags, ['claude']) ?? false;
+            const codexOnly = (0, args_1.getBooleanFlag)(flags, ['codex']) ?? false;
+            const dryRun = (0, args_1.getBooleanFlag)(flags, ['dry-run']) ?? false;
+            const system = (0, args_1.getBooleanFlag)(flags, ['system']) ?? false;
+            const projectIdFlag = (0, args_1.getStringFlag)(flags, ['project']);
+            const projectId = projectIdFlag ?? context.projectId;
+            if (!system && !projectId) {
+                throw new Error('No project specified. Use --project <id> or set default in profile, or use --system for system secrets');
+            }
+            const extractClaude = !codexOnly; // Extract Claude unless --codex is specified
+            const extractCodex = !claudeOnly; // Extract Codex unless --claude is specified
+            const extractedTokens = {};
+            const platform = process.platform;
+            // Extract Claude OAuth tokens
+            if (extractClaude) {
+                if (platform === 'darwin') {
+                    try {
+                        const output = (0, node_child_process_1.execSync)('security find-generic-password -s "anthropic.claude" -w', { encoding: 'utf8' }).trim();
+                        if (output) {
+                            extractedTokens.CLAUDE_OAUTH_TOKEN = output;
+                        }
+                    }
+                    catch (error) {
+                        // Token not found in keychain, continue
+                    }
+                }
+                else {
+                    // Linux: Check various credential file locations
+                    const credentialPaths = [
+                        `${(0, node_os_1.homedir)()}/.claude/.credentials.json`,
+                        `${(0, node_os_1.homedir)()}/.claude/credentials.json`,
+                        `${(0, node_os_1.homedir)()}/.config/claude/credentials.json`,
+                    ];
+                    for (const path of credentialPaths) {
+                        if ((0, node_fs_1.existsSync)(path)) {
+                            try {
+                                const content = (0, node_fs_1.readFileSync)(path, 'utf8');
+                                const creds = JSON.parse(content);
+                                if (creds.oauth_token || creds.access_token) {
+                                    extractedTokens.CLAUDE_OAUTH_TOKEN = creds.oauth_token || creds.access_token;
+                                    break;
+                                }
+                            }
+                            catch {
+                                // Failed to parse, continue
+                            }
+                        }
+                    }
+                }
+            }
+            // Extract Codex OAuth tokens
+            if (extractCodex) {
+                if (platform === 'darwin') {
+                    try {
+                        const output = (0, node_child_process_1.execSync)('security find-generic-password -s "openai.codex" -w', { encoding: 'utf8' }).trim();
+                        if (output) {
+                            extractedTokens.CODEX_OAUTH_TOKEN = output;
+                        }
+                    }
+                    catch (error) {
+                        // Token not found in keychain, continue
+                    }
+                }
+                // Check ~/.codex/auth.json for Codex tokens (all platforms)
+                const codexAuthPath = `${(0, node_os_1.homedir)()}/.codex/auth.json`;
+                if ((0, node_fs_1.existsSync)(codexAuthPath)) {
+                    try {
+                        const content = (0, node_fs_1.readFileSync)(codexAuthPath, 'utf8');
+                        const auth = JSON.parse(content);
+                        if (auth.oauth_token || auth.access_token) {
+                            extractedTokens.CODEX_OAUTH_TOKEN = auth.oauth_token || auth.access_token;
+                        }
+                    }
+                    catch {
+                        // Failed to parse, continue
+                    }
+                }
+            }
+            if (Object.keys(extractedTokens).length === 0) {
+                (0, output_1.outputJson)({ extracted: 0, tokens: [] }, json, 'No tokens found on host machine');
+                return;
+            }
+            if (dryRun) {
+                const tokenList = Object.keys(extractedTokens).map(key => ({
+                    name: key,
+                    value: `${extractedTokens[key].substring(0, 10)}...`,
+                }));
+                (0, output_1.outputJson)({ dry_run: true, would_set: tokenList, target: system ? 'system' : `project ${projectId}` }, json, `Would set ${tokenList.length} token(s) on ${system ? 'system' : `project ${projectId}`}:\n${tokenList.map(t => `  - ${t.name}`).join('\n')}`);
+                return;
+            }
+            // Set secrets via API
+            const endpoint = system ? '/system/secrets' : `/projects/${projectId}/secrets`;
+            const results = [];
+            for (const [name, value] of Object.entries(extractedTokens)) {
+                try {
+                    await (0, client_1.requestJson)(context, endpoint, {
+                        method: 'POST',
+                        body: {
+                            name,
+                            value,
+                        },
+                    });
+                    results.push({ name, success: true });
+                }
+                catch (error) {
+                    results.push({
+                        name,
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            const successCount = results.filter(r => r.success).length;
+            const failCount = results.filter(r => !r.success).length;
+            (0, output_1.outputJson)({
+                target: system ? 'system' : `project ${projectId}`,
+                results,
+                success: successCount,
+                failed: failCount,
+            }, json, `✓ Set ${successCount} secret(s) on ${system ? 'system' : `project ${projectId}`}${failCount > 0 ? ` (${failCount} failed)` : ''}`);
+            return;
+        }
         default:
-            throw new Error('Usage: eve auth <login|logout|status|whoami>');
+            throw new Error('Usage: eve auth <login|logout|status|whoami|bootstrap|sync>');
+    }
+}
+function signNonceWithSsh(keyPath, nonce) {
+    const tempDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'eve-auth-'));
+    const noncePath = (0, node_path_1.join)(tempDir, 'nonce');
+    const signaturePath = `${noncePath}.sig`;
+    try {
+        (0, node_fs_1.writeFileSync)(noncePath, nonce);
+        const result = (0, node_child_process_1.spawnSync)('ssh-keygen', ['-Y', 'sign', '-f', keyPath, '-n', 'eve-auth', noncePath], {
+            encoding: 'utf8',
+        });
+        if (result.status !== 0) {
+            throw new Error(`ssh-keygen failed: ${result.stderr || 'unknown error'}`);
+        }
+        return (0, node_fs_1.readFileSync)(signaturePath, 'utf8');
+    }
+    finally {
+        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+    }
+}
+async function attemptSshLogin(context, credentials, flags, email, userId) {
+    const challengeResponse = await (0, client_1.requestRaw)(context, '/auth/challenge', {
+        method: 'POST',
+        body: {
+            email,
+            user_id: userId,
+        },
+    });
+    if (!challengeResponse.ok) {
+        const message = typeof challengeResponse.data === 'string'
+            ? challengeResponse.data
+            : challengeResponse.text;
+        return { success: false, error: `Challenge failed: ${message}` };
+    }
+    const challenge = challengeResponse.data;
+    if (!challenge.challenge_id || !challenge.nonce) {
+        return { success: false, error: 'Challenge response missing fields' };
+    }
+    const sshKeyPath = (0, args_1.getStringFlag)(flags, ['ssh-key']) ||
+        process.env.EVE_AUTH_SSH_KEY ||
+        context.profile.default_ssh_key ||
+        (0, node_path_1.join)((0, node_os_1.homedir)(), '.ssh', 'id_ed25519');
+    let signature;
+    try {
+        signature = signNonceWithSsh(sshKeyPath, challenge.nonce);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { success: false, error: `Failed to sign challenge: ${msg}` };
+    }
+    const verifyResponse = await (0, client_1.requestRaw)(context, '/auth/verify', {
+        method: 'POST',
+        body: { challenge_id: challenge.challenge_id, signature },
+    });
+    if (!verifyResponse.ok) {
+        const message = typeof verifyResponse.data === 'string'
+            ? verifyResponse.data
+            : verifyResponse.text;
+        return { success: false, error: `Auth verify failed: ${message}` };
+    }
+    const payload = verifyResponse.data;
+    if (!payload.access_token) {
+        return { success: false, error: 'Auth verify response missing access_token' };
+    }
+    credentials.profiles[context.profileName] = {
+        access_token: payload.access_token,
+        expires_at: payload.expires_at,
+        token_type: payload.token_type,
+    };
+    (0, config_1.saveCredentials)(credentials);
+    return { success: true, tokenType: payload.token_type };
+}
+async function fetchGitHubKeys(username) {
+    const response = await fetch(`https://github.com/${username}.keys`);
+    if (!response.ok) {
+        if (response.status === 404) {
+            throw new Error(`GitHub user not found: ${username}`);
+        }
+        throw new Error(`Failed to fetch GitHub keys: HTTP ${response.status}`);
+    }
+    const text = await response.text();
+    return text.trim().split('\n').filter(k => k.length > 0);
+}
+async function offerGitHubKeyRegistration(context, email) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        console.log('\nNo registered SSH key found for this user.');
+        const username = await rl.question('Enter GitHub username to register keys (or press Enter to skip): ');
+        if (!username.trim()) {
+            return false;
+        }
+        let keys;
+        try {
+            keys = await fetchGitHubKeys(username.trim());
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to fetch GitHub keys: ${msg}`);
+            return false;
+        }
+        if (keys.length === 0) {
+            console.log(`No SSH keys found for github.com/${username}`);
+            return false;
+        }
+        console.log(`\nFound ${keys.length} SSH key(s) for github.com/${username.trim()}`);
+        const confirm = await rl.question('Register them? [Y/n]: ');
+        if (confirm.toLowerCase() === 'n' || confirm.toLowerCase() === 'no') {
+            return false;
+        }
+        // Register each key
+        let registered = 0;
+        for (const publicKey of keys) {
+            try {
+                await (0, client_1.requestJson)(context, '/auth/identities', {
+                    method: 'POST',
+                    body: {
+                        email,
+                        public_key: publicKey,
+                        label: `github-${username.trim()}`,
+                    },
+                });
+                registered += 1;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(`Failed to register key: ${msg}`);
+            }
+        }
+        if (registered === 0) {
+            console.log('No keys were registered');
+            return false;
+        }
+        console.log(`✓ Registered ${registered} SSH key(s)`);
+        return true;
+    }
+    finally {
+        rl.close();
     }
 }

package/dist/commands/db.js

@@ -6,7 +6,6 @@ const client_1 = require("../lib/client");
 const output_1 = require("../lib/output");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const yaml_1 = require("yaml");
 async function handleDb(subcommand, positionals, flags, context) {
     const jsonOutput = Boolean(flags.json);
     switch (subcommand) {
@@ -16,14 +15,11 @@ async function handleDb(subcommand, positionals, flags, context) {
             return handleRls(positionals, flags, context, jsonOutput);
         case 'sql':
             return handleSql(positionals, flags, context, jsonOutput);
-        case 'migrate':
-            return handleMigrate(positionals, flags, context, jsonOutput);
         default:
-            throw new Error('Usage: eve db <schema|rls|sql|migrate> --env <name> [options]\n' +
+            throw new Error('Usage: eve db <schema|rls|sql> --env <name> [options]\n' +
                 '  schema   --env <name>                 - show DB schema info\n' +
                 '  rls      --env <name>                 - show RLS policies and tables\n' +
-                '  sql      --env <name> --sql <stmt> [--write] - run parameterized SQL\n' +
-                '  migrate  --env <name> [--component <name>] [--path <dir>] - apply pending migrations');
+                '  sql      --env <name> --sql <stmt> [--write] - run parameterized SQL');
     }
 }
 async function handleSchema(positionals, flags, context, jsonOutput) {
@@ -67,20 +63,6 @@ async function handleSql(positionals, flags, context, jsonOutput) {
     });
     (0, output_1.outputJson)(response, jsonOutput);
 }
-async function handleMigrate(positionals, flags, context, jsonOutput) {
-    const { projectId, envName } = resolveProjectEnv(positionals, flags, context);
-    const manifest = loadLocalManifest();
-    const migrationsPath = getMigrationsPath(flags, manifest);
-    const migrations = loadMigrations(migrationsPath);
-    if (migrations.length === 0) {
-        throw new Error(`No migrations found in ${migrationsPath}`);
-    }
-    const response = await (0, client_1.requestJson)(context, `/projects/${projectId}/envs/${envName}/migrate`, {
-        method: 'POST',
-        body: { migrations },
-    });
-    (0, output_1.outputJson)(response, jsonOutput);
-}
 function resolveProjectEnv(positionals, flags, context) {
     const projectId = (0, args_1.getStringFlag)(flags, ['project']) ?? context.projectId;
     const envName = (0, args_1.getStringFlag)(flags, ['env']) ?? positionals[0];
@@ -89,43 +71,6 @@ function resolveProjectEnv(positionals, flags, context) {
     }
     return { projectId, envName };
 }
-function loadLocalManifest() {
-    const manifestPath = (0, node_path_1.resolve)('.eve/manifest.yaml');
-    if (!(0, node_fs_1.existsSync)(manifestPath)) {
-        return undefined;
-    }
-    const content = (0, node_fs_1.readFileSync)(manifestPath, 'utf-8');
-    return (0, yaml_1.parse)(content);
-}
-function getMigrationsPath(flags, manifest) {
-    // 1. --path flag takes precedence
-    const pathFlag = (0, args_1.getStringFlag)(flags, ['path']);
-    if (pathFlag) {
-        return (0, node_path_1.resolve)(pathFlag);
-    }
-    // 2. Check --component flag or find first database component
-    const componentName = (0, args_1.getStringFlag)(flags, ['component']);
-    const components = manifest?.components;
-    if (components) {
-        if (componentName) {
-            // Specific component requested
-            const component = components[componentName];
-            if (component?.migrations?.path) {
-                return (0, node_path_1.resolve)(component.migrations.path);
-            }
-        }
-        else {
-            // Find first database component with migrations
-            for (const [name, component] of Object.entries(components)) {
-                if (component?.type === 'database' && component?.migrations?.path) {
-                    return (0, node_path_1.resolve)(component.migrations.path);
-                }
-            }
-        }
-    }
-    // 3. Default to .eve/migrations
-    return (0, node_path_1.resolve)('.eve/migrations');
-}
 function parseJson(value, label) {
     try {
         return JSON.parse(value);
@@ -134,16 +79,3 @@ function parseJson(value, label) {
         throw new Error(`${label} must be valid JSON: ${error.message}`);
     }
 }
-function loadMigrations(dir) {
-    if (!(0, node_fs_1.existsSync)(dir)) {
-        throw new Error(`Migrations directory not found: ${dir}`);
-    }
-    const entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true })
-        .filter((entry) => entry.isFile() && entry.name.endsWith('.sql'))
-        .map((entry) => entry.name)
-        .sort();
-    return entries.map((name) => ({
-        name,
-        sql: (0, node_fs_1.readFileSync)((0, node_path_1.resolve)(dir, name), 'utf-8'),
-    }));
-}