@juppytt/fws 0.1.0

package/.claude/settings.local.json

@@ -0,0 +1,72 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(gws --help)",
+      "Bash(gws gmail:*)",
+      "Bash(gws auth:*)",
+      "Bash(gws schema:*)",
+      "Bash(npm list:*)",
+      "Bash(mockoon-cli --help)",
+      "Bash(GOOGLE_WORKSPACE_CLI_LOG=gws=debug gws gmail users messages list --params '{\"userId\":\"me\",\"maxResults\":1}')",
+      "Bash(GOOGLE_WORKSPACE_CLI_LOG=gws=trace gws gmail users messages list --params '{\"userId\":\"me\",\"maxResults\":1}')",
+      "Bash(gws)",
+      "Bash(env)",
+      "Bash(HTTPS_PROXY=http://localhost:9999 GOOGLE_WORKSPACE_CLI_TOKEN=fake gws gmail users messages list --params '{\"userId\":\"me\",\"maxResults\":1}')",
+      "Bash(python3 -c \"import json,sys; d=json.load\\(sys.stdin\\); print\\(d.get\\('rootUrl','N/A'\\)\\); print\\(d.get\\('baseUrl','N/A'\\)\\); print\\(d.get\\('basePath','N/A'\\)\\); print\\(d.get\\('servicePath','N/A'\\)\\)\")",
+      "Bash(cp ~/.config/gws/cache/gmail_v1.json /tmp/gmail_v1_backup.json)",
+      "Bash(python3 -c ':*)",
+      "Bash(npm --version)",
+      "Bash(tsc --version)",
+      "Bash(ls:*)",
+      "Bash(python3:*)",
+      "Bash(npm install:*)",
+      "Bash(npx tsc:*)",
+      "Bash(npx vitest:*)",
+      "Bash(npx tsx:*)",
+      "Bash(git add:*)",
+      "Bash(git commit -m ':*)",
+      "Bash(chmod +x:*)",
+      "Bash(npm link:*)",
+      "Bash(fws --help)",
+      "Bash(fws drive:*)",
+      "Bash(fws server:*)",
+      "Bash(export GOOGLE_WORKSPACE_CLI_CONFIG_DIR=/home/juhee/.local/share/fws/config)",
+      "Bash(export GOOGLE_WORKSPACE_CLI_TOKEN=fake)",
+      "Bash(curl -s http://localhost:4100/__fws/status)",
+      "Bash(kill %1)",
+      "Bash(kill 1088227)",
+      "Bash(gws drive:*)",
+      "Bash(GOOGLE_WORKSPACE_CLI_LOG=gws=debug gws gmail +triage --max 2)",
+      "Bash(GOOGLE_WORKSPACE_CLI_LOG=gws=trace gws gmail +triage --max 1)",
+      "Bash(kill 1093361)",
+      "Bash(wait)",
+      "Bash(cp /home/juhee/.config/gws/accounts.json /home/juhee/.local/share/fws/config/)",
+      "Bash(node -e ':*)",
+      "Bash(xargs kill:*)",
+      "Bash(HTTPS_PROXY=http://localhost:19999 gws gmail +triage --max 1)",
+      "Bash(HTTPS_PROXY=http://localhost:19999 gws gmail users messages list --params '{\"userId\":\"me\",\"maxResults\":1}')",
+      "Bash(find /home/juhee/headless-clawd/projects/agent-dfi/gws-src -name \"*.rs\" -exec grep -l \"config\\\\|Config\" {} \\\\;)",
+      "Bash(node -e \"const tls = require\\('tls'\\); const crypto = require\\('crypto'\\); console.log\\('crypto available:', !!crypto.generateKeyPairSync\\);\")",
+      "Bash(export HTTPS_PROXY=http://localhost:4101)",
+      "Bash(export SSL_CERT_FILE=/home/juhee/.local/share/fws/certs/ca.crt)",
+      "Bash(fws gmail:*)",
+      "Bash(gws calendar:*)",
+      "Bash(echo \"EXIT: $?\")",
+      "Bash(gh repo:*)",
+      "Bash(git:*)",
+      "Bash(gh issue create --repo pinchbench/skill --title 'Proposal: GWS-powered user tasks using fws \\(Fake Google Workspace\\)' --body ':*)",
+      "Bash(gws tasks:*)",
+      "Bash(./scripts/run.sh --suite task_26_gws_email_triage --model anthropic/claude-sonnet-4 --no-upload -v)",
+      "Bash(./scripts/run.sh --suite task_26_gws_email_triage --model openai/gpt-4o --no-upload -v)",
+      "Bash(./scripts/run.sh --suite task_26_gws_email_triage --model openai/gpt-4.1 --no-upload -v)",
+      "Bash(./scripts/run.sh --suite task_16_email_triage --model openai/gpt-4.1 --no-upload -v)",
+      "Bash(grep:*)",
+      "Bash(gh pr create --repo pinchbench/skill --title 'Fix judge API: use max_completion_tokens for OpenAI/OpenRouter' --body ':*)",
+      "Bash(npm whoami:*)",
+      "Bash(npm view:*)",
+      "Bash(mock-gws --help)",
+      "Bash(mock-gws gmail:*)",
+      "Bash(npm publish:*)"
+    ]
+  }
+}

