@skillrecordings/cli 0.1.0 → 0.2.1

package/src/commands/front-stats.ts

@@ -1,75 +0,0 @@
-import { createInstrumentedFrontClient } from '@skillrecordings/core/front/instrumented-client'
-
-export async function frontStats() {
-  const front = createInstrumentedFrontClient({
-    apiToken: process.env.FRONT_API_TOKEN!,
-  })
-
-  // List all inboxes
-  const inboxes = await front.inboxes.list()
-  const inboxList = (inboxes as any)?._results ?? []
-
-  console.log(`Found ${inboxList.length} inboxes\n`)
-  console.log('Counting conversations (this may take a minute)...\n')
-
-  let grandTotal = 0
-  const results: { name: string; id: string; count: number }[] = []
-
-  // Key inboxes to check
-  const keyInboxes = [
-    'Total TypeScript',
-    'Epic Web',
-    'AI Hero',
-    'Pro Tailwind',
-    'Epic AI',
-  ]
-
-  for (const inbox of inboxList) {
-    // Only count key inboxes for speed
-    if (!keyInboxes.some((k) => inbox.name.includes(k))) continue
-
-    process.stdout.write(`📬 ${inbox.name}... `)
-
-    try {
-      // Count by paginating
-      let count = 0
-      let hasMore = true
-      let pageToken: string | undefined
-
-      while (hasMore && count < 10000) {
-        // Cap at 10k
-        const response = (await front.inboxes.listConversations(inbox.id, {
-          limit: 100,
-          ...(pageToken ? { page_token: pageToken } : {}),
-        })) as any
-
-        const convos = response?._results ?? []
-        count += convos.length
-
-        pageToken = response?._pagination?.next
-        hasMore = !!pageToken && convos.length === 100
-
-        // Rate limit
-        await new Promise((r) => setTimeout(r, 100))
-      }
-
-      console.log(`${count}${count >= 10000 ? '+' : ''} conversations`)
-      results.push({ name: inbox.name, id: inbox.id, count })
-      grandTotal += count
-    } catch (e: any) {
-      console.log(`Error: ${e.message}`)
-    }
-  }
-
-  console.log(`\n📊 Key inboxes total: ${grandTotal} conversations`)
-  console.log(
-    `   (${inboxList.length} total inboxes, only counted ${results.length} key ones)`
-  )
-}
-
-frontStats()
-  .then(() => process.exit(0))
-  .catch((e) => {
-    console.error(e)
-    process.exit(1)
-  })

package/src/commands/health.test.ts

@@ -1,82 +0,0 @@
-import { createHmac } from 'node:crypto'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-// Mock fetch globally
-const mockFetch = vi.fn()
-vi.stubGlobal('fetch', mockFetch)
-
-describe('health command', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  describe('signRequest', () => {
-    it('creates valid HMAC signature', async () => {
-      // Import the module to test signature format
-      const body = '{"action":"lookupUser","email":"[EMAIL]"}'
-      const secret = 'test-secret'
-      const timestamp = Math.floor(Date.now() / 1000)
-      const payload = `${timestamp}.${body}`
-      const expectedSignature = createHmac('sha256', secret)
-        .update(payload)
-        .digest('hex')
-
-      // The signature format should be: timestamp=X,v1=Y
-      expect(expectedSignature).toMatch(/^[a-f0-9]{64}$/)
-    })
-  })
-
-  describe('testAction', () => {
-    it('returns ok for successful response', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        json: async () => ({ id: 'user-123', email: '[EMAIL]' }),
-      })
-
-      // Test that fetch was called with correct headers
-      const response = await mockFetch('http://localhost:3016/api/support', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'x-support-signature': 'timestamp=123,v1=abc',
-        },
-        body: '{"action":"lookupUser","email":"[EMAIL]"}',
-      })
-
-      expect(response.ok).toBe(true)
-    })
-
-    it('returns not_implemented for 501 response', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: false,
-        status: 501,
-        json: async () => ({ error: 'Method not implemented' }),
-      })
-
-      const response = await mockFetch('http://localhost:3016/api/support', {
-        method: 'POST',
-        body: '{"action":"getSubscriptions"}',
-      })
-
-      expect(response.status).toBe(501)
-    })
-
-    it('returns error for failed response', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: false,
-        status: 401,
-        statusText: 'Unauthorized',
-        json: async () => ({ error: 'Invalid signature' }),
-      })
-
-      const response = await mockFetch('http://localhost:3016/api/support', {
-        method: 'POST',
-        body: '{"action":"lookupUser"}',
-      })
-
-      expect(response.ok).toBe(false)
-      expect(response.status).toBe(401)
-    })
-  })
-})

