open-multi-agent-kit 0.78.6 → 0.78.7

package/dist/util/fs/paths.js

@@ -0,0 +1,82 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import { getProjectRoot as resolveProjectRootSync, getProjectRootAsync as resolveProjectRootAsyncPath, getProjectRootDiagnostics, resolveProjectRoot, resolveProjectRootAsync, displayProjectRootPath, } from "../project-root.js";
+export { getProjectRootDiagnostics, resolveProjectRoot, resolveProjectRootAsync, displayProjectRootPath, };
+export function getProjectRoot() {
+    return resolveProjectRootSync();
+}
+export async function getProjectRootAsync() {
+    return resolveProjectRootAsyncPath();
+}
+export function getUserHome(env = process.env) {
+    return (normalizeUserHomePath(env.OMK_ORIGINAL_HOME)
+        ?? normalizeUserHomePath(env.HOME)
+        ?? normalizeUserHomePath(env.USERPROFILE)
+        ?? normalizeUserHomePath(homedir())
+        ?? homedir());
+}
+export function normalizeUserHomePath(value) {
+    if (value === undefined)
+        return undefined;
+    const trimmed = stripWrappingQuotes(value.trim());
+    if (!trimmed)
+        return undefined;
+    const wslPath = normalizeWslUncPath(trimmed);
+    return stripKimiConfigSuffix(wslPath ?? trimmed);
+}
+function stripWrappingQuotes(value) {
+    if (value.length < 2)
+        return value;
+    const first = value[0];
+    const last = value[value.length - 1];
+    if ((first === "\"" && last === "\"") || (first === "'" && last === "'")) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function normalizeWslUncPath(value) {
+    const slashPath = value.replace(/\\/g, "/");
+    const match = slashPath.match(/^\/\/wsl(?:\.localhost|\$)\/[^/]+(?:\/(.*))?$/i);
+    if (!match)
+        return undefined;
+    const distroRelative = match[1] ?? "";
+    return `/${distroRelative}`.replace(/\/+/g, "/");
+}
+function stripKimiConfigSuffix(value) {
+    const slashPath = value.replace(/\\/g, "/");
+    const lower = slashPath.toLowerCase();
+    for (const suffix of ["/.kimi/mcp.json", "/.kimi/config.toml", "/.kimi/skills"]) {
+        if (lower.endsWith(suffix)) {
+            return value.slice(0, value.length - suffix.length);
+        }
+    }
+    if (lower.endsWith("/.kimi")) {
+        return value.slice(0, value.length - "/.kimi".length);
+    }
+    return value;
+}
+export function getOmkPath(subPath) {
+    const root = getProjectRoot();
+    return subPath ? join(root, ".omk", subPath) : join(root, ".omk");
+}
+export { validateRunId, sanitizeRunId, validateRunArtifactPath, getRunsDir, getRunPath, getRunArtifactPath, listValidRunIds, } from "../run-store.js";
+export function getKimiConfigPath() {
+    return join(getUserHome(), ".kimi", "config.toml");
+}
+/** 프로젝트의 .kimi/skills 디렉토리 경로 */
+export function getKimiSkillsDir() {
+    return join(getProjectRoot(), ".kimi", "skills");
+}
+/** ~/.kimi/config.toml 에서 default_model 읽기 */
+export async function getKimiDefaultModel() {
+    const configPath = getKimiConfigPath();
+    try {
+        const content = await readFile(configPath, "utf-8");
+        const match = content.match(/^default_model\s*=\s*["']([^"']+)["']/m);
+        return match?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,27 @@
+export type RuntimeMcpPreflightMode = "warn-skip" | "strict" | "off";
+export type RuntimeMcpPreflightFailureReason = "timeout" | "exit";
+export type RuntimeMcpPreflightEntryStatus = "ok" | "failed" | "skipped";
+export interface RuntimeMcpPreflightOptions {
+    timeoutMs: number;
+    concurrency: number;
+}
+export interface RuntimeMcpPreflightEntry {
+    name: string;
+    status: RuntimeMcpPreflightEntryStatus;
+    reason?: RuntimeMcpPreflightFailureReason | "not-npm-family" | "no-package-spec";
+    detail?: string;
+    packageSpec?: string;
+}
+export interface RuntimeMcpPreflightResult {
+    failed: Set<string>;
+    details: Map<string, {
+        reason: RuntimeMcpPreflightFailureReason;
+        detail: string;
+    }>;
+    entries: RuntimeMcpPreflightEntry[];
+}
+export declare function resolveRuntimeMcpPreflightMode(env?: Record<string, string | undefined>): RuntimeMcpPreflightMode;
+export declare function resolveRuntimeMcpPreflightOptions(env?: Record<string, string | undefined>): RuntimeMcpPreflightOptions & {
+    mode: RuntimeMcpPreflightMode;
+};
+export declare function preflightRuntimeMcpServers(servers: Record<string, unknown>, options: RuntimeMcpPreflightOptions): Promise<RuntimeMcpPreflightResult>;

package/dist/util/fs/preflight.js

@@ -0,0 +1,271 @@
+import { execa } from "execa";
+import { basenameOfRuntimeCommand, formatPreflightFailureDetail, isRecord, QUIET_PACKAGE_MANAGER_ENV, runtimeShellInlineScripts, } from "./internal.js";
+export function resolveRuntimeMcpPreflightMode(env = process.env) {
+    const raw = env.OMK_MCP_PREFLIGHT?.trim();
+    if (!raw)
+        return "warn-skip";
+    if (raw === "strict" || raw === "warn-skip")
+        return raw;
+    return "off";
+}
+function resolvePreflightTimeout(env = process.env) {
+    const raw = env.OMK_MCP_PREFLIGHT_TIMEOUT_MS;
+    if (!raw)
+        return 5000;
+    const n = Number.parseInt(raw, 10);
+    return Number.isFinite(n) && n > 0 ? n : 5000;
+}
+function resolvePreflightConcurrency(env = process.env) {
+    const raw = env.OMK_MCP_PREFLIGHT_CONCURRENCY;
+    if (!raw)
+        return 3;
+    const n = Number.parseInt(raw, 10);
+    return Number.isFinite(n) && n > 0 ? n : 3;
+}
+export function resolveRuntimeMcpPreflightOptions(env = process.env) {
+    return {
+        mode: resolveRuntimeMcpPreflightMode(env),
+        timeoutMs: resolvePreflightTimeout(env),
+        concurrency: resolvePreflightConcurrency(env),
+    };
+}
+const NPM_FAMILY_RUNTIME_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 PACKAGE_ARG_OPTIONS_WITH_VALUE = new Set([
+    "-p",
+    "--package",
+    "--package-name",
+    "--registry",
+    "--cache",
+    "--userconfig",
+    "--prefix",
+]);
+const PACKAGE_ARG_FLAGS = new Set([
+    "-y",
+    "--yes",
+    "--quiet",
+    "--silent",
+    "--no",
+    "--no-install",
+    "--ignore-existing",
+    "--prefer-offline",
+    "--offline",
+]);
+function isRuntimePackageSpecifier(value) {
+    if (!value || value.startsWith("-") || value === "--")
+        return false;
+    if (/^(?:https?|git\+ssh|git\+https?):/i.test(value))
+        return false;
+    if (value.startsWith(".") || value.startsWith("/") || value.startsWith("~") || value.includes("\\") || value.includes(":"))
+        return false;
+    return /^(?:@[a-z0-9._~-]+\/)?[a-z0-9._~-]+(?:@[a-z0-9._~+-]+)?$/i.test(value);
+}
+function findPackageSpecifier(args, commandName) {
+    let start = 0;
+    if (commandName === "npm" && ["exec", "x", "dlx"].includes(args[0] ?? ""))
+        start = 1;
+    if (commandName === "pnpm" && ["dlx", "exec"].includes(args[0] ?? ""))
+        start = 1;
+    if (commandName === "yarn" && ["dlx", "exec"].includes(args[0] ?? ""))
+        start = 1;
+    if (commandName === "bun" && ["x", "runx"].includes(args[0] ?? ""))
+        start = 1;
+    for (let i = start; i < args.length; i += 1) {
+        const arg = args[i];
+        if (!arg || arg === "--")
+            break;
+        if (arg.startsWith("--package=")) {
+            const value = arg.slice("--package=".length);
+            return isRuntimePackageSpecifier(value) ? value : null;
+        }
+        if (PACKAGE_ARG_OPTIONS_WITH_VALUE.has(arg)) {
+            const value = args[i + 1];
+            if (arg === "-p" || arg === "--package" || arg === "--package-name") {
+                return value && isRuntimePackageSpecifier(value) ? value : null;
+            }
+            i += 1;
+            continue;
+        }
+        if (PACKAGE_ARG_FLAGS.has(arg))
+            continue;
+        if (arg.startsWith("-"))
+            continue;
+        return isRuntimePackageSpecifier(arg) ? arg : null;
+    }
+    return null;
+}
+function runtimeNpmPreflightEnv(concurrency) {
+    const maxSockets = String(Math.max(1, Math.min(16, concurrency)));
+    return {
+        ...QUIET_PACKAGE_MANAGER_ENV,
+        npm_config_maxsockets: maxSockets,
+        NPM_CONFIG_MAXSOCKETS: maxSockets,
+    };
+}
+function isSafeNpmPreflightEnvKey(key) {
+    const lower = key.toLowerCase();
+    if (/(?:token|secret|password|passwd|credential|auth|cookie|key)/i.test(key))
+        return false;
+    if (["http_proxy", "https_proxy", "no_proxy"].includes(lower))
+        return true;
+    if (!lower.startsWith("npm_config_"))
+        return false;
+    const npmKey = lower.slice("npm_config_".length).replace(/-/g, "_");
+    return [
+        "registry",
+        "proxy",
+        "https_proxy",
+        "http_proxy",
+        "noproxy",
+        "no_proxy",
+        "strict_ssl",
+        "cafile",
+        "userconfig",
+        "cache",
+    ].includes(npmKey);
+}
+function runtimeNpmPreflightServerEnv(server) {
+    const env = isRecord(server.env) ? server.env : {};
+    const safe = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (!isSafeNpmPreflightEnvKey(key))
+            continue;
+        if (typeof value === "string") {
+            safe[key] = value;
+        }
+    }
+    return safe;
+}
+function isNpmFamilyRuntimeServer(server) {
+    const command = typeof server.command === "string" ? basenameOfRuntimeCommand(server.command) : "";
+    return NPM_FAMILY_RUNTIME_COMMANDS.has(command);
+}
+function buildPreflightProbeCommand(server, concurrency) {
+    const command = typeof server.command === "string" ? server.command : "";
+    if (!command)
+        return null;
+    const commandName = basenameOfRuntimeCommand(command);
+    if (!NPM_FAMILY_RUNTIME_COMMANDS.has(commandName))
+        return null;
+    if (runtimeShellInlineScripts(server).length > 0)
+        return null;
+    const args = Array.isArray(server.args)
+        ? server.args.filter((arg) => typeof arg === "string")
+        : [];
+    const packageSpec = findPackageSpecifier(args, commandName);
+    if (!packageSpec)
+        return null;
+    return {
+        command: "npm",
+        args: [
+            "view",
+            packageSpec,
+            "version",
+            "--json",
+            "--prefer-offline",
+            "--no-audit",
+            "--no-fund",
+            "--progress=false",
+            "--loglevel=error",
+            "--fetch-retries=0",
+            "--fetch-retry-mintimeout=1000",
+            "--fetch-retry-maxtimeout=1000",
+            `--maxsockets=${Math.max(1, Math.min(16, concurrency))}`,
+        ],
+        env: {
+            ...runtimeNpmPreflightEnv(concurrency),
+            ...runtimeNpmPreflightServerEnv(server),
+        },
+        packageSpec,
+    };
+}
+function safePreflightProcessEnv() {
+    const safe = {};
+    for (const key of ["PATH", "Path", "HOME", "USERPROFILE", "TMP", "TMPDIR", "TEMP", "SystemRoot", "ComSpec"]) {
+        const value = process.env[key];
+        if (value !== undefined)
+            safe[key] = value;
+    }
+    return safe;
+}
+async function runPreflightProbe(probe, timeoutMs) {
+    try {
+        const result = await execa(probe.command, probe.args, {
+            env: { ...safePreflightProcessEnv(), ...probe.env },
+            extendEnv: false,
+            timeout: timeoutMs,
+            reject: false,
+            stdio: "pipe",
+        });
+        if (result.timedOut) {
+            return { failed: true, reason: "timeout", detail: `timeout after ${timeoutMs}ms` };
+        }
+        if (result.exitCode !== 0) {
+            return { failed: true, reason: "exit", detail: `exit ${result.exitCode}` };
+        }
+        return { failed: false };
+    }
+    catch (err) {
+        const code = err.code;
+        return { failed: true, reason: "exit", detail: code ? `spawn failed (${code})` : "spawn failed" };
+    }
+}
+export async function preflightRuntimeMcpServers(servers, options) {
+    const entries = Object.entries(servers);
+    const failed = new Set();
+    const details = new Map();
+    const results = [];
+    async function probeOne([name, server]) {
+        if (!isRecord(server) || typeof server.url === "string" || !isNpmFamilyRuntimeServer(server)) {
+            results.push({ name, status: "skipped", reason: "not-npm-family" });
+            return;
+        }
+        const probe = buildPreflightProbeCommand(server, options.concurrency);
+        if (!probe) {
+            results.push({ name, status: "skipped", reason: "no-package-spec" });
+            return;
+        }
+        const result = await runPreflightProbe(probe, options.timeoutMs);
+        if (result.failed) {
+            failed.add(name);
+            if (result.reason && result.detail) {
+                details.set(name, { reason: result.reason, detail: result.detail });
+            }
+            results.push({
+                name,
+                status: "failed",
+                reason: result.reason ?? "exit",
+                detail: formatPreflightFailureDetail(result.reason, result.detail),
+                packageSpec: probe.packageSpec,
+            });
+            return;
+        }
+        results.push({ name, status: "ok", packageSpec: probe.packageSpec });
+    }
+    const concurrency = Math.max(1, options.concurrency);
+    for (let i = 0; i < entries.length; i += concurrency) {
+        const batch = entries.slice(i, i + concurrency);
+        await Promise.all(batch.map(probeOne));
+    }
+    const order = new Map(entries.map(([name], index) => [name, index]));
+    results.sort((a, b) => (order.get(a.name) ?? 0) - (order.get(b.name) ?? 0));
+    return { failed, details, entries: results };
+}

package/dist/util/fs.d.ts

@@ -1,128 +1,8 @@
-import { SyncManifestEntry } from "./sync-manifest.js";
-import { type OmkRuntimeScope } from "./resource-profile.js";
-import { getProjectRootDiagnostics, resolveProjectRoot, resolveProjectRootAsync, displayProjectRootPath, type ProjectRootResolution, type ProjectRootSource } from "./project-root.js";
-export { getProjectRootDiagnostics, resolveProjectRoot, resolveProjectRootAsync, displayProjectRootPath, type ProjectRootResolution, type ProjectRootSource, };
-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[];
-}
-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 interface RuntimeMcpPruneDiagnostic {
-    name: string;
-    kind: string;
-    message: string;
-}
-export interface RuntimeMcpNormalization {
-    name: string;
-    kind: string;
-    message: string;
-}
-export declare function getManifestPath(): string;
-export declare function getBackupDir(timestamp: string): string;
-export declare function readManifest(): Promise<SyncManifestEntry[]>;
-export declare function writeManifest(entries: SyncManifestEntry[]): Promise<void>;
-export declare function backupFile(sourcePath: string, backupDir: string, relativePath: string): Promise<string>;
-export declare function isDirectory(path: string): Promise<boolean>;
-export declare function readTextFile(path: string, defaultValue?: string): Promise<string>;
-export declare function getProjectRoot(): string;
-export declare function getProjectRootAsync(): Promise<string>;
-export declare function getUserHome(env?: NodeJS.ProcessEnv): string;
-export declare function normalizeUserHomePath(value: string | undefined): string | undefined;
-export declare function getOmkPath(subPath?: string): string;
-export { validateRunId, sanitizeRunId, validateRunArtifactPath, getRunsDir, getRunPath, getRunArtifactPath, listValidRunIds, } from "./run-store.js";
-export declare function getKimiConfigPath(): string;
-/**
- * .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>;
-/** Canonical OMK MCP config collection with project `.kimi/mcp.json` compatibility. */
-export declare function collectMcpConfigs(scope?: OmkRuntimeScope): Promise<string[]>;
-export declare const STALE_PACKAGE_NAMES: Record<string, string>;
-export declare function diagnoseRuntimeMcpServer(name: string, server: unknown): Promise<RuntimeMcpPruneDiagnostic[]>;
-export type RuntimeMcpPreflightMode = "warn-skip" | "strict" | "off";
-export type RuntimeMcpPreflightFailureReason = "timeout" | "exit";
-export type RuntimeMcpPreflightEntryStatus = "ok" | "failed" | "skipped";
-export interface RuntimeMcpPreflightOptions {
-    timeoutMs: number;
-    concurrency: number;
-}
-export interface RuntimeMcpPreflightEntry {
-    name: string;
-    status: RuntimeMcpPreflightEntryStatus;
-    reason?: RuntimeMcpPreflightFailureReason | "not-npm-family" | "no-package-spec";
-    detail?: string;
-    packageSpec?: string;
-}
-export interface RuntimeMcpPreflightResult {
-    failed: Set<string>;
-    details: Map<string, {
-        reason: RuntimeMcpPreflightFailureReason;
-        detail: string;
-    }>;
-    entries: RuntimeMcpPreflightEntry[];
-}
-export declare function resolveRuntimeMcpPreflightMode(env?: Record<string, string | undefined>): RuntimeMcpPreflightMode;
-export declare function resolveRuntimeMcpPreflightOptions(env?: Record<string, string | undefined>): RuntimeMcpPreflightOptions & {
-    mode: RuntimeMcpPreflightMode;
-};
-export declare function preflightRuntimeMcpServers(servers: Record<string, unknown>, options: RuntimeMcpPreflightOptions): Promise<RuntimeMcpPreflightResult>;
-export declare function pruneRuntimeMcpServers(servers: Record<string, unknown>): Promise<{
-    servers: Record<string, unknown>;
-    diagnostics: RuntimeMcpPruneDiagnostic[];
-    normalizations: RuntimeMcpNormalization[];
-}>;
-export declare function writeRuntimeMcpConfig(configPaths: string[], allowlist?: readonly string[]): Promise<string | null>;
-/** 프로젝트의 .kimi/skills 디렉토리 경로 */
-export declare function getKimiSkillsDir(): string;
-/** ~/.kimi/config.toml 에서 default_model 읽기 */
-export declare function getKimiDefaultModel(): Promise<string | null>;
-/** .omk/config.toml 에서 안전한 logo_image 경로 읽기 (상대경로는 프로젝트 루트 기준) */
-export declare function getOmkLogoImagePath(): Promise<string | null>;
-/**
- * Auto-generate a built-in omk-project MCP config so users never need to
- * define it manually in ~/.kimi/mcp.json or .kimi/mcp.json.
- * The config uses the currently-running omk CLI path and sets OMK_PROJECT_ROOT
- * to the current project root.
- */
-export declare function writeBuiltinMcpConfig(): Promise<string | null>;
-/** Kimi CLI 실행 인자에 model + MCP + Skills 주입 (전역 동기화는 별도) */
-export declare function injectKimiGlobals(args: string[], options?: {
-    mcpScope?: OmkRuntimeScope;
-    skillsScope?: OmkRuntimeScope;
-    hooksScope?: OmkRuntimeScope;
-    role?: string;
-    mcpAllowlist?: readonly string[];
-}): Promise<void>;
+export * from "./fs/core.js";
+export * from "./fs/paths.js";
+export * from "./fs/manifest.js";
+export * from "./fs/kimi-sync.js";
+export * from "./fs/mcp-diagnose.js";
+export * from "./fs/preflight.js";
+export * from "./fs/mcp-runtime-config.js";
+export * from "./fs/logo.js";