gogcli-mcp 1.0.4 → 1.0.6

package/docs/superpowers/plans/2026-04-13-browser-auth.md

@@ -1,450 +0,0 @@
-# Browser-Based Auth Flow Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Add a `gog_auth_add` MCP tool that opens the user's browser for Google OAuth and blocks until completion.
-
-**Architecture:** Extend `RunOptions` with `interactive` and `timeout` fields. Add a dedicated `gog_auth_add` tool that uses these options to run the blocking browser auth flow. Existing runner behavior is unchanged for all other tools.
-
-**Tech Stack:** TypeScript, vitest, zod, @modelcontextprotocol/sdk
-
----
-
-### Task 1: Runner — add `interactive` option (skip `--no-input`)
-
-**Files:**
-- Modify: `src/runner.ts:4-5` (RunOptions interface)
-- Modify: `src/runner.ts:17-22` (run function)
-- Test: `tests/runner.test.ts`
-
-- [ ] **Step 1: Write the failing test for `interactive: true` omitting `--no-input`**
-
-Add to `tests/runner.test.ts` inside the existing `describe('run', ...)`:
-
-```ts
-it('omits --no-input when interactive is true', async () => {
-  const spawner = makeSpawner(0, '{"ok":true}');
-  await run(['auth', 'add', 'user@gmail.com'], { spawner, interactive: true });
-  const callArgs = (spawner as ReturnType<typeof vi.fn>).mock.calls[0][1] as string[];
-  expect(callArgs).toContain('--json');
-  expect(callArgs).toContain('--color=never');
-  expect(callArgs).not.toContain('--no-input');
-  expect(callArgs).toContain('auth');
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `npm test -- --reporter=verbose -t "omits --no-input when interactive is true"`
-Expected: FAIL — `interactive` is not a recognized option yet, `--no-input` is still present.
-
-- [ ] **Step 3: Write the regression test for default (non-interactive) still including `--no-input`**
-
-Add to `tests/runner.test.ts`:
-
-```ts
-it('includes --no-input when interactive is not set', async () => {
-  const spawner = makeSpawner(0, '{"ok":true}');
-  await run(['sheets', 'get', 'id1', 'A1'], { spawner });
-  const callArgs = (spawner as ReturnType<typeof vi.fn>).mock.calls[0][1] as string[];
-  expect(callArgs).toContain('--no-input');
-});
-```
-
-- [ ] **Step 4: Implement `interactive` in runner**
-
-In `src/runner.ts`, update `RunOptions`:
-
-```ts
-export interface RunOptions {
-  account?: string;
-  spawner?: Spawner;
-  interactive?: boolean;
-  timeout?: number;
-}
-```
-
-In the `run()` function, change the `fullArgs` construction:
-
-```ts
-const { account, spawner = spawn as unknown as Spawner, interactive = false, timeout } = options;
-
-const effectiveAccount = account ?? process.env.GOG_ACCOUNT;
-
-const fullArgs = ['--json', '--color=never'];
-if (!interactive) {
-  fullArgs.push('--no-input');
-}
-```
-
-- [ ] **Step 5: Run tests to verify both pass**
-
-Run: `npm test -- --reporter=verbose`
-Expected: Both new tests PASS, all existing tests PASS.
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add src/runner.ts tests/runner.test.ts
-git commit -m "feat(runner): add interactive option to skip --no-input"
-```
-
----
-
-### Task 2: Runner — add custom `timeout` option
-
-**Files:**
-- Modify: `src/runner.ts:17-18` (run function, timeout handling)
-- Test: `tests/runner.test.ts`
-
-- [ ] **Step 1: Write the failing test for custom timeout**
-
-Add to `tests/runner.test.ts`:
-
-```ts
-it('uses custom timeout when provided', async () => {
-  vi.useFakeTimers();
-  const spawner = vi.fn(() => {
-    const proc = new EventEmitter() as ReturnType<Spawner>;
-    (proc as unknown as { stdout: EventEmitter; stderr: EventEmitter }).stdout = new EventEmitter();
-    (proc as unknown as { stdout: EventEmitter; stderr: EventEmitter }).stderr = new EventEmitter();
-    proc.kill = vi.fn();
-    return proc;
-  }) as unknown as Spawner;
-
-  const promise = run(['auth', 'add', 'user@gmail.com'], { spawner, timeout: 300_000 });
-  // Should NOT have timed out at 30s
-  vi.advanceTimersByTime(30_000);
-  // Advance to custom timeout
-  vi.advanceTimersByTime(270_000);
-  await expect(promise).rejects.toThrow('gog timed out after 300000ms (5 minutes)');
-  vi.useRealTimers();
-});
-```
-
-- [ ] **Step 2: Write test that default timeout still works**
-
-Add to `tests/runner.test.ts`:
-
-```ts
-it('includes human-readable duration in timeout error for default timeout', async () => {
-  vi.useFakeTimers();
-  const spawner = vi.fn(() => {
-    const proc = new EventEmitter() as ReturnType<Spawner>;
-    (proc as unknown as { stdout: EventEmitter; stderr: EventEmitter }).stdout = new EventEmitter();
-    (proc as unknown as { stdout: EventEmitter; stderr: EventEmitter }).stderr = new EventEmitter();
-    proc.kill = vi.fn();
-    return proc;
-  }) as unknown as Spawner;
-
-  const promise = run(['sheets', 'get', 'id', 'A1'], { spawner });
-  vi.advanceTimersByTime(30_000);
-  await expect(promise).rejects.toThrow('gog timed out after 30000ms');
-  vi.useRealTimers();
-});
-```
-
-- [ ] **Step 3: Run tests to verify they fail**
-
-Run: `npm test -- --reporter=verbose`
-Expected: Custom timeout test FAIL (times out at 30s instead of 300s). Default timeout message test may also fail if message format changed.
-
-- [ ] **Step 4: Implement custom timeout in runner**
-
-In `src/runner.ts`, update the `run()` function:
-
-```ts
-const effectiveTimeout = timeout ?? TIMEOUT_MS;
-
-// Helper for human-readable duration
-function formatTimeout(ms: number): string {
-  const seconds = Math.round(ms / 1000);
-  if (seconds >= 60) {
-    const minutes = Math.round(seconds / 60);
-    return `${ms}ms (${minutes} minute${minutes !== 1 ? 's' : ''})`;
-  }
-  return `${ms}ms`;
-}
-
-const timer = setTimeout(() => {
-  settled = true;
-  child.kill();
-  reject(new Error(`gog timed out after ${formatTimeout(effectiveTimeout)}`));
-}, effectiveTimeout);
-```
-
-Note: `formatTimeout` should be defined inside `run()` or as a module-level helper. Since it's small, define it at module level above the `run` function.
-
-- [ ] **Step 5: Run tests to verify they pass**
-
-Run: `npm test -- --reporter=verbose`
-Expected: All tests PASS.
-
-- [ ] **Step 6: Verify existing timeout test still passes**
-
-The existing test `'rejects with timeout error when gog does not respond'` uses `.toThrow('gog timed out after 30000ms')` which is a substring match. The new message `"gog timed out after 30000ms"` still contains this substring (30s doesn't reach the 60s threshold for the minutes suffix). Verify it passes with no changes needed.
-
-Run: `npm test -- --reporter=verbose -t "does not respond"`
-Expected: PASS with no changes.
-
-- [ ] **Step 7: Run full test suite**
-
-Run: `npm test -- --reporter=verbose`
-Expected: All tests PASS.
-
-- [ ] **Step 8: Commit**
-
-```bash
-git add src/runner.ts tests/runner.test.ts
-git commit -m "feat(runner): add custom timeout option with human-readable error"
-```
-
----
-
-### Task 3: Runner — append stderr on interactive success
-
-**Files:**
-- Modify: `src/runner.ts` (close handler)
-- Test: `tests/runner.test.ts`
-
-- [ ] **Step 1: Write the failing test for stderr appended on interactive success**
-
-Add to `tests/runner.test.ts`:
-
-```ts
-it('appends stderr to stdout on success when interactive is true', async () => {
-  const spawner = vi.fn(() => {
-    const proc = new EventEmitter() as ReturnType<Spawner>;
-    (proc as unknown as { stdout: EventEmitter; stderr: EventEmitter }).stdout = new EventEmitter();
-    (proc as unknown as { stdout: EventEmitter; stderr: EventEmitter }).stderr = new EventEmitter();
-    setTimeout(() => {
-      (proc as unknown as { stdout: EventEmitter }).stdout.emit('data', Buffer.from('{"success":true}'));
-      (proc as unknown as { stderr: EventEmitter }).stderr.emit('data', Buffer.from('Opening browser...\nIf the browser doesn\'t open, visit this URL:\nhttps://accounts.google.com/auth?...'));
-      proc.emit('close', 0);
-    }, 0);
-    return proc;
-  }) as unknown as Spawner;
-
-  const result = await run(['auth', 'add', 'user@gmail.com'], { spawner, interactive: true });
-  expect(result).toContain('{"success":true}');
-  expect(result).toContain('Opening browser...');
-  expect(result).toContain('https://accounts.google.com/auth?...');
-});
-```
-
-- [ ] **Step 2: Write test that non-interactive success does NOT include stderr**
-
-Add to `tests/runner.test.ts`:
-
-```ts
-it('does not append stderr to stdout on success when interactive is false', async () => {
-  const spawner = vi.fn(() => {
-    const proc = new EventEmitter() as ReturnType<Spawner>;
-    (proc as unknown as { stdout: EventEmitter; stderr: EventEmitter }).stdout = new EventEmitter();
-    (proc as unknown as { stdout: EventEmitter; stderr: EventEmitter }).stderr = new EventEmitter();
-    setTimeout(() => {
-      (proc as unknown as { stdout: EventEmitter }).stdout.emit('data', Buffer.from('{"ok":true}'));
-      (proc as unknown as { stderr: EventEmitter }).stderr.emit('data', Buffer.from('some warning'));
-      proc.emit('close', 0);
-    }, 0);
-    return proc;
-  }) as unknown as Spawner;
-
-  const result = await run(['sheets', 'get', 'id', 'A1'], { spawner });
-  expect(result).toBe('{"ok":true}');
-  expect(result).not.toContain('some warning');
-});
-```
-
-- [ ] **Step 3: Run tests to verify they fail**
-
-Run: `npm test -- --reporter=verbose`
-Expected: Interactive stderr test FAIL (stderr not included in result).
-
-- [ ] **Step 4: Implement stderr append for interactive mode**
-
-In `src/runner.ts`, update the close handler:
-
-```ts
-child.on('close', (code: number | null) => {
-  clearTimeout(timer);
-  if (settled) return;
-  settled = true;
-  if (code === 0) {
-    if (interactive && stderr.trim()) {
-      resolve(stdout + '\n' + stderr);
-    } else {
-      resolve(stdout);
-    }
-  } else {
-    reject(new Error(stderr.trim() || `gog exited with code ${code}`));
-  }
-});
-```
-
-- [ ] **Step 5: Run tests to verify they pass**
-
-Run: `npm test -- --reporter=verbose`
-Expected: All tests PASS.
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add src/runner.ts tests/runner.test.ts
-git commit -m "feat(runner): append stderr on interactive success for fallback URL"
-```
-
----
-
-### Task 4: Auth tool — add `gog_auth_add`
-
-**Files:**
-- Modify: `src/tools/auth.ts:6-56` (add new tool, update `gog_auth_run` description)
-- Test: `tests/tools/auth.test.ts`
-
-- [ ] **Step 1: Write the failing test for `gog_auth_add` with default services**
-
-Add to `tests/tools/auth.test.ts`:
-
-```ts
-describe('gog_auth_add', () => {
-  it('calls run with correct args, interactive true, and 5-minute timeout', async () => {
-    vi.mocked(runner.run).mockResolvedValue('Authorization successful for user@gmail.com');
-    const handlers = setupHandlers();
-    const result = await handlers.get('gog_auth_add')!({ email: 'user@gmail.com' });
-    expect(runner.run).toHaveBeenCalledWith(
-      ['auth', 'add', 'user@gmail.com', '--services', 'all'],
-      { interactive: true, timeout: 300_000 },
-    );
-    expect(result.content[0].text).toBe('Authorization successful for user@gmail.com');
-  });
-});
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `npm test -- --reporter=verbose -t "gog_auth_add"`
-Expected: FAIL — handler `gog_auth_add` does not exist.
-
-- [ ] **Step 3: Write additional tests for `gog_auth_add`**
-
-Add inside the `describe('gog_auth_add', ...)`:
-
-```ts
-it('passes custom services when provided', async () => {
-  vi.mocked(runner.run).mockResolvedValue('Authorization successful');
-  const handlers = setupHandlers();
-  await handlers.get('gog_auth_add')!({ email: 'user@gmail.com', services: 'sheets,gmail' });
-  expect(runner.run).toHaveBeenCalledWith(
-    ['auth', 'add', 'user@gmail.com', '--services', 'sheets,gmail'],
-    { interactive: true, timeout: 300_000 },
-  );
-});
-
-it('returns error text on failure', async () => {
-  vi.mocked(runner.run).mockRejectedValue(new Error('Auth cancelled by user'));
-  const handlers = setupHandlers();
-  const result = await handlers.get('gog_auth_add')!({ email: 'user@gmail.com' });
-  expect(result.content[0].text).toBe('Error: Auth cancelled by user');
-});
-
-it('returns error text on timeout', async () => {
-  vi.mocked(runner.run).mockRejectedValue(new Error('gog timed out after 300000ms (5 minutes)'));
-  const handlers = setupHandlers();
-  const result = await handlers.get('gog_auth_add')!({ email: 'user@gmail.com' });
-  expect(result.content[0].text).toContain('timed out');
-  expect(result.content[0].text).toContain('5 minutes');
-});
-```
-
-- [ ] **Step 4: Implement `gog_auth_add` tool**
-
-Add to `src/tools/auth.ts`, before the `gog_auth_run` registration:
-
-```ts
-server.registerTool('gog_auth_add', {
-  description:
-    'Authorize a Google account via browser-based OAuth. ' +
-    'Opens a browser window where the user must sign in and grant access. ' +
-    'Blocks for up to 5 minutes waiting for the user to complete authorization. ' +
-    'If the browser does not open automatically, a fallback URL is included in the response. ' +
-    'Use gog_auth_list to check which accounts are already configured.',
-  annotations: { destructiveHint: true },
-  inputSchema: {
-    email: z.string().describe('Google account email to authorize'),
-    services: z.string().optional().default('all').describe(
-      'Services to authorize: "all" or comma-separated list (e.g. "sheets,gmail,calendar"). Default: "all"',
-    ),
-  },
-}, async ({ email, services }) => {
-  try {
-    return toText(await run(['auth', 'add', email, '--services', services], {
-      interactive: true,
-      timeout: 300_000,
-    }));
-  } catch (err) {
-    return toError(err);
-  }
-});
-```
-
-- [ ] **Step 5: Update `gog_auth_run` description**
-
-Change the `gog_auth_run` description from:
-
-```ts
-description: 'Run any gog auth subcommand. Run `gog auth --help` to see all available subcommands and flags. Note: gog auth add requires interactive browser auth and cannot be completed over MCP — run it in your terminal instead: gog auth add <email> --services <service>',
-```
-
-to:
-
-```ts
-description: 'Run any gog auth subcommand. Run `gog auth --help` to see all available subcommands and flags. Note: for browser-based authorization, use gog_auth_add instead.',
-```
-
-- [ ] **Step 6: Run all tests**
-
-Run: `npm test -- --reporter=verbose`
-Expected: All tests PASS.
-
-- [ ] **Step 7: Commit**
-
-```bash
-git add src/tools/auth.ts tests/tools/auth.test.ts
-git commit -m "feat(auth): add gog_auth_add tool for browser-based OAuth"
-```
-
----
-
-### Task 5: Manifest update
-
-**Files:**
-- Modify: `manifest.json`
-
-- [ ] **Step 1: Add `gog_auth_add` to manifest tools list**
-
-Add a new entry in the `tools` array in `manifest.json`, after the existing `gog_auth_list` entry:
-
-```json
-{
-  "name": "gog_auth_add",
-  "description": "Authorize a Google account via browser-based OAuth"
-},
-```
-
-- [ ] **Step 2: Run build to verify no issues**
-
-Run: `npm run build`
-Expected: Build succeeds.
-
-- [ ] **Step 3: Run full test suite**
-
-Run: `npm test -- --reporter=verbose`
-Expected: All tests PASS.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add manifest.json
-git commit -m "chore(manifest): add gog_auth_add tool"
-```

package/docs/superpowers/specs/2026-04-12-gogcli-mcp-design.md

@@ -1,102 +0,0 @@
-# gogcli-mcp Design Spec
-
-**Date:** 2026-04-12
-**Status:** Approved
-
-## Overview
-
-An MCP server that wraps the `gog` CLI (gogcli), exposing Google service operations as typed MCP tools. Sheets is implemented first; the architecture is scaffolded for easy addition of other services (Gmail, Calendar, Drive, etc.).
-
-## Architecture
-
-### Project Structure
-
-```
-gogcli-mcp/
-├── src/
-│   ├── index.ts          — MCP server entry point; registers all service tools
-│   ├── runner.ts         — Core executor: spawns gog, handles auth & errors
-│   └── tools/
-│       └── sheets.ts     — Sheets curated tools + escape hatch
-├── package.json
-├── tsconfig.json
-└── .mcp.json             — MCP server config for Claude Code
-```
-
-### Key Principle
-
-No service tool file touches `child_process` directly. All execution goes through `runner.ts`. Adding a new service means creating `src/tools/<service>.ts` and registering it in `index.ts`.
-
-## Components
-
-### `runner.ts`
-
-Exports a single `run(service, subcommand, args, options)` function:
-
-- Prepends global flags: `--json`, `--no-input`, `--color=never`
-- Injects `--account <email>` from `options.account` → `GOG_ACCOUNT` env var → omit
-- Spawns `gog` as a child process, capturing stdout and stderr separately
-- On exit code 0: returns parsed JSON (or raw stdout if not valid JSON)
-- On non-zero exit: throws an error with stderr content as the message (gogcli stderr is human-readable)
-
-### `src/tools/sheets.ts`
-
-Exports `registerSheetsTools(server: McpServer)`. Implements:
-
-| Tool | gog command | Notes |
-|------|-------------|-------|
-| `gog_sheets_get` | `gog sheets get <id> <range>` | Read-only hint |
-| `gog_sheets_update` | `gog sheets update <id> <range> <values>` | Values as JSON array of arrays |
-| `gog_sheets_append` | `gog sheets append <id> <range> <values>` | Values as JSON array of arrays |
-| `gog_sheets_clear` | `gog sheets clear <id> <range>` | Destructive hint |
-| `gog_sheets_metadata` | `gog sheets metadata <id>` | Returns tabs, named ranges, etc. |
-| `gog_sheets_create` | `gog sheets create <title>` | Returns new spreadsheet ID |
-| `gog_sheets_find_replace` | `gog sheets find-replace <id> <find> <replace>` | |
-| `gog_sheets_run` | `gog sheets <subcommand> [args...]` | Escape hatch for any other sheets op |
-
-All tools accept an optional `account` string parameter to override the default account.
-
-### `src/index.ts`
-
-Creates the `McpServer`, calls `registerSheetsTools(server)` (and future service registrations), connects via `StdioServerTransport`.
-
-### `.mcp.json`
-
-Documents `GOG_ACCOUNT` as the environment variable for the default Google account. Used by Claude Code to configure the server.
-
-## Auth Flow
-
-Account resolution order (most specific wins):
-
-1. Tool-level `account` parameter (per-call override)
-2. `GOG_ACCOUNT` environment variable (session default)
-3. No `--account` flag (gogcli uses its own configured default)
-
-## Error Handling
-
-- Runner captures stdout and stderr as separate streams
-- Non-zero exit: throw `Error(stderr)` — gogcli error messages are already user-readable
-- The MCP tool catches the error and returns it as text content so the model sees it
-
-## Testing
-
-- **Unit tests** (vitest): mock `child_process.spawn` to assert correct argument construction for each tool without executing gogcli
-- **No integration tests**: real-world validation is done by running the server against live gogcli
-
-## Adding Future Services
-
-To add a new service (e.g., Gmail):
-
-1. Create `src/tools/gmail.ts` with `registerGmailTools(server)`
-2. Implement curated tools for common operations + a `gog_gmail_run` escape hatch
-3. Import and call `registerGmailTools(server)` in `src/index.ts`
-4. No changes to `runner.ts` required
-
-## Stack
-
-- **Language:** TypeScript (ES2022, NodeNext modules)
-- **MCP SDK:** `@modelcontextprotocol/sdk`
-- **Schema validation:** Zod
-- **Build:** esbuild (single bundled output)
-- **Tests:** vitest
-- **Pattern:** Mirrors ofw-mcp structure

package/docs/superpowers/specs/2026-04-13-browser-auth-design.md

@@ -1,88 +0,0 @@
-# Browser-Based Auth Flow for gogcli-mcp
-
-## Summary
-
-Add a `gog_auth_add` MCP tool that runs the default `gog auth add` browser flow, opening the user's browser for Google OAuth and blocking until completion. This gives users a one-click auth experience without leaving Claude.
-
-## Runner Changes
-
-### `RunOptions` additions (`src/runner.ts`)
-
-Add two optional fields to the existing `RunOptions` interface:
-
-```ts
-export interface RunOptions {
-  account?: string;
-  spawner?: Spawner;
-  interactive?: boolean;  // NEW: when true, omit --no-input
-  timeout?: number;       // NEW: override default 30s timeout (ms)
-}
-```
-
-### Behavior changes in `run()`
-
-- When `interactive` is `true`, do NOT inject `--no-input` into `fullArgs`.
-- When `timeout` is provided, use it instead of the `TIMEOUT_MS` constant.
-- When `interactive` is `true` and the process exits successfully (code 0), append any captured stderr to the stdout result. This ensures the fallback URL ("If the browser doesn't open, visit this URL") reaches Claude even on success.
-- When `timeout` is provided, the timeout error message includes the human-readable duration: e.g., `"gog timed out after 300000ms (5 minutes)"` so both the raw value and friendly form are visible.
-
-### Default behavior
-
-Unchanged. Existing calls without `interactive` or `timeout` behave exactly as before.
-
-## New Tool: `gog_auth_add`
-
-### Registration (`src/tools/auth.ts`)
-
-- **Name:** `gog_auth_add`
-- **Annotations:** `{ destructiveHint: true }`
-- **Input schema:**
-  - `email` — required `z.string()`, Google account email to authorize
-  - `services` — optional `z.string()`, default `"all"`, comma-separated services or `"all"`
-- **Handler:** Calls `run(['auth', 'add', email, '--services', services], { interactive: true, timeout: 300_000 })`
-- **Error handling:** Standard `toError()` wrapping, same as other auth tools.
-
-### Tool description
-
-The description tells Claude:
-
-1. This opens a browser window for Google OAuth
-2. The user must complete authorization in the browser
-3. The tool blocks for up to 5 minutes waiting for completion
-4. If the browser doesn't open automatically, a fallback URL is included in the response
-
-### `gog_auth_run` description update
-
-Remove the "gog auth add requires interactive browser auth and cannot be completed over MCP" caveat. Replace with a note pointing to `gog_auth_add` for browser-based authorization.
-
-## Manifest update
-
-Add `gog_auth_add` to the `manifest.json` tools list.
-
-## Error Handling
-
-| Scenario | Behavior |
-|---|---|
-| User completes auth in browser | Tool returns success with gogcli output |
-| User doesn't complete within 5 min | Process killed, error: "gog auth timed out after 5 minutes" |
-| User cancels/denies in browser | gogcli exits non-zero, stderr returned as error |
-| Browser doesn't open | Fallback URL included in response via stderr capture |
-| Already authorized account | gogcli re-authorizes (updates scopes), no special handling |
-
-## Testing
-
-### Runner tests (`tests/runner.test.ts`)
-
-- `interactive: true` omits `--no-input` from args
-- Custom `timeout` is respected (process killed at custom time, not 30s)
-- `interactive: true` on success appends stderr to stdout result
-- `interactive: false` (or omitted) still includes `--no-input` (regression)
-- Timeout error message includes human-readable duration
-
-### Auth tool tests (`tests/tools/auth.test.ts`)
-
-- `gog_auth_add` passes correct args to runner with `interactive: true` and `timeout: 300_000`
-- `gog_auth_add` defaults services to `"all"` when omitted
-- `gog_auth_add` passes custom services when provided
-- `gog_auth_add` returns error text on failure
-- `gog_auth_add` returns error text on timeout