pilotswarm-cli 0.1.12 → 0.1.13

package/src/bootstrap-env.js

@@ -0,0 +1,187 @@
+import { parseArgs } from "node:util";
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkgRoot = path.resolve(__dirname, "..");
+const defaultTuiSplashPath = path.join(pkgRoot, "tui-splash.txt");
+
+function readPluginMetadata(pluginDir) {
+    if (!pluginDir) return null;
+    const pluginJsonPath = path.join(pluginDir, "plugin.json");
+    if (!fs.existsSync(pluginJsonPath)) return null;
+    try {
+        return JSON.parse(fs.readFileSync(pluginJsonPath, "utf-8"));
+    } catch (error) {
+        throw new Error(`Failed to parse plugin metadata: ${pluginJsonPath}: ${error.message}`);
+    }
+}
+
+function resolvePluginDir(flags) {
+    if (flags.plugin) return path.resolve(flags.plugin);
+    if (process.env.PLUGIN_DIRS) {
+        const dirs = process.env.PLUGIN_DIRS.split(",").map((value) => value.trim()).filter(Boolean);
+        return dirs[0] || null;
+    }
+    const cwdPlugin = path.resolve("plugins");
+    if (fs.existsSync(cwdPlugin)) return cwdPlugin;
+    const bundledPlugin = path.join(pkgRoot, "plugins");
+    if (fs.existsSync(bundledPlugin)) return bundledPlugin;
+    return null;
+}
+
+function resolveSystemMessage(flags) {
+    if (flags.system) {
+        if (fs.existsSync(flags.system)) {
+            return fs.readFileSync(flags.system, "utf-8").trim();
+        }
+        return flags.system;
+    }
+
+    const pluginDir = resolvePluginDir(flags);
+    if (pluginDir) {
+        const systemMd = path.join(pluginDir, "system.md");
+        if (fs.existsSync(systemMd)) {
+            return fs.readFileSync(systemMd, "utf-8").trim();
+        }
+    }
+
+    if (process.env.SYSTEM_MESSAGE) return process.env.SYSTEM_MESSAGE;
+    return undefined;
+}
+
+function resolveTuiBranding(pluginDir) {
+    const pluginMeta = readPluginMetadata(pluginDir);
+    const tui = pluginMeta?.tui;
+    let defaultSplash = "{bold}{cyan-fg}PilotSwarm{/cyan-fg}{/bold}";
+    if (fs.existsSync(defaultTuiSplashPath)) {
+        defaultSplash = fs.readFileSync(defaultTuiSplashPath, "utf-8").trimEnd();
+    }
+    if (!tui || typeof tui !== "object") {
+        return { title: "PilotSwarm", splash: defaultSplash };
+    }
+
+    const title = typeof tui.title === "string" && tui.title.trim() ? tui.title.trim() : "PilotSwarm";
+    let splash = defaultSplash;
+    if (typeof tui.splash === "string" && tui.splash.trim()) {
+        splash = tui.splash;
+    } else if (typeof tui.splashFile === "string" && tui.splashFile.trim()) {
+        const splashPath = path.resolve(pluginDir, tui.splashFile);
+        if (!fs.existsSync(splashPath)) {
+            throw new Error(`TUI splash file not found: ${splashPath}`);
+        }
+        splash = fs.readFileSync(splashPath, "utf-8").trimEnd();
+    }
+    return { title, splash };
+}
+
+function loadEnvFile(envFile) {
+    if (!fs.existsSync(envFile)) return;
+    const envContent = fs.readFileSync(envFile, "utf-8");
+    for (const line of envContent.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx === -1) continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        const value = trimmed.slice(eqIdx + 1).trim();
+        if (!process.env[key]) {
+            process.env[key] = value;
+        }
+    }
+}
+
+function ensureGithubToken() {
+    if (process.env.GITHUB_TOKEN) return;
+    try {
+        const token = execFileSync("gh", ["auth", "token"], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (token) {
+            process.env.GITHUB_TOKEN = token;
+        }
+    } catch {}
+}
+
+export function parseCliIntoEnv(argv) {
+    const { values: flags, positionals } = parseArgs({
+        options: {
+            store: { type: "string", short: "s" },
+            env: { type: "string", short: "e" },
+            plugin: { type: "string", short: "p" },
+            worker: { type: "string", short: "w" },
+            workers: { type: "string", short: "n" },
+            model: { type: "string", short: "m" },
+            system: { type: "string" },
+            context: { type: "string", short: "c" },
+            namespace: { type: "string" },
+            label: { type: "string" },
+            help: { type: "boolean", short: "h" },
+        },
+        allowPositionals: true,
+        strict: false,
+        args: argv,
+    });
+
+    if (flags.help) {
+        console.log(`
+pilotswarm — PilotSwarm terminal UI
+
+USAGE
+  npx pilotswarm [local|remote] [flags]
+
+FLAGS
+  -e, --env <file>       Env file
+  -p, --plugin <dir>     Plugin directory
+  -w, --worker <module>  Worker tools module
+  -n, --workers <count>  Embedded worker count
+  -m, --model <name>     Initial model
+  -c, --context <ctx>    K8s context for remote mode
+      --namespace <ns>   K8s namespace
+      --label <selector> K8s pod label
+  -h, --help             Show help
+`.trim());
+        process.exit(0);
+    }
+
+    const mode = positionals[0] === "remote" ? "remote" : "local";
+    const envFile = flags.env || (mode === "remote" ? ".env.remote" : ".env");
+    loadEnvFile(envFile);
+    ensureGithubToken();
+
+    process.env.DATABASE_URL = flags.store || process.env.DATABASE_URL || "sqlite::memory:";
+    process.env.WORKERS = mode === "remote" ? "0" : (flags.workers ?? process.env.WORKERS ?? "4");
+    process.env.COPILOT_MODEL = flags.model || process.env.COPILOT_MODEL || "";
+    process.env.K8S_CONTEXT = flags.context || process.env.K8S_CONTEXT || "";
+    process.env.K8S_NAMESPACE = flags.namespace || process.env.K8S_NAMESPACE || "copilot-runtime";
+    process.env.K8S_POD_LABEL = flags.label || process.env.K8S_POD_LABEL || "app.kubernetes.io/component=worker";
+
+    const pluginDir = resolvePluginDir(flags);
+    if (pluginDir) {
+        process.env.PLUGIN_DIRS = pluginDir;
+    }
+
+    const branding = resolveTuiBranding(pluginDir);
+    process.env._TUI_TITLE = branding.title;
+    process.env._TUI_SPLASH = branding.splash;
+
+    const systemMessage = resolveSystemMessage(flags);
+    if (systemMessage) process.env._TUI_SYSTEM_MESSAGE = systemMessage;
+
+    if (mode === "local" && flags.worker) {
+        const resolvedWorker = path.resolve(flags.worker);
+        if (!fs.existsSync(resolvedWorker)) {
+            throw new Error(`Worker module not found: ${resolvedWorker}`);
+        }
+        process.env._TUI_WORKER_MODULE = resolvedWorker;
+    }
+
+    return {
+        mode,
+        store: process.env.DATABASE_URL,
+        branding,
+    };
+}

package/src/embedded-workers.js

@@ -0,0 +1,65 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { createRequire } from "node:module";
+import { PilotSwarmWorker } from "pilotswarm-sdk";
+
+export async function startEmbeddedWorkers({ count, store }) {
+    const workers = [];
+    if (!count || count <= 0) return workers;
+
+    const defaultPluginDir = path.resolve(process.cwd(), "packages/cli/plugins");
+    const pluginDirs = process.env.PLUGIN_DIRS
+        ? process.env.PLUGIN_DIRS.split(",").map((value) => value.trim()).filter(Boolean)
+        : (fs.existsSync(defaultPluginDir) ? [defaultPluginDir] : []);
+
+    let workerModuleConfig = {};
+    if (process.env._TUI_WORKER_MODULE) {
+        const imported = await import(process.env._TUI_WORKER_MODULE);
+        workerModuleConfig = imported.default || imported;
+    }
+
+    const sessionStateDir = process.env.SESSION_STATE_DIR || path.join(os.homedir(), ".copilot", "session-state");
+    const originalConsole = {
+        log: console.log,
+        warn: console.warn,
+        error: console.error,
+    };
+
+    for (let index = 0; index < count; index++) {
+        console.log = () => {};
+        console.warn = () => {};
+        console.error = () => {};
+        try {
+            const worker = new PilotSwarmWorker({
+                store,
+                githubToken: process.env.GITHUB_TOKEN,
+                logLevel: process.env.LOG_LEVEL || "error",
+                sessionStateDir,
+                workerNodeId: `local-${index}`,
+                systemMessage: workerModuleConfig.systemMessage || process.env._TUI_SYSTEM_MESSAGE || undefined,
+                pluginDirs,
+            });
+
+            const workerTools = typeof workerModuleConfig.createTools === "function"
+                ? await workerModuleConfig.createTools({ workerNodeId: `local-${index}`, workerIndex: index })
+                : workerModuleConfig.tools;
+            if (workerTools?.length) {
+                worker.registerTools(workerTools);
+            }
+
+            await worker.start();
+            workers.push(worker);
+        } finally {
+            console.log = originalConsole.log;
+            console.warn = originalConsole.warn;
+            console.error = originalConsole.error;
+        }
+    }
+
+    return workers;
+}
+
+export async function stopEmbeddedWorkers(workers) {
+    await Promise.allSettled((workers || []).map((worker) => worker.stop()));
+}

package/src/index.js

@@ -0,0 +1,152 @@
+import React from "react";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import { render } from "ink";
+import {
+    PilotSwarmUiController,
+    appReducer,
+    createInitialState,
+    createStore,
+} from "pilotswarm-ui-core";
+import { PilotSwarmTuiApp } from "./app.js";
+import { createTuiPlatform } from "./platform.js";
+import { NodeSdkTransport } from "./node-sdk-transport.js";
+
+const require = createRequire(import.meta.url);
+
+function setupTuiHostRuntime() {
+    const logFile = "/tmp/duroxide-tui.log";
+    const originalConsole = {
+        log: console.log.bind(console),
+        warn: console.warn.bind(console),
+        error: console.error.bind(console),
+    };
+    const originalStderrWrite = process.stderr.write.bind(process.stderr);
+    const originalEmitWarning = process.emitWarning.bind(process);
+
+    try {
+        fs.writeFileSync(logFile, "");
+    } catch {}
+
+    try {
+        const { initTracing } = require("duroxide");
+        initTracing({
+            logFile,
+            logLevel: process.env.LOG_LEVEL || "info",
+            logFormat: "compact",
+        });
+    } catch {}
+
+    const appendLog = (...parts) => {
+        try {
+            const text = parts
+                .map((part) => {
+                    if (typeof part === "string") return part;
+                    if (part instanceof Error) return part.stack || part.message;
+                    try { return JSON.stringify(part); } catch { return String(part); }
+                })
+                .join(" ");
+            fs.appendFileSync(logFile, `${text}\n`);
+        } catch {}
+    };
+
+    console.log = (...args) => appendLog(...args);
+    console.warn = (...args) => appendLog(...args);
+    console.error = (...args) => appendLog(...args);
+
+    process.stderr.write = (chunk, encoding, cb) => {
+        try {
+            const text = typeof chunk === "string" ? chunk : chunk?.toString?.(encoding || "utf8");
+            if (text) appendLog(text.trimEnd());
+        } catch {}
+        if (typeof cb === "function") cb();
+        return true;
+    };
+
+    process.emitWarning = (warning, ...args) => {
+        appendLog("[warning]", warning, ...args);
+    };
+
+    return () => {
+        console.log = originalConsole.log;
+        console.warn = originalConsole.warn;
+        console.error = originalConsole.error;
+        process.stderr.write = originalStderrWrite;
+        process.emitWarning = originalEmitWarning;
+    };
+}
+
+function clearTerminalScreen() {
+    if (!process.stdout?.isTTY) return;
+    try {
+        process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+    } catch {}
+}
+
+export async function startTuiApp(config) {
+    const restoreHostRuntime = setupTuiHostRuntime();
+    const platform = createTuiPlatform();
+    const transport = new NodeSdkTransport({
+        store: config.store,
+        mode: config.mode,
+    });
+    const store = createStore(appReducer, createInitialState({
+        mode: config.mode,
+        branding: config.branding,
+    }));
+    const controller = new PilotSwarmUiController({ store, transport });
+    let tuiApp;
+    let finalized = false;
+    let resolveExit;
+    const exitPromise = new Promise((resolve) => {
+        resolveExit = resolve;
+    });
+
+    const finalizeHost = () => {
+        if (finalized) return;
+        finalized = true;
+        try {
+            tuiApp?.cleanup?.();
+        } catch {}
+        restoreHostRuntime();
+        clearTerminalScreen();
+        resolveExit?.();
+    };
+
+    const requestExit = async () => {
+        const forceExitTimer = setTimeout(() => {
+            finalizeHost();
+            process.exit(0);
+        }, 5000);
+        forceExitTimer.unref?.();
+
+        try {
+            await controller.stop();
+        } catch {}
+        finally {
+            clearTimeout(forceExitTimer);
+            try {
+                tuiApp?.clear?.();
+            } catch {}
+            try {
+                tuiApp?.unmount();
+            } catch {}
+            finalizeHost();
+            process.exit(0);
+        }
+    };
+
+    tuiApp = render(React.createElement(PilotSwarmTuiApp, {
+        controller,
+        platform,
+        onRequestExit: requestExit,
+    }), {
+        exitOnCtrlC: false,
+    });
+
+    try {
+        await exitPromise;
+    } finally {
+        finalizeHost();
+    }
+}