pilotswarm-cli 0.1.14 → 0.1.16

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,67 @@ 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");
+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";
+
+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 +164,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 +184,7 @@ function buildLogEntry(line, counter) {
         podName,
         level: normalizeLogLevel(rawLine),
         orchId,
+        sessionId,
         category,
         rawLine,
         message: extractPrettyLogMessage(rawLine),
@@ -127,6 +192,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, "_");
 }
@@ -139,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";
@@ -179,13 +327,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 +376,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 +397,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 +457,41 @@ export class NodeSdkTransport {
     }
 
     getLogConfig() {
-        const hasK8sConfig = Boolean((process.env.K8S_CONTEXT || "").trim() || (process.env.KUBECONFIG || "").trim());
+        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) {
+            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 +547,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 +652,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 +777,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 +803,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 +1036,125 @@ 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();
         });
     }
 
+    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;
+        }
+
+        this.startKubectlLogProcess();
+    }
+
     startLogTail(handler) {
         if (typeof handler === "function") {
             this.logSubscribers.add(handler);
@@ -690,10 +1172,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");