@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/features/advanced-capabilities/clipboard/actions/delete.js

@@ -0,0 +1,136 @@
+import { logger, ModelType, parseKeyValueXml, } from "../../../../types/index.js";
+import { createClipboardService } from "../services/clipboardService.js";
+import { requireActionSpec } from "../specs.js";
+function isValidDeleteInput(obj) {
+    return typeof obj.id === "string" && obj.id.length > 0;
+}
+const EXTRACT_TEMPLATE = `Extract the clipboard entry ID to delete from the user's message.
+
+User message: {{text}}
+
+Available clipboard entries:
+{{entries}}
+
+Respond with XML containing:
+- id: The ID of the clipboard entry to delete (required)
+
+<response>
+<id>entry-id</id>
+</response>`;
+async function extractDeleteInfo(runtime, message, availableEntries) {
+    const prompt = EXTRACT_TEMPLATE.replace("{{text}}", message.content.text ?? "").replace("{{entries}}", availableEntries);
+    const result = await runtime.useModel(ModelType.TEXT_SMALL, {
+        prompt,
+        stopSequences: [],
+    });
+    logger.debug("[ClipboardDelete] Extract result:", result);
+    const parsed = parseKeyValueXml(String(result));
+    if (!parsed || !isValidDeleteInput(parsed)) {
+        logger.error("[ClipboardDelete] Failed to extract valid delete info");
+        return null;
+    }
+    return {
+        id: String(parsed.id),
+    };
+}
+const spec = requireActionSpec("CLIPBOARD_DELETE");
+export const clipboardDeleteAction = {
+    name: spec.name,
+    similes: spec.similes ? [...spec.similes] : [],
+    description: spec.description,
+    validate: async (runtime, message, state, options) => {
+        const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+        const __avText = __avTextRaw.toLowerCase();
+        const __avKeywords = ["clipboard", "delete"];
+        const __avKeywordOk = __avKeywords.length > 0 &&
+            __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
+        const __avRegex = /\b(?:clipboard|delete)\b/i;
+        const __avRegexOk = __avRegex.test(__avText);
+        const __avSource = String(message?.content?.source ?? "");
+        const __avExpectedSource = "";
+        const __avSourceOk = __avExpectedSource
+            ? __avSource === __avExpectedSource
+            : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
+        const __avOptions = options && typeof options === "object" ? options : {};
+        const __avInputOk = __avText.trim().length > 0 ||
+            Object.keys(__avOptions).length > 0 ||
+            Boolean(message?.content && typeof message.content === "object");
+        if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+            return false;
+        }
+        const __avLegacyValidate = async (_runtime, _message) => {
+            return true;
+        };
+        try {
+            return Boolean(await __avLegacyValidate(runtime, message));
+        }
+        catch {
+            return false;
+        }
+    },
+    handler: async (runtime, message, _stateFromTrigger, _options, callback, _responses) => {
+        const service = createClipboardService(runtime);
+        // Get list of available entries for context
+        const entries = await service.list();
+        const entriesContext = entries
+            .map((e) => `- ${e.id}: "${e.title}"`)
+            .join("\n");
+        if (entries.length === 0) {
+            if (callback) {
+                await callback({
+                    text: "There are no clipboard entries to delete.",
+                    actions: ["CLIPBOARD_DELETE_EMPTY"],
+                    source: message.content.source,
+                });
+            }
+            return { success: false, text: "No entries available" };
+        }
+        const deleteInfo = await extractDeleteInfo(runtime, message, entriesContext);
+        if (!deleteInfo) {
+            if (callback) {
+                await callback({
+                    text: `I couldn't determine which note to delete. Available entries:\n${entriesContext}`,
+                    actions: ["CLIPBOARD_DELETE_FAILED"],
+                    source: message.content.source,
+                });
+            }
+            return { success: false, text: "Failed to extract delete info" };
+        }
+        try {
+            const deleted = await service.delete(deleteInfo.id);
+            if (!deleted) {
+                if (callback) {
+                    await callback({
+                        text: `Clipboard entry "${deleteInfo.id}" not found.`,
+                        actions: ["CLIPBOARD_DELETE_NOT_FOUND"],
+                        source: message.content.source,
+                    });
+                }
+                return { success: false, text: "Entry not found" };
+            }
+            const successMessage = `Successfully deleted clipboard entry "${deleteInfo.id}".`;
+            if (callback) {
+                await callback({
+                    text: successMessage,
+                    actions: ["CLIPBOARD_DELETE_SUCCESS"],
+                    source: message.content.source,
+                });
+            }
+            return { success: true, text: successMessage };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            logger.error("[ClipboardDelete] Error:", errorMsg);
+            if (callback) {
+                await callback({
+                    text: `Failed to delete the note: ${errorMsg}`,
+                    actions: ["CLIPBOARD_DELETE_FAILED"],
+                    source: message.content.source,
+                });
+            }
+            return { success: false, text: "Failed to delete clipboard entry" };
+        }
+    },
+    examples: [],
+};
+export default clipboardDeleteAction;

