@otto-assistant/otto 0.1.2 → 0.7.16

package/dist/anthropic-auth-state.js

@@ -0,0 +1,303 @@
+import * as fs from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { normalizeAnthropicAccountIdentity, } from './anthropic-account-identity.js';
+const AUTH_LOCK_STALE_MS = 30_000;
+const AUTH_LOCK_RETRY_MS = 100;
+async function readJson(filePath, fallback) {
+    try {
+        return JSON.parse(await fs.readFile(filePath, 'utf8'));
+    }
+    catch {
+        return fallback;
+    }
+}
+async function writeJson(filePath, value) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(value, null, 2), 'utf8');
+    await fs.chmod(filePath, 0o600);
+}
+function getErrorCode(error) {
+    if (!(error instanceof Error))
+        return undefined;
+    return error.code;
+}
+async function sleep(ms) {
+    await new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+export function authFilePath() {
+    if (process.env.XDG_DATA_HOME) {
+        return path.join(process.env.XDG_DATA_HOME, 'opencode', 'auth.json');
+    }
+    return path.join(homedir(), '.local', 'share', 'opencode', 'auth.json');
+}
+export function accountsFilePath() {
+    if (process.env.XDG_DATA_HOME) {
+        return path.join(process.env.XDG_DATA_HOME, 'opencode', 'anthropic-oauth-accounts.json');
+    }
+    return path.join(homedir(), '.local', 'share', 'opencode', 'anthropic-oauth-accounts.json');
+}
+export async function withAuthStateLock(fn) {
+    const file = authFilePath();
+    const lockDir = `${file}.lock`;
+    const deadline = Date.now() + AUTH_LOCK_STALE_MS;
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    while (true) {
+        try {
+            await fs.mkdir(lockDir);
+            break;
+        }
+        catch (error) {
+            const code = getErrorCode(error);
+            if (code !== 'EEXIST') {
+                throw error;
+            }
+            const stats = await fs.stat(lockDir).catch(() => {
+                return null;
+            });
+            if (stats && Date.now() - stats.mtimeMs > AUTH_LOCK_STALE_MS) {
+                await fs.rm(lockDir, { force: true, recursive: true }).catch(() => { });
+                continue;
+            }
+            if (Date.now() >= deadline) {
+                throw new Error(`Timed out waiting for auth lock: ${lockDir}`);
+            }
+            await sleep(AUTH_LOCK_RETRY_MS);
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        await fs.rm(lockDir, { force: true, recursive: true }).catch(() => { });
+    }
+}
+export function normalizeAccountStore(input) {
+    const accounts = Array.isArray(input?.accounts)
+        ? input.accounts.filter((account) => !!account &&
+            account.type === 'oauth' &&
+            typeof account.refresh === 'string' &&
+            typeof account.access === 'string' &&
+            typeof account.expires === 'number' &&
+            (typeof account.email === 'undefined' || typeof account.email === 'string') &&
+            (typeof account.accountId === 'undefined' || typeof account.accountId === 'string') &&
+            typeof account.addedAt === 'number' &&
+            typeof account.lastUsed === 'number')
+        : [];
+    const rawIndex = typeof input?.activeIndex === 'number' ? Math.floor(input.activeIndex) : 0;
+    const activeIndex = accounts.length === 0 ? 0 : ((rawIndex % accounts.length) + accounts.length) % accounts.length;
+    return { version: 1, activeIndex, accounts };
+}
+export async function loadAccountStore() {
+    const raw = await readJson(accountsFilePath(), null);
+    return normalizeAccountStore(raw);
+}
+export async function saveAccountStore(store) {
+    await writeJson(accountsFilePath(), normalizeAccountStore(store));
+}
+/** Short label for an account: first 8 + last 4 chars of refresh token. */
+export function accountLabel(account, index) {
+    const accountWithIdentity = account;
+    const identity = accountWithIdentity.email || accountWithIdentity.accountId;
+    const r = account.refresh;
+    const short = r.length > 12 ? `${r.slice(0, 8)}...${r.slice(-4)}` : r;
+    if (identity) {
+        return index !== undefined ? `#${index + 1} (${identity})` : identity;
+    }
+    return index !== undefined ? `#${index + 1} (${short})` : short;
+}
+function findCurrentAccountIndex(store, auth) {
+    if (!store.accounts.length)
+        return 0;
+    const byRefresh = store.accounts.findIndex((account) => {
+        return account.refresh === auth.refresh;
+    });
+    if (byRefresh >= 0)
+        return byRefresh;
+    const byAccess = store.accounts.findIndex((account) => {
+        return account.access === auth.access;
+    });
+    if (byAccess >= 0)
+        return byAccess;
+    return store.activeIndex;
+}
+export function upsertAccount(store, auth, now = Date.now()) {
+    const authWithIdentity = auth;
+    const identity = normalizeAnthropicAccountIdentity({
+        email: authWithIdentity.email,
+        accountId: authWithIdentity.accountId,
+    });
+    const index = store.accounts.findIndex((account) => {
+        if (account.refresh === auth.refresh || account.access === auth.access) {
+            return true;
+        }
+        if (identity?.accountId && account.accountId === identity.accountId) {
+            return true;
+        }
+        if (identity?.email && account.email === identity.email) {
+            return true;
+        }
+        return false;
+    });
+    const nextAccount = {
+        type: 'oauth',
+        refresh: auth.refresh,
+        access: auth.access,
+        expires: auth.expires,
+        ...identity,
+        addedAt: now,
+        lastUsed: now,
+    };
+    if (index < 0) {
+        store.accounts.push(nextAccount);
+        store.activeIndex = store.accounts.length - 1;
+        return store.activeIndex;
+    }
+    const existing = store.accounts[index];
+    if (!existing)
+        return index;
+    store.accounts[index] = {
+        ...existing,
+        ...nextAccount,
+        addedAt: existing.addedAt,
+        email: nextAccount.email || existing.email,
+        accountId: nextAccount.accountId || existing.accountId,
+    };
+    store.activeIndex = index;
+    return index;
+}
+export async function rememberAnthropicOAuth(auth, identity) {
+    await withAuthStateLock(async () => {
+        const store = await loadAccountStore();
+        upsertAccount(store, { ...auth, ...normalizeAnthropicAccountIdentity(identity) });
+        await saveAccountStore(store);
+    });
+}
+async function writeAnthropicAuthFile(auth) {
+    const file = authFilePath();
+    const data = await readJson(file, {});
+    if (auth) {
+        data.anthropic = auth;
+    }
+    else {
+        delete data.anthropic;
+    }
+    await writeJson(file, data);
+}
+function isOAuthStored(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const record = value;
+    return (record.type === 'oauth' &&
+        typeof record.refresh === 'string' &&
+        typeof record.access === 'string' &&
+        typeof record.expires === 'number');
+}
+export async function getCurrentAnthropicAccount() {
+    const authJson = await readJson(authFilePath(), {});
+    const auth = authJson.anthropic;
+    if (!isOAuthStored(auth)) {
+        return null;
+    }
+    const store = await loadAccountStore();
+    const index = findCurrentAccountIndex(store, auth);
+    const account = store.accounts[index];
+    if (!account) {
+        return { auth };
+    }
+    if (account.refresh !== auth.refresh && account.access !== auth.access) {
+        return { auth };
+    }
+    return {
+        auth,
+        account,
+        index,
+    };
+}
+export async function setAnthropicAuth(auth, client) {
+    await writeAnthropicAuthFile(auth);
+    await client.auth.set({ path: { id: 'anthropic' }, body: auth });
+}
+export async function rotateAnthropicAccount(auth, client) {
+    return withAuthStateLock(async () => {
+        const store = await loadAccountStore();
+        if (store.accounts.length < 2)
+            return undefined;
+        const currentIndex = findCurrentAccountIndex(store, auth);
+        const currentAccount = store.accounts[currentIndex];
+        const nextIndex = (currentIndex + 1) % store.accounts.length;
+        const nextAccount = store.accounts[nextIndex];
+        if (!nextAccount)
+            return undefined;
+        const fromLabel = currentAccount
+            ? accountLabel(currentAccount, currentIndex)
+            : accountLabel(auth, currentIndex);
+        nextAccount.lastUsed = Date.now();
+        store.activeIndex = nextIndex;
+        await saveAccountStore(store);
+        const nextAuth = {
+            type: 'oauth',
+            refresh: nextAccount.refresh,
+            access: nextAccount.access,
+            expires: nextAccount.expires,
+        };
+        await setAnthropicAuth(nextAuth, client);
+        return {
+            auth: nextAuth,
+            fromLabel,
+            toLabel: accountLabel(nextAccount, nextIndex),
+            fromIndex: currentIndex,
+            toIndex: nextIndex,
+        };
+    });
+}
+export async function removeAccount(index) {
+    return withAuthStateLock(async () => {
+        const store = await loadAccountStore();
+        if (!Number.isInteger(index) || index < 0 || index >= store.accounts.length) {
+            throw new Error(`Account ${index + 1} does not exist`);
+        }
+        store.accounts.splice(index, 1);
+        if (store.accounts.length === 0) {
+            store.activeIndex = 0;
+            await saveAccountStore(store);
+            await writeAnthropicAuthFile(undefined);
+            return { store, active: undefined };
+        }
+        if (store.activeIndex > index) {
+            store.activeIndex -= 1;
+        }
+        else if (store.activeIndex >= store.accounts.length) {
+            store.activeIndex = 0;
+        }
+        const active = store.accounts[store.activeIndex];
+        if (!active)
+            throw new Error('Active Anthropic account disappeared during removal');
+        active.lastUsed = Date.now();
+        await saveAccountStore(store);
+        const nextAuth = {
+            type: 'oauth',
+            refresh: active.refresh,
+            access: active.access,
+            expires: active.expires,
+        };
+        await writeAnthropicAuthFile(nextAuth);
+        return { store, active: nextAuth };
+    });
+}
+export function shouldRotateAuth(status, bodyText) {
+    const haystack = bodyText.toLowerCase();
+    if (status === 429)
+        return true;
+    if (status === 401 || status === 403)
+        return true;
+    return (haystack.includes('rate_limit') ||
+        haystack.includes('rate limit') ||
+        haystack.includes('invalid api key') ||
+        haystack.includes('authentication_error') ||
+        haystack.includes('permission_error') ||
+        haystack.includes('oauth'));
+}

package/dist/anthropic-auth-state.test.js

@@ -0,0 +1,150 @@
+// Tests Anthropic OAuth account persistence, deduplication, and rotation.
+import { mkdtemp, readFile, rm, mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
+import { accountLabel, authFilePath, loadAccountStore, rememberAnthropicOAuth, removeAccount, rotateAnthropicAccount, saveAccountStore, shouldRotateAuth, } from './anthropic-auth-state.js';
+const firstAccount = {
+    type: 'oauth',
+    refresh: 'refresh-first',
+    access: 'access-first',
+    expires: 1,
+};
+const secondAccount = {
+    type: 'oauth',
+    refresh: 'refresh-second',
+    access: 'access-second',
+    expires: 2,
+};
+let originalXdgDataHome;
+let tempDir = '';
+beforeEach(async () => {
+    originalXdgDataHome = process.env.XDG_DATA_HOME;
+    tempDir = await mkdtemp(path.join(tmpdir(), 'anthropic-auth-plugin-'));
+    process.env.XDG_DATA_HOME = tempDir;
+});
+afterEach(async () => {
+    if (originalXdgDataHome === undefined) {
+        delete process.env.XDG_DATA_HOME;
+    }
+    else {
+        process.env.XDG_DATA_HOME = originalXdgDataHome;
+    }
+    await rm(tempDir, { force: true, recursive: true });
+});
+describe('rememberAnthropicOAuth', () => {
+    test('stores accounts and updates existing entries by refresh token', async () => {
+        await rememberAnthropicOAuth(firstAccount);
+        await rememberAnthropicOAuth({ ...firstAccount, access: 'access-first-new', expires: 3 });
+        const store = await loadAccountStore();
+        expect(store.activeIndex).toBe(0);
+        expect(store.accounts).toHaveLength(1);
+        expect(store.accounts[0]).toMatchObject({
+            refresh: 'refresh-first',
+            access: 'access-first-new',
+            expires: 3,
+        });
+    });
+    test('deduplicates new tokens by email or account ID', async () => {
+        await rememberAnthropicOAuth(firstAccount, {
+            email: 'user@example.com',
+            accountId: 'usr_123',
+        });
+        await rememberAnthropicOAuth(secondAccount, {
+            email: 'User@example.com',
+            accountId: 'usr_123',
+        });
+        const store = await loadAccountStore();
+        expect(store.accounts).toHaveLength(1);
+        expect(store.accounts[0]).toMatchObject({
+            refresh: 'refresh-second',
+            access: 'access-second',
+            email: 'user@example.com',
+            accountId: 'usr_123',
+        });
+        expect(accountLabel(store.accounts[0])).toBe('user@example.com');
+    });
+});
+describe('rotateAnthropicAccount', () => {
+    test('rotates to the next stored account and syncs auth state', async () => {
+        await saveAccountStore({
+            version: 1,
+            activeIndex: 0,
+            accounts: [
+                { ...firstAccount, addedAt: 1, lastUsed: 1 },
+                { ...secondAccount, addedAt: 2, lastUsed: 2 },
+            ],
+        });
+        const authSetCalls = [];
+        const client = {
+            auth: {
+                set: async (input) => {
+                    authSetCalls.push(input);
+                },
+            },
+        };
+        const rotated = await rotateAnthropicAccount(firstAccount, client);
+        const store = await loadAccountStore();
+        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
+        expect(rotated).toMatchObject({
+            auth: { refresh: 'refresh-second' },
+            fromLabel: '#1 (refresh-...irst)',
+            toLabel: '#2 (refresh-...cond)',
+            fromIndex: 0,
+            toIndex: 1,
+        });
+        expect(store.activeIndex).toBe(1);
+        expect(authJson.anthropic?.refresh).toBe('refresh-second');
+        expect(authSetCalls).toEqual([
+            {
+                path: { id: 'anthropic' },
+                body: {
+                    type: 'oauth',
+                    refresh: 'refresh-second',
+                    access: 'access-second',
+                    expires: 2,
+                },
+            },
+        ]);
+    });
+});
+describe('removeAccount', () => {
+    test('removing the active account promotes the next stored account', async () => {
+        await saveAccountStore({
+            version: 1,
+            activeIndex: 1,
+            accounts: [
+                { ...firstAccount, addedAt: 1, lastUsed: 1 },
+                { ...secondAccount, addedAt: 2, lastUsed: 2 },
+            ],
+        });
+        await removeAccount(1);
+        const store = await loadAccountStore();
+        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
+        expect(store.activeIndex).toBe(0);
+        expect(store.accounts).toHaveLength(1);
+        expect(store.accounts[0]?.refresh).toBe('refresh-first');
+        expect(authJson.anthropic?.refresh).toBe('refresh-first');
+    });
+    test('removing the last account clears active Anthropic auth', async () => {
+        await saveAccountStore({
+            version: 1,
+            activeIndex: 0,
+            accounts: [{ ...firstAccount, addedAt: 1, lastUsed: 1 }],
+        });
+        await mkdir(path.dirname(authFilePath()), { recursive: true });
+        await writeFile(authFilePath(), JSON.stringify({ anthropic: firstAccount }, null, 2));
+        await removeAccount(0);
+        const store = await loadAccountStore();
+        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
+        expect(store.accounts).toHaveLength(0);
+        expect(authJson.anthropic).toBeUndefined();
+    });
+});
+describe('shouldRotateAuth', () => {
+    test('only rotates on rate limit or auth failures', () => {
+        expect(shouldRotateAuth(429, '')).toBe(true);
+        expect(shouldRotateAuth(401, 'permission_error')).toBe(true);
+        expect(shouldRotateAuth(400, 'bad request')).toBe(false);
+    });
+});

package/dist/bin.js

@@ -0,0 +1,152 @@
+// Crash-recovery supervisor for `otto gateway start`.
+//
+// Parents run goke-backed `cli.js` directly for every invocation except top-level
+// `otto gateway start` (without `--help`). Those long-running installs get an
+// outer Node process that restarts `cli.js` on non-clean exits (crash, OOM, etc.).
+// Exit code `0` / `EXIT_NO_RESTART=64` / SIGTERM+SIGINT grace paths suppress restarts.
+//
+// When __OTTO_CHILD is set, we're supervised — import `cli.js` directly.
+//
+// V8 heap snapshot flags:
+// Injects --heapsnapshot-near-heap-limit=3 and --diagnostic-dir so V8 writes
+// heap snapshots internally as it approaches the heap limit. This catches OOM
+// situations where SIGKILL (exit 137) would kill the process before our
+// heap-monitor.ts polling can react. The polling monitor is kept as an early
+// warning system at 85% usage; the V8 flag is the last-resort safety net.
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const HEAP_SNAPSHOT_DIR = path.join(os.homedir(), '.otto', 'heap-snapshots');
+const STARTUP_LOG_WAIT_MS = 2_500;
+const STARTUP_LOG_POLL_MS = 200;
+const STARTUP_LOG_MAX_LINES = 12;
+const argv = process.argv.slice(2);
+const isHelpFlag = process.argv.includes('--help');
+const isGatewayDaemon = process.env.OTTO_GATEWAY_DAEMON === '1';
+function isGatewayStartInvocation() {
+    return argv[0] === 'gateway' && argv[1] === 'start';
+}
+function resolveDataDirFromArgv() {
+    const inlineArg = argv.find((entry) => {
+        return entry.startsWith('--data-dir=');
+    });
+    if (inlineArg) {
+        return path.resolve(inlineArg.slice('--data-dir='.length));
+    }
+    const dataDirIndex = argv.findIndex((entry) => {
+        return entry === '--data-dir';
+    });
+    if (dataDirIndex !== -1) {
+        const value = argv[dataDirIndex + 1];
+        if (value && !value.startsWith('--')) {
+            return path.resolve(value);
+        }
+    }
+    return path.join(os.homedir(), '.otto');
+}
+async function printStartupLogs({ dataDir, }) {
+    const logPath = path.join(dataDir, 'otto.log');
+    const seenLines = new Set();
+    const deadline = Date.now() + STARTUP_LOG_WAIT_MS;
+    while (Date.now() < deadline && seenLines.size < STARTUP_LOG_MAX_LINES) {
+        if (fs.existsSync(logPath)) {
+            const content = fs.readFileSync(logPath, 'utf8');
+            const lines = content
+                .split(/\r?\n/)
+                .map((entry) => {
+                return entry.trim();
+            })
+                .filter((entry) => {
+                return entry.length > 0;
+            });
+            for (const line of lines) {
+                if (seenLines.has(line)) {
+                    continue;
+                }
+                seenLines.add(line);
+                console.error(`[gateway] ${line}`);
+                if (seenLines.size >= STARTUP_LOG_MAX_LINES) {
+                    return;
+                }
+            }
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, STARTUP_LOG_POLL_MS);
+        });
+    }
+}
+if (process.env.__OTTO_CHILD || isHelpFlag || !isGatewayStartInvocation()) {
+    await import('./cli.js');
+}
+else if (!isGatewayDaemon) {
+    const dataDir = resolveDataDirFromArgv();
+    const daemon = spawn(process.execPath, process.argv.slice(1), {
+        stdio: 'ignore',
+        detached: true,
+        env: { ...process.env, OTTO_GATEWAY_DAEMON: '1' },
+        windowsHide: process.platform === 'win32',
+    });
+    daemon.unref();
+    console.error('otto gateway start: launched in background');
+    await printStartupLogs({ dataDir });
+    process.exit(0);
+}
+else {
+    console.error('otto gateway start: supervised process will restart the child on crash');
+    console.error();
+    const EXIT_NO_RESTART = 64;
+    const MAX_RAPID_RESTARTS = 5;
+    const RAPID_RESTART_WINDOW_MS = 60_000;
+    const RESTART_DELAY_MS = 2_000;
+    const restartTimestamps = [];
+    let child = null;
+    let shutdownRequested = false;
+    function start() {
+        if (!fs.existsSync(HEAP_SNAPSHOT_DIR)) {
+            fs.mkdirSync(HEAP_SNAPSHOT_DIR, { recursive: true });
+        }
+        const heapArgs = [
+            `--heapsnapshot-near-heap-limit=3`,
+            `--diagnostic-dir=${HEAP_SNAPSHOT_DIR}`,
+        ];
+        const args = [...heapArgs, ...process.execArgv, ...process.argv.slice(1)];
+        child = spawn(process.argv[0], args, {
+            stdio: 'ignore',
+            env: { ...process.env, __OTTO_CHILD: '1' },
+            windowsHide: process.platform === 'win32',
+        });
+        child.on('exit', (code, signal) => {
+            if (code === 0 || code === EXIT_NO_RESTART || shutdownRequested) {
+                process.exit(code ?? 0);
+                return;
+            }
+            const now = Date.now();
+            restartTimestamps.push(now);
+            while (restartTimestamps.length > 0 &&
+                restartTimestamps[0] < now - RAPID_RESTART_WINDOW_MS) {
+                restartTimestamps.shift();
+            }
+            if (restartTimestamps.length > MAX_RAPID_RESTARTS) {
+                console.error(`[otto] Crash loop detected (${MAX_RAPID_RESTARTS} crashes in ${RAPID_RESTART_WINDOW_MS / 1000}s), exiting`);
+                process.exit(1);
+                return;
+            }
+            const reason = signal ? `signal ${signal}` : `code ${code}`;
+            console.error(`[otto] Process exited with ${reason}, restarting in ${RESTART_DELAY_MS / 1000}s...`);
+            setTimeout(start, RESTART_DELAY_MS);
+        });
+    }
+    for (const sig of ['SIGTERM', 'SIGINT']) {
+        process.on(sig, () => {
+            shutdownRequested = true;
+            child?.kill(sig);
+        });
+    }
+    for (const sig of ['SIGUSR1', 'SIGUSR2']) {
+        process.on(sig, () => {
+            child?.kill(sig);
+        });
+    }
+    start();
+}

package/dist/btw-prefix-detection.js

@@ -0,0 +1,17 @@
+// Detects the raw `btw ` Discord message shortcut used to fork a side-question
+// thread without invoking the /btw slash command UI.
+export function extractBtwPrefix(content) {
+    if (!content) {
+        return null;
+    }
+    // Match "btw" followed by whitespace or punctuation (. , : ; ! ?) then the prompt
+    const match = content.match(/^\s*btw[.,;:!?\s]\s*([\s\S]+)$/i);
+    if (!match) {
+        return null;
+    }
+    const prompt = match[1]?.trim();
+    if (!prompt) {
+        return null;
+    }
+    return { prompt };
+}

package/dist/btw-prefix-detection.test.js

@@ -0,0 +1,63 @@
+import { describe, expect, test } from 'vitest';
+import { extractBtwPrefix } from './btw-prefix-detection.js';
+describe('extractBtwPrefix', () => {
+    test('matches lowercase prefix', () => {
+        expect(extractBtwPrefix('btw fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('matches uppercase prefix', () => {
+        expect(extractBtwPrefix('BTW check this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "check this",
+      }
+    `);
+    });
+    test('keeps multiline content', () => {
+        expect(extractBtwPrefix('  btw first line\nsecond line  ')).toMatchInlineSnapshot(`
+      {
+        "prompt": "first line
+      second line",
+      }
+    `);
+    });
+    test('matches dot separator', () => {
+        expect(extractBtwPrefix('btw. fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('matches comma separator', () => {
+        expect(extractBtwPrefix('btw, fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('matches colon separator', () => {
+        expect(extractBtwPrefix('btw: fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('matches punctuation without trailing space', () => {
+        expect(extractBtwPrefix('btw.fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('does not match without separating whitespace', () => {
+        expect(extractBtwPrefix('btwfix this')).toMatchInlineSnapshot(`null`);
+    });
+    test('does not match mid-message', () => {
+        expect(extractBtwPrefix('hello btw fix this')).toMatchInlineSnapshot(`null`);
+    });
+    test('does not match empty payload', () => {
+        expect(extractBtwPrefix('btw   ')).toMatchInlineSnapshot(`null`);
+    });
+});