@kitecd/cli 1.0.0

package/dist/pack.js

@@ -0,0 +1,137 @@
+import archiver from 'archiver';
+import fs from 'fs';
+import path from 'path';
+const IGNORED = ['node_modules/**', '.git/**', '*.zip', '.env*'];
+/**
+ * 将路径列表折叠：如果一个目录下的所有文件都在列表中，则只展示目录
+ */
+function collapseEntries(rawEntries) {
+    if (rawEntries.length === 0)
+        return [];
+    // 构建目录树
+    const tree = {};
+    for (const entry of rawEntries) {
+        const parts = entry.split('/');
+        for (let i = 1; i < parts.length; i++) {
+            const dir = parts.slice(0, i).join('/');
+            if (!tree[dir])
+                tree[dir] = new Set();
+            tree[dir].add(parts.slice(0, i + 1).join('/'));
+        }
+    }
+    // 递归检查：目录下所有子项都在列表中则折叠
+    const allPaths = new Set(rawEntries);
+    function isCompleteDir(dirPath) {
+        const children = tree[dirPath];
+        if (!children)
+            return true;
+        for (const child of children) {
+            if (tree[child]) {
+                if (!isCompleteDir(child))
+                    return false;
+            }
+            else if (!allPaths.has(child)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    const result = [];
+    const added = new Set();
+    for (const entry of rawEntries) {
+        // 检查这个文件的祖先目录是否已经完整折叠
+        let dominated = false;
+        const parts = entry.split('/');
+        for (let i = 1; i < parts.length; i++) {
+            const ancestor = parts.slice(0, i).join('/');
+            if (added.has(ancestor + '/')) {
+                dominated = true;
+                break;
+            }
+            if (tree[ancestor] && isCompleteDir(ancestor)) {
+                result.push(ancestor + '/');
+                added.add(ancestor + '/');
+                dominated = true;
+                break;
+            }
+        }
+        if (dominated)
+            continue;
+        // 检查这个文件是否是一个完整目录的叶子
+        const dir = path.dirname(entry);
+        if (dir !== '.' && tree[dir] && isCompleteDir(dir)) {
+            if (!added.has(dir + '/')) {
+                result.push(dir + '/');
+                added.add(dir + '/');
+            }
+        }
+        else {
+            if (!added.has(entry)) {
+                result.push(entry);
+                added.add(entry);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * 将指定目录或文件打包为 zip 文件
+ * @param sourceDir 要打包的源目录
+ * @param destZip 目标 zip 文件的路径
+ * @param files 允许上传的特定文件或目录列表（可选，如果提供则仅打包这些内容）
+ */
+export async function packProject(sourceDir, destZip, files) {
+    return new Promise((resolve, reject) => {
+        const output = fs.createWriteStream(destZip);
+        const archive = archiver('zip', {
+            zlib: { level: 9 }
+        });
+        const rawEntries = [];
+        archive.on('entry', (entry) => {
+            if (entry.stats && !entry.stats.isDirectory()) {
+                rawEntries.push(entry.name);
+            }
+        });
+        output.on('close', () => {
+            const entries = collapseEntries(rawEntries);
+            resolve({
+                size: archive.pointer(),
+                entries,
+                fileCount: rawEntries.length
+            });
+        });
+        archive.on('warning', (err) => {
+            if (err.code === 'ENOENT') {
+                console.warn(err);
+            }
+            else {
+                reject(err);
+            }
+        });
+        archive.on('error', (err) => {
+            reject(err);
+        });
+        archive.pipe(output);
+        if (files && files.length > 0) {
+            files.forEach(pattern => {
+                const fullPath = path.resolve(sourceDir, pattern);
+                if (fs.existsSync(fullPath)) {
+                    const stat = fs.statSync(fullPath);
+                    if (stat.isDirectory()) {
+                        archive.directory(fullPath, pattern);
+                    }
+                    else {
+                        archive.file(fullPath, { name: pattern });
+                    }
+                }
+                else {
+                    archive.glob(pattern, { cwd: sourceDir, ignore: IGNORED });
+                }
+            });
+        }
+        else {
+            archive.glob('**/*', { cwd: sourceDir, ignore: IGNORED });
+        }
+        archive.finalize();
+    });
+}

package/dist/serve.js

@@ -0,0 +1,208 @@
+import { spawn, spawnSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { randomToken, readLocalEnv, writeLocalEnvValue, getKiteHome } from './home.js';
+function getServerBundlePath() {
+    // dist/server/index.js relative to this compiled file (dist/serve.js)
+    const bundlePath = path.resolve(new URL('../dist/server/index.js', import.meta.url).pathname);
+    return bundlePath;
+}
+function getWebDirPath() {
+    return path.resolve(new URL('../dist/web', import.meta.url).pathname);
+}
+function detectRuntime(preferred) {
+    const checkRuntime = (name) => {
+        const result = spawnSync(name, ['--version'], { stdio: 'pipe' });
+        if (result.error)
+            return null;
+        const ver = result.stdout.toString().trim();
+        return { name, version: name === 'bun' ? `v${ver}` : ver };
+    };
+    if (preferred) {
+        const rt = checkRuntime(preferred);
+        if (!rt) {
+            console.error(chalk.red(`${preferred} is not installed.`));
+            process.exit(1);
+        }
+        return rt;
+    }
+    // Default: try bun first, fallback to node
+    return checkRuntime('bun') || checkRuntime('node') || (() => {
+        console.error(chalk.red('Neither Bun nor Node.js is installed.'));
+        console.error(chalk.gray('Install Bun from https://bun.sh or Node.js from https://nodejs.org'));
+        process.exit(1);
+    });
+}
+function ensureAdminToken() {
+    const localEnv = readLocalEnv();
+    if (localEnv.KITE_DEPLOY_TOKEN) {
+        // Use existing token from .env.local
+        // But we need ADMIN_TOKEN specifically
+    }
+    // Check if ADMIN_TOKEN already exists in .env.local
+    const envPath = path.join(process.cwd(), '.env.local');
+    if (fs.existsSync(envPath)) {
+        const content = fs.readFileSync(envPath, 'utf-8');
+        const match = content.match(/^ADMIN_TOKEN=(.+)$/m);
+        if (match) {
+            return match[1].replace(/^['"]|['"]$/g, '');
+        }
+    }
+    // Generate a new admin token
+    const token = randomToken('admin');
+    writeLocalEnvValue('ADMIN_TOKEN', token);
+    return token;
+}
+function buildServerEnv(options, adminToken) {
+    const cliPkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url).pathname, 'utf-8'));
+    return {
+        ...process.env,
+        PORT: String(options.port),
+        HOST: options.host,
+        ADMIN_TOKEN: adminToken,
+        KITE_WEB_DIR: getWebDirPath(),
+        KITE_DB_DIR: getKiteHome(),
+        KITE_SERVER_VERSION: cliPkg.version || '1.0.0',
+    };
+}
+function startForeground(options, env, runtime) {
+    const bundlePath = getServerBundlePath();
+    if (!fs.existsSync(bundlePath)) {
+        console.error(chalk.red(`Server bundle not found at ${bundlePath}`));
+        console.error(chalk.gray('Run the build step first: bun run build'));
+        process.exit(1);
+    }
+    console.log(chalk.green('Starting Kite Server...'));
+    console.log(chalk.gray(`  Runtime: ${runtime.name} ${runtime.version}`));
+    console.log(chalk.gray(`  Host: ${options.host}`));
+    console.log(chalk.gray(`  Port: ${options.port}`));
+    console.log(chalk.gray(`  Web Dir: ${env.KITE_WEB_DIR}`));
+    console.log(chalk.gray(`  DB Dir: ${env.KITE_DB_DIR}`));
+    console.log(chalk.yellow(`  Admin Token: ${env.ADMIN_TOKEN}`));
+    console.log();
+    const args = runtime.name === 'bun' ? ['run', bundlePath] : [bundlePath];
+    const child = spawn(runtime.name, args, {
+        stdio: 'inherit',
+        env,
+        cwd: process.cwd(),
+    });
+    let shuttingDown = false;
+    child.on('error', (err) => {
+        console.error(chalk.red(`Failed to start server: ${err.message}`));
+        process.exit(1);
+    });
+    child.on('exit', (code, signal) => {
+        if (!shuttingDown) {
+            shuttingDown = true;
+            if (signal) {
+                console.log(chalk.gray(`\nServer stopped by signal ${signal}`));
+            }
+            else {
+                console.log(chalk.gray(`\nServer exited with code ${code}`));
+            }
+        }
+        process.exit(code ?? 0);
+    });
+    // Graceful shutdown on SIGINT/SIGTERM
+    const shutdown = (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        console.log(chalk.gray(`\nReceived ${signal}, shutting down server...`));
+        child.kill('SIGTERM');
+        // Force kill after 5s if child doesn't exit
+        setTimeout(() => {
+            console.log(chalk.yellow('Force killing server...'));
+            child.kill('SIGKILL');
+            process.exit(1);
+        }, 5000).unref();
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+}
+function getPm2Dir() {
+    const dir = path.join(getKiteHome(), 'pm2');
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function startPm2(options, env, runtime) {
+    const bundlePath = getServerBundlePath();
+    if (!fs.existsSync(bundlePath)) {
+        console.error(chalk.red(`Server bundle not found at ${bundlePath}`));
+        console.error(chalk.gray('Run the build step first: bun run build'));
+        process.exit(1);
+    }
+    // Check pm2 availability
+    const pm2Check = spawnSync('pm2', ['--version'], { stdio: 'pipe' });
+    if (pm2Check.error) {
+        console.error(chalk.red('pm2 is not installed.'));
+        console.error(chalk.gray('Install it with: npm install -g pm2'));
+        console.error(chalk.gray('Or run without --pm2 for foreground mode.'));
+        process.exit(1);
+    }
+    // Stop existing process if running
+    spawnSync('pm2', ['delete', 'kite-server'], { stdio: 'pipe' });
+    const pm2Dir = getPm2Dir();
+    const configPath = path.join(pm2Dir, 'ecosystem.config.cjs');
+    const pm2Args = runtime.name === 'bun' ? `run ${bundlePath}` : bundlePath;
+    const config = `module.exports = {
+  apps: [{
+    name: 'kite-server',
+    script: '${runtime.name}',
+    args: '${pm2Args}',
+    cwd: ${JSON.stringify(process.cwd())},
+    env: ${JSON.stringify(env, null, 6)},
+    max_restarts: 5,
+    min_uptime: '10s',
+    error_file: ${JSON.stringify(path.join(pm2Dir, 'error.log'))},
+    out_file: ${JSON.stringify(path.join(pm2Dir, 'out.log'))},
+    merge_logs: true,
+  }]
+};
+`;
+    fs.writeFileSync(configPath, config);
+    const result = spawnSync('pm2', ['start', configPath], { stdio: 'inherit' });
+    if (result.error) {
+        console.error(chalk.red(`Failed to start pm2: ${result.error.message}`));
+        process.exit(1);
+    }
+    console.log();
+    console.log(chalk.green('Kite Server started with pm2!'));
+    console.log(chalk.gray(`  Name: kite-server`));
+    console.log(chalk.gray(`  Runtime: ${runtime.name} ${runtime.version}`));
+    console.log(chalk.gray(`  Host: ${options.host}`));
+    console.log(chalk.gray(`  Port: ${options.port}`));
+    console.log(chalk.gray(`  Web Dir: ${env.KITE_WEB_DIR}`));
+    console.log(chalk.gray(`  DB Dir: ${env.KITE_DB_DIR}`));
+    console.log(chalk.yellow(`  Admin Token: ${env.ADMIN_TOKEN}`));
+    console.log();
+    console.log(chalk.gray('Commands:'));
+    console.log(chalk.gray('  pm2 logs kite-server    # View logs'));
+    console.log(chalk.gray('  pm2 status              # Check status'));
+    console.log(chalk.gray('  kite serve --pm2 stop   # Stop server'));
+}
+function stopPm2() {
+    const result = spawnSync('pm2', ['delete', 'kite-server'], { stdio: 'inherit' });
+    if (result.error) {
+        console.error(chalk.red(`Failed to stop pm2: ${result.error.message}`));
+        process.exit(1);
+    }
+    console.log(chalk.green('Kite Server stopped.'));
+}
+export async function startServe(options) {
+    // Handle pm2 stop
+    if (options.pm2 && options.pm2Action === 'stop') {
+        stopPm2();
+        return;
+    }
+    const runtime = detectRuntime(options.runtime);
+    const adminToken = ensureAdminToken();
+    const env = buildServerEnv(options, adminToken);
+    if (options.pm2) {
+        startPm2(options, env, runtime);
+    }
+    else {
+        startForeground(options, env, runtime);
+    }
+}