feat: add td update self-update command (#88)

scottlovegrove · claude · web-flow · commit 3f9fe80743b1 · 2026-02-20T17:07:48.000Z
Co-authored-by: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/src/__tests__/update.test.ts b/src/__tests__/update.test.ts
@@ -0,0 +1,221 @@
+import { Command } from 'commander'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Mock child_process
+vi.mock('node:child_process', () => ({
+    spawn: vi.fn(),
+}))
+
+// Mock chalk to avoid colors in tests
+vi.mock('chalk', () => ({
+    default: {
+        green: vi.fn((text: string) => text),
+        red: vi.fn((text: string) => text),
+        dim: vi.fn((text: string) => text),
+    },
+}))
+
+// Mock spinner — pass through to the callback
+vi.mock('../lib/spinner.js', () => ({
+    withSpinner: vi.fn((_opts: unknown, fn: () => Promise<unknown>) => fn()),
+}))
+
+import { spawn } from 'node:child_process'
+import { registerUpdateCommand } from '../commands/update.js'
+
+const mockSpawn = vi.mocked(spawn)
+
+function createProgram() {
+    const program = new Command()
+    program.exitOverride()
+    registerUpdateCommand(program)
+    return program
+}
+
+function mockFetch(version: string) {
+    vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({ version }),
+        }),
+    )
+}
+
+function mockFetchError(status: number) {
+    vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+            ok: false,
+            status,
+        }),
+    )
+}
+
+function mockFetchNetworkError(message: string) {
+    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error(message)))
+}
+
+function mockSpawnSuccess() {
+    mockSpawn.mockReturnValue({
+        on: vi.fn((event: string, cb: (arg?: unknown) => void) => {
+            if (event === 'close') cb(0)
+        }),
+    } as never)
+}
+
+function mockSpawnFailure(exitCode: number) {
+    mockSpawn.mockReturnValue({
+        on: vi.fn((event: string, cb: (arg?: unknown) => void) => {
+            if (event === 'close') cb(exitCode)
+        }),
+    } as never)
+}
+
+function mockSpawnPermissionError() {
+    mockSpawn.mockReturnValue({
+        on: vi.fn((event: string, cb: (arg?: unknown) => void) => {
+            if (event === 'error') {
+                const err = Object.assign(new Error('EACCES'), { code: 'EACCES' })
+                cb(err)
+            }
+        }),
+    } as never)
+}
+
+describe('update command', () => {
+    let consoleSpy: ReturnType<typeof vi.spyOn>
+    let consoleErrorSpy: ReturnType<typeof vi.spyOn>
+
+    beforeEach(() => {
+        consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+        consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+        process.exitCode = undefined
+    })
+
+    afterEach(() => {
+        vi.restoreAllMocks()
+        vi.unstubAllGlobals()
+        process.exitCode = undefined
+    })
+
+    describe('already up to date', () => {
+        it('prints up-to-date message when versions match', async () => {
+            const { version } = await import('../../package.json')
+            mockFetch(version)
+
+            const program = createProgram()
+            await program.parseAsync(['node', 'td', 'update'])
+
+            expect(consoleSpy).toHaveBeenCalledWith(
+                expect.anything(),
+                expect.stringContaining('Already up to date'),
+            )
+            expect(mockSpawn).not.toHaveBeenCalled()
+        })
+    })
+
+    describe('--check flag', () => {
+        it('shows version info without installing when update available', async () => {
+            mockFetch('99.99.99')
+
+            const program = createProgram()
+            await program.parseAsync(['node', 'td', 'update', '--check'])
+
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Update available'))
+            expect(mockSpawn).not.toHaveBeenCalled()
+        })
+
+        it('shows up-to-date message when already current', async () => {
+            const { version } = await import('../../package.json')
+            mockFetch(version)
+
+            const program = createProgram()
+            await program.parseAsync(['node', 'td', 'update', '--check'])
+
+            expect(consoleSpy).toHaveBeenCalledWith(
+                expect.anything(),
+                expect.stringContaining('Already up to date'),
+            )
+        })
+    })
+
+    describe('update available', () => {
+        it('spawns npm install and reports success', async () => {
+            mockFetch('99.99.99')
+            mockSpawnSuccess()
+
+            const program = createProgram()
+            await program.parseAsync(['node', 'td', 'update'])
+
+            expect(mockSpawn).toHaveBeenCalledWith(
+                'npm',
+                ['install', '-g', '@doist/todoist-cli@latest'],
+                { stdio: 'inherit' },
+            )
+            expect(consoleSpy).toHaveBeenCalledWith(
+                expect.anything(),
+                expect.stringContaining('Updated to v99.99.99'),
+            )
+        })
+    })
+
+    describe('registry errors', () => {
+        it('handles HTTP errors from registry', async () => {
+            mockFetchError(503)
+
+            const program = createProgram()
+            await program.parseAsync(['node', 'td', 'update'])
+
+            expect(consoleErrorSpy).toHaveBeenCalledWith(
+                expect.anything(),
+                expect.stringContaining('Failed to check for updates'),
+            )
+            expect(process.exitCode).toBe(1)
+        })
+
+        it('handles network failures', async () => {
+            mockFetchNetworkError('getaddrinfo ENOTFOUND registry.npmjs.org')
+
+            const program = createProgram()
+            await program.parseAsync(['node', 'td', 'update'])
+
+            expect(consoleErrorSpy).toHaveBeenCalledWith(
+                expect.anything(),
+                expect.stringContaining('Failed to check for updates'),
+            )
+            expect(process.exitCode).toBe(1)
+        })
+    })
+
+    describe('install errors', () => {
+        it('suggests sudo on permission error', async () => {
+            mockFetch('99.99.99')
+            mockSpawnPermissionError()
+
+            const program = createProgram()
+            await program.parseAsync(['node', 'td', 'update'])
+
+            expect(consoleErrorSpy).toHaveBeenCalledWith(
+                expect.anything(),
+                expect.stringContaining('Permission denied'),
+            )
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('sudo'))
+            expect(process.exitCode).toBe(1)
+        })
+
+        it('handles non-zero exit code from npm', async () => {
+            mockFetch('99.99.99')
+            mockSpawnFailure(1)
+
+            const program = createProgram()
+            await program.parseAsync(['node', 'td', 'update'])
+
+            expect(consoleErrorSpy).toHaveBeenCalledWith(
+                expect.anything(),
+                expect.stringContaining('exited with code 1'),
+            )
+            expect(process.exitCode).toBe(1)
+        })
+    })
+})
diff --git a/src/commands/update.ts b/src/commands/update.ts
@@ -0,0 +1,100 @@
+import { spawn } from 'node:child_process'
+import chalk from 'chalk'
+import { Command } from 'commander'
+import packageJson from '../../package.json' with { type: 'json' }
+import { withSpinner } from '../lib/spinner.js'
+
+const PACKAGE_NAME = '@doist/todoist-cli'
+const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`
+
+interface RegistryResponse {
+    version: string
+}
+
+async function fetchLatestVersion(): Promise<string> {
+    const response = await fetch(REGISTRY_URL)
+    if (!response.ok) {
+        throw new Error(`Registry request failed (HTTP ${response.status})`)
+    }
+    const data = (await response.json()) as RegistryResponse
+    return data.version
+}
+
+function detectPackageManager(): string {
+    const execPath = process.env.npm_execpath ?? ''
+    if (execPath.includes('pnpm')) return 'pnpm'
+    return 'npm'
+}
+
+function runInstall(pm: string): Promise<number> {
+    return new Promise((resolve, reject) => {
+        const child = spawn(pm, ['install', '-g', `${PACKAGE_NAME}@latest`], {
+            stdio: 'inherit',
+        })
+
+        child.on('error', reject)
+        child.on('close', (code) => resolve(code ?? 1))
+    })
+}
+
+export async function updateAction(options: { check?: boolean }): Promise<void> {
+    const currentVersion = packageJson.version
+
+    let latestVersion: string
+    try {
+        latestVersion = await withSpinner(
+            { text: 'Checking for updates...', color: 'blue' },
+            fetchLatestVersion,
+        )
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        console.error(chalk.red('Error:'), `Failed to check for updates: ${message}`)
+        process.exitCode = 1
+        return
+    }
+
+    if (currentVersion === latestVersion) {
+        console.log(chalk.green('✓'), `Already up to date (v${currentVersion})`)
+        return
+    }
+
+    console.log(
+        `Update available: ${chalk.dim(`v${currentVersion}`)} → ${chalk.green(`v${latestVersion}`)}`,
+    )
+
+    if (options.check) {
+        return
+    }
+
+    const pm = detectPackageManager()
+    console.log(chalk.dim(`Updating to v${latestVersion}...`))
+
+    try {
+        const exitCode = await runInstall(pm)
+        if (exitCode !== 0) {
+            console.error(chalk.red('Error:'), `${pm} exited with code ${exitCode}`)
+            process.exitCode = 1
+            return
+        }
+    } catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'EACCES') {
+            console.error(chalk.red('Error:'), 'Permission denied. Try running with sudo:')
+            console.error(chalk.dim(`  sudo ${pm} install -g ${PACKAGE_NAME}@latest`))
+        } else {
+            const message = error instanceof Error ? error.message : String(error)
+            console.error(chalk.red('Error:'), `Install failed: ${message}`)
+        }
+        process.exitCode = 1
+        return
+    }
+
+    console.log(chalk.green('✓'), `Updated to v${latestVersion}`)
+}
+
+export function registerUpdateCommand(program: Command): void {
+    program
+        .command('update')
+        .description('Update the CLI to the latest version')
+        .option('--check', 'Check for updates without installing')
+        .action(updateAction)
+}
diff --git a/src/index.ts b/src/index.ts
@@ -104,6 +104,10 @@ const commands: Record<string, [string, () => Promise<(p: Command) => void>]> =
         'View a Todoist entity or page by URL',
         async () => (await import('./commands/view.js')).registerViewCommand,
     ],
+    update: [
+        'Update the CLI to the latest version',
+        async () => (await import('./commands/update.js')).registerUpdateCommand,
+    ],
 }
 
 // Register placeholders so --help lists all commands
diff --git a/src/lib/skills/content.ts b/src/lib/skills/content.ts
@@ -26,6 +26,7 @@ Use this skill when the user wants to interact with their Todoist tasks.
 - \`td settings view\` - User settings
 - \`td completion install\` - Install shell completions
 - \`td view <url>\` - View supported Todoist entities/pages by URL
+- \`td update\` - Self-update the CLI to the latest version
 
 ## Output Formats
 
@@ -286,6 +287,12 @@ td view <url> --json                           # JSON output for entity views
 td view <url> --limit 25 --ndjson              # Passthrough list options where supported
 \`\`\`
 
+### Update
+\`\`\`bash
+td update                                    # Update CLI to latest version
+td update --check                            # Check for updates without installing
+\`\`\`
+
 ## Examples
 
 ### Daily workflow
