pilotswarm-cli 0.1.5 → 0.1.7

package/cli/tui.js

@@ -13,7 +13,7 @@
  *   npx pilotswarm remote --env .env.remote       # client-only (AKS)
  */
 
-import { PilotSwarmClient, PilotSwarmWorker, PilotSwarmManagementClient, SessionBlobStore, systemAgentUUID } from "pilotswarm-sdk";
+import { PilotSwarmClient, PilotSwarmWorker, PilotSwarmManagementClient, SessionBlobStore, FilesystemArtifactStore, systemAgentUUID, loadAgentFiles } from "pilotswarm-sdk";
 import { createRequire } from "node:module";
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
@@ -340,15 +340,19 @@ const sessionArtifacts = new Map();
 const _registeredArtifacts = new Set();
 const MAX_ARTIFACT_REGISTRY = 500;
 
-/** TUI-level blob store for on-demand artifact downloads. Created lazily. */
-let _tuiBlobStore = null;
-function getTuiBlobStore() {
-    if (_tuiBlobStore) return _tuiBlobStore;
+/** TUI-level artifact store for on-demand downloads. Created lazily.
+ *  Uses Azure Blob when configured, otherwise falls back to local filesystem. */
+let _tuiArtifactStore = null;
+function getTuiArtifactStore() {
+    if (_tuiArtifactStore) return _tuiArtifactStore;
     const connStr = process.env.AZURE_STORAGE_CONNECTION_STRING;
-    const container = process.env.AZURE_STORAGE_CONTAINER || "copilot-sessions";
-    if (!connStr) return null;
-    _tuiBlobStore = new SessionBlobStore(connStr, container);
-    return _tuiBlobStore;
+    if (connStr) {
+        const container = process.env.AZURE_STORAGE_CONTAINER || "copilot-sessions";
+        _tuiArtifactStore = new SessionBlobStore(connStr, container);
+    } else {
+        _tuiArtifactStore = new FilesystemArtifactStore();
+    }
+    return _tuiArtifactStore;
 }
 
 /**
@@ -381,17 +385,13 @@ function detectArtifactLinks(text, orchId) {
  * Returns the local path on success, null on failure.
  */
 async function downloadArtifact(sessionId, filename) {
-    const bs = getTuiBlobStore();
-    if (!bs) {
-        appendLog("{red-fg}📥 No blob storage configured — cannot download artifacts.{/red-fg}");
-        return null;
-    }
+    const store = getTuiArtifactStore();
     const sessionDir = path.join(EXPORTS_DIR, sessionId.slice(0, 8));
     fs.mkdirSync(sessionDir, { recursive: true });
     const localPath = path.join(sessionDir, filename);
 
     try {
-        const content = await bs.downloadArtifact(sessionId, filename);
+        const content = await store.downloadArtifact(sessionId, filename);
         fs.writeFileSync(localPath, content, "utf-8");
         appendLog(`{green-fg}📥 Downloaded: ~/${path.relative(os.homedir(), localPath)} (${(content.length / 1024).toFixed(1)}KB){/green-fg}`);
         return localPath;
@@ -1099,6 +1099,58 @@ function appendActivity(text, orchId) {
     }
 }
 
+function formatToolArgValue(value) {
+    if (typeof value === "string") return JSON.stringify(value);
+    if (typeof value === "number" || typeof value === "boolean") return String(value);
+    if (value === null) return "null";
+    if (Array.isArray(value)) return `[${value.map(formatToolArgValue).join(", ")}]`;
+    try {
+        return JSON.stringify(value);
+    } catch {
+        return String(value);
+    }
+}
+
+function formatToolArgsSummary(toolName, args) {
+    if (!args || typeof args !== "object") return "";
+    if (toolName === "wait") {
+        const seconds = args.seconds != null ? `${args.seconds}s` : "?";
+        const preserve = args.preserveWorkerAffinity === true ? " preserve=true" : "";
+        const reason = typeof args.reason === "string" && args.reason
+            ? ` reason=${JSON.stringify(args.reason)}`
+            : "";
+        return ` ${seconds}${preserve}${reason}`;
+    }
+
+    const entries = Object.entries(args)
+        .slice(0, 4)
+        .map(([key, value]) => `${key}=${formatToolArgValue(value)}`);
+    if (entries.length === 0) return "";
+    const suffix = Object.keys(args).length > entries.length ? ", ..." : "";
+    return ` ${entries.join(", ")}${suffix}`;
+}
+
+function formatToolActivityLine(timeStr, evt, phase = "start") {
+    const toolName = evt.data?.toolName || evt.data?.name || "tool";
+    const args = evt.data?.arguments || evt.data?.args;
+    const dsid = evt.data?.durableSessionId ? ` {gray-fg}[${shortId(evt.data.durableSessionId)}]{/gray-fg}` : "";
+    const summary = formatToolArgsSummary(toolName, args);
+    if (phase === "start") {
+        return `{white-fg}[${timeStr}]{/white-fg} {yellow-fg}▶ ${toolName}${summary}{/yellow-fg}${dsid}`;
+    }
+    return `{white-fg}[${timeStr}]{/white-fg} {green-fg}✓ ${toolName}{/green-fg}${dsid}`;
+}
+
+function summarizeActivityPreview(text, maxLen = 100) {
+    const compact = String(text || "")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!compact) return "(no content)";
+    return compact.length > maxLen
+        ? `${compact.slice(0, maxLen - 1)}...`
+        : compact;
+}
+
 function ensureSessionSplashBuffer(orchId) {
     const existing = sessionChatBuffers.get(orchId) || [];
     const splashText = systemSplashText.get(orchId);
@@ -2907,12 +2959,9 @@ async function loadCmsHistory(orchId, options = {}) {
                         lines.push("");
                     }
                 } else if (type === "tool.execution_start") {
-                    const toolName = evt.data?.toolName || "tool";
-                    const dsid = evt.data?.durableSessionId ? ` {gray-fg}[${shortId(evt.data.durableSessionId)}]{/gray-fg}` : "";
-                    activityLines.push(`{white-fg}[${timeStr}]{/white-fg} {yellow-fg}▶ ${toolName}{/yellow-fg}${dsid}`);
+                    activityLines.push(formatToolActivityLine(timeStr, evt, "start"));
                 } else if (type === "tool.execution_complete") {
-                    const toolName = evt.data?.toolName || "tool";
-                    activityLines.push(`{white-fg}[${timeStr}]{/white-fg} {green-fg}✓ ${toolName}{/green-fg}`);
+                    activityLines.push(formatToolActivityLine(timeStr, evt, "complete"));
                 } else if (type === "abort" || type === "session.info" || type === "session.idle"
                     || type === "session.usage_info" || type === "pending_messages.modified"
                     || type === "assistant.usage") {
@@ -2971,7 +3020,45 @@ async function loadCmsHistory(orchId, options = {}) {
             }
 
             const maxRenderedSeq = (events || []).reduce((max, evt) => Math.max(max, evt.seq || 0), 0);
-            sessionChatBuffers.set(orchId, lines);
+
+            // Append pending question so it survives the history buffer swap.
+            // The observer may have written it into the old buffer, but this
+            // replacement would nuke it without this check.
+            const pendingQ = sessionPendingQuestions.get(orchId);
+            if (pendingQ) {
+                lines.push(`{cyan-fg}{bold}Copilot:{/bold}{/cyan-fg}`);
+                const renderedQ = renderMarkdown(pendingQ);
+                for (const line of renderedQ.split("\n")) {
+                    lines.push(line);
+                }
+                lines.push("");
+            }
+
+            // If CMS history produced no chat-visible lines (only the footer),
+            // but the observer previously wrote real content into the buffer,
+            // keep the existing buffer. This handles the case where assistant
+            // response text comes via the observer (customStatus streaming) but
+            // hasn't been persisted as CMS assistant.message events yet.
+            const chatContentLines = lines.filter(l =>
+                l && !/^{(?:white|gray)-fg}──/.test(l) && l.trim() !== "",
+            );
+            const existing = sessionChatBuffers.get(orchId);
+            const existingHasContent = existing && existing.length > 1
+                && existing.some(l => l && !/Loading/.test(l) && !/no recent/.test(l));
+
+            if (chatContentLines.length === 0 && existingHasContent) {
+                // CMS has no chat-worthy content but observer buffer does —
+                // append the footer to the existing buffer instead of replacing.
+                if (eventCount > 0) {
+                    const footerIdx = lines.findIndex(l => /recent history loaded/.test(l));
+                    if (footerIdx >= 0) {
+                        existing.push(lines[footerIdx]);
+                        existing.push("");
+                    }
+                }
+            } else {
+                sessionChatBuffers.set(orchId, lines);
+            }
             sessionActivityBuffers.set(orchId, activityLines);
             sessionHistoryLoadedAt.set(orchId, Date.now());
             sessionRenderedCmsSeq.set(orchId, maxRenderedSeq);
@@ -3134,8 +3221,11 @@ if (!isRemote) {
             ...(workerModuleConfig.mcpServers && { mcpServers: workerModuleConfig.mcpServers }),
         });
         // Register custom tools from worker module
-        if (workerModuleConfig.tools?.length) {
-            w.registerTools(workerModuleConfig.tools);
+        const workerTools = typeof workerModuleConfig.createTools === "function"
+            ? await workerModuleConfig.createTools({ workerNodeId: `local-rt-${i}`, workerIndex: i })
+            : workerModuleConfig.tools;
+        if (workerTools?.length) {
+            w.registerTools(workerTools);
         }
         await w.start();
         workers.push(w);
@@ -3276,10 +3366,30 @@ if (!modelProviders) {
     // Will be populated from mgmt.getModelsByProvider() after mgmt.start()
 }
 
-// Capture session policy + agent list from the first worker
-const _workerSessionPolicy = workers[0]?.sessionPolicy || null;
-const _workerAllowedAgentNames = workers[0]?.allowedAgentNames || [];
-const _workerLoadedAgents = workers[0]?.loadedAgents || [];
+// Capture session policy + agent list from the first worker.
+// In remote mode (no local workers), load directly from the plugin directory
+// so the TUI enforces the same session creation restrictions as the backend.
+let _workerSessionPolicy = workers[0]?.sessionPolicy || null;
+let _workerAllowedAgentNames = workers[0]?.allowedAgentNames || [];
+let _workerLoadedAgents = workers[0]?.loadedAgents || [];
+
+if (workers.length === 0 && process.env.PLUGIN_DIRS) {
+    const pluginDirsArr = process.env.PLUGIN_DIRS.split(",").map(d => d.trim()).filter(Boolean);
+    for (const dir of pluginDirsArr) {
+        const policyFile = path.join(dir, "session-policy.json");
+        if (fs.existsSync(policyFile)) {
+            try { _workerSessionPolicy = JSON.parse(fs.readFileSync(policyFile, "utf-8")); } catch {}
+        }
+        const agentsDir = path.join(dir, "agents");
+        if (fs.existsSync(agentsDir)) {
+            try {
+                const agents = loadAgentFiles(agentsDir).filter(a => !a.system && a.name !== "default");
+                _workerLoadedAgents = agents;
+                _workerAllowedAgentNames = agents.map(a => a.name).filter(Boolean);
+            } catch {}
+        }
+    }
+}
 if (_workerSessionPolicy) {
     appendLog(`Session policy: mode=${_workerSessionPolicy.creation?.mode || "open"}, allowGeneric=${_workerSessionPolicy.creation?.allowGeneric ?? true}`);
 }
@@ -5108,12 +5218,8 @@ function startObserver(orchId) {
         }
         if (response.type === "wait" && response.content) {
             appendActivity(`{green-fg}[obs] ✓ SHOWING ${source}: version=${response.version} type=wait content=${response.content.slice(0, 80)}{/green-fg}`, orchId);
-            const prefix = `{white-fg}[${ts()}]{/white-fg} {gray-fg}[intermediate]{/gray-fg}`;
-            appendActivity(prefix, orchId);
-            const rendered = renderMarkdown(response.content);
-            for (const line of rendered.split("\n")) {
-                appendActivity(line, orchId);
-            }
+            const preview = summarizeActivityPreview(response.content);
+            appendActivity(`{white-fg}[${ts()}]{/white-fg} {gray-fg}[intermediate]{/gray-fg} ${preview}`, orchId);
             promoteIntermediateContent(response.content, orchId);
             setStatusIfActive(`Waiting (${cs.waitReason || response.waitReason || "timer"})…`);
             return;
@@ -5513,13 +5619,12 @@ function startCmsPoller(orchId) {
 
             if (type === "tool.execution_start") {
                 const toolName = evt.data?.toolName || "tool";
-                const dsid = evt.data?.durableSessionId ? ` {gray-fg}[${shortId(evt.data.durableSessionId)}]{/gray-fg}` : "";
                 // Track last tool name so we can show it on completion too
                 sess._lastToolName = toolName;
-                appendActivity(`{white-fg}[${t}]{/white-fg} {yellow-fg}▶ ${toolName}{/yellow-fg}${dsid}`, orchId);
+                appendActivity(formatToolActivityLine(t, evt, "start"), orchId);
             } else if (type === "tool.execution_complete") {
                 const toolName = evt.data?.toolName || sess._lastToolName || "tool";
-                appendActivity(`{white-fg}[${t}]{/white-fg} {green-fg}✓ ${toolName}{/green-fg}`, orchId);
+                appendActivity(formatToolActivityLine(t, { ...evt, data: { ...(evt.data || {}), toolName } }, "complete"), orchId);
             } else if (type === "assistant.reasoning") {
                 appendActivity(`{white-fg}[${t}]{/white-fg} {gray-fg}[reasoning]{/gray-fg}`, orchId);
             } else if (type === "assistant.turn_start") {
@@ -6376,33 +6481,43 @@ screen.on("keypress", (ch, key) => {
         picker.key(["escape", "q", "a"], closePicker);
 
         picker.on("select", async (_el, idx) => {
-            closePicker();
             const art = artifacts[idx];
             if (!art) return;
 
-            setStatus(`Downloading ${art.filename}...`);
-            screen.render();
-            const localPath = await downloadArtifact(art.sessionId, art.filename);
-            if (localPath) {
-                art.downloaded = true;
-                art.localPath = localPath;
-
-                // Open markdown viewer with this file selected
+            if (art.downloaded) {
+                // Already downloaded — close picker and open viewer
+                closePicker();
                 mdViewActive = true;
                 refreshMarkdownViewer();
-
-                // Find and select the downloaded file in the viewer
                 const files = scanExportFiles();
-                const matchIdx = files.findIndex(f => f.localPath === localPath);
+                const matchIdx = files.findIndex(f => f.localPath === art.localPath);
                 if (matchIdx >= 0) {
                     mdViewerSelectedIdx = matchIdx;
                     mdFileListPane.select(matchIdx);
                     refreshMarkdownViewer();
                 }
-
                 screen.realloc();
                 relayoutAll();
                 setStatus("Markdown Viewer (v to exit)");
+                screen.render();
+                return;
+            }
+
+            setStatus(`Downloading ${art.filename}...`);
+            screen.render();
+            const localPath = await downloadArtifact(art.sessionId, art.filename);
+            if (localPath) {
+                art.downloaded = true;
+                art.localPath = localPath;
+
+                // Update picker item to show downloaded state
+                const updatedItems = artifacts.map((a) => {
+                    const icon = a.downloaded ? "✓" : "↓";
+                    return ` ${icon} ${a.filename}`;
+                });
+                picker.setItems(updatedItems);
+                picker.select(idx);
+                setStatus(`Downloaded ${art.filename}`);
             } else {
                 setStatus("Download failed — check logs");
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pilotswarm-cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Terminal UI for pilotswarm — interactive durable agent orchestration.",
   "type": "module",
   "bin": {