pilotswarm-cli 0.1.14 → 0.1.16

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

package/src/sync-workspace-ui.js

@@ -0,0 +1,53 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const BUNDLED_UI_PACKAGES = ["pilotswarm-ui-core", "pilotswarm-ui-react"];
+
+function copyTree(sourceDir, targetDir) {
+    fs.mkdirSync(targetDir, { recursive: true });
+    for (const entry of fs.readdirSync(sourceDir, { withFileTypes: true })) {
+        const sourcePath = path.join(sourceDir, entry.name);
+        const targetPath = path.join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            copyTree(sourcePath, targetPath);
+            continue;
+        }
+        fs.copyFileSync(sourcePath, targetPath);
+    }
+}
+
+export function syncBundledWorkspaceUiPackages({ cliPackageDir = path.resolve(__dirname, "..") } = {}) {
+    const packagesDir = path.resolve(cliPackageDir, "..");
+    const syncedPackages = [];
+
+    for (const packageName of BUNDLED_UI_PACKAGES) {
+        const workspaceDir = path.join(packagesDir, packageName.replace("pilotswarm-", ""));
+        const sourcePackageJson = path.join(workspaceDir, "package.json");
+        const sourceReadme = path.join(workspaceDir, "README.md");
+        const sourceSrcDir = path.join(workspaceDir, "src");
+        if (!fs.existsSync(sourcePackageJson) || !fs.existsSync(sourceSrcDir)) {
+            continue;
+        }
+
+        const targetDir = path.join(cliPackageDir, "node_modules", packageName);
+        fs.rmSync(targetDir, { recursive: true, force: true });
+        fs.mkdirSync(targetDir, { recursive: true });
+        fs.copyFileSync(sourcePackageJson, path.join(targetDir, "package.json"));
+        if (fs.existsSync(sourceReadme)) {
+            fs.copyFileSync(sourceReadme, path.join(targetDir, "README.md"));
+        }
+        copyTree(sourceSrcDir, path.join(targetDir, "src"));
+        syncedPackages.push(packageName);
+    }
+
+    return syncedPackages;
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    const syncedPackages = syncBundledWorkspaceUiPackages();
+    if (syncedPackages.length > 0) {
+        console.log(`[sync-workspace-ui] synced ${syncedPackages.join(", ")}`);
+    }
+}