@frockbot/plugin-desktop-clipboard 0.0.0 → 0.1.0

package/frockbot.json

@@ -0,0 +1,15 @@
+{
+  "schemaVersion": 3,
+  "id": "desktop-clipboard",
+  "displayName": "Desktop Clipboard",
+  "version": "0.0.1",
+  "compatibility": { "frockbot": ">=0.0.1" },
+  "contributions": {
+    "desktop": {
+      "entry": "./desktop",
+      "execution": "trusted-main",
+      "commands": []
+    }
+  },
+  "permissions": ["desktop:clipboard:read", "desktop:clipboard:write"]
+}

package/package.json

@@ -1,14 +1,37 @@
 {
   "name": "@frockbot/plugin-desktop-clipboard",
-  "version": "0.0.0",
-  "description": "Placeholder reserving this name for trusted publishing. Superseded by the first release.",
-  "license": "UNLICENSED",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./desktop": "./src/desktop.ts",
+    "./manifest": "./src/manifest.ts",
+    "./frockbot.json": "./frockbot.json",
+    "./package.json": "./package.json"
+  },
+  "frockbot": {
+    "manifest": "./frockbot.json"
+  },
+  "scripts": {
+    "test": "bun test src",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@frockbot/desktop-core": "0.1.0",
+    "cordis": "4.0.0-rc.8"
+  },
+  "devDependencies": {
+    "@frockbot/plugin-testkit": "0.1.0",
+    "@types/bun": "1.4.0",
+    "typescript": "^7.0.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/timoconnellaus/frockbot.git",
     "directory": "packages/plugin-desktop-clipboard"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }

package/src/desktop.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, test } from "bun:test";
+import {
+  DesktopClipboardCapability,
+  DesktopCommandRegistry,
+} from "@frockbot/desktop-core";
+import {
+  createPluginHarness,
+  verifyPluginPackage,
+} from "@frockbot/plugin-testkit";
+import manifest from "../frockbot.json" with { type: "json" };
+import packageJson from "../package.json" with { type: "json" };
+import desktopClipboardPlugin, {
+  READ_CLIPBOARD_TEXT_COMMAND,
+  type ReadClipboardTextResult,
+  WRITE_CLIPBOARD_TEXT_COMMAND,
+  type WriteClipboardTextResult,
+} from "./desktop.js";
+
+class FakeClipboard extends DesktopClipboardCapability {
+  text = "initial";
+
+  readText(signal: AbortSignal): Promise<string> {
+    signal.throwIfAborted();
+    return Promise.resolve(this.text);
+  }
+
+  writeText(text: string, signal: AbortSignal): Promise<void> {
+    signal.throwIfAborted();
+    this.text = text;
+    return Promise.resolve();
+  }
+}
+
+async function createHost(): Promise<{
+  harness: Awaited<ReturnType<typeof createPluginHarness>>;
+  clipboard: FakeClipboard;
+}> {
+  const harness = await createPluginHarness([
+    DesktopCommandRegistry,
+    FakeClipboard,
+  ]);
+  return {
+    harness,
+    clipboard: harness.root.desktopClipboard as FakeClipboard,
+  };
+}
+
+async function expectFailure(
+  promise: Promise<unknown>,
+  message: string,
+): Promise<void> {
+  let failure: unknown;
+  try {
+    await promise;
+  } catch (error) {
+    failure = error;
+  }
+  expect(failure).toBeInstanceOf(Error);
+  expect(failure instanceof Error ? failure.message : "").toContain(message);
+}
+
+describe("desktop clipboard plugin", () => {
+  test("registers read and write commands over the granted capability", async () => {
+    const { harness, clipboard } = await createHost();
+    await harness.mount(desktopClipboardPlugin);
+
+    expect(
+      await harness.root.desktopCommands.invoke<ReadClipboardTextResult>(
+        READ_CLIPBOARD_TEXT_COMMAND,
+        {},
+      ),
+    ).toEqual({ text: "initial" });
+    expect(
+      await harness.root.desktopCommands.invoke<WriteClipboardTextResult>(
+        WRITE_CLIPBOARD_TEXT_COMMAND,
+        { text: "updated" },
+      ),
+    ).toEqual({ written: true });
+    expect(clipboard.text).toBe("updated");
+    await harness.dispose();
+  });
+
+  test("preserves exact clipboard text, including an empty string", async () => {
+    const { harness, clipboard } = await createHost();
+    await harness.mount(desktopClipboardPlugin);
+
+    await harness.root.desktopCommands.invoke(WRITE_CLIPBOARD_TEXT_COMMAND, {
+      text: "",
+    });
+    expect(clipboard.text).toBe("");
+    await harness.dispose();
+  });
+
+  test("unregisters both commands on disposal", async () => {
+    const { harness } = await createHost();
+    const fiber = await harness.mount(desktopClipboardPlugin);
+
+    await fiber.dispose();
+    await expectFailure(
+      harness.root.desktopCommands.invoke(READ_CLIPBOARD_TEXT_COMMAND, {}),
+      "is unavailable",
+    );
+    await expectFailure(
+      harness.root.desktopCommands.invoke(WRITE_CLIPBOARD_TEXT_COMMAND, {
+        text: "not written",
+      }),
+      "is unavailable",
+    );
+    await harness.dispose();
+  });
+
+  test("rejects malformed writes before invoking the capability", async () => {
+    const { harness, clipboard } = await createHost();
+    await harness.mount(desktopClipboardPlugin);
+
+    await expectFailure(
+      harness.root.desktopCommands.invoke(WRITE_CLIPBOARD_TEXT_COMMAND, {
+        text: 42,
+      }),
+      "clipboard text must be a string",
+    );
+    expect(clipboard.text).toBe("initial");
+    await harness.dispose();
+  });
+
+  test("satisfies plugin package conventions", () => {
+    expect(verifyPluginPackage({ packageJson, manifest })).toMatchObject({
+      name: "@frockbot/plugin-desktop-clipboard",
+      contributionKinds: ["desktop"],
+    });
+  });
+});

