open-multi-agent-kit 0.78.0

package/dist/util/sync-manifest.js

@@ -0,0 +1,22 @@
+import { createHash } from "crypto";
+export function sha256(content) {
+    return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+export function simpleDiff(oldText, newText) {
+    const oldLines = oldText.split("\n");
+    const newLines = newText.split("\n");
+    const result = [];
+    const maxLen = Math.max(oldLines.length, newLines.length);
+    for (let i = 0; i < maxLen; i++) {
+        const oldLine = oldLines[i] ?? "";
+        const newLine = newLines[i] ?? "";
+        if (oldLine !== newLine) {
+            result.push(`-${oldLine}`);
+            result.push(`+${newLine}`);
+        }
+        else {
+            result.push(` ${oldLine}`);
+        }
+    }
+    return result.join("\n");
+}

package/dist/util/terminal-input.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Helpers for temporarily taking ownership of TTY input.
+ *
+ * Interactive wrappers, dashboards, and mode pickers often need raw stdin.
+ * They must restore only the terminal state they changed; otherwise nested
+ * tmux/WSL sessions can lose visible input or stay in raw mode after exit.
+ */
+export interface TerminalInputLike {
+    isTTY?: boolean;
+    isRaw?: boolean;
+    readableFlowing: boolean | null;
+    setRawMode?: (mode: boolean) => unknown;
+    resume(): unknown;
+    pause(): unknown;
+    listenerCount(eventName: string | symbol): number;
+}
+export interface TerminalInputState {
+    readonly wasTTY: boolean;
+    readonly rawMode?: boolean;
+    readonly readableFlowing: boolean | null;
+    readonly dataListenerCount: number;
+}
+export declare function captureTerminalInputState(input?: TerminalInputLike): TerminalInputState;
+export declare function enableRawTerminalInput(input?: TerminalInputLike): TerminalInputState;
+export declare function restoreTerminalInputState(input: TerminalInputLike | undefined, state: TerminalInputState): void;

package/dist/util/terminal-input.js

@@ -0,0 +1,35 @@
+/**
+ * Helpers for temporarily taking ownership of TTY input.
+ *
+ * Interactive wrappers, dashboards, and mode pickers often need raw stdin.
+ * They must restore only the terminal state they changed; otherwise nested
+ * tmux/WSL sessions can lose visible input or stay in raw mode after exit.
+ */
+export function captureTerminalInputState(input = process.stdin) {
+    return {
+        wasTTY: Boolean(input.isTTY),
+        rawMode: input.isTTY ? Boolean(input.isRaw) : undefined,
+        readableFlowing: input.readableFlowing,
+        dataListenerCount: input.listenerCount("data"),
+    };
+}
+export function enableRawTerminalInput(input = process.stdin) {
+    const state = captureTerminalInputState(input);
+    if (input.isTTY && typeof input.setRawMode === "function") {
+        input.setRawMode(true);
+    }
+    input.resume();
+    return state;
+}
+export function restoreTerminalInputState(input = process.stdin, state) {
+    const externalDataOwnerAttached = input.listenerCount("data") > state.dataListenerCount;
+    if (!externalDataOwnerAttached && state.wasTTY && typeof input.setRawMode === "function") {
+        input.setRawMode(state.rawMode ?? false);
+    }
+    // Only pause stdin when this owner started it and no other data consumer is
+    // still attached. Pausing shared stdin after readline/PTY cleanup is a common
+    // cause of apparently "disappearing" keyboard input in nested WSL terminals.
+    if (state.readableFlowing !== true && !externalDataOwnerAttached && input.listenerCount("data") === 0) {
+        input.pause();
+    }
+}

package/dist/util/terminal-layout.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Terminal layout utilities — visible-width-aware helpers for CLI rendering.
+ */
+import { sanitizeTerminalText } from "./theme.js";
+export declare function visibleTerminalWidth(value: string): number;
+/** Truncate visible text while preserving ANSI escape sequences. */
+export declare function truncateLine(line: string, maxWidth: number): string;
+export declare function padEndVisible(value: string, targetWidth: number): string;
+export declare function padStartVisible(value: string, targetWidth: number): string;
+/** Ensure an array of lines exactly matches a target count (truncate or pad). */
+export declare function fitLines(lines: string[], count: number): string[];
+/** Ensure an array of lines fits a target height (truncate or pad). */
+export declare function fitHeight(lines: string[], height?: number): string[];
+/** Wrap lines in a themed box panel. */
+export declare function panel(title: string, lines: string[], width: number): string;
+/** Render a section header. */
+export declare function sectionHeader(title: string): string;
+export { sanitizeTerminalText };

package/dist/util/terminal-layout.js

@@ -0,0 +1,108 @@
+/**
+ * Terminal layout utilities — visible-width-aware helpers for CLI rendering.
+ */
+import { style, box, subheader, sanitizeTerminalText } from "./theme.js";
+const ANSI_REGEX = /\x1B(?:[@-Z\-_]|\[[0-?]*[ -/]*[@-~])/g;
+function isCombiningCodePoint(codePoint) {
+    return (codePoint === 0x200d ||
+        (codePoint >= 0x0300 && codePoint <= 0x036f) ||
+        (codePoint >= 0x1ab0 && codePoint <= 0x1aff) ||
+        (codePoint >= 0x1dc0 && codePoint <= 0x1dff) ||
+        (codePoint >= 0x20d0 && codePoint <= 0x20ff) ||
+        (codePoint >= 0xfe00 && codePoint <= 0xfe0f) ||
+        (codePoint >= 0xfe20 && codePoint <= 0xfe2f));
+}
+function isWideCodePoint(codePoint) {
+    return ((codePoint >= 0x1100 && codePoint <= 0x115f) ||
+        codePoint === 0x2329 ||
+        codePoint === 0x232a ||
+        (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+        (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+        (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+        (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+        (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+        (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+        (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+        (codePoint >= 0x1f300 && codePoint <= 0x1faff) ||
+        (codePoint >= 0x2600 && codePoint <= 0x27bf));
+}
+function terminalCharWidth(char) {
+    const codePoint = char.codePointAt(0);
+    if (codePoint === undefined)
+        return 0;
+    if (codePoint === 0 || codePoint < 0x20 || (codePoint >= 0x7f && codePoint < 0xa0))
+        return 0;
+    if (isCombiningCodePoint(codePoint))
+        return 0;
+    return isWideCodePoint(codePoint) ? 2 : 1;
+}
+export function visibleTerminalWidth(value) {
+    return [...sanitizeTerminalText(value)].reduce((width, char) => width + terminalCharWidth(char), 0);
+}
+/** Truncate visible text while preserving ANSI escape sequences. */
+export function truncateLine(line, maxWidth) {
+    if (maxWidth <= 0)
+        return "";
+    if (visibleTerminalWidth(line) <= maxWidth)
+        return line;
+    const ellipsis = style.gray("…");
+    const limit = Math.max(0, maxWidth - 1);
+    let currentWidth = 0;
+    let result = "";
+    let lastIndex = 0;
+    let match;
+    const appendText = (text) => {
+        for (const char of text) {
+            const charWidth = terminalCharWidth(char);
+            if (currentWidth + charWidth > limit)
+                return false;
+            result += char;
+            currentWidth += charWidth;
+        }
+        return true;
+    };
+    ANSI_REGEX.lastIndex = 0;
+    while ((match = ANSI_REGEX.exec(line)) !== null) {
+        const textBefore = line.slice(lastIndex, match.index);
+        if (!appendText(textBefore))
+            return result + ellipsis;
+        result += match[0];
+        lastIndex = ANSI_REGEX.lastIndex;
+    }
+    const remaining = line.slice(lastIndex);
+    if (!appendText(remaining))
+        return result + ellipsis;
+    return result;
+}
+export function padEndVisible(value, targetWidth) {
+    return value + " ".repeat(Math.max(0, targetWidth - visibleTerminalWidth(value)));
+}
+export function padStartVisible(value, targetWidth) {
+    return " ".repeat(Math.max(0, targetWidth - visibleTerminalWidth(value))) + value;
+}
+/** Ensure an array of lines exactly matches a target count (truncate or pad). */
+export function fitLines(lines, count) {
+    const result = lines.slice(0, count);
+    while (result.length < count)
+        result.push("");
+    return result;
+}
+/** Ensure an array of lines fits a target height (truncate or pad). */
+export function fitHeight(lines, height) {
+    if (height == null)
+        return lines;
+    const result = lines.slice(0, height);
+    while (result.length < height)
+        result.push("");
+    return result;
+}
+/** Wrap lines in a themed box panel. */
+export function panel(title, lines, width) {
+    const processed = lines.map((line) => padEndVisible(truncateLine(line, width), width));
+    return box(processed, title || undefined);
+}
+/** Render a section header. */
+export function sectionHeader(title) {
+    return subheader(title);
+}
+export { sanitizeTerminalText };

package/dist/util/terminal-owner.d.ts

@@ -0,0 +1,19 @@
+export type TerminalOwnerState = "idle" | "readline" | "child" | "raw-selector";
+export interface TerminalInputOwnerLike {
+    pause(): unknown;
+    resume(): unknown;
+}
+export interface ReadlineOwnerLike {
+    pause(): unknown;
+    resume(): unknown;
+    prompt?(preserveCursor?: boolean): unknown;
+}
+export declare class TerminalOwner {
+    private readonly input;
+    private active;
+    constructor(input?: TerminalInputOwnerLike);
+    get state(): TerminalOwnerState;
+    claimReadline(): () => void;
+    withChildProcess<T>(readline: ReadlineOwnerLike | undefined, fn: () => Promise<T>): Promise<T>;
+    private assertCanOwn;
+}

package/dist/util/terminal-owner.js

@@ -0,0 +1,64 @@
+export class TerminalOwner {
+    input;
+    active = "idle";
+    constructor(input = process.stdin) {
+        this.input = input;
+    }
+    get state() {
+        return this.active;
+    }
+    claimReadline() {
+        this.assertCanOwn("readline");
+        this.active = "readline";
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            if (this.active === "readline")
+                this.active = "idle";
+        };
+    }
+    async withChildProcess(readline, fn) {
+        if (this.active !== "idle" && this.active !== "readline") {
+            throw new Error(`Terminal already owned by ${this.active}; cannot start child`);
+        }
+        const previous = this.active;
+        this.active = "child";
+        try {
+            try {
+                readline?.pause();
+            }
+            catch {
+                // Piped input can close readline before queued work finishes.
+            }
+            try {
+                this.input.pause();
+            }
+            catch {
+                // Non-standard test streams may already be closed.
+            }
+            return await fn();
+        }
+        finally {
+            try {
+                this.input.resume();
+            }
+            catch {
+                // EOF/non-TTY test harnesses can close stdin while a child-owned task is settling.
+            }
+            try {
+                readline?.resume();
+            }
+            catch {
+                // Readline may already be closed after piped input EOF; ownership must still reset.
+            }
+            this.active = previous;
+        }
+    }
+    assertCanOwn(next) {
+        if (this.active !== "idle") {
+            throw new Error(`Terminal already owned by ${this.active}; cannot start ${next}`);
+        }
+    }
+}

package/dist/util/theme.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Backward-compatible theme bridge.
+ *
+ * The canonical OMK UI/UX surface lives in src/theme/*. New code should import
+ * from `../theme/index.js` (or focused submodules) directly. This bridge keeps
+ * existing `util/theme.js` consumers on the same single source of truth without
+ * preserving a duplicate theme implementation.
+ */
+export * from "../theme/index.js";

package/dist/util/theme.js

@@ -0,0 +1,9 @@
+/**
+ * Backward-compatible theme bridge.
+ *
+ * The canonical OMK UI/UX surface lives in src/theme/*. New code should import
+ * from `../theme/index.js` (or focused submodules) directly. This bridge keeps
+ * existing `util/theme.js` consumers on the same single source of truth without
+ * preserving a duplicate theme implementation.
+ */
+export * from "../theme/index.js";

package/dist/util/timeout-config.d.ts

@@ -0,0 +1,18 @@
+import type { TimeoutPreset } from "../contracts/orchestration.js";
+/**
+ * Resolve timeout presets from .omk/config.toml [timeouts.<preset>] sections.
+ * Merges: built-in defaults → config overrides → env override for default.
+ */
+export declare function resolveTimeoutPresets(): Promise<Record<string, TimeoutPreset>>;
+/**
+ * Reset cached preset config (mainly for tests).
+ */
+export declare function resetTimeoutPresetCache(): void;
+/**
+ * Resolve the effective timeout in milliseconds for a node or run.
+ * Priority: per-node timeoutMs > preset > env OMK_NODE_TIMEOUT_MS > default preset.
+ */
+export declare function resolveTimeoutMs(options: {
+    timeoutMs?: number;
+    timeoutPreset?: string;
+}): Promise<number>;

package/dist/util/timeout-config.js

@@ -0,0 +1,101 @@
+import { readSimpleToml, getProjectRoot } from "./resource-profile.js";
+import { join } from "path";
+const HARD_MAX_TIMEOUT_MS = 3_600_000; // 1 hour
+const DEFAULT_PRESETS = {
+    default: { name: "default", timeoutMs: 120_000, description: "Default 2-minute timeout" },
+    quick: { name: "quick", timeoutMs: 30_000, description: "Quick 30-second timeout for simple tasks" },
+    standard: { name: "standard", timeoutMs: 120_000, description: "Standard 2-minute timeout" },
+    "long-running": { name: "long-running", timeoutMs: 1_800_000, description: "Long-running 30-minute timeout" },
+    unlimited: { name: "unlimited", timeoutMs: HARD_MAX_TIMEOUT_MS, description: "Hard maximum 1-hour timeout" },
+};
+let presetCache;
+/**
+ * Resolve timeout presets from .omk/config.toml [timeouts.<preset>] sections.
+ * Merges: built-in defaults → config overrides → env override for default.
+ */
+export async function resolveTimeoutPresets() {
+    presetCache ??= loadTimeoutPresets();
+    return presetCache;
+}
+/**
+ * Reset cached preset config (mainly for tests).
+ */
+export function resetTimeoutPresetCache() {
+    presetCache = undefined;
+}
+/**
+ * Resolve the effective timeout in milliseconds for a node or run.
+ * Priority: per-node timeoutMs > preset > env OMK_NODE_TIMEOUT_MS > default preset.
+ */
+export async function resolveTimeoutMs(options) {
+    let value;
+    // 1. Explicit per-node timeout wins
+    if (options.timeoutMs !== undefined && options.timeoutMs >= 0) {
+        value = options.timeoutMs;
+    }
+    else {
+        // 2. Preset lookup
+        const presets = await resolveTimeoutPresets();
+        const requestedPreset = options.timeoutPreset?.trim();
+        const presetName = requestedPreset && requestedPreset.length > 0 ? requestedPreset : "default";
+        const preset = presets[presetName];
+        if (preset) {
+            value = preset.timeoutMs;
+        }
+        else {
+            const validPresets = Object.keys(presets).sort().join(", ");
+            throw new Error(`Unknown timeout preset "${presetName}". Valid presets: ${validPresets}`);
+        }
+    }
+    if (value === 0 || value > HARD_MAX_TIMEOUT_MS) {
+        return HARD_MAX_TIMEOUT_MS;
+    }
+    return value;
+}
+async function loadTimeoutPresets() {
+    const path = join(getProjectRoot(), ".omk", "config.toml");
+    const flat = await readSimpleToml(path);
+    const presets = { ...DEFAULT_PRESETS };
+    for (const [key, value] of Object.entries(flat)) {
+        const m = key.match(/^timeouts\.([A-Za-z0-9_-]+)\.(timeout_ms|timeout_minutes|description)$/);
+        if (!m)
+            continue;
+        const [, presetName, field] = m;
+        const preset = (presets[presetName] ??= { name: presetName, timeoutMs: 0 });
+        switch (field) {
+            case "timeout_ms": {
+                const ms = parsePositiveInt(value);
+                if (ms !== undefined)
+                    preset.timeoutMs = ms;
+                break;
+            }
+            case "timeout_minutes": {
+                const minutes = parsePositiveNumber(value);
+                if (minutes !== undefined)
+                    preset.timeoutMs = Math.round(minutes * 60_000);
+                break;
+            }
+            case "description":
+                preset.description = value;
+                break;
+        }
+    }
+    // Env override for the default preset
+    const envTimeout = parsePositiveInt(process.env.OMK_NODE_TIMEOUT_MS);
+    if (envTimeout !== undefined) {
+        presets.default = { ...presets.default, timeoutMs: envTimeout };
+    }
+    return presets;
+}
+function parsePositiveInt(value) {
+    if (value === undefined || value.trim() === "")
+        return undefined;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+function parsePositiveNumber(value) {
+    if (value === undefined || value.trim() === "")
+        return undefined;
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}

package/dist/util/todo-sync.d.ts

@@ -0,0 +1,58 @@
+export type TodoStatus = "pending" | "in_progress" | "done" | "failed" | "blocked" | "skipped";
+export type TodoWriteOperationName = "init" | "start" | "done" | "drop" | "rm" | "append" | "note";
+export interface TodoItem {
+    title: string;
+    status: TodoStatus;
+    agent?: string;
+    role?: string;
+    startedAt?: string;
+    completedAt?: string;
+    elapsedMs?: number;
+    evidence?: string;
+    description?: string;
+    activeForm?: string;
+    phase?: string;
+    order?: number;
+    notes?: string[];
+}
+export type TodoWriteStatus = "pending" | "in_progress" | "completed";
+export interface TodoWriteItem {
+    content: string;
+    status: TodoWriteStatus;
+    activeForm?: string;
+}
+export interface TodoWriteInput {
+    todos: TodoWriteItem[];
+}
+export interface TodoWritePhaseInput {
+    phase: string;
+    items: string[];
+}
+export interface TodoWriteOperation {
+    op: TodoWriteOperationName;
+    list?: TodoWritePhaseInput[];
+    task?: string;
+    phase?: string;
+    items?: string[];
+    text?: string;
+}
+export interface TodoWriteOpsInput {
+    ops: TodoWriteOperation[];
+}
+export interface TodoWriteOpsResult {
+    todos: TodoItem[];
+    applied: number;
+}
+export declare function writeTodos(runId: string, todos: TodoItem[]): Promise<void>;
+export declare function readTodos(runId: string): Promise<TodoItem[] | null>;
+export declare function normalizeTodoItems(value: unknown): TodoItem[];
+export declare function normalizeTodoWriteInput(input: unknown): TodoItem[];
+export declare function applyTodoWriteOperations(existingTodos: readonly TodoItem[], operations: readonly TodoWriteOperation[], now?: () => string): TodoWriteOpsResult;
+export declare function updateTodoStatus(runId: string, title: string, status: TodoStatus): Promise<void>;
+export declare function deriveTodosFromState(runId: string): Promise<TodoItem[] | null>;
+export declare function parseSetTodoListFromOutput(output: string): TodoItem[] | null;
+/**
+ * Load todos for a run, trying todos.json first then falling back to state.json nodes.
+ * This is the canonical read path used by cockpit and HUD renderers.
+ */
+export declare function loadTodos(runId: string | null): Promise<TodoItem[] | null>;