@kitecd/cli 1.0.0 → 1.2.0

package/dist/doctor.js

@@ -0,0 +1,181 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import chalk from 'chalk';
+import { getKiteHome, readGlobalConfig } from './home.js';
+function fmt(level) {
+    if (level === 'ok')
+        return chalk.green('✓');
+    if (level === 'warn')
+        return chalk.yellow('!');
+    return chalk.red('✗');
+}
+function homeRelative(p) {
+    const home = os.homedir();
+    return p.startsWith(home) ? '~' + p.slice(home.length) : p;
+}
+function checkNodeVersion() {
+    const major = Number(process.versions.node.split('.')[0]);
+    if (Number.isFinite(major) && major >= 18) {
+        return { name: 'Node.js', level: 'ok', detail: `v${process.versions.node} (>=18 required)` };
+    }
+    return { name: 'Node.js', level: 'error', detail: `v${process.versions.node} (require >=18)` };
+}
+function checkKiteHome() {
+    const home = getKiteHome();
+    const out = [];
+    try {
+        fs.mkdirSync(home, { recursive: true });
+        const probe = path.join(home, `.doctor-${Date.now()}.tmp`);
+        fs.writeFileSync(probe, 'ok');
+        fs.unlinkSync(probe);
+        out.push({ name: 'Kite Home', level: 'ok', detail: homeRelative(home) });
+    }
+    catch (err) {
+        out.push({ name: 'Kite Home', level: 'error', detail: `${homeRelative(home)} not writable: ${err?.message}` });
+    }
+    for (const sub of ['deployments', 'tmp']) {
+        const p = path.join(home, sub);
+        try {
+            fs.mkdirSync(p, { recursive: true });
+            out.push({ name: `Kite Home / ${sub}`, level: 'ok', detail: homeRelative(p) });
+        }
+        catch (err) {
+            out.push({ name: `Kite Home / ${sub}`, level: 'error', detail: `${homeRelative(p)} create failed: ${err?.message}` });
+        }
+    }
+    return out;
+}
+function checkDiskFree() {
+    if (process.platform === 'win32') {
+        return { name: 'Disk free', level: 'warn', detail: 'skipped on Windows' };
+    }
+    try {
+        const home = getKiteHome();
+        const out = execSync(`df -kP "${home}"`, { encoding: 'utf-8', timeout: 3000 });
+        const lines = out.trim().split('\n');
+        const cols = lines[lines.length - 1].trim().split(/\s+/).slice(-5);
+        const total = Number(cols[0]);
+        const avail = Number(cols[2]);
+        if (!Number.isFinite(total) || !Number.isFinite(avail) || total <= 0) {
+            return { name: 'Disk free', level: 'warn', detail: 'unable to parse df output' };
+        }
+        const freeGB = (avail / 1024 / 1024).toFixed(2);
+        const pctUsed = Math.round(((total - avail) / total) * 100);
+        if (pctUsed >= 95)
+            return { name: 'Disk free', level: 'error', detail: `${freeGB} GB free (${pctUsed}% used)` };
+        if (pctUsed >= 85)
+            return { name: 'Disk free', level: 'warn', detail: `${freeGB} GB free (${pctUsed}% used)` };
+        return { name: 'Disk free', level: 'ok', detail: `${freeGB} GB free (${pctUsed}% used)` };
+    }
+    catch (err) {
+        return { name: 'Disk free', level: 'warn', detail: `df failed: ${err?.message}` };
+    }
+}
+function checkLocalConfig() {
+    const cfg = readGlobalConfig();
+    if (cfg.serverUrl)
+        return { name: 'Global config', level: 'ok', detail: `serverUrl=${cfg.serverUrl}` };
+    return { name: 'Global config', level: 'warn', detail: 'no serverUrl in ~/.kite/config.json (use `kite config set serverUrl <url>`)' };
+}
+async function checkRemote(opts) {
+    if (!opts.serverUrl) {
+        return [{ name: 'Remote', level: 'warn', detail: 'no server url (pass --server or configure globally)' }];
+    }
+    const base = opts.serverUrl.replace(/\/$/, '');
+    const out = [];
+    try {
+        const res = await fetch(`${base}/api/health`);
+        if (res.ok) {
+            const body = await res.json().catch(() => ({}));
+            out.push({ name: 'GET /api/health', level: 'ok', detail: `status=${body.status} uptime=${body.uptime}s version=${body.version}` });
+        }
+        else {
+            out.push({ name: 'GET /api/health', level: 'error', detail: `HTTP ${res.status}` });
+            return out;
+        }
+    }
+    catch (err) {
+        out.push({ name: 'GET /api/health', level: 'error', detail: `network error: ${err?.message}` });
+        return out;
+    }
+    if (!opts.token) {
+        out.push({ name: 'GET /api/health/detail', level: 'warn', detail: 'no admin token (pass --token or configure globally) — detail skipped' });
+        return out;
+    }
+    try {
+        const res = await fetch(`${base}/api/health/detail`, { headers: { Authorization: `Bearer ${opts.token}` } });
+        if (res.status === 401) {
+            out.push({ name: 'GET /api/health/detail', level: 'error', detail: 'unauthorized — token mismatch' });
+            return out;
+        }
+        const body = await res.json().catch(() => ({}));
+        if (!res.ok) {
+            out.push({ name: 'GET /api/health/detail', level: 'error', detail: `HTTP ${res.status}` });
+        }
+        if (body?.db) {
+            out.push({ name: 'Remote DB', level: body.db.ok ? 'ok' : 'error', detail: `${body.db.path} (${body.db.latencyMs}ms)${body.db.error ? ' ' + body.db.error : ''}` });
+        }
+        if (body?.kiteHome) {
+            out.push({ name: 'Remote Kite Home', level: body.kiteHome.writable ? 'ok' : 'error', detail: `${body.kiteHome.path} writable=${body.kiteHome.writable} tmp=${body.kiteHome.tmpWritable}` });
+        }
+        if (body?.disk) {
+            const d = body.disk;
+            if (d.percentUsed == null) {
+                out.push({ name: 'Remote Disk', level: 'warn', detail: 'unavailable on remote platform' });
+            }
+            else {
+                const lvl = d.percentUsed >= 95 ? 'error' : d.percentUsed >= 85 ? 'warn' : 'ok';
+                const freeGB = d.freeBytes != null ? (d.freeBytes / 1024 / 1024 / 1024).toFixed(2) + ' GB' : '?';
+                out.push({ name: 'Remote Disk', level: lvl, detail: `${freeGB} free (${d.percentUsed}% used)` });
+            }
+        }
+        if (body?.deploy) {
+            const rate = body.deploy.successRate;
+            const lvl = rate == null ? 'warn' : rate >= 0.8 ? 'ok' : rate >= 0.5 ? 'warn' : 'error';
+            out.push({ name: 'Recent deploys', level: lvl, detail: `last ${body.deploy.last5.length} success rate=${rate == null ? 'n/a' : (rate * 100).toFixed(0) + '%'}` });
+        }
+        if (body?.runtime) {
+            out.push({ name: 'Remote runtime', level: 'ok', detail: `${body.runtime.name} ${body.runtime.version} uptime=${body.uptimeSec}s` });
+        }
+    }
+    catch (err) {
+        out.push({ name: 'GET /api/health/detail', level: 'error', detail: `network error: ${err?.message}` });
+    }
+    return out;
+}
+export async function runDoctor(opts = {}) {
+    const cfg = readGlobalConfig();
+    const serverUrl = opts.server || process.env.KITE_SERVER_URL || cfg.serverUrl;
+    const token = opts.token || process.env.KITE_TOKEN || cfg.token;
+    const localChecks = [
+        checkNodeVersion(),
+        ...checkKiteHome(),
+        checkDiskFree(),
+        checkLocalConfig(),
+    ];
+    const remoteChecks = await checkRemote({ serverUrl, token });
+    console.log(chalk.bold('\n[Local]'));
+    for (const c of localChecks) {
+        console.log(`  ${fmt(c.level)} ${c.name.padEnd(22)} ${chalk.gray(c.detail)}`);
+    }
+    console.log(chalk.bold(`\n[Remote ${serverUrl || '(none)'}]`));
+    for (const c of remoteChecks) {
+        console.log(`  ${fmt(c.level)} ${c.name.padEnd(22)} ${chalk.gray(c.detail)}`);
+    }
+    const all = [...localChecks, ...remoteChecks];
+    const hasError = all.some(c => c.level === 'error');
+    const hasWarn = all.some(c => c.level === 'warn');
+    console.log('');
+    if (hasError) {
+        console.log(chalk.red('Doctor: some checks failed.'));
+        return 1;
+    }
+    if (hasWarn) {
+        console.log(chalk.yellow('Doctor: passed with warnings.'));
+        return 0;
+    }
+    console.log(chalk.green('Doctor: all checks passed.'));
+    return 0;
+}

