open-multi-agent-kit 0.80.2 → 0.80.3

package/dist/util/checkpoint.js

@@ -1,238 +0,0 @@
-import { mkdir, writeFile, readFile, readdir } from "fs/promises";
-import { isAbsolute, join, normalize } from "path";
-import { runShell } from "./shell.js";
-import { redactSecrets } from "../orchestration/state-persister.js";
-import { getProjectRoot, pathExists, readTextFile } from "./fs.js";
-import { validateRunId } from "./run-store.js";
-const CHECKPOINTS_DIR = ".omk/checkpoints";
-const PROTECTED_CHECKPOINT_PATH_MARKERS = [
-    ".env",
-    ".pem",
-    ".key",
-    "id_rsa",
-    "id_ed25519",
-    "credentials.json",
-    "service-account",
-    ".p12",
-    ".pfx",
-    ".keystore",
-];
-function sanitizeLabel(label) {
-    return label.replace(/[^a-zA-Z0-9_-]/g, "_").substring(0, 64);
-}
-function getCheckpointsBasePath() {
-    return join(getProjectRoot(), CHECKPOINTS_DIR);
-}
-function getCheckpointPath(runId, checkpointId) {
-    return join(getCheckpointsBasePath(), validateRunId(runId), sanitizeLabel(checkpointId));
-}
-function getRunPath(runId) {
-    return join(getProjectRoot(), ".omk", "runs", validateRunId(runId));
-}
-function sanitizeJsonText(content) {
-    try {
-        return JSON.stringify(redactSecrets(JSON.parse(content)), null, 2);
-    }
-    catch {
-        return String(redactSecrets(content));
-    }
-}
-function normalizePatchPath(pathValue) {
-    return normalize(pathValue.replace(/^"?[ab]\//, "").replace(/"?$/, ""));
-}
-function protectedPatchPathReason(pathValue) {
-    const normalized = normalizePatchPath(pathValue);
-    if (!normalized || normalized === "/dev/null")
-        return null;
-    if (isAbsolute(normalized) || normalized.startsWith(".."))
-        return `unsafe checkpoint path: ${pathValue}`;
-    const lower = normalized.toLowerCase();
-    const base = lower.split(/[\\/]/).pop() ?? lower;
-    if (PROTECTED_CHECKPOINT_PATH_MARKERS.some((marker) => lower.includes(marker) || base === marker)) {
-        return `protected checkpoint path: ${pathValue}`;
-    }
-    return null;
-}
-function validateCheckpointPatchPaths(patchContent) {
-    for (const line of patchContent.split(/\r?\n/)) {
-        let candidate = null;
-        if (line.startsWith("diff --git ")) {
-            const parts = line.split(/\s+/);
-            candidate = parts[2] ?? parts[3] ?? null;
-        }
-        else if (line.startsWith("+++ ") || line.startsWith("--- ")) {
-            candidate = line.slice(4).trim();
-        }
-        if (!candidate || candidate === "/dev/null")
-            continue;
-        const reason = protectedPatchPathReason(candidate);
-        if (reason)
-            return reason;
-    }
-    return null;
-}
-export async function saveCheckpoint(runId, label, metadata) {
-    const timestamp = new Date().toISOString().replace(/:/g, "-");
-    const checkpointId = `${sanitizeLabel(label)}-${timestamp}`;
-    const cpPath = getCheckpointPath(runId, checkpointId);
-    await mkdir(cpPath, { recursive: true });
-    const meta = redactSecrets({
-        timestamp: new Date().toISOString(),
-        label,
-        runId,
-        ...(metadata ?? {}),
-    });
-    await writeFile(join(cpPath, "metadata.json"), JSON.stringify(meta, null, 2), "utf-8");
-    const projectRoot = getProjectRoot();
-    const gitDiffResult = await runShell("git", ["diff", "HEAD"], { cwd: projectRoot, timeout: 10000 });
-    const patchContent = !gitDiffResult.failed ? gitDiffResult.stdout : "";
-    await writeFile(join(cpPath, "git-patch.diff"), patchContent, "utf-8");
-    const runDir = getRunPath(runId);
-    const todosPath = join(runDir, "todos.json");
-    if (await pathExists(todosPath)) {
-        const todosContent = await readFile(todosPath, "utf-8");
-        await writeFile(join(cpPath, "todos.json"), sanitizeJsonText(todosContent), "utf-8");
-    }
-    const statePath = join(runDir, "state.json");
-    if (await pathExists(statePath)) {
-        const stateContent = await readFile(statePath, "utf-8");
-        await writeFile(join(cpPath, "state.json"), sanitizeJsonText(stateContent), "utf-8");
-    }
-    return { checkpointId, path: cpPath };
-}
-export async function listCheckpoints(runId) {
-    const basePath = getCheckpointsBasePath();
-    if (!(await pathExists(basePath)))
-        return [];
-    const results = [];
-    const runDirs = await readdir(basePath, { withFileTypes: true });
-    for (const runDir of runDirs) {
-        if (!runDir.isDirectory())
-            continue;
-        const currentRunId = runDir.name;
-        if (runId && currentRunId !== runId)
-            continue;
-        const runPath = join(basePath, currentRunId);
-        const cpDirs = await readdir(runPath, { withFileTypes: true });
-        for (const cpDir of cpDirs) {
-            if (!cpDir.isDirectory())
-                continue;
-            const checkpointId = cpDir.name;
-            const metaPath = join(runPath, checkpointId, "metadata.json");
-            if (!(await pathExists(metaPath)))
-                continue;
-            try {
-                const metaContent = await readFile(metaPath, "utf-8");
-                const meta = JSON.parse(metaContent);
-                results.push({
-                    checkpointId,
-                    runId: currentRunId,
-                    label: meta.label ?? checkpointId,
-                    createdAt: meta.timestamp ?? "",
-                });
-            }
-            catch {
-                // skip malformed metadata
-            }
-        }
-    }
-    return results.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-}
-export async function restoreCheckpoint(checkpointId, runId, options = {}) {
-    const cpPath = getCheckpointPath(runId, checkpointId);
-    const projectRoot = getProjectRoot();
-    const restoredFiles = [];
-    if (!(await pathExists(cpPath))) {
-        return { success: false, restoredFiles, message: `Checkpoint not found: ${cpPath}` };
-    }
-    const patchPath = join(cpPath, "git-patch.diff");
-    const patchContent = await readTextFile(patchPath, "");
-    if (patchContent.trim().length > 0) {
-        const unsafePatchPath = validateCheckpointPatchPaths(patchContent);
-        if (unsafePatchPath) {
-            return {
-                success: false,
-                restoredFiles,
-                message: `Checkpoint restore refused: ${unsafePatchPath}`,
-            };
-        }
-        const dirtyCheck = await runShell("git", ["status", "--porcelain", "--untracked-files=normal"], {
-            cwd: projectRoot,
-            timeout: 10000,
-        });
-        if (!options.force && !dirtyCheck.failed && dirtyCheck.stdout.trim().length > 0) {
-            return {
-                success: false,
-                restoredFiles,
-                message: "Checkpoint restore refused: dirty worktree. Re-run with force after reviewing local changes.",
-            };
-        }
-        const gitApplyCheck = await runShell("git", ["apply", "--check", patchPath], {
-            cwd: projectRoot,
-            timeout: 10000,
-        });
-        if (!gitApplyCheck.failed) {
-            const gitApply = await runShell("git", ["apply", patchPath], {
-                cwd: projectRoot,
-                timeout: 10000,
-            });
-            if (gitApply.failed) {
-                return {
-                    success: false,
-                    restoredFiles,
-                    message: `Git apply failed: ${gitApply.stderr}`,
-                };
-            }
-            restoredFiles.push("git-patch.diff (applied)");
-        }
-        else {
-            const patchCheck = await runShell("patch", ["-p1", "--dry-run", "-i", patchPath], {
-                cwd: projectRoot,
-                timeout: 10000,
-            });
-            if (!patchCheck.failed) {
-                const patchApply = await runShell("patch", ["-p1", "-i", patchPath], {
-                    cwd: projectRoot,
-                    timeout: 10000,
-                });
-                if (patchApply.failed) {
-                    return {
-                        success: false,
-                        restoredFiles,
-                        message: `patch command failed: ${patchApply.stderr}`,
-                    };
-                }
-                restoredFiles.push("git-patch.diff (applied via patch)");
-            }
-            else {
-                return {
-                    success: false,
-                    restoredFiles,
-                    message: `Patch cannot be applied: ${gitApplyCheck.stderr || patchCheck.stderr}`,
-                };
-            }
-        }
-    }
-    const runDir = getRunPath(runId);
-    const todosCpPath = join(cpPath, "todos.json");
-    if (await pathExists(todosCpPath)) {
-        const todosContent = await readFile(todosCpPath, "utf-8");
-        const todosRunPath = join(runDir, "todos.json");
-        await mkdir(runDir, { recursive: true });
-        await writeFile(todosRunPath, sanitizeJsonText(todosContent), "utf-8");
-        restoredFiles.push("todos.json");
-    }
-    const stateCpPath = join(cpPath, "state.json");
-    if (await pathExists(stateCpPath)) {
-        const stateContent = await readFile(stateCpPath, "utf-8");
-        const stateRunPath = join(runDir, "state.json");
-        await mkdir(runDir, { recursive: true });
-        await writeFile(stateRunPath, sanitizeJsonText(stateContent), "utf-8");
-        restoredFiles.push("state.json");
-    }
-    return {
-        success: true,
-        restoredFiles,
-        message: `Restored ${restoredFiles.length} items from checkpoint ${checkpointId}`,
-    };
-}

