open-multi-agent-kit 0.78.0

package/dist/adapters/kimi/bug-filter.js

@@ -0,0 +1,150 @@
+function stripAnsi(str) {
+    if (!str.includes("\x1b"))
+        return str;
+    return str.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "");
+}
+/** Map a position in stripped text back to the corresponding position in the original text. */
+function strippedToOriginal(original, strippedIndex) {
+    let origIdx = 0;
+    let stripIdx = 0;
+    while (stripIdx < strippedIndex && origIdx < original.length) {
+        if (original.charCodeAt(origIdx) === 0x1b &&
+            origIdx + 1 < original.length &&
+            original.charCodeAt(origIdx + 1) === 0x5b) {
+            const seqStart = origIdx;
+            origIdx += 2;
+            // Match [0-9;]* — digits and semicolons only
+            while (origIdx < original.length) {
+                const code = original.charCodeAt(origIdx);
+                if ((code >= 0x30 && code <= 0x39) || code === 0x3b) {
+                    origIdx++;
+                }
+                else {
+                    break;
+                }
+            }
+            // Now check for [A-Za-z] terminator
+            if (origIdx < original.length) {
+                const code = original.charCodeAt(origIdx);
+                if ((code >= 0x40 && code <= 0x5a) || (code >= 0x61 && code <= 0x7a)) {
+                    origIdx++; // skip terminator, sequence fully matched
+                    continue;
+                }
+            }
+            // Not a matching sequence; treat ESC as a regular character
+            origIdx = seqStart + 1;
+            stripIdx++;
+        }
+        else {
+            origIdx++;
+            stripIdx++;
+        }
+    }
+    return origIdx;
+}
+const START_MARKER = "Unhandled exception in event loop:";
+const END_MARKER = "Press ENTER to continue...";
+export class KimiBugFilter {
+    state = "idle";
+    buffer = "";
+    BUG_LIMIT = 1024;
+    process(chunk) {
+        if (this.state === "idle") {
+            return this.processIdle(chunk);
+        }
+        this.buffer += chunk;
+        return this.processInBug();
+    }
+    processIdle(chunk) {
+        this.buffer += chunk;
+        const stripped = stripAnsi(this.buffer);
+        const startIdx = stripped.indexOf(START_MARKER);
+        if (startIdx !== -1) {
+            const origStart = strippedToOriginal(this.buffer, startIdx);
+            const beforeBug = this.buffer.slice(0, origStart);
+            this.buffer = this.buffer.slice(origStart);
+            this.state = "in_bug";
+            const result = this.processInBug();
+            const before = beforeBug.length > 0 ? beforeBug : "";
+            const after = result.output ?? "";
+            const combined = before + after;
+            return {
+                output: combined.length > 0 ? combined : null,
+                sendEnter: result.sendEnter,
+            };
+        }
+        // Only hold back bytes that could be a prefix of START_MARKER.
+        // This eliminates the fixed 38-byte tail lag that caused typing delay.
+        const keep = this.splitKeepBytes(stripped);
+        if (this.buffer.length > keep) {
+            const flushed = keep === 0 ? this.buffer : this.buffer.slice(0, -keep);
+            this.buffer = keep === 0 ? "" : this.buffer.slice(-keep);
+            return { output: flushed.length > 0 ? flushed : null, sendEnter: false };
+        }
+        return { output: null, sendEnter: false };
+    }
+    /** Compute how many raw bytes to retain because they may be a split START_MARKER prefix. */
+    splitKeepBytes(stripped) {
+        const maxLen = Math.min(stripped.length, START_MARKER.length - 1);
+        for (let len = maxLen; len > 0; len--) {
+            if (stripped.endsWith(START_MARKER.slice(0, len))) {
+                const strippedStart = stripped.length - len;
+                const rawStart = strippedToOriginal(this.buffer, strippedStart);
+                return this.buffer.length - rawStart;
+            }
+        }
+        return 0;
+    }
+    /** Flush any remaining buffered data. Called on PTY exit. */
+    forceFlush() {
+        if (this.state === "idle") {
+            const flushed = this.buffer;
+            this.buffer = "";
+            return flushed.length > 0 ? flushed : null;
+        }
+        // Try to finish any in-progress bug extraction
+        const result = this.processInBug();
+        if (result.output !== null) {
+            return result.output;
+        }
+        const flushed = this.buffer;
+        this.buffer = "";
+        this.state = "idle";
+        return flushed.length > 0 ? flushed : null;
+    }
+    processInBug() {
+        const stripped = stripAnsi(this.buffer);
+        if (!stripped.includes(END_MARKER)) {
+            if (this.buffer.length > this.BUG_LIMIT) {
+                const flushed = this.buffer;
+                this.buffer = "";
+                this.state = "idle";
+                return { output: flushed.length > 0 ? flushed : null, sendEnter: false };
+            }
+            return { output: null, sendEnter: false };
+        }
+        const regex = /Unhandled exception in event loop:\s*(?:\n\s*)*Exception None\s*(?:\n\s*)*Press ENTER to continue\.\.\.\s*\n?/g;
+        let match;
+        let lastEndOrig = 0;
+        let sendEnter = false;
+        const parts = [];
+        while ((match = regex.exec(stripped)) !== null) {
+            const origStart = strippedToOriginal(this.buffer, match.index);
+            const origEnd = strippedToOriginal(this.buffer, match.index + match[0].length);
+            parts.push(this.buffer.slice(lastEndOrig, origStart));
+            lastEndOrig = origEnd;
+            sendEnter = true;
+        }
+        parts.push(this.buffer.slice(lastEndOrig));
+        const remaining = parts.join("");
+        const remainingStripped = stripAnsi(remaining);
+        if (remainingStripped.includes(START_MARKER)) {
+            this.buffer = remaining;
+            this.state = "in_bug";
+            return { output: null, sendEnter };
+        }
+        this.buffer = remaining;
+        this.state = "idle";
+        return { output: remaining.length > 0 ? remaining : null, sendEnter };
+    }
+}

