@ericsanchezok/synergy-util 3.0.24 → 3.1.0

package/dist/terminal.js

@@ -0,0 +1,111 @@
+import z from "zod";
+import { EOL } from "os";
+import { NamedError } from "./error.js";
+export var UI;
+(function (UI) {
+    UI.CancelledError = NamedError.create("UICancelledError", z.void());
+    UI.Style = {
+        TEXT_HIGHLIGHT: "\x1b[96m",
+        TEXT_HIGHLIGHT_BOLD: "\x1b[96m\x1b[1m",
+        TEXT_DIM: "\x1b[90m",
+        TEXT_DIM_BOLD: "\x1b[90m\x1b[1m",
+        TEXT_NORMAL: "\x1b[0m",
+        TEXT_NORMAL_BOLD: "\x1b[1m",
+        TEXT_WARNING: "\x1b[93m",
+        TEXT_WARNING_BOLD: "\x1b[93m\x1b[1m",
+        TEXT_DANGER: "\x1b[91m",
+        TEXT_DANGER_BOLD: "\x1b[91m\x1b[1m",
+        TEXT_SUCCESS: "\x1b[92m",
+        TEXT_SUCCESS_BOLD: "\x1b[92m\x1b[1m",
+        TEXT_INFO: "\x1b[94m",
+        TEXT_INFO_BOLD: "\x1b[94m\x1b[1m",
+    };
+    function println(...message) {
+        print(...message);
+        Bun.stderr.write(EOL);
+    }
+    UI.println = println;
+    function print(...message) {
+        blank = false;
+        Bun.stderr.write(message.join(" "));
+    }
+    UI.print = print;
+    let blank = false;
+    function empty() {
+        if (blank)
+            return;
+        println("" + UI.Style.TEXT_NORMAL);
+        blank = true;
+    }
+    UI.empty = empty;
+    async function input(prompt) {
+        const readline = require("readline");
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve) => {
+            rl.question(prompt, (answer) => {
+                rl.close();
+                resolve(answer.trim());
+            });
+        });
+    }
+    UI.input = input;
+    function error(message) {
+        println(UI.Style.TEXT_DANGER_BOLD + "Error: " + UI.Style.TEXT_NORMAL + message);
+    }
+    UI.error = error;
+    function markdown(text) {
+        return text;
+    }
+    UI.markdown = markdown;
+    function progressBar(opts) {
+        const width = opts.width ?? 24;
+        const ratio = Math.max(0, Math.min(1, Number.isFinite(opts.ratio) ? opts.ratio : 0));
+        const filled = Math.round(ratio * width);
+        const empty = Math.max(0, width - filled);
+        const filledChar = opts.filledChar ?? "■";
+        const emptyChar = opts.emptyChar ?? "·";
+        const filledStyle = opts.filledStyle ?? UI.Style.TEXT_INFO_BOLD;
+        const emptyStyle = opts.emptyStyle ?? UI.Style.TEXT_DIM;
+        const body = filledStyle + filledChar.repeat(filled) + emptyStyle + emptyChar.repeat(empty) + UI.Style.TEXT_NORMAL;
+        if (opts.brackets === false)
+            return body;
+        return UI.Style.TEXT_DIM + "[" + UI.Style.TEXT_NORMAL + body + UI.Style.TEXT_DIM + "]" + UI.Style.TEXT_NORMAL;
+    }
+    UI.progressBar = progressBar;
+    function card(opts) {
+        const DIM = UI.Style.TEXT_DIM;
+        const RESET = UI.Style.TEXT_NORMAL;
+        const ts = opts.titleStyle ?? UI.Style.TEXT_HIGHLIGHT_BOLD;
+        const labelCol = 3 + Math.max(...opts.rows.map((r) => r.label.length)) + 2;
+        const widths = [opts.minWidth ?? 0, 1 + opts.title.length, ...opts.rows.map((r) => labelCol + r.value.length)];
+        if (opts.description)
+            widths.push(1 + opts.description.length);
+        if (opts.footer)
+            widths.push(1 + opts.footer.length);
+        const w = Math.max(...widths);
+        const fill = (n) => " ".repeat(Math.max(0, n));
+        const blank = DIM + "│" + fill(w) + "│";
+        const lines = [];
+        lines.push(DIM + "┌" + "─".repeat(w) + "┐");
+        lines.push(DIM + "│" + ts + " " + opts.title + fill(w - 1 - opts.title.length) + DIM + "│");
+        if (opts.description) {
+            lines.push(DIM + "│" + RESET + " " + opts.description + fill(w - 1 - opts.description.length) + DIM + "│");
+        }
+        lines.push(blank);
+        for (const r of opts.rows) {
+            const vs = r.valueStyle ?? RESET;
+            const gap = fill(labelCol - 3 - r.label.length);
+            lines.push(DIM + "│" + RESET + "   " + r.label + gap + vs + r.value + fill(w - labelCol - r.value.length) + DIM + "│");
+        }
+        lines.push(blank);
+        if (opts.footer) {
+            lines.push(DIM + "│" + RESET + " " + opts.footer + fill(w - 1 - opts.footer.length) + DIM + "│");
+        }
+        lines.push(DIM + "└" + "─".repeat(w) + "┘" + RESET);
+        return lines.join("\n");
+    }
+    UI.card = card;
+})(UI || (UI = {}));