package/packages/typescript/src/features/advanced-capabilities/clipboard/actions/list.d.ts

@@ -0,0 +1,4 @@
+import { type Action } from "../../../../types/index.ts";
+export declare const clipboardListAction: Action;
+export default clipboardListAction;
+//# sourceMappingURL=list.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/clipboard/actions/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../../../../../../../typescript/src/features/advanced-capabilities/clipboard/actions/list.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,MAAM,EAOX,MAAM,4BAA4B,CAAC;AAMpC,eAAO,MAAM,mBAAmB,EAAE,MAwGjC,CAAC;AAEF,eAAe,mBAAmB,CAAC"}

package/packages/typescript/src/features/advanced-capabilities/clipboard/actions/list.js

@@ -0,0 +1,84 @@
+import { logger, } from "../../../../types/index.js";
+import { createClipboardService } from "../services/clipboardService.js";
+import { requireActionSpec } from "../specs.js";
+const spec = requireActionSpec("CLIPBOARD_LIST");
+export const clipboardListAction = {
+    name: spec.name,
+    similes: spec.similes ? [...spec.similes] : [],
+    description: spec.description,
+    validate: async (runtime, message, state, options) => {
+        const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+        const __avText = __avTextRaw.toLowerCase();
+        const __avKeywords = ["clipboard", "list"];
+        const __avKeywordOk = __avKeywords.length > 0 &&
+            __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
+        const __avRegex = /\b(?:clipboard|list)\b/i;
+        const __avRegexOk = __avRegex.test(__avText);
+        const __avSource = String(message?.content?.source ?? "");
+        const __avExpectedSource = "";
+        const __avSourceOk = __avExpectedSource
+            ? __avSource === __avExpectedSource
+            : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
+        const __avOptions = options && typeof options === "object" ? options : {};
+        const __avInputOk = __avText.trim().length > 0 ||
+            Object.keys(__avOptions).length > 0 ||
+            Boolean(message?.content && typeof message.content === "object");
+        if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+            return false;
+        }
+        const __avLegacyValidate = async (_runtime, _message) => {
+            return true;
+        };
+        try {
+            return Boolean(await __avLegacyValidate(runtime, message));
+        }
+        catch {
+            return false;
+        }
+    },
+    handler: async (runtime, message, _stateFromTrigger, _options, callback, _responses) => {
+        try {
+            const service = createClipboardService(runtime);
+            const entries = await service.list();
+            if (entries.length === 0) {
+                if (callback) {
+                    await callback({
+                        text: "You don't have any clipboard entries yet. Use CLIPBOARD_WRITE to create one.",
+                        actions: ["CLIPBOARD_LIST_EMPTY"],
+                        source: message.content.source,
+                    });
+                }
+                return { success: true, text: "No entries", entries: [] };
+            }
+            const listText = entries
+                .map((e, i) => {
+                const tagsStr = e.tags?.length ? ` [${e.tags.join(", ")}]` : "";
+                return `${i + 1}. **${e.title}** (${e.id})${tagsStr}\n   _Modified: ${e.modifiedAt.toLocaleDateString()}_`;
+            })
+                .join("\n");
+            const successMessage = `**Your Clipboard Entries** (${entries.length} total):\n\n${listText}`;
+            if (callback) {
+                await callback({
+                    text: successMessage,
+                    actions: ["CLIPBOARD_LIST_SUCCESS"],
+                    source: message.content.source,
+                });
+            }
+            return { success: true, text: successMessage, entries };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            logger.error("[ClipboardList] Error:", errorMsg);
+            if (callback) {
+                await callback({
+                    text: `Failed to list clipboard entries: ${errorMsg}`,
+                    actions: ["CLIPBOARD_LIST_FAILED"],
+                    source: message.content.source,
+                });
+            }
+            return { success: false, text: "Failed to list clipboard entries" };
+        }
+    },
+    examples: [],
+};
+export default clipboardListAction;