package/dist/adapters/kimi/capability.d.ts

@@ -0,0 +1,25 @@
+export interface KimiCapabilityFlags {
+    model: boolean;
+    thinking: boolean;
+    temperature: boolean;
+    topP: boolean;
+    variant: boolean;
+    version: string | null;
+    agentFile: boolean;
+    webTools: boolean;
+    swarmStatus: "available" | "unavailable" | "unknown";
+}
+/**
+ * Probe the installed Kimi CLI for supported flags by parsing --help output.
+ * Results are cached for the process lifetime.
+ */
+export declare function getKimiCapabilities(): KimiCapabilityFlags;
+/**
+ * Pure helper: parse capability flags from raw --help and --version strings.
+ * Exported for unit testing without spawning the real CLI.
+ */
+export declare function parseKimiCapabilityFlags(helpOutput: string, versionOutput: string): KimiCapabilityFlags;
+/**
+ * Reset cached capabilities (mainly for tests).
+ */
+export declare function resetKimiCapabilities(): void;

package/dist/adapters/kimi/capability.js

@@ -0,0 +1,68 @@
+import { execSync } from "child_process";
+let capabilityCache;
+/**
+ * Probe the installed Kimi CLI for supported flags by parsing --help output.
+ * Results are cached for the process lifetime.
+ */
+export function getKimiCapabilities() {
+    if (capabilityCache)
+        return capabilityCache;
+    let helpOutput = "";
+    let versionOutput = "";
+    try {
+        helpOutput = execSync("kimi --help", { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"], timeout: 5000 });
+    }
+    catch {
+        helpOutput = "";
+    }
+    try {
+        versionOutput = execSync("kimi --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"], timeout: 5000 });
+    }
+    catch {
+        versionOutput = "";
+    }
+    const flags = parseKimiCapabilityFlags(helpOutput, versionOutput);
+    capabilityCache = flags;
+    return flags;
+}
+/**
+ * Pure helper: parse capability flags from raw --help and --version strings.
+ * Exported for unit testing without spawning the real CLI.
+ */
+export function parseKimiCapabilityFlags(helpOutput, versionOutput) {
+    return {
+        model: /\s--model\s/.test(helpOutput) || /\s-m\s/.test(helpOutput),
+        thinking: /\s--thinking\s/.test(helpOutput) || /\s--no-thinking\s/.test(helpOutput),
+        temperature: /\s--temperature\b/.test(helpOutput),
+        topP: /\s--top-p\b/.test(helpOutput) || /\s--top_p\b/.test(helpOutput),
+        variant: /\s--variant\b/.test(helpOutput),
+        version: parseKimiVersion(versionOutput) ?? parseKimiVersion(helpOutput),
+        agentFile: /\s--agent-file\b/.test(helpOutput),
+        webTools: /\sSearchWeb\b/.test(helpOutput) || /\sFetchURL\b/.test(helpOutput) || /\sweb search\b/i.test(helpOutput),
+        swarmStatus: inferSwarmStatus(versionOutput, helpOutput),
+    };
+}
+function inferSwarmStatus(versionOutput, helpOutput) {
+    // Kimi K2.6 Agent Swarm is a platform capability, not a CLI flag.
+    // We infer availability from version (>=1.1.0 heuristic) or help mentions.
+    const version = parseKimiVersion(versionOutput) ?? parseKimiVersion(helpOutput);
+    if (!version)
+        return "unknown";
+    const [major, minor] = version.split(".").map((n) => Number.parseInt(n, 10));
+    if (Number.isNaN(major) || Number.isNaN(minor))
+        return "unknown";
+    // Conservative heuristic: swarm APIs stabilized around 1.1+
+    if (major > 1 || (major === 1 && minor >= 1))
+        return "available";
+    return "unavailable";
+}
+function parseKimiVersion(output) {
+    const m = output.match(/kimi,\s*version\s+([0-9]+\.[0-9]+\.[0-9]+)/i);
+    return m?.[1] ?? null;
+}
+/**
+ * Reset cached capabilities (mainly for tests).
+ */
+export function resetKimiCapabilities() {
+    capabilityCache = undefined;
+}

