open-multi-agent-kit 0.78.0

package/dist/util/update-check.js

@@ -0,0 +1,321 @@
+import { readTextFile, writeFileSafe, pathExists } from "./fs.js";
+import { getOmkVersionSync } from "./version.js";
+import { runShell } from "./shell.js";
+import { join } from "path";
+import { homedir } from "os";
+const CACHE_TTL_MS = 6 * 60 * 60 * 1000;
+const DEFAULT_UPDATE_REMIND_HOURS = 24;
+const UPDATE_PROMPT_TIMEOUT_MS = 30_000;
+export const OMK_NPM_PACKAGE_NAME = "@omk/cli";
+const OMK_UPDATE_INSTALL_CMD = `npm i -g ${OMK_NPM_PACKAGE_NAME}`;
+const FALLBACK_INSTALL_SCRIPT = "Set KIMI_API_KEY and optionally KIMI_MODEL for direct Moonshot API access.";
+function getCachePath() {
+    return join(homedir(), ".omk", "update-cache.json");
+}
+export function getOmkUpdatePromptStatePath() {
+    return join(homedir(), ".omk", "update-prompt.json");
+}
+function normalizeVersionForPrompt(version) {
+    if (!version)
+        return "unknown";
+    return version.startsWith("v") ? version : `v${version}`;
+}
+function isTruthyCiValue(value) {
+    if (value === undefined)
+        return false;
+    const normalized = value.trim().toLowerCase();
+    return normalized !== "" && normalized !== "0" && normalized !== "false" && normalized !== "off";
+}
+function getUpdatePromptMode(env) {
+    const normalized = env.OMK_UPDATE_PROMPT?.trim().toLowerCase();
+    if (normalized === "0" || normalized === "false" || normalized === "off" || normalized === "never") {
+        return "off";
+    }
+    if (normalized === "force")
+        return "force";
+    return "normal";
+}
+function getUpdateRemindHours(env) {
+    const parsed = Number(env.OMK_UPDATE_REMIND_HOURS);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_UPDATE_REMIND_HOURS;
+}
+function getUpdateRemindMs(env) {
+    return getUpdateRemindHours(env) * 60 * 60 * 1000;
+}
+function isPromptState(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const state = value;
+    return ((state.skippedVersion === undefined || typeof state.skippedVersion === "string") &&
+        (state.remindAfter === undefined || typeof state.remindAfter === "string") &&
+        (state.updatedAt === undefined || typeof state.updatedAt === "string"));
+}
+export async function readOmkUpdatePromptState(statePath = getOmkUpdatePromptStatePath()) {
+    if (!(await pathExists(statePath)))
+        return null;
+    try {
+        const parsed = JSON.parse(await readTextFile(statePath));
+        return isPromptState(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeOmkUpdatePromptState(state, statePath = getOmkUpdatePromptStatePath()) {
+    await writeFileSafe(statePath, `${JSON.stringify(state, null, 2)}\n`);
+}
+export function resolveOmkUpdatePromptState(options) {
+    const env = options.env ?? process.env;
+    const mode = getUpdatePromptMode(env);
+    if (mode === "off")
+        return { shouldPrompt: false, reason: "disabled" };
+    const isCI = options.isCI ?? (isTruthyCiValue(env.CI) || isTruthyCiValue(env.GITHUB_ACTIONS));
+    if (isCI)
+        return { shouldPrompt: false, reason: "ci" };
+    if (options.isTTY === false)
+        return { shouldPrompt: false, reason: "non-tty" };
+    const status = options.status;
+    if (!status?.omk.outdated)
+        return { shouldPrompt: false, reason: "not-outdated" };
+    const latestVersion = status.omk.latest ?? undefined;
+    if (!latestVersion)
+        return { shouldPrompt: false, reason: "missing-latest" };
+    if (mode === "force")
+        return { shouldPrompt: true, reason: "prompt", latestVersion };
+    const state = options.state;
+    if (state?.skippedVersion === latestVersion) {
+        return { shouldPrompt: false, reason: "skipped-version", latestVersion };
+    }
+    if (state?.remindAfter) {
+        const remindAt = new Date(state.remindAfter).getTime();
+        const now = options.now ?? new Date();
+        if (Number.isFinite(remindAt) && remindAt > now.getTime()) {
+            return { shouldPrompt: false, reason: "remind-active", latestVersion, remindAfter: state.remindAfter };
+        }
+    }
+    return { shouldPrompt: true, reason: "prompt", latestVersion };
+}
+export function formatStartupUpdateBanner(updateStatus) {
+    let banner = "";
+    if (updateStatus.omk.outdated) {
+        banner += `\n  ! omk ${updateStatus.omk.current} → ${updateStatus.omk.latest}  |  ${updateStatus.omk.installCmd}`;
+    }
+    return banner;
+}
+async function defaultSelectUpdatePrompt(config, options) {
+    const { select } = await import("@inquirer/prompts");
+    return (await select(config, options));
+}
+function classifyPromptError(err) {
+    if (err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError"))
+        return "timeout";
+    return "cancelled";
+}
+function promptActionToDecisionAction(reason) {
+    return reason === "prompt" ? "suppressed" : reason;
+}
+export async function maybePromptForOmkUpdate(options = {}) {
+    const env = options.env ?? process.env;
+    const now = options.now ?? new Date();
+    const isTTY = options.isTTY ?? Boolean(process.stdout.isTTY && process.stdin.isTTY);
+    const isCI = options.isCI ?? (isTruthyCiValue(env.CI) || isTruthyCiValue(env.GITHUB_ACTIONS));
+    const log = options.onLog ?? ((message) => console.log(message));
+    const preflight = resolveOmkUpdatePromptState({
+        status: null,
+        env,
+        isTTY,
+        isCI,
+        now,
+    });
+    if (preflight.reason === "disabled" || preflight.reason === "ci" || preflight.reason === "non-tty") {
+        return { action: preflight.reason, shouldExit: false };
+    }
+    let updateStatus;
+    try {
+        updateStatus = options.status ?? await (options.checkUpdatesFn ?? checkUpdates)();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { action: "suppressed", shouldExit: false, message };
+    }
+    const statePath = options.statePath ?? getOmkUpdatePromptStatePath();
+    const state = await readOmkUpdatePromptState(statePath);
+    const decision = resolveOmkUpdatePromptState({
+        status: updateStatus,
+        state,
+        env,
+        isTTY,
+        isCI,
+        now,
+    });
+    if (!decision.shouldPrompt) {
+        return {
+            action: promptActionToDecisionAction(decision.reason),
+            shouldExit: false,
+            version: decision.latestVersion,
+        };
+    }
+    const latestVersion = decision.latestVersion ?? updateStatus.omk.latest ?? "";
+    const currentVersion = updateStatus.omk.current;
+    const promptMessage = `New OMK version available: ${normalizeVersionForPrompt(latestVersion)}. You are using ${normalizeVersionForPrompt(currentVersion)}. Update now?`;
+    const remindHours = getUpdateRemindHours(env);
+    const choices = [
+        { name: "Update now", value: "update-now", description: updateStatus.omk.installCmd },
+        { name: "Skip this version", value: "skip-version", description: normalizeVersionForPrompt(latestVersion) },
+        { name: "Remind me later", value: "remind-later", description: `${remindHours}h` },
+    ];
+    let answer;
+    try {
+        answer = await (options.selectPrompt ?? defaultSelectUpdatePrompt)({ message: promptMessage, choices }, { signal: AbortSignal.timeout(options.promptTimeoutMs ?? UPDATE_PROMPT_TIMEOUT_MS) });
+    }
+    catch (err) {
+        const action = classifyPromptError(err);
+        log(action === "timeout" ? "Update prompt timed out; continuing without updating." : "Update prompt cancelled.");
+        return { action, shouldExit: false, version: latestVersion };
+    }
+    const updatedAt = now.toISOString();
+    if (answer === "skip-version") {
+        try {
+            await writeOmkUpdatePromptState({ skippedVersion: latestVersion, updatedAt }, statePath);
+        }
+        catch {
+            // State persistence is advisory; never block startup.
+        }
+        log(`Skipping OMK ${normalizeVersionForPrompt(latestVersion)} update prompt for this version.`);
+        return { action: "prompted-skip", shouldExit: false, version: latestVersion };
+    }
+    if (answer === "remind-later") {
+        const remindAfter = new Date(now.getTime() + getUpdateRemindMs(env)).toISOString();
+        try {
+            await writeOmkUpdatePromptState({ remindAfter, updatedAt }, statePath);
+        }
+        catch {
+            // State persistence is advisory; never block startup.
+        }
+        log(`OMK update reminder scheduled for ${remindAfter}.`);
+        return { action: "prompted-remind", shouldExit: false, version: latestVersion };
+    }
+    log(`Running update: ${OMK_UPDATE_INSTALL_CMD}`);
+    const runUpdate = options.runUpdate ?? (() => runShell("npm", ["i", "-g", OMK_NPM_PACKAGE_NAME], { timeout: 120_000 }));
+    const updateResult = await runUpdate();
+    if (updateResult.failed) {
+        const detail = updateResult.stderr.trim() || updateResult.stdout.trim() || `exit ${updateResult.exitCode}`;
+        log(`Update failed: ${detail}`);
+        log(`Manual update command: ${OMK_UPDATE_INSTALL_CMD}`);
+        return { action: "update-failed", shouldExit: true, exitCode: 1, version: latestVersion, message: detail };
+    }
+    log("OMK update completed successfully. Restart omk chat to use the new version.");
+    return { action: "updated", shouldExit: true, exitCode: 0, version: latestVersion };
+}
+async function readCache() {
+    const cachePath = getCachePath();
+    if (!(await pathExists(cachePath)))
+        return null;
+    try {
+        const raw = await readTextFile(cachePath);
+        const parsed = JSON.parse(raw);
+        const age = Date.now() - new Date(parsed.checkedAt).getTime();
+        if (age > CACHE_TTL_MS)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCache(cache) {
+    const cachePath = getCachePath();
+    try {
+        await writeFileSafe(cachePath, JSON.stringify(cache, null, 2));
+    }
+    catch {
+        // non-fatal
+    }
+}
+export function parseSemverParts(v) {
+    const m = v.match(/^(\d+)\.(\d+)\.(\d+)$/);
+    if (!m)
+        return null;
+    return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+export function compareVersions(a, b) {
+    const pa = parseSemverParts(a);
+    const pb = parseSemverParts(b);
+    if (!pa || !pb)
+        return 0;
+    for (let i = 0; i < 3; i++) {
+        if (pa[i] > pb[i])
+            return 1;
+        if (pa[i] < pb[i])
+            return -1;
+    }
+    return 0;
+}
+export function isOutdated(current, latest) {
+    return compareVersions(latest, current) > 0;
+}
+async function fetchOmkLatest() {
+    try {
+        const result = await runShell("npm", ["view", OMK_NPM_PACKAGE_NAME, "version"], {
+            timeout: 8000,
+        });
+        if (result.failed)
+            return null;
+        return result.stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchKimiLatest() {
+    return null;
+}
+async function getKimiInstalledVersion() {
+    return null;
+}
+export async function checkUpdates(forceRefresh = false) {
+    const cached = forceRefresh ? null : await readCache();
+    const cacheHit = cached !== null;
+    const omkCurrent = getOmkVersionSync();
+    const kimiInstalled = await getKimiInstalledVersion();
+    let omkLatest = cached?.omkLatest ?? null;
+    let kimiLatest = cached?.kimiLatest ?? null;
+    if (!cacheHit) {
+        const [omk, kimi] = await Promise.all([
+            fetchOmkLatest(),
+            fetchKimiLatest(),
+        ]);
+        omkLatest = omk;
+        kimiLatest = kimi;
+        await writeCache({
+            omkLatest,
+            kimiLatest,
+            checkedAt: new Date().toISOString(),
+        });
+    }
+    const omkOutdated = !!omkLatest && isOutdated(omkCurrent, omkLatest);
+    let omkError = null;
+    const kimiError = null;
+    if (!omkLatest && !cacheHit)
+        omkError = "registry unreachable";
+    return {
+        omk: {
+            current: omkCurrent,
+            latest: omkLatest,
+            outdated: omkOutdated,
+            error: omkError,
+            installCmd: OMK_UPDATE_INSTALL_CMD,
+        },
+        kimi: {
+            installed: kimiInstalled,
+            latest: kimiLatest,
+            outdated: false,
+            error: kimiError,
+            installCmd: "Set KIMI_API_KEY for direct Moonshot API access.",
+            installScript: FALLBACK_INSTALL_SCRIPT,
+            fallbackInstallCmd: FALLBACK_INSTALL_SCRIPT,
+        },
+        checkedAt: new Date().toISOString(),
+        cacheHit,
+    };
+}

package/dist/util/usage-view-model.d.ts

@@ -0,0 +1,22 @@
+import { type UsageStats } from "../kimi/usage.js";
+export interface UsageViewModel {
+    accountLabel: string;
+    authStatus: string;
+    source: "remoteQuota" | "localSessionFallback" | "missingAuth" | "networkError";
+    fiveHour: {
+        percent: number | null;
+        label: string;
+        resetHint?: string;
+    };
+    weekly: {
+        percent: number | null;
+        label: string;
+        resetHint?: string;
+    };
+    today: {
+        label: string;
+        sessionCount: number;
+    };
+    error?: string;
+}
+export declare function buildUsageViewModel(stats: UsageStats): UsageViewModel;

package/dist/util/usage-view-model.js

@@ -0,0 +1,57 @@
+import { formatDuration } from "../kimi/usage.js";
+export function buildUsageViewModel(stats) {
+    const accountLabel = stats.oauth.displayId;
+    const authStatus = stats.oauth.tokenStatus;
+    let source;
+    if (!stats.oauth.loggedIn) {
+        source = "missingAuth";
+    }
+    else if (stats.quota.error && stats.quota.rows.length === 0) {
+        source = "networkError";
+    }
+    else if (stats.quota.rows.length === 0) {
+        source = "localSessionFallback";
+    }
+    else {
+        source = "remoteQuota";
+    }
+    const fiveHour = source === "missingAuth"
+        ? { percent: null, label: "login required" }
+        : buildWindowViewModel(stats.quota.fiveHour, stats.totalSecondsLast5Hours);
+    const weekly = source === "missingAuth"
+        ? { percent: null, label: "login required" }
+        : buildWindowViewModel(stats.quota.weekly, stats.totalSecondsWeek);
+    return {
+        accountLabel,
+        authStatus,
+        source,
+        fiveHour,
+        weekly,
+        today: {
+            label: formatDuration(stats.totalSecondsToday),
+            sessionCount: stats.sessionCountToday,
+        },
+        error: stats.quota.error,
+    };
+}
+function buildWindowViewModel(row, fallbackSeconds) {
+    if (row && row.remainingPercent !== null) {
+        const usedPercent = Math.min(100, Math.max(0, 100 - row.remainingPercent));
+        return {
+            percent: usedPercent,
+            label: `${usedPercent}% used`,
+            resetHint: row.resetHint,
+        };
+    }
+    if (row && row.remainingPercent === null) {
+        return {
+            percent: null,
+            label: "unknown",
+            resetHint: row.resetHint,
+        };
+    }
+    return {
+        percent: null,
+        label: formatDuration(fallbackSeconds),
+    };
+}

package/dist/util/user-visible-output.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Last-line-of-defense output sanitizer.
+ * Strips control-plane leakage from text before it reaches the user.
+ */
+export declare const CONTROL_PLANE_LEAK_PATTERNS: RegExp[];
+/**
+ * Returns true if the value contains any control-plane leak pattern.
+ */
+export declare function isControlPlaneLeak(value: string): boolean;
+/**
+ * Returns a safe Korean summary to display when a leak is detected.
+ */
+export declare function getSafeSummary(): string;
+/**
+ * Sanitizes user-visible output.
+ * If a control-plane leak is detected, returns a safe summary.
+ * Otherwise returns the original value unchanged.
+ */
+export declare function sanitizeUserVisibleOutput(value: string): string;

package/dist/util/user-visible-output.js

@@ -0,0 +1,48 @@
+/**
+ * Last-line-of-defense output sanitizer.
+ * Strips control-plane leakage from text before it reaches the user.
+ */
+export const CONTROL_PLANE_LEAK_PATTERNS = [
+    // Korean: user repeatedly pasting the same prompt (with variants)
+    /사용자가\s+반복적으로\s+동일한\s+프롬프트를\s+복내고\s+있습니다/,
+    /사용자가\s+반복적으로\s+동일한\s+프롬프트를\s+복사하고\s+있습니다/,
+    /사용자가\s+반복적으로\s+동일한\s+프롬프트를\s+붙여넣고\s+있습니다/,
+    // Korean: this is an automated loop
+    /이는\s+자동화된\s+루프입니다/,
+    // Korean: must keep choosing STOP
+    /계속\s+STOP을\s+선택해야\s+합니다/,
+    // Korean: task already completed, followed by list pattern
+    /작업은\s+이미\s+완료되었습니다[\s\S]*?(?:\n\s*[-*]\s|\n\s*\d+\.\s)/,
+    // Korean: choose STOP (standalone)
+    /STOP을\s+선택/,
+    // English meta-text patterns
+    /The model may report evidence/,
+    /The runtime decides stop\/continue/,
+    // Line starting with Loop Guard: or Decision: followed by JSON-like braces
+    /^(?:Loop Guard|Decision):\s*\{.*\}/m,
+];
+/**
+ * Returns true if the value contains any control-plane leak pattern.
+ */
+export function isControlPlaneLeak(value) {
+    return CONTROL_PLANE_LEAK_PATTERNS.some((pattern) => pattern.test(value));
+}
+/**
+ * Returns a safe Korean summary to display when a leak is detected.
+ */
+export function getSafeSummary() {
+    return ("검증 완료.\n" +
+        "\n" +
+        "이전 작업 상태와 산출물이 확인되어 추가 실행을 중단했습니다.");
+}
+/**
+ * Sanitizes user-visible output.
+ * If a control-plane leak is detected, returns a safe summary.
+ * Otherwise returns the original value unchanged.
+ */
+export function sanitizeUserVisibleOutput(value) {
+    if (isControlPlaneLeak(value)) {
+        return getSafeSummary();
+    }
+    return value;
+}

package/dist/util/version.d.ts

@@ -0,0 +1,4 @@
+export declare const OMK_REPO_URL = "https://github.com/dmae97/open-multi-agent-kit";
+export declare function getOmkVersionSync(): string;
+export declare function getOmkRepoUrlSync(): string;
+export declare function formatOmkVersionFooter(version?: string): string;

package/dist/util/version.js

@@ -0,0 +1,51 @@
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+export const OMK_REPO_URL = "https://github.com/dmae97/open-multi-agent-kit";
+let cachedVersion;
+let cachedRepoUrl;
+function packageRoot() {
+    const currentFile = fileURLToPath(import.meta.url);
+    return join(dirname(currentFile), "..", "..");
+}
+export function getOmkVersionSync() {
+    if (cachedVersion)
+        return cachedVersion;
+    try {
+        const packageJson = JSON.parse(readFileSync(join(packageRoot(), "package.json"), "utf-8"));
+        cachedVersion = typeof packageJson.version === "string" ? packageJson.version : "0.0.0";
+    }
+    catch {
+        cachedVersion = "0.0.0";
+    }
+    return cachedVersion;
+}
+function normalizeRepositoryUrl(repository) {
+    const value = typeof repository === "string"
+        ? repository
+        : repository && typeof repository === "object" && "url" in repository && typeof repository.url === "string"
+            ? repository.url
+            : undefined;
+    if (!value)
+        return undefined;
+    return value
+        .replace(/^git\+/, "")
+        .replace(/\.git$/, "");
+}
+export function getOmkRepoUrlSync() {
+    if (cachedRepoUrl)
+        return cachedRepoUrl;
+    try {
+        const packageJson = JSON.parse(readFileSync(join(packageRoot(), "package.json"), "utf-8"));
+        cachedRepoUrl = normalizeRepositoryUrl(packageJson.repository)
+            ?? (typeof packageJson.homepage === "string" ? packageJson.homepage.replace(/#readme$/, "") : undefined)
+            ?? OMK_REPO_URL;
+    }
+    catch {
+        cachedRepoUrl = OMK_REPO_URL;
+    }
+    return cachedRepoUrl;
+}
+export function formatOmkVersionFooter(version = getOmkVersionSync()) {
+    return `omk v${version} • GitHub: ${getOmkRepoUrlSync()}`;
+}

package/dist/util/worktree.d.ts

@@ -0,0 +1,10 @@
+export declare function validateWorktreeId(value: string, label?: string): string;
+export declare function getWorktreesRoot(): string;
+export declare function resolveSafeWorktreePath(candidatePath: string): Promise<string>;
+export declare function createWorktree(runId: string, nodeId: string): Promise<string>;
+export declare function removeWorktreeDirectory(path: string): Promise<void>;
+export declare function removeWorktree(path: string): Promise<void>;
+export declare function listWorktrees(runId: string): Promise<string[]>;
+export declare function createAttemptWorktree(runId: string, nodeId: string, attempt: number): Promise<string>;
+export declare function removeAttemptWorktree(runId: string, nodeId: string, attempt: number): Promise<void>;
+export declare function listAttemptWorktrees(runId: string, nodeId: string): Promise<string[]>;