@frockbot/plugin-mobile-notifications 0.0.0 → 0.1.1

package/frockbot.json

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

package/package.json

@@ -1,14 +1,37 @@
 {
   "name": "@frockbot/plugin-mobile-notifications",
-  "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-notifications"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./mobile.js";
+export { default as mobileNotificationsManifest } 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,158 @@
+import { describe, expect, test } from "bun:test";
+import {
+  MobileCommandRegistry,
+  MobileNotificationCapability,
+  type MobileNotificationRequest,
+} 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 mobileNotificationsPlugin, {
+  SHOW_NOTIFICATION_COMMAND,
+  type ShowNotificationResult,
+} from "./mobile.js";
+
+class FakeNotifications extends MobileNotificationCapability {
+  requests: MobileNotificationRequest[] = [];
+
+  show(request: MobileNotificationRequest, signal: AbortSignal): Promise<void> {
+    signal.throwIfAborted();
+    this.requests.push(request);
+    return Promise.resolve();
+  }
+}
+
+async function createHost(): Promise<{
+  harness: Awaited<ReturnType<typeof createPluginHarness>>;
+  notifications: FakeNotifications;
+}> {
+  const harness = await createPluginHarness([
+    MobileCommandRegistry,
+    FakeNotifications,
+  ]);
+  return {
+    harness,
+    notifications: harness.root.mobileNotifications as FakeNotifications,
+  };
+}
+
+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 notifications plugin", () => {
+  test("registers a command backed by the granted capability", async () => {
+    const { harness, notifications } = await createHost();
+    await harness.mount(mobileNotificationsPlugin);
+
+    expect(
+      await harness.root.mobileCommands.invoke<ShowNotificationResult>(
+        SHOW_NOTIFICATION_COMMAND,
+        { title: " Turn complete ", body: " FrockBot is idle " },
+      ),
+    ).toEqual({ shown: true });
+    expect(notifications.requests).toEqual([
+      {
+        title: "Turn complete",
+        body: "FrockBot is idle",
+        urgency: "normal",
+      },
+    ]);
+    await harness.dispose();
+  });
+
+  test("forwards a critical urgency request", async () => {
+    const { harness, notifications } = await createHost();
+    await harness.mount(mobileNotificationsPlugin);
+
+    await harness.root.mobileCommands.invoke(SHOW_NOTIFICATION_COMMAND, {
+      title: "Blocked",
+      urgency: "critical",
+    });
+    expect(notifications.requests).toEqual([
+      { title: "Blocked", body: undefined, urgency: "critical" },
+    ]);
+    await harness.dispose();
+  });
+
+  test("unregisters its command when its fiber is disposed", async () => {
+    const { harness } = await createHost();
+    const fiber = await harness.mount(mobileNotificationsPlugin);
+
+    await fiber.dispose();
+
+    await expectFailure(
+      harness.root.mobileCommands.invoke(SHOW_NOTIFICATION_COMMAND, {
+        title: "Not delivered",
+      }),
+      "is unavailable",
+    );
+    await harness.dispose();
+  });
+
+  test("rejects malformed input before invoking the capability", async () => {
+    const { harness, notifications } = await createHost();
+    await harness.mount(mobileNotificationsPlugin);
+
+    await expectFailure(
+      harness.root.mobileCommands.invoke(SHOW_NOTIFICATION_COMMAND, {
+        title: " ",
+      }),
+      "notification title is required",
+    );
+    await expectFailure(
+      harness.root.mobileCommands.invoke(SHOW_NOTIFICATION_COMMAND, {
+        title: "Turn complete",
+        urgency: "loud",
+      }),
+      'notification urgency must be "normal" or "critical"',
+    );
+    await expectFailure(
+      harness.root.mobileCommands.invoke(SHOW_NOTIFICATION_COMMAND, {
+        title: "Turn complete",
+        extra: true,
+      }),
+      "notification input has unknown fields",
+    );
+    expect(notifications.requests).toEqual([]);
+    await harness.dispose();
+  });
+
+  test("propagates the caller signal to the capability", async () => {
+    const { harness, notifications } = await createHost();
+    await harness.mount(mobileNotificationsPlugin);
+    const controller = new AbortController();
+    controller.abort(new Error("cancelled by test"));
+
+    await expectFailure(
+      harness.root.mobileCommands.invoke(
+        SHOW_NOTIFICATION_COMMAND,
+        { title: "Turn complete" },
+        controller.signal,
+      ),
+      "cancelled by test",
+    );
+    expect(notifications.requests).toEqual([]);
+    await harness.dispose();
+  });
+
+  test("satisfies plugin package conventions", () => {
+    expect(verifyPluginPackage({ packageJson, manifest })).toMatchObject({
+      name: "@frockbot/plugin-mobile-notifications",
+      contributionKinds: ["mobile"],
+    });
+  });
+});

package/src/mobile.ts

@@ -0,0 +1,82 @@
+import type {
+  MobileCommand,
+  MobileNotificationRequest,
+} from "@frockbot/mobile-core";
+import type { Plugin } from "cordis";
+
+export const SHOW_NOTIFICATION_COMMAND = "mobile.notifications.show";
+
+export interface ShowNotificationInput {
+  title: string;
+  body?: string;
+  urgency?: "normal" | "critical";
+}
+
+export interface ShowNotificationResult {
+  shown: true;
+}
+
+function optionalString(
+  record: Record<string, unknown>,
+  key: string,
+  maxLength: number,
+): string | undefined {
+  const value = record[key];
+  if (value === undefined) return undefined;
+  if (typeof value !== "string") throw new Error(`${key} must be a string`);
+  const normalized = value.trim();
+  if (!normalized) return undefined;
+  if (normalized.length > maxLength) {
+    throw new Error(`${key} must be at most ${maxLength} characters`);
+  }
+  return normalized;
+}
+
+export function decodeShowNotificationInput(
+  input: unknown,
+): ShowNotificationInput {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw new Error("notification input must be an object");
+  }
+  const keys = Reflect.ownKeys(input);
+  if (
+    keys.some(
+      (key) =>
+        typeof key !== "string" ||
+        !["title", "body", "urgency"].includes(key) ||
+        !Object.prototype.propertyIsEnumerable.call(input, key),
+    )
+  ) {
+    throw new Error("notification input has unknown fields");
+  }
+  const record = input as Record<string, unknown>;
+  const title = optionalString(record, "title", 200);
+  if (!title) throw new Error("notification title is required");
+  const body = optionalString(record, "body", 4_096);
+  const urgency = record.urgency ?? "normal";
+  if (urgency !== "normal" && urgency !== "critical") {
+    throw new Error('notification urgency must be "normal" or "critical"');
+  }
+  return { title, body, urgency };
+}
+
+export const mobileNotificationsPlugin: Plugin.Function = (ctx) => {
+  const command: MobileCommand<ShowNotificationInput, ShowNotificationResult> =
+    {
+      id: SHOW_NOTIFICATION_COMMAND,
+      decode: decodeShowNotificationInput,
+      async execute(input, context): Promise<ShowNotificationResult> {
+        const request: MobileNotificationRequest = {
+          title: input.title,
+          body: input.body,
+          urgency: input.urgency ?? "normal",
+        };
+        await ctx.mobileNotifications.show(request, context.signal);
+        return { shown: true };
+      },
+    };
+  return ctx.mobileCommands.register(command);
+};
+mobileNotificationsPlugin.inject = ["mobileCommands", "mobileNotifications"];
+
+export default mobileNotificationsPlugin;

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