@frockbot/plugin-mobile-clipboard 0.0.0 → 0.1.1

package/frockbot.json

@@ -0,0 +1,10 @@
+{
+  "schemaVersion": 1,
+  "id": "mobile-clipboard",
+  "displayName": "Mobile Clipboard",
+  "version": "0.0.1",
+  "contributions": {
+    "mobile": "./mobile"
+  },
+  "permissions": ["mobile:clipboard:read", "mobile:clipboard:write"]
+}

package/package.json

@@ -1,14 +1,37 @@
 {
   "name": "@frockbot/plugin-mobile-clipboard",
-  "version": "0.0.0",
-  "description": "Placeholder reserving this name for trusted publishing. Superseded by the first release.",
-  "license": "UNLICENSED",
+  "version": "0.1.1",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./mobile": "./src/mobile.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/mobile-core": "0.1.1",
+    "cordis": "4.0.0-rc.8"
+  },
+  "devDependencies": {
+    "@frockbot/plugin-testkit": "0.1.1",
+    "@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-mobile-clipboard"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }

package/src/index.ts

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

package/src/manifest.ts

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

package/src/mobile.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, test } from "bun:test";
+import {
+  MobileClipboardCapability,
+  MobileCommandRegistry,
+} from "@frockbot/mobile-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 mobileClipboardPlugin, {
+  MAX_CLIPBOARD_TEXT_LENGTH,
+  READ_CLIPBOARD_TEXT_COMMAND,
+  type ReadClipboardTextResult,
+  WRITE_CLIPBOARD_TEXT_COMMAND,
+  type WriteClipboardTextResult,
+} from "./mobile.js";
+
+class FakeClipboard extends MobileClipboardCapability {
+  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([
+    MobileCommandRegistry,
+    FakeClipboard,
+  ]);
+  return {
+    harness,
+    clipboard: harness.root.mobileClipboard 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("mobile clipboard plugin", () => {
+  test("registers read and write commands over the granted capability", async () => {
+    const { harness, clipboard } = await createHost();
+    await harness.mount(mobileClipboardPlugin);
+
+    expect(
+      await harness.root.mobileCommands.invoke<ReadClipboardTextResult>(
+        READ_CLIPBOARD_TEXT_COMMAND,
+        {},
+      ),
+    ).toEqual({ text: "initial" });
+    expect(
+      await harness.root.mobileCommands.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(mobileClipboardPlugin);
+
+    await harness.root.mobileCommands.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(mobileClipboardPlugin);
+
+    await fiber.dispose();
+    await expectFailure(
+      harness.root.mobileCommands.invoke(READ_CLIPBOARD_TEXT_COMMAND, {}),
+      "is unavailable",
+    );
+    await expectFailure(
+      harness.root.mobileCommands.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(mobileClipboardPlugin);
+
+    await expectFailure(
+      harness.root.mobileCommands.invoke(WRITE_CLIPBOARD_TEXT_COMMAND, {
+        text: 42,
+      }),
+      "clipboard text must be a string",
+    );
+    await expectFailure(
+      harness.root.mobileCommands.invoke(WRITE_CLIPBOARD_TEXT_COMMAND, {
+        text: "x".repeat(MAX_CLIPBOARD_TEXT_LENGTH + 1),
+      }),
+      "clipboard text must be at most 1000000 characters",
+    );
+    await expectFailure(
+      harness.root.mobileCommands.invoke(READ_CLIPBOARD_TEXT_COMMAND, {
+        extra: true,
+      }),
+      "clipboard input has unknown fields",
+    );
+    clipboard.text = "x".repeat(MAX_CLIPBOARD_TEXT_LENGTH + 1);
+    await expectFailure(
+      harness.root.mobileCommands.invoke(READ_CLIPBOARD_TEXT_COMMAND, {}),
+      "clipboard text must be at most 1000000 characters",
+    );
+    expect(clipboard.text.length).toBe(MAX_CLIPBOARD_TEXT_LENGTH + 1);
+    await harness.dispose();
+  });
+
+  test("propagates the caller signal to the capability", async () => {
+    const { harness, clipboard } = await createHost();
+    await harness.mount(mobileClipboardPlugin);
+    const controller = new AbortController();
+    controller.abort(new Error("cancelled by test"));
+
+    await expectFailure(
+      harness.root.mobileCommands.invoke(
+        WRITE_CLIPBOARD_TEXT_COMMAND,
+        { text: "not written" },
+        controller.signal,
+      ),
+      "cancelled by test",
+    );
+    expect(clipboard.text).toBe("initial");
+    await harness.dispose();
+  });
+
+  test("satisfies plugin package conventions", () => {
+    expect(verifyPluginPackage({ packageJson, manifest })).toMatchObject({
+      name: "@frockbot/plugin-mobile-clipboard",
+      contributionKinds: ["mobile"],
+    });
+  });
+});

package/src/mobile.ts

@@ -0,0 +1,105 @@
+import type {
+  MobileCommand,
+  MobileClipboardCapability,
+} from "@frockbot/mobile-core";
+import type { Plugin } from "cordis";
+
+export const READ_CLIPBOARD_TEXT_COMMAND = "mobile.clipboard.readText";
+export const WRITE_CLIPBOARD_TEXT_COMMAND = "mobile.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,
+  allowedKeys: readonly string[],
+): Record<string, unknown> {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw new Error("clipboard input must be an object");
+  }
+  const keys = Reflect.ownKeys(input);
+  if (
+    keys.some(
+      (key) =>
+        typeof key !== "string" ||
+        !allowedKeys.includes(key) ||
+        !Object.prototype.propertyIsEnumerable.call(input, key),
+    )
+  ) {
+    throw new Error("clipboard input has unknown fields");
+  }
+  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, ["text"]);
+  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: MobileClipboardCapability,
+): MobileCommand<ReadClipboardTextInput, ReadClipboardTextResult> {
+  return {
+    id: READ_CLIPBOARD_TEXT_COMMAND,
+    decode: decodeReadClipboardTextInput,
+    async execute(_input, context): Promise<ReadClipboardTextResult> {
+      const text = await clipboard.readText(context.signal);
+      if (text.length > MAX_CLIPBOARD_TEXT_LENGTH) {
+        throw new Error(
+          `clipboard text must be at most ${MAX_CLIPBOARD_TEXT_LENGTH} characters`,
+        );
+      }
+      return { text };
+    },
+  };
+}
+
+function writeCommand(
+  clipboard: MobileClipboardCapability,
+): MobileCommand<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 mobileClipboardPlugin: Plugin.Function = (ctx) => [
+  ctx.mobileCommands.register(readCommand(ctx.mobileClipboard)),
+  ctx.mobileCommands.register(writeCommand(ctx.mobileClipboard)),
+];
+mobileClipboardPlugin.inject = ["mobileCommands", "mobileClipboard"];
+
+export default mobileClipboardPlugin;

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-mobile-clipboard
-
-Placeholder reserving this name. See https://github.com/timoconnellaus/frockbot.