pilotswarm-cli 0.1.15 → 0.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pilotswarm-cli",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "Terminal UI for PilotSwarm.",
   "type": "module",
   "bin": {
@@ -14,6 +14,7 @@
   },
   "scripts": {
     "build": "echo 'pilotswarm-cli: no build step (plain JS)'",
+    "prepack": "node ./src/sync-workspace-ui.js",
     "start": "node ./bin/tui.js local --env ../../.env.remote",
     "start:remote": "node ./bin/tui.js remote --env ../../.env.remote",
     "clean": "true"
@@ -37,7 +38,7 @@
   },
   "dependencies": {
     "ink": "^6.8.0",
-    "pilotswarm-sdk": "^0.1.15",
+    "pilotswarm-sdk": "^0.1.17",
     "pilotswarm-ui-core": "0.1.0",
     "pilotswarm-ui-react": "0.1.0",
     "react": "^19.2.4"
@@ -45,6 +46,10 @@
   "engines": {
     "node": ">=24.0.0"
   },
+  "bundledDependencies": [
+    "pilotswarm-ui-core",
+    "pilotswarm-ui-react"
+  ],
   "files": [
     "bin/**/*",
     "src/**/*",

package/src/app.js

@@ -2,6 +2,7 @@ import React from "react";
 import { useInput, useStdin } from "ink";
 import { UiPlatformProvider, SharedPilotSwarmApp } from "pilotswarm-ui-react";
 import { UI_COMMANDS } from "pilotswarm-ui-core";
+import { PILOTSWARM_CLI_VERSION_LABEL } from "./version.js";
 
 const MOUSE_INPUT_PATTERN = /\u001b\[<(\d+);(\d+);(\d+)([mM])/gu;
 const MOUSE_INPUT_FRAGMENT_PATTERN = /(?:\u001b)?\[<\d+;\d+;\d+[mM]/u;
@@ -281,6 +282,17 @@ export function PilotSwarmTuiApp({ controller, platform, onRequestExit }) {
                 controller.handleCommand(UI_COMMANDS.CLOSE_MODAL).catch(() => {});
                 return;
             }
+            if (modal.type === "confirm") {
+                if (key.escape || input === "n" || input === "q") {
+                    controller.handleCommand(UI_COMMANDS.CLOSE_MODAL).catch(() => {});
+                    return;
+                }
+                if (key.return || input === "y") {
+                    controller.handleCommand(UI_COMMANDS.MODAL_CONFIRM).catch(() => {});
+                    return;
+                }
+                return;
+            }
             if (modal.type === "renameSession" || modal.type === "artifactUpload") {
                 if (key.escape) {
                     controller.handleCommand(UI_COMMANDS.CLOSE_MODAL).catch(() => {});
@@ -646,5 +658,8 @@ export function PilotSwarmTuiApp({ controller, platform, onRequestExit }) {
     });
 
     return React.createElement(UiPlatformProvider, { platform },
-        React.createElement(SharedPilotSwarmApp, { controller }));
+        React.createElement(SharedPilotSwarmApp, {
+            controller,
+            versionLabel: PILOTSWARM_CLI_VERSION_LABEL,
+        }));
 }

package/src/node-sdk-transport.js

@@ -13,7 +13,9 @@ import {
 import { startEmbeddedWorkers, stopEmbeddedWorkers } from "./embedded-workers.js";
 import { getPluginDirsFromEnv } from "./plugin-config.js";
 
-const EXPORTS_DIR = path.join(os.homedir(), "pilotswarm-exports");
+const EXPORTS_DIR = path.resolve(
+    expandUserPath(process.env.PILOTSWARM_EXPORT_DIR || path.join(os.homedir(), "pilotswarm-exports")),
+);
 fs.mkdirSync(EXPORTS_DIR, { recursive: true });
 const K8S_SERVICE_ACCOUNT_DIR = "/var/run/secrets/kubernetes.io/serviceaccount";
 
@@ -218,6 +220,73 @@ function expandUserPath(filePath) {
         : value;
 }
 
+function getLocalLogDir() {
+    const configured = expandUserPath(process.env.PILOTSWARM_LOG_DIR || "");
+    return configured ? path.resolve(configured) : "";
+}
+
+function listLocalLogFiles(logDir) {
+    if (!logDir || !fileExists(logDir)) return [];
+    try {
+        return fs.readdirSync(logDir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".log"))
+            .map((entry) => path.join(logDir, entry.name))
+            .sort();
+    } catch {
+        return [];
+    }
+}
+
+function readRecentLogLines(filePath, maxBytes = 128 * 1024, maxLines = 200) {
+    try {
+        const stats = fs.statSync(filePath);
+        if (!stats.isFile() || stats.size <= 0) return [];
+        const fd = fs.openSync(filePath, "r");
+        try {
+            const bytesToRead = Math.min(stats.size, maxBytes);
+            const buffer = Buffer.alloc(bytesToRead);
+            fs.readSync(fd, buffer, 0, bytesToRead, stats.size - bytesToRead);
+            let text = buffer.toString("utf8");
+            if (bytesToRead < stats.size) {
+                const newlineIndex = text.indexOf("\n");
+                text = newlineIndex >= 0 ? text.slice(newlineIndex + 1) : "";
+            }
+            return text
+                .split(/\r?\n/u)
+                .map((line) => line.trimEnd())
+                .filter(Boolean)
+                .slice(-maxLines);
+        } finally {
+            fs.closeSync(fd);
+        }
+    } catch {
+        return [];
+    }
+}
+
+function readLogChunk(filePath, start, end) {
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) return "";
+    try {
+        const fd = fs.openSync(filePath, "r");
+        try {
+            const length = end - start;
+            const buffer = Buffer.alloc(length);
+            const bytesRead = fs.readSync(fd, buffer, 0, length, start);
+            return buffer.toString("utf8", 0, bytesRead);
+        } finally {
+            fs.closeSync(fd);
+        }
+    } catch {
+        return "";
+    }
+}
+
+function getLocalLogPollIntervalMs() {
+    const value = Number.parseInt(process.env.PILOTSWARM_LOG_POLL_INTERVAL_MS || "", 10);
+    if (Number.isFinite(value) && value >= 50) return value;
+    return 500;
+}
+
 function guessArtifactContentType(filename) {
     const ext = path.extname(String(filename || "")).toLowerCase();
     if (ext === ".md" || ext === ".markdown" || ext === ".mdx") return "text/markdown";
@@ -388,6 +457,17 @@ export class NodeSdkTransport {
     }
 
     getLogConfig() {
+        const localLogDir = getLocalLogDir();
+        if (localLogDir) {
+            const exists = fileExists(localLogDir);
+            return {
+                available: exists,
+                availabilityReason: exists
+                    ? ""
+                    : `Log tailing disabled: local log directory ${JSON.stringify(localLogDir)} does not exist.`,
+            };
+        }
+
         const hasInClusterConfig = hasInClusterK8sAccess();
         const hasKubectlConfig = hasExplicitKubectlConfig();
         if (hasInClusterConfig) {
@@ -970,10 +1050,103 @@ export class NodeSdkTransport {
         });
     }
 
+    startLocalLogProcess() {
+        const logDir = getLocalLogDir();
+        if (!logDir || this.logTailHandle) return;
+
+        const handle = {
+            stopped: false,
+            files: new Map(),
+            interval: null,
+            stop: () => {
+                if (handle.stopped) return;
+                handle.stopped = true;
+                if (handle.interval) {
+                    clearInterval(handle.interval);
+                    handle.interval = null;
+                }
+                handle.files.clear();
+            },
+        };
+        this.logTailHandle = handle;
+
+        const emitLine = (filePath, line) => {
+            const text = String(line || "").trim();
+            if (!text) return;
+            const pseudoPod = path.basename(filePath, path.extname(filePath));
+            this.logEntryCounter += 1;
+            this.emitLogEntry(buildLogEntry(`[pod/${pseudoPod}] ${text}`, this.logEntryCounter));
+        };
+
+        const refresh = () => {
+            if (handle.stopped || this.logTailHandle !== handle) return;
+            for (const filePath of listLocalLogFiles(logDir)) {
+                let state = handle.files.get(filePath);
+                let stats;
+                try {
+                    stats = fs.statSync(filePath);
+                } catch {
+                    continue;
+                }
+                if (!stats.isFile()) continue;
+
+                if (!state) {
+                    state = {
+                        position: stats.size,
+                        inode: stats.ino,
+                        buffer: "",
+                    };
+                    handle.files.set(filePath, state);
+                    for (const line of readRecentLogLines(filePath)) {
+                        emitLine(filePath, line);
+                    }
+                    state.position = stats.size;
+                    state.inode = stats.ino;
+                    continue;
+                }
+
+                if (state.inode !== stats.ino || stats.size < state.position) {
+                    state.position = 0;
+                    state.buffer = "";
+                    state.inode = stats.ino;
+                }
+
+                if (stats.size <= state.position) continue;
+
+                const chunk = readLogChunk(filePath, state.position, stats.size);
+                state.position = stats.size;
+                if (!chunk) continue;
+                const combined = state.buffer + chunk;
+                const lines = combined.split(/\r?\n/u);
+                state.buffer = lines.pop() || "";
+                for (const line of lines) {
+                    emitLine(filePath, line);
+                }
+            }
+        };
+
+        try {
+            refresh();
+            handle.interval = setInterval(refresh, getLocalLogPollIntervalMs());
+            if (typeof handle.interval.unref === "function") {
+                handle.interval.unref();
+            }
+        } catch (error) {
+            this.logTailHandle = null;
+            handle.stop();
+            this.emitSyntheticLogMessage(error?.message || String(error), "error", "local-log");
+        }
+    }
+
     startLogProcess() {
         const config = this.getLogConfig();
         if (!config.available || this.logProc || this.logTailHandle) return;
 
+        if (getLocalLogDir()) {
+            this.startLocalLogProcess();
+            return;
+        }
+
         if (hasInClusterK8sAccess()) {
             this.startInClusterLogProcess();
             return;

package/src/sync-workspace-ui.js

@@ -0,0 +1,53 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const BUNDLED_UI_PACKAGES = ["pilotswarm-ui-core", "pilotswarm-ui-react"];
+
+function copyTree(sourceDir, targetDir) {
+    fs.mkdirSync(targetDir, { recursive: true });
+    for (const entry of fs.readdirSync(sourceDir, { withFileTypes: true })) {
+        const sourcePath = path.join(sourceDir, entry.name);
+        const targetPath = path.join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            copyTree(sourcePath, targetPath);
+            continue;
+        }
+        fs.copyFileSync(sourcePath, targetPath);
+    }
+}
+
+export function syncBundledWorkspaceUiPackages({ cliPackageDir = path.resolve(__dirname, "..") } = {}) {
+    const packagesDir = path.resolve(cliPackageDir, "..");
+    const syncedPackages = [];
+
+    for (const packageName of BUNDLED_UI_PACKAGES) {
+        const workspaceDir = path.join(packagesDir, packageName.replace("pilotswarm-", ""));
+        const sourcePackageJson = path.join(workspaceDir, "package.json");
+        const sourceReadme = path.join(workspaceDir, "README.md");
+        const sourceSrcDir = path.join(workspaceDir, "src");
+        if (!fs.existsSync(sourcePackageJson) || !fs.existsSync(sourceSrcDir)) {
+            continue;
+        }
+
+        const targetDir = path.join(cliPackageDir, "node_modules", packageName);
+        fs.rmSync(targetDir, { recursive: true, force: true });
+        fs.mkdirSync(targetDir, { recursive: true });
+        fs.copyFileSync(sourcePackageJson, path.join(targetDir, "package.json"));
+        if (fs.existsSync(sourceReadme)) {
+            fs.copyFileSync(sourceReadme, path.join(targetDir, "README.md"));
+        }
+        copyTree(sourceSrcDir, path.join(targetDir, "src"));
+        syncedPackages.push(packageName);
+    }
+
+    return syncedPackages;
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    const syncedPackages = syncBundledWorkspaceUiPackages();
+    if (syncedPackages.length > 0) {
+        console.log(`[sync-workspace-ui] synced ${syncedPackages.join(", ")}`);
+    }
+}

package/src/version.js

@@ -0,0 +1,7 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const cliPackageJson = require("../package.json");
+
+export const PILOTSWARM_CLI_VERSION = String(cliPackageJson?.version || "0.0.0");
+export const PILOTSWARM_CLI_VERSION_LABEL = `v${PILOTSWARM_CLI_VERSION}`;