@otto-assistant/otto 0.1.2 → 0.7.15

package/dist/commands/cli-commands-group-a.test.js

@@ -0,0 +1,728 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, expect, test, vi } from 'vitest';
+import { execAsync } from '../exec-async.js';
+import { closeDatabase, getPrisma, getThreadDeletionSyncMode, initDatabase, resetThreadDeletionSyncMode, setBotMode, setBotToken, setThreadDeletionSyncMode, setThreadSession, } from '../database.js';
+import { setDataDir } from '../config.js';
+import { detectPm, getCurrentVersion } from '../upgrade.js';
+import { applyThreadDeletionSyncPolicy } from '../discord-utils.js';
+import { buildSessionSearchSnippet, findFirstSessionSearchHit, parseSessionSearchPattern, } from '../session-search.js';
+const CLI_ROOT = path.resolve(import.meta.dirname, '..', '..');
+// Normalize CLI output so snapshots are stable across runs.
+// Replaces volatile timestamps (HH:MM) and random temp dir names.
+function normalizeCliOutput(output) {
+    return output
+        // Strip ANSI colors used in CI/vitest output so snapshots stay stable.
+        .replace(/\u001b\[[0-9;]*m/g, '')
+        // Replace timestamps like "│ 09:48" or "│  09:48" with "│ HH:MM"
+        .replace(/│\s+\d{2}:\d{2}/g, '│ HH:MM')
+        // Replace random temp dir suffixes like "-nasKOL" with "-<tmp>"
+        .replace(/cli-commands-group-a-[a-zA-Z0-9]+/g, 'cli-commands-group-a-<tmp>')
+        // Replace absolute temp paths (local + GitHub runner) with "<tmp>".
+        .replace(/[^\s"]*\/cli\/tmp\/cli-commands-group-a-<tmp>/g, '<tmp>');
+}
+const CLI_TEST_TIMEOUT_MS = 60_000;
+function createSandbox() {
+    const tmpRoot = path.resolve(CLI_ROOT, 'tmp');
+    fs.mkdirSync(tmpRoot, { recursive: true });
+    const rootDir = fs.mkdtempSync(path.join(tmpRoot, 'cli-commands-group-a-'));
+    const homeDir = path.join(rootDir, 'home');
+    const dataDir = path.join(homeDir, '.otto');
+    fs.mkdirSync(dataDir, { recursive: true });
+    return { rootDir, homeDir, dataDir };
+}
+function extractExecFailure(error) {
+    if (!(error instanceof Error)) {
+        return {
+            stdout: '',
+            stderr: String(error),
+            message: String(error),
+        };
+    }
+    const withStreams = error;
+    return {
+        stdout: withStreams.stdout || '',
+        stderr: withStreams.stderr || '',
+        message: error.message,
+    };
+}
+function buildCliCommand({ args }) {
+    const quotedArgs = args
+        .map((arg) => {
+        return JSON.stringify(arg);
+    })
+        .join(' ');
+    return `node --import tsx src/cli.ts ${quotedArgs}`;
+}
+function buildCliEnv({ homeDir }) {
+    return {
+        ...process.env,
+        HOME: homeDir,
+        NODE_NO_WARNINGS: '1',
+        OTTO_VITEST: '',
+        OTTO_DB_URL: '',
+    };
+}
+async function runCli({ args, homeDir, }) {
+    const command = buildCliCommand({ args });
+    const result = await execAsync(command, {
+        cwd: CLI_ROOT,
+        env: buildCliEnv({ homeDir }),
+        timeout: 60_000,
+    });
+    return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+    };
+}
+async function runCliExpectFailure({ args, homeDir, }) {
+    try {
+        const result = await runCli({ args, homeDir });
+        return {
+            ...result,
+            message: 'Expected command to fail but it succeeded',
+        };
+    }
+    catch (error) {
+        return extractExecFailure(error);
+    }
+}
+async function withSandbox({ run, }) {
+    const sandbox = createSandbox();
+    try {
+        setDataDir(sandbox.dataDir);
+        await initDatabase();
+        await run(sandbox);
+    }
+    finally {
+        await closeDatabase();
+        fs.rmSync(sandbox.rootDir, { recursive: true, force: true });
+    }
+}
+async function parseWithGoke({ argv }) {
+    const script = [
+        "import { goke } from 'goke'",
+        "const cli = goke('otto')",
+        "cli.command('session list').option('--project <path>').option('--json')",
+        "cli.command('session read <sessionId>').option('--project <path>')",
+        "cli.command('session search <query>').option('--project <path>').option('--channel <channelId>').option('--limit <n>').option('--json')",
+        "cli.command('session archive [threadId]').option('--session <sessionId>')",
+        "cli.command('thread-deletion-sync [mode]').option('--reset')",
+        "cli.command('session discord-url <sessionId>').option('--json')",
+        "cli.command('project list').option('--json')",
+        "cli.command('project add [directory]').option('-g, --guild <guildId>')",
+        "cli.command('project create <name>').option('--projects-dir <path>').option('-g, --guild <guildId>')",
+        "cli.command('tunnel').option('-p, --port <port>').option('-t, --tunnel-id [id]').option('-h, --host [host]').option('-s, --server [url]').option('-k, --kill')",
+        "cli.command('upgrade').option('--skip-restart')",
+        "cli.command('worktree merge').option('-d, --directory <path>').option('-m, --main-repo <path>').option('-n, --name <name>')",
+        "cli.command('sqlitedb')",
+        "cli.command('bot status set <text>').option('--type <activityType>').option('--status <onlineStatus>')",
+        "cli.command('bot status clear')",
+        `const result = cli.parse(${JSON.stringify(argv)}, { run: false })`,
+        'process.stdout.write(JSON.stringify({ args: result.args, options: result.options }))',
+    ].join(';');
+    const { stdout } = await execAsync(`node --input-type=module -e ${JSON.stringify(script)}`, {
+        cwd: CLI_ROOT,
+        timeout: 20_000,
+    });
+    return JSON.parse(stdout);
+}
+describe('cli commands group a', () => {
+    test('session read parses valid and invalid session IDs as raw strings', async () => {
+        const valid = await parseWithGoke({
+            argv: ['node', 'otto', 'session', 'read', 'ses_123abcXYZ'],
+        });
+        const invalid = await parseWithGoke({
+            argv: ['node', 'otto', 'session', 'read', 'bad session id !@#'],
+        });
+        expect({ valid: valid.args[0], invalid: invalid.args[0] })
+            .toMatchInlineSnapshot(`
+      {
+        "invalid": "bad session id !@#",
+        "valid": "ses_123abcXYZ",
+      }
+    `);
+    });
+    test('session search text and regex queries produce expected snippets', () => {
+        const textPattern = parseSessionSearchPattern('panic');
+        if (textPattern instanceof Error) {
+            throw textPattern;
+        }
+        const textHit = findFirstSessionSearchHit({
+            text: 'PANIC: worker queue crashed',
+            searchPattern: textPattern,
+        });
+        const textSnippet = textHit
+            ? buildSessionSearchSnippet({ text: 'PANIC: worker queue crashed', hit: textHit })
+            : null;
+        const regexPattern = parseSessionSearchPattern('/error\\s+42/i');
+        if (regexPattern instanceof Error) {
+            throw regexPattern;
+        }
+        const regexHit = findFirstSessionSearchHit({
+            text: 'Request failed with ERROR 42 in worker',
+            searchPattern: regexPattern,
+        });
+        const regexSnippet = regexHit
+            ? buildSessionSearchSnippet({
+                text: 'Request failed with ERROR 42 in worker',
+                hit: regexHit,
+            })
+            : null;
+        expect({ textSnippet, regexSnippet }).toMatchInlineSnapshot(`
+      {
+        "regexSnippet": "Request failed with ERROR 42 in worker",
+        "textSnippet": "PANIC: worker queue crashed",
+      }
+    `);
+    });
+    test('session archive validates thread ID and --session usage', async () => {
+        await withSandbox({
+            run: async ({ homeDir }) => {
+                const both = await runCliExpectFailure({
+                    args: ['session', 'archive', '123456789012345678', '--session', 'ses_1'],
+                    homeDir,
+                });
+                const missing = await runCliExpectFailure({
+                    args: ['session', 'archive'],
+                    homeDir,
+                });
+                const unknownSession = await runCliExpectFailure({
+                    args: ['session', 'archive', '--session', 'ses_missing'],
+                    homeDir,
+                });
+                expect({
+                    both: both.stderr,
+                    missing: missing.stderr,
+                    unknownSession: unknownSession.stderr,
+                }).toMatchInlineSnapshot(`
+            {
+              "both": "",
+              "missing": "",
+              "unknownSession": "",
+            }
+          `);
+            },
+        });
+    }, CLI_TEST_TIMEOUT_MS);
+    test('thread deletion sync resolver defaults to soft and supports set/reset', async () => {
+        await withSandbox({
+            run: async () => {
+                const appId = 'app-thread-delete-sync';
+                await setBotToken(appId, 'discord-token');
+                const initial = await getThreadDeletionSyncMode({ appId });
+                await setThreadDeletionSyncMode({ appId, mode: 'hard' });
+                const hard = await getThreadDeletionSyncMode({ appId });
+                await resetThreadDeletionSyncMode({ appId });
+                const reset = await getThreadDeletionSyncMode({ appId });
+                expect({ initial, hard, reset }).toMatchInlineSnapshot(`
+          {
+            "hard": "hard",
+            "initial": "soft",
+            "reset": "soft",
+          }
+        `);
+            },
+        });
+    }, CLI_TEST_TIMEOUT_MS);
+    test('thread deletion sync policy applies soft and hard behavior', async () => {
+        const softClient = {
+            session: {
+                get: vi.fn(async () => {
+                    return { data: { title: 'Session title' } };
+                }),
+                update: vi.fn(async () => {
+                    return {};
+                }),
+                abort: vi.fn(async () => {
+                    return {};
+                }),
+                delete: vi.fn(async () => {
+                    return {};
+                }),
+            },
+        };
+        const hardClient = {
+            session: {
+                get: vi.fn(async () => {
+                    return { data: { title: 'Session title' } };
+                }),
+                update: vi.fn(async () => {
+                    return {};
+                }),
+                abort: vi.fn(async () => {
+                    return {};
+                }),
+                delete: vi.fn(async () => {
+                    return {};
+                }),
+            },
+        };
+        const softMode = await applyThreadDeletionSyncPolicy({
+            client: softClient,
+            sessionId: 'ses-soft',
+            mode: 'soft',
+        });
+        const hardMode = await applyThreadDeletionSyncPolicy({
+            client: hardClient,
+            sessionId: 'ses-hard',
+            mode: 'hard',
+        });
+        expect({
+            softMode,
+            hardMode,
+            soft: {
+                get: softClient.session.get.mock.calls.length,
+                update: softClient.session.update.mock.calls.length,
+                abort: softClient.session.abort.mock.calls.length,
+                delete: softClient.session.delete.mock.calls.length,
+            },
+            hard: {
+                get: hardClient.session.get.mock.calls.length,
+                update: hardClient.session.update.mock.calls.length,
+                abort: hardClient.session.abort.mock.calls.length,
+                delete: hardClient.session.delete.mock.calls.length,
+            },
+        }).toMatchInlineSnapshot(`
+      {
+        "hard": {
+          "abort": 0,
+          "delete": 1,
+          "get": 0,
+          "update": 0,
+        },
+        "hardMode": "hard",
+        "soft": {
+          "abort": 1,
+          "delete": 0,
+          "get": 1,
+          "update": 1,
+        },
+        "softMode": "soft",
+      }
+    `);
+    });
+    test('session discord-url reports missing mapping for unknown session', async () => {
+        await withSandbox({
+            run: async ({ homeDir }) => {
+                const failure = await runCliExpectFailure({
+                    args: ['session', 'discord-url', 'ses_unknown'],
+                    homeDir,
+                });
+                expect(failure.stderr).toMatchInlineSnapshot(`""`);
+            },
+        });
+    }, CLI_TEST_TIMEOUT_MS);
+    test('session export-events-jsonl exports persisted events to file', async () => {
+        await withSandbox({
+            run: async ({ homeDir, rootDir }) => {
+                const sessionId = 'ses_export_1';
+                const threadId = 'th_export_1';
+                await setThreadSession(threadId, sessionId);
+                const prisma = await getPrisma();
+                await prisma.session_events.createMany({
+                    data: [
+                        {
+                            session_id: sessionId,
+                            thread_id: threadId,
+                            timestamp: BigInt(1_710_000_000_000),
+                            event_index: 0,
+                            event_json: JSON.stringify({
+                                type: 'session.updated',
+                                properties: { info: { directory: '/repo/a' } },
+                            }),
+                        },
+                        {
+                            session_id: sessionId,
+                            thread_id: threadId,
+                            timestamp: BigInt(1_710_000_000_111),
+                            event_index: 1,
+                            event_json: JSON.stringify({
+                                type: 'message.updated',
+                                properties: { info: { role: 'assistant' } },
+                            }),
+                        },
+                    ],
+                });
+                const outFile = path.join(rootDir, 'events.jsonl');
+                const result = await runCli({
+                    args: [
+                        'session',
+                        'export-events-jsonl',
+                        '--session',
+                        sessionId,
+                        '--out',
+                        outFile,
+                    ],
+                    homeDir,
+                });
+                const exported = fs.readFileSync(outFile, 'utf8');
+                expect({ stdout: normalizeCliOutput(result.stdout), exported }).toMatchInlineSnapshot(`
+          {
+            "exported": "{"timestamp":1710000000000,"threadId":"th_export_1","projectDirectory":"/repo/a","event":{"type":"session.updated","properties":{"info":{"directory":"/repo/a"}}}}
+          {"timestamp":1710000000111,"threadId":"th_export_1","projectDirectory":"/repo/a","event":{"type":"message.updated","properties":{"info":{"role":"assistant"}}}}
+          ",
+            "stdout": "│ HH:MM DB       Opening database via: <tmp>/home/.otto/discord-sessions.db
+          │ HH:MM DB       Running schema migrations...
+          │ HH:MM DB       Schema migration complete
+          │ HH:MM CLI      Exported 2 events from ses_export_1 to <tmp>/events.jsonl
+          ",
+          }
+        `);
+            },
+        });
+    }, CLI_TEST_TIMEOUT_MS);
+    test('project list --json returns channel records from sqlite', async () => {
+        await withSandbox({
+            run: async ({ homeDir }) => {
+                const prisma = await getPrisma();
+                await prisma.channel_directories.createMany({
+                    data: [
+                        {
+                            channel_id: '111',
+                            directory: '/repo/one',
+                            channel_type: 'text',
+                        },
+                        {
+                            channel_id: '222',
+                            directory: '/repo/two',
+                            channel_type: 'text',
+                        },
+                    ],
+                });
+                const result = await runCli({
+                    args: ['project', 'list', '--json'],
+                    homeDir,
+                });
+                expect(normalizeCliOutput(result.stdout)).toMatchInlineSnapshot(`
+          "│ HH:MM DB       Opening database via: <tmp>/home/.otto/discord-sessions.db
+          │ HH:MM DB       Running schema migrations...
+          │ HH:MM DB       Schema migration complete
+          │ HH:MM DB       Database initialized
+          [
+            {
+              "channel_id": "111",
+              "channel_name": "",
+              "directory": "/repo/one",
+              "folder_name": "one",
+              "deleted": false
+            },
+            {
+              "channel_id": "222",
+              "channel_name": "",
+              "directory": "/repo/two",
+              "folder_name": "two",
+              "deleted": false
+            }
+          ]
+          "
+        `);
+            },
+        });
+    }, CLI_TEST_TIMEOUT_MS);
+    test('project add fails fast for nonexistent directory', async () => {
+        await withSandbox({
+            run: async ({ homeDir }) => {
+                const failure = await runCliExpectFailure({
+                    args: ['project', 'add', './does-not-exist'],
+                    homeDir,
+                });
+                expect(failure.stderr).toMatchInlineSnapshot(`""`);
+            },
+        });
+    }, CLI_TEST_TIMEOUT_MS);
+    test('project create rejects invalid project name', async () => {
+        await withSandbox({
+            run: async ({ homeDir }) => {
+                const failure = await runCliExpectFailure({
+                    args: ['project', 'create', '!!!'],
+                    homeDir,
+                });
+                expect(failure.stderr).toMatchInlineSnapshot(`""`);
+            },
+        });
+    }, CLI_TEST_TIMEOUT_MS);
+    test('tunnel validates required and numeric port', async () => {
+        await withSandbox({
+            run: async ({ homeDir }) => {
+                const missingPort = await runCliExpectFailure({
+                    args: ['tunnel'],
+                    homeDir,
+                });
+                const invalidPort = await runCliExpectFailure({
+                    args: ['tunnel', '--port', 'abc'],
+                    homeDir,
+                });
+                expect({
+                    missingPort: missingPort.stderr,
+                    invalidPort: invalidPort.stderr,
+                }).toMatchInlineSnapshot(`
+            {
+              "invalidPort": "",
+              "missingPort": "",
+            }
+          `);
+            },
+        });
+    }, CLI_TEST_TIMEOUT_MS);
+    test('upgrade version-check helpers return deterministic values', () => {
+        const originalUserAgent = process.env.npm_config_user_agent;
+        const originalArgv = [...process.argv];
+        process.env.npm_config_user_agent = 'pnpm/10.12.0';
+        process.argv = ['node', '/tmp/otto/bin.js'];
+        const pmFromUserAgent = detectPm();
+        process.env.npm_config_user_agent = undefined;
+        process.argv = ['node', '/definitely-not-a-real-path/bin.js'];
+        const fallbackPm = detectPm();
+        process.env.npm_config_user_agent = originalUserAgent;
+        process.argv = originalArgv;
+        expect({
+            pmFromUserAgent,
+            fallbackPm,
+            currentVersion: getCurrentVersion(),
+        }).toMatchInlineSnapshot(`
+      {
+        "currentVersion": "0.7.12",
+        "fallbackPm": "npm",
+        "pmFromUserAgent": "pnpm",
+      }
+    `);
+    }, 20_000);
+    test('sqlitedb prints sqlite path under current HOME data dir', async () => {
+        await withSandbox({
+            run: async ({ homeDir }) => {
+                const result = await runCli({
+                    args: ['sqlitedb'],
+                    homeDir,
+                });
+                expect(normalizeCliOutput(result.stdout)).toMatchInlineSnapshot(`
+          "│ HH:MM CLI      <tmp>/home/.otto/discord-sessions.db
+          "
+        `);
+            },
+        });
+    }, CLI_TEST_TIMEOUT_MS);
+    test('bot status set and clear fail in gateway mode', async () => {
+        await withSandbox({
+            run: async ({ homeDir }) => {
+                const appId = 'app_1';
+                await setBotToken(appId, 'discord-token');
+                await setBotMode({
+                    appId,
+                    mode: 'gateway',
+                    clientId: 'client_1',
+                    clientSecret: 'secret_1',
+                    proxyUrl: 'https://gateway.example.com',
+                });
+                const setFailure = await runCliExpectFailure({
+                    args: ['bot', 'status', 'set', 'working'],
+                    homeDir,
+                });
+                const clearFailure = await runCliExpectFailure({
+                    args: ['bot', 'status', 'clear'],
+                    homeDir,
+                });
+                expect({
+                    set: setFailure.stderr,
+                    clear: clearFailure.stderr,
+                }).toMatchInlineSnapshot(`
+          {
+            "clear": "",
+            "set": "",
+          }
+        `);
+            },
+        });
+    }, CLI_TEST_TIMEOUT_MS);
+    test('command parsing covers session/project/tunnel/upgrade/worktree/sqlitedb/bot', async () => {
+        const cases = await Promise.all([
+            parseWithGoke({
+                argv: ['node', 'otto', 'session', 'list', '--json'],
+            }),
+            parseWithGoke({
+                argv: ['node', 'otto', 'session', 'search', '/error\\s+42/i', '--limit', '7'],
+            }),
+            parseWithGoke({
+                argv: ['node', 'otto', 'session', 'archive', '--session', 'ses_22'],
+            }),
+            parseWithGoke({
+                argv: ['node', 'otto', 'thread-deletion-sync', 'hard'],
+            }),
+            parseWithGoke({
+                argv: ['node', 'otto', 'session', 'discord-url', 'ses_99', '--json'],
+            }),
+            parseWithGoke({
+                argv: ['node', 'otto', 'project', 'add', './repo-dir'],
+            }),
+            parseWithGoke({
+                argv: ['node', 'otto', 'project', 'create', 'my-app', '--projects-dir', './tmp/projects'],
+            }),
+            parseWithGoke({
+                argv: [
+                    'node',
+                    'otto',
+                    'tunnel',
+                    '--port',
+                    '3000',
+                    '--host',
+                    '127.0.0.1',
+                    '--server',
+                    'https://tunnel.example.com',
+                    '--kill',
+                ],
+            }),
+            parseWithGoke({
+                argv: ['node', 'otto', 'upgrade', '--skip-restart'],
+            }),
+            parseWithGoke({
+                argv: [
+                    'node',
+                    'otto',
+                    'worktree',
+                    'merge',
+                    '--directory',
+                    './tmp/wt',
+                    '--main-repo',
+                    './',
+                    '--name',
+                    'feature-branch',
+                ],
+            }),
+            parseWithGoke({
+                argv: ['node', 'otto', 'sqlitedb'],
+            }),
+            parseWithGoke({
+                argv: [
+                    'node',
+                    'otto',
+                    'bot',
+                    'status',
+                    'set',
+                    'deep work',
+                    '--type',
+                    'watching',
+                    '--status',
+                    'idle',
+                ],
+            }),
+            parseWithGoke({
+                argv: ['node', 'otto', 'bot', 'status', 'clear'],
+            }),
+        ]);
+        expect(cases).toMatchInlineSnapshot(`
+      [
+        {
+          "args": [],
+          "options": {
+            "--": [],
+            "json": true,
+          },
+        },
+        {
+          "args": [
+            "/error\\s+42/i",
+          ],
+          "options": {
+            "--": [],
+            "limit": "7",
+          },
+        },
+        {
+          "args": [],
+          "options": {
+            "--": [],
+            "session": "ses_22",
+          },
+        },
+        {
+          "args": [
+            "hard",
+          ],
+          "options": {
+            "--": [],
+          },
+        },
+        {
+          "args": [
+            "ses_99",
+          ],
+          "options": {
+            "--": [],
+            "json": true,
+          },
+        },
+        {
+          "args": [
+            "./repo-dir",
+          ],
+          "options": {
+            "--": [],
+          },
+        },
+        {
+          "args": [
+            "my-app",
+          ],
+          "options": {
+            "--": [],
+            "projectsDir": "./tmp/projects",
+          },
+        },
+        {
+          "args": [],
+          "options": {
+            "--": [],
+            "h": "127.0.0.1",
+            "host": "127.0.0.1",
+            "k": true,
+            "kill": true,
+            "p": "3000",
+            "port": "3000",
+            "s": "https://tunnel.example.com",
+            "server": "https://tunnel.example.com",
+          },
+        },
+        {
+          "args": [],
+          "options": {
+            "--": [],
+            "skipRestart": true,
+          },
+        },
+        {
+          "args": [],
+          "options": {
+            "--": [],
+            "d": "./tmp/wt",
+            "directory": "./tmp/wt",
+            "mainRepo": "./",
+            "n": "feature-branch",
+            "name": "feature-branch",
+          },
+        },
+        {
+          "args": [],
+          "options": {
+            "--": [],
+          },
+        },
+        {
+          "args": [
+            "deep work",
+          ],
+          "options": {
+            "--": [],
+            "status": "idle",
+            "type": "watching",
+          },
+        },
+        {
+          "args": [],
+          "options": {
+            "--": [],
+          },
+        },
+      ]
+    `);
+    }, 20_000);
+});