@sqaoss/flowy 1.10.0 → 1.12.0

package/src/commands/backup.test.ts

@@ -0,0 +1,252 @@
+import { spawnSync } from 'node:child_process'
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+
+let mockOutput: ReturnType<typeof vi.fn>
+let mockOutputError: ReturnType<typeof vi.fn>
+let workDir: string
+
+// `bun:sqlite` is unavailable under the Node-based root test runner, so these
+// tests drive a real `bun` subprocess to seed and read SQLite files. That keeps
+// the row-level assertions genuine (open the backup, compare rows) without
+// importing `bun:sqlite` into Node — exactly how the CLI runs at runtime.
+
+/** Create a populated SQLite DB at `path` via a real bun subprocess. */
+function seedDb(
+  path: string,
+  rows: Array<{ id: string; title: string }> = [
+    { id: 'n1', title: 'Alpha' },
+    { id: 'n2', title: 'Beta' },
+    { id: 'n3', title: 'Gamma' },
+  ],
+): Array<{ id: string; title: string }> {
+  const script = `
+    const { Database } = require('bun:sqlite')
+    const db = new Database(process.argv[1])
+    db.run('PRAGMA journal_mode = WAL')
+    db.run('CREATE TABLE nodes (id TEXT PRIMARY KEY, type TEXT NOT NULL, title TEXT NOT NULL)')
+    const rows = JSON.parse(process.argv[2])
+    for (const r of rows) db.run('INSERT INTO nodes (id, type, title) VALUES (?, ?, ?)', [r.id, 'task', r.title])
+    db.close()
+  `
+  const res = spawnSync('bun', ['-e', script, path, JSON.stringify(rows)], {
+    encoding: 'utf-8',
+  })
+  if (res.status !== 0) throw new Error(`seedDb failed: ${res.stderr}`)
+  return rows
+}
+
+/** Read all node {id,title} rows from a SQLite file via a real bun subprocess. */
+function readNodes(path: string): Array<{ id: string; title: string }> {
+  const script = `
+    const { Database } = require('bun:sqlite')
+    const db = new Database(process.argv[1], { readonly: true })
+    console.log(JSON.stringify(db.query('SELECT id, title FROM nodes ORDER BY id').all()))
+    db.close()
+  `
+  const res = spawnSync('bun', ['-e', script, path], { encoding: 'utf-8' })
+  if (res.status !== 0) throw new Error(`readNodes failed: ${res.stderr}`)
+  return JSON.parse(res.stdout.trim())
+}
+
+beforeEach(() => {
+  mockOutput = vi.fn()
+  mockOutputError = vi.fn()
+  vi.doMock('../util/format.ts', () => ({
+    output: mockOutput,
+    outputError: mockOutputError,
+  }))
+  workDir = mkdtempSync(join(tmpdir(), 'flowy-backup-'))
+  delete process.env.FLOWY_DB_PATH
+})
+
+afterEach(() => {
+  rmSync(workDir, { recursive: true, force: true })
+  delete process.env.FLOWY_DB_PATH
+  vi.resetModules()
+  vi.restoreAllMocks()
+})
+
+describe('backup command', () => {
+  test('exports a command named "backup"', async () => {
+    const { backupCommand } = await import('./backup.ts')
+    expect(backupCommand.name()).toBe('backup')
+  })
+
+  test('declares a --db option', async () => {
+    const { backupCommand } = await import('./backup.ts')
+    const flags = backupCommand.options.map((o) => o.long)
+    expect(flags).toContain('--db')
+  })
+
+  test('writes a valid SQLite snapshot whose rows match the source DB', async () => {
+    const src = join(workDir, 'flowy.sqlite')
+    const dest = join(workDir, 'backup.sqlite')
+    const expected = seedDb(src)
+
+    const { backupCommand } = await import('./backup.ts')
+    await backupCommand.parseAsync([dest, '--db', src], { from: 'user' })
+
+    expect(mockOutputError).not.toHaveBeenCalled()
+    expect(existsSync(dest)).toBe(true)
+    // The backup is a real, openable SQLite database with identical rows.
+    expect(readNodes(dest)).toEqual(expected)
+  })
+
+  test('resolves the DB path from FLOWY_DB_PATH when --db is omitted', async () => {
+    const src = join(workDir, 'env.sqlite')
+    const dest = join(workDir, 'backup.sqlite')
+    const expected = seedDb(src)
+    process.env.FLOWY_DB_PATH = src
+
+    const { backupCommand } = await import('./backup.ts')
+    await backupCommand.parseAsync([dest], { from: 'user' })
+
+    expect(mockOutputError).not.toHaveBeenCalled()
+    expect(readNodes(dest)).toEqual(expected)
+  })
+
+  test('produces a consistent snapshot while the source DB is open (WAL)', async () => {
+    const src = join(workDir, 'flowy.sqlite')
+    const dest = join(workDir, 'backup.sqlite')
+    const expected = seedDb(src)
+
+    // A long-lived bun process holds the DB open to mimic a running server.
+    const holder = spawnSync(
+      'bun',
+      [
+        '-e',
+        `const { Database } = require('bun:sqlite'); const db = new Database(process.argv[1]); db.query('SELECT 1').get(); Bun.sleepSync(50); db.close()`,
+        src,
+      ],
+      { encoding: 'utf-8' },
+    )
+    expect(holder.status).toBe(0)
+
+    const { backupCommand } = await import('./backup.ts')
+    await backupCommand.parseAsync([dest, '--db', src], { from: 'user' })
+
+    expect(mockOutputError).not.toHaveBeenCalled()
+    expect(readNodes(dest)).toEqual(expected)
+  })
+
+  test('errors when the source DB does not exist', async () => {
+    const dest = join(workDir, 'backup.sqlite')
+    const missing = join(workDir, 'nope.sqlite')
+
+    const { backupCommand } = await import('./backup.ts')
+    await backupCommand.parseAsync([dest, '--db', missing], { from: 'user' })
+
+    expect(mockOutputError).toHaveBeenCalled()
+    expect(existsSync(dest)).toBe(false)
+  })
+
+  test('reports the source and destination on success', async () => {
+    const src = join(workDir, 'flowy.sqlite')
+    const dest = join(workDir, 'backup.sqlite')
+    seedDb(src)
+
+    const { backupCommand } = await import('./backup.ts')
+    await backupCommand.parseAsync([dest, '--db', src], { from: 'user' })
+
+    expect(mockOutput).toHaveBeenCalledWith(
+      expect.objectContaining({ source: src, file: dest }),
+    )
+  })
+})
+
+describe('restore command', () => {
+  test('exports a command named "restore"', async () => {
+    const { restoreCommand } = await import('./backup.ts')
+    expect(restoreCommand.name()).toBe('restore')
+  })
+
+  test('declares --db and --force options', async () => {
+    const { restoreCommand } = await import('./backup.ts')
+    const flags = restoreCommand.options.map((o) => o.long)
+    expect(flags).toContain('--db')
+    expect(flags).toContain('--force')
+  })
+
+  test('round-trips: restoring a backup reproduces the original rows', async () => {
+    const src = join(workDir, 'flowy.sqlite')
+    const backup = join(workDir, 'backup.sqlite')
+    const target = join(workDir, 'restored.sqlite')
+    const expected = seedDb(src)
+
+    const { backupCommand, restoreCommand } = await import('./backup.ts')
+    await backupCommand.parseAsync([backup, '--db', src], { from: 'user' })
+    await restoreCommand.parseAsync([backup, '--db', target], { from: 'user' })
+
+    expect(mockOutputError).not.toHaveBeenCalled()
+    expect(readNodes(target)).toEqual(expected)
+  })
+
+  test('refuses to clobber an existing DB without --force', async () => {
+    const src = join(workDir, 'flowy.sqlite')
+    const backup = join(workDir, 'backup.sqlite')
+    const target = join(workDir, 'existing.sqlite')
+    // Pre-existing target whose content must NOT be overwritten.
+    const original = seedDb(target, [{ id: 'keep', title: 'Original' }])
+    // Source (and thus backup) differs from the existing target.
+    seedDb(src, [{ id: 'new', title: 'Incoming' }])
+
+    const { backupCommand, restoreCommand } = await import('./backup.ts')
+    await backupCommand.parseAsync([backup, '--db', src], { from: 'user' })
+
+    mockOutputError.mockClear()
+    await restoreCommand.parseAsync([backup, '--db', target], { from: 'user' })
+
+    expect(mockOutputError).toHaveBeenCalled()
+    // The existing DB is untouched.
+    expect(readNodes(target)).toEqual(original)
+  })
+
+  test('overwrites an existing DB when --force is given', async () => {
+    const src = join(workDir, 'flowy.sqlite')
+    const backup = join(workDir, 'backup.sqlite')
+    const target = join(workDir, 'existing.sqlite')
+    seedDb(target, [{ id: 'old', title: 'Stale' }]) // pre-existing, replaced
+    seedDb(src, [{ id: 'z9', title: 'New' }])
+
+    const { backupCommand, restoreCommand } = await import('./backup.ts')
+    await backupCommand.parseAsync([backup, '--db', src], { from: 'user' })
+    await restoreCommand.parseAsync([backup, '--db', target, '--force'], {
+      from: 'user',
+    })
+
+    expect(mockOutputError).not.toHaveBeenCalled()
+    expect(readNodes(target)).toEqual([{ id: 'z9', title: 'New' }])
+  })
+
+  test('errors when the backup source does not exist', async () => {
+    const target = join(workDir, 'restored.sqlite')
+    const missing = join(workDir, 'nope.sqlite')
+
+    const { restoreCommand } = await import('./backup.ts')
+    await restoreCommand.parseAsync([missing, '--db', target], { from: 'user' })
+
+    expect(mockOutputError).toHaveBeenCalled()
+    expect(existsSync(target)).toBe(false)
+  })
+
+  test('errors when the backup source is not a valid SQLite database', async () => {
+    const target = join(workDir, 'restored.sqlite')
+    const garbage = join(workDir, 'garbage.bin')
+    writeFileSync(garbage, 'this is not a sqlite database')
+
+    const { restoreCommand } = await import('./backup.ts')
+    await restoreCommand.parseAsync([garbage, '--db', target], { from: 'user' })
+
+    // A corrupt source must surface as a clean snapshot failure, not an
+    // incidental downstream error (e.g. a rename ENOENT).
+    expect(mockOutputError).toHaveBeenCalledWith(
+      expect.objectContaining({ code: 'BACKUP_ERROR' }),
+    )
+    expect(existsSync(target)).toBe(false)
+    // No staged temp file is left behind.
+    expect(existsSync(`${target}.restore-tmp`)).toBe(false)
+  })
+})