package/dist/util/cli-contract.d.ts

@@ -1,46 +0,0 @@
-/**
- * CLI Contract helpers — enforce JSON-mode stdout purity and typed command results.
- *
- * Rules:
- * - --json → stdout is exactly one JSON document, no banners/ANSI/human text.
- * - Human diagnostics go to stderr only.
- * - Command functions must NOT call process.exit; they throw CliError or return CommandResult.
- * - Only src/cli.ts adapters set process.exitCode.
- */
-export interface CommandResult<T = void> {
-    ok: boolean;
-    exitCode: number;
-    data?: T;
-    diagnostics?: string[];
-}
-export declare class CliError extends Error {
-    readonly exitCode: number;
-    readonly diagnostics?: string[] | undefined;
-    constructor(message: string, exitCode?: number, diagnostics?: string[] | undefined);
-}
-export declare class UsageError extends CliError {
-    constructor(message: string, diagnostics?: string[]);
-}
-export declare class NotFoundError extends CliError {
-    constructor(message: string, diagnostics?: string[]);
-}
-export declare class VerificationError extends CliError {
-    constructor(message: string, diagnostics?: string[]);
-}
-export declare class InterruptedError extends CliError {
-    constructor(message?: string);
-}
-/** Emit a single JSON document to stdout. */
-export declare function emitJson(data: unknown): void;
-/** Emit error: JSON to stdout (in JSON mode), human text to stderr (always). */
-export declare function emitError(message: string, json: boolean, jsonPayload?: Record<string, unknown>): void;
-/** Build a successful CommandResult. */
-export declare function successResult<T>(data?: T): CommandResult<T>;
-/** Build a failed CommandResult. */
-export declare function failureResult(exitCode: number, diagnostics?: string[]): CommandResult;
-/** Adapter: convert a CommandResult to CLI exit code. Does NOT call process.exit. */
-export declare function applyExitCode(result: CommandResult): void;
-/** Returns true when stdout should be JSON-only (no ANSI, no human text). */
-export declare function isJsonMode(options: {
-    json?: boolean;
-}): boolean;