package/README.md

@@ -0,0 +1,126 @@
+# fws — Fake Google Workspace
+
+A local mock server that redirects the `gws` CLI, enabling Google Workspace testing without OAuth authentication.
+
+Built with [Claude Code](https://claude.ai/code).
+
+## How it works
+
+`gws` sends API requests to the `rootUrl` defined in its discovery cache (`~/.config/gws/cache/*.json`). fws rewrites these URLs to `http://localhost:4100/` and sets `GOOGLE_WORKSPACE_CLI_TOKEN=fake` to bypass auth.
+
+For helper commands (`+triage`, `+send`, `+reply`, etc.) that hardcode `googleapis.com` URLs, fws runs a MITM CONNECT proxy on port 4101 that intercepts HTTPS traffic and forwards it to the local mock server.
+
+All data lives **in memory**. When the server stops, everything is lost unless you save a snapshot first. Use `fws snapshot save` to persist state.
+
+## Install
+
+```bash
+npm install
+npm link     # makes `fws` command available globally
+```
+
+## Quick Start
+
+```bash
+# Start the server (runs in background)
+fws server start
+
+# Set env vars (printed by the command above)
+export GOOGLE_WORKSPACE_CLI_CONFIG_DIR=~/.local/share/fws/config
+export GOOGLE_WORKSPACE_CLI_TOKEN=fake
+export HTTPS_PROXY=http://localhost:4101
+export SSL_CERT_FILE=~/.local/share/fws/certs/ca.crt
+
+# Try some commands
+gws gmail users messages list --params '{"userId":"me"}'
+gws gmail +triage
+gws calendar events list --params '{"calendarId":"primary"}'
+gws drive files list
+gws tasks tasklists list
+gws sheets spreadsheets get --params '{"spreadsheetId":"sheet001"}'
+gws people people connections list --params '{"resourceName":"people/me","personFields":"names"}'
+
+# When done
+fws server stop
+```
+
+The server starts with sample seed data (5 emails, 4 calendar events, 5 drive files, 2 tasks, 1 spreadsheet, 2 contacts) so you can try gws commands immediately.
+
+## Usage
+
+### Proxy mode (one-shot)
+
+Starts a temporary server, runs gws, exits. No separate server needed.
+
+```bash
+fws gmail users messages list --params '{"userId":"me"}'
+fws gmail +triage
+fws calendar calendarList list
+fws drive about get --params '{"fields":"*"}'
+```
+
+### Server mode (persistent)
+
+```bash
+fws server start                  # Start in background
+fws server status                 # Check if running
+fws server stop                   # Stop
+fws server start --foreground     # Run in foreground (for debugging)
+```
+
+### Setup (add data to running server)
+
+```bash
+fws setup gmail add-message --from alice@corp.com --subject "Meeting" --body "See you at 3pm"
+fws setup calendar add-event --summary "Team sync" --start 2026-04-08T15:00:00 --duration 1h
+fws setup drive add-file --name "report.pdf" --mimeType application/pdf
+```
+
+### Snapshots
+
+Data is in-memory only. Save before stopping the server if you need to keep it.
+
+```bash
+fws snapshot save my-scenario     # Save current state to disk
+fws snapshot load my-scenario     # Restore saved state into running server
+fws snapshot list                 # List saved snapshots
+fws snapshot delete my-scenario   # Delete a snapshot
+fws reset                        # Reset to default seed data
+fws reset --snapshot my-scenario  # Reset to a specific snapshot
+```
+
+Snapshots are stored in `~/.local/share/fws/snapshots/` (override with `FWS_DATA_DIR`).
+
+## Default seed data
+
+| Service  | Data |
+|----------|------|
+| Gmail    | 5 messages (3 inbox, 1 sent, 1 read), system labels + "Projects" user label |
+| Calendar | 4 events (Daily Standup, Q3 Planning, 1:1, Team Lunch) |
+| Drive    | 5 files (docs, spreadsheet, image, folder) |
+| Tasks    | 1 task list with 2 tasks (1 pending, 1 completed) |
+| Sheets   | 1 spreadsheet ("Budget 2026") |
+| People   | 2 contacts (Alice, Bob), 1 contact group |
+
+## API support
+
+Gmail (28/79 + 5 helpers), Calendar (21/37), Drive (18/57), Tasks (14/14), Sheets (7/17), People (16/24). 135 tests, 89 gws CLI validated.
+
+See [docs/gws-support.md](docs/gws-support.md) for the full endpoint-by-endpoint table.
+
+## Documentation
+
+- [docs/cli-reference.md](docs/cli-reference.md) — Full CLI reference with all flags, HTTP API equivalents, and examples
+- [docs/gws-support.md](docs/gws-support.md) — Endpoint-by-endpoint support table
+
+## Structure
+
+```
+bin/fws.ts              CLI entry point
+src/server/routes/      Gmail, Calendar, Drive, and control API routes
+src/store/              In-memory data store + seed data
+src/config/             Discovery cache URL rewriting
+src/proxy/              MITM proxy for helper commands
+test/                   Vitest tests (with gws CLI validation)
+docs/                   API support documentation
+```

package/bin/fws-cli.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# Wrapper that runs fws.ts via tsx without requiring a build step
+SCRIPT_DIR="$(cd "$(dirname "$(readlink -f "$0")")" && pwd)"
+exec "$SCRIPT_DIR/../node_modules/.bin/tsx" "$SCRIPT_DIR/fws.ts" "$@"

package/bin/fws.ts

@@ -0,0 +1,421 @@
+#!/usr/bin/env tsx
+import { Command } from 'commander';
+import { createApp } from '../src/server/app.js';
+import { resetStore, loadStore, serializeStore, deserializeStore } from '../src/store/index.js';
+import { generateConfigDir } from '../src/config/rewrite-cache.js';
+import { generateCACert, startMitmProxy } from '../src/proxy/mitm.js';
+import { spawn, execFile } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import type { Server } from 'node:http';
+
+const DEFAULT_PORT = 4100;
+const DEFAULT_PROXY_PORT = 4101;
+
+function getDataDir(): string {
+  return process.env.FWS_DATA_DIR || path.join(os.homedir(), '.local', 'share', 'fws');
+}
+
+function getSnapshotsDir(): string {
+  return path.join(getDataDir(), 'snapshots');
+}
+
+function getServerInfoPath(): string {
+  return path.join(getDataDir(), 'server.json');
+}
+
+async function ensureDir(dir: string): Promise<void> {
+  await fs.mkdir(dir, { recursive: true });
+}
+
+const program = new Command();
+program
+  .name('fws')
+  .description('Fake Google Workspace — local mock server for gws CLI testing')
+  .version('0.1.0');
+
+// === Server commands ===
+const serverCmd = program.command('server');
+
+serverCmd
+  .command('start')
+  .description('Start the mock server in the background')
+  .option('-p, --port <port>', 'Port number', String(DEFAULT_PORT))
+  .option('-s, --snapshot <name>', 'Load a snapshot on start')
+  .option('--foreground', 'Run in foreground (used internally)')
+  .action(async (opts) => {
+    const port = parseInt(opts.port);
+
+    if (opts.foreground) {
+      // Actually run the server (called by the background spawner below)
+      if (opts.snapshot) {
+        const snapshotPath = path.join(getSnapshotsDir(), opts.snapshot, 'store.json');
+        try {
+          const data = await fs.readFile(snapshotPath, 'utf-8');
+          loadStore(deserializeStore(data));
+        } catch {
+          console.error(`Snapshot not found: ${opts.snapshot}`);
+          process.exit(1);
+        }
+      }
+
+      const configDir = path.join(getDataDir(), 'config');
+      await generateConfigDir(port, configDir);
+
+      // Generate CA cert for MITM proxy
+      const { caPath } = await generateCACert(getDataDir());
+
+      const app = createApp();
+      const server: Server = await new Promise((resolve) => {
+        const s = app.listen(port, () => resolve(s));
+      });
+
+      // Start MITM proxy for helper commands (+triage, +send, etc.)
+      const proxyPort = port + 1;
+      const proxyServer = startMitmProxy(port, proxyPort);
+
+      await ensureDir(getDataDir());
+      await fs.writeFile(getServerInfoPath(), JSON.stringify({
+        port, proxyPort, pid: process.pid, caPath,
+      }));
+
+      const shutdown = () => {
+        server.close();
+        proxyServer.close();
+        fs.unlink(getServerInfoPath()).catch(() => {});
+        process.exit(0);
+      };
+      process.on('SIGINT', shutdown);
+      process.on('SIGTERM', shutdown);
+      return;
+    }
+
+    // Kill existing server if any
+    try {
+      const info = JSON.parse(await fs.readFile(getServerInfoPath(), 'utf-8'));
+      try {
+        process.kill(info.pid, 'SIGTERM');
+        await new Promise(r => setTimeout(r, 300));
+      } catch {}
+      await fs.unlink(getServerInfoPath()).catch(() => {});
+    } catch {}
+
+    // Spawn the server as a detached background process
+    const configDir = path.join(getDataDir(), 'config');
+    await ensureDir(getDataDir());
+    await generateConfigDir(port, configDir);
+
+    const logFile = path.join(getDataDir(), 'server.log');
+    // Truncate log on each start so it's fresh
+    const logFd = await fs.open(logFile, 'w');
+
+    const args = ['server', 'start', '--foreground', '-p', String(port)];
+    if (opts.snapshot) args.push('-s', opts.snapshot);
+
+    const tsxPath = path.join(import.meta.dirname, '..', 'node_modules', '.bin', 'tsx');
+    const scriptPath = path.join(import.meta.dirname, 'fws.ts');
+
+    const child = spawn(tsxPath, [scriptPath, ...args], {
+      detached: true,
+      stdio: ['ignore', logFd.fd, logFd.fd],
+    });
+    child.unref();
+
+    // Retry health check a few times (server needs time to start)
+    let started = false;
+    for (let i = 0; i < 10; i++) {
+      await new Promise(r => setTimeout(r, 300));
+      try {
+        const res = await fetch(`http://localhost:${port}/__fws/status`);
+        if (res.ok) {
+          started = true;
+          break;
+        }
+      } catch {}
+    }
+
+    await logFd.close();
+
+    if (started) {
+      // Read server info to get caPath and proxyPort
+      const serverInfo = JSON.parse(await fs.readFile(getServerInfoPath(), 'utf-8').catch(() => '{}'));
+      const proxyPort = serverInfo.proxyPort || port + 1;
+      const caPath = serverInfo.caPath || path.join(getDataDir(), 'certs', 'ca.crt');
+
+      console.log(`fws server started on port ${port} (pid ${child.pid})\n`);
+      console.log(`To use with gws:\n`);
+      console.log(`  export GOOGLE_WORKSPACE_CLI_CONFIG_DIR=${configDir}`);
+      console.log(`  export GOOGLE_WORKSPACE_CLI_TOKEN=fake`);
+      console.log(`  export HTTPS_PROXY=http://localhost:${proxyPort}`);
+      console.log(`  export SSL_CERT_FILE=${caPath}\n`);
+      console.log(`Then try:\n`);
+      console.log(`  gws gmail users messages list --params '{"userId":"me"}'`);
+      console.log(`  gws gmail +triage`);
+      console.log(`  gws calendar events list --params '{"calendarId":"primary"}'`);
+      console.log(`  gws drive files list\n`);
+      console.log(`Stop with: fws server stop`);
+    } else {
+      const log = await fs.readFile(logFile, 'utf-8').catch(() => '');
+      console.error('Failed to start server.');
+      if (log.trim()) {
+        console.error('\nServer log:\n' + log);
+      }
+    }
+  });
+
+serverCmd
+  .command('stop')
+  .description('Stop the running mock server')
+  .action(async () => {
+    try {
+      const info = JSON.parse(await fs.readFile(getServerInfoPath(), 'utf-8'));
+      process.kill(info.pid, 'SIGTERM');
+      await fs.unlink(getServerInfoPath());
+      console.log(`Stopped fws server (pid ${info.pid})`);
+    } catch {
+      console.log('No running server found');
+    }
+  });
+
+serverCmd
+  .command('status')
+  .description('Show server status')
+  .action(async () => {
+    try {
+      const info = JSON.parse(await fs.readFile(getServerInfoPath(), 'utf-8'));
+      try {
+        process.kill(info.pid, 0);
+        console.log(`Server running on port ${info.port} (pid ${info.pid})`);
+      } catch {
+        console.log('Server info exists but process is not running');
+        await fs.unlink(getServerInfoPath()).catch(() => {});
+      }
+    } catch {
+      console.log('No server running');
+    }
+  });
+
+// === Snapshot commands ===
+const snapshotCmd = program.command('snapshot');
+
+snapshotCmd
+  .command('save <name>')
+  .description('Save current server state as a snapshot')
+  .option('-p, --port <port>', 'Server port', String(DEFAULT_PORT))
+  .action(async (name, opts) => {
+    const port = parseInt(opts.port);
+    const res = await fetch(`http://localhost:${port}/__fws/snapshot/save`, { method: 'POST' });
+    const data = await res.text();
+
+    const snapshotDir = path.join(getSnapshotsDir(), name);
+    await ensureDir(snapshotDir);
+    await fs.writeFile(path.join(snapshotDir, 'store.json'), data);
+    console.log(`Snapshot saved: ${name}`);
+  });
+
+snapshotCmd
+  .command('load <name>')
+  .description('Load a snapshot into the running server')
+  .option('-p, --port <port>', 'Server port', String(DEFAULT_PORT))
+  .action(async (name, opts) => {
+    const port = parseInt(opts.port);
+    const snapshotPath = path.join(getSnapshotsDir(), name, 'store.json');
+    const data = await fs.readFile(snapshotPath, 'utf-8');
+
+    await fetch(`http://localhost:${port}/__fws/snapshot/load`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: data,
+    });
+    console.log(`Snapshot loaded: ${name}`);
+  });
+
+snapshotCmd
+  .command('list')
+  .description('List available snapshots')
+  .action(async () => {
+    const dir = getSnapshotsDir();
+    try {
+      const entries = await fs.readdir(dir);
+      if (entries.length === 0) {
+        console.log('No snapshots');
+      } else {
+        for (const name of entries) {
+          console.log(`  ${name}`);
+        }
+      }
+    } catch {
+      console.log('No snapshots');
+    }
+  });
+
+snapshotCmd
+  .command('delete <name>')
+  .description('Delete a snapshot')
+  .action(async (name) => {
+    const snapshotDir = path.join(getSnapshotsDir(), name);
+    await fs.rm(snapshotDir, { recursive: true, force: true });
+    console.log(`Snapshot deleted: ${name}`);
+  });
+
+// === Setup commands ===
+const setupCmd = program.command('setup');
+const setupGmail = setupCmd.command('gmail');
+
+setupGmail
+  .command('add-message')
+  .description('Add a message to the mailbox')
+  .requiredOption('--from <email>', 'From address')
+  .option('--to <email>', 'To address')
+  .option('--subject <text>', 'Subject line')
+  .option('--body <text>', 'Message body')
+  .option('--labels <list>', 'Comma-separated label IDs', 'INBOX,UNREAD')
+  .option('-p, --port <port>', 'Server port', String(DEFAULT_PORT))
+  .action(async (opts) => {
+    const port = parseInt(opts.port);
+    const res = await fetch(`http://localhost:${port}/__fws/setup/gmail/message`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        from: opts.from,
+        to: opts.to,
+        subject: opts.subject,
+        body: opts.body,
+        labels: opts.labels.split(','),
+      }),
+    });
+    const data = await res.json();
+    console.log(`Message added: ${data.id}`);
+  });
+
+const setupCalendar = setupCmd.command('calendar');
+
+setupCalendar
+  .command('add-event')
+  .description('Add an event to a calendar')
+  .requiredOption('--summary <text>', 'Event title')
+  .requiredOption('--start <datetime>', 'Start time (ISO 8601)')
+  .option('--duration <dur>', 'Duration (e.g. 30m, 1h, 2h)', '1h')
+  .option('--calendar <id>', 'Calendar ID', 'primary')
+  .option('--location <text>', 'Location')
+  .option('--attendees <list>', 'Comma-separated attendee emails')
+  .option('-p, --port <port>', 'Server port', String(DEFAULT_PORT))
+  .action(async (opts) => {
+    const port = parseInt(opts.port);
+    const res = await fetch(`http://localhost:${port}/__fws/setup/calendar/event`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        summary: opts.summary,
+        start: opts.start,
+        duration: opts.duration,
+        calendar: opts.calendar === 'primary' ? undefined : opts.calendar,
+        location: opts.location,
+        attendees: opts.attendees?.split(','),
+      }),
+    });
+    const data = await res.json();
+    console.log(`Event added: ${data.id}`);
+  });
+
+const setupDrive = setupCmd.command('drive');
+
+setupDrive
+  .command('add-file')
+  .description('Add a file to Drive')
+  .requiredOption('--name <text>', 'File name')
+  .option('--mimeType <type>', 'MIME type', 'application/octet-stream')
+  .option('--parent <id>', 'Parent folder ID', 'root')
+  .option('--size <bytes>', 'File size in bytes')
+  .option('-p, --port <port>', 'Server port', String(DEFAULT_PORT))
+  .action(async (opts) => {
+    const port = parseInt(opts.port);
+    const res = await fetch(`http://localhost:${port}/__fws/setup/drive/file`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        name: opts.name,
+        mimeType: opts.mimeType,
+        parent: opts.parent,
+        size: opts.size ? parseInt(opts.size) : undefined,
+      }),
+    });
+    const data = await res.json();
+    console.log(`File added: ${data.id}`);
+  });
+
+// === Reset command ===
+program
+  .command('reset')
+  .description('Reset server to seed data or a snapshot')
+  .option('-s, --snapshot <name>', 'Load this snapshot after reset')
+  .option('-p, --port <port>', 'Server port', String(DEFAULT_PORT))
+  .action(async (opts) => {
+    const port = parseInt(opts.port);
+
+    if (opts.snapshot) {
+      const snapshotPath = path.join(getSnapshotsDir(), opts.snapshot, 'store.json');
+      const data = await fs.readFile(snapshotPath, 'utf-8');
+      await fetch(`http://localhost:${port}/__fws/snapshot/load`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: data,
+      });
+      console.log(`Reset to snapshot: ${opts.snapshot}`);
+    } else {
+      await fetch(`http://localhost:${port}/__fws/reset`, { method: 'POST' });
+      console.log('Reset to seed data');
+    }
+  });
+
+// === Proxy mode (default): start server, run gws, exit ===
+// If first arg is not a known subcommand, treat as gws proxy
+const SUBCOMMANDS = ['server', 'snapshot', 'setup', 'reset', 'help', '--help', '-h', '--version', '-V'];
+
+async function runProxy(args: string[]): Promise<void> {
+  const port = DEFAULT_PORT;
+  const proxyPort = DEFAULT_PROXY_PORT;
+
+  // Start server in-process
+  const configDir = await fs.mkdtemp(path.join(os.tmpdir(), 'fws-proxy-'));
+  await generateConfigDir(port, configDir);
+
+  // Generate CA and start MITM proxy
+  const dataDir = await fs.mkdtemp(path.join(os.tmpdir(), 'fws-proxy-data-'));
+  const { caPath } = await generateCACert(dataDir);
+  const proxyServer = startMitmProxy(port, proxyPort);
+
+  const app = createApp();
+  const server: Server = await new Promise((resolve) => {
+    const s = app.listen(port, () => resolve(s));
+  });
+
+  const gwsPath = process.env.GWS_PATH || 'gws';
+  const env = {
+    ...process.env,
+    GOOGLE_WORKSPACE_CLI_CONFIG_DIR: configDir,
+    GOOGLE_WORKSPACE_CLI_TOKEN: 'fake',
+    HTTPS_PROXY: `http://localhost:${proxyPort}`,
+    SSL_CERT_FILE: caPath,
+  };
+
+  const child = spawn(gwsPath, args, { env, stdio: 'inherit' });
+
+  child.on('close', async (code) => {
+    server.close();
+    proxyServer.close();
+    await fs.rm(configDir, { recursive: true, force: true });
+    await fs.rm(dataDir, { recursive: true, force: true });
+    process.exit(code ?? 0);
+  });
+}
+
+// Main entry
+const firstArg = process.argv[2];
+if (firstArg && !SUBCOMMANDS.includes(firstArg)) {
+  // Proxy mode
+  runProxy(process.argv.slice(2));
+} else {
+  program.parse();
+}