package/dist/adapters/kimi/continue-prompt-guard.d.ts

@@ -0,0 +1,20 @@
+export declare function stripAnsi(value: string): string;
+export interface ContinuePromptGuardOptions {
+    maxAutoEnters?: number;
+    cooldownMs?: number;
+    now?: () => number;
+}
+export declare class KimiContinuePromptGuard {
+    private readonly maxAutoEnters;
+    private readonly cooldownMs;
+    private readonly now;
+    private tail;
+    private autoEnterCount;
+    private lastEnterAt;
+    constructor(options?: ContinuePromptGuardOptions);
+    process(chunk: string): {
+        sendEnter: boolean;
+        reason?: string;
+        exceeded?: boolean;
+    };
+}

package/dist/adapters/kimi/continue-prompt-guard.js

@@ -0,0 +1,70 @@
+export function stripAnsi(value) {
+    return value
+        .replace(/\x1B\][\s\S]*?(?:\x07|\x1B\\)/g, "")
+        .replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
+}
+const SAFE_CONTINUE_PROMPT_PATTERNS = [
+    /press\s+(?:enter|return)\s+to\s+continue\.{0,3}/i,
+    /press\s+any\s+key\s+to\s+continue\.{0,3}/i,
+    /hit\s+(?:enter|return)\s+to\s+continue\.{0,3}/i,
+    /계속하려면\s*(?:enter|엔터)/i,
+];
+const UNSAFE_PROMPT_PATTERNS = [
+    /approve/i,
+    /permission/i,
+    /allow/i,
+    /confirm/i,
+    /delete/i,
+    /overwrite/i,
+    /publish/i,
+    /deploy/i,
+    /execute/i,
+    /run command/i,
+    /proceed\?/i,
+    /y\/n/i,
+    /\[y\/n\]/i,
+];
+export class KimiContinuePromptGuard {
+    maxAutoEnters;
+    cooldownMs;
+    now;
+    tail = "";
+    autoEnterCount = 0;
+    lastEnterAt = 0;
+    constructor(options = {}) {
+        this.maxAutoEnters = options.maxAutoEnters ?? 5;
+        this.cooldownMs = options.cooldownMs ?? 750;
+        this.now = options.now ?? (() => Date.now());
+    }
+    process(chunk) {
+        this.tail += chunk;
+        this.tail = stripAnsi(this.tail);
+        if (this.tail.length > 4096) {
+            this.tail = this.tail.slice(-4096);
+        }
+        if (this.autoEnterCount >= this.maxAutoEnters) {
+            return {
+                exceeded: true,
+                reason: `Kimi continue prompt exceeded maxAutoEnter=${this.maxAutoEnters}`,
+                sendEnter: false,
+            };
+        }
+        if (this.now() - this.lastEnterAt < this.cooldownMs) {
+            return { sendEnter: false };
+        }
+        for (const pattern of UNSAFE_PROMPT_PATTERNS) {
+            if (pattern.test(this.tail)) {
+                return { sendEnter: false };
+            }
+        }
+        for (const pattern of SAFE_CONTINUE_PROMPT_PATTERNS) {
+            if (pattern.test(this.tail)) {
+                this.autoEnterCount++;
+                this.lastEnterAt = this.now();
+                this.tail = "";
+                return { sendEnter: true, reason: "safe Kimi continue prompt detected" };
+            }
+        }
+        return { sendEnter: false };
+    }
+}