package/dist/util/cli-contract.js

@@ -1,72 +0,0 @@
-/**
- * CLI Contract helpers — enforce JSON-mode stdout purity and typed command results.
- *
- * Rules:
- * - --json → stdout is exactly one JSON document, no banners/ANSI/human text.
- * - Human diagnostics go to stderr only.
- * - Command functions must NOT call process.exit; they throw CliError or return CommandResult.
- * - Only src/cli.ts adapters set process.exitCode.
- */
-export class CliError extends Error {
-    exitCode;
-    diagnostics;
-    constructor(message, exitCode = 1, diagnostics) {
-        super(message);
-        this.exitCode = exitCode;
-        this.diagnostics = diagnostics;
-        this.name = "CliError";
-    }
-}
-export class UsageError extends CliError {
-    constructor(message, diagnostics) {
-        super(message, 1, diagnostics);
-        this.name = "UsageError";
-    }
-}
-export class NotFoundError extends CliError {
-    constructor(message, diagnostics) {
-        super(message, 1, diagnostics);
-        this.name = "NotFoundError";
-    }
-}
-export class VerificationError extends CliError {
-    constructor(message, diagnostics) {
-        super(message, 1, diagnostics);
-        this.name = "VerificationError";
-    }
-}
-export class InterruptedError extends CliError {
-    constructor(message = "Interrupted") {
-        super(message, 130);
-        this.name = "InterruptedError";
-    }
-}
-/** Emit a single JSON document to stdout. */
-export function emitJson(data) {
-    console.log(JSON.stringify(data, null, 2));
-}
-/** Emit error: JSON to stdout (in JSON mode), human text to stderr (always). */
-export function emitError(message, json, jsonPayload) {
-    if (json) {
-        console.log(JSON.stringify({ error: message, ...jsonPayload }, null, 2));
-    }
-    console.error(message);
-}
-/** Build a successful CommandResult. */
-export function successResult(data) {
-    return { ok: true, exitCode: 0, data };
-}
-/** Build a failed CommandResult. */
-export function failureResult(exitCode, diagnostics) {
-    return { ok: false, exitCode, diagnostics };
-}
-/** Adapter: convert a CommandResult to CLI exit code. Does NOT call process.exit. */
-export function applyExitCode(result) {
-    if (!result.ok && process.exitCode === undefined) {
-        process.exitCode = result.exitCode;
-    }
-}
-/** Returns true when stdout should be JSON-only (no ANSI, no human text). */
-export function isJsonMode(options) {
-    return Boolean(options.json);
-}

