@crewhaus/channel-adapter-imessage 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewhaus/channel-adapter-imessage",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "description": "macOS-only iMessage channel adapter: ~/Library/Messages/chat.db polling + osascript send + cursor-based idempotency (Section 33)",
   "main": "src/index.ts",
@@ -12,13 +12,13 @@
     "test": "bun test src"
   },
   "dependencies": {
-    "@crewhaus/errors": "0.1.1"
+    "@crewhaus/errors": "0.1.2"
   },
   "license": "Apache-2.0",
   "author": {
     "name": "Max Meier",
-    "email": "max@studiomax.io",
-    "url": "https://studiomax.io"
+    "email": "max@crewhaus.ai",
+    "url": "https://crewhaus.ai"
   },
   "repository": {
     "type": "git",
@@ -30,12 +30,7 @@
     "url": "https://github.com/crewhaus/factory/issues"
   },
   "publishConfig": {
-    "access": "restricted"
+    "access": "public"
   },
-  "files": [
-    "src",
-    "README.md",
-    "LICENSE",
-    "NOTICE"
-  ]
+  "files": ["src", "README.md", "LICENSE", "NOTICE"]
 }

package/src/index.osascript.test.ts

@@ -0,0 +1,116 @@
+/**
+ * Coverage for the production `defaultOsascript` path — the branch that
+ * dynamically `import("node:child_process")` and spawns the real `osascript`.
+ *
+ * Calling `sendReply` without an injected `osascript` runner exercises that
+ * default. To keep the test deterministic (no real process, no real iMessage
+ * send) we replace `node:child_process` with a fake `spawn` via `mock.module`.
+ *
+ * This lives in its own file so only these tests see the mock — but Bun does
+ * NOT reset module mocks at the file boundary: `bun test` runs every file in
+ * one process, file order is nondeterministic, and a `mock.module` persists
+ * until overwritten. The `afterAll` below re-mocks the real module so the
+ * fake `spawn` cannot leak into files that happen to run later.
+ */
+import { afterAll, describe, expect, mock, test } from "bun:test";
+import { EventEmitter } from "node:events";
+import { rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { buildFixtureChatDb } from "./fixtures/build-chat-db";
+
+// Captured BEFORE the mock below so afterAll can reinstall the real module.
+const realChildProcess = require("node:child_process") as typeof import("node:child_process");
+
+/** Records the scripts handed to the fake `osascript` across the file. */
+const writtenScripts: string[] = [];
+let nextExit = 0;
+
+mock.module("node:child_process", () => ({
+  spawn: (command: string, args: readonly string[], options: unknown) => {
+    // Sanity-check the default runner invokes osascript reading from stdin.
+    expect(command).toBe("osascript");
+    expect(args).toEqual(["-"]);
+    expect(options).toEqual({ stdio: ["pipe", "ignore", "pipe"] });
+    const child = new EventEmitter() as EventEmitter & {
+      stderr: EventEmitter;
+      stdin: { write(s: string): void; end(): void };
+    };
+    child.stderr = new EventEmitter();
+    child.stdin = {
+      write: (s: string) => writtenScripts.push(s),
+      end: () => {},
+    };
+    queueMicrotask(() => {
+      if (nextExit === 0) {
+        child.emit("close", 0);
+      } else {
+        child.stderr.emit("data", Buffer.from("osascript boom", "utf8"));
+        child.emit("close", nextExit);
+      }
+    });
+    return child;
+  },
+}));
+
+afterAll(() => {
+  // Bun has no mock.module restore API; re-mocking with the real exports is
+  // the documented way to undo a module mock. Without this, the fake `spawn`
+  // (which asserts it is called as `osascript`) stays registered for every
+  // test file that runs after this one.
+  mock.module("node:child_process", () => realChildProcess);
+});
+
+// Import AFTER registering the mock so the dynamic import inside
+// defaultOsascript resolves to the fake.
+const { createIMessageAdapter } = await import("./index");
+
+function makeAdapter() {
+  const dbPath = buildFixtureChatDb();
+  const cursorPath = join(dirname(dbPath), "cursor.json");
+  const adapter = createIMessageAdapter({
+    chatDbPath: dbPath,
+    cursorPath,
+    requireHostOptIn: false,
+  });
+  return { adapter, cleanup: () => rmSync(dirname(dbPath), { recursive: true, force: true }) };
+}
+
+const baseEvent = {
+  idempotencyKey: "imsg:1",
+  workspaceId: "imessage",
+  channelId: "alice@example.com",
+  userId: "alice@example.com",
+  ts: "0",
+  text: "in",
+  subtype: "message",
+} as const;
+
+describe("defaultOsascript (real-runner branch, child_process mocked)", () => {
+  test("sendReply with no injected runner spawns osascript and writes the script", async () => {
+    nextExit = 0;
+    writtenScripts.length = 0;
+    const { adapter, cleanup } = makeAdapter();
+    try {
+      await adapter.sendReply({ event: baseEvent, text: "hello from default" });
+      expect(writtenScripts.length).toBe(1);
+      expect(writtenScripts[0]).toContain('tell application "Messages"');
+      expect(writtenScripts[0]).toContain('send "hello from default"');
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("sendReply rejects when the spawned osascript exits non-zero", async () => {
+    nextExit = 3;
+    writtenScripts.length = 0;
+    const { adapter, cleanup } = makeAdapter();
+    try {
+      await expect(adapter.sendReply({ event: baseEvent, text: "x" })).rejects.toThrow(
+        /osascript exited with 3: osascript boom/,
+      );
+    } finally {
+      cleanup();
+    }
+  });
+});

package/src/index.test.ts

@@ -4,10 +4,104 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 
 import { buildFixtureChatDb } from "./fixtures/build-chat-db";
-import { IMessageAdapterError, _internal, createIMessageAdapter } from "./index";
+import {
+  IMessageAdapterError,
+  type OsascriptSpawn,
+  _internal,
+  createIMessageAdapter,
+  runOsascript,
+} from "./index";
 
 const { isSafeHandle, escapeAppleScriptString, validateChatDbPath } = _internal;
 
+/**
+ * Build a deterministic fake of `child_process.spawn` for {@link runOsascript}
+ * tests — no real process. `behavior` decides which lifecycle events fire and
+ * is invoked on a microtask so the runner has wired its listeners first.
+ */
+function fakeSpawn(behavior: {
+  readonly stderrChunks?: readonly string[];
+  readonly closeCode?: number | null;
+  readonly emitError?: Error;
+  /** Force `stdin`/`stderr` to be null to exercise the optional-chaining guards. */
+  readonly nullStreams?: boolean;
+}): { spawn: OsascriptSpawn; getWritten: () => string | undefined; ended: () => boolean } {
+  let written: string | undefined;
+  let didEnd = false;
+  const spawn: OsascriptSpawn = (command, args, options) => {
+    // The runner must always invoke osascript reading the script from stdin.
+    expect(command).toBe("osascript");
+    expect(args).toEqual(["-"]);
+    expect(options).toEqual({ stdio: ["pipe", "ignore", "pipe"] });
+    const handlers: Record<string, (arg: never) => void> = {};
+    const stderrHandlers: ((chunk: Buffer) => void)[] = [];
+    queueMicrotask(() => {
+      for (const c of behavior.stderrChunks ?? []) {
+        for (const h of stderrHandlers) h(Buffer.from(c, "utf8"));
+      }
+      if (behavior.emitError) handlers["error"]?.(behavior.emitError as never);
+      else handlers["close"]?.((behavior.closeCode ?? 0) as never);
+    });
+    return {
+      stderr: behavior.nullStreams ? null : { on: (_e, cb) => stderrHandlers.push(cb) },
+      stdin: behavior.nullStreams
+        ? null
+        : {
+            write: (chunk: string) => {
+              written = chunk;
+            },
+            end: () => {
+              didEnd = true;
+            },
+          },
+      on: (event: string, cb: (arg: never) => void) => {
+        handlers[event] = cb;
+      },
+    };
+  };
+  return { spawn, getWritten: () => written, ended: () => didEnd };
+}
+
+describe("runOsascript (default-runner core, dependency-injected spawn)", () => {
+  test("writes the script to stdin and resolves on exit code 0", async () => {
+    const f = fakeSpawn({ closeCode: 0 });
+    await runOsascript(f.spawn, "tell app");
+    expect(f.getWritten()).toBe("tell app");
+    expect(f.ended()).toBe(true);
+  });
+
+  test("rejects with stderr text + code on a non-zero exit", async () => {
+    const f = fakeSpawn({ closeCode: 2, stderrChunks: ["bad ", "things"] });
+    await expect(runOsascript(f.spawn, "x")).rejects.toThrow(/osascript exited with 2: bad things/);
+  });
+
+  test("rejects with a clear message when spawn emits 'error'", async () => {
+    const boom = new Error("ENOENT osascript");
+    const f = fakeSpawn({ emitError: boom });
+    let caught: unknown;
+    try {
+      await runOsascript(f.spawn, "x");
+    } catch (e) {
+      caught = e;
+    }
+    expect(caught).toBeInstanceOf(IMessageAdapterError);
+    expect((caught as Error).message).toBe("osascript spawn failed");
+    // The originating error is preserved on the cause chain.
+    expect((caught as IMessageAdapterError).cause).toBe(boom);
+  });
+
+  test("null stdin/stderr streams are tolerated (optional-chaining guards)", async () => {
+    const f = fakeSpawn({ nullStreams: true, closeCode: 0 });
+    await runOsascript(f.spawn, "x");
+    // Nothing was written because stdin was null; the runner still resolved.
+    expect(f.getWritten()).toBeUndefined();
+  });
+
+  test("exposed on _internal for the adapter's wiring", () => {
+    expect(_internal.runOsascript).toBe(runOsascript);
+  });
+});
+
 describe("isSafeHandle / escapeAppleScriptString / validateChatDbPath", () => {
   test("accepts well-formed iMessage handles", () => {
     expect(isSafeHandle("alice@example.com")).toBe(true);

package/src/index.ts

@@ -274,13 +274,38 @@ function writeCursor(cursorPath: string, cursor: number): void {
 
 // ─── default osascript runner ──────────────────────────────────────────────
 
-const defaultOsascript = async (script: string): Promise<void> => {
-  const { spawn } = await import("node:child_process");
+/**
+ * Minimal structural type for the slice of `child_process.spawn` that the
+ * osascript runner uses. Keeping it explicit (rather than importing Node's
+ * `ChildProcess`) lets tests inject a deterministic fake without a real
+ * process spawn — mirroring the dependency-injection style used elsewhere in
+ * factory's adapters.
+ */
+type SpawnedChild = {
+  readonly stdout?: { on(event: "data", cb: (chunk: Buffer) => void): void } | null;
+  readonly stderr: { on(event: "data", cb: (chunk: Buffer) => void): void } | null;
+  readonly stdin: { write(chunk: string): void; end(): void } | null;
+  on(event: "error", cb: (err: Error) => void): void;
+  on(event: "close", cb: (code: number | null) => void): void;
+};
+
+export type OsascriptSpawn = (
+  command: string,
+  args: readonly string[],
+  options: { stdio: readonly ["pipe", "ignore", "pipe"] },
+) => SpawnedChild;
+
+/**
+ * Run `osascript` reading the script from stdin, using an injected `spawn`.
+ * Resolves on exit code 0; rejects with an {@link IMessageAdapterError} on a
+ * spawn failure or any non-zero exit (surfacing captured stderr).
+ */
+export function runOsascript(spawn: OsascriptSpawn, script: string): Promise<void> {
   return new Promise<void>((resolve, reject) => {
     const head = "osascript";
     const child = spawn(head, ["-"], { stdio: ["pipe", "ignore", "pipe"] });
     const errBufs: Buffer[] = [];
-    child.stderr.on("data", (b) => errBufs.push(b));
+    child.stderr?.on("data", (b) => errBufs.push(b));
     child.on("error", (e) => reject(new IMessageAdapterError("osascript spawn failed", e)));
     child.on("close", (code) => {
       if (code === 0) resolve();
@@ -291,9 +316,14 @@ const defaultOsascript = async (script: string): Promise<void> => {
           ),
         );
     });
-    child.stdin.write(script);
-    child.stdin.end();
+    child.stdin?.write(script);
+    child.stdin?.end();
   });
+}
+
+const defaultOsascript = async (script: string): Promise<void> => {
+  const { spawn } = await import("node:child_process");
+  return runOsascript(spawn as unknown as OsascriptSpawn, script);
 };
 
 // ─── chat.db row shape + query ──────────────────────────────────────────────
@@ -327,4 +357,5 @@ export const _internal = {
   isSafeHandle,
   escapeAppleScriptString,
   validateChatDbPath,
+  runOsascript,
 };