package/src/commands/backup.ts

@@ -0,0 +1,145 @@
+import { spawnSync } from 'node:child_process'
+import { existsSync, renameSync, rmSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { Command } from 'commander'
+import { output, outputError } from '../util/format.ts'
+
+/**
+ * Resolve the local SQLite database path the bundled server uses, from the same
+ * sources `server/src/index.ts` and `flowy serve` honour:
+ *   1. an explicit `--db <path>` flag
+ *   2. the `FLOWY_DB_PATH` env var
+ *   3. the default `./flowy.sqlite`
+ */
+export function resolveDbPath(dbOpt?: string): string {
+  return dbOpt ?? process.env.FLOWY_DB_PATH ?? './flowy.sqlite'
+}
+
+/**
+ * Snapshot one SQLite database into another file with `VACUUM INTO`.
+ *
+ * `VACUUM INTO` takes a transactionally-consistent snapshot even while the
+ * source is open/being written by a running server (it reads under a read
+ * transaction), and writes a single fully-checkpointed file with no `-wal`/
+ * `-shm` sidecars — strictly safer than copying the file bytes. It also fails
+ * cleanly if `src` is not a valid SQLite database, which doubles as validation.
+ *
+ * Runs in a `bun` subprocess so this module never imports `bun:sqlite`
+ * (unavailable under the Node-based unit-test runner); the CLI itself always
+ * runs under bun, so the subprocess shares the same runtime.
+ */
+function vacuumInto(src: string, dest: string): void {
+  // Note: `bun -e` does not reliably exit non-zero on an uncaught throw, so the
+  // script explicitly catches, writes the message to stderr, and exits 1 — that
+  // is what lets the parent distinguish a corrupt source from a clean snapshot.
+  const script = `
+    const { Database } = require('bun:sqlite')
+    try {
+      const db = new Database(process.argv[1], { readonly: true })
+      try {
+        db.run('VACUUM INTO ?', [process.argv[2]])
+      } finally {
+        db.close()
+      }
+    } catch (e) {
+      console.error(e && e.message ? e.message : String(e))
+      process.exit(1)
+    }
+  `
+  const result = spawnSync('bun', ['-e', script, src, dest], {
+    encoding: 'utf-8',
+  })
+  if (result.status !== 0) {
+    const detail = (result.stderr || result.stdout || '').trim()
+    const err = new Error(
+      `Failed to snapshot SQLite database ${src}${detail ? `: ${detail}` : '.'}`,
+    ) as Error & { code?: string }
+    err.code = 'BACKUP_ERROR'
+    throw err
+  }
+}
+
+/** Remove a SQLite file together with its `-wal`/`-shm` sidecars. */
+function removeDbFiles(path: string): void {
+  for (const suffix of ['', '-wal', '-shm', '-journal']) {
+    rmSync(`${path}${suffix}`, { force: true })
+  }
+}
+
+export const backupCommand = new Command('backup')
+  .description(
+    'Write a consistent file-level snapshot of the local SQLite database',
+  )
+  .argument('<dest>', 'Path to write the backup file to')
+  .option(
+    '-d, --db <path>',
+    'SQLite database to back up (default: $FLOWY_DB_PATH or ./flowy.sqlite)',
+  )
+  .action((dest: string, opts: { db?: string }) => {
+    try {
+      const src = resolveDbPath(opts.db)
+      if (!existsSync(src)) {
+        const err = new Error(
+          `No SQLite database at ${resolve(src)}. ` +
+            `Set --db or FLOWY_DB_PATH, or start the server first.`,
+        ) as Error & { code?: string }
+        err.code = 'NOT_FOUND'
+        throw err
+      }
+      // VACUUM INTO refuses to write an existing file, so clear a stale dest.
+      removeDbFiles(dest)
+      vacuumInto(src, dest)
+      output({ source: src, file: dest })
+    } catch (error) {
+      outputError(error)
+    }
+  })
+
+export const restoreCommand = new Command('restore')
+  .description('Restore the local SQLite database from a backup file')
+  .argument('<src>', 'Path to a backup file produced by "flowy backup"')
+  .option(
+    '-d, --db <path>',
+    'SQLite database to restore into (default: $FLOWY_DB_PATH or ./flowy.sqlite)',
+  )
+  .option('-f, --force', 'Overwrite the target database if it already exists')
+  .action((src: string, opts: { db?: string; force?: boolean }) => {
+    try {
+      if (!existsSync(src)) {
+        const err = new Error(`No backup file at ${resolve(src)}.`) as Error & {
+          code?: string
+        }
+        err.code = 'NOT_FOUND'
+        throw err
+      }
+      const target = resolveDbPath(opts.db)
+      if (existsSync(target) && !opts.force) {
+        const err = new Error(
+          `Target database ${resolve(target)} already exists. ` +
+            `Re-run with --force to overwrite it (the current data will be lost).`,
+        ) as Error & { code?: string }
+        err.code = 'TARGET_EXISTS'
+        throw err
+      }
+      // VACUUM INTO validates that `src` is a real SQLite database and writes a
+      // clean single-file copy. Stage it next to the target first, so a corrupt
+      // backup never destroys the existing DB before validation succeeds.
+      const staged = `${target}.restore-tmp`
+      removeDbFiles(staged)
+      try {
+        vacuumInto(src, staged)
+      } catch (error) {
+        removeDbFiles(staged)
+        throw error
+      }
+      // Validation passed — swap the staged copy into place. `staged` sits in
+      // the same directory as `target`, so this rename stays on one filesystem.
+      // VACUUM INTO never creates `-wal`/`-shm` sidecars, so only the main file
+      // needs moving.
+      removeDbFiles(target)
+      renameSync(staged, target)
+      output({ restored: target, source: src })
+    } catch (error) {
+      outputError(error)
+    }
+  })

package/src/commands/search.test.ts

@@ -0,0 +1,90 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+
+let mockGraphql: ReturnType<typeof vi.fn>
+let mockOutput: ReturnType<typeof vi.fn>
+let mockOutputError: ReturnType<typeof vi.fn>
+let stderr: ReturnType<typeof vi.spyOn>
+
+beforeEach(() => {
+  mockOutput = vi.fn()
+  mockOutputError = vi.fn()
+  mockGraphql = vi.fn()
+  stderr = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+  vi.doMock('../util/format.ts', () => ({
+    output: mockOutput,
+    outputError: mockOutputError,
+  }))
+  vi.doMock('../util/client.ts', () => ({
+    graphql: mockGraphql,
+  }))
+})
+
+afterEach(() => {
+  vi.resetModules()
+  vi.restoreAllMocks()
+})
+
+describe('search command', () => {
+  test('sends the SearchResult envelope query and outputs nodes + meta', async () => {
+    mockGraphql.mockResolvedValue({
+      search: {
+        nodes: [{ id: 'proj_1', title: 'Auth' }],
+        truncated: false,
+        total: 1,
+      },
+    })
+
+    const { searchCommand } = await import('./search.ts')
+    await searchCommand.parseAsync(['Auth'], { from: 'user' })
+
+    const query = mockGraphql.mock.calls[0]?.[0] as string
+    expect(query).toContain('nodes')
+    expect(query).toContain('truncated')
+    expect(query).toContain('total')
+
+    expect(mockOutput).toHaveBeenCalledWith({
+      nodes: [{ id: 'proj_1', title: 'Auth' }],
+      truncated: false,
+      total: 1,
+    })
+    // no truncation warning when not truncated
+    expect(stderr).not.toHaveBeenCalled()
+  })
+
+  test('renders a clear truncation marker when results are capped', async () => {
+    mockGraphql.mockResolvedValue({
+      search: {
+        nodes: new Array(50).fill({ id: 'x' }),
+        truncated: true,
+        total: 137,
+      },
+    })
+
+    const { searchCommand } = await import('./search.ts')
+    await searchCommand.parseAsync(['Task'], { from: 'user' })
+
+    const outputArg = mockOutput.mock.calls[0]?.[0] as {
+      truncated: boolean
+      total: number
+    }
+    expect(outputArg.truncated).toBe(true)
+    expect(outputArg.total).toBe(137)
+
+    expect(stderr).toHaveBeenCalledOnce()
+    const warning = stderr.mock.calls[0]?.[0] as string
+    expect(warning).toMatch(/truncated/i)
+    expect(warning).toContain('50')
+    expect(warning).toContain('137')
+  })
+
+  test('outputs error when the query fails', async () => {
+    mockGraphql.mockRejectedValue(new Error('boom'))
+    const { searchCommand } = await import('./search.ts')
+    await searchCommand.parseAsync(['Auth'], { from: 'user' })
+    expect(mockOutputError).toHaveBeenCalledWith(
+      expect.objectContaining({ message: 'boom' }),
+    )
+    expect(mockOutput).not.toHaveBeenCalled()
+  })
+})

package/src/commands/search.ts

@@ -3,6 +3,12 @@ import { graphql } from '../util/client.ts'
 import { output, outputError } from '../util/format.ts'
 import { SEARCH } from '../util/operations.ts'
 
+interface SearchResult {
+  nodes: unknown[]
+  truncated: boolean
+  total: number
+}
+
 export const searchCommand = new Command('search')
   .description('Search nodes by text')
   .argument('<query>', 'Search query')
@@ -11,13 +17,23 @@ export const searchCommand = new Command('search')
   .option('--limit <n>', 'Limit results', '50')
   .action(async (query: string, opts) => {
     try {
-      const data = await graphql<{ search: unknown[] }>(SEARCH, {
+      const limit = opts.limit ? Number.parseInt(opts.limit, 10) : undefined
+      const data = await graphql<{ search: SearchResult }>(SEARCH, {
         query,
         type: opts.type,
         status: opts.status,
-        limit: opts.limit ? Number.parseInt(opts.limit, 10) : undefined,
+        limit,
       })
-      output(data.search)
+      const { nodes, truncated, total } = data.search
+      // The truncation marker rides in the JSON envelope so callers can detect
+      // it programmatically; when capped we also warn on stderr so it is not
+      // silently lost in a human-read terminal.
+      output({ nodes, truncated, total })
+      if (truncated) {
+        console.error(
+          `Results truncated: showing ${nodes.length} of ${total} matches. Raise --limit to see more.`,
+        )
+      }
     } catch (error) {
       outputError(error)
     }

package/src/commands/status.test.ts

@@ -0,0 +1,71 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+
+let mockGraphql: ReturnType<typeof vi.fn>
+let mockOutput: ReturnType<typeof vi.fn>
+let mockOutputError: ReturnType<typeof vi.fn>
+
+beforeEach(() => {
+  mockOutput = vi.fn()
+  mockOutputError = vi.fn()
+  mockGraphql = vi.fn().mockResolvedValue({
+    updateNode: { id: 'task_1', type: 'task', title: 'T', status: 'done' },
+  })
+
+  vi.doMock('../util/format.ts', () => ({
+    output: mockOutput,
+    outputError: mockOutputError,
+  }))
+  vi.doMock('../util/client.ts', () => ({
+    graphql: mockGraphql,
+  }))
+})
+
+afterEach(() => {
+  vi.resetModules()
+  vi.restoreAllMocks()
+})
+
+describe('status command', () => {
+  test('accepts a valid status and sends the update', async () => {
+    const { statusCommand } = await import('./status.ts')
+    await statusCommand.parseAsync(['task_1', 'in_progress'], { from: 'user' })
+
+    expect(mockGraphql).toHaveBeenCalledOnce()
+    expect(mockGraphql.mock.calls[0]?.[1]).toEqual({
+      id: 'task_1',
+      status: 'in_progress',
+    })
+    expect(mockOutput).toHaveBeenCalledOnce()
+  })
+
+  test('rejects an invalid status client-side (.choices) without a request', async () => {
+    const { statusCommand } = await import('./status.ts')
+    // Commander throws on an invalid choice; configure it not to exit the
+    // process so the test can assert.
+    statusCommand.exitOverride()
+    statusCommand.configureOutput({ writeErr: () => {}, writeOut: () => {} })
+
+    await expect(
+      statusCommand.parseAsync(['task_1', 'bogus'], { from: 'user' }),
+    ).rejects.toThrow(/Allowed choices|bogus/i)
+
+    expect(mockGraphql).not.toHaveBeenCalled()
+  })
+
+  test('exposes the full canonical status vocabulary as choices', async () => {
+    const { statusCommand, STATUS_CHOICES } = await import('./status.ts')
+    expect(STATUS_CHOICES).toEqual([
+      'draft',
+      'pending_review',
+      'approved',
+      'in_progress',
+      'done',
+      'blocked',
+      'cancelled',
+    ])
+    const statusArg = statusCommand.registeredArguments.find(
+      (a) => a.name() === 'status',
+    )
+    expect(statusArg?.argChoices).toEqual([...STATUS_CHOICES])
+  })
+})

package/src/commands/status.ts

@@ -1,14 +1,28 @@
-import { Command } from 'commander'
+import { Argument, Command } from 'commander'
 import { graphql } from '../util/client.ts'
 import { output, outputError } from '../util/format.ts'
 import { UPDATE_STATUS } from '../util/operations.ts'
 
+/**
+ * The canonical Flowy status vocabulary, mirrored from the server's
+ * VALID_STATUSES. Used for client-side `.choices()` validation so an invalid
+ * status is rejected before a request is ever sent.
+ */
+export const STATUS_CHOICES = [
+  'draft',
+  'pending_review',
+  'approved',
+  'in_progress',
+  'done',
+  'blocked',
+  'cancelled',
+] as const
+
 export const statusCommand = new Command('status')
   .description('Update a node status (shorthand)')
   .argument('<id>', 'Node ID')
-  .argument(
-    '<status>',
-    'New status (draft, pending_review, approved, in_progress, done, blocked, cancelled)',
+  .addArgument(
+    new Argument('<status>', 'New status').choices([...STATUS_CHOICES]),
   )
   .action(async (id: string, status: string) => {
     try {

package/src/index.test.ts

@@ -51,6 +51,10 @@ vi.mock('./commands/import.ts', () => ({
 vi.mock('./commands/export.ts', () => ({
   exportCommand: { name: () => 'export' },
 }))
+vi.mock('./commands/backup.ts', () => ({
+  backupCommand: { name: () => 'backup' },
+  restoreCommand: { name: () => 'restore' },
+}))
 
 describe('index.ts command registration', () => {
   test('registers billing and key commands', async () => {
@@ -112,4 +116,18 @@ describe('index.ts command registration', () => {
     )
     expect(indexSource).toContain('program.addCommand(historyCommand)')
   })
+
+  test('registers the backup and restore commands', async () => {
+    const { readFileSync } = await import('node:fs')
+    const indexSource = readFileSync(
+      new URL('./index.ts', import.meta.url).pathname,
+      'utf-8',
+    )
+
+    expect(indexSource).toContain(
+      "import { backupCommand, restoreCommand } from './commands/backup.ts'",
+    )
+    expect(indexSource).toContain('program.addCommand(backupCommand)')
+    expect(indexSource).toContain('program.addCommand(restoreCommand)')
+  })
 })

package/src/index.ts

@@ -12,6 +12,7 @@ const pkgPath = resolve(
 const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'))
 
 import { approveCommand } from './commands/approve.ts'
+import { backupCommand, restoreCommand } from './commands/backup.ts'
 import { billingCommand } from './commands/billing.ts'
 import { clientCommand } from './commands/client.ts'
 import { exportCommand } from './commands/export.ts'
@@ -51,5 +52,7 @@ program.addCommand(historyCommand)
 program.addCommand(whoamiCommand)
 program.addCommand(importCommand)
 program.addCommand(exportCommand)
+program.addCommand(backupCommand)
+program.addCommand(restoreCommand)
 
 program.parse()