package/dist/util/clipboard-image.d.ts

@@ -1,49 +0,0 @@
-/**
- * Cross-platform clipboard image reader.
- *
- * Wraps the platform-specific clipboard reading from screenshot-store patterns
- * into a reusable utility for the chat REPL, goal commands, and any input
- * surface that needs Ctrl+V / paste image support.
- *
- * Platforms:
- * - macOS: `pngpaste -` (brew) or `osascript` with TIFF→PNG conversion
- * - Linux: `xclip -selection clipboard -target image/png`
- * - Windows: PowerShell System.Windows.Forms.Clipboard
- *
- * Output: PNG Buffer + saved file path under .omk/screenshots/
- */
-export declare const SCREENSHOT_DIR = ".omk/screenshots";
-export declare const MAX_IMAGE_BYTES: number;
-export interface ClipboardImage {
-    ok: boolean;
-    /** Absolute path to the saved PNG/JPG/WebP/GIF file. */
-    path?: string;
-    /** Project-relative path (e.g. .omk/screenshots/2026-06-08/screenshot-....png). */
-    relativePath?: string;
-    /** Base64 data URI suitable for wire protocol image_url. */
-    dataUri?: string;
-    /** Base64 raw (no prefix). */
-    base64?: string;
-    /** Detected extension: png, jpg, webp, gif. */
-    ext?: string;
-    /** Error message when ok=false. */
-    error?: string;
-}
-export declare function detectImageExt(buf: Buffer): string | null;
-export declare function toDataUri(base64: string, ext: string): string;
-/**
- * Read an image from the system clipboard. Returns null if clipboard is empty
- * or contains no image. Platform-specific: macOS (pngpaste/osascript), Linux
- * (xclip/wl-paste), Windows (PowerShell).
- */
-export declare function readClipboardImage(platform?: NodeJS.Platform): Buffer | null;
-/**
- * Read clipboard image, validate, save to .omk/screenshots/, and return
- * both the file path and base64 data URI for wire protocol use.
- */
-export declare function pasteClipboardImage(projectRoot: string): ClipboardImage;
-/**
- * Read an image file from disk, validate, and return base64 data URI.
- * Used for --image <file> flag support.
- */
-export declare function readImageFile(filePath: string): ClipboardImage;

package/dist/util/clipboard-image.js

