pilotswarm-cli 0.1.14 → 0.1.15

package/README.md

@@ -22,6 +22,9 @@ npx pilotswarm local --env .env --plugin ./plugin --worker ./worker-module.js
 
 `pilotswarm-cli` provides the shipped TUI. Your app customizes it with `plugin/plugin.json`, `plugin/agents/*.agent.md`, `plugin/skills/*/SKILL.md`, and optional worker-side tools.
 
+Portal/runtime helpers that are intentionally shared with `pilotswarm-web`
+are exported from `pilotswarm-cli/portal`.
+
 Common docs:
 
 - CLI apps: `https://github.com/affandar/PilotSwarm/blob/main/docs/cli/building-cli-apps.md`

package/bin/tui.js

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 
-import { parseCliIntoEnv } from "../src/bootstrap-env.js";
-import { startTuiApp } from "../src/index.js";
+// Force the shipped TUI onto production React/Ink unless the caller
+// explicitly opts into another environment for debugging.
+process.env.NODE_ENV ??= "production";
 
+const { parseCliIntoEnv } = await import("../src/bootstrap-env.js");
 const config = parseCliIntoEnv(process.argv.slice(2));
+const { startTuiApp } = await import("../src/index.js");
 await startTuiApp(config);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pilotswarm-cli",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "Terminal UI for PilotSwarm.",
   "type": "module",
   "bin": {
@@ -9,7 +9,8 @@
   },
   "main": "./src/index.js",
   "exports": {
-    ".": "./src/index.js"
+    ".": "./src/index.js",
+    "./portal": "./src/portal.js"
   },
   "scripts": {
     "build": "echo 'pilotswarm-cli: no build step (plain JS)'",
@@ -36,7 +37,7 @@
   },
   "dependencies": {
     "ink": "^6.8.0",
-    "pilotswarm-sdk": "^0.1.12",
+    "pilotswarm-sdk": "^0.1.15",
     "pilotswarm-ui-core": "0.1.0",
     "pilotswarm-ui-react": "0.1.0",
     "react": "^19.2.4"

package/src/app.js

@@ -231,6 +231,7 @@ export function PilotSwarmTuiApp({ controller, platform, onRequestExit }) {
         const focus = controller.getState().ui.focusRegion;
         const modal = controller.getState().ui.modal;
         const inspectorTab = controller.getState().ui.inspectorTab;
+        const fullscreenPane = controller.getState().ui.fullscreenPane || null;
         const plainShortcut = isPlainShortcutKey(key);
         const matchesCtrlKey = (name, controlChar) => key.ctrl
             && (key.name === name || input === name || input === controlChar);
@@ -357,6 +358,9 @@ export function PilotSwarmTuiApp({ controller, platform, onRequestExit }) {
             return;
         }
         if (key.tab) {
+            if (focus === "prompt" && controller.acceptPromptReferenceAutocomplete()) {
+                return;
+            }
             controller.handleCommand(UI_COMMANDS.FOCUS_NEXT).catch(() => {});
             return;
         }
@@ -364,6 +368,15 @@ export function PilotSwarmTuiApp({ controller, platform, onRequestExit }) {
             controller.handleCommand(UI_COMMANDS.TOGGLE_FILE_PREVIEW_FULLSCREEN).catch(() => {});
             return;
         }
+        if (key.escape && fullscreenPane) {
+            if (focus === "prompt") {
+                controller.setPrompt("");
+                controller.setFocus(fullscreenPane);
+                return;
+            }
+            controller.handleCommand(UI_COMMANDS.TOGGLE_PANE_FULLSCREEN).catch(() => {});
+            return;
+        }
         if (key.escape) {
             if (focus === "prompt") {
                 controller.setPrompt("");
@@ -397,6 +410,14 @@ export function PilotSwarmTuiApp({ controller, platform, onRequestExit }) {
             controller.handleCommand(UI_COMMANDS.OPEN_FILES_FILTER).catch(() => {});
             return;
         }
+        if (focus === "inspector" && inspectorTab === "files" && input === "u") {
+            controller.handleCommand(UI_COMMANDS.OPEN_ARTIFACT_UPLOAD).catch(() => {});
+            return;
+        }
+        if (focus === "inspector" && inspectorTab === "files" && input === "a") {
+            controller.handleCommand(UI_COMMANDS.DOWNLOAD_SELECTED_FILE).catch(() => {});
+            return;
+        }
         if (focus === "inspector" && inspectorTab === "history" && input === "f") {
             controller.handleCommand(UI_COMMANDS.OPEN_HISTORY_FORMAT).catch(() => {});
             return;
@@ -413,6 +434,10 @@ export function PilotSwarmTuiApp({ controller, platform, onRequestExit }) {
             controller.handleCommand(UI_COMMANDS.TOGGLE_FILE_PREVIEW_FULLSCREEN).catch(() => {});
             return;
         }
+        if (focus !== "prompt" && input === "v") {
+            controller.handleCommand(UI_COMMANDS.TOGGLE_PANE_FULLSCREEN).catch(() => {});
+            return;
+        }
         if (focus === "inspector" && inspectorTab === "files" && plainShortcut && input === "o") {
             controller.handleCommand(UI_COMMANDS.OPEN_SELECTED_FILE).catch(() => {});
             return;
@@ -436,6 +461,14 @@ export function PilotSwarmTuiApp({ controller, platform, onRequestExit }) {
             controller.handleCommand(UI_COMMANDS.GROW_RIGHT_PANE).catch(() => {});
             return;
         }
+        if (focus !== "prompt" && input === "{") {
+            controller.handleCommand(UI_COMMANDS.SHRINK_SESSION_PANE).catch(() => {});
+            return;
+        }
+        if (focus !== "prompt" && input === "}") {
+            controller.handleCommand(UI_COMMANDS.GROW_SESSION_PANE).catch(() => {});
+            return;
+        }
 
         if (focus === "prompt") {
             if (isCtrlA) {

package/src/bootstrap-env.js

@@ -3,21 +3,10 @@ import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveTuiBranding } from "./plugin-config.js";
 
 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);
@@ -52,31 +41,6 @@ function resolveSystemMessage(flags) {
     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");

package/src/node-sdk-transport.js

@@ -1,5 +1,6 @@
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import fs from "node:fs";
+import https from "node:https";
 import os from "node:os";
 import path from "node:path";
 import {
@@ -10,9 +11,65 @@ import {
     SessionBlobStore,
 } from "pilotswarm-sdk";
 import { startEmbeddedWorkers, stopEmbeddedWorkers } from "./embedded-workers.js";
+import { getPluginDirsFromEnv } from "./plugin-config.js";
 
 const EXPORTS_DIR = path.join(os.homedir(), "pilotswarm-exports");
 fs.mkdirSync(EXPORTS_DIR, { recursive: true });
+const K8S_SERVICE_ACCOUNT_DIR = "/var/run/secrets/kubernetes.io/serviceaccount";
+
+function fileExists(filePath) {
+    try {
+        return fs.existsSync(filePath);
+    } catch {
+        return false;
+    }
+}
+
+function getInClusterK8sPaths() {
+    const baseDir = process.env.PILOTSWARM_K8S_SERVICE_ACCOUNT_DIR || K8S_SERVICE_ACCOUNT_DIR;
+    return {
+        tokenPath: process.env.PILOTSWARM_K8S_TOKEN_PATH || path.join(baseDir, "token"),
+        caPath: process.env.PILOTSWARM_K8S_CA_PATH || path.join(baseDir, "ca.crt"),
+        namespacePath: process.env.PILOTSWARM_K8S_NAMESPACE_PATH || path.join(baseDir, "namespace"),
+    };
+}
+
+function readOptionalTextFile(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf8").trim();
+    } catch {
+        return "";
+    }
+}
+
+function hasInClusterK8sAccess() {
+    const { tokenPath, caPath } = getInClusterK8sPaths();
+    return Boolean(process.env.KUBERNETES_SERVICE_HOST)
+        && fileExists(tokenPath)
+        && fileExists(caPath);
+}
+
+function getInClusterK8sConfig() {
+    if (!hasInClusterK8sAccess()) return null;
+
+    const { tokenPath, caPath, namespacePath } = getInClusterK8sPaths();
+    return {
+        host: String(process.env.KUBERNETES_SERVICE_HOST || "").trim(),
+        port: Number(process.env.KUBERNETES_SERVICE_PORT || 443) || 443,
+        token: readOptionalTextFile(tokenPath),
+        ca: fs.readFileSync(caPath),
+        namespace: String(process.env.K8S_NAMESPACE || "").trim() || readOptionalTextFile(namespacePath) || "default",
+    };
+}
+
+function hasExplicitKubectlConfig() {
+    return Boolean((process.env.K8S_CONTEXT || "").trim() || (process.env.KUBECONFIG || "").trim());
+}
+
+function isKubectlAvailable() {
+    const result = spawnSync("kubectl", ["version", "--client=true"], { stdio: "ignore" });
+    return !result.error;
+}
 
 function stripAnsi(value) {
     return String(value || "").replace(/\x1b\[[0-9;]*m/g, "");
@@ -105,9 +162,14 @@ function buildLogEntry(line, counter) {
     const prefixMatch = line.match(/^\[pod\/([^/\]]+)/);
     const podName = prefixMatch ? prefixMatch[1] : "unknown";
     const rawLine = trimLogText(stripAnsi(line.replace(/^\[pod\/[^\]]+\]\s*/, "")).trim());
-    const orchMatch = rawLine.match(/\b(instance_id|orchestration_id)=(session-[^\s,]+)/i)
+    const orchMatch = rawLine.match(/\b(?:instance_id|orchestration_id|orch)=(session-[^\s,]+)/i)
         || rawLine.match(/\b(session-[0-9a-f-]{8,})\b/i);
-    const orchId = orchMatch ? orchMatch[2] || orchMatch[1] : null;
+    const parsedOrchId = orchMatch ? orchMatch[1] : null;
+    const sessionIdMatch = rawLine.match(/\b(?:sessionId|session|durableSessionId)=([0-9a-f-]{8,})\b/i);
+    const sessionId = sessionIdMatch
+        ? sessionIdMatch[1]
+        : (parsedOrchId && parsedOrchId.startsWith("session-") ? parsedOrchId.slice("session-".length) : null);
+    const orchId = parsedOrchId || (sessionId ? `session-${sessionId}` : null);
     const category = rawLine.includes("duroxide::activity")
             ? "activity"
             : rawLine.includes("duroxide::orchestration") || rawLine.includes("::orchestration")
@@ -120,6 +182,7 @@ function buildLogEntry(line, counter) {
         podName,
         level: normalizeLogLevel(rawLine),
         orchId,
+        sessionId,
         category,
         rawLine,
         message: extractPrettyLogMessage(rawLine),
@@ -127,6 +190,22 @@ function buildLogEntry(line, counter) {
     };
 }
 
+function buildSyntheticLogEntry({ message, level = "info", podName = "k8s", counter = 0 }) {
+    const safeMessage = trimLogText(String(message || "").trim());
+    return {
+        id: `log:${Date.now()}:${counter}`,
+        time: extractLogTime(safeMessage),
+        podName,
+        level,
+        orchId: null,
+        sessionId: null,
+        category: "log",
+        rawLine: safeMessage,
+        message: safeMessage,
+        prettyMessage: safeMessage,
+    };
+}
+
 function sanitizeArtifactFilename(filename) {
     return String(filename || "").replace(/[/\\]/g, "_");
 }
@@ -179,13 +258,6 @@ function isTerminalSendError(error) {
     return /instance is terminal|terminal orchestration|cannot accept new messages/i.test(message);
 }
 
-function getPluginDirsFromEnv() {
-    return String(process.env.PLUGIN_DIRS || "")
-        .split(",")
-        .map((value) => value.trim())
-        .filter(Boolean);
-}
-
 function normalizeCreatableAgent(agent) {
     const name = String(agent?.name || "").trim();
     if (!name) return null;
@@ -235,8 +307,8 @@ function loadSessionCreationMetadataFromPluginDirs(pluginDirs = []) {
 }
 
 function buildTerminalSendError(sessionId, session) {
-    if (session?.status === "failed" || session?.orchestrationStatus === "Failed") {
-        return `Session ${sessionId.slice(0, 8)} is a failed terminal orchestration and cannot accept new messages.`;
+    if (session?.status === "failed" || session?.status === "cancelled" || session?.orchestrationStatus === "Failed") {
+        return `Session ${sessionId.slice(0, 8)} is a terminal orchestration and cannot accept new messages.`;
     }
 
     const statusLabel = String(session?.orchestrationStatus || session?.status || "Unknown");
@@ -256,10 +328,12 @@ export class NodeSdkTransport {
         this.allowedAgentNames = [];
         this.creatableAgents = [];
         this.logProc = null;
+        this.logTailHandle = null;
         this.logBuffer = "";
         this.logRestartTimer = null;
         this.logSubscribers = new Set();
         this.logEntryCounter = 0;
+        this.kubectlAvailable = null;
     }
 
     async start() {
@@ -314,12 +388,30 @@ export class NodeSdkTransport {
     }
 
     getLogConfig() {
-        const hasK8sConfig = Boolean((process.env.K8S_CONTEXT || "").trim() || (process.env.KUBECONFIG || "").trim());
+        const hasInClusterConfig = hasInClusterK8sAccess();
+        const hasKubectlConfig = hasExplicitKubectlConfig();
+        if (hasInClusterConfig) {
+            return {
+                available: true,
+                availabilityReason: "",
+            };
+        }
+
+        if (hasKubectlConfig) {
+            if (this.kubectlAvailable == null) {
+                this.kubectlAvailable = isKubectlAvailable();
+            }
+            return {
+                available: this.kubectlAvailable,
+                availabilityReason: this.kubectlAvailable
+                    ? ""
+                    : "Log tailing disabled: kubectl is not installed in this environment.",
+            };
+        }
+
         return {
-            available: hasK8sConfig,
-            availabilityReason: hasK8sConfig
-                ? ""
-                : "Log tailing disabled: no K8S_CONTEXT configured in the env file.",
+            available: false,
+            availabilityReason: "Log tailing disabled: no K8S_CONTEXT/KUBECONFIG or in-cluster Kubernetes access detected.",
         };
     }
 
@@ -375,11 +467,11 @@ export class NodeSdkTransport {
         if (!session) {
             throw new Error(`Session ${sessionId.slice(0, 8)} was not found.`);
         }
-        if (session.status === "failed" || session.orchestrationStatus === "Failed") {
+        if (session.status === "failed" || session.status === "cancelled" || session.orchestrationStatus === "Failed") {
             throw new Error(buildTerminalSendError(sessionId, session));
         }
         if (
-            session.status === "completed"
+            (session.status === "completed" || session.status === "cancelled")
             && session.parentSessionId
             && !session.isSystem
             && !session.cronActive
@@ -480,6 +572,36 @@ export class NodeSdkTransport {
         };
     }
 
+    async uploadArtifactContent(sessionId, filename, content, contentType = guessArtifactContentType(filename)) {
+        if (!this.artifactStore) {
+            throw new Error("Artifact store is not available for this transport.");
+        }
+        const safeSessionId = String(sessionId || "").trim();
+        const safeFilename = path.basename(String(filename || "").trim());
+        const safeContent = typeof content === "string" ? content : String(content || "");
+        if (!safeSessionId) {
+            throw new Error("Session id is required for artifact upload.");
+        }
+        if (!safeFilename) {
+            throw new Error("Filename is required for artifact upload.");
+        }
+
+        await this.artifactStore.uploadArtifact(
+            safeSessionId,
+            safeFilename,
+            safeContent,
+            contentType || guessArtifactContentType(safeFilename),
+        );
+
+        return {
+            sessionId: safeSessionId,
+            filename: safeFilename,
+            resolvedPath: safeFilename,
+            sizeBytes: Buffer.byteLength(safeContent, "utf8"),
+            contentType: contentType || guessArtifactContentType(safeFilename),
+        };
+    }
+
     getArtifactExportDirectory() {
         return EXPORTS_DIR;
     }
@@ -575,10 +697,19 @@ export class NodeSdkTransport {
     }
 
     emitLogEntry(entry) {
-        for (const handler of this.logSubscribers) {
-            try {
-                handler(entry);
-            } catch {}
+        if (!this._logBatch) this._logBatch = [];
+        this._logBatch.push(entry);
+        if (!this._logBatchTimer) {
+            this._logBatchTimer = setTimeout(() => {
+                const batch = this._logBatch;
+                this._logBatch = [];
+                this._logBatchTimer = null;
+                for (const handler of this.logSubscribers) {
+                    try {
+                        handler(batch);
+                    } catch {}
+                }
+            }, 250);
         }
     }
 
@@ -592,9 +723,208 @@ export class NodeSdkTransport {
         }, 5000);
     }
 
-    startLogProcess() {
+    emitSyntheticLogMessage(message, level = "info", podName = "k8s") {
+        this.logEntryCounter += 1;
+        this.emitLogEntry(buildSyntheticLogEntry({
+            message,
+            level,
+            podName,
+            counter: this.logEntryCounter,
+        }));
+    }
+
+    async listPodsFromKubeApi(config, labelSelector) {
+        const params = new URLSearchParams();
+        if (labelSelector) params.set("labelSelector", labelSelector);
+        const pathName = `/api/v1/namespaces/${encodeURIComponent(config.namespace)}/pods${params.size > 0 ? `?${params.toString()}` : ""}`;
+
+        return await new Promise((resolve, reject) => {
+            const req = https.request({
+                method: "GET",
+                hostname: config.host,
+                port: config.port,
+                path: pathName,
+                ca: config.ca,
+                headers: {
+                    Authorization: `Bearer ${config.token}`,
+                    Accept: "application/json",
+                },
+            }, (res) => {
+                let body = "";
+                res.setEncoding("utf8");
+                res.on("data", (chunk) => {
+                    body += chunk;
+                });
+                res.on("end", () => {
+                    if ((res.statusCode || 0) >= 400) {
+                        reject(new Error(
+                            `Kubernetes API pod list failed (${res.statusCode}): ${trimLogText(body || res.statusMessage || "unknown error")}`,
+                        ));
+                        return;
+                    }
+                    try {
+                        const payload = JSON.parse(body || "{}");
+                        const items = Array.isArray(payload?.items) ? payload.items : [];
+                        resolve(items
+                            .map((item) => String(item?.metadata?.name || "").trim())
+                            .filter(Boolean));
+                    } catch (error) {
+                        reject(error);
+                    }
+                });
+            });
+
+            req.on("error", reject);
+            req.end();
+        });
+    }
+
+    streamPodLogsFromKubeApi(config, podName, handle, options = {}) {
+        const params = new URLSearchParams({
+            follow: "true",
+            timestamps: "true",
+            tailLines: String(options.tailLines ?? 500),
+        });
+        const pathName = `/api/v1/namespaces/${encodeURIComponent(config.namespace)}/pods/${encodeURIComponent(podName)}/log?${params.toString()}`;
+
+        return new Promise((resolve, reject) => {
+            let buffer = "";
+            let settled = false;
+            let response = null;
+
+            const finish = (error = null) => {
+                if (settled) return;
+                settled = true;
+
+                if (buffer.trim()) {
+                    this.logEntryCounter += 1;
+                    this.emitLogEntry(buildLogEntry(`[pod/${podName}] ${buffer.trim()}`, this.logEntryCounter));
+                    buffer = "";
+                }
+
+                if (response) {
+                    handle.responses.delete(response);
+                }
+                handle.requests.delete(request);
+
+                if (error) reject(error);
+                else resolve();
+            };
+
+            const request = https.request({
+                method: "GET",
+                hostname: config.host,
+                port: config.port,
+                path: pathName,
+                ca: config.ca,
+                headers: {
+                    Authorization: `Bearer ${config.token}`,
+                    Accept: "*/*",
+                },
+            }, (res) => {
+                response = res;
+                handle.responses.add(res);
+
+                if ((res.statusCode || 0) >= 400) {
+                    let body = "";
+                    res.setEncoding("utf8");
+                    res.on("data", (chunk) => {
+                        body += chunk;
+                    });
+                    res.on("end", () => {
+                        finish(new Error(
+                            `Kubernetes log stream failed for ${podName} (${res.statusCode}): ${trimLogText(body || res.statusMessage || "unknown error")}`,
+                        ));
+                    });
+                    return;
+                }
+
+                res.setEncoding("utf8");
+                res.on("data", (chunk) => {
+                    buffer += chunk;
+                    const lines = buffer.split("\n");
+                    buffer = lines.pop() || "";
+                    for (const line of lines) {
+                        if (!line.trim()) continue;
+                        this.logEntryCounter += 1;
+                        this.emitLogEntry(buildLogEntry(`[pod/${podName}] ${line}`, this.logEntryCounter));
+                    }
+                });
+                res.on("end", () => finish());
+                res.on("close", () => finish());
+                res.on("error", (error) => finish(error));
+            });
+
+            handle.requests.add(request);
+            request.on("error", (error) => finish(error));
+            request.end();
+        });
+    }
+
+    startInClusterLogProcess() {
+        const config = getInClusterK8sConfig();
+        if (!config || this.logTailHandle) return;
+
+        const labelSelector = process.env.K8S_POD_LABEL || "app.kubernetes.io/component=worker";
+        const handle = {
+            stopped: false,
+            requests: new Set(),
+            responses: new Set(),
+            stop: () => {
+                if (handle.stopped) return;
+                handle.stopped = true;
+                for (const response of handle.responses) {
+                    try { response.destroy(); } catch {}
+                }
+                handle.responses.clear();
+                for (const request of handle.requests) {
+                    try { request.destroy(); } catch {}
+                }
+                handle.requests.clear();
+            },
+        };
+        this.logTailHandle = handle;
+
+        this.listPodsFromKubeApi(config, labelSelector)
+            .then(async (podNames) => {
+                if (handle.stopped || this.logTailHandle !== handle) return;
+                if (podNames.length === 0) {
+                    this.emitSyntheticLogMessage(
+                        `No pods matched label selector ${JSON.stringify(labelSelector)} in namespace ${config.namespace}.`,
+                        "warn",
+                    );
+                    return;
+                }
+
+                const results = await Promise.allSettled(
+                    podNames.map((podName) => this.streamPodLogsFromKubeApi(config, podName, handle)),
+                );
+
+                if (handle.stopped || this.logTailHandle !== handle) return;
+                for (const result of results) {
+                    if (result.status === "fulfilled") continue;
+                    this.emitSyntheticLogMessage(result.reason?.message || String(result.reason), "error");
+                }
+            })
+            .catch((error) => {
+                if (handle.stopped || this.logTailHandle !== handle) return;
+                this.emitSyntheticLogMessage(error?.message || String(error), "error");
+            })
+            .finally(() => {
+                if (this.logTailHandle === handle) {
+                    this.logTailHandle = null;
+                }
+                if (!handle.stopped) {
+                    this.scheduleLogRestart();
+                }
+            });
+    }
+
+    startKubectlLogProcess() {
+        if (this.logProc) return;
+
         const config = this.getLogConfig();
-        if (!config.available || this.logProc) return;
+        if (!config.available) return;
 
         const k8sContext = process.env.K8S_CONTEXT || "";
         const k8sNamespace = process.env.K8S_NAMESPACE || "copilot-runtime";
@@ -626,53 +956,32 @@ export class NodeSdkTransport {
         this.logProc.stderr.on("data", (chunk) => {
             const text = stripAnsi(chunk.toString()).trim();
             if (!text) return;
-            this.logEntryCounter += 1;
-            this.emitLogEntry({
-                id: `log:${Date.now()}:${this.logEntryCounter}`,
-                time: extractLogTime(text),
-                podName: "kubectl",
-                level: "warn",
-                orchId: null,
-                category: "log",
-                rawLine: trimLogText(text),
-                message: trimLogText(text),
-                prettyMessage: trimLogText(text),
-            });
+            this.emitSyntheticLogMessage(text, "warn", "kubectl");
         });
 
         this.logProc.on("error", (error) => {
-            this.logEntryCounter += 1;
-            this.emitLogEntry({
-                id: `log:${Date.now()}:${this.logEntryCounter}`,
-                time: extractLogTime(""),
-                podName: "kubectl",
-                level: "error",
-                orchId: null,
-                category: "log",
-                rawLine: trimLogText(`kubectl error: ${error.message}`),
-                message: trimLogText(`kubectl error: ${error.message}`),
-                prettyMessage: trimLogText(`kubectl error: ${error.message}`),
-            });
+            this.emitSyntheticLogMessage(`kubectl error: ${error.message}`, "error", "kubectl");
         });
 
         this.logProc.on("exit", (code, signal) => {
             this.logProc = null;
-            this.logEntryCounter += 1;
-            this.emitLogEntry({
-                id: `log:${Date.now()}:${this.logEntryCounter}`,
-                time: extractLogTime(""),
-                podName: "kubectl",
-                level: "warn",
-                orchId: null,
-                category: "log",
-                rawLine: trimLogText(`kubectl exited (code=${code} signal=${signal})`),
-                message: trimLogText(`kubectl exited (code=${code} signal=${signal})`),
-                prettyMessage: trimLogText(`kubectl exited (code=${code} signal=${signal})`),
-            });
+            this.emitSyntheticLogMessage(`kubectl exited (code=${code} signal=${signal})`, "warn", "kubectl");
             this.scheduleLogRestart();
         });
     }
 
+    startLogProcess() {
+        const config = this.getLogConfig();
+        if (!config.available || this.logProc || this.logTailHandle) return;
+
+        if (hasInClusterK8sAccess()) {
+            this.startInClusterLogProcess();
+            return;
+        }
+
+        this.startKubectlLogProcess();
+    }
+
     startLogTail(handler) {
         if (typeof handler === "function") {
             this.logSubscribers.add(handler);
@@ -690,10 +999,21 @@ export class NodeSdkTransport {
     }
 
     async stopLogTail() {
+        if (this._logBatchTimer) {
+            clearTimeout(this._logBatchTimer);
+            this._logBatchTimer = null;
+            this._logBatch = [];
+        }
         if (this.logRestartTimer) {
             clearTimeout(this.logRestartTimer);
             this.logRestartTimer = null;
         }
+        if (this.logTailHandle) {
+            try {
+                this.logTailHandle.stop();
+            } catch {}
+            this.logTailHandle = null;
+        }
         if (this.logProc) {
             try {
                 this.logProc.kill("SIGKILL");

package/src/platform.js

@@ -1,7 +1,7 @@
 import React from "react";
 import { spawnSync } from "node:child_process";
 import { Box, Text } from "ink";
-import { DEFAULT_THEME_ID, getTheme, parseTerminalMarkupRuns } from "pilotswarm-ui-core";
+import { DEFAULT_THEME_ID, getTheme, isThemeLight, parseTerminalMarkupRuns } from "pilotswarm-ui-core";
 
 const MAX_PROMPT_INPUT_ROWS = 3;
 const SELECTION_BACKGROUND = "selectionBackground";
@@ -38,8 +38,12 @@ function resolveColorToken(color) {
     return theme?.tui?.[color] || color;
 }
 
+export function shouldDimGrayTextForTheme(theme = getCurrentTheme()) {
+    return !isThemeLight(theme);
+}
+
 function isDimColorToken(color) {
-    return color === "gray";
+    return color === "gray" && shouldDimGrayTextForTheme();
 }
 
 function trimText(value, width) {
@@ -361,19 +365,46 @@ function renderPanelRow(line, rowKey, contentWidth, borderColor, scrollIndicator
                 : selectedRuns.length > 0
                     ? renderInlineRuns(selectedRuns, `inline:${rowKey}`)
                     : React.createElement(Text, null, "")),
-        React.createElement(Text, { color: scrollIndicator ? resolveColorToken("gray") : undefined, dimColor: Boolean(scrollIndicator) }, scrollChar),
+        React.createElement(Text, {
+            color: scrollIndicator ? resolveColorToken("gray") : undefined,
+            dimColor: Boolean(scrollIndicator) && shouldDimGrayTextForTheme(),
+        }, scrollChar),
         React.createElement(Text, { color: resolveColorToken(borderColor) }, "│"));
 }
 
-function renderBorderTop(title, color, width) {
+function renderBorderTop(title, color, width, titleRight = null) {
     const safeWidth = Math.max(8, Number(width) || 40);
-    const safeTitleRuns = trimRuns(normalizeTitleRuns(title, color), Math.max(1, safeWidth - 6));
-    const fill = Math.max(0, safeWidth - titleRunLength(safeTitleRuns) - 5);
+    const normalizedTitleRuns = normalizeTitleRuns(title, color);
+    const normalizedRightRuns = titleRight ? normalizeTitleRuns(titleRight, "gray") : [];
+    let safeTitleRuns = trimRuns(normalizedTitleRuns, Math.max(1, safeWidth - 6));
+    let safeRightRuns = trimRuns(normalizedRightRuns, Math.max(0, safeWidth - 8));
+    let titleWidth = titleRunLength(safeTitleRuns);
+    let rightWidth = titleRunLength(safeRightRuns);
+    const hasRightTitle = rightWidth > 0;
+    const chromeWidth = hasRightTitle ? 6 : 5;
+    const availableTitleWidth = Math.max(1, safeWidth - chromeWidth);
+
+    if (titleWidth + rightWidth > availableTitleWidth) {
+        safeTitleRuns = trimRuns(normalizedTitleRuns, Math.max(1, availableTitleWidth - rightWidth));
+        titleWidth = titleRunLength(safeTitleRuns);
+        if (titleWidth + rightWidth > availableTitleWidth) {
+            safeRightRuns = trimRuns(normalizedRightRuns, Math.max(0, availableTitleWidth - titleWidth));
+            rightWidth = titleRunLength(safeRightRuns);
+        }
+    }
+
+    const fill = Math.max(0, safeWidth - titleWidth - rightWidth - chromeWidth);
 
     return React.createElement(Box, null,
         React.createElement(Text, { color: resolveColorToken(color) }, "╭─ "),
         renderInlineRuns(safeTitleRuns, "title"),
-        React.createElement(Text, { color: resolveColorToken(color) }, ` ${"─".repeat(fill)}╮`));
+        hasRightTitle
+            ? [
+                React.createElement(Text, { key: "title-fill", color: resolveColorToken(color) }, ` ${"─".repeat(fill)} `),
+                ...renderInlineRuns(safeRightRuns, "title-right"),
+                React.createElement(Text, { key: "title-end", color: resolveColorToken(color) }, "╮"),
+            ]
+            : React.createElement(Text, { color: resolveColorToken(color) }, ` ${"─".repeat(fill)}╮`));
 }
 
 function renderBorderBottom(color, width) {
@@ -576,11 +607,12 @@ function Header({ title, subtitle }) {
         justifyContent: "space-between",
     },
     React.createElement(Text, { bold: true, color: resolveColorToken("cyan") }, title),
-    React.createElement(Text, { color: resolveColorToken("gray"), dimColor: true }, subtitle || ""));
+    React.createElement(Text, { color: resolveColorToken("gray"), dimColor: shouldDimGrayTextForTheme() }, subtitle || ""));
 }
 
 function Panel({
     title,
+    titleRight,
     color = "white",
     focused = false,
     width,
@@ -649,7 +681,7 @@ function Panel({
         flexGrow,
         flexBasis,
     },
-    renderBorderTop(title, borderColor, safeWidth),
+    renderBorderTop(title, borderColor, safeWidth, titleRight),
     lines
         ? React.createElement(Box, { flexDirection: "column", flexGrow: 1, backgroundColor: fillColor || undefined },
             [
@@ -773,7 +805,7 @@ function Input({ label, value, focused, placeholder, rows = 1, cursorIndex = 0 }
             ? [
                 renderPromptRow(placeholder || "Type a message and press Enter", focused ? 0 : null, {
                     color: resolveColorToken("gray"),
-                    dimColor: true,
+                    dimColor: shouldDimGrayTextForTheme(),
                     showCursor: Boolean(focused),
                     keyPrefix: "prompt-line:0",
                     prefix: labelPrefix,
@@ -800,7 +832,7 @@ function StatusLine({ left, right }) {
         justifyContent: "space-between",
     },
     React.createElement(Text, { color: resolveColorToken("white") }, left || ""),
-    React.createElement(Text, { color: resolveColorToken("gray"), dimColor: true }, right || ""));
+    React.createElement(Text, { color: resolveColorToken("gray"), dimColor: shouldDimGrayTextForTheme() }, right || ""));
 }
 
 function Overlay({ children }) {

package/src/plugin-config.js

@@ -0,0 +1,239 @@
+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 fileExists(filePath) {
+    try {
+        return fs.existsSync(filePath);
+    } catch {
+        return false;
+    }
+}
+
+function readOptionalTextFile(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf-8").trimEnd();
+    } catch {
+        return null;
+    }
+}
+
+function getObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+
+function firstNonEmptyString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    return null;
+}
+
+function resolveRelativePath(baseDir, relativePath) {
+    if (!baseDir || typeof relativePath !== "string" || !relativePath.trim()) return null;
+    const basePath = path.resolve(baseDir);
+    const filePath = path.resolve(basePath, relativePath);
+    if (filePath !== basePath && !filePath.startsWith(`${basePath}${path.sep}`)) {
+        return null;
+    }
+    return filePath;
+}
+
+function readRelativeTextFile(baseDir, relativePath) {
+    const filePath = resolveRelativePath(baseDir, relativePath);
+    if (!filePath) return null;
+    return readOptionalTextFile(filePath);
+}
+
+function resolveRelativeAssetFile(baseDir, relativePath) {
+    const filePath = resolveRelativePath(baseDir, relativePath);
+    if (!filePath || !fileExists(filePath)) return null;
+    return filePath;
+}
+
+function firstAssetUrl(...values) {
+    for (const value of values) {
+        if (typeof value !== "string" || !value.trim()) continue;
+        const trimmed = value.trim();
+        if (/^(https?:\/\/|\/|data:|blob:)/iu.test(trimmed)) {
+            return trimmed;
+        }
+    }
+    return null;
+}
+
+function resolvePortalAsset(baseDir, { file, url }) {
+    const directUrl = firstAssetUrl(url);
+    if (directUrl) {
+        return { filePath: null, publicUrl: directUrl };
+    }
+    const filePath = resolveRelativeAssetFile(baseDir, file);
+    if (!filePath) {
+        return { filePath: null, publicUrl: null };
+    }
+    return { filePath, publicUrl: null };
+}
+
+function readSplashValue(baseDir, config, fallback) {
+    if (typeof config?.splash === "string" && config.splash.trim()) {
+        return config.splash;
+    }
+    if (typeof config?.splashFile === "string" && config.splashFile.trim()) {
+        const fileText = readRelativeTextFile(baseDir, config.splashFile);
+        if (fileText != null) return fileText;
+    }
+    return fallback;
+}
+
+function getDefaultSplash() {
+    return readOptionalTextFile(defaultTuiSplashPath) || "{bold}{cyan-fg}PilotSwarm{/cyan-fg}{/bold}";
+}
+
+export function readPluginMetadata(pluginDir) {
+    if (!pluginDir) return null;
+    const pluginJsonPath = path.join(pluginDir, "plugin.json");
+    if (!fileExists(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}`);
+    }
+}
+
+export function getPluginDirsFromEnv() {
+    const envDirs = String(process.env.PLUGIN_DIRS || "")
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean)
+        .map((value) => path.resolve(value));
+    if (envDirs.length > 0) return envDirs;
+
+    const cwdPlugin = path.resolve(process.cwd(), "plugins");
+    if (fileExists(cwdPlugin)) return [cwdPlugin];
+
+    const bundledPlugin = path.join(pkgRoot, "plugins");
+    if (fileExists(bundledPlugin)) return [bundledPlugin];
+
+    return [];
+}
+
+export function resolveTuiBranding(pluginDir) {
+    const pluginMeta = readPluginMetadata(pluginDir);
+    const tui = pluginMeta?.tui;
+    const defaultSplash = getDefaultSplash();
+    if (!tui || typeof tui !== "object") {
+        return { title: "PilotSwarm", splash: defaultSplash };
+    }
+
+    const title = firstNonEmptyString(tui.title, "PilotSwarm") || "PilotSwarm";
+    const splash = readSplashValue(pluginDir, tui, defaultSplash);
+    return { title, splash };
+}
+
+export function resolvePortalConfigBundleFromPluginDirs(pluginDirs = []) {
+    const defaultSplash = getDefaultSplash();
+    const defaults = {
+        branding: {
+            title: "PilotSwarm",
+            pageTitle: "PilotSwarm",
+            splash: defaultSplash,
+            logoUrl: null,
+            faviconUrl: null,
+        },
+        ui: {
+            loadingMessage: "Preparing your workspace",
+            loadingCopy: "Connecting the shared workspace and live session feeds...",
+        },
+        auth: {
+            provider: null,
+            providers: {},
+            signInTitle: "Sign in to PilotSwarm",
+            signInMessage: null,
+            signInLabel: "Sign In",
+        },
+    };
+
+    for (const pluginDir of pluginDirs) {
+        const absDir = path.resolve(pluginDir);
+        const pluginMeta = readPluginMetadata(absDir);
+        if (!pluginMeta) continue;
+
+        const portal = getObject(pluginMeta?.portal);
+        const portalBranding = getObject(portal.branding);
+        const portalUi = getObject(portal.ui);
+        const portalAuth = getObject(portal.auth);
+        const tui = getObject(pluginMeta?.tui);
+
+        const title = firstNonEmptyString(portalBranding.title, portal.title, tui.title, defaults.branding.title) || defaults.branding.title;
+        const pageTitle = firstNonEmptyString(portalBranding.pageTitle, portal.pageTitle, title, defaults.branding.pageTitle) || defaults.branding.pageTitle;
+        const splash = readSplashValue(
+            absDir,
+            portalBranding,
+            readSplashValue(absDir, portal, readSplashValue(absDir, tui, defaults.branding.splash)),
+        );
+        const logoAsset = resolvePortalAsset(absDir, {
+            file: firstNonEmptyString(portalBranding.logoFile, portal.logoFile),
+            url: firstNonEmptyString(portalBranding.logoUrl, portal.logoUrl),
+        });
+        const faviconAsset = resolvePortalAsset(absDir, {
+            file: firstNonEmptyString(portalBranding.faviconFile, portal.faviconFile, portalBranding.logoFile, portal.logoFile),
+            url: firstNonEmptyString(portalBranding.faviconUrl, portal.faviconUrl, portalBranding.logoUrl, portal.logoUrl),
+        });
+
+        const assetFiles = {};
+        const branding = {
+            title,
+            pageTitle,
+            splash,
+            logoUrl: logoAsset.publicUrl || null,
+            faviconUrl: faviconAsset.publicUrl || null,
+        };
+
+        if (logoAsset.filePath) {
+            assetFiles.logo = logoAsset.filePath;
+            branding.logoUrl = "/api/portal-assets/logo";
+        }
+        if (faviconAsset.filePath) {
+            assetFiles.favicon = faviconAsset.filePath;
+            branding.faviconUrl = "/api/portal-assets/favicon";
+        }
+        if (!branding.faviconUrl && branding.logoUrl) {
+            branding.faviconUrl = branding.logoUrl;
+        }
+
+        return {
+            portalConfig: {
+                branding,
+                ui: {
+                    loadingMessage: firstNonEmptyString(portalUi.loadingMessage, portal.loadingMessage, defaults.ui.loadingMessage) || defaults.ui.loadingMessage,
+                    loadingCopy: firstNonEmptyString(portalUi.loadingCopy, portal.loadingCopy, defaults.ui.loadingCopy) || defaults.ui.loadingCopy,
+                },
+                auth: {
+                    provider: firstNonEmptyString(portalAuth.provider, portal.provider),
+                    providers: getObject(portalAuth.providers),
+                    signInTitle: firstNonEmptyString(portalAuth.signInTitle, portal.signInTitle, `Sign in to ${title}`) || `Sign in to ${title}`,
+                    signInMessage: firstNonEmptyString(portalAuth.signInMessage, portal.signInMessage, defaults.auth.signInMessage),
+                    signInLabel: firstNonEmptyString(portalAuth.signInLabel, defaults.auth.signInLabel) || defaults.auth.signInLabel,
+                },
+            },
+            assetFiles,
+        };
+    }
+
+    return {
+        portalConfig: defaults,
+        assetFiles: {},
+    };
+}
+
+export function resolvePortalConfigFromPluginDirs(pluginDirs = []) {
+    return resolvePortalConfigBundleFromPluginDirs(pluginDirs).portalConfig;
+}

package/src/portal.js

@@ -0,0 +1,7 @@
+export { NodeSdkTransport } from "./node-sdk-transport.js";
+export {
+    getPluginDirsFromEnv,
+    readPluginMetadata,
+    resolvePortalConfigBundleFromPluginDirs,
+    resolvePortalConfigFromPluginDirs,
+} from "./plugin-config.js";