package/dist/adapters/kimi/isolated-home.d.ts

@@ -0,0 +1,21 @@
+type RuntimeScope = "all" | "project" | "none";
+export interface IsolatedKimiHomeOptions {
+    originalHome?: string;
+    projectRoot?: string;
+    inheritLocalAuth?: boolean;
+    skillsScope?: RuntimeScope;
+    hooksScope?: RuntimeScope;
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * Create a temporary HOME directory while preserving Kimi auth and local agent
+ * credentials. MCP configs are intentionally *not* synthesized inside this
+ * temporary HOME: OMK runtime passes explicit --mcp-config-file arguments that
+ * point at the real project .kimi/mcp.json and, for all-scope runs, the real
+ * user ~/.kimi/mcp.json through OMK_ORIGINAL_HOME. This keeps Kimi from
+ * reporting or depending on disposable /tmp MCP config paths.
+ */
+export declare function prepareIsolatedKimiHome(options?: IsolatedKimiHomeOptions): Promise<string>;
+export declare function cleanupIsolatedKimiHome(tmpHome: string): Promise<void>;
+export declare function resolveOriginalHome(env?: NodeJS.ProcessEnv): string;
+export {};

package/dist/adapters/kimi/isolated-home.js

@@ -0,0 +1,270 @@
+import { lstat, mkdtemp, mkdir, symlink, rm, writeFile, readFile } from "fs/promises";
+import { dirname, isAbsolute, join } from "path";
+import { tmpdir } from "os";
+import { pathExists, getProjectRoot, getUserHome, extractHooksBlocks } from "../../util/fs.js";
+const KIMI_BASE_INHERITED_DIRS = ["credentials", "agents", "logs"];
+/**
+ * Local agent/OMK auth paths that should remain visible when OMK gives Kimi a
+ * sanitized temporary HOME. Keep this default intentionally narrow for public
+ * installs: broad OS/cloud credentials require explicit trusted-local opt-in.
+ */
+const DEFAULT_LOCAL_TERMINAL_AUTH_PATHS = [
+    ".codex",
+    ".opencode",
+    ".claude",
+    ".gemini",
+    ".railway",
+    ".config/gh",
+    ".config/omk",
+    ".config/github-copilot",
+    ".config/railway",
+];
+const TRUSTED_LOCAL_TERMINAL_AUTH_PATHS = [
+    ...DEFAULT_LOCAL_TERMINAL_AUTH_PATHS,
+    ".ssh",
+    ".aws",
+    ".azure",
+    ".docker",
+    ".kube",
+    ".gnupg",
+    ".config/gcloud",
+    ".config/vercel",
+    ".config/netlify",
+    ".config/heroku",
+    ".config/hub",
+    ".gitconfig",
+    ".git-credentials",
+    ".netrc",
+    ".npmrc",
+    ".pypirc",
+    ".yarnrc",
+    ".yarnrc.yml",
+];
+/**
+ * Create a temporary HOME directory while preserving Kimi auth and local agent
+ * credentials. MCP configs are intentionally *not* synthesized inside this
+ * temporary HOME: OMK runtime passes explicit --mcp-config-file arguments that
+ * point at the real project .kimi/mcp.json and, for all-scope runs, the real
+ * user ~/.kimi/mcp.json through OMK_ORIGINAL_HOME. This keeps Kimi from
+ * reporting or depending on disposable /tmp MCP config paths.
+ */
+export async function prepareIsolatedKimiHome(options = {}) {
+    const env = options.env ?? process.env;
+    const originalHome = options.originalHome ?? resolveOriginalHome(env);
+    const projectRoot = options.projectRoot ?? getProjectRoot();
+    const tmpHome = await mkdtemp(join(tmpdir(), "omk-home-"));
+    const originalKimi = join(originalHome, ".kimi");
+    const tmpKimi = join(tmpHome, ".kimi");
+    const skillsScope = normalizeRuntimeScope(options.skillsScope ?? env.OMK_SKILLS_SCOPE, "project");
+    const hooksScope = normalizeRuntimeScope(options.hooksScope ?? env.OMK_HOOKS_SCOPE, "project");
+    await mkdir(tmpKimi, { recursive: true });
+    // Symlink only scoped global directories. Skills/hooks are intentionally not
+    // inherited for project/none scopes; explicit --skills-dir and merged hook
+    // config below are the source of truth for those capabilities.
+    const inheritedDirs = [
+        ...KIMI_BASE_INHERITED_DIRS,
+        ...(skillsScope === "all" ? ["skills"] : []),
+        ...(hooksScope === "all" ? ["hooks"] : []),
+    ];
+    for (const name of inheritedDirs) {
+        const src = join(originalKimi, name);
+        const dst = join(tmpKimi, name);
+        if (await pathExists(src)) {
+            if (name === "credentials") {
+                try {
+                    await symlink(src, dst, "dir");
+                }
+                catch (err) {
+                    throw new Error(`[omk] Fatal: failed to symlink ~/.kimi/credentials to isolated HOME: ${err.message ?? err}`);
+                }
+            }
+            else {
+                await symlink(src, dst, "dir").catch((err) => {
+                    console.warn(`[omk] Failed to symlink ~/.kimi/${name} to isolated HOME: ${err.message ?? err}`);
+                });
+            }
+        }
+    }
+    if (shouldInheritLocalAuth(options.inheritLocalAuth, env)) {
+        await inheritLocalTerminalAuth(originalHome, tmpHome, env);
+    }
+    await ensureNoSyntheticTmpMcpConfig(tmpKimi, projectRoot);
+    // Merge hooks from project config into isolated HOME config.toml so that
+    // project-specific hooks are active even when the global config hasn't been
+    // synced yet. We copy (not symlink) so we can append missing hooks safely.
+    const originalConfig = join(originalKimi, "config.toml");
+    const tmpConfig = join(tmpKimi, "config.toml");
+    const projectHookConfigs = [
+        join(projectRoot, ".omk", "kimi.config.toml"),
+        join(projectRoot, ".kimi", "kimi.config.toml"),
+    ];
+    const originalConfigContent = await pathExists(originalConfig)
+        ? await readFile(originalConfig, "utf-8").catch(() => "")
+        : "";
+    const globalConfigContent = hooksScope === "all"
+        ? originalConfigContent
+        : stripHooksBlocks(originalConfigContent);
+    const missingHookBlocks = [];
+    if (hooksScope !== "none") {
+        for (const projectHookConfig of projectHookConfigs) {
+            if (!(await pathExists(projectHookConfig)))
+                continue;
+            const content = await readFile(projectHookConfig, "utf-8").catch(() => "");
+            const hooksBlock = rewriteProjectHookCommands(extractHooksBlocks(content), projectRoot);
+            if (hooksBlock && !globalConfigContent.includes(hooksBlock.trim())) {
+                missingHookBlocks.push(hooksBlock);
+            }
+        }
+    }
+    try {
+        if (globalConfigContent || missingHookBlocks.length > 0) {
+            const mergedConfig = [globalConfigContent.trimEnd(), ...missingHookBlocks].filter(Boolean).join("\n\n") + "\n";
+            await writeFile(tmpConfig, mergedConfig, { mode: 0o600 });
+        }
+    }
+    catch (err) {
+        console.warn(`[omk] Failed to write merged config.toml to isolated HOME: ${err.message ?? err}`);
+    }
+    // Shell profile bridging can re-export arbitrary local secrets. Keep it off
+    // by default and require a trusted-local opt-in.
+    if (shouldBridgeShellProfiles(env)) {
+        const SHELL_PROFILES = [".bashrc", ".bash_profile", ".profile", ".zshrc", ".zprofile"];
+        for (const name of SHELL_PROFILES) {
+            const src = join(originalHome, name);
+            const dst = join(tmpHome, name);
+            if (await pathExists(src)) {
+                await writeIsolatedShellProfileBridge(src, dst, originalHome, name);
+            }
+        }
+    }
+    return tmpHome;
+}
+export async function cleanupIsolatedKimiHome(tmpHome) {
+    await rm(tmpHome, { recursive: true, force: true }).catch(() => { });
+}
+export function resolveOriginalHome(env = process.env) {
+    return getUserHome(env);
+}
+async function inheritLocalTerminalAuth(originalHome, tmpHome, env) {
+    for (const relativePath of localTerminalAuthPaths(env)) {
+        const src = join(originalHome, relativePath);
+        const dst = join(tmpHome, relativePath);
+        await symlinkIfExists(src, dst, relativePath);
+    }
+}
+function shouldInheritLocalAuth(optionValue, env) {
+    if (typeof optionValue === "boolean")
+        return optionValue;
+    const value = env.OMK_ISOLATED_HOME_INHERIT_AUTH ?? env.OMK_INHERIT_LOCAL_AUTH;
+    return !value || !["0", "false", "no", "off"].includes(value.toLowerCase());
+}
+function shouldBridgeShellProfiles(env) {
+    const value = env.OMK_ISOLATED_HOME_BRIDGE_SHELL_PROFILES ?? env.OMK_BRIDGE_SHELL_PROFILES;
+    return value ? ["1", "true", "yes", "on"].includes(value.trim().toLowerCase()) : false;
+}
+function normalizeRuntimeScope(value, fallback) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "none" || normalized === "off" || normalized === "disabled")
+        return "none";
+    if (normalized === "all" || normalized === "global" || normalized === "local-user" || normalized === "local_user" || normalized === "personal" || normalized === "user")
+        return "all";
+    if (normalized === "project" || normalized === "local")
+        return "project";
+    return fallback;
+}
+function stripHooksBlocks(content) {
+    const result = [];
+    let skippingHookBlock = false;
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("[[hooks]]")) {
+            skippingHookBlock = true;
+            continue;
+        }
+        if (skippingHookBlock && /^\[[^\]]+]/.test(trimmed)) {
+            skippingHookBlock = false;
+        }
+        if (!skippingHookBlock)
+            result.push(line);
+    }
+    return result.join("\n").trimEnd();
+}
+function rewriteProjectHookCommands(content, projectRoot) {
+    return content.replace(/^(\s*command\s*=\s*)"([^"]+)"/gm, (line, prefix, command) => {
+        if (!isProjectHookCommand(command))
+            return line;
+        const absoluteCommand = isAbsolute(command) ? command : join(projectRoot, command);
+        return `${prefix}${JSON.stringify(absoluteCommand)}`;
+    });
+}
+function isProjectHookCommand(command) {
+    return command.startsWith(".omk/hooks/") || command.startsWith(".kimi/hooks/");
+}
+function localTerminalAuthPaths(env = process.env) {
+    const explicit = parseListEnv(env.OMK_ISOLATED_HOME_AUTH_PATHS);
+    if (explicit.length > 0)
+        return explicit;
+    const scope = (env.OMK_ISOLATED_HOME_AUTH_SCOPE ?? env.OMK_INHERIT_LOCAL_AUTH_SCOPE ?? "default").toLowerCase();
+    if (["trusted", "broad", "all"].includes(scope)) {
+        return TRUSTED_LOCAL_TERMINAL_AUTH_PATHS;
+    }
+    return DEFAULT_LOCAL_TERMINAL_AUTH_PATHS;
+}
+async function ensureNoSyntheticTmpMcpConfig(tmpKimi, projectRoot) {
+    const projectMcpPath = join(projectRoot, ".kimi", "mcp.json");
+    if (!(await pathExists(projectMcpPath)))
+        return;
+    // Deliberately no temp mcp.json creation. Remove stale leftovers if this
+    // helper is ever called with a reused temp directory in tests.
+    await rm(join(tmpKimi, "mcp.json"), { force: true }).catch(() => { });
+}
+function parseListEnv(value) {
+    return (value ?? "")
+        .split(",")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+}
+async function symlinkIfExists(src, dst, label) {
+    let type;
+    try {
+        const stat = await lstat(src);
+        type = stat.isDirectory() ? "dir" : "file";
+    }
+    catch {
+        return;
+    }
+    if (await pathExists(dst))
+        return;
+    await mkdir(dirname(dst), { recursive: true });
+    await symlink(src, dst, type).catch((err) => {
+        console.warn(`[omk] Failed to symlink local auth path ${label} to isolated HOME: ${err.message ?? err}`);
+    });
+}
+async function writeIsolatedShellProfileBridge(src, dst, originalHome, label) {
+    await mkdir(dirname(dst), { recursive: true });
+    await writeFile(dst, [
+        "# OMK isolated HOME shell profile bridge.",
+        "# Source the real profile with the real HOME, then restore isolated HOME.",
+        "if [ \"${OMK_SHELL_PROFILE_BRIDGE_ACTIVE:-}\" = \"1\" ]; then",
+        "  return 0 2>/dev/null || exit 0",
+        "fi",
+        `__omk_isolated_home="$HOME"`,
+        `__omk_original_home=\${OMK_ORIGINAL_HOME:-${shellQuote(originalHome)}}`,
+        "OMK_SHELL_PROFILE_BRIDGE_ACTIVE=1",
+        "export OMK_SHELL_PROFILE_BRIDGE_ACTIVE",
+        'HOME="$__omk_original_home"',
+        "export HOME",
+        `. ${shellQuote(src)}`,
+        "__omk_bridge_status=$?",
+        'HOME="$__omk_isolated_home"',
+        "export HOME",
+        "unset OMK_SHELL_PROFILE_BRIDGE_ACTIVE __omk_original_home __omk_isolated_home",
+        "return \"$__omk_bridge_status\" 2>/dev/null || exit \"$__omk_bridge_status\"",
+        "",
+    ].join("\n"), { mode: 0o600 }).catch((err) => {
+        console.warn(`[omk] Failed to bridge ~/${label} into isolated HOME: ${err.message ?? err}`);
+    });
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}