pilotswarm-cli 0.1.13 → 0.1.15

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.",
         };
     }
 
@@ -335,6 +427,10 @@ export class NodeSdkTransport {
         return this.mgmt.getOrchestrationStats(sessionId);
     }
 
+    async getExecutionHistory(sessionId, executionId) {
+        return this.mgmt.getExecutionHistory(sessionId, executionId);
+    }
+
     async createSession({ model } = {}) {
         const effectiveModel = model || this.mgmt.getDefaultModel();
         const session = await this.client.createSession(effectiveModel ? { model: effectiveModel } : undefined);
@@ -371,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
@@ -476,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;
     }
@@ -495,6 +621,43 @@ export class NodeSdkTransport {
         };
     }
 
+    async exportExecutionHistory(sessionId) {
+        if (!this.artifactStore) {
+            throw new Error("Artifact store is not available for this transport.");
+        }
+        const shortId = String(sessionId || "").slice(0, 8);
+        const [history, stats] = await Promise.all([
+            this.mgmt.getExecutionHistory(sessionId),
+            this.mgmt.getOrchestrationStats(sessionId),
+        ]);
+        const sessionInfo = await this.mgmt.getSession(sessionId).catch(() => null);
+        const exportData = {
+            exportedAt: new Date().toISOString(),
+            sessionId,
+            title: sessionInfo?.title || null,
+            agentId: sessionInfo?.agentId || null,
+            model: sessionInfo?.model || null,
+            orchestrationStats: stats || null,
+            eventCount: history?.length || 0,
+            events: (history || []).map((e) => {
+                const evt = { ...e };
+                if (evt.data) {
+                    try { evt.data = JSON.parse(evt.data); } catch { /* keep raw */ }
+                }
+                return evt;
+            }),
+        };
+        const filename = `execution-history-${shortId}-${Date.now()}.json`;
+        const content = JSON.stringify(exportData, null, 2);
+        await this.artifactStore.uploadArtifact(sessionId, filename, content, guessArtifactContentType(filename));
+        return {
+            sessionId,
+            filename,
+            artifactLink: `artifact://${sessionId}/${filename}`,
+            sizeBytes: Buffer.byteLength(content, "utf8"),
+        };
+    }
+
     async openPathInDefaultApp(targetPath) {
         const resolvedPath = path.resolve(expandUserPath(targetPath));
         if (!resolvedPath) {
@@ -534,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);
         }
     }
 
@@ -551,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";
@@ -585,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);
@@ -649,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");