package/packages/typescript/src/features/advanced-capabilities/clipboard/actions/read-attachment.d.ts

@@ -0,0 +1,4 @@
+import { type Action } from "../../../../types/index.ts";
+export declare const readAttachmentAction: Action;
+export default readAttachmentAction;
+//# sourceMappingURL=read-attachment.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/clipboard/actions/read-attachment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-attachment.d.ts","sourceRoot":"","sources":["../../../../../../../../../typescript/src/features/advanced-capabilities/clipboard/actions/read-attachment.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,MAAM,EAQX,MAAM,4BAA4B,CAAC;AAQpC,eAAO,MAAM,oBAAoB,EAAE,MA8HlC,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/packages/typescript/src/features/advanced-capabilities/clipboard/actions/read-attachment.js

@@ -0,0 +1,112 @@
+import { ContentType, logger, } from "../../../../types/index.js";
+import { listConversationAttachments, readAttachmentRecord, summarizeAttachment, } from "../services/attachmentContext.js";
+import { maybeStoreTaskClipboardItem } from "../services/taskClipboardPersistence.js";
+export const readAttachmentAction = {
+    name: "READ_ATTACHMENT",
+    similes: ["OPEN_ATTACHMENT", "INSPECT_ATTACHMENT"],
+    description: "Read a stored attachment by attachment ID. Use this instead of relying on inline attachment descriptions in the conversation context. Set addToClipboard=true to keep the result in bounded task clipboard state.",
+    validate: async (runtime, message) => {
+        const isAttachmentRequest = typeof message.content.attachmentId === "string" ||
+            /attachment|image|screenshot|file/i.test(String(message.content.text ?? ""));
+        if (!isAttachmentRequest) {
+            return false;
+        }
+        const attachments = await listConversationAttachments(runtime, message);
+        return attachments.length > 0;
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        try {
+            const explicitId = typeof message.content.attachmentId === "string"
+                ? message.content.attachmentId.trim()
+                : null;
+            const result = await readAttachmentRecord(runtime, message, explicitId);
+            if (!result) {
+                const attachments = await listConversationAttachments(runtime, message);
+                const fallback = attachments.length
+                    ? `Available attachments:\n${attachments.map(summarizeAttachment).join("\n\n")}`
+                    : "No attachments are available in the current conversation window.";
+                if (callback) {
+                    await callback({
+                        text: fallback,
+                        actions: ["READ_ATTACHMENT_FAILED"],
+                        source: message.content.source,
+                    });
+                }
+                return { success: false, text: fallback };
+            }
+            const storedContent = result.content.trim();
+            const clipboardResult = await maybeStoreTaskClipboardItem(runtime, message, {
+                fallbackTitle: result.attachment.title || result.attachment.id,
+                content: storedContent,
+                sourceType: result.attachment.contentType === ContentType.IMAGE
+                    ? "image_attachment"
+                    : "attachment",
+                sourceId: result.attachment.id,
+                sourceLabel: result.attachment.title || result.attachment.url,
+                mimeType: result.attachment.contentType,
+            });
+            let clipboardStatusText = "";
+            if (clipboardResult.requested) {
+                if (clipboardResult.stored) {
+                    clipboardStatusText = `${clipboardResult.replaced ? "Updated" : "Added"} clipboard item ${clipboardResult.item.id}: ${clipboardResult.item.title}`;
+                }
+                else if ("reason" in clipboardResult) {
+                    clipboardStatusText = `Clipboard add skipped: ${clipboardResult.reason}`;
+                }
+            }
+            const responseText = [
+                summarizeAttachment(result.attachment),
+                result.autoSelected
+                    ? "Selection: auto-selected because no attachment ID was provided."
+                    : "",
+                clipboardStatusText,
+                clipboardResult.requested && clipboardResult.stored
+                    ? `Clipboard usage: ${clipboardResult.snapshot.items.length}/${clipboardResult.snapshot.maxItems}.`
+                    : "",
+                clipboardResult.requested && clipboardResult.stored
+                    ? "Clear unused clipboard state when it is no longer needed."
+                    : "",
+                "",
+                storedContent ||
+                    "No stored attachment content is available for this attachment.",
+            ]
+                .filter(Boolean)
+                .join("\n");
+            if (callback) {
+                await callback({
+                    text: responseText,
+                    actions: ["READ_ATTACHMENT_SUCCESS"],
+                    source: message.content.source,
+                });
+            }
+            return {
+                success: true,
+                text: responseText,
+                data: {
+                    attachmentId: result.attachment.id,
+                    attachment: result.attachment,
+                    content: storedContent,
+                    clipboard: clipboardResult,
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error("[ClipboardReadAttachment] Error:", errorMessage);
+            if (callback) {
+                await callback({
+                    text: `Failed to read attachment: ${errorMessage}`,
+                    actions: ["READ_ATTACHMENT_FAILED"],
+                    source: message.content.source,
+                });
+            }
+            return {
+                success: false,
+                text: "Failed to read attachment",
+                error: errorMessage,
+            };
+        }
+    },
+    examples: [],
+};
+export default readAttachmentAction;

package/packages/typescript/src/features/advanced-capabilities/clipboard/actions/read-file.d.ts

@@ -0,0 +1,16 @@
+import { type Action, type IAgentRuntime, type Memory, type State } from "../../../../types/index.ts";
+type ReadFileInput = {
+    filePath: string;
+    from?: number;
+    lines?: number;
+};
+export declare function readFileFromActionInput(runtime: IAgentRuntime, message: Memory, state?: State, explicitInput?: Partial<ReadFileInput>): Promise<{
+    filePath: string;
+    content: string;
+    truncated: boolean;
+    from: number;
+    linesRead: number;
+}>;
+export declare const readFileAction: Action;
+export default readFileAction;
+//# sourceMappingURL=read-file.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/clipboard/actions/read-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-file.d.ts","sourceRoot":"","sources":["../../../../../../../../../typescript/src/features/advanced-capabilities/clipboard/actions/read-file.ts"],"names":[],"mappings":"AAEA,OAAO,EACN,KAAK,MAAM,EAGX,KAAK,aAAa,EAElB,KAAK,MAAM,EAGX,KAAK,KAAK,EACV,MAAM,4BAA4B,CAAC;AAKpC,KAAK,aAAa,GAAG;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAmGF,wBAAsB,uBAAuB,CAC5C,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,KAAK,EACb,aAAa,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GACpC,OAAO,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CAClB,CAAC,CA8CD;AAED,eAAO,MAAM,cAAc,EAAE,MA2F5B,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/packages/typescript/src/features/advanced-capabilities/clipboard/actions/read-file.js

@@ -0,0 +1,192 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { logger, ModelType, parseKeyValueXml, } from "../../../../types/index.js";
+import { maybeStoreTaskClipboardItem } from "../services/taskClipboardPersistence.js";
+const MAX_READ_FILE_BYTES = 128 * 1024;
+function extractWorkdir(message, state) {
+    if (typeof message.content.workdir === "string" &&
+        message.content.workdir.trim()) {
+        return message.content.workdir.trim();
+    }
+    const codingWorkspace = state?.codingWorkspace;
+    if (typeof codingWorkspace?.path === "string" &&
+        codingWorkspace.path.trim()) {
+        return codingWorkspace.path.trim();
+    }
+    return null;
+}
+function resolveFilePath(inputPath, message, state) {
+    if (path.isAbsolute(inputPath)) {
+        return path.normalize(inputPath);
+    }
+    const workdir = extractWorkdir(message, state);
+    return path.resolve(workdir ?? process.cwd(), inputPath);
+}
+function hasReadFilePath(obj) {
+    return typeof obj.filePath === "string" && obj.filePath.trim().length > 0;
+}
+async function extractReadFileInput(runtime, message) {
+    const explicitPath = typeof message.content.filePath === "string"
+        ? message.content.filePath.trim()
+        : typeof message.content.path === "string"
+            ? message.content.path.trim()
+            : "";
+    if (explicitPath) {
+        return {
+            filePath: explicitPath,
+            from: typeof message.content.from === "number"
+                ? message.content.from
+                : undefined,
+            lines: typeof message.content.lines === "number"
+                ? message.content.lines
+                : undefined,
+        };
+    }
+    const text = typeof message.content.text === "string" ? message.content.text : "";
+    if (!text.trim()) {
+        return null;
+    }
+    const response = await runtime.useModel(ModelType.TEXT_SMALL, {
+        prompt: [
+            "Extract the file path and optional line range to read.",
+            "",
+            `User message: ${text}`,
+            "",
+            "Respond with XML:",
+            "<response><filePath>relative/or/absolute/path</filePath><from>1</from><lines>40</lines></response>",
+        ].join("\n"),
+        stopSequences: [],
+    });
+    const parsed = parseKeyValueXml(String(response));
+    if (!parsed || !hasReadFilePath(parsed)) {
+        return null;
+    }
+    const filePath = String(parsed.filePath);
+    const fromValue = parsed.from;
+    const linesValue = parsed.lines;
+    return {
+        filePath: filePath.trim(),
+        from: typeof fromValue === "string" && fromValue.trim()
+            ? Number(fromValue)
+            : undefined,
+        lines: typeof linesValue === "string" && linesValue.trim()
+            ? Number(linesValue)
+            : undefined,
+    };
+}
+export async function readFileFromActionInput(runtime, message, state, explicitInput) {
+    const inferred = explicitInput?.filePath
+        ? {
+            filePath: explicitInput.filePath,
+            from: explicitInput.from,
+            lines: explicitInput.lines,
+        }
+        : await extractReadFileInput(runtime, message);
+    if (!inferred) {
+        throw new Error("I couldn't determine which file to read.");
+    }
+    const resolvedPath = resolveFilePath(inferred.filePath, message, state);
+    const stat = await fs.stat(resolvedPath);
+    if (!stat.isFile()) {
+        throw new Error(`Not a file: ${resolvedPath}`);
+    }
+    const raw = await fs.readFile(resolvedPath);
+    if (raw.includes(0)) {
+        throw new Error(`Refusing to read binary file: ${resolvedPath}`);
+    }
+    let text = raw.toString("utf8");
+    const fromLine = Math.max(1, inferred.from ?? 1);
+    if (fromLine > 1 || typeof inferred.lines === "number") {
+        const allLines = text.split("\n");
+        const startIndex = fromLine - 1;
+        const lineCount = Math.max(1, inferred.lines ?? allLines.length - startIndex);
+        text = allLines.slice(startIndex, startIndex + lineCount).join("\n");
+    }
+    const truncated = Buffer.byteLength(text, "utf8") > MAX_READ_FILE_BYTES;
+    const finalContent = truncated ? text.slice(0, MAX_READ_FILE_BYTES) : text;
+    return {
+        filePath: resolvedPath,
+        content: finalContent,
+        truncated,
+        from: fromLine,
+        linesRead: finalContent.split("\n").length,
+    };
+}
+export const readFileAction = {
+    name: "READ_FILE",
+    similes: ["OPEN_FILE", "LOAD_FILE"],
+    description: "Read a local text file for the current task. Returns the file content so the agent can reference it. Set addToClipboard=true to keep the read result in bounded task clipboard state.",
+    validate: async (_runtime, message) => typeof message.content.filePath === "string" ||
+        typeof message.content.path === "string" ||
+        /(?:read|open|inspect).*(?:file|path)/i.test(String(message.content.text ?? "")),
+    handler: async (runtime, message, state, _options, callback) => {
+        try {
+            const result = await readFileFromActionInput(runtime, message, state);
+            const clipboardResult = await maybeStoreTaskClipboardItem(runtime, message, {
+                fallbackTitle: path.basename(result.filePath),
+                content: result.content,
+                sourceType: "file",
+                sourceId: result.filePath,
+                sourceLabel: result.filePath,
+            });
+            let clipboardStatusText = "";
+            if (clipboardResult.requested) {
+                if (clipboardResult.stored) {
+                    clipboardStatusText = `${clipboardResult.replaced ? "Updated" : "Added"} clipboard item ${clipboardResult.item.id}: ${clipboardResult.item.title}`;
+                }
+                else if ("reason" in clipboardResult) {
+                    clipboardStatusText = `Clipboard add skipped: ${clipboardResult.reason}`;
+                }
+            }
+            const responseText = [
+                `Read file: ${result.filePath}`,
+                `Lines: ${result.from}-${result.from + result.linesRead - 1}`,
+                result.truncated ? "(truncated to 128 KB)" : "",
+                clipboardStatusText,
+                clipboardResult.requested && clipboardResult.stored
+                    ? `Clipboard usage: ${clipboardResult.snapshot.items.length}/${clipboardResult.snapshot.maxItems}.`
+                    : "",
+                clipboardResult.requested && clipboardResult.stored
+                    ? "Clear unused clipboard state when it is no longer needed."
+                    : "",
+                "",
+                result.content,
+            ]
+                .filter(Boolean)
+                .join("\n");
+            if (callback) {
+                await callback({
+                    text: responseText,
+                    actions: ["READ_FILE_SUCCESS"],
+                    source: message.content.source,
+                });
+            }
+            return {
+                success: true,
+                text: responseText,
+                data: {
+                    ...result,
+                    clipboard: clipboardResult,
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error("[ClipboardReadFile] Error:", errorMessage);
+            if (callback) {
+                await callback({
+                    text: `Failed to read file: ${errorMessage}`,
+                    actions: ["READ_FILE_FAILED"],
+                    source: message.content.source,
+                });
+            }
+            return {
+                success: false,
+                text: "Failed to read file",
+                error: errorMessage,
+            };
+        }
+    },
+    examples: [],
+};
+export default readFileAction;

package/packages/typescript/src/features/advanced-capabilities/clipboard/actions/read.d.ts

@@ -0,0 +1,4 @@
+import { type Action } from "../../../../types/index.ts";
+export declare const clipboardReadAction: Action;
+export default clipboardReadAction;
+//# sourceMappingURL=read.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/clipboard/actions/read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../../../../../../../../typescript/src/features/advanced-capabilities/clipboard/actions/read.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,MAAM,EASX,MAAM,4BAA4B,CAAC;AAoEpC,eAAO,MAAM,mBAAmB,EAAE,MA6HjC,CAAC;AAEF,eAAe,mBAAmB,CAAC"}