gogcli-mcp 2.25.0 → 2.27.0

package/tests/tools/appscript.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { registerAppScriptTools } from '../../src/tools/appscript.js';
+import * as runner from '../../src/runner.js';
+import { createTestHarness } from '@chrischall/mcp-utils/test';
+
+vi.mock('../../src/runner.js');
+
+const setupHandlers = () => createTestHarness(registerAppScriptTools);
+
+beforeEach(() => vi.clearAllMocks());
+
+describe('gog_appscript_get', () => {
+  it('gets project metadata', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_get', { scriptId: 'S1' });
+    expect(runner.run).toHaveBeenCalledWith(['appscript', 'get', 'S1'], { account: undefined });
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(runner.run).mockRejectedValue(new Error('Get failed'));
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_appscript_get', { scriptId: 'S1' });
+    expect(result.content[0].text).toBe('Error: Get failed');
+  });
+});
+
+describe('gog_appscript_content', () => {
+  it('reads the project source', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_content', { scriptId: 'S1', account: 'me@x.com' });
+    expect(runner.run).toHaveBeenCalledWith(['appscript', 'content', 'S1'], { account: 'me@x.com' });
+  });
+});
+
+describe('gog_appscript_pull', () => {
+  it('pulls into a directory', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_pull', { scriptId: 'S1', dir: '/tmp/proj' });
+    expect(runner.run).toHaveBeenCalledWith(['appscript', 'pull', 'S1', '/tmp/proj'], { account: undefined });
+  });
+
+  it('passes --overwrite', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_pull', { scriptId: 'S1', dir: '/tmp/proj', overwrite: true });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['appscript', 'pull', 'S1', '/tmp/proj', '--overwrite'],
+      { account: undefined },
+    );
+  });
+
+  // The directory resolves where gog runs, which is a different machine on the
+  // hosted connector. A caller who does not know that gets a "success" whose
+  // files they cannot reach.
+  it('says in its description where the directory resolves', async () => {
+    const { McpServer } = await import('@modelcontextprotocol/sdk/server/mcp.js');
+    const server = new McpServer({ name: 'test', version: '0.0.0' });
+    const configs = new Map<string, { description?: string }>();
+    vi.spyOn(server, 'registerTool').mockImplementation((name, config) => {
+      configs.set(name, config as { description?: string });
+      return undefined as never;
+    });
+    registerAppScriptTools(server);
+    const desc = configs.get('gog_appscript_pull')?.description ?? '';
+    expect(desc).toContain('RESOLVED WHERE GOG RUNS');
+    expect(desc).toMatch(/gog_appscript_content/);
+  });
+});
+
+describe('gog_appscript_create', () => {
+  it('creates a standalone project', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_create', { title: 'Helpers' });
+    expect(runner.run).toHaveBeenCalledWith(['appscript', 'create', '--title=Helpers'], { account: undefined });
+  });
+
+  it('binds the project to a Drive file', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_create', { title: 'Bound', parentId: 'FILE1' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['appscript', 'create', '--title=Bound', '--parent-id=FILE1'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_appscript_deployments', () => {
+  it('lists deployments with pagination', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_deployments', { scriptId: 'S1', max: 10, pageToken: 'tok' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['appscript', 'deployments', 'S1', '--max=10', '--page=tok'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_appscript_versions', () => {
+  it('lists versions', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_versions', { scriptId: 'S1', all: true });
+    expect(runner.run).toHaveBeenCalledWith(['appscript', 'versions', 'S1', '--all'], { account: undefined });
+  });
+});
+
+describe('gog_appscript_run_function', () => {
+  it('runs a deployed function', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_run_function', { scriptId: 'S1', functionName: 'doWork' });
+    expect(runner.run).toHaveBeenCalledWith(['appscript', 'run', 'S1', 'doWork'], { account: undefined });
+  });
+
+  it('passes params and --dev-mode', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_run_function', {
+      scriptId: 'S1', functionName: 'doWork', params: '["a",1]', devMode: true,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['appscript', 'run', 'S1', 'doWork', '--params=["a",1]', '--dev-mode'],
+      { account: undefined },
+    );
+  });
+
+  it('rejects params that are not a JSON array before spawning gog', async () => {
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_appscript_run_function', {
+      scriptId: 'S1', functionName: 'doWork', params: '{"a":1}',
+    });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+
+  it('rejects params that are not JSON at all', async () => {
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_appscript_run_function', {
+      scriptId: 'S1', functionName: 'doWork', params: 'a,1',
+    });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+});
+
+describe('gog_appscript_run', () => {
+  it('passes the subcommand and args through', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_appscript_run', { subcommand: 'get', args: ['S1'] });
+    expect(runner.run).toHaveBeenCalledWith(['appscript', 'get', 'S1'], { account: undefined });
+  });
+});