package/src/commands/health.ts

@@ -1,362 +0,0 @@
-import { createHmac } from 'node:crypto'
-import { AppsTable, closeDb, eq, getDb } from '@skillrecordings/database'
-
-interface HealthCheckResult {
-  endpoint: string
-  status: 'ok' | 'error'
-  responseTime: number
-  actions: {
-    name: string
-    status: 'ok' | 'error' | 'not_implemented'
-    error?: string
-  }[]
-}
-
-/**
- * Sign a request payload with HMAC-SHA256
- */
-function signRequest(body: string, secret: string): string {
-  const timestamp = Math.floor(Date.now() / 1000)
-  const payload = `${timestamp}.${body}`
-  const signature = createHmac('sha256', secret).update(payload).digest('hex')
-  return `timestamp=${timestamp},v1=${signature}`
-}
-
-/**
- * Test a single action against the integration endpoint
- */
-async function testAction(
-  baseUrl: string,
-  secret: string,
-  action: string,
-  params: Record<string, unknown>
-): Promise<{ status: 'ok' | 'error' | 'not_implemented'; error?: string }> {
-  const body = JSON.stringify({ action, ...params })
-  const signature = signRequest(body, secret)
-
-  try {
-    const response = await fetch(baseUrl, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-support-signature': signature,
-      },
-      body,
-    })
-
-    if (response.status === 501) {
-      return { status: 'not_implemented' }
-    }
-
-    if (!response.ok) {
-      const data = (await response.json().catch(() => ({}))) as {
-        error?: string
-      }
-      return {
-        status: 'error',
-        error: `${response.status}: ${data.error || response.statusText}`,
-      }
-    }
-
-    return { status: 'ok' }
-  } catch (err) {
-    return {
-      status: 'error',
-      error: err instanceof Error ? err.message : 'Unknown error',
-    }
-  }
-}
-
-/**
- * Look up an app by slug from the database
- */
-async function lookupApp(
-  slugOrUrl: string
-): Promise<{ baseUrl: string; secret: string } | null> {
-  // If it looks like a URL, return null (use direct mode)
-  if (slugOrUrl.startsWith('http://') || slugOrUrl.startsWith('https://')) {
-    return null
-  }
-
-  try {
-    const db = getDb()
-    const app = await db
-      .select({
-        integration_base_url: AppsTable.integration_base_url,
-        webhook_secret: AppsTable.webhook_secret,
-      })
-      .from(AppsTable)
-      .where(eq(AppsTable.slug, slugOrUrl))
-      .limit(1)
-
-    const record = app[0]
-    if (!record) {
-      return null
-    }
-
-    return {
-      baseUrl: record.integration_base_url,
-      secret: record.webhook_secret,
-    }
-  } catch (err) {
-    console.error('Database lookup failed:', err)
-    return null
-  }
-}
-
-/**
- * List all registered apps
- */
-async function listApps(): Promise<void> {
-  try {
-    const db = getDb()
-    const apps = await db
-      .select({
-        slug: AppsTable.slug,
-        name: AppsTable.name,
-        integration_base_url: AppsTable.integration_base_url,
-      })
-      .from(AppsTable)
-
-    if (!apps.length) {
-      console.log('No apps registered.')
-      await closeDb()
-      return
-    }
-
-    console.log('\nRegistered apps:\n')
-    for (const app of apps) {
-      console.log(`  ${app.slug}`)
-      console.log(`    Name: ${app.name}`)
-      console.log(`    URL:  ${app.integration_base_url}\n`)
-    }
-    await closeDb()
-  } catch (err) {
-    console.error('Failed to list apps:', err)
-    await closeDb()
-    process.exit(1)
-  }
-}
-
-/**
- * Health check command - tests integration endpoint connectivity and capabilities
- *
- * Agent-friendly: all options are non-interactive.
- * Use --json for machine-readable output.
- *
- * Usage:
- *   skill health <slug>              - Look up app by slug from database
- *   skill health <url> --secret xxx  - Direct URL mode
- *   skill health --list              - List all registered apps
- *   skill health <slug> --json       - Output as JSON
- */
-export async function health(
-  slugOrUrl: string | undefined,
-  options: { secret?: string; list?: boolean; json?: boolean }
-): Promise<void> {
-  const { json = false } = options
-
-  // Handle --list flag
-  if (options.list) {
-    await listApps()
-    return
-  }
-
-  if (!slugOrUrl) {
-    const error = {
-      success: false,
-      error:
-        'App slug or URL required. Usage: skill health <slug|url> [--secret <secret>]',
-    }
-    if (json) {
-      console.log(JSON.stringify(error, null, 2))
-    } else {
-      console.error('Error: App slug or URL required')
-      console.error('Usage: skill health <slug|url> [--secret <secret>]')
-      console.error('       skill health --list')
-    }
-    await closeDb()
-    process.exit(1)
-  }
-
-  let baseUrl: string
-  let secret: string
-
-  // Try database lookup first
-  const appConfig = await lookupApp(slugOrUrl)
-
-  if (appConfig) {
-    // Found in database
-    baseUrl = appConfig.baseUrl.endsWith('/api/support')
-      ? appConfig.baseUrl
-      : appConfig.baseUrl.replace(/\/$/, '') + '/api/support'
-    secret = appConfig.secret
-    if (!json) {
-      console.log(`\nUsing app configuration for: ${slugOrUrl}`)
-    }
-  } else if (
-    slugOrUrl.startsWith('http://') ||
-    slugOrUrl.startsWith('https://')
-  ) {
-    // Direct URL mode
-    const secretValue = options.secret || process.env.SUPPORT_WEBHOOK_SECRET
-    if (!secretValue) {
-      const error = {
-        success: false,
-        error:
-          'Webhook secret required for direct URL mode. Use --secret or set SUPPORT_WEBHOOK_SECRET',
-      }
-      if (json) {
-        console.log(JSON.stringify(error, null, 2))
-      } else {
-        console.error(`Error: ${error.error}`)
-      }
-      await closeDb()
-      process.exit(1)
-    }
-    baseUrl = slugOrUrl.endsWith('/api/support')
-      ? slugOrUrl
-      : slugOrUrl.replace(/\/$/, '') + '/api/support'
-    secret = secretValue
-  } else {
-    // Slug not found in database
-    const error = {
-      success: false,
-      error: `App "${slugOrUrl}" not found in database. Use --list to see registered apps, or provide a full URL.`,
-    }
-    if (json) {
-      console.log(JSON.stringify(error, null, 2))
-    } else {
-      console.error(`Error: App "${slugOrUrl}" not found in database`)
-      console.error('Use --list to see registered apps, or provide a full URL')
-    }
-    await closeDb()
-    process.exit(1)
-  }
-
-  if (!json) {
-    console.log(`\nHealth check: ${baseUrl}\n`)
-  }
-
-  const start = Date.now()
-  const results: HealthCheckResult = {
-    endpoint: baseUrl,
-    status: 'ok',
-    responseTime: 0,
-    actions: [],
-  }
-
-  // Test required actions
-  const requiredActions = [
-    { name: 'lookupUser', params: { email: '[EMAIL]' } },
-    { name: 'getPurchases', params: { userId: 'health-check-user-id' } },
-  ]
-
-  // Test optional actions
-  const optionalActions = [
-    { name: 'getSubscriptions', params: { userId: 'health-check-user-id' } },
-    {
-      name: 'generateMagicLink',
-      params: { email: '[EMAIL]', expiresIn: 60 },
-    },
-    {
-      name: 'getClaimedSeats',
-      params: { bulkCouponId: 'health-check-coupon-id' },
-    },
-  ]
-
-  if (!json) {
-    console.log('Testing required actions...')
-  }
-  for (const { name, params } of requiredActions) {
-    const result = await testAction(baseUrl, secret, name, params)
-    results.actions.push({ name, ...result })
-
-    if (!json) {
-      const icon =
-        result.status === 'ok'
-          ? '✓'
-          : result.status === 'not_implemented'
-            ? '○'
-            : '✗'
-      const color =
-        result.status === 'ok'
-          ? '\x1b[32m'
-          : result.status === 'not_implemented'
-            ? '\x1b[33m'
-            : '\x1b[31m'
-      console.log(
-        `  ${color}${icon}\x1b[0m ${name}${result.error ? ` - ${result.error}` : ''}`
-      )
-    }
-
-    if (result.status === 'error') {
-      results.status = 'error'
-    }
-  }
-
-  if (!json) {
-    console.log('\nTesting optional actions...')
-  }
-  for (const { name, params } of optionalActions) {
-    const result = await testAction(baseUrl, secret, name, params)
-    results.actions.push({ name, ...result })
-
-    if (!json) {
-      const icon =
-        result.status === 'ok'
-          ? '✓'
-          : result.status === 'not_implemented'
-            ? '○'
-            : '✗'
-      const color =
-        result.status === 'ok'
-          ? '\x1b[32m'
-          : result.status === 'not_implemented'
-            ? '\x1b[33m'
-            : '\x1b[31m'
-      console.log(
-        `  ${color}${icon}\x1b[0m ${name}${result.error ? ` - ${result.error}` : ''}`
-      )
-    }
-  }
-
-  results.responseTime = Date.now() - start
-
-  // Summary
-  const okCount = results.actions.filter((a) => a.status === 'ok').length
-  const errorCount = results.actions.filter((a) => a.status === 'error').length
-  const notImplementedCount = results.actions.filter(
-    (a) => a.status === 'not_implemented'
-  ).length
-
-  // JSON output includes success flag
-  const jsonResult = {
-    success: results.status !== 'error',
-    ...results,
-    summary: {
-      ok: okCount,
-      notImplemented: notImplementedCount,
-      errors: errorCount,
-    },
-  }
-
-  if (json) {
-    console.log(JSON.stringify(jsonResult, null, 2))
-  } else {
-    console.log(`\n─────────────────────────────`)
-    console.log(`Total time: ${results.responseTime}ms`)
-    console.log(
-      `Actions: \x1b[32m${okCount} ok\x1b[0m, \x1b[33m${notImplementedCount} not implemented\x1b[0m, \x1b[31m${errorCount} errors\x1b[0m`
-    )
-
-    if (results.status === 'error') {
-      console.log(`\n\x1b[31m✗ Health check failed\x1b[0m\n`)
-    } else {
-      console.log(`\n\x1b[32m✓ Health check passed\x1b[0m\n`)
-    }
-  }
-
-  await closeDb()
-  process.exit(results.status === 'error' ? 1 : 0)
-}

