@kitecd/cli 1.1.0 → 1.3.0

package/dist/import.js

@@ -0,0 +1,333 @@
+import fs from 'fs';
+import path from 'path';
+import AdmZip from 'adm-zip';
+import ora from 'ora';
+import chalk from 'chalk';
+import { createClient } from '@libsql/client';
+import { ensureKiteHome, readGlobalConfig, writeGlobalConfig } from './home.js';
+const DEFAULT_LOCAL_SERVER_URL = 'http://127.0.0.1:5431';
+const SUPPORTED_SCHEMA = 1;
+const PROJECT_COLUMNS = [
+    'id', 'name', 'description', 'deploy_path', 'token',
+    'pre_deploy_script', 'post_deploy_script', 'env', 'status',
+    'created_at', 'updated_at',
+];
+const DEPLOYMENT_COLUMNS = [
+    'id', 'project_id', 'project_name', 'status', 'trigger_source',
+    'duration', 'output', 'start_time', 'end_time',
+];
+const CREATE_PROJECTS = `
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    description TEXT,
+    deploy_path TEXT NOT NULL,
+    token TEXT NOT NULL UNIQUE,
+    pre_deploy_script TEXT,
+    post_deploy_script TEXT,
+    env TEXT,
+    status TEXT DEFAULT 'idle',
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+`;
+const CREATE_SETTINGS = `
+  CREATE TABLE IF NOT EXISTS settings (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+`;
+const CREATE_DEPLOYMENTS = `
+  CREATE TABLE IF NOT EXISTS deployments (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES projects(id),
+    project_name TEXT NOT NULL,
+    status TEXT NOT NULL,
+    trigger_source TEXT NOT NULL,
+    duration TEXT,
+    output TEXT,
+    start_time TEXT NOT NULL,
+    end_time TEXT
+  );
+`;
+const ensureSchema = async (client) => {
+    await client.execute(CREATE_PROJECTS);
+    try {
+        await client.execute(`ALTER TABLE projects ADD COLUMN env TEXT`);
+    }
+    catch { /* exists */ }
+    await client.execute(CREATE_SETTINGS);
+    await client.execute(CREATE_DEPLOYMENTS);
+};
+const readJsonEntry = (zip, name) => {
+    const entry = zip.getEntry(name);
+    if (!entry)
+        return null;
+    return JSON.parse(entry.getData().toString('utf-8'));
+};
+export async function runImport(file, options) {
+    const strategy = options.strategy || 'skip-existing';
+    if (!['merge', 'overwrite', 'skip-existing'].includes(strategy)) {
+        console.error(chalk.red(`Invalid strategy: ${strategy}. Use merge | overwrite | skip-existing.`));
+        process.exit(1);
+    }
+    if (strategy === 'overwrite' && !options.yes && !options.dryRun) {
+        console.error(chalk.red('Strategy "overwrite" requires --yes to confirm destructive replacement.'));
+        process.exit(1);
+    }
+    const absFile = path.resolve(process.cwd(), file);
+    if (!fs.existsSync(absFile)) {
+        console.error(chalk.red(`Import file not found: ${absFile}`));
+        process.exit(1);
+    }
+    const home = ensureKiteHome();
+    const dbPath = path.join(home, 'kite.db');
+    const spinner = ora('Reading import package...').start();
+    const zip = new AdmZip(absFile);
+    const manifest = readJsonEntry(zip, 'kite-export/manifest.json');
+    if (!manifest) {
+        spinner.fail();
+        console.error(chalk.red('Invalid import package: kite-export/manifest.json not found.'));
+        process.exit(1);
+    }
+    if (manifest.schemaVersion !== SUPPORTED_SCHEMA) {
+        spinner.fail();
+        console.error(chalk.red(`Unsupported schemaVersion ${manifest.schemaVersion} (CLI supports ${SUPPORTED_SCHEMA}). Upgrade CLI and retry.`));
+        process.exit(1);
+    }
+    spinner.succeed(chalk.green(`Loaded export package (exported ${manifest.exportedAt}, kite ${manifest.kiteVersion})`));
+    const projects = readJsonEntry(zip, 'kite-export/projects.json') || [];
+    const settings = readJsonEntry(zip, 'kite-export/settings.json') || [];
+    const deployments = manifest.includes.deployments
+        ? (readJsonEntry(zip, 'kite-export/deployments.json') || [])
+        : [];
+    const client = createClient({ url: `file:${dbPath}` });
+    try {
+        await ensureSchema(client);
+        // 预扫现状用于摘要 + skip-existing 判断
+        const existingProjectIds = new Set();
+        const existingTokens = new Set();
+        for (const row of (await client.execute(`SELECT id, token FROM projects`)).rows) {
+            existingProjectIds.add(String(row.id));
+            existingTokens.add(String(row.token));
+        }
+        const existingSettingKeys = new Set();
+        for (const row of (await client.execute(`SELECT key FROM settings`)).rows) {
+            existingSettingKeys.add(String(row.key));
+        }
+        const existingDeploymentIds = new Set();
+        for (const row of (await client.execute(`SELECT id FROM deployments`)).rows) {
+            existingDeploymentIds.add(String(row.id));
+        }
+        const projectCounts = { added: 0, updated: 0, skipped: 0 };
+        const settingCounts = { added: 0, updated: 0, skipped: 0 };
+        const deploymentCounts = { added: 0, updated: 0, skipped: 0 };
+        const projectsToWrite = [];
+        const settingsToWrite = [];
+        const deploymentsToWrite = [];
+        for (const p of projects) {
+            const id = String(p.id);
+            const token = String(p.token);
+            const idExists = existingProjectIds.has(id);
+            const tokenConflict = !idExists && existingTokens.has(token);
+            if (idExists) {
+                if (strategy === 'overwrite') {
+                    projectsToWrite.push(p);
+                    projectCounts.updated++;
+                }
+                else {
+                    projectCounts.skipped++;
+                }
+            }
+            else if (tokenConflict) {
+                // token unique constraint 会冲突，跳过避免报错
+                projectCounts.skipped++;
+            }
+            else {
+                projectsToWrite.push(p);
+                projectCounts.added++;
+            }
+        }
+        for (const s of settings) {
+            const key = String(s.key);
+            const exists = existingSettingKeys.has(key);
+            if (exists) {
+                if (strategy === 'overwrite') {
+                    settingsToWrite.push(s);
+                    settingCounts.updated++;
+                }
+                else {
+                    settingCounts.skipped++;
+                }
+            }
+            else {
+                settingsToWrite.push(s);
+                settingCounts.added++;
+            }
+        }
+        for (const d of deployments) {
+            const id = String(d.id);
+            const exists = existingDeploymentIds.has(id);
+            if (exists) {
+                if (strategy === 'overwrite') {
+                    deploymentsToWrite.push(d);
+                    deploymentCounts.updated++;
+                }
+                else {
+                    deploymentCounts.skipped++;
+                }
+            }
+            else {
+                deploymentsToWrite.push(d);
+                deploymentCounts.added++;
+            }
+        }
+        // 摘要
+        console.log(chalk.bold('\nImport summary:'));
+        console.log(`  Strategy:    ${strategy}`);
+        console.log(`  DB path:     ${dbPath}`);
+        console.log(`  Projects:    + ${projectCounts.added} new, ~ ${projectCounts.updated} update, - ${projectCounts.skipped} skip`);
+        console.log(`  Settings:    + ${settingCounts.added} new, ~ ${settingCounts.updated} update, - ${settingCounts.skipped} skip`);
+        if (manifest.includes.deployments) {
+            console.log(`  Deployments: + ${deploymentCounts.added} new, ~ ${deploymentCounts.updated} update, - ${deploymentCounts.skipped} skip`);
+        }
+        if (manifest.includes.artifacts) {
+            const restoreCount = options.restoreArtifacts ? manifest.artifacts.filter(a => a.archive).length : 0;
+            console.log(`  Artifacts:   ${options.restoreArtifacts ? `restore ${restoreCount}` : 'available, not restored (pass --restore-artifacts)'}`);
+        }
+        console.log(`  Global cfg:  will write projectToken for ${projectsToWrite.length} projects to ~/.kite/config.json`);
+        if (options.dryRun) {
+            console.log(chalk.gray('\nDry-run complete. No changes written.'));
+            return;
+        }
+        const writeSpinner = ora('Writing to database...').start();
+        const placeholders = (cols) => cols.map(() => '?').join(', ');
+        const upsertProject = (cols) => `INSERT INTO projects (${cols.join(', ')}) VALUES (${placeholders(cols)}) ` +
+            `ON CONFLICT(id) DO UPDATE SET ${cols.filter(c => c !== 'id').map(c => `${c} = excluded.${c}`).join(', ')}`;
+        const upsertSetting = `INSERT INTO settings (key, value) VALUES (?, ?) ` +
+            `ON CONFLICT(key) DO UPDATE SET value = excluded.value`;
+        const upsertDeployment = (cols) => `INSERT INTO deployments (${cols.join(', ')}) VALUES (${placeholders(cols)}) ` +
+            `ON CONFLICT(id) DO UPDATE SET ${cols.filter(c => c !== 'id').map(c => `${c} = excluded.${c}`).join(', ')}`;
+        const tx = await client.transaction('write');
+        try {
+            for (const p of projectsToWrite) {
+                const args = PROJECT_COLUMNS.map(c => (p[c] ?? null));
+                await tx.execute({ sql: upsertProject(PROJECT_COLUMNS), args });
+            }
+            for (const s of settingsToWrite) {
+                await tx.execute({ sql: upsertSetting, args: [String(s.key), String(s.value ?? '')] });
+            }
+            for (const d of deploymentsToWrite) {
+                const args = DEPLOYMENT_COLUMNS.map(c => (d[c] ?? null));
+                await tx.execute({ sql: upsertDeployment(DEPLOYMENT_COLUMNS), args });
+            }
+            await tx.commit();
+        }
+        catch (err) {
+            await tx.rollback();
+            writeSpinner.fail();
+            throw err;
+        }
+        writeSpinner.succeed(chalk.green('Database updated.'));
+        // 写回 CLI 全局 config，方便目标机器直接 kite push
+        try {
+            const globalConfig = readGlobalConfig();
+            const nextProjectToken = { ...(globalConfig.projectToken || {}) };
+            let tokenAdded = 0;
+            let tokenUpdated = 0;
+            let tokenSkipped = 0;
+            for (const p of projectsToWrite) {
+                const projectId = String(p.id);
+                const token = p.token != null ? String(p.token) : '';
+                if (!projectId || !token)
+                    continue;
+                const existing = nextProjectToken[projectId];
+                if (existing === undefined) {
+                    nextProjectToken[projectId] = token;
+                    tokenAdded++;
+                }
+                else if (strategy === 'overwrite') {
+                    if (existing !== token) {
+                        nextProjectToken[projectId] = token;
+                        tokenUpdated++;
+                    }
+                }
+                else {
+                    tokenSkipped++;
+                }
+            }
+            const serverUrlMissing = !globalConfig.serverUrl;
+            const nextServerUrl = serverUrlMissing ? DEFAULT_LOCAL_SERVER_URL : globalConfig.serverUrl;
+            writeGlobalConfig({
+                ...globalConfig,
+                serverUrl: nextServerUrl,
+                projectToken: nextProjectToken,
+            });
+            console.log(chalk.green('Global config updated (~/.kite/config.json).'));
+            console.log(chalk.gray(`  projectToken: + ${tokenAdded} new, ~ ${tokenUpdated} update, - ${tokenSkipped} skip`));
+            if (serverUrlMissing) {
+                console.log(chalk.gray(`  serverUrl:    set to ${DEFAULT_LOCAL_SERVER_URL} (override via \`kite config:set serverUrl <url>\`)`));
+            }
+        }
+        catch (err) {
+            console.log(chalk.yellow(`  ! Failed to update global config: ${err.message}`));
+        }
+        if (manifest.includes.artifacts && options.restoreArtifacts) {
+            // 重新读取写入后 projects 表，获取最新 deploy_path（可能用户保留了已有项目的路径）
+            const deployPathMap = new Map();
+            for (const row of (await client.execute(`SELECT id, deploy_path FROM projects`)).rows) {
+                deployPathMap.set(String(row.id), String(row.deploy_path));
+            }
+            const artifactSpinner = ora('Restoring artifacts...').start();
+            let okCount = 0;
+            let warnCount = 0;
+            for (const a of manifest.artifacts) {
+                if (!a.archive)
+                    continue;
+                const target = deployPathMap.get(a.projectId);
+                if (!target) {
+                    console.log(chalk.yellow(`  ! ${a.projectId}: project not in DB, skip restore`));
+                    warnCount++;
+                    continue;
+                }
+                const entry = zip.getEntry(`kite-export/${a.archive}`);
+                if (!entry) {
+                    console.log(chalk.yellow(`  ! ${a.projectId}: archive entry missing`));
+                    warnCount++;
+                    continue;
+                }
+                try {
+                    fs.mkdirSync(target, { recursive: true });
+                    const tmpZipPath = path.join(home, 'tmp', `restore-${a.projectId}-${Date.now()}.zip`);
+                    fs.mkdirSync(path.dirname(tmpZipPath), { recursive: true });
+                    fs.writeFileSync(tmpZipPath, entry.getData());
+                    const innerZip = new AdmZip(tmpZipPath);
+                    // 路径穿越校验
+                    for (const e of innerZip.getEntries()) {
+                        const dest = path.resolve(target, e.entryName);
+                        if (!dest.startsWith(path.resolve(target) + path.sep) && dest !== path.resolve(target)) {
+                            throw new Error(`Refusing to extract entry outside target: ${e.entryName}`);
+                        }
+                    }
+                    innerZip.extractAllTo(target, true);
+                    fs.unlinkSync(tmpZipPath);
+                    okCount++;
+                }
+                catch (err) {
+                    console.log(chalk.yellow(`  ! ${a.projectId}: restore failed - ${err.message}`));
+                    warnCount++;
+                }
+            }
+            artifactSpinner.succeed(chalk.green(`Artifacts restored: ${okCount} ok, ${warnCount} warnings`));
+        }
+        console.log(chalk.green('\nImport completed.'));
+        if (!manifest.includes.artifacts || !options.restoreArtifacts) {
+            console.log(chalk.gray('Tip: start `kite serve` to verify projects in the dashboard.'));
+        }
+        console.log(chalk.gray('Tip: `kite push` from your project directory now uses the restored token automatically.'));
+        console.log(chalk.gray('Tip: run `kite verify` to self-check migration integrity (db, deploy paths, tokens).'));
+    }
+    finally {
+        client.close();
+    }
+}