package/tests/tools/calendar.test.ts

@@ -457,3 +457,124 @@ describe('gog_calendar_events — pagination (previously absent entirely)', () =
     expect(out).not.toHaveProperty('nextPageToken');
   });
 });
+
+// Reminders (gog >= 0.38.0 for --no-reminders, openclaw/gogcli#1002/#1016).
+// Three distinct states share these two params and gog spells each one
+// differently, so each is pinned separately: custom overrides, "no reminders at
+// all", and — on update only — "go back to whatever the calendar says", which
+// is an EMPTY --reminder rather than a flag of its own. All three were verified
+// against a real gog 0.38.0 with --dry-run.
+describe('gog_calendar_create reminders', () => {
+  it('passes each reminder as its own repeated flag', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_calendar_create', {
+      calendarId: 'primary',
+      summary: 'Standup',
+      from: '2026-04-14T09:00:00Z',
+      to: '2026-04-14T09:30:00Z',
+      reminders: ['popup:30m', 'email:1d'],
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'create', 'primary', '--summary=Standup', '--from=2026-04-14T09:00:00Z', '--to=2026-04-14T09:30:00Z',
+        '--reminder=popup:30m', '--reminder=email:1d'],
+      { account: undefined },
+    );
+  });
+
+  it('passes --no-reminders', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_calendar_create', {
+      calendarId: 'primary',
+      summary: 'Quiet',
+      from: '2026-04-14T09:00:00Z',
+      to: '2026-04-14T09:30:00Z',
+      noReminders: true,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'create', 'primary', '--summary=Quiet', '--from=2026-04-14T09:00:00Z', '--to=2026-04-14T09:30:00Z',
+        '--no-reminders'],
+      { account: undefined },
+    );
+  });
+
+  it('rejects reminders and noReminders together, as gog does', async () => {
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_calendar_create', {
+      calendarId: 'primary',
+      summary: 'Both',
+      from: '2026-04-14T09:00:00Z',
+      to: '2026-04-14T09:30:00Z',
+      reminders: ['popup:10m'],
+      noReminders: true,
+    });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+
+  it('rejects more than the five reminders Google allows', async () => {
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_calendar_create', {
+      calendarId: 'primary',
+      summary: 'Too many',
+      from: '2026-04-14T09:00:00Z',
+      to: '2026-04-14T09:30:00Z',
+      reminders: ['popup:1m', 'popup:2m', 'popup:3m', 'popup:4m', 'popup:5m', 'popup:6m'],
+    });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+});
+
+describe('gog_calendar_update reminders', () => {
+  it('replaces the overrides', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_calendar_update', {
+      calendarId: 'primary', eventId: 'evt1', reminders: ['popup:15m'],
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'update', 'primary', 'evt1', '--reminder=popup:15m'],
+      { account: undefined },
+    );
+  });
+
+  // Verified live: `calendar update … --reminder= --dry-run` patches
+  // reminders.useDefault=true with overrides cleared.
+  it('restores the calendar defaults with an empty reminder list', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_calendar_update', {
+      calendarId: 'primary', eventId: 'evt1', reminders: [],
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'update', 'primary', 'evt1', '--reminder='],
+      { account: undefined },
+    );
+  });
+
+  it('turns every reminder off', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_calendar_update', {
+      calendarId: 'primary', eventId: 'evt1', noReminders: true,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'update', 'primary', 'evt1', '--no-reminders'],
+      { account: undefined },
+    );
+  });
+
+  it('leaves reminders alone when neither param is given', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_calendar_update', {
+      calendarId: 'primary', eventId: 'evt1', summary: 'Renamed',
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['calendar', 'update', 'primary', 'evt1', '--summary=Renamed'],
+      { account: undefined },
+    );
+  });
+});