package/dist/tool-display.d.ts

@@ -1,3 +1,11 @@
+export interface ToolIconSource {
+    src: string;
+    mimeType?: string;
+    sizes?: string[];
+    theme?: "light" | "dark";
+}
+export declare const MAX_TOOL_ICON_BYTES: number;
+export declare function toolIconSources(value: unknown): ToolIconSource[];
 export interface ToolMediaDisplay {
     type: "image" | "video" | "audio";
     actionLabel?: string;
@@ -7,6 +15,8 @@ export interface ToolMediaDisplay {
     size?: "small" | "medium" | "large";
 }
 export interface ToolDisplay {
+    /** A registered host/plugin glyph or bounded image data from the tool owner. */
+    icon?: string | ToolIconSource[];
     kind?: "default" | "media-generation";
     toolCard?: "visible" | "hidden";
     media?: ToolMediaDisplay;

package/dist/tool-display.js

@@ -1 +1,22 @@
-export {};
+export const MAX_TOOL_ICON_BYTES = 64 * 1024;
+export function toolIconSources(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.slice(0, 3).flatMap((item) => {
+        if (!item || typeof item !== "object" || typeof item.src !== "string")
+            return [];
+        if (item.src.length > Math.ceil(MAX_TOOL_ICON_BYTES / 3) * 4 + 64)
+            return [];
+        if (!/^data:image\/(?:png|jpeg|webp|svg\+xml);base64,[A-Za-z0-9+/]+={0,2}$/.test(item.src))
+            return [];
+        if (item.theme !== undefined && item.theme !== "light" && item.theme !== "dark")
+            return [];
+        return [
+            {
+                src: item.src,
+                ...(typeof item.mimeType === "string" ? { mimeType: item.mimeType } : {}),
+                ...(item.theme ? { theme: item.theme } : {}),
+            },
+        ];
+    });
+}

package/dist/tool-timeout.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The single definition of the tool-timeout contract shared by the runtime
+ * (which produces it on tool parts) and the shared UI (which renders it).
+ *
+ * It lives in `util` because that is the only workspace package both
+ * `harness` and `ui` already depend on; UI may not import runtime-private
+ * modules, and exposing this through the plugin API would turn an internal
+ * diagnostic bag into a versioned public contract.
+ *
+ * Field names and units are deliberately unchanged (`*Ms`): the metadata is
+ * persisted on tool parts, so renaming would strand the timeout information on
+ * every historical part. Seconds are the unit at the human- and agent-facing
+ * boundary only; the conversion happens there, not here.
+ */
+export type ToolTimeoutSource = "tool_timeout" | "search" | "fetch" | "download" | "wait" | "auto_background" | "question" | "vision" | "document_extract";
+export interface ToolTimeoutMetadata {
+    toolTimeoutMs: number;
+    operationTimeoutMs?: number;
+    displayMs: number;
+    source: ToolTimeoutSource;
+}

package/dist/tool-timeout.js

@@ -0,0 +1 @@
+export {};

package/dist/tool.d.ts

@@ -1,3 +1,4 @@
+import type { AttachmentPresentation } from "./attachment-presentation";
 import { z } from "zod";
 import type { ToolDisplay } from "./tool-display.js";
 import type { BunShell } from "./shell.js";
@@ -85,12 +86,7 @@ export type PluginToolAttachment = {
     filename?: string;
     url: string;
     localPath?: string;
-    presentation?: {
-        hidden?: boolean;
-        renderer?: "image" | "video" | "audio" | "thumbnail" | "file";
-        size?: "original" | "small" | "medium" | "large";
-        crop?: boolean;
-    };
+    presentation?: AttachmentPresentation;
     model?: {
         mode: "summary";
         summary?: string;
@@ -119,6 +115,7 @@ export type ToolExposure = {
     group: string;
     title?: string;
     description?: string;
+    /** @deprecated Put selection guidance in description; retained for Plugin API4 source compatibility. */
     whenToExpand?: string;
 } | {
     mode: "search";
@@ -131,16 +128,18 @@ export declare function tool<Args extends z.ZodRawShape>(input: {
     description: string;
     exposure?: ToolExposure;
     display?: ToolDisplay;
+    requiresWorkspace?: boolean;
     args: Args;
     execute(args: z.infer<z.ZodObject<Args>>, context: ToolContext): Promise<string | ToolResult>;
 }): {
     description: string;
     exposure?: ToolExposure;
     display?: ToolDisplay;
+    requiresWorkspace?: boolean;
     args: Args;
     execute(args: z.infer<z.ZodObject<Args>>, context: ToolContext): Promise<string | ToolResult>;
 };
 export declare namespace tool {
-    var schema: typeof z;
+    export { z as schema };
 }
 export type ToolDefinition = ReturnType<typeof tool>;