open-multi-agent-kit 0.78.6 → 0.78.8

package/dist/util/chat-cockpit.js

@@ -1,6 +1,8 @@
 import { resolve, join } from "path";
 import { mkdir, writeFile } from "fs/promises";
 import { runShell } from "./shell.js";
+import { BRAND_HEX, setBrandPaletteTheme } from "../brand/palette.js";
+import { getActiveBrandChromeLabel } from "../brand/theme-compiled.js";
 import { getProjectRoot, getRunPath, pathExists } from "./fs.js";
 import { writeSessionMeta } from "./session.js";
 import { writeTodos } from "./todo-sync.js";
@@ -83,8 +85,46 @@ function parseCockpitHeight(value) {
         return undefined;
     return Math.min(MAX_CHAT_COCKPIT_HEIGHT, Math.max(MIN_CHAT_COCKPIT_HEIGHT, parsed));
 }
+function normalizeBrandChromeTheme(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    if (normalized === "rust-forge" ||
+        normalized === "rust" ||
+        normalized === "cargo" ||
+        normalized === "oxide" ||
+        normalized === "forge" ||
+        normalized === "oxidized-forge" ||
+        normalized === "oxidized" ||
+        normalized === "rust-native") {
+        return "rust-forge";
+    }
+    if (normalized === "night-city" ||
+        normalized === "night-city-ops" ||
+        normalized === "neon-grid" ||
+        normalized === "neon" ||
+        normalized === "grid" ||
+        normalized === "control" ||
+        normalized === "omk-control" ||
+        normalized === "metrics" ||
+        normalized === "metrics-control" ||
+        normalized === "cyberpunk") {
+        return "night-city";
+    }
+    return undefined;
+}
+export function resolveCockpitChromeTheme(options) {
+    // OMK_THEME is the user-selected control chrome theme. Chat `--brand omk`
+    // is only the left-pane skin and must not overwrite an env/project theme.
+    return normalizeBrandChromeTheme(options.env?.OMK_THEME)
+        ?? normalizeBrandChromeTheme(options.brand);
+}
 export function buildRightPaneCommand(options) {
     let cmd = `${options.nodeCmd} ${options.cliCmd} cockpit --run-id ${shellQuote(options.runId)} --watch --refresh ${options.refreshMs}`;
+    const theme = normalizeBrandChromeTheme(options.theme);
+    if (theme) {
+        cmd = `OMK_THEME=${shellQuote(theme)} ${cmd}`;
+    }
     if (options.redraw && options.redraw !== "diff") {
         cmd += ` --redraw ${shellQuote(options.redraw)}`;
     }
@@ -93,29 +133,37 @@ export function buildRightPaneCommand(options) {
     }
     return cmd;
 }
