pilotswarm-cli 0.1.13 → 0.1.15

package/src/platform.js

@@ -1,11 +1,11 @@
 import React from "react";
 import { spawnSync } from "node:child_process";
 import { Box, Text } from "ink";
-import { 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 = "white";
-const SELECTION_FOREGROUND = "black";
+const SELECTION_BACKGROUND = "selectionBackground";
+const SELECTION_FOREGROUND = "selectionForeground";
 
 function clampValue(value, min, max) {
     return Math.max(min, Math.min(max, value));
@@ -25,8 +25,27 @@ const tuiPlatformRuntime = {
     paneRegistry: new Map(),
     selection: createEmptySelection(),
     renderInvalidator: null,
+    themeId: DEFAULT_THEME_ID,
 };
 
+function getCurrentTheme() {
+    return getTheme(tuiPlatformRuntime.themeId) || getTheme(DEFAULT_THEME_ID);
+}
+
+function resolveColorToken(color) {
+    if (!color) return undefined;
+    const theme = getCurrentTheme();
+    return theme?.tui?.[color] || color;
+}
+
+export function shouldDimGrayTextForTheme(theme = getCurrentTheme()) {
+    return !isThemeLight(theme);
+}
+
+function isDimColorToken(color) {
+    return color === "gray" && shouldDimGrayTextForTheme();
+}
+
 function trimText(value, width) {
     if (width <= 0) return "";
     const text = String(value || "");
@@ -230,11 +249,11 @@ function flattenTitleText(title) {
 function renderInlineRuns(runs, keyPrefix = "run") {
     return runs.map((run, index) => React.createElement(Text, {
         key: `${keyPrefix}:${index}`,
-        color: run.color || undefined,
-        backgroundColor: run.backgroundColor || undefined,
+        color: resolveColorToken(run.color),
+        backgroundColor: resolveColorToken(run.backgroundColor),
         bold: Boolean(run.bold),
         underline: Boolean(run.underline),
-        dimColor: run.color === "gray",
+        dimColor: isDimColorToken(run.color),
     }, run.text || ""));
 }
 
@@ -339,31 +358,58 @@ function renderPanelRow(line, rowKey, contentWidth, borderColor, scrollIndicator
     const selectedRuns = applySelectionToRuns(lineToRuns(line, contentWidth), normalizedSelection);
 
     return React.createElement(Box, { key: `row:${rowKey}`, flexDirection: "row" },
-        React.createElement(Text, { color: borderColor }, "│ "),
-        React.createElement(Box, { width: contentWidth, backgroundColor: fillColor || undefined },
+        React.createElement(Text, { color: resolveColorToken(borderColor) }, "│ "),
+        React.createElement(Box, { width: contentWidth, backgroundColor: resolveColorToken(fillColor) },
             !line
                 ? React.createElement(Text, null, " ".repeat(contentWidth))
                 : selectedRuns.length > 0
                     ? renderInlineRuns(selectedRuns, `inline:${rowKey}`)
                     : React.createElement(Text, null, "")),
-        React.createElement(Text, { color: scrollIndicator ? "gray" : undefined, dimColor: Boolean(scrollIndicator) }, scrollChar),
-        React.createElement(Text, { color: borderColor }, "│"));
+        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 }, "╭─ "),
+        React.createElement(Text, { color: resolveColorToken(color) }, "╭─ "),
         renderInlineRuns(safeTitleRuns, "title"),
-        React.createElement(Text, { 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) {
     const safeWidth = Math.max(8, Number(width) || 40);
-    return React.createElement(Text, { color }, `╰${"─".repeat(Math.max(0, safeWidth - 2))}╯`);
+    return React.createElement(Text, { color: resolveColorToken(color) }, `╰${"─".repeat(Math.max(0, safeWidth - 2))}╯`);
 }
 
 function compareSelectionPoints(left, right) {
@@ -527,10 +573,10 @@ function linesToElements(lines) {
         }
         return React.createElement(Text, {
             key: `text:${index}`,
-            color: line.color || undefined,
-            backgroundColor: line.backgroundColor || undefined,
+            color: resolveColorToken(line.color),
+            backgroundColor: resolveColorToken(line.backgroundColor),
             bold: Boolean(line.bold),
-            dimColor: line.color === "gray",
+            dimColor: isDimColorToken(line.color),
         }, line.text || "");
     });
 }
@@ -540,6 +586,7 @@ function Root({ children }) {
         flexDirection: "column",
         height: process.stdout.rows || 40,
         width: process.stdout.columns || 120,
+        backgroundColor: resolveColorToken("background"),
     }, children);
 }
 
@@ -554,17 +601,18 @@ function Column({ children, ...props }) {
 function Header({ title, subtitle }) {
     return React.createElement(Box, {
         borderStyle: "round",
-        borderColor: "cyan",
+        borderColor: resolveColorToken("cyan"),
         paddingX: 1,
         marginBottom: 1,
         justifyContent: "space-between",
     },
-    React.createElement(Text, { bold: true, color: "cyan" }, title),
-    React.createElement(Text, { color: "gray" }, subtitle || ""));
+    React.createElement(Text, { bold: true, color: resolveColorToken("cyan") }, title),
+    React.createElement(Text, { color: resolveColorToken("gray"), dimColor: shouldDimGrayTextForTheme() }, subtitle || ""));
 }
 
 function Panel({
     title,
+    titleRight,
     color = "white",
     focused = false,
     width,
@@ -633,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 },
             [
@@ -660,10 +708,10 @@ function Panel({
         : React.createElement(Box, {
             flexDirection: "column",
             borderStyle: "round",
-            borderColor: borderColor,
+            borderColor: resolveColorToken(borderColor),
             paddingX: 1,
             flexGrow: 1,
-            backgroundColor: fillColor || undefined,
+            backgroundColor: resolveColorToken(fillColor),
         }, children),
     renderBorderBottom(borderColor, safeWidth));
 }
@@ -717,11 +765,11 @@ function renderPromptRow(lineText, cursorColumn, { color, showCursor, keyPrefix,
         showCursor
             ? cursorChar
                 ? React.createElement(Text, {
-                    color: "black",
-                    backgroundColor: "green",
+                    color: resolveColorToken("promptCursorForeground"),
+                    backgroundColor: resolveColorToken("promptCursorBackground"),
                     dimColor,
                 }, cursorChar)
-                : React.createElement(Text, { color: "green" }, "█")
+                : React.createElement(Text, { color: resolveColorToken("promptCursorBackground") }, "█")
             : null,
         after ? React.createElement(Text, { color, dimColor }, after) : null,
     );
@@ -732,7 +780,7 @@ function Input({ label, value, focused, placeholder, rows = 1, cursorIndex = 0 }
     const isEmpty = safeValue.length === 0;
     const safeRows = clampValue(Number(rows) || 1, 1, MAX_PROMPT_INPUT_ROWS);
     const labelPrefix = React.createElement(Text, {
-        color: focused ? "red" : "green",
+        color: resolveColorToken(focused ? "red" : "green"),
         bold: true,
     }, `${label}: `);
     const cursorPosition = getPromptCursorPosition(safeValue, cursorIndex);
@@ -756,8 +804,8 @@ function Input({ label, value, focused, placeholder, rows = 1, cursorIndex = 0 }
         isEmpty
             ? [
                 renderPromptRow(placeholder || "Type a message and press Enter", focused ? 0 : null, {
-                    color: "gray",
-                    dimColor: true,
+                    color: resolveColorToken("gray"),
+                    dimColor: shouldDimGrayTextForTheme(),
                     showCursor: Boolean(focused),
                     keyPrefix: "prompt-line:0",
                     prefix: labelPrefix,
@@ -768,7 +816,7 @@ function Input({ label, value, focused, placeholder, rows = 1, cursorIndex = 0 }
                 }, React.createElement(Text, null, ""))),
             ]
             : displayLines.map((line, index) => renderPromptRow(line, focused && visibleCursorLine === index ? cursorPosition.column : null, {
-                color: "white",
+                color: resolveColorToken("white"),
                 showCursor: Boolean(focused && visibleCursorLine === index),
                 keyPrefix: `prompt-line:${index}`,
                 prefix: index === 0 ? labelPrefix : null,
@@ -779,12 +827,12 @@ function Input({ label, value, focused, placeholder, rows = 1, cursorIndex = 0 }
 function StatusLine({ left, right }) {
     return React.createElement(Box, {
         borderStyle: "round",
-        borderColor: "gray",
+        borderColor: resolveColorToken("gray"),
         paddingX: 1,
         justifyContent: "space-between",
     },
-    React.createElement(Text, { color: "white" }, left || ""),
-    React.createElement(Text, { color: "gray", dimColor: true }, right || ""));
+    React.createElement(Text, { color: resolveColorToken("white") }, left || ""),
+    React.createElement(Text, { color: resolveColorToken("gray"), dimColor: shouldDimGrayTextForTheme() }, right || ""));
 }
 
 function Overlay({ children }) {
@@ -807,6 +855,7 @@ export function createTuiPlatform() {
     tuiPlatformRuntime.paneRegistry.clear();
     tuiPlatformRuntime.selection = createEmptySelection();
     tuiPlatformRuntime.renderInvalidator = null;
+    tuiPlatformRuntime.themeId = DEFAULT_THEME_ID;
 
     return {
         Root,
@@ -818,6 +867,12 @@ export function createTuiPlatform() {
         Lines,
         Input,
         StatusLine,
+        setTheme(themeId) {
+            const nextTheme = getTheme(themeId) || getTheme(DEFAULT_THEME_ID);
+            if (!nextTheme || nextTheme.id === tuiPlatformRuntime.themeId) return;
+            tuiPlatformRuntime.themeId = nextTheme.id;
+            requestTuiRender();
+        },
         setRenderInvalidator(fn) {
             tuiPlatformRuntime.renderInvalidator = typeof fn === "function" ? fn : null;
         },

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";