package/dist/index.js

@@ -10,6 +10,12 @@ import { uploadZip } from './upload.js';
 import { getConfigPath, getKiteHome, randomToken, readGlobalConfig, readLocalEnv, setGlobalConfig, writeGlobalConfig, writeLocalEnvValue, listProjectEnvs, resolveProjectConfig, envTokenKey } from './home.js';
 import { LocalStore } from './local-store.js';
 import { startServe } from './serve.js';
+import { parseIgnoreOption } from './ignore.js';
+import { runExport } from './export.js';
+import { runImport } from './import.js';
+import { runVerify } from './verify.js';
+import { runDoctor } from './doctor.js';
+import { runList, runStatus, runLogs, runRollback } from './ops.js';
 // @ts-ignore
 const cli = cac('kite');
 // ==========================
@@ -482,6 +488,8 @@ const displayPackResult = (result) => {
 cli.command('build', 'Pack project files and verify packaging (no upload)')
     .option('--env <name>', 'Environment name (selects kite.config.<name>.json)')
     .option('--out <dir>', 'Output directory to pack')
+    .option('--ignore <patterns>', 'Extra ignore patterns (comma separated, may repeat)')
+    .option('--no-ignore-builtin', 'Disable built-in ignore patterns (node_modules, .git, .env*, etc.)')
     .action(async (options) => {
     try {
         const allEnvs = listProjectEnvs();
@@ -513,9 +521,21 @@ cli.command('build', 'Pack project files and verify packaging (no upload)')
             console.error(chalk.red(`Error: Output directory not found: ${sourceDir}`));
             process.exit(1);
         }
+        const cliIgnore = parseIgnoreOption(options.ignore);
+        const ignore = cliIgnore.length > 0
+            ? cliIgnore
+            : (Array.isArray(projectConfig.ignore) ? projectConfig.ignore : []);
+        // cac: --no-ignore-builtin 时 options.ignoreBuiltin === false；未传时 true
+        const ignoreBuiltin = options.ignoreBuiltin === false
+            ? true
+            : (projectConfig.ignoreBuiltin === true);
         const spinner = ora('Packing files...').start();
         const zipFilePath = path.resolve(process.cwd(), '.deploy-archive.zip');
-        const result = await packProject(sourceDir, zipFilePath, files.length > 0 ? files : undefined);
+        const result = await packProject(sourceDir, zipFilePath, {
+            files: files.length > 0 ? files : undefined,
+            ignore,
+            ignoreBuiltin,
+        });
         spinner.succeed(chalk.green('Pack successful!'));
         displayPackResult(result);
         console.log(chalk.gray(`  Archive: ${zipFilePath}`));
@@ -537,8 +557,12 @@ cli.command('push', 'Push and deploy project')
     .option('--pre <script>', 'Pre-deploy script (Server side)')
     .option('--post <script>', 'Post-deploy script (Server side)')
     .option('--command <script>', 'Deploy command alias, same as --post')
+    .option('--post-deploy-async', 'Run postDeploy asynchronously (do not wait for it to finish)')
     .option('--set-env <vars>', 'Environment variables as JSON or KEY=VALUE (overrides config)')
+    .option('--ignore <patterns>', 'Extra ignore patterns (comma separated, may repeat)')
+    .option('--no-ignore-builtin', 'Disable built-in ignore patterns (node_modules, .git, .env*, etc.)')
     .action(async (options) => {
+    const pushStartedAt = new Date().toISOString();
     try {
         // 1. 解析环境配置
         const allEnvs = listProjectEnvs();
@@ -601,6 +625,16 @@ cli.command('push', 'Push and deploy project')
         const files = projectConfig.files || [];
         const preDeploy = options.pre || localEnv.KITE_PRE_DEPLOY || projectConfig.preDeploy;
         const postDeploy = options.command || options.post || localEnv.KITE_DEPLOY_COMMAND || localEnv.KITE_POST_DEPLOY || projectConfig.command || projectConfig.postDeploy;
+        // postDeployAsync: CLI flag > env > project config（undefined = 不覆盖项目设置）
+        let postDeployAsync;
+        if (options.postDeployAsync === true)
+            postDeployAsync = true;
+        else if (localEnv.KITE_POST_DEPLOY_ASYNC === 'true' || localEnv.KITE_POST_DEPLOY_ASYNC === '1')
+            postDeployAsync = true;
+        else if (localEnv.KITE_POST_DEPLOY_ASYNC === 'false' || localEnv.KITE_POST_DEPLOY_ASYNC === '0')
+            postDeployAsync = false;
+        else if (typeof projectConfig.postDeployAsync === 'boolean')
+            postDeployAsync = projectConfig.postDeployAsync;
         // 解析 env: 项目配置 + CLI --set-env 覆盖
         let deployEnv = projectConfig.env || undefined;
         if (options.setEnv) {
@@ -624,9 +658,21 @@ cli.command('push', 'Push and deploy project')
             process.exit(1);
         }
         // 5. 打包文件
+        const cliIgnore = parseIgnoreOption(options.ignore);
+        const ignore = cliIgnore.length > 0
+            ? cliIgnore
+            : (Array.isArray(projectConfig.ignore) ? projectConfig.ignore : []);
+        // cac: --no-ignore-builtin 时 options.ignoreBuiltin === false；未传时 true
+        const ignoreBuiltin = options.ignoreBuiltin === false
+            ? true
+            : (projectConfig.ignoreBuiltin === true);
         const spinner = ora('Packing files...').start();
         const zipFilePath = path.resolve(process.cwd(), '.deploy-archive.zip');
-        const packResult = await packProject(sourceDir, zipFilePath, files.length > 0 ? files : undefined);
+        const packResult = await packProject(sourceDir, zipFilePath, {
+            files: files.length > 0 ? files : undefined,
+            ignore,
+            ignoreBuiltin,
+        });
         spinner.succeed(chalk.green('Packed successfully'));
         displayPackResult(packResult);
         // 6. 上传与部署
@@ -639,13 +685,21 @@ cli.command('push', 'Push and deploy project')
             projectId,
             preDeploy,
             postDeploy,
-            env: deployEnv
+            postDeployAsync,
+            env: deployEnv,
+            startedAt: pushStartedAt
         });
         if (result.success) {
             console.log(chalk.green(`\nDeployed successfully! (${result.duration})`));
+            if (result.traceId) {
+                console.log(chalk.gray(`  trace: ${result.traceId}`));
+            }
         }
         else {
             console.error(chalk.red('\nDeployment failed'));
+            if (result.traceId) {
+                console.error(chalk.gray(`  trace: ${result.traceId}`));
+            }
             process.exit(1);
         }
     }
@@ -661,6 +715,162 @@ cli.command('push', 'Push and deploy project')
         }
     }
 });