package/dist/export.js

@@ -0,0 +1,144 @@
+import fs from 'fs';
+import path from 'path';
+import archiver from 'archiver';
+import ora from 'ora';
+import chalk from 'chalk';
+import { createClient } from '@libsql/client';
+import { ensureKiteHome } from './home.js';
+import { packProject } from './pack.js';
+import { parseIgnoreOption } from './ignore.js';
+const rowsToObjects = (rows) => rows.map(row => ({ ...row }));
+const formatBytes = (bytes) => {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+};
+const tableExists = async (client, name) => {
+    const result = await client.execute({
+        sql: `SELECT name FROM sqlite_master WHERE type='table' AND name = ?`,
+        args: [name],
+    });
+    return result.rows.length > 0;
+};
+const dumpTable = async (client, table) => {
+    if (!(await tableExists(client, table)))
+        return [];
+    const result = await client.execute(`SELECT * FROM ${table}`);
+    return rowsToObjects(result.rows);
+};
+export async function runExport(options, kiteVersion) {
+    const home = ensureKiteHome();
+    const dbPath = path.join(home, 'kite.db');
+    if (!fs.existsSync(dbPath)) {
+        console.error(chalk.red(`No Kite database found at ${dbPath}`));
+        console.error(chalk.gray('Run `kite serve` at least once on the source machine to initialize the database.'));
+        process.exit(1);
+    }
+    const includeArtifacts = !!options.includeArtifacts;
+    const includeLogs = !!options.includeLogs;
+    const stamp = new Date().toISOString().replace(/[-:.TZ]/g, '').slice(0, 14);
+    const outPath = path.resolve(process.cwd(), options.out || `kite-export-${stamp}.zip`);
+    const client = createClient({ url: `file:${dbPath}` });
+    try {
+        const projectFilter = (options.projects || '')
+            .split(',')
+            .map(s => s.trim())
+            .filter(Boolean);
+        const spinner = ora('Reading Kite database...').start();
+        const allProjects = await dumpTable(client, 'projects');
+        const projects = projectFilter.length > 0
+            ? allProjects.filter(p => projectFilter.includes(String(p.id)))
+            : allProjects;
+        const settings = await dumpTable(client, 'settings');
+        const deployments = includeLogs ? await dumpTable(client, 'deployments') : [];
+        const filteredDeployments = projectFilter.length > 0
+            ? deployments.filter(d => projectFilter.includes(String(d.project_id)))
+            : deployments;
+        spinner.succeed(chalk.green(`Read database: ${projects.length} projects, ${settings.length} settings, ${filteredDeployments.length} deployments`));
+        const manifest = {
+            schemaVersion: 1,
+            exportedAt: new Date().toISOString(),
+            kiteVersion,
+            includes: {
+                settings: settings.length > 0,
+                projects: projects.length > 0,
+                deployments: includeLogs,
+                artifacts: includeArtifacts,
+            },
+            projectIds: projects.map(p => String(p.id)),
+            artifacts: [],
+        };
+        const tmpDir = path.join(home, 'tmp', `export-${stamp}`);
+        fs.mkdirSync(tmpDir, { recursive: true });
+        const artifactsDir = path.join(tmpDir, 'artifacts');
+        if (includeArtifacts) {
+            fs.mkdirSync(artifactsDir, { recursive: true });
+            const artifactsSpinner = ora('Packing project artifacts...').start();
+            const ignoreCustom = parseIgnoreOption(options.ignore);
+            const ignoreBuiltin = options.ignoreBuiltin === false ? true : false;
+            for (const project of projects) {
+                const projectId = String(project.id);
+                const deployPath = String(project.deploy_path || '');
+                if (!deployPath || !fs.existsSync(deployPath)) {
+                    manifest.artifacts.push({ projectId, deployPath, skipped: 'deploy path not found' });
+                    continue;
+                }
+                try {
+                    const stat = fs.statSync(deployPath);
+                    if (!stat.isDirectory()) {
+                        manifest.artifacts.push({ projectId, deployPath, skipped: 'deploy path is not a directory' });
+                        continue;
+                    }
+                    const archiveName = `${projectId}.zip`;
+                    const archivePath = path.join(artifactsDir, archiveName);
+                    await packProject(deployPath, archivePath, {
+                        ignore: ignoreCustom,
+                        ignoreBuiltin,
+                    });
+                    manifest.artifacts.push({ projectId, deployPath, archive: `artifacts/${archiveName}` });
+                }
+                catch (err) {
+                    manifest.artifacts.push({ projectId, deployPath, skipped: `pack error: ${err.message}` });
+                }
+            }
+            artifactsSpinner.succeed(chalk.green(`Packed artifacts for ${manifest.artifacts.filter(a => a.archive).length} projects`));
+        }
+        fs.writeFileSync(path.join(tmpDir, 'manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`);
+        fs.writeFileSync(path.join(tmpDir, 'projects.json'), `${JSON.stringify(projects, null, 2)}\n`);
+        fs.writeFileSync(path.join(tmpDir, 'settings.json'), `${JSON.stringify(settings, null, 2)}\n`);
+        if (includeLogs) {
+            fs.writeFileSync(path.join(tmpDir, 'deployments.json'), `${JSON.stringify(filteredDeployments, null, 2)}\n`);
+        }
+        const zipSpinner = ora(`Writing ${path.basename(outPath)}...`).start();
+        await new Promise((resolve, reject) => {
+            const output = fs.createWriteStream(outPath);
+            const archive = archiver('zip', { zlib: { level: 9 } });
+            output.on('close', () => resolve());
+            archive.on('error', reject);
+            archive.pipe(output);
+            archive.directory(tmpDir, 'kite-export');
+            archive.finalize();
+        });
+        zipSpinner.succeed(chalk.green(`Wrote ${outPath}`));
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        const stat = fs.statSync(outPath);
+        console.log(chalk.gray(`  Size: ${formatBytes(stat.size)}`));
+        console.log(chalk.gray(`  Projects: ${projects.length}${projectFilter.length > 0 ? ` (filtered from ${allProjects.length})` : ''}`));
+        console.log(chalk.gray(`  Settings: ${settings.length}`));
+        if (includeLogs)
+            console.log(chalk.gray(`  Deployments: ${filteredDeployments.length}`));
+        if (includeArtifacts) {
+            const ok = manifest.artifacts.filter(a => a.archive).length;
+            const skipped = manifest.artifacts.filter(a => a.skipped).length;
+            console.log(chalk.gray(`  Artifacts: ${ok} packed, ${skipped} skipped`));
+            for (const a of manifest.artifacts.filter(x => x.skipped)) {
+                console.log(chalk.yellow(`    ! ${a.projectId}: ${a.skipped}`));
+            }
+        }
+    }
+    finally {
+        client.close();
+    }
+}

package/dist/ignore.js

@@ -0,0 +1,38 @@
+export const DEFAULT_IGNORED = [
+    '.git/**',
+    '.svn/**',
+    '.hg/**',
+    'node_modules/**',
+    '.next/**',
+    '.nuxt/**',
+    '.turbo/**',
+    '.cache/**',
+    '.parcel-cache/**',
+    '.vite/**',
+    'coverage/**',
+    '.nyc_output/**',
+    '.DS_Store',
+    'Thumbs.db',
+    '.idea/**',
+    '.vscode/**',
+    '*.log',
+    'logs/**',
+    'tmp/**',
+    '.tmp/**',
+    '.deploy-archive.zip',
+    'kite-export-*.tar.gz',
+    '.env*',
+];
+export function mergeIgnore(opts = {}) {
+    const { custom = [], ignoreBuiltin = false } = opts;
+    const base = ignoreBuiltin ? [] : DEFAULT_IGNORED;
+    return Array.from(new Set([...base, ...custom]));
+}
+export function parseIgnoreOption(raw) {
+    if (!raw)
+        return [];
+    if (Array.isArray(raw)) {
+        return raw.flatMap(item => String(item).split(',')).map(s => s.trim()).filter(Boolean);
+    }
+    return String(raw).split(',').map(s => s.trim()).filter(Boolean);
+}