package/src/commands/init.test.ts

@@ -1,89 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { init } from './init'
-
-// Mock process.exit to prevent test termination
-const mockExit = vi.spyOn(process, 'exit').mockImplementation((code) => {
-  throw new Error(`process.exit(${code})`)
-})
-
-describe('init command', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    mockExit.mockClear()
-  })
-
-  afterEach(() => {
-    mockExit.mockClear()
-  })
-
-  it('should generate a secure 64-character hex webhook secret', async () => {
-    const consoleSpy = vi.spyOn(console, 'log')
-
-    // Expect process.exit(0) to be called
-    await expect(init('test-app')).rejects.toThrow('process.exit(0)')
-
-    const output = consoleSpy.mock.calls.flat().join('\n')
-    const secretMatch = output.match(/Webhook Secret: ([a-f0-9]+)/)
-
-    expect(secretMatch).toBeTruthy()
-    expect(secretMatch?.[1]).toHaveLength(64) // 32 bytes = 64 hex chars
-  })
-
-  it('should use provided app name', async () => {
-    const consoleSpy = vi.spyOn(console, 'log')
-
-    await expect(init('my-custom-app')).rejects.toThrow('process.exit(0)')
-
-    const output = consoleSpy.mock.calls.flat().join('\n')
-    expect(output).toContain('my-custom-app')
-  })
-
-  it('should default to "my-app" when name not provided and no input given', async () => {
-    // Skip this test in CI - requires user interaction
-    // In real usage, promptForName() waits for user input
-    // Testing the happy path with explicit name is sufficient
-    expect(true).toBe(true)
-  })
-
-  it('should output webhook URL and .env format', async () => {
-    const consoleSpy = vi.spyOn(console, 'log')
-
-    await expect(init('test-app')).rejects.toThrow('process.exit(0)')
-
-    const output = consoleSpy.mock.calls.flat().join('\n')
-    expect(output).toContain('Webhook URL:')
-    expect(output).toContain('Add to your .env:')
-    expect(output).toContain('FRONT_WEBHOOK_SECRET=')
-  })
-
-  it('should output JSON when --json flag is used', async () => {
-    const consoleSpy = vi.spyOn(console, 'log')
-
-    await expect(init('json-test-app', { json: true })).rejects.toThrow(
-      'process.exit(0)'
-    )
-
-    const output = consoleSpy.mock.calls.flat().join('\n')
-    const parsed = JSON.parse(output)
-
-    expect(parsed.success).toBe(true)
-    expect(parsed.appName).toBe('json-test-app')
-    expect(parsed.webhookSecret).toHaveLength(64)
-  })
-
-  it('should error in non-interactive mode without name', async () => {
-    // Mock non-interactive by checking TTY
-    const originalIsTTY = process.stdin.isTTY
-    Object.defineProperty(process.stdin, 'isTTY', {
-      value: false,
-      writable: true,
-    })
-
-    await expect(init(undefined)).rejects.toThrow('process.exit(1)')
-
-    Object.defineProperty(process.stdin, 'isTTY', {
-      value: originalIsTTY,
-      writable: true,
-    })
-  })
-})

