open-multi-agent-kit 0.79.1 → 0.80.0

package/dist/util/screenshot-store.js

@@ -0,0 +1,340 @@
+/**
+ * Screenshot store — cross-platform clipboard image reader with safe project-relative paths.
+ *
+ * All images are saved under .omk/screenshots/YYYY-MM-DD/ so they stay
+ * gitignored and organized by date.
+ */
+import { execFileSync } from "node:child_process";
+import { writeFileSync, mkdirSync, readFileSync, readdirSync, statSync, existsSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, relative } from "node:path";
+import { createHash } from "node:crypto";
+import { getProjectRoot } from "./fs.js";
+export const SCREENSHOT_DIR = ".omk/screenshots";
+export const MAX_SIZE_BYTES = 20 * 1024 * 1024;
+const CLIPBOARD_TIMEOUT_MS = 5000;
+const CLIPBOARD_MAX_BUFFER_BYTES = MAX_SIZE_BYTES * 2;
+export function listScreenshotCaptureCapabilities(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const wsl = platform === "linux" && isWslEnvironment(options.env, options.procVersion);
+    return [
+        {
+            name: "windows-clipboard-image",
+            supported: platform === "win32" || wsl,
+            mode: "image",
+            note: "PowerShell STA bridge reads Snipping Tool / Ctrl+V image clipboard data.",
+        },
+        {
+            name: "macos-clipboard-image",
+            supported: platform === "darwin",
+            mode: "image",
+            note: "pngpaste or osascript reads image clipboard data.",
+        },
+        {
+            name: "linux-clipboard-image",
+            supported: platform === "linux",
+            mode: "image",
+            note: "wl-paste/xclip reads image clipboard data; WSL tries Windows first.",
+        },
+        {
+            name: "terminal-kit-ctrl-v-text",
+            supported: true,
+            mode: "raw-key",
+            note: "terminal-kit can capture Ctrl+V-style raw key/text clipboard hooks, not image screenshots.",
+        },
+    ];
+}
+const IMAGE_MAGIC = new Map([
+    ["png", [0x89, 0x50, 0x4e, 0x47]],
+    ["jpg", [0xff, 0xd8, 0xff]],
+    ["webp", [0x52, 0x49, 0x46, 0x46]], // RIFF
+    ["gif", [0x47, 0x49, 0x46, 0x38]], // GIF8
+]);
+export function validateMagicBytes(buf) {
+    for (const [ext, magic] of IMAGE_MAGIC) {
+        if (buf.length >= magic.length && magic.every((b, i) => buf[i] === b)) {
+            return { ok: true, ext };
+        }
+    }
+    return { ok: false, ext: "" };
+}
+function generateScreenshotPath(projectRoot, ext) {
+    const now = new Date();
+    const dateDir = now.toISOString().slice(0, 10);
+    const timestamp = now.toISOString().replace(/[:.]/g, "").slice(0, 15);
+    const hash = createHash("sha256").update(`${Date.now()}-${Math.random()}`).digest("hex").slice(0, 8);
+    const fileName = `screenshot-${timestamp}-${hash}.${ext}`;
+    const dir = join(projectRoot, SCREENSHOT_DIR, dateDir);
+    mkdirSync(dir, { recursive: true });
+    const fullPath = join(dir, fileName);
+    const relativePath = relative(projectRoot, fullPath).replace(/\\/g, "/");
+    return { fullPath, relativePath };
+}
+function saveScreenshot(data, ext, projectRoot) {
+    if (data.length > MAX_SIZE_BYTES) {
+        return { ok: false, error: `Image exceeds ${MAX_SIZE_BYTES / (1024 * 1024)} MB limit` };
+    }
+    const magic = validateMagicBytes(data);
+    if (!magic.ok) {
+        return { ok: false, error: "Clipboard does not contain a valid image (PNG/JPG/WebP/GIF)" };
+    }
+    const { fullPath, relativePath } = generateScreenshotPath(projectRoot, magic.ext);
+    writeFileSync(fullPath, data);
+    return { ok: true, path: fullPath, relativePath: `./${relativePath}` };
+}
+// ---------------------------------------------------------------------------
+// Windows provider
+// ---------------------------------------------------------------------------
+export function buildWindowsClipboardImageScript() {
+    return `
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+
+function Emit-Bytes([byte[]]$Bytes) {
+  if ($null -eq $Bytes -or $Bytes.Length -eq 0) { exit 1 }
+  [Console]::Out.Write([Convert]::ToBase64String($Bytes))
+  exit 0
+}
+
+$data = [System.Windows.Forms.Clipboard]::GetDataObject()
+if ($null -ne $data) {
+  foreach ($format in @('PNG', 'image/png')) {
+    if ($data.GetDataPresent($format)) {
+      $raw = $data.GetData($format)
+      if ($raw -is [System.IO.MemoryStream]) { Emit-Bytes $raw.ToArray() }
+      if ($raw -is [byte[]]) { Emit-Bytes $raw }
+    }
+  }
+
+  if ($data.GetDataPresent([System.Windows.Forms.DataFormats]::FileDrop)) {
+    $files = [string[]]$data.GetData([System.Windows.Forms.DataFormats]::FileDrop)
+    foreach ($file in $files) {
+      if ($file -match '[.](png|jpg|jpeg|webp|gif)$' -and [System.IO.File]::Exists($file)) {
+        Emit-Bytes ([System.IO.File]::ReadAllBytes($file))
+      }
+    }
+  }
+}
+
+if ([System.Windows.Forms.Clipboard]::ContainsImage()) {
+  $img = [System.Windows.Forms.Clipboard]::GetImage()
+  if ($null -ne $img) {
+    $ms = New-Object System.IO.MemoryStream
+    try {
+      $img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)
+      Emit-Bytes $ms.ToArray()
+    } finally {
+      $ms.Dispose()
+      $img.Dispose()
+    }
+  }
+}
+
+exit 1
+`;
+}
+export function getWindowsClipboardImageCommands(env = process.env) {
+    const explicit = env.OMK_WINDOWS_POWERSHELL_PATH?.trim();
+    const candidates = explicit
+        ? [explicit]
+        : [
+            "powershell.exe",
+            "pwsh.exe",
+            "/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe",
+        ];
+    return [...new Set(candidates.filter((cmd) => cmd.length > 0))];
+}
+function execWindowsClipboardScript(command, options = {}) {
+    const encoded = Buffer.from(buildWindowsClipboardImageScript(), "utf16le").toString("base64");
+    return execFileSync(command, ["-NoProfile", "-STA", "-EncodedCommand", encoded], {
+        encoding: "utf-8",
+        timeout: options.timeoutMs ?? CLIPBOARD_TIMEOUT_MS,
+        maxBuffer: CLIPBOARD_MAX_BUFFER_BYTES,
+        windowsHide: true,
+        env: options.env ? { ...process.env, ...options.env } : process.env,
+    }).trim();
+}
+function readWindowsClipboard(projectRoot, options = {}) {
+    let lastError = "No image in clipboard";
+    for (const command of getWindowsClipboardImageCommands(options.env)) {
+        try {
+            const b64 = execWindowsClipboardScript(command, options);
+            const buf = Buffer.from(b64, "base64");
+            if (buf.length === 0) {
+                lastError = "No image in clipboard";
+                continue;
+            }
+            return saveScreenshot(buf, "png", projectRoot);
+        }
+        catch (e) {
+            lastError = e instanceof Error ? e.message : String(e);
+        }
+    }
+    return { ok: false, error: lastError };
+}
+// ---------------------------------------------------------------------------
+// macOS provider
+// ---------------------------------------------------------------------------
+function readMacOSClipboard(projectRoot, options = {}) {
+    // Try pngpaste first (more reliable)
+    try {
+        const tmpPath = join(tmpdir(), `omk-screenshot-${Date.now()}.png`);
+        execFileSync("pngpaste", [tmpPath], { timeout: options.timeoutMs ?? CLIPBOARD_TIMEOUT_MS });
+        const buf = readFileSync(tmpPath);
+        if (buf.length === 0) {
+            return { ok: false, error: "No image in clipboard" };
+        }
+        return saveScreenshot(buf, "png", projectRoot);
+    }
+    catch {
+        // Fallback to osascript
+        try {
+            const tmpPath = join(tmpdir(), `omk-screenshot-${Date.now()}.png`);
+            const script = `
+        set pngData to the clipboard as «class PNGf»
+        set f to open for access POSIX file "${tmpPath}" with write permission
+        write pngData to f
+        close access f
+      `;
+            execFileSync("osascript", ["-e", script], { encoding: "utf-8", timeout: options.timeoutMs ?? CLIPBOARD_TIMEOUT_MS });
+            const buf = readFileSync(tmpPath);
+            if (buf.length === 0) {
+                return { ok: false, error: "No image in clipboard" };
+            }
+            return saveScreenshot(buf, "png", projectRoot);
+        }
+        catch (e) {
+            return { ok: false, error: e.message };
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Linux / WSL provider
+// ---------------------------------------------------------------------------
+export function isWslEnvironment(env = process.env, procVersion) {
+    if (env.WSL_DISTRO_NAME || env.WSLENV || env.WSL_INTEROP)
+        return true;
+    const version = procVersion ?? (() => {
+        try {
+            return readFileSync("/proc/version", "utf-8");
+        }
+        catch {
+            return "";
+        }
+    })();
+    return /microsoft|wsl/i.test(version);
+}
+function readLinuxClipboard(projectRoot, options = {}) {
+    let wslError;
+    if (isWslEnvironment(options.env, options.procVersion)) {
+        const windowsResult = readWindowsClipboard(projectRoot, options);
+        if (windowsResult.ok)
+            return windowsResult;
+        wslError = windowsResult.error;
+    }
+    try {
+        let buf;
+        try {
+            buf = execFileSync("wl-paste", ["--type", "image/png"], {
+                timeout: options.timeoutMs ?? CLIPBOARD_TIMEOUT_MS,
+                encoding: "buffer",
+                maxBuffer: CLIPBOARD_MAX_BUFFER_BYTES,
+            });
+        }
+        catch {
+            buf = execFileSync("xclip", ["-selection", "clipboard", "-t", "image/png", "-o"], {
+                timeout: options.timeoutMs ?? CLIPBOARD_TIMEOUT_MS,
+                encoding: "buffer",
+                maxBuffer: CLIPBOARD_MAX_BUFFER_BYTES,
+            });
+        }
+        if (buf.length === 0) {
+            return { ok: false, error: "No image in clipboard" };
+        }
+        return saveScreenshot(buf, "png", projectRoot);
+    }
+    catch (e) {
+        const linuxError = e instanceof Error ? e.message : String(e);
+        const error = wslError ? `Windows clipboard unavailable (${wslError}); Linux clipboard unavailable (${linuxError})` : linuxError;
+        return { ok: false, error };
+    }
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+export function pasteScreenshot(projectRoot, options = {}) {
+    const root = projectRoot ?? getProjectRoot();
+    const platform = options.platform ?? process.platform;
+    if (platform === "win32") {
+        return readWindowsClipboard(root, options);
+    }
+    if (platform === "darwin") {
+        return readMacOSClipboard(root, options);
+    }
+    return readLinuxClipboard(root, options);
+}
+export function getScreenshotDir(projectRoot) {
+    const root = projectRoot ?? getProjectRoot();
+    return join(root, SCREENSHOT_DIR);
+}
+export function listScreenshots(projectRoot) {
+    const root = projectRoot ?? getProjectRoot();
+    const base = join(root, SCREENSHOT_DIR);
+    if (!existsSync(base))
+        return [];
+    const entries = [];
+    for (const dateDir of readdirSync(base)) {
+        const datePath = join(base, dateDir);
+        const stat = statSync(datePath, { throwIfNoEntry: false });
+        if (!stat || !stat.isDirectory())
+            continue;
+        for (const file of readdirSync(datePath)) {
+            const fullPath = join(datePath, file);
+            const s = statSync(fullPath, { throwIfNoEntry: false });
+            if (!s || !s.isFile())
+                continue;
+            entries.push({
+                relativePath: relative(root, fullPath).replace(/\\/g, "/"),
+                fullPath,
+                size: s.size,
+                mtimeMs: s.mtimeMs,
+            });
+        }
+    }
+    return entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+export function cleanScreenshots(days, dryRun, projectRoot) {
+    const root = projectRoot ?? getProjectRoot();
+    const base = join(root, SCREENSHOT_DIR);
+    if (!existsSync(base))
+        return { deleted: [], skipped: [] };
+    const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+    const result = { deleted: [], skipped: [] };
+    for (const dateDir of readdirSync(base)) {
+        const datePath = join(base, dateDir);
+        const stat = statSync(datePath, { throwIfNoEntry: false });
+        if (!stat || !stat.isDirectory())
+            continue;
+        for (const file of readdirSync(datePath)) {
+            const fullPath = join(datePath, file);
+            const s = statSync(fullPath, { throwIfNoEntry: false });
+            if (!s || !s.isFile())
+                continue;
+            if (s.mtimeMs < cutoff) {
+                if (!dryRun) {
+                    rmSync(fullPath);
+                }
+                result.deleted.push(relative(root, fullPath).replace(/\\/g, "/"));
+            }
+            else {
+                result.skipped.push(relative(root, fullPath).replace(/\\/g, "/"));
+            }
+        }
+        // Remove empty date directories
+        if (!dryRun && readdirSync(datePath).length === 0) {
+            rmSync(datePath, { recursive: true });
+        }
+    }
+    return result;
+}

package/dist/util/secret-mask.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Mask sensitive tokens, credentials, and secrets in free-text output.
+ * Safe to apply to error messages, command output, diagnostic text, and URLs.
+ */
+export declare function maskSensitiveText(value: string): string;

package/dist/util/secret-mask.js

@@ -0,0 +1,41 @@
+/**
+ * Mask sensitive tokens, credentials, and secrets in free-text output.
+ * Safe to apply to error messages, command output, diagnostic text, and URLs.
+ */
+export function maskSensitiveText(value) {
+    if (typeof value !== "string")
+        return String(value ?? "");
+    return (value
+        // Bearer tokens
+        .replace(/(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1***")
+        // OpenAI keys
+        .replace(/\bsk-(?:proj|svcacct)-[A-Za-z0-9_-]{8,}\b/g, "sk-***")
+        .replace(/\bsk-[A-Za-z0-9_-]{20,}\b/g, "sk-***")
+        // GitHub PATs
+        .replace(/\bghp_[A-Za-z0-9]{36,}\b/g, "ghp_***")
+        .replace(/\bgithub_pat_[A-Za-z0-9]{22,}\b/g, "github_pat_***")
+        // GitLab PATs
+        .replace(/\bglpat-[A-Za-z0-9_-]{10,}\b/g, "glpat-***")
+        // JWT-like tokens (three base64url segments)
+        .replace(/\beyJ[A-Za-z0-9_-]*\.eyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]*\b/g, "***")
+        // OAuth / access / refresh / session / id tokens as key=value or key: value
+        .replace(/((?:oauth|access|refresh|session|id)[_-]?token\s*[:=]\s*)[^\s"';,]+/gi, "$1***")
+        // OMK session/run/goal identifiers
+        .replace(/\b(OMK_[A-Z_][A-Za-z0-9_]*)\s*[:=]\s*[^\s"';,]+/g, "$1=***")
+        // CLI flags like --api-key=...
+        .replace(/(--(?:api[-_]?key|api[-_]?token|token|key|secret|password|client[-_]?secret|x[-_]?auth[-_]?token)(?:=|\s+))[^"'`\s;]+/gi, "$1***")
+        // Env var assignments with secret-like names
+        .replace(/([A-Za-z_][A-Za-z0-9_]*(?:SECRET|TOKEN|KEY|PASSWORD|PASSWD|CREDENTIAL|AUTH|COOKIE|SESSION|PRIVATE|DSN|PAT|URI|JWT|BEARER|OAUTH)[A-Za-z0-9_]*\s*=\s*)[^"'`\s;]+/gi, "$1***")
+        // URL query parameters with secrets
+        .replace(/([?&](?:token|api[-_]?key|key|secret|password|auth|credential|session|bearer|access[-_]?token|refresh[-_]?token|client[-_]?secret|x[-_]?auth[-_]?token|signature|sig|jwt|private[-_]?key|pat|dsn)=)[^&#"'`\s]+/gi, "$1***")
+        // URL fragments after hash
+        .replace(/(https?:\/\/[^#\s"'`]+)#[^ \t\r\n"'`]+/gi, "$1#***")
+        // URL credentials user:pass@
+        .replace(/[A-Za-z0-9._%+-]+:[A-Za-z0-9._%+-]+@/g, "***@")
+        // Authorization / Proxy-Authorization headers
+        .replace(/\b(authorization|proxy-authorization)\s*([:=])\s*(?:Bearer\s+)?[^\s"',;]+/gi, "$1$2 Bearer ***")
+        // Cookie / Set-Cookie headers
+        .replace(/\b(cookie|set-cookie)\s*([:=])\s*[^"'\n]+/gi, "$1$2 ***")
+        // x-api-key, x-auth-token, and similar inline secrets
+        .replace(/((?:x-api-key|x-auth-token|api[_-]?key|api[_-]?token|access[_-]?token|refresh[_-]?token|token|secret|password|client[_-]?secret|private[-_]?key)\s*[:=]\s*)[^\s"',;]+/gi, "$1***"));
+}

package/dist/util/session.d.ts

@@ -0,0 +1,19 @@
+export declare function createOmkSessionId(prefix?: "chat" | "plan" | "run" | "team" | "session" | "feature" | "bugfix" | "refactor" | "review"): string;
+export declare function createOmkSessionEnv(projectRoot: string, sessionId: string): Record<string, string>;
+export interface SessionMeta {
+    runId: string;
+    type: "chat" | "plan" | "run" | "team" | "parallel";
+    status: "active" | "completed" | "failed" | "idle";
+    startedAt: string;
+    updatedAt: string;
+    endedAt?: string;
+    goalTitle?: string;
+    omkSessionId?: string;
+    kimiSessionId?: string;
+    todoCount: number;
+    todoDoneCount: number;
+}
+export declare function ensureSessionDir(runId: string): Promise<string>;
+export declare function writeSessionMeta(runId: string, meta: SessionMeta): Promise<void>;
+export declare function readSessionMeta(runId: string): Promise<SessionMeta | null>;
+export declare function listActiveSessions(): Promise<SessionMeta[]>;

package/dist/util/session.js

@@ -0,0 +1,81 @@
+import { writeFile, readdir, readFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { getOmkPath, pathExists, validateRunId } from "./fs.js";
+import { getRunArtifactPath } from "./run-store.js";
+export function createOmkSessionId(prefix = "session") {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    return `${prefix}-${timestamp}-${process.pid}`;
+}
+export function createOmkSessionEnv(projectRoot, sessionId) {
+    return {
+        OMK_PROJECT_ROOT: projectRoot,
+        OMK_SESSION_ID: sessionId,
+    };
+}
+export async function ensureSessionDir(runId) {
+    const sanitized = validateRunId(runId);
+    const dir = getRunArtifactPath(sanitized, ".");
+    await mkdir(dir, { recursive: true });
+    return dir;
+}
+export async function writeSessionMeta(runId, meta) {
+    const sanitized = validateRunId(runId);
+    const dir = await ensureSessionDir(sanitized);
+    const metaPath = join(dir, "session.json");
+    const payload = {
+        ...meta,
+        runId: sanitized,
+        updatedAt: new Date().toISOString(),
+    };
+    await writeFile(metaPath, JSON.stringify(payload, null, 2), "utf-8");
+}
+export async function readSessionMeta(runId) {
+    const sanitized = validateRunId(runId);
+    const metaPath = getRunArtifactPath(sanitized, "session.json");
+    if (!(await pathExists(metaPath)))
+        return null;
+    try {
+        const content = await readFile(metaPath, "utf-8");
+        const parsed = JSON.parse(content);
+        if (!isSessionMeta(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export async function listActiveSessions() {
+    const runsDir = getOmkPath("runs");
+    if (!(await pathExists(runsDir)))
+        return [];
+    const entries = await readdir(runsDir, { withFileTypes: true });
+    const results = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const meta = await readSessionMeta(entry.name).catch(() => null);
+        if (meta && meta.status === "active") {
+            results.push(meta);
+        }
+    }
+    return results.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+}
+function isSessionMeta(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const v = value;
+    return (typeof v.runId === "string" &&
+        typeof v.type === "string" &&
+        ["chat", "plan", "run", "team", "parallel"].includes(v.type) &&
+        typeof v.status === "string" &&
+        ["active", "completed", "failed", "idle"].includes(v.status) &&
+        typeof v.startedAt === "string" &&
+        typeof v.updatedAt === "string" &&
+        typeof v.todoCount === "number" &&
+        typeof v.todoDoneCount === "number" &&
+        (v.endedAt === undefined || typeof v.endedAt === "string") &&
+        (v.goalTitle === undefined || typeof v.goalTitle === "string") &&
+        (v.omkSessionId === undefined || typeof v.omkSessionId === "string") &&
+        (v.kimiSessionId === undefined || typeof v.kimiSessionId === "string"));
+}

package/dist/util/shell.d.ts

@@ -0,0 +1,30 @@
+export interface ShellResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    failed: boolean;
+}
+export interface StreamingShellOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeout?: number;
+    maxBuffer?: number;
+    stdio?: "pipe" | "inherit";
+    logPath?: string;
+    input?: string;
+    onStdout?: (line: string, io?: StreamingShellIo) => void;
+    onStderr?: (line: string, io?: StreamingShellIo) => void;
+    sudo?: boolean;
+    signal?: AbortSignal;
+    inheritEnv?: boolean;
+}
+export interface StreamingShellIo {
+    writeStdin(input: string): void;
+    terminate(reason?: string): void;
+}
+export declare function runShell(command: string, args?: string[], options?: StreamingShellOptions): Promise<ShellResult>;
+export declare function runShellStreaming(command: string, args?: string[], options?: StreamingShellOptions): Promise<ShellResult>;
+export declare function which(command: string): Promise<ShellResult>;
+export declare function checkCommand(command: string): Promise<boolean>;
+export declare function resolveKimiBin(env?: NodeJS.ProcessEnv | Record<string, string | undefined>): string;
+export declare function getKimiVersion(): Promise<string | null>;