bestviber 0.0.0-stage → 0.2.0

package/src/commands.mjs

@@ -0,0 +1,644 @@
+import { spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import {
+  baseUrl,
+  call,
+  clearConfig,
+  CLIENT_ID,
+  CliError,
+  configPath,
+  localTimeZone,
+  manifest,
+  readConfig,
+  request,
+  token,
+  writeConfig,
+} from './client.mjs'
+import { clock, duration, elapsed, stats } from './format.mjs'
+import {
+  clearTrackingState,
+  hasClaudeCode,
+  hooksInstalled,
+  installHooks,
+  launchHook,
+  runHookWorker,
+  uninstallHooks,
+} from './hooks.mjs'
+
+/**
+ * @typedef {{ flags: Record<string, any>, args: string[], json: boolean }} Ctx
+ * @typedef {{
+ *   summary: string,
+ *   usage?: string,
+ *   actions: string[],
+ *   hidden?: boolean,
+ *   run: (ctx: Ctx) => Promise<unknown>,
+ * }} Command
+ */
+
+/** Download the agent skill into the folders agents read. */
+async function installSkill(/** @type {string | undefined} */ dir) {
+  // ~/.claude/skills for Claude Code; ~/.agents/skills is the shared folder
+  // other agents read, when it exists.
+  const dirs = dir
+    ? [dir]
+    : [
+        join(homedir(), '.claude', 'skills'),
+        ...(existsSync(join(homedir(), '.agents'))
+          ? [join(homedir(), '.agents', 'skills')]
+          : []),
+      ]
+  const files = await Promise.all(
+    ['SKILL.md', 'reference.md'].map(async (name) => {
+      const res = await fetch(`${await baseUrl()}/skill/${name}`)
+      if (!res.ok)
+        throw new CliError(`Could not download ${name} (HTTP ${res.status}).`)
+      return { name, body: await res.text() }
+    }),
+  )
+  const written = []
+  for (const d of dirs) {
+    const target = join(d, 'bestviber')
+    await mkdir(target, { recursive: true })
+    for (const f of files) await writeFile(join(target, f.name), f.body)
+    written.push(target)
+  }
+  return written
+}
+
+/** Yes/no on a terminal; with no terminal (an agent ran us), the default. */
+async function confirm(/** @type {string} */ question, fallback = true) {
+  if (!process.stdin.isTTY || !process.stderr.isTTY) return fallback
+  const { createInterface } = await import('node:readline/promises')
+  const rl = createInterface({ input: process.stdin, output: process.stderr })
+  const answer = (await rl.question(`${question} [Y/n] `)).trim().toLowerCase()
+  rl.close()
+  return answer === '' ? fallback : answer.startsWith('y')
+}
+
+/** After sign-in: the skill, and automatic tracking for Claude Code. */
+async function setUpAgents() {
+  const lines = []
+  try {
+    await installSkill(undefined)
+    lines.push('Installed the agent skill.')
+  } catch (err) {
+    lines.push(`Skipped the agent skill: ${/** @type {Error} */ (err).message}`)
+  }
+  if (!hasClaudeCode()) return lines
+  const ask = process.stdin.isTTY && process.stderr.isTTY
+  if (
+    await confirm(
+      '\nTrack your Claude Code sessions automatically? Each session is filed under the repository you work in.',
+    )
+  ) {
+    await installHooks()
+    lines.push(
+      'Claude Code sessions are now tracked automatically, by project.' +
+        (ask ? '' : ' (Turn it off with `bestviber tracking off`.)'),
+    )
+  } else {
+    lines.push(
+      'Automatic tracking is off. Turn it on with `bestviber tracking on`.',
+    )
+  }
+  return lines
+}
+
+const sleep = (/** @type {number} */ ms) =>
+  new Promise((r) => setTimeout(r, ms))
+
+function openBrowser(/** @type {string} */ url) {
+  const cmd =
+    process.platform === 'darwin'
+      ? 'open'
+      : process.platform === 'win32'
+        ? 'cmd'
+        : 'xdg-open'
+  const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url]
+  try {
+    spawn(cmd, args, { stdio: 'ignore', detached: true })
+      .on('error', () => {})
+      .unref()
+  } catch {
+    // No browser; the URL is printed anyway.
+  }
+}
+
+/** Prints `human` normally, `data` as JSON with --json. */
+function out(
+  /** @type {Ctx} */ ctx,
+  /** @type {unknown} */ data,
+  /** @type {string} */ human,
+) {
+  return ctx.json ? data : human
+}
+
+async function tagIdsByName(/** @type {string[]} */ names) {
+  if (names.length === 0) return undefined
+  /** @type {Array<{id: string, name: string}>} */
+  const tags = await call('list_tags')
+  return names.map((name) => {
+    const t = tags.find((x) => x.name.toLowerCase() === name.toLowerCase())
+    if (!t)
+      throw new CliError(
+        `No tag "${name}". Tags: ${tags.map((x) => x.name).join(', ') || 'none'}. Create it with \`bestviber tags add ${name}\`.`,
+      )
+    return t.id
+  })
+}
+
+const asList = (/** @type {unknown} */ v) =>
+  v === undefined ? [] : Array.isArray(v) ? v : [v]
+
+/** @type {Record<string, Command>} */
+export const commands = {
+  // ───── account ─────
+  login: {
+    summary: 'Sign in by approving a code in your browser',
+    usage: 'login [--no-browser]',
+    actions: [],
+    async run(ctx) {
+      const start = await request('/api/auth/device/code', {
+        auth: false,
+        body: { client_id: CLIENT_ID },
+      })
+      if (!start.ok)
+        throw new CliError(
+          `Could not start sign-in: ${start.data?.error_description ?? start.status}`,
+        )
+      const d = start.data
+      const code = `${d.user_code.slice(0, 4)}-${d.user_code.slice(4)}`
+      process.stderr.write(
+        `\nOpen ${d.verification_uri_complete}\nand approve the code  ${code}\n\nWaiting for approval…`,
+      )
+      if (!ctx.flags['no-browser']) openBrowser(d.verification_uri_complete)
+
+      let interval = (d.interval ?? 5) * 1000
+      const deadline = Date.now() + d.expires_in * 1000
+      while (Date.now() < deadline) {
+        await sleep(interval)
+        const res = await request('/api/auth/device/token', {
+          auth: false,
+          body: {
+            grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+            device_code: d.device_code,
+            client_id: CLIENT_ID,
+          },
+        })
+        if (res.ok && res.data?.access_token) {
+          const t = res.data.access_token
+          const me = await fetch(`${await baseUrl()}/api/auth/get-session`, {
+            headers: { Authorization: `Bearer ${t}` },
+          }).then((r) => r.json())
+          await writeConfig({
+            ...(await readConfig()),
+            token: t,
+            email: me?.user?.email,
+          })
+          process.stderr.write(' approved.\n')
+          const setup = await setUpAgents()
+          return out(
+            ctx,
+            { ok: true, email: me?.user?.email, setup },
+            [`Signed in as ${me?.user?.email ?? 'you'}.`, ...setup].join('\n'),
+          )
+        }
+        const err = res.data?.error
+        if (err === 'authorization_pending') continue
+        if (err === 'slow_down') {
+          interval += 5000
+          continue
+        }
+        process.stderr.write('\n')
+        if (err === 'access_denied') throw new CliError('Sign-in was denied.')
+        if (err === 'expired_token')
+          throw new CliError('The code expired. Run `bestviber login` again.')
+        throw new CliError(
+          `Sign-in failed: ${res.data?.error_description ?? err ?? res.status}`,
+        )
+      }
+      throw new CliError('The code expired. Run `bestviber login` again.')
+    },
+  },
+
+  logout: {
+    summary: 'Sign out and forget the token on this machine',
+    actions: [],
+    async run(ctx) {
+      if (await token())
+        await request('/api/auth/sign-out', { body: {} }).catch(() => {})
+      await clearConfig()
+      const removed = await uninstallHooks().catch(() => false)
+      await clearTrackingState()
+      return out(
+        ctx,
+        { ok: true, trackingRemoved: removed },
+        removed
+          ? 'Signed out, and stopped tracking Claude Code sessions.'
+          : 'Signed out.',
+      )
+    },
+  },
+
+  whoami: {
+    summary: 'Show the signed-in account',
+    actions: [],
+    async run(ctx) {
+      const res = await request('/api/auth/get-session')
+      const email = res.data?.user?.email
+      if (!email) throw new CliError('Not signed in. Run `bestviber login`.', 2)
+      return out(ctx, { email, server: await baseUrl() }, email)
+    },
+  },
+
+  token: {
+    summary: 'Print the API token (for MCP or scripts). Keep it secret.',
+    actions: [],
+    async run() {
+      const t = await token()
+      if (!t) throw new CliError('Not signed in. Run `bestviber login`.', 2)
+      return t
+    },
+  },
+
+  mcp: {
+    summary: 'Show how to connect an AI agent over MCP',
+    actions: [],
+    async run(ctx) {
+      const url = `${await baseUrl()}/api/mcp`
+      const config = {
+        mcpServers: {
+          bestviber: {
+            type: 'http',
+            url,
+            headers: {
+              Authorization: 'Bearer <run: bestviber token>',
+              'X-Timezone': localTimeZone(),
+            },
+          },
+        },
+      }
+      if (ctx.json) return config
+      return [
+        ...((await token())
+          ? []
+          : [
+              'Not signed in yet: run `bestviber login` first, or the token below is empty.',
+              '',
+            ]),
+        'Claude Code:',
+        `  claude mcp add --transport http bestviber ${url} \\`,
+        '    --header "Authorization: Bearer $(bestviber token)" \\',
+        `    --header "X-Timezone: ${localTimeZone()}"`,
+        '',
+        'Other clients (JSON config; paste the output of `bestviber token`):',
+        JSON.stringify(config, null, 2)
+          .split('\n')
+          .map((l) => `  ${l}`)
+          .join('\n'),
+      ].join('\n')
+    },
+  },
+
+  skill: {
+    summary: 'Install the bestviber skill for Claude Code and other agents',
+    usage: 'skill install [--dir <skills-folder>]',
+    actions: [],
+    async run(ctx) {
+      if (ctx.args[0] !== 'install')
+        throw new CliError('Usage: bestviber skill install [--dir <folder>]')
+      const written = await installSkill(
+        ctx.flags.dir ? String(ctx.flags.dir) : undefined,
+      )
+      return out(
+        ctx,
+        { installed: written },
+        `Installed the bestviber skill to:\n${written.map((d) => `  ${d}`).join('\n')}\nRun this again any time to update it.`,
+      )
+    },
+  },
+
+  // Called by Claude Code, not by people: see hooks.mjs.
+  hook: {
+    summary: 'Claude Code hook entry point',
+    actions: [
+      'get_active_session',
+      'start_focus_session',
+      'pause_focus_session',
+      'resume_focus_session',
+      'finish_focus_session',
+    ],
+    hidden: true,
+    async run(ctx) {
+      if (ctx.flags.run) await runHookWorker()
+      else await launchHook()
+      return undefined
+    },
+  },
+
+  tracking: {
+    summary: 'Automatic tracking of Claude Code sessions: on, off or status',
+    usage: 'tracking [on | off]',
+    actions: [],
+    hidden: true,
+    async run(ctx) {
+      const sub = ctx.args[0]
+      if (sub === 'on') {
+        if (!(await token()))
+          throw new CliError('Not signed in. Run `bestviber login` first.', 2)
+        const r = await installHooks()
+        return out(
+          ctx,
+          { on: true, ...r },
+          'Claude Code sessions are tracked automatically.',
+        )
+      }
+      if (sub === 'off') {
+        await uninstallHooks()
+        await clearTrackingState()
+        return out(ctx, { on: false }, 'Automatic tracking is off.')
+      }
+      if (sub) throw new CliError('Usage: bestviber tracking [on | off]')
+      const on = await hooksInstalled()
+      return out(
+        ctx,
+        { on },
+        on ? 'Automatic tracking is on.' : 'Automatic tracking is off.',
+      )
+    },
+  },
+
+  // ───── timer ─────
+  start: {
+    summary: 'Start a focus session',
+    usage: 'start [--tag <name>]... [--room <id>]',
+    actions: ['start_focus_session', 'list_tags'],
+    async run(ctx) {
+      const row = await call('start_focus_session', {
+        tagIds: await tagIdsByName(asList(ctx.flags.tag)),
+        roomId: ctx.flags.room,
+      })
+      return out(ctx, row, `Focus session started at ${clock(row.startedAt)}.`)
+    },
+  },
+
+  pause: {
+    summary: 'Pause the running session',
+    actions: ['pause_focus_session'],
+    async run(ctx) {
+      return out(ctx, await call('pause_focus_session'), 'Paused.')
+    },
+  },
+
+  resume: {
+    summary: 'Resume the paused session',
+    actions: ['resume_focus_session'],
+    async run(ctx) {
+      return out(ctx, await call('resume_focus_session'), 'Resumed.')
+    },
+  },
+
+  stop: {
+    summary: 'Finish the session and record it',
+    usage: 'stop [--note <text>]',
+    actions: ['finish_focus_session'],
+    async run(ctx) {
+      const res = await call('finish_focus_session', { notes: ctx.flags.note })
+      return out(ctx, res, `Recorded ${duration(res.durationMs)} of focus.`)
+    },
+  },
+
+  status: {
+    summary: 'Show the open session and today so far',
+    actions: ['get_active_session', 'get_focus_totals'],
+    async run(ctx) {
+      const [active, totals] = await Promise.all([
+        call('get_active_session'),
+        call('get_focus_totals'),
+      ])
+      if (ctx.json) return { active, totals }
+      const running = active ? elapsed(active) : 0
+      const lines = [
+        active
+          ? `${active.status === 'paused' ? 'Paused' : 'Focusing'}: ${duration(running)} (started ${clock(active.startedAt)})`
+          : 'No session running.',
+        `Today: ${duration(totals.today + running)}   last 7 days: ${duration(totals.week + running)}`,
+      ]
+      return lines.join('\n')
+    },
+  },
+
+  // ───── stats ─────
+  today: periodCommand('day', 'today', 'Stats for today'),
+  yesterday: periodCommand('day', 'yesterday', 'Stats for yesterday'),
+  week: periodCommand('week', 'today', 'Stats for this week (from Monday)'),
+  month: periodCommand('month', 'today', 'Stats for this month'),
+  year: periodCommand('year', 'today', 'Stats for this year'),
+
+  stats: {
+    summary: 'Stats for any period or range',
+    usage:
+      'stats [--period day|week|month|year] [--date <YYYY-MM-DD>] | [--from <date> --to <date>]',
+    actions: ['get_stats'],
+    async run(ctx) {
+      const s = await call('get_stats', {
+        period: ctx.flags.period,
+        date: ctx.flags.date,
+        from: ctx.flags.from,
+        to: ctx.flags.to,
+      })
+      return out(ctx, s, stats(s))
+    },
+  },
+
+  streak: {
+    summary: 'Current and longest streak of focus days',
+    actions: ['get_streaks'],
+    async run(ctx) {
+      const s = await call('get_streaks')
+      return out(
+        ctx,
+        s,
+        [
+          `Current streak: ${s.currentDays} day${s.currentDays === 1 ? '' : 's'}${s.currentDays && !s.focusedToday ? ' (focus today to keep it)' : ''}`,
+          `Longest: ${s.longestDays} day${s.longestDays === 1 ? '' : 's'}${s.longest ? ` (${s.longest.from} → ${s.longest.to})` : ''}`,
+          `Active days in total: ${s.totalActiveDays}`,
+        ].join('\n'),
+      )
+    },
+  },
+
+  insights: {
+    summary: 'Findings about when and how you focus',
+    actions: ['get_insights'],
+    async run(ctx) {
+      const r = await call('get_insights')
+      return out(
+        ctx,
+        r,
+        r.insights.map((/** @type {any} */ i) => `• ${i.text}`).join('\n'),
+      )
+    },
+  },
+
+  sessions: {
+    summary: 'List finished sessions for a day or range',
+    usage:
+      'sessions [--date today|yesterday|<YYYY-MM-DD>] | [--from <date> --to <date>]',
+    actions: ['list_sessions'],
+    async run(ctx) {
+      /** @type {any[]} */
+      const rows = await call('list_sessions', {
+        date: ctx.flags.date,
+        from: ctx.flags.from,
+        to: ctx.flags.to,
+      })
+      if (ctx.json) return rows
+      if (rows.length === 0) return 'No sessions.'
+      return rows
+        .map(
+          (s) =>
+            `${new Date(s.startedAt).toLocaleDateString()} ${clock(s.startedAt)}  ${duration(s.durationMs).padStart(7)}${s.notes ? `  ${s.notes}` : ''}`,
+        )
+        .join('\n')
+    },
+  },
+
+  // ───── tags & rooms ─────
+  tags: {
+    summary: 'List tags, or `tags add <name>` / `tags rm <name>`',
+    usage: 'tags [add <name> | rm <name>]',
+    actions: ['list_tags', 'create_tag', 'delete_tag'],
+    async run(ctx) {
+      const [sub, ...rest] = ctx.args
+      const name = rest.join(' ')
+      if (sub === 'add') {
+        if (!name) throw new CliError('Usage: bestviber tags add <name>')
+        return out(
+          ctx,
+          await call('create_tag', { name }),
+          `Added tag "${name}".`,
+        )
+      }
+      if (sub === 'rm' || sub === 'remove') {
+        const [id] = (await tagIdsByName([name])) ?? []
+        return out(
+          ctx,
+          await call('delete_tag', { id }),
+          `Removed tag "${name}".`,
+        )
+      }
+      if (sub) throw new CliError(`Unknown subcommand "tags ${sub}".`)
+      /** @type {any[]} */
+      const tags = await call('list_tags')
+      return out(
+        ctx,
+        tags,
+        tags.length ? tags.map((t) => t.name).join('\n') : 'No tags yet.',
+      )
+    },
+  },
+
+  rooms: {
+    summary: 'List your focus rooms',
+    actions: ['list_rooms'],
+    async run(ctx) {
+      /** @type {any[]} */
+      const rooms = await call('list_rooms')
+      return out(
+        ctx,
+        rooms,
+        rooms.length
+          ? rooms.map((r) => `${r.id}  ${r.name}`).join('\n')
+          : 'No rooms yet.',
+      )
+    },
+  },
+
+  // ───── everything else ─────
+  tools: {
+    summary: 'List every action the server offers (always up to date)',
+    actions: [],
+    async run(ctx) {
+      const list = await manifest()
+      if (ctx.json) return list
+      const width = Math.max(...list.map((a) => a.name.length))
+      return list
+        .map((a) => `${a.name.padEnd(width)}  ${a.title}`)
+        .join('\n')
+        .concat(
+          '\n\nRun one with: bestviber run <name> [--key value]... or --input <json>',
+        )
+    },
+  },
+
+  run: {
+    summary: 'Run any action by name',
+    usage:
+      'run <action> [--key value]... | run <action> --input \'{"json":true}\'',
+    actions: [],
+    async run(ctx) {
+      const [name] = ctx.args
+      if (!name)
+        throw new CliError(
+          'Usage: bestviber run <action>. See `bestviber tools`.',
+        )
+      const { input: raw, ...rest } = ctx.flags
+      let input = {}
+      if (raw) {
+        try {
+          input = JSON.parse(raw)
+        } catch {
+          throw new CliError('--input must be JSON.')
+        }
+      } else {
+        const action = (await manifest()).find((a) => a.name === name)
+        if (!action)
+          throw new CliError(
+            `Unknown action "${name}". See \`bestviber tools\`.`,
+          )
+        input = coerce(rest, action.inputSchema)
+      }
+      const result = await call(name, input)
+      return ctx.json ? result : JSON.stringify(result, null, 2)
+    },
+  },
+}
+
+/** Turns `--key value` strings into the types the JSON Schema asks for. */
+function coerce(
+  /** @type {Record<string, any>} */ flags,
+  /** @type {any} */ schema,
+) {
+  /** @type {Record<string, unknown>} */
+  const input = {}
+  for (const [key, value] of Object.entries(flags)) {
+    const type = schema?.properties?.[key]?.type
+    if (type === 'number' || type === 'integer') input[key] = Number(value)
+    else if (type === 'boolean') input[key] = value === true || value === 'true'
+    else if (type === 'array') input[key] = asList(value)
+    else input[key] = value
+  }
+  return input
+}
+
+function periodCommand(
+  /** @type {string} */ period,
+  /** @type {string} */ date,
+  /** @type {string} */ summary,
+) {
+  return /** @type {Command} */ ({
+    summary,
+    actions: ['get_stats'],
+    async run(ctx) {
+      const s = await call('get_stats', { period, date })
+      return out(ctx, s, stats(s))
+    },
+  })
+}
+
+export { configPath }