package/src/commands/init.ts

@@ -1,106 +0,0 @@
-import { randomBytes } from 'node:crypto'
-import { createInterface } from 'node:readline'
-
-/**
- * Check if stdin is a TTY (interactive terminal)
- */
-function isInteractive(): boolean {
-  return process.stdin.isTTY === true
-}
-
-/**
- * Prompt user for app name interactively
- */
-async function promptForName(): Promise<string> {
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  })
-
-  return new Promise((resolve) => {
-    rl.question('App name: ', (answer) => {
-      rl.close()
-      resolve(answer.trim() || 'my-app')
-    })
-  })
-}
-
-export interface InitOptions {
-  json?: boolean
-}
-
-export interface InitResult {
-  success: boolean
-  appName?: string
-  webhookSecret?: string
-  error?: string
-}
-
-/**
- * Initialize command for registering new app with webhook secret
- *
- * Agent-friendly: requires name argument in non-interactive mode.
- * Use --json for machine-readable output.
- *
- * @param name - Name for the app (required in non-interactive mode)
- * @param options - Command options
- */
-export async function init(
-  name: string | undefined,
-  options: InitOptions = {}
-): Promise<void> {
-  const { json = false } = options
-
-  // In non-interactive mode, name is required
-  if (!name && !isInteractive()) {
-    const result: InitResult = {
-      success: false,
-      error:
-        'App name is required in non-interactive mode. Usage: skill init <name>',
-    }
-    if (json) {
-      console.log(JSON.stringify(result, null, 2))
-    } else {
-      console.error(`Error: ${result.error}`)
-    }
-    process.exit(1)
-  }
-
-  const appName = name || (await promptForName())
-
-  if (!appName || appName.trim() === '') {
-    const result: InitResult = {
-      success: false,
-      error: 'App name cannot be empty',
-    }
-    if (json) {
-      console.log(JSON.stringify(result, null, 2))
-    } else {
-      console.error(`Error: ${result.error}`)
-    }
-    process.exit(1)
-  }
-
-  const webhookSecret = randomBytes(32).toString('hex')
-
-  // TODO: Save to DB when database connection is configured
-  // For now, output the values for manual configuration
-
-  const result: InitResult = {
-    success: true,
-    appName,
-    webhookSecret,
-  }
-
-  if (json) {
-    console.log(JSON.stringify(result, null, 2))
-  } else {
-    console.log(`\n✓ App "${appName}" initialized\n`)
-    console.log(`Webhook URL: https://your-domain.com/api/webhooks/front`)
-    console.log(`Webhook Secret: ${webhookSecret}`)
-    console.log(`\nAdd to your .env:`)
-    console.log(`FRONT_WEBHOOK_SECRET=${webhookSecret}`)
-  }
-
-  process.exit(0)
-}