clawmini 0.0.7 → 0.0.9

package/e2e/adapters/_google-chat-fixtures.ts

@@ -0,0 +1,340 @@
+import { afterAll, afterEach, beforeAll, vi } from 'vitest';
+import { EventEmitter } from 'node:events';
+import { TestEnvironment } from '../_helpers/test-environment.js';
+import {
+  getTRPCClient,
+  type GoogleChatApi,
+  type MessageSourceLike,
+} from '../../src/adapter-google-chat/client.js';
+import type { GoogleChatConfig } from '../../src/adapter-google-chat/config.js';
+import { startDaemonToGoogleChatForwarder } from '../../src/adapter-google-chat/forwarder.js';
+import { updateGoogleChatState } from '../../src/adapter-google-chat/state.js';
+
+export const BASE_CONFIG: GoogleChatConfig = {
+  projectId: 'fake-project',
+  subscriptionName: 'fake-sub',
+  topicName: 'fake-topic',
+  authorizedUsers: ['user@example.com'],
+  requireMention: false,
+  chatId: 'gc-chat',
+  driveUploadEnabled: false,
+};
+
+export interface FakeMessage {
+  data: Buffer;
+  attributes: Record<string, string>;
+  ack: ReturnType<typeof vi.fn>;
+  nack: ReturnType<typeof vi.fn>;
+}
+
+export function makePubsubMessage(
+  body: Record<string, unknown>,
+  attributes: Record<string, string> = {}
+): FakeMessage {
+  return {
+    data: Buffer.from(JSON.stringify(body)),
+    attributes,
+    ack: vi.fn(),
+    nack: vi.fn(),
+  };
+}
+
+/**
+ * Pub/Sub-shaped MESSAGE event in a DIRECT_MESSAGE (singleUserBotDm) space.
+ * `sender` defaults to the authorized user. Pass `attachment` for attachment
+ * tests, or `quotedMessageMetadata` to model a quote-reply.
+ */
+export function makeDmMessage(opts: {
+  space: string;
+  messageId: string;
+  text: string;
+  sender?: string;
+  attachment?: unknown[];
+  quotedMessageMetadata?: unknown;
+}): FakeMessage {
+  const sender = opts.sender ?? 'user@example.com';
+  return makePubsubMessage({
+    type: 'MESSAGE',
+    space: { name: opts.space, type: 'DIRECT_MESSAGE', singleUserBotDm: true },
+    message: {
+      name: `${opts.space}/messages/${opts.messageId}`,
+      sender: { email: sender, type: 'USER' },
+      text: opts.text,
+      ...(opts.attachment ? { attachment: opts.attachment } : {}),
+      ...(opts.quotedMessageMetadata
+        ? { quotedMessageMetadata: opts.quotedMessageMetadata }
+        : {}),
+    },
+  });
+}
+
+/**
+ * Pub/Sub-shaped MESSAGE event in a non-DM SPACE. `authUser` authenticates the
+ * caller (top-level `user.email`); `sender` (if provided) sets
+ * `message.sender` — omit it for command-style messages that arrive without a
+ * sender. `mention: true` adds the bot-targeted USER_MENTION annotation used
+ * by the `requireMention` path; pass `annotations` directly to control the
+ * exact shape (e.g. the simpler `[{ type: 'USER_MENTION' }]` form).
+ */
+export function makeSpaceMessage(opts: {
+  space: string;
+  messageId: string;
+  text: string;
+  authUser?: string;
+  sender?: string;
+  mention?: boolean;
+  annotations?: unknown[];
+}): FakeMessage {
+  const authUser = opts.authUser ?? 'user@example.com';
+  const annotations =
+    opts.annotations ??
+    (opts.mention
+      ? [{ type: 'USER_MENTION', userMention: { user: { type: 'BOT' } } }]
+      : undefined);
+  return makePubsubMessage({
+    type: 'MESSAGE',
+    space: { name: opts.space, type: 'SPACE' },
+    user: { email: authUser },
+    message: {
+      name: `${opts.space}/messages/${opts.messageId}`,
+      text: opts.text,
+      ...(opts.sender ? { sender: { email: opts.sender, type: 'USER' } } : {}),
+      ...(annotations ? { annotations } : {}),
+    },
+  });
+}
+
+export interface ChatCreateParams {
+  parent: string;
+  requestBody: {
+    text?: string;
+    cardsV2?: unknown[];
+    [key: string]: unknown;
+  };
+}
+
+export interface ChatUpdateParams {
+  name: string;
+  updateMask: string;
+  requestBody: {
+    text?: string;
+    cardsV2?: unknown[];
+    [key: string]: unknown;
+  };
+}
+
+type ChatCreateFn = (params: ChatCreateParams) => Promise<unknown>;
+type ChatUpdateFn = (params: ChatUpdateParams) => Promise<unknown>;
+
+export function makeFakeChatApi() {
+  const create = vi.fn<ChatCreateFn>().mockResolvedValue({});
+  const update = vi.fn<ChatUpdateFn>().mockResolvedValue({});
+  const list = vi.fn().mockResolvedValue({ data: { messages: [] } });
+  const api = {
+    spaces: {
+      messages: { create, update, list },
+    },
+  } as unknown as GoogleChatApi;
+  return { api, create, update, list };
+}
+
+/** Find a `chatApi.spaces.messages.create` call by `requestBody.text`. */
+export function findCreateByText(
+  create: ReturnType<typeof makeFakeChatApi>['create'],
+  match: string | ((text: string) => boolean)
+): ChatCreateParams | undefined {
+  const test = typeof match === 'string' ? (t: string) => t === match : match;
+  return create.mock.calls.find(
+    ([params]) => typeof params.requestBody.text === 'string' && test(params.requestBody.text)
+  )?.[0];
+}
+
+/** Find the first `create` call carrying a non-empty `cardsV2` payload. */
+export function findCreateWithCard(
+  create: ReturnType<typeof makeFakeChatApi>['create']
+): ChatCreateParams | undefined {
+  return create.mock.calls.find(
+    ([params]) => Array.isArray(params.requestBody.cardsV2) && params.requestBody.cardsV2.length > 0
+  )?.[0];
+}
+
+export function makeFakeSubscription(): MessageSourceLike & {
+  emitMessage: (msg: FakeMessage) => void;
+} {
+  const emitter = new EventEmitter();
+  const messageSource = emitter as unknown as MessageSourceLike;
+  return Object.assign(messageSource, {
+    emitMessage: (msg: FakeMessage) => emitter.emit('message', msg),
+  });
+}
+
+export interface QueuingFakeSubscription extends MessageSourceLike {
+  emitMessage: (msg: FakeMessage) => void;
+  detach: () => void;
+  pendingCount: () => number;
+}
+
+/**
+ * Fake Pub/Sub subscription that buffers emitted messages until a 'message'
+ * listener is attached, and replays them on attach. Models Pub/Sub's at-least-
+ * once redelivery: when the consumer (adapter process) is offline, messages
+ * aren't lost — they reappear when a new consumer connects.
+ *
+ * `detach()` removes the current listener, simulating the adapter crashing/
+ * shutting down. Subsequent `emitMessage` calls queue until a fresh
+ * `.on('message', ...)` attaches.
+ */
+export function makeQueuingFakeSubscription(): QueuingFakeSubscription {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let listener: ((msg: any) => void | Promise<void>) | null = null;
+  const queue: FakeMessage[] = [];
+
+  const sub: QueuingFakeSubscription = {
+    on(event, l) {
+      if (event === 'message') {
+        listener = l;
+        while (queue.length > 0 && listener) {
+          const next = queue.shift()!;
+          listener(next);
+        }
+      }
+      return sub;
+    },
+    emitMessage(msg) {
+      if (listener) {
+        listener(msg);
+      } else {
+        queue.push(msg);
+      }
+    },
+    detach() {
+      listener = null;
+    },
+    pendingCount() {
+      return queue.length;
+    },
+  };
+
+  return sub;
+}
+
+/**
+ * Wrap a trpc client so we can observe when `waitForMessages.subscribe` has been
+ * acknowledged by the server (SSE `started` frame). Tests `await ready` before
+ * sending a message so the forwarder's subscription is guaranteed to be live.
+ */
+export function instrumentTrpcForReadiness(trpc: ReturnType<typeof getTRPCClient>) {
+  let resolveReady: () => void = () => {};
+  const ready = new Promise<void>((r) => {
+    resolveReady = r;
+  });
+  const wrapped = new Proxy(trpc, {
+    get(target, prop, receiver) {
+      if (prop === 'waitForMessages') {
+        const route = Reflect.get(target, prop, receiver) as {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          subscribe: (input: unknown, opts: any) => { unsubscribe: () => void };
+        };
+        return {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          subscribe: (input: unknown, opts: any) =>
+            route.subscribe(input, {
+              ...opts,
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              onStarted: (ctx: any) => {
+                resolveReady();
+                opts?.onStarted?.(ctx);
+              },
+            }),
+        };
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+  }) as ReturnType<typeof getTRPCClient>;
+  return { trpc: wrapped, ready };
+}
+
+/**
+ * Run the daemon → Google Chat forwarder for the duration of `body`. Wraps
+ * `trpc` with readiness instrumentation, awaits the SSE `started` frame so
+ * body code can rely on the subscription being live, and aborts + joins the
+ * forwarder in a finally block so a throwing body doesn't leak it.
+ */
+export async function runForwarder(
+  options: {
+    trpc: ReturnType<typeof getTRPCClient>;
+    chatApi: GoogleChatApi;
+    startDir: string;
+    config?: GoogleChatConfig;
+    filters?: Record<string, boolean>;
+  },
+  body: () => Promise<void>
+): Promise<void> {
+  const { trpc, ready } = instrumentTrpcForReadiness(options.trpc);
+  const abort = new AbortController();
+  const forwarderPromise = startDaemonToGoogleChatForwarder(
+    trpc,
+    options.config ?? BASE_CONFIG,
+    { filters: options.filters ?? {} },
+    abort.signal,
+    { chatApi: options.chatApi, startDir: options.startDir }
+  );
+  try {
+    await ready;
+    await body();
+  } finally {
+    abort.abort();
+    await forwarderPromise;
+  }
+}
+
+/**
+ * Boilerplate for a Google Chat adapter e2e suite: spins up a dedicated
+ * TestEnvironment for the suite and resets adapter state between tests.
+ *
+ * Pass `{ subagents: true }` to install the `debug-agent` + exported
+ * `clawmini-lite.js` on PATH, so tests can drive thread-log events by spawning
+ * subagents (the echo agent init() installs only produces command + agent_reply
+ * messages, and command messages are dropped from the turn log).
+ *
+ * The reset is queued through `updateGoogleChatState` so it runs after any
+ * pending writes (e.g. a late `saveLastMessageId` from the prior test's
+ * forwarder) — otherwise those writes could resurrect `channelChatMap`
+ * entries after the reset.
+ */
+export function useGoogleChatAdapterEnv(
+  suiteName: string,
+  options: { subagents?: boolean } = {}
+) {
+  const ref: { env: TestEnvironment } = { env: null as unknown as TestEnvironment };
+
+  beforeAll(async () => {
+    ref.env = new TestEnvironment(suiteName);
+    await ref.env.setup();
+    if (options.subagents) {
+      await ref.env.setupSubagentEnv();
+    } else {
+      await ref.env.init();
+      await ref.env.up();
+    }
+  }, 60000);
+
+  afterAll(async () => {
+    await ref.env.teardown();
+  }, 30000);
+
+  afterEach(async () => {
+    await ref.env.disconnectAll();
+    await updateGoogleChatState(
+      () => ({
+        lastSyncedMessageIds: {},
+        channelChatMap: {},
+        oauthTokens: undefined,
+        filters: {},
+      }),
+      ref.env.e2eDir
+    );
+  });
+
+  return ref;
+}

package/{src/cli/e2e → e2e/adapters}/adapter-discord.test.ts

@@ -1,29 +1,29 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { createE2EContext } from './utils.js';
-import { getTRPCClient } from '../../adapter-discord/client.js';
-import { getSocketPath } from '../../shared/workspace.js';
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import { TestEnvironment } from '../_helpers/test-environment.js';
+import { getTRPCClient } from '../../src/adapter-discord/client.js';
+import { getSocketPath } from '../../src/shared/workspace.js';
 
-const { runCli, e2eDir, setupE2E, teardownE2E } = createE2EContext('e2e-discord');
 describe('Discord Adapter Client E2E', () => {
+  let env: TestEnvironment;
+
   beforeAll(async () => {
-    await setupE2E();
-    await runCli(['init']);
-    await runCli(['up']);
+    env = new TestEnvironment('e2e-discord');
+    await env.setup();
+    await env.init();
+    await env.up();
   }, 30000);
 
-  afterAll(async () => {
-    await runCli(['down']);
-    await teardownE2E();
-  }, 30000);
+  afterAll(() => env.teardown(), 30000);
+  afterEach(() => env.disconnectAll());
 
   it('should successfully connect to the daemon and subscribe to messages', async () => {
-    const socketPath = getSocketPath(e2eDir);
+    const socketPath = getSocketPath(env.e2eDir);
     const trpc = getTRPCClient({ socketPath });
 
     const pingResult = await trpc.ping.query();
     expect(pingResult).toEqual({ status: 'ok' });
 
-    await runCli(['chats', 'add', 'discord-chat']);
+    await env.addChat('discord-chat');
 
     let subscription: { unsubscribe: () => void } | undefined;
     const messages: Record<string, unknown>[] = [];
@@ -33,7 +33,10 @@ describe('Discord Adapter Client E2E', () => {
         { chatId: 'discord-chat' },
         {
           onData: (data) => {
-            messages.push(...(data as Record<string, unknown>[]));
+            const items = data as Array<{ kind: string; message?: Record<string, unknown> }>;
+            for (const item of items) {
+              if (item.kind === 'message' && item.message) messages.push(item.message);
+            }
             if (messages.some((m) => m.content === 'hello from adapter e2e test')) {
               resolve();
             }
@@ -47,14 +50,10 @@ describe('Discord Adapter Client E2E', () => {
       // Wait a brief moment to ensure subscription is established before sending a message
       setTimeout(async () => {
         try {
-          await runCli([
-            'messages',
-            'send',
-            'hello from adapter e2e test',
-            '--chat',
-            'discord-chat',
-            '--no-wait',
-          ]);
+          await env.sendMessage('hello from adapter e2e test', {
+            chat: 'discord-chat',
+            noWait: true,
+          });
         } catch (e) {
           reject(e);
         }

package/e2e/adapters/adapter-google-chat-downtime.test.ts

@@ -0,0 +1,157 @@
+import { describe, it, expect, vi } from 'vitest';
+import {
+  getTRPCClient,
+  startGoogleChatIngestion,
+} from '../../src/adapter-google-chat/client.js';
+import {
+  readGoogleChatState,
+  updateGoogleChatState,
+} from '../../src/adapter-google-chat/state.js';
+import { getSocketPath } from '../../src/shared/workspace.js';
+import {
+  BASE_CONFIG,
+  findCreateByText,
+  makeDmMessage,
+  makeFakeChatApi,
+  makeQueuingFakeSubscription,
+  runForwarder,
+  useGoogleChatAdapterEnv,
+} from './_google-chat-fixtures.js';
+
+describe('Google Chat Adapter E2E — adapter downtime', () => {
+  const envRef = useGoogleChatAdapterEnv('e2e-google-chat-downtime');
+
+  it('processes Pub/Sub messages that arrived while inbound ingestion was down', async () => {
+    const { env } = envRef;
+    const trpc = getTRPCClient({ socketPath: getSocketPath(env.e2eDir) });
+    const subscription = makeQueuingFakeSubscription();
+    const { api } = makeFakeChatApi();
+
+    await updateGoogleChatState(
+      { channelChatMap: { 'spaces/dt-in': { chatId: 'gc-dt-in' } } },
+      env.e2eDir
+    );
+    await env.addChat('gc-dt-in');
+    const chat = await env.connect('gc-dt-in');
+
+    // First ingestion consumer. After it processes msg A we 'detach' it to
+    // simulate the adapter crashing, then emit B/C while nothing is listening.
+    startGoogleChatIngestion(
+      BASE_CONFIG,
+      trpc,
+      {},
+      { subscription, chatApi: api, startDir: env.e2eDir }
+    );
+
+    const msgA = makeDmMessage({ space: 'spaces/dt-in', messageId: 'a', text: 'msg A' });
+    subscription.emitMessage(msgA);
+
+    await chat.waitForMessage((m) => m.role === 'user' && m.content === 'msg A');
+    await vi.waitFor(() => expect(msgA.ack).toHaveBeenCalled());
+
+    // Simulate adapter downtime.
+    subscription.detach();
+
+    const msgB = makeDmMessage({ space: 'spaces/dt-in', messageId: 'b', text: 'msg B' });
+    const msgC = makeDmMessage({ space: 'spaces/dt-in', messageId: 'c', text: 'msg C' });
+    subscription.emitMessage(msgB);
+    subscription.emitMessage(msgC);
+
+    // While the adapter is down the messages are buffered (like Pub/Sub's
+    // unacked queue), not dropped.
+    expect(subscription.pendingCount()).toBe(2);
+    expect(msgB.ack).not.toHaveBeenCalled();
+    expect(msgC.ack).not.toHaveBeenCalled();
+
+    // A fresh ingestion consumer attaches — equivalent to restarting the
+    // adapter process. The buffered messages should replay and reach the
+    // daemon in order.
+    startGoogleChatIngestion(
+      BASE_CONFIG,
+      trpc,
+      {},
+      { subscription, chatApi: api, startDir: env.e2eDir }
+    );
+
+    await chat.waitForMessage((m) => m.role === 'user' && m.content === 'msg B');
+    await chat.waitForMessage((m) => m.role === 'user' && m.content === 'msg C');
+    await vi.waitFor(() => expect(msgB.ack).toHaveBeenCalled());
+    await vi.waitFor(() => expect(msgC.ack).toHaveBeenCalled());
+  }, 30000);
+
+  it('resumes outbound forwarding from lastSyncedMessageIds after a restart', async () => {
+    const { env } = envRef;
+    const trpc = getTRPCClient({ socketPath: getSocketPath(env.e2eDir) });
+    const { api, create } = makeFakeChatApi();
+
+    await updateGoogleChatState(
+      { channelChatMap: { 'spaces/dt-out': { chatId: 'gc-dt-out' } } },
+      env.e2eDir
+    );
+    await env.addChat('gc-dt-out');
+
+    // Scope the forwarder to just `gc-dt-out` so we don't also spin up a
+    // default-chat subscription that spams `getMessages` errors.
+    // The default agent echoes $CLAW_CLI_MESSAGE into an agent reply, so each
+    // env.sendMessage produces exactly one agent-reply create call when we
+    // leave filters at their default (agent-only) setting.
+    const config = { ...BASE_CONFIG, chatId: 'gc-dt-out' };
+
+    let cursorAfterMsg1 = '';
+
+    await runForwarder({ trpc, chatApi: api, startDir: env.e2eDir, config }, async () => {
+      // Send "msg 1" and wait for it to both land on the chat API and for the
+      // lastSyncedMessageIds cursor to advance. That's the durable proof that
+      // the state file we'll reopen from holds a real checkpoint.
+      await env.sendMessage('msg 1', { chat: 'gc-dt-out', noWait: true });
+      await vi.waitFor(
+        () => {
+          expect(findCreateByText(create, 'msg 1')).toBeDefined();
+        },
+        { timeout: 10000 }
+      );
+      await vi.waitFor(async () => {
+        const id = (await readGoogleChatState(env.e2eDir)).lastSyncedMessageIds?.['gc-dt-out'];
+        expect(id).toBeTruthy();
+      });
+      cursorAfterMsg1 = (await readGoogleChatState(env.e2eDir)).lastSyncedMessageIds![
+        'gc-dt-out'
+      ]!;
+    });
+
+    // Forwarder is now down. Daemon continues to receive messages — these are
+    // the ones that would arrive at the forwarder if it were still online.
+    await env.sendMessage('msg 2', { chat: 'gc-dt-out', noWait: true });
+    await env.sendMessage('msg 3', { chat: 'gc-dt-out', noWait: true });
+
+    // Nothing should have been posted to Google Chat while the forwarder was
+    // down.
+    expect(findCreateByText(create, 'msg 2')).toBeUndefined();
+    expect(findCreateByText(create, 'msg 3')).toBeUndefined();
+
+    // Restart the forwarder with the same startDir — so it reads back
+    // lastSyncedMessageIds and resumes.
+    await runForwarder({ trpc, chatApi: api, startDir: env.e2eDir, config }, async () => {
+      await vi.waitFor(
+        () => {
+          expect(findCreateByText(create, 'msg 2')).toBeDefined();
+          expect(findCreateByText(create, 'msg 3')).toBeDefined();
+        },
+        { timeout: 15000 }
+      );
+
+      // And the cursor should have advanced past the restart-point.
+      await vi.waitFor(async () => {
+        const now = (await readGoogleChatState(env.e2eDir)).lastSyncedMessageIds?.['gc-dt-out'];
+        expect(now).toBeDefined();
+        expect(now).not.toBe(cursorAfterMsg1);
+      });
+
+      // msg 1 must not be re-posted by the resumed forwarder.
+      const msg1Calls = create.mock.calls.filter(
+        ([params]) => params.requestBody.text === 'msg 1'
+      );
+      expect(msg1Calls.length).toBe(1);
+    });
+  }, 45000);
+});