@@ -1,263 +0,0 @@
-/**
- * Cross-platform clipboard image reader.
- *
- * Wraps the platform-specific clipboard reading from screenshot-store patterns
- * into a reusable utility for the chat REPL, goal commands, and any input
- * surface that needs Ctrl+V / paste image support.
- *
- * Platforms:
- * - macOS: `pngpaste -` (brew) or `osascript` with TIFF→PNG conversion
- * - Linux: `xclip -selection clipboard -target image/png`
- * - Windows: PowerShell System.Windows.Forms.Clipboard
- *
- * Output: PNG Buffer + saved file path under .omk/screenshots/
- */
-import { execFileSync } from "node:child_process";
-import { mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync } from "node:fs";
-import { createHash } from "node:crypto";
-import { join, relative } from "node:path";
-export const SCREENSHOT_DIR = ".omk/screenshots";
-export const MAX_IMAGE_BYTES = 20 * 1024 * 1024;
-const CLIPBOARD_TIMEOUT_MS = 5000;
-const CLIPBOARD_MAX_BUFFER = MAX_IMAGE_BYTES * 2;
-const IMAGE_MAGIC = [
-    ["png", [0x89, 0x50, 0x4e, 0x47]],
-    ["jpg", [0xff, 0xd8, 0xff]],
-    ["webp", [0x52, 0x49, 0x46, 0x46]],
-    ["gif", [0x47, 0x49, 0x46, 0x38]],
-];
-export function detectImageExt(buf) {
-    for (const [ext, magic] of IMAGE_MAGIC) {
-        if (buf.length >= magic.length && magic.every((b, i) => buf[i] === b)) {
-            return ext;
-        }
-    }
-    return null;
-}
-function mimeTypeForExt(ext) {
-    switch (ext) {
-        case "png": return "image/png";
-        case "jpg": return "image/jpeg";
-        case "webp": return "image/webp";
-        case "gif": return "image/gif";
-        default: return "application/octet-stream";
-    }
-}
-export function toDataUri(base64, ext) {
-    return `data:${mimeTypeForExt(ext)};base64,${base64}`;
-}
-function generatePath(projectRoot, ext) {
-    const dateDir = new Date().toISOString().slice(0, 10);
-    const timestamp = new Date().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 };
-}
-// ── Platform readers ────────────────────────────────────────────────────────
-function readMacClipboard() {
-    // Try pngpaste first (faster, more reliable)
-    try {
-        const out = execFileSync("pngpaste", ["-"], {
-            timeout: CLIPBOARD_TIMEOUT_MS,
-            maxBuffer: CLIPBOARD_MAX_BUFFER,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        if (out.length > 0)
-            return out;
-    }
-    catch {
-        // pngpaste not installed or clipboard empty
-    }
-    // Fallback: osascript (handles TIFF → PNG conversion)
-    try {
-        const script = `
-      set theFile to (POSIX path of (path to temporary items) & "omk-clip-" & (random number from 100000 to 999999) & ".png")
-      set img to the clipboard as «class PNGf»
-      set fRef to open for access POSIX file theFile with write permission
-      write img to fRef
-      close access fRef
-      return theFile
-    `;
-        const filePath = execFileSync("osascript", ["-e", script], {
-            timeout: CLIPBOARD_TIMEOUT_MS,
-            encoding: "utf-8",
-        }).trim();
-        if (filePath) {
-            const buf = readFileSync(filePath);
-            try {
-                unlinkSync(filePath);
-            }
-            catch { /* ignore */ }
-            if (buf.length > 0)
-                return buf;
-        }
-    }
-    catch {
-        // osascript failed
-    }
-    return null;
-}
-function readLinuxClipboard() {
-    try {
-        const out = execFileSync("xclip", ["-selection", "clipboard", "-target", "image/png", "-o"], {
-            timeout: CLIPBOARD_TIMEOUT_MS,
-            maxBuffer: CLIPBOARD_MAX_BUFFER,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        if (out.length > 0)
-            return out;
-    }
-    catch {
-        // xclip not available
-    }
-    // Fallback: wl-paste (Wayland)
-    try {
-        const out = execFileSync("wl-paste", ["--type", "image/png"], {
-            timeout: CLIPBOARD_TIMEOUT_MS,
-            maxBuffer: CLIPBOARD_MAX_BUFFER,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        if (out.length > 0)
-            return out;
-    }
-    catch {
-        // wl-paste not available
-    }
-    return null;
-}
-function readWindowsClipboard() {
-    const script = `
-$ErrorActionPreference = 'SilentlyContinue'
-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]::OpenStandardOutput().Write($Bytes, 0, $Bytes.Length)
-  exit 0
-}
-
-# Try PNG format first
-$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 }
-    }
-  }
-  # File drop (screenshot tool saves to file then copies path)
-  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))
-      }
-    }
-  }
-}
-
-# Fallback: GetImage
-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
-`;
-    try {
-        const out = execFileSync("powershell.exe", ["-NoProfile", "-Command", "-"], {
-            input: script,
-            timeout: CLIPBOARD_TIMEOUT_MS,
-            maxBuffer: CLIPBOARD_MAX_BUFFER,
-            windowsHide: true,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        if (out.length > 0)
-            return out;
-    }
-    catch {
-        // PowerShell failed
-    }
-    return null;
-}
-/**
- * Read an image from the system clipboard. Returns null if clipboard is empty
- * or contains no image. Platform-specific: macOS (pngpaste/osascript), Linux
- * (xclip/wl-paste), Windows (PowerShell).
- */
-export function readClipboardImage(platform = process.platform) {
-    switch (platform) {
-        case "darwin": return readMacClipboard();
-        case "linux": return readLinuxClipboard();
-        case "win32": return readWindowsClipboard();
-        default: return null;
-    }
-}
-// ── High-level API ──────────────────────────────────────────────────────────
-/**
- * Read clipboard image, validate, save to .omk/screenshots/, and return
- * both the file path and base64 data URI for wire protocol use.
- */
-export function pasteClipboardImage(projectRoot) {
-    const buf = readClipboardImage();
-    if (!buf || buf.length === 0) {
-        return { ok: false, error: "No image found in clipboard" };
-    }
-    if (buf.length > MAX_IMAGE_BYTES) {
-        return { ok: false, error: `Clipboard image exceeds ${MAX_IMAGE_BYTES / (1024 * 1024)} MB` };
-    }
-    const ext = detectImageExt(buf);
-    if (!ext) {
-        return { ok: false, error: "Clipboard content is not a recognized image format (PNG/JPG/WebP/GIF)" };
-    }
-    const { fullPath, relativePath } = generatePath(projectRoot, ext);
-    writeFileSync(fullPath, buf);
-    const base64 = buf.toString("base64");
-    return {
-        ok: true,
-        path: fullPath,
-        relativePath: `./${relativePath}`,
-        dataUri: toDataUri(base64, ext),
-        base64,
-        ext,
-    };
-}
-/**
- * Read an image file from disk, validate, and return base64 data URI.
- * Used for --image <file> flag support.
- */
-export function readImageFile(filePath) {
-    if (!existsSync(filePath)) {
-        return { ok: false, error: `File not found: ${filePath}` };
-    }
-    const buf = readFileSync(filePath);
-    if (buf.length > MAX_IMAGE_BYTES) {
-        return { ok: false, error: `File exceeds ${MAX_IMAGE_BYTES / (1024 * 1024)} MB` };
-    }
-    const ext = detectImageExt(buf);
-    if (!ext) {
-        return { ok: false, error: "File is not a recognized image format (PNG/JPG/WebP/GIF)" };
-    }
-    const base64 = buf.toString("base64");
-    return {
-        ok: true,
-        path: filePath,
-        dataUri: toDataUri(base64, ext),
-        base64,
-        ext,
-    };
-}

package/dist/util/command-envelope.d.ts

@@ -1,19 +0,0 @@
-import type { OmkCommandDiagnostic, OmkCommandEnvelope, OmkCommandEnvelopeStatus } from "../contracts/command.js";
-import type { EvidenceRef } from "../contracts/evidence.js";
-export type CreateOmkCommandEnvelopeOptions<TData> = {
-    command: string;
-    status: OmkCommandEnvelopeStatus;
-    data: TData;
-    diagnostics?: OmkCommandDiagnostic[];
-    evidenceRefs?: EvidenceRef[];
-    exitCode?: number;
-    runId?: string;
-    commit?: string;
-    startedAt?: string;
-    finishedAt?: string;
-};
-export declare function createOmkCommandEnvelope<TData>(options: CreateOmkCommandEnvelopeOptions<TData>): OmkCommandEnvelope<TData>;
-export declare function commandDiagnostic(severity: OmkCommandDiagnostic["severity"], code: string, message: string, options?: Partial<Omit<OmkCommandDiagnostic, "severity" | "code" | "message" | "redacted">> & {
-    redacted?: boolean;
-}): OmkCommandDiagnostic;
-export declare function createCommandRunId(prefix?: string): string;