package/tests/tools/chat.test.ts

@@ -0,0 +1,284 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { registerChatTools } from '../../src/tools/chat.js';
+import * as runner from '../../src/runner.js';
+import { createTestHarness } from '@chrischall/mcp-utils/test';
+
+vi.mock('../../src/runner.js');
+
+const setupHandlers = () => createTestHarness(registerChatTools);
+
+beforeEach(() => vi.clearAllMocks());
+
+describe('gog_chat_spaces_list', () => {
+  it('lists spaces', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"spaces":[]}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_spaces_list', {});
+    expect(runner.run).toHaveBeenCalledWith(['chat', 'spaces', 'list'], { account: undefined });
+  });
+
+  it('passes pagination flags', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"spaces":[]}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_spaces_list', { max: 20, pageToken: 'tok', all: true });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'spaces', 'list', '--max=20', '--page=tok', '--all'],
+      { account: undefined },
+    );
+  });
+
+  it('returns error text on failure', async () => {
+    vi.mocked(runner.run).mockRejectedValue(new Error('Spaces failed'));
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_chat_spaces_list', {});
+    expect(result.content[0].text).toBe('Error: Spaces failed');
+  });
+
+  // The constraint is the ACCOUNT, not the token, so it has to be in the
+  // description a model reads — a source comment would not reach it. Every chat
+  // tool carries the note, because any of them can be the first one called.
+  it('warns in EVERY description that Chat is Workspace-only', async () => {
+    const { McpServer } = await import('@modelcontextprotocol/sdk/server/mcp.js');
+    const server = new McpServer({ name: 'test', version: '0.0.0' });
+    const configs = new Map<string, { description?: string }>();
+    vi.spyOn(server, 'registerTool').mockImplementation((name, config) => {
+      configs.set(name, config as { description?: string });
+      return undefined as never;
+    });
+    registerChatTools(server);
+    expect(configs.size).toBe(12);
+    for (const [name, config] of configs) {
+      expect(config.description, name).toMatch(/consumer accounts|Workspace/i);
+    }
+  });
+});
+
+describe('gog_chat_spaces_find', () => {
+  it('searches by display name', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_spaces_find', { displayName: 'Team' });
+    expect(runner.run).toHaveBeenCalledWith(['chat', 'spaces', 'find', 'Team'], { account: undefined });
+  });
+
+  it('passes --exact and --max', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_spaces_find', { displayName: 'Team', exact: true, max: 5 });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'spaces', 'find', 'Team', '--exact', '--max=5'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_chat_spaces_create', () => {
+  it('creates a space with members', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_spaces_create', { displayName: 'Launch', members: ['a@b.com', 'c@d.com'] });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'spaces', 'create', 'Launch', '--member=a@b.com', '--member=c@d.com'],
+      { account: undefined },
+    );
+  });
+
+  it('creates an empty space', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_spaces_create', { displayName: 'Solo' });
+    expect(runner.run).toHaveBeenCalledWith(['chat', 'spaces', 'create', 'Solo'], { account: undefined });
+  });
+});
+
+describe('gog_chat_threads_list', () => {
+  it('lists threads in a space', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_threads_list', { space: 'spaces/AAA', max: 10 });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'threads', 'list', 'spaces/AAA', '--max=10'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_chat_messages_list', () => {
+  it('lists messages in a space', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_messages_list', { space: 'spaces/AAA' });
+    expect(runner.run).toHaveBeenCalledWith(['chat', 'messages', 'list', 'spaces/AAA'], { account: undefined });
+  });
+
+  it('filters by thread, unread and order', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_messages_list', {
+      space: 'spaces/AAA', thread: 'spaces/AAA/threads/T', unread: true, order: 'createTime desc', max: 50,
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'messages', 'list', 'spaces/AAA', '--thread=spaces/AAA/threads/T', '--unread',
+        '--order=createTime desc', '--max=50'],
+      { account: undefined },
+    );
+  });
+
+  it('rejects a sort order Chat does not accept', async () => {
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_chat_messages_list', { space: 'spaces/AAA', order: 'newest' });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+});
+
+describe('gog_chat_messages_send', () => {
+  it('sends text to a space', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_messages_send', { space: 'spaces/AAA', text: 'hi' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'messages', 'send', 'spaces/AAA', '--text=hi'],
+      { account: undefined },
+    );
+  });
+
+  it('replies in a thread and attaches a server-side path', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_messages_send', {
+      space: 'spaces/AAA', text: 'see this', thread: 'spaces/AAA/threads/T', attach: ['/tmp/a.png'],
+    });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'messages', 'send', 'spaces/AAA', '--text=see this', '--thread=spaces/AAA/threads/T', '--attach=/tmp/a.png'],
+      { account: undefined },
+    );
+  });
+
+  it('carries caller-side bytes as a file arg', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_messages_send', {
+      space: 'spaces/AAA',
+      text: 'chart',
+      attachInline: [{ filename: 'chart.png', contentBase64: Buffer.from('png').toString('base64') }],
+    });
+    const args = vi.mocked(runner.run).mock.calls[0][0];
+    expect(args).toContainEqual(expect.objectContaining({
+      kind: 'file', flag: 'attach', filename: 'chart.png', encoding: 'base64',
+    }));
+  });
+
+  it('sends an attachment with no text at all', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_messages_send', { space: 'spaces/AAA', attach: ['/tmp/a.png'] });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'messages', 'send', 'spaces/AAA', '--attach=/tmp/a.png'],
+      { account: undefined },
+    );
+  });
+
+  it('refuses a message with neither text nor an attachment', async () => {
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_chat_messages_send', { space: 'spaces/AAA' });
+    expect(result.isError).toBe(true);
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+});
+
+describe('gog_chat_dm_send', () => {
+  it('sends a direct message by email', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_dm_send', { email: 'a@b.com', text: 'hi' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'dm', 'send', 'a@b.com', '--text=hi'],
+      { account: undefined },
+    );
+  });
+
+  it('replies in an existing DM thread', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_dm_send', { email: 'a@b.com', text: 'hi', thread: 'spaces/D/threads/T' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'dm', 'send', 'a@b.com', '--text=hi', '--thread=spaces/D/threads/T'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_chat_dm_space', () => {
+  it('resolves the DM space for an address', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_dm_space', { email: 'a@b.com' });
+    expect(runner.run).toHaveBeenCalledWith(['chat', 'dm', 'space', 'a@b.com'], { account: undefined });
+  });
+});
+
+describe('gog_chat_reactions_list', () => {
+  it('lists reactions, qualifying a bare message ID with its space', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_reactions_list', { message: 'MSG', space: 'spaces/AAA', max: 10 });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'messages', 'reactions', 'list', 'MSG', '--space=spaces/AAA', '--max=10'],
+      { account: undefined },
+    );
+  });
+
+  it('omits --space when the message is already fully qualified', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_reactions_list', { message: 'spaces/AAA/messages/M' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'messages', 'reactions', 'list', 'spaces/AAA/messages/M'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_chat_reactions_create', () => {
+  it('adds an emoji reaction', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_reactions_create', { message: 'spaces/AAA/messages/M', emoji: '👍' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'messages', 'reactions', 'create', 'spaces/AAA/messages/M', '👍'],
+      { account: undefined },
+    );
+  });
+
+  it('passes --space for a bare message ID', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_reactions_create', { message: 'M', emoji: '👍', space: 'spaces/AAA' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'messages', 'reactions', 'create', 'M', '👍', '--space=spaces/AAA'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_chat_reactions_delete', () => {
+  it('deletes a reaction by resource name', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_reactions_delete', { reaction: 'spaces/AAA/messages/M/reactions/R' });
+    expect(runner.run).toHaveBeenCalledWith(
+      ['chat', 'messages', 'reactions', 'delete', 'spaces/AAA/messages/M/reactions/R'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_chat_run', () => {
+  it('passes the subcommand and args through', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{}');
+    const harness = await setupHandlers();
+    await harness.callTool('gog_chat_run', { subcommand: 'spaces', args: ['list'] });
+    expect(runner.run).toHaveBeenCalledWith(['chat', 'spaces', 'list'], { account: undefined });
+  });
+});