+// ==========================
+// Migration commands: export / import
+// ==========================
+cli.command('export', 'Export Kite database (and optional artifacts) to a portable archive')
+    .option('--out <file>', 'Output file path (default: kite-export-<timestamp>.zip)')
+    .option('--no-include-artifacts', 'Skip packing each project deployPath contents (default: include)')
+    .option('--no-include-logs', 'Skip deployment history (default: include)')
+    .option('--projects <ids>', 'Comma separated project ids to include (default: all)')
+    .option('--ignore <patterns>', 'Extra ignore patterns for artifacts (comma separated, may repeat)')
+    .option('--no-ignore-builtin', 'Disable built-in ignore patterns when packing artifacts')
+    .action(async (options) => {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
+        const ignoreBuiltin = options.ignoreBuiltin === false;
+        await runExport({
+            out: options.out,
+            includeArtifacts: options.includeArtifacts !== false,
+            includeLogs: options.includeLogs !== false,
+            projects: options.projects,
+            ignore: options.ignore,
+            ignoreBuiltin,
+        }, pkg.version || '0.0.0');
+    }
+    catch (error) {
+        console.error(chalk.red(`\nExport failed: ${error.message}`));
+        process.exit(1);
+    }
+});
+cli.command('import <file>', 'Import Kite database from an export archive')
+    .option('--strategy <mode>', 'Conflict strategy: merge | overwrite | skip-existing', { default: 'skip-existing' })
+    .option('--no-restore-artifacts', 'Skip restoring each project deployPath from the archive (default: restore when archive contains artifacts)')
+    .option('--dry-run', 'Show summary without writing')
+    .option('--yes', 'Confirm destructive --strategy overwrite')
+    .action(async (file, options) => {
+    try {
+        await runImport(file, {
+            strategy: options.strategy,
+            restoreArtifacts: options.restoreArtifacts !== false,
+            dryRun: !!options.dryRun,
+            yes: !!options.yes,
+        });
+    }
+    catch (error) {
+        console.error(chalk.red(`\nImport failed: ${error.message}`));
+        process.exit(1);
+    }
+});
+cli.command('verify', 'Verify ~/.kite migration integrity (db, deploy paths, tokens, optional server health)')
+    .option('--check-server', 'Also probe configured serverUrl with HTTP GET')
+    .option('--timeout <ms>', 'Server probe timeout in ms', { default: 5000 })
+    .action(async (options) => {
+    try {
+        await runVerify({
+            checkServer: !!options.checkServer,
+            timeout: Number(options.timeout) || 5000,
+        });
+    }
+    catch (error) {
+        console.error(chalk.red(`\nVerify failed: ${error.message}`));
+        process.exit(1);
+    }
+});
+cli.command('doctor', 'Run local + remote health diagnostics')
+    .option('--server <url>', 'Override server URL (defaults to global config / KITE_SERVER_URL)')
+    .option('--token <token>', 'Override admin token (defaults to global config / KITE_TOKEN)')
+    .action(async (options) => {
+    try {
+        const code = await runDoctor({ server: options.server, token: options.token });
+        process.exit(code);
+    }
+    catch (error) {
+        console.error(chalk.red(`\nDoctor failed: ${error.message}`));
+        process.exit(1);
+    }
+});
+cli.command('list', 'List projects on Kite server')
+    .option('--server <url>', 'Override server URL')
+    .option('--token <token>', 'Override admin token')
+    .option('--env <name>', 'Filter by project env')
+    .option('--json', 'Output JSON (no colors)')
+    .action(async (options) => {
+    try {
+        const code = await runList({ server: options.server, token: options.token, env: options.env, json: options.json });
+        process.exit(code);
+    }
+    catch (error) {
+        console.error(chalk.red(`\nList failed: ${error.message}`));
+        process.exit(1);
+    }
+});
+cli.command('status [projectId]', 'Show recent deployments of a project')
+    .option('--server <url>', 'Override server URL')
+    .option('--token <token>', 'Override admin token')
+    .option('--env <name>', 'Pick kite.config.<env>.json when no projectId given')
+    .option('--limit <n>', 'Number of deployments to show (default 5, max 50)')
+    .option('--json', 'Output JSON')
+    .action(async (projectId, options) => {
+    try {
+        const code = await runStatus(projectId, {
+            server: options.server,
+            token: options.token,
+            env: options.env,
+            limit: options.limit ? Number(options.limit) : undefined,
+            json: options.json,
+        });
+        process.exit(code);
+    }
+    catch (error) {
+        console.error(chalk.red(`\nStatus failed: ${error.message}`));
+        process.exit(1);
+    }
+});
+cli.command('logs <deployId>', 'Print deployment logs (or follow live with -f)')
+    .option('--server <url>', 'Override server URL')
+    .option('--token <token>', 'Override admin token')
+    .option('-f, --follow', 'Stream live logs via SSE until the deployment finishes')
+    .option('--json', 'Output JSON (only without --follow)')
+    .action(async (deployId, options) => {
+    try {
+        const code = await runLogs(deployId, {
+            server: options.server,
+            token: options.token,
+            follow: options.follow,
+            json: options.json,
+        });
+        process.exit(code);
+    }
+    catch (error) {
+        console.error(chalk.red(`\nLogs failed: ${error.message}`));
+        process.exit(1);
+    }
+});
+cli.command('rollback [projectId]', 'Rollback a project to a previous successful deployment')
+    .option('--server <url>', 'Override server URL')
+    .option('--token <token>', 'Override admin token (admin required)')
+    .option('--env <name>', 'Pick kite.config.<env>.json when no projectId given')
+    .option('--to <deployId>', 'Target deployment to roll back to (default: previous success)')
+    .option('--yes', 'Skip interactive confirmation (required in non-TTY)')
+    .option('--json', 'Output JSON on success')
+    .action(async (projectId, options) => {
+    try {
+        const code = await runRollback(projectId, {
+            server: options.server,
+            token: options.token,
+            env: options.env,
+            to: options.to,
+            yes: options.yes,
+            json: options.json,
+        });
+        process.exit(code);
+    }
+    catch (error) {
+        console.error(chalk.red(`\nRollback failed: ${error.message}`));
+        process.exit(1);
+    }
+});
 cli.help();
 const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
 cli.version(pkg.version);