package/src/desktop.ts

@@ -0,0 +1,85 @@
+import type {
+  DesktopCommand,
+  DesktopClipboardCapability,
+} from "@frockbot/desktop-core";
+import type { Plugin } from "cordis";
+
+export const READ_CLIPBOARD_TEXT_COMMAND = "desktop.clipboard.readText";
+export const WRITE_CLIPBOARD_TEXT_COMMAND = "desktop.clipboard.writeText";
+export const MAX_CLIPBOARD_TEXT_LENGTH = 1_000_000;
+
+export type ReadClipboardTextInput = Record<string, never>;
+
+export interface ReadClipboardTextResult {
+  text: string;
+}
+
+export interface WriteClipboardTextInput {
+  text: string;
+}
+
+export interface WriteClipboardTextResult {
+  written: true;
+}
+
+function inputRecord(input: unknown): Record<string, unknown> {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw new Error("clipboard input must be an object");
+  }
+  return input as Record<string, unknown>;
+}
+
+export function decodeReadClipboardTextInput(
+  input: unknown,
+): ReadClipboardTextInput {
+  inputRecord(input);
+  return {};
+}
+
+export function decodeWriteClipboardTextInput(
+  input: unknown,
+): WriteClipboardTextInput {
+  const record = inputRecord(input);
+  if (typeof record.text !== "string") {
+    throw new Error("clipboard text must be a string");
+  }
+  if (record.text.length > MAX_CLIPBOARD_TEXT_LENGTH) {
+    throw new Error(
+      `clipboard text must be at most ${MAX_CLIPBOARD_TEXT_LENGTH} characters`,
+    );
+  }
+  return { text: record.text };
+}
+
+function readCommand(
+  clipboard: DesktopClipboardCapability,
+): DesktopCommand<ReadClipboardTextInput, ReadClipboardTextResult> {
+  return {
+    id: READ_CLIPBOARD_TEXT_COMMAND,
+    decode: decodeReadClipboardTextInput,
+    async execute(_input, context): Promise<ReadClipboardTextResult> {
+      return { text: await clipboard.readText(context.signal) };
+    },
+  };
+}
+
+function writeCommand(
+  clipboard: DesktopClipboardCapability,
+): DesktopCommand<WriteClipboardTextInput, WriteClipboardTextResult> {
+  return {
+    id: WRITE_CLIPBOARD_TEXT_COMMAND,
+    decode: decodeWriteClipboardTextInput,
+    async execute(input, context): Promise<WriteClipboardTextResult> {
+      await clipboard.writeText(input.text, context.signal);
+      return { written: true };
+    },
+  };
+}
+
+export const desktopClipboardPlugin: Plugin.Function = (ctx) => [
+  ctx.desktopCommands.register(readCommand(ctx.desktopClipboard)),
+  ctx.desktopCommands.register(writeCommand(ctx.desktopClipboard)),
+];
+desktopClipboardPlugin.inject = ["desktopCommands", "desktopClipboard"];
+
+export default desktopClipboardPlugin;

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./desktop.js";
+export { default as desktopClipboardManifest } from "./manifest.js";

package/src/manifest.ts

@@ -0,0 +1,3 @@
+import manifest from "../frockbot.json" with { type: "json" };
+
+export default manifest;

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "lib": ["ES2023", "DOM"],
+    "types": ["bun"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/README.md

@@ -1,3 +0,0 @@
-# @frockbot/plugin-desktop-clipboard
-
-Placeholder reserving this name. See https://github.com/timoconnellaus/frockbot.