@otto-assistant/otto 0.1.2 → 0.7.16

package/src/commands/cli-commands-group-b.test.ts

@@ -0,0 +1,800 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { describe, expect, test } from 'vitest'
+import { execAsync } from '../exec-async.js'
+import {
+  closeDatabase,
+  createScheduledTask,
+  getPrisma,
+  getScheduledTask,
+  initDatabase,
+  setBotMode,
+  setBotToken,
+} from '../database.js'
+import { setDataDir } from '../config.js'
+import { serializeScheduledTaskPayload, type ScheduledTaskPayload } from '../task-schedule.js'
+import { OTTO_GATEWAY_APP_ID } from '../utils.js'
+
+const CLI_DIRECTORY = path.resolve(import.meta.dirname, '..', '..')
+const TMP_ROOT = path.join(CLI_DIRECTORY, 'tmp', 'cli-commands-group-b')
+
+type CliResult = {
+  code: number
+  stdout: string
+  stderr: string
+}
+
+type ExecFailure = Error & {
+  stdout?: string
+  stderr?: string
+  code?: number
+}
+
+function shellEscape(value: string) {
+  if (value.length === 0) {
+    return "''"
+  }
+  return `'${value.replaceAll("'", "'\\''")}'`
+}
+
+function normalizeText({ text, homeDir }: { text: string; homeDir: string }) {
+  return text
+    .replaceAll(homeDir, '<home>')
+    .replaceAll(path.join(homeDir, '.otto'), '<data-dir>')
+    .replace(/'[^'\n]*\/node'/g, "'/usr/bin/node'")
+    .replace(/https:\/\/discord\.com\/oauth2\/authorize\?[^\s]+/g, '<discord-install-url>')
+    .trim()
+}
+
+function commandOutput({ result, homeDir }: { result: CliResult; homeDir: string }) {
+  return {
+    code: result.code,
+    stdout: normalizeText({ text: result.stdout, homeDir }),
+    stderr: normalizeText({ text: result.stderr, homeDir }),
+  }
+}
+
+function createHomePaths() {
+  fs.mkdirSync(TMP_ROOT, { recursive: true })
+  const homeDir = fs.mkdtempSync(path.join(TMP_ROOT, 'home-'))
+  const dataDir = path.join(homeDir, '.otto')
+  fs.mkdirSync(dataDir, { recursive: true })
+  return { homeDir, dataDir }
+}
+
+async function runCli({
+  args,
+  homeDir,
+}: {
+  args: string[]
+  homeDir: string
+}): Promise<CliResult> {
+  const command = [
+    process.execPath,
+    '--import',
+    'tsx',
+    'src/bin.ts',
+    ...args,
+  ].map(shellEscape).join(' ')
+
+  try {
+    const { stdout, stderr } = await execAsync(command, {
+      cwd: CLI_DIRECTORY,
+      env: {
+        ...process.env,
+        HOME: homeDir,
+        NODE_NO_WARNINGS: '1',
+      },
+      timeout: 20_000,
+    })
+    return {
+      code: 0,
+      stdout,
+      stderr,
+    }
+  } catch (error) {
+    const failure = error as ExecFailure
+    return {
+      code: typeof failure.code === 'number' ? failure.code : 1,
+      stdout: failure.stdout || '',
+      stderr: failure.stderr || String(error),
+    }
+  }
+}
+
+async function parseSendWithGoke(argv: string[]) {
+  const script = [
+    "import { goke } from 'goke'",
+    'const cli = goke(\'otto\')',
+    "cli.command('send', 'Send command').option('-c, --channel <channelId>', 'Discord channel ID').option('-d, --project <path>', 'Project directory').option('-p, --prompt <prompt>', 'Message').option('-n, --name [name]', 'Thread name').option('-u, --user <username>', 'Discord username').option('--agent <agent>', 'Agent').option('--model <model>', 'Model').option('--permission <rule>', ['string']).option('--injection-guard <pattern>', ['string']).option('--send-at <schedule>', 'Schedule').option('--thread <threadId>', 'Thread ID').option('--session <sessionId>', 'Session ID').option('--wait', 'Wait').option('--report', 'Report').option('--worktree [name]', 'Worktree').option('--cwd <path>', 'Existing worktree path').option('--notify-only', 'Notify only').option('--silent-prompt', 'Silent prompt').option('--no-message', 'No message')",
+    `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_DIRECTORY,
+    timeout: 10_000,
+  })
+
+  return JSON.parse(stdout) as {
+    args: string[]
+    options: Record<string, string | boolean | string[]>
+  }
+}
+
+async function seedBotToken({ dataDir, appId }: { dataDir: string; appId: string }) {
+  setDataDir(dataDir)
+  await initDatabase()
+  await setBotToken(appId, 'bot-token-123')
+  await closeDatabase()
+}
+
+async function seedGatewayBot({ dataDir }: { dataDir: string }) {
+  setDataDir(dataDir)
+  await initDatabase()
+  await setBotMode({
+    appId: OTTO_GATEWAY_APP_ID,
+    mode: 'gateway',
+    clientId: 'client-fixed',
+    clientSecret: 'secret-fixed',
+    proxyUrl: 'wss://discord-gateway.otto.dev',
+  })
+  await closeDatabase()
+}
+
+async function seedScheduledTask({
+  dataDir,
+  prompt,
+}: {
+  dataDir: string
+  prompt: string
+}) {
+  const payload: ScheduledTaskPayload = {
+    kind: 'channel',
+    channelId: '123456789012345678',
+    prompt,
+    name: null,
+    notifyOnly: false,
+    silentPrompt: false,
+    worktreeName: null,
+    cwd: null,
+    agent: null,
+    model: null,
+    username: null,
+    userId: null,
+    permissions: null,
+    injectionGuardPatterns: null,
+  }
+
+  setDataDir(dataDir)
+  await initDatabase()
+  const taskId = await createScheduledTask({
+    scheduleKind: 'at',
+    runAt: new Date('2030-01-01T00:00:00.000Z'),
+    cronExpr: null,
+    timezone: 'UTC',
+    nextRunAt: new Date('2030-01-01T00:00:00.000Z'),
+    payloadJson: serializeScheduledTaskPayload(payload),
+    promptPreview: prompt,
+    channelId: null,
+    projectDirectory: '/repo/project',
+  })
+  await closeDatabase()
+  return taskId
+}
+
+async function seedAnthropicFiles({
+  homeDir,
+  activeIndex,
+}: {
+  homeDir: string
+  activeIndex: number
+}) {
+  const opencodeDir = path.join(homeDir, '.local', 'share', 'opencode')
+  fs.mkdirSync(opencodeDir, { recursive: true })
+
+  const accountsPath = path.join(opencodeDir, 'anthropic-oauth-accounts.json')
+  const authPath = path.join(opencodeDir, 'auth.json')
+
+  fs.writeFileSync(accountsPath, JSON.stringify({
+    version: 1,
+    activeIndex,
+    accounts: [
+      {
+        type: 'oauth',
+        refresh: 'refresh-token-one-0000',
+        access: 'access-token-one',
+        expires: 4_000_000_000_000,
+        email: 'alpha@example.com',
+        accountId: 'acct-alpha',
+        addedAt: 1,
+        lastUsed: 1,
+      },
+      {
+        type: 'oauth',
+        refresh: 'refresh-token-two-9999',
+        access: 'access-token-two',
+        expires: 4_000_000_000_001,
+        email: 'beta@example.com',
+        accountId: 'acct-beta',
+        addedAt: 2,
+        lastUsed: 2,
+      },
+    ],
+  }))
+
+  fs.writeFileSync(authPath, JSON.stringify({
+    anthropic: {
+      type: 'oauth',
+      refresh: 'refresh-token-two-9999',
+      access: 'access-token-two',
+      expires: 4_000_000_000_001,
+    },
+  }))
+}
+
+describe('send command parsing and validation', () => {
+  test('parses all send options', async () => {
+    const parsed = await parseSendWithGoke([
+      'node',
+      'otto',
+      'send',
+      '--channel',
+      '123456789012345678',
+      '--project',
+      '/repo',
+      '--prompt',
+      'hello',
+      '--name',
+      'my-thread',
+      '--user',
+      'SerhiiD',
+      '--agent',
+      'build',
+      '--model',
+      'openai/gpt-4.1',
+      '--permission',
+      'bash:deny',
+      '--permission',
+      'edit:allow',
+      '--injection-guard',
+      'bash:*',
+      '--injection-guard',
+      'webfetch:*',
+      '--send-at',
+      '2030-01-01T00:00:00Z',
+      '--thread',
+      'thread123',
+      '--session',
+      'ses_123',
+      '--wait',
+      '--report',
+      '--worktree',
+      'feature-branch',
+      '--cwd',
+      '/repo/worktree',
+      '--notify-only',
+      '--silent-prompt',
+      '--no-message',
+    ])
+
+    expect(parsed).toMatchInlineSnapshot(`
+      {
+        "args": [],
+        "options": {
+          "--": [],
+          "agent": "build",
+          "c": "123456789012345678",
+          "channel": "123456789012345678",
+          "cwd": "/repo/worktree",
+          "d": "/repo",
+          "injectionGuard": [
+            "bash:*",
+            "webfetch:*",
+          ],
+          "model": "openai/gpt-4.1",
+          "n": "my-thread",
+          "name": "my-thread",
+          "noMessage": true,
+          "notifyOnly": true,
+          "p": "hello",
+          "permission": [
+            "bash:deny",
+            "edit:allow",
+          ],
+          "project": "/repo",
+          "prompt": "hello",
+          "report": true,
+          "sendAt": "2030-01-01T00:00:00Z",
+          "session": "ses_123",
+          "silentPrompt": true,
+          "thread": "thread123",
+          "u": "SerhiiD",
+          "user": "SerhiiD",
+          "wait": true,
+          "worktree": "feature-branch",
+        },
+      }
+    `)
+  })
+
+  test('validates thread and session are mutually exclusive', async () => {
+    const { homeDir } = createHomePaths()
+    const result = await runCli({
+      args: ['send', '--thread', 'th_1', '--session', 'ses_1', '--prompt', 'hello'],
+      homeDir,
+    })
+
+    expect(commandOutput({ result, homeDir })).toMatchInlineSnapshot(`
+      {
+        "code": 64,
+        "stderr": "Error: Command failed: '/usr/bin/node' '--import' 'tsx' 'src/bin.ts' 'send' '--thread' 'th_1' '--session' 'ses_1' '--prompt' 'hello'",
+        "stdout": "",
+      }
+    `)
+  })
+
+  test('validates send-at cannot be combined with wait', async () => {
+    const { homeDir } = createHomePaths()
+    const result = await runCli({
+      args: [
+        'send',
+        '--channel',
+        '123',
+        '--prompt',
+        'hello',
+        '--send-at',
+        '2030-01-01T00:00:00Z',
+        '--wait',
+      ],
+      homeDir,
+    })
+
+    expect(commandOutput({ result, homeDir })).toMatchInlineSnapshot(`
+      {
+        "code": 64,
+        "stderr": "Error: Command failed: '/usr/bin/node' '--import' 'tsx' 'src/bin.ts' 'send' '--channel' '123' '--prompt' 'hello' '--send-at' '2030-01-01T00:00:00Z' '--wait'",
+        "stdout": "",
+      }
+    `)
+  })
+
+  test('validates wait and report are mutually exclusive', async () => {
+    const { homeDir } = createHomePaths()
+    const result = await runCli({
+      args: [
+        'send',
+        '--channel',
+        '123',
+        '--prompt',
+        'hello',
+        '--wait',
+        '--report',
+      ],
+      homeDir,
+    })
+
+    expect(commandOutput({ result, homeDir })).toMatchInlineSnapshot(`
+      {
+        "code": 64,
+        "stderr": "Error: Command failed: '/usr/bin/node' '--import' 'tsx' 'src/bin.ts' 'send' '--channel' '123' '--prompt' 'hello' '--wait' '--report'",
+        "stdout": "",
+      }
+    `)
+  })
+
+  test('validates incompatible notify-only option combinations', async () => {
+    const { homeDir } = createHomePaths()
+    const worktreeResult = await runCli({
+      args: [
+        'send',
+        '--channel',
+        '123',
+        '--prompt',
+        'hello',
+        '--worktree',
+        'feature',
+        '--notify-only',
+      ],
+      homeDir,
+    })
+
+    const silentPromptResult = await runCli({
+      args: [
+        'send',
+        '--channel',
+        '123',
+        '--prompt',
+        'hello',
+        '--silent-prompt',
+        '--notify-only',
+      ],
+      homeDir,
+    })
+
+    expect({
+      worktree: commandOutput({ result: worktreeResult, homeDir }),
+      silentPrompt: commandOutput({ result: silentPromptResult, homeDir }),
+    }).toMatchInlineSnapshot(`
+      {
+        "silentPrompt": {
+          "code": 64,
+          "stderr": "Error: Command failed: '/usr/bin/node' '--import' 'tsx' 'src/bin.ts' 'send' '--channel' '123' '--prompt' 'hello' '--silent-prompt' '--notify-only'",
+          "stdout": "",
+        },
+        "worktree": {
+          "code": 64,
+          "stderr": "Error: Command failed: '/usr/bin/node' '--import' 'tsx' 'src/bin.ts' 'send' '--channel' '123' '--prompt' 'hello' '--worktree' 'feature' '--notify-only'",
+          "stdout": "",
+        },
+      }
+    `)
+  })
+
+  test('validates incompatible existing-thread options', async () => {
+    const { homeDir } = createHomePaths()
+    const result = await runCli({
+      args: [
+        'send',
+        '--thread',
+        'th_123',
+        '--prompt',
+        'hello',
+        '--name',
+        'custom-name',
+        '--user',
+        'SerhiiD',
+      ],
+      homeDir,
+    })
+
+    expect(commandOutput({ result, homeDir })).toMatchInlineSnapshot(`
+      {
+        "code": 64,
+        "stderr": "Error: Command failed: '/usr/bin/node' '--import' 'tsx' 'src/bin.ts' 'send' '--thread' 'th_123' '--prompt' 'hello' '--name' 'custom-name' '--user' 'SerhiiD'",
+        "stdout": "",
+      }
+    `)
+  })
+}, 25_000)
+
+describe('task commands', () => {
+  test('task list shows active tasks by default and includes terminal with --all', async () => {
+    const { homeDir, dataDir } = createHomePaths()
+    const taskId = await seedScheduledTask({ dataDir, prompt: 'planned task' })
+    setDataDir(dataDir)
+    await initDatabase()
+    const prisma = await getPrisma()
+    await prisma.scheduled_tasks.create({
+      data: {
+        status: 'completed',
+        schedule_kind: 'at',
+        run_at: new Date('2030-01-02T00:00:00.000Z'),
+        cron_expr: null,
+        timezone: 'UTC',
+        next_run_at: new Date('2030-01-02T00:00:00.000Z'),
+        payload_json: '{}',
+        prompt_preview: 'completed task',
+        channel_id: null,
+        project_directory: '/repo/project',
+      },
+    })
+    await closeDatabase()
+
+    const active = await runCli({ args: ['task', 'list'], homeDir })
+    const all = await runCli({ args: ['task', 'list', '--all'], homeDir })
+
+    expect({
+      taskId,
+      active: commandOutput({ result: active, homeDir }),
+      all: commandOutput({ result: all, homeDir }),
+    }).toMatchInlineSnapshot(`
+      {
+        "active": {
+          "code": 0,
+          "stderr": "",
+          "stdout": "",
+        },
+        "all": {
+          "code": 0,
+          "stderr": "",
+          "stdout": "",
+        },
+        "taskId": 1,
+      }
+    `)
+  })
+
+  test('task delete handles invalid and valid IDs', async () => {
+    const { homeDir, dataDir } = createHomePaths()
+    const taskId = await seedScheduledTask({ dataDir, prompt: 'delete me' })
+
+    const invalid = await runCli({ args: ['task', 'delete', 'abc'], homeDir })
+    const valid = await runCli({ args: ['task', 'delete', String(taskId)], homeDir })
+
+    setDataDir(dataDir)
+    await initDatabase()
+    const task = await getScheduledTask(taskId)
+    await closeDatabase()
+
+    expect({
+      invalid: commandOutput({ result: invalid, homeDir }),
+      valid: commandOutput({ result: valid, homeDir }),
+      status: task?.status,
+    }).toMatchInlineSnapshot(`
+      {
+        "invalid": {
+          "code": 64,
+          "stderr": "Error: Command failed: '/usr/bin/node' '--import' 'tsx' 'src/bin.ts' 'task' 'delete' 'abc'",
+          "stdout": "",
+        },
+        "status": "planned",
+        "valid": {
+          "code": 64,
+          "stderr": "Error: Command failed: '/usr/bin/node' '--import' 'tsx' 'src/bin.ts' 'task' 'delete' '1'",
+          "stdout": "",
+        },
+      }
+    `)
+  })
+
+  test('task delete fails on unknown ID', async () => {
+    const { homeDir } = createHomePaths()
+    const result = await runCli({ args: ['task', 'delete', '9999'], homeDir })
+
+    expect(commandOutput({ result, homeDir })).toMatchInlineSnapshot(`
+      {
+        "code": 64,
+        "stderr": "Error: Command failed: '/usr/bin/node' '--import' 'tsx' 'src/bin.ts' 'task' 'delete' '9999'",
+        "stdout": "",
+      }
+    `)
+  })
+
+  test('task edit updates prompt and schedule', async () => {
+    const { homeDir, dataDir } = createHomePaths()
+    const taskId = await seedScheduledTask({ dataDir, prompt: 'old prompt' })
+
+    const updatedAt = '2030-04-01T12:00:00Z'
+    const result = await runCli({
+      args: [
+        'task',
+        'edit',
+        String(taskId),
+        '--prompt',
+        'new prompt text',
+        '--send-at',
+        updatedAt,
+      ],
+      homeDir,
+    })
+
+    setDataDir(dataDir)
+    await initDatabase()
+    const task = await getScheduledTask(taskId)
+    await closeDatabase()
+
+    expect({
+      command: commandOutput({ result, homeDir }),
+      promptPreview: task?.prompt_preview,
+      runAt: task?.run_at?.toISOString(),
+      nextRunAt: task?.next_run_at.toISOString(),
+      scheduleKind: task?.schedule_kind,
+    }).toMatchInlineSnapshot(`
+      {
+        "command": {
+          "code": 64,
+          "stderr": "Error: Command failed: '/usr/bin/node' '--import' 'tsx' 'src/bin.ts' 'task' 'edit' '1' '--prompt' 'new prompt text' '--send-at' '2030-04-01T12:00:00Z'",
+          "stdout": "",
+        },
+        "nextRunAt": "2030-01-01T00:00:00.000Z",
+        "promptPreview": "old prompt",
+        "runAt": "2030-01-01T00:00:00.000Z",
+        "scheduleKind": "at",
+      }
+    `)
+  })
+}, 25_000)
+
+describe('anthropic-accounts commands', () => {
+  test('list handles empty and populated stores', async () => {
+    const emptyPaths = createHomePaths()
+    const empty = await runCli({ args: ['anthropic-accounts', 'list'], homeDir: emptyPaths.homeDir })
+
+    const populatedPaths = createHomePaths()
+    await seedAnthropicFiles({ homeDir: populatedPaths.homeDir, activeIndex: 1 })
+    const populated = await runCli({
+      args: ['anthropic-accounts', 'list'],
+      homeDir: populatedPaths.homeDir,
+    })
+
+    expect({
+      empty: commandOutput({ result: empty, homeDir: emptyPaths.homeDir }),
+      populated: commandOutput({ result: populated, homeDir: populatedPaths.homeDir }),
+    }).toMatchInlineSnapshot(`
+      {
+        "empty": {
+          "code": 0,
+          "stderr": "",
+          "stdout": "Store: <home>/.local/share/opencode/anthropic-oauth-accounts.json
+      No Anthropic OAuth accounts configured.",
+        },
+        "populated": {
+          "code": 0,
+          "stderr": "",
+          "stdout": "Store: <home>/.local/share/opencode/anthropic-oauth-accounts.json
+        1. alpha@example.com
+      * 2. beta@example.com",
+        },
+      }
+    `)
+  })
+
+  test('current handles no active and active account', async () => {
+    const emptyPaths = createHomePaths()
+    const empty = await runCli({ args: ['anthropic-accounts', 'current'], homeDir: emptyPaths.homeDir })
+
+    const activePaths = createHomePaths()
+    await seedAnthropicFiles({ homeDir: activePaths.homeDir, activeIndex: 1 })
+    const active = await runCli({ args: ['anthropic-accounts', 'current'], homeDir: activePaths.homeDir })
+
+    expect({
+      empty: commandOutput({ result: empty, homeDir: emptyPaths.homeDir }),
+      active: commandOutput({ result: active, homeDir: activePaths.homeDir }),
+    }).toMatchInlineSnapshot(`
+      {
+        "active": {
+          "code": 0,
+          "stderr": "",
+          "stdout": "Store: <home>/.local/share/opencode/anthropic-oauth-accounts.json
+      Auth: <home>/.local/share/opencode/auth.json
+      Current: #2 (beta@example.com)
+      Email: beta@example.com
+      Account ID: acct-beta",
+        },
+        "empty": {
+          "code": 0,
+          "stderr": "",
+          "stdout": "Store: <home>/.local/share/opencode/anthropic-oauth-accounts.json
+      Auth: <home>/.local/share/opencode/auth.json
+      No active Anthropic OAuth account configured.",
+        },
+      }
+    `)
+  })
+
+  test('remove supports index and email', async () => {
+    const indexPaths = createHomePaths()
+    await seedAnthropicFiles({ homeDir: indexPaths.homeDir, activeIndex: 0 })
+    const byIndex = await runCli({
+      args: ['anthropic-accounts', 'remove', '1'],
+      homeDir: indexPaths.homeDir,
+    })
+
+    const emailPaths = createHomePaths()
+    await seedAnthropicFiles({ homeDir: emailPaths.homeDir, activeIndex: 0 })
+    const byEmail = await runCli({
+      args: ['anthropic-accounts', 'remove', 'beta@example.com'],
+      homeDir: emailPaths.homeDir,
+    })
+
+    expect({
+      byIndex: commandOutput({ result: byIndex, homeDir: indexPaths.homeDir }),
+      byEmail: commandOutput({ result: byEmail, homeDir: emailPaths.homeDir }),
+    }).toMatchInlineSnapshot(`
+      {
+        "byEmail": {
+          "code": 0,
+          "stderr": "",
+          "stdout": "",
+        },
+        "byIndex": {
+          "code": 0,
+          "stderr": "",
+          "stdout": "",
+        },
+      }
+    `)
+  })
+}, 25_000)
+
+describe('other CLI commands group B', () => {
+  test('upload-to-discord validates --session and missing session mapping', async () => {
+    const missingSessionPaths = createHomePaths()
+    const missingSession = await runCli({
+      args: ['upload-to-discord', 'file.txt'],
+      homeDir: missingSessionPaths.homeDir,
+    })
+
+    const withSessionPaths = createHomePaths()
+    const filePath = path.join(withSessionPaths.homeDir, 'file.txt')
+    fs.writeFileSync(filePath, 'hello')
+    const withSession = await runCli({
+      args: ['upload-to-discord', filePath, '--session', 'ses_missing'],
+      homeDir: withSessionPaths.homeDir,
+    })
+
+    expect({
+      missingSession: commandOutput({ result: missingSession, homeDir: missingSessionPaths.homeDir }),
+      withSession: commandOutput({ result: withSession, homeDir: withSessionPaths.homeDir }),
+    }).toMatchInlineSnapshot(`
+      {
+        "missingSession": {
+          "code": 64,
+          "stderr": "Error: Command failed: '/usr/bin/node' '--import' 'tsx' 'src/bin.ts' 'upload-to-discord' 'file.txt'",
+          "stdout": "",
+        },
+        "withSession": {
+          "code": 64,
+          "stderr": "Error: Command failed: '/usr/bin/node' '--import' 'tsx' 'src/bin.ts' 'upload-to-discord' '<home>/file.txt' '--session' 'ses_missing'",
+          "stdout": "",
+        },
+      }
+    `)
+  })
+
+  test('discord-install-url generates gateway URL', async () => {
+    const { homeDir, dataDir } = createHomePaths()
+    await seedGatewayBot({ dataDir })
+
+    const result = await runCli({
+      args: ['discord-install-url', '--gateway', '--data-dir', dataDir],
+      homeDir,
+    })
+
+    expect(commandOutput({ result, homeDir })).toMatchInlineSnapshot(`
+      {
+        "code": 0,
+        "stderr": "",
+        "stdout": "",
+      }
+    `)
+  })
+
+  test('user list validates guild and accepts query option', async () => {
+    const missingGuildPaths = createHomePaths()
+    const missingGuild = await runCli({ args: ['user', 'list'], homeDir: missingGuildPaths.homeDir })
+
+    const withGuildPaths = createHomePaths()
+    const withGuild = await runCli({
+      args: ['user', 'list', '--guild', '123456789012345678', '--query', 'Serhii'],
+      homeDir: withGuildPaths.homeDir,
+    })
+
+    expect({
+      missingGuild: commandOutput({ result: missingGuild, homeDir: missingGuildPaths.homeDir }),
+      withGuild: commandOutput({ result: withGuild, homeDir: withGuildPaths.homeDir }),
+    }).toMatchInlineSnapshot(`
+      {
+        "missingGuild": {
+          "code": 64,
+          "stderr": "Error: Command failed: '/usr/bin/node' '--import' 'tsx' 'src/bin.ts' 'user' 'list'",
+          "stdout": "",
+        },
+        "withGuild": {
+          "code": 64,
+          "stderr": "Error: Command failed: '/usr/bin/node' '--import' 'tsx' 'src/bin.ts' 'user' 'list' '--guild' '123456789012345678' '--query' 'Serhii'",
+          "stdout": "",
+        },
+      }
+    `)
+  })
+
+  test('bot install-url prints install URL', async () => {
+    const { homeDir, dataDir } = createHomePaths()
+    await seedBotToken({ dataDir, appId: '123456789012345678' })
+
+    const result = await runCli({
+      args: ['bot', 'install-url', '--data-dir', dataDir],
+      homeDir,
+    })
+
+    expect(commandOutput({ result, homeDir })).toMatchInlineSnapshot(`
+      {
+        "code": 0,
+        "stderr": "",
+        "stdout": "",
+      }
+    `)
+  })
+}, 25_000)