-const TMUX_NIGHT_CITY_STATUS_LEFT = "#[fg=#00FFC2,bold] OMK//CONTROL #[fg=#758FA8]Night City";
-const TMUX_NIGHT_CITY_STATUS_RIGHT = "#[fg=#00D6FF]#S #[fg=#758FA8]%H:%M";
-const TMUX_NIGHT_CITY_SESSION_OPTIONS = [
-    ["status", "on"],
-    ["status-style", "bg=#070B14,fg=#E8F8FF"],
-    ["message-style", "bg=#9D4EDD,fg=#E8F8FF,bold"],
-    ["window-status-style", "fg=#758FA8,bg=#070B14"],
-    ["window-status-current-style", "fg=#070B14,bg=#00FFC2,bold"],
-    ["status-left", TMUX_NIGHT_CITY_STATUS_LEFT],
-    ["status-right", TMUX_NIGHT_CITY_STATUS_RIGHT],
-];
-const TMUX_NIGHT_CITY_WINDOW_OPTIONS = [
-    ["pane-border-style", "fg=#22324A"],
-    ["pane-active-border-style", "fg=#FF47B2"],
-];
-async function applyTmuxNightCityTheme(session, cwd) {
-    for (const [option, value] of TMUX_NIGHT_CITY_SESSION_OPTIONS) {
+// Active brand tmux chrome. Values are built at launch time so P/BRAND_HEX
+// mutations from setBrandPaletteTheme() are reflected without changing imports.
+export function buildTmuxBrandChromeOptions(brand) {
+    setBrandPaletteTheme(brand);
+    const statusLeft = `#[fg=${BRAND_HEX.mint},bold] OMK//CONTROL #[fg=${BRAND_HEX.gray}]${getActiveBrandChromeLabel()}`;
+    const statusRight = `#[fg=${BRAND_HEX.cyan}]#S #[fg=${BRAND_HEX.gray}]%H:%M`;
+    return {
+        sessionOptions: [
+            ["status", "on"],
+            ["status-style", `bg=${BRAND_HEX.dark},fg=${BRAND_HEX.cream}`],
+            ["message-style", `bg=${BRAND_HEX.purple},fg=${BRAND_HEX.cream},bold`],
+            ["window-status-style", `fg=${BRAND_HEX.gray},bg=${BRAND_HEX.dark}`],
+            ["window-status-current-style", `fg=${BRAND_HEX.dark},bg=${BRAND_HEX.mint},bold`],
+            ["status-left", statusLeft],
+            ["status-right", statusRight],
+        ],
+        windowOptions: [
+            ["pane-border-style", `fg=${BRAND_HEX.gridLine}`],
+            ["pane-active-border-style", `fg=${BRAND_HEX.magenta}`],
+        ],
+    };
+}
+async function applyTmuxBrandTheme(session, cwd, brand) {
+    const chrome = buildTmuxBrandChromeOptions(brand);
+    for (const [option, value] of chrome.sessionOptions) {
         const result = await runShell("tmux", ["set-option", "-t", session, option, value], { cwd, timeout: 5000 });
         if (result.failed) {
             console.warn(`Failed to set tmux ${option}: ${result.stderr || result.stdout}`);
         }
     }
-    for (const [option, value] of TMUX_NIGHT_CITY_WINDOW_OPTIONS) {
+    for (const [option, value] of chrome.windowOptions) {
         const result = await runShell("tmux", ["set-window-option", "-t", `${session}:chat`, option, value], { cwd, timeout: 5000 });
         if (result.failed) {
             console.warn(`Failed to set tmux ${option}: ${result.stderr || result.stdout}`);
@@ -183,10 +231,19 @@ export async function launchChatCockpit(options = {}) {
     const hasRoomForHistoryPane = history === "watch" &&
         terminalWidth >= 80 &&
         terminalHeight >= MIN_CHAT_COCKPIT_HEIGHT + minHistoryPaneHeight;
+    const chromeTheme = resolveCockpitChromeTheme({ brand, env: process.env });
     const leftCmd = buildLeftPaneCommand({ nodeCmd, cliCmd, runId, brand, agentFile: options.agentFile, workers: options.workers, maxStepsPerTurn: options.maxStepsPerTurn, mcpScope: options.mcpScope, provider: options.provider, model: options.model, execution: options.execution, ui: options.ui });
     // When no explicit --cockpit-height is provided, pass undefined so the child
     // measures its actual tmux pane after splits/resizes and keeps the right rail pinned.
-    const rightTopCmd = buildRightPaneCommand({ nodeCmd, cliCmd, runId, refreshMs, redraw, height: requestedCockpitHeight });
+    const rightTopCmd = buildRightPaneCommand({
+        nodeCmd,
+        cliCmd,
+        runId,
+        refreshMs,
+        redraw,
+        height: requestedCockpitHeight,
+        theme: chromeTheme,
+    });
     const rightBottomCmd = `${nodeCmd} ${cliCmd} runs --watch --limit 15 --refresh 5000`;
     // 3. Create detached tmux session with left-pane command already running
     const createResult = await runShell("tmux", ["new-session", "-d", "-s", session, "-n", "chat", "-e", "OMK_CHAT_COCKPIT_CHILD=1", leftCmd], { cwd, timeout: 10000 });
@@ -247,7 +304,7 @@ export async function launchChatCockpit(options = {}) {
     if (historyResult.failed) {
         console.warn(`Failed to set tmux history limit: ${historyResult.stderr || historyResult.stdout}`);
     }
-    await applyTmuxNightCityTheme(session, cwd);
+    await applyTmuxBrandTheme(session, cwd, chromeTheme);
     // 8. Set a hook so the session is destroyed when the chat pane dies
     const hookResult = await runShell("tmux", ["set-hook", "-t", leftPaneId, "pane-died", `if-shell -F '#{==:#{hook_pane},${leftPaneId}}' 'kill-session -t ${session}'`], { cwd, timeout: 5000 });
     if (hookResult.failed) {

package/dist/util/fs/core.d.ts

@@ -0,0 +1,5 @@
+export declare function ensureDir(path: string): Promise<void>;
+export declare function writeFileSafe(path: string, content: string): Promise<void>;
+export declare function pathExists(path: string): Promise<boolean>;
+export declare function isDirectory(path: string): Promise<boolean>;
+export declare function readTextFile(path: string, defaultValue?: string): Promise<string>;

package/dist/util/fs/core.js

@@ -0,0 +1,35 @@
+import { mkdir, writeFile, readFile, access, constants, readdir } from "fs/promises";
+import { dirname } from "path";
+export async function ensureDir(path) {
+    await mkdir(path, { recursive: true });
+}
+export async function writeFileSafe(path, content) {
+    await ensureDir(dirname(path));
+    await writeFile(path, content, "utf-8");
+}
+export async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isDirectory(path) {
+    try {
+        await readdir(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function readTextFile(path, defaultValue = "") {
+    try {
+        return await readFile(path, "utf-8");
+    }
+    catch {
+        return defaultValue;
+    }
+}

package/dist/util/fs/internal.d.ts

@@ -0,0 +1,14 @@
+import type { RuntimeMcpPreflightFailureReason } from "./preflight.js";
+export declare function isShellInlineMcpArg(server: Record<string, unknown>, index: number): boolean;
+export declare const PACKAGE_MANAGER_COMMANDS: Set<string>;
+export declare const PDF_MCP_SERVER_RE: RegExp;
+export declare const QUIET_PACKAGE_MANAGER_ENV: Record<string, string>;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function basenameOfRuntimeCommand(command: string): string;
+export declare function runtimeShellInlineScripts(server: Record<string, unknown>): string[];
+export declare function runtimeCommandText(server: Record<string, unknown>): string;
+export declare function hasHttpTransportMismatch(name: string, server: Record<string, unknown>): boolean;
+export declare function isPackageManagerRuntimeServer(server: Record<string, unknown>): boolean;
+export declare function sanitizeRuntimeMcpPreflightText(value: string): string;
+export declare function formatPreflightFailureDetail(reason: RuntimeMcpPreflightFailureReason | undefined, detail: string | undefined): string;
+export declare function registerRuntimeMcpCleanupPath(runtimeConfigPath: string): void;

package/dist/util/fs/internal.js

@@ -0,0 +1,169 @@
+import { rmSync } from "fs";
+export function isShellInlineMcpArg(server, index) {
+    const command = typeof server.command === "string" ? server.command : "";
+    const commandName = command.replace(/\\/g, "/").split("/").pop()?.toLowerCase() ?? command.toLowerCase();
+    if (!["bash", "sh", "zsh", "fish", "pwsh", "powershell", "cmd", "cmd.exe"].includes(commandName)) {
+        return false;
+    }
+    const args = Array.isArray(server.args) ? server.args : [];
+    const previous = args[index - 1];
+    return previous === "-c" || previous === "-lc" || previous === "/c" || previous === "--command";
+}
+const NODE_PACKAGE_MANAGER_COMMANDS = new Set([
+    "npm",
+    "npx",
+    "pnpm",
+    "yarn",
+    "bun",
+    "bunx",
+    "npm.cmd",
+    "npx.cmd",
+    "pnpm.cmd",
+    "yarn.cmd",
+    "bun.cmd",
+    "bunx.cmd",
+    "npm.exe",
+    "npx.exe",
+    "pnpm.exe",
+    "yarn.exe",
+    "bun.exe",
+    "bunx.exe",
+]);
+const PYTHON_PACKAGE_MANAGER_COMMANDS = new Set([
+    "uv",
+    "uvx",
+    "pip",
+    "pip3",
+    "pipx",
+    "poetry",
+    "rye",
+    "uv.exe",
+    "uvx.exe",
+    "pip.exe",
+    "pip3.exe",
+    "pipx.exe",
+    "poetry.exe",
+    "rye.exe",
+]);
+export const PACKAGE_MANAGER_COMMANDS = new Set([
+    ...NODE_PACKAGE_MANAGER_COMMANDS,
+    ...PYTHON_PACKAGE_MANAGER_COMMANDS,
+]);
+const PYTHON_RUNTIME_COMMANDS = new Set(["python", "python3", "py", "python.exe", "python3.exe", "py.exe"]);
+const INLINE_PACKAGE_MANAGER_RE = /(?:^|[\s/])(npm|npx|pnpm|yarn|bun|bunx|uv|uvx|pip|pip3|pipx|poetry|rye)(?:\.(?:cmd|exe))?(?:\s|$)/i;
+const INLINE_PYTHON_PACKAGE_MANAGER_RE = /(?:^|[\s/])(?:python(?:3)?|py)(?:\.exe)?\s+-m\s+(?:pip|pip3|uv)(?:\s|$)/i;
+const STDIO_INCOMPATIBLE_HTTP_MCP_COMMANDS = new Set(["page-design-guide", "mcp-pdf-server"]);
+export const PDF_MCP_SERVER_RE = /(?:^|\s)(?:@modelcontextprotocol\/server-pdf|mcp-pdf-server)(?:\s|$)/i;
+const EXPLICIT_STDIO_TRANSPORT_RE = /(?:^|\s)(?:--stdio|--transport(?:=|\s+)stdio)(?:\s|$)/i;
+const EXPLICIT_HTTP_TRANSPORT_RE = /(?:^|\s)--transport(?:=|\s+)(?:http|sse|streamable-http)(?:\s|$)/i;
+export const QUIET_PACKAGE_MANAGER_ENV = {
+    npm_config_loglevel: "error",
+    NPM_CONFIG_LOGLEVEL: "error",
+    npm_config_progress: "false",
+    NPM_CONFIG_PROGRESS: "false",
+    npm_config_audit: "false",
+    NPM_CONFIG_AUDIT: "false",
+    npm_config_fund: "false",
+    NPM_CONFIG_FUND: "false",
+    npm_config_prefer_offline: "true",
+    NPM_CONFIG_PREFER_OFFLINE: "true",
+    npm_config_fetch_retries: "0",
+    NPM_CONFIG_FETCH_RETRIES: "0",
+    npm_config_fetch_retry_mintimeout: "1000",
+    NPM_CONFIG_FETCH_RETRY_MINTIMEOUT: "1000",
+    npm_config_fetch_retry_maxtimeout: "1000",
+    NPM_CONFIG_FETCH_RETRY_MAXTIMEOUT: "1000",
+    npm_config_maxsockets: "3",
+    NPM_CONFIG_MAXSOCKETS: "3",
+    npm_config_update_notifier: "false",
+    NPM_CONFIG_UPDATE_NOTIFIER: "false",
+    NO_UPDATE_NOTIFIER: "1",
+    NODE_NO_WARNINGS: "1",
+    UV_NO_PROGRESS: "1",
+    PIP_DISABLE_PIP_VERSION_CHECK: "1",
+    PIP_NO_INPUT: "1",
+    PIP_NO_PYTHON_VERSION_WARNING: "1",
+    PIP_PROGRESS_BAR: "off",
+};
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function basenameOfRuntimeCommand(command) {
+    return command.replace(/\\/g, "/").split("/").pop()?.toLowerCase() ?? command.toLowerCase();
+}
+export function runtimeShellInlineScripts(server) {
+    const args = Array.isArray(server.args) ? server.args : [];
+    return args.filter((arg, index) => typeof arg === "string" && isShellInlineMcpArg(server, index));
+}
+export function runtimeCommandText(server) {
+    const command = typeof server.command === "string" ? server.command : "";
+    const args = Array.isArray(server.args)
+        ? server.args.filter((arg) => typeof arg === "string")
+        : [];
+    return [command, ...args, ...runtimeShellInlineScripts(server)].join(" ");
+}
+function hasExplicitStdioTransport(server) {
+    return EXPLICIT_STDIO_TRANSPORT_RE.test(runtimeCommandText(server));
+}
+export function hasHttpTransportMismatch(name, server) {
+    if (hasExplicitStdioTransport(server))
+        return false;
+    const command = typeof server.command === "string" ? basenameOfRuntimeCommand(server.command) : "";
+    const targetText = runtimeCommandText(server);
+    if (PDF_MCP_SERVER_RE.test(targetText))
+        return true;
+    if (STDIO_INCOMPATIBLE_HTTP_MCP_COMMANDS.has(command) || STDIO_INCOMPATIBLE_HTTP_MCP_COMMANDS.has(name)) {
+        return true;
+    }
+    return EXPLICIT_HTTP_TRANSPORT_RE.test(targetText);
+}
+export function isPackageManagerRuntimeServer(server) {
+    const command = typeof server.command === "string" ? basenameOfRuntimeCommand(server.command) : "";
+    if (PACKAGE_MANAGER_COMMANDS.has(command))
+        return true;
+    if (PYTHON_RUNTIME_COMMANDS.has(command)) {
+        const args = Array.isArray(server.args)
+            ? server.args.filter((arg) => typeof arg === "string")
+            : [];
+        for (let index = 0; index < args.length - 1; index += 1) {
+            if (args[index] === "-m" && PYTHON_PACKAGE_MANAGER_COMMANDS.has(basenameOfRuntimeCommand(args[index + 1]))) {
+                return true;
+            }
+        }
+    }
+    return runtimeShellInlineScripts(server).some((script) => {
+        const normalized = script.replace(/\\/g, "/");
+        return INLINE_PACKAGE_MANAGER_RE.test(normalized) || INLINE_PYTHON_PACKAGE_MANAGER_RE.test(normalized);
+    });
+}
+export function sanitizeRuntimeMcpPreflightText(value) {
+    return value
+        .replace(/(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1***")
+        .replace(/(--(?:api-)?(?:token|key|secret|password)(?:=|\s+))[^"'`\s;]+/gi, "$1***")
+        .replace(/([A-Za-z_][A-Za-z0-9_]*(?:SECRET|TOKEN|KEY|PASSWORD|CREDENTIAL|AUTH)[A-Za-z0-9_]*\s*=\s*)[^"'`\s;]+/gi, "$1***")
+        .replace(/([?&](?:token|api[-_]?key|key|secret|password|auth|credential|session|bearer|access[-_]?token|refresh[-_]?token|client[-_]?secret|x[-_]?auth[-_]?token|signature|sig)=)[^&#\s]+/gi, "$1***");
+}
+export function formatPreflightFailureDetail(reason, detail) {
+    if (reason === "timeout")
+        return "timeout";
+    return sanitizeRuntimeMcpPreflightText(detail ?? "failed");
+}
+const runtimeMcpCleanupPaths = new Set();
+let runtimeMcpCleanupRegistered = false;
+function cleanupRuntimeMcpFiles() {
+    for (const path of runtimeMcpCleanupPaths) {
+        try {
+            rmSync(path, { force: true });
+        }
+        catch {
+            // Best-effort cleanup for a local runtime cache that may contain MCP env.
+        }
+    }
+}
+export function registerRuntimeMcpCleanupPath(runtimeConfigPath) {
+    runtimeMcpCleanupPaths.add(runtimeConfigPath);
+    if (!runtimeMcpCleanupRegistered) {
+        runtimeMcpCleanupRegistered = true;
+        process.once("exit", cleanupRuntimeMcpFiles);
+    }
+}

package/dist/util/fs/kimi-sync.d.ts

@@ -0,0 +1,41 @@
+import { SyncManifestEntry } from "../sync-manifest.js";
+type KimiGlobalSyncStepName = "hooks" | "mcp" | "skills" | "memory";
+export interface KimiGlobalSyncOptions {
+    dryRun?: boolean;
+    diff?: boolean;
+    quiet?: boolean;
+    manifest?: SyncManifestEntry[];
+    timestamp?: string;
+}
+export interface KimiGlobalSyncStepReport {
+    name: KimiGlobalSyncStepName;
+    changed: boolean;
+    blocked: boolean;
+    skipped: boolean;
+    error?: string;
+    manifest: SyncManifestEntry[];
+}
+export interface KimiGlobalSyncReport {
+    changed: boolean;
+    blocked: boolean;
+    steps: KimiGlobalSyncStepReport[];
+    actions: string[];
+    skipped: string[];
+    errors: string[];
+    manifest: SyncManifestEntry[];
+}
+/**
+ * .omk/kimi.config.toml 의 hooks 를 ~/.kimi/config.toml 에 병합.
+ * 상대 경로를 절대 경로로 변환하여 어디서 실행돼도 작동하도록 함.
+ */
+export declare function mergeKimiHooks(omkConfigPath: string, options?: KimiGlobalSyncOptions): Promise<boolean>;
+export declare function extractHooksBlocks(content: string): string;
+/** 프로젝트의 .omk/mcp.json + .kimi/mcp.json → ~/.kimi/mcp.json 병합 */
+export declare function syncKimiMcpGlobal(options?: KimiGlobalSyncOptions): Promise<boolean>;
+/** 프로젝트의 .kimi/skills/* → ~/.kimi/skills/ 심링크 */
+export declare function syncKimiSkillsGlobal(options?: KimiGlobalSyncOptions): Promise<boolean>;
+/** local graph memory policy를 ~/.kimi/omk.memory.toml 에 동기화 */
+export declare function syncKimiMemoryGlobal(options?: KimiGlobalSyncOptions): Promise<boolean>;
+/** Sync hooks + MCP + skills to ~/.kimi/ at once */
+export declare function syncAllKimiGlobals(options?: KimiGlobalSyncOptions): Promise<KimiGlobalSyncReport>;
+export {};