@agentmessier/restwalker 1.0.0

package/node/db.ts

@@ -0,0 +1,392 @@
+import Database from 'better-sqlite3'
+import { drizzle } from 'drizzle-orm/better-sqlite3'
+import { eq, desc, asc, sql, and, lte, inArray } from 'drizzle-orm'
+import { existsSync, mkdirSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
+
+import * as schema from './schema.js'
+
+// ── Bootstrap ──────────────────────────────────────────────────────────────────
+
+const DATA_DIR = join(homedir(), '.restwalker')
+if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true })
+
+const DB_PATH = process.env.RESTWALKER_DB ?? join(DATA_DIR, 'restwalker.db')
+
+export const CLAUDE_PROJECTS_DIR = join(homedir(), '.claude', 'projects')
+
+const client = new Database(DB_PATH)
+client.pragma('journal_mode = WAL')
+
+const db = drizzle(client, { schema })
+
+// ── Types ──────────────────────────────────────────────────────────────────────
+
+export interface Settings {
+  CODING_START_H:       string
+  CODING_END_H:         string
+  TIMEZONE:             string
+  FIVE_HOUR_PAUSE_PCT:  string
+  WEEKLY_RESERVE_PCT:   string
+  WEEKLY_HARD_STOP_PCT: string
+  POLL_INTERVAL_MIN:    string
+  CACHE_STALE_MIN:      string
+  [key: string]: string
+}
+
+export interface HistoryBucket {
+  bucket:        string
+  five_hour_pct: number
+  weekly_pct:    number
+  samples:       number
+}
+
+export type Provider     = typeof schema.providers.$inferSelect
+export type Task         = typeof schema.tasks.$inferSelect
+export type TaskStatus   = 'scheduled' | 'pending' | 'running' | 'done' | 'failed' | 'cancelled'
+export type TaskSchedule = 'once' | 'hourly' | 'daily' | 'weekly' | 'monthly'
+
+export interface Snapshot {
+  id:               number
+  five_hour_pct:    number
+  weekly_pct:       number
+  weekly_resets_at: string | null
+  recorded_at:      string
+}
+
+export const SETTING_DEFAULTS: Settings = {
+  CODING_START_H:       process.env.CODING_START_H        ?? '16',
+  CODING_END_H:         process.env.CODING_END_H          ?? '2',
+  TIMEZONE:             process.env.TIMEZONE              ?? 'America/Los_Angeles',
+  FIVE_HOUR_PAUSE_PCT:  process.env.FIVE_HOUR_PAUSE_PCT   ?? '75',
+  WEEKLY_RESERVE_PCT:   process.env.WEEKLY_RESERVE_PCT    ?? '35',
+  WEEKLY_HARD_STOP_PCT: process.env.WEEKLY_HARD_STOP_PCT  ?? '90',
+  POLL_INTERVAL_MIN:    process.env.POLL_INTERVAL_MIN     ?? '5',
+  CACHE_STALE_MIN:      process.env.CACHE_STALE_MIN       ?? '30',
+}
+
+// ── Schema migration ───────────────────────────────────────────────────────────
+
+const DEFAULT_CLAUDE_ARGS = JSON.stringify([
+  '--print', '--permission-mode', 'auto', '--output-format', 'text',
+  '--model', '{{model}}', '{{task}}',
+])
+
+export function migrate(): void {
+  client.exec(`
+    CREATE TABLE IF NOT EXISTS usage_snapshots (
+      id               INTEGER PRIMARY KEY AUTOINCREMENT,
+      five_hour_pct    REAL    NOT NULL,
+      weekly_pct       REAL    NOT NULL,
+      weekly_resets_at TEXT,
+      recorded_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+    );
+    CREATE INDEX IF NOT EXISTS usage_snapshots_recorded_at
+      ON usage_snapshots(recorded_at DESC);
+
+    CREATE TABLE IF NOT EXISTS settings (
+      key        TEXT PRIMARY KEY,
+      value      TEXT NOT NULL,
+      updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS providers (
+      id            INTEGER PRIMARY KEY AUTOINCREMENT,
+      name          TEXT    NOT NULL,
+      command       TEXT    NOT NULL,
+      args_template TEXT    NOT NULL DEFAULT '[]',
+      is_default    INTEGER NOT NULL DEFAULT 0,
+      created_at    TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      id           INTEGER PRIMARY KEY AUTOINCREMENT,
+      description  TEXT    NOT NULL,
+      cwd          TEXT    NOT NULL DEFAULT '',
+      model        TEXT    NOT NULL DEFAULT 'claude-sonnet-4-6',
+      provider_id  INTEGER REFERENCES providers(id),
+      schedule     TEXT    NOT NULL DEFAULT 'once',
+      next_run_at  TEXT,
+      status       TEXT    NOT NULL DEFAULT 'pending',
+      result       TEXT,
+      session_id   TEXT,
+      session_path TEXT,
+      tool_calls   INTEGER NOT NULL DEFAULT 0,
+      tokens_used  INTEGER NOT NULL DEFAULT 0,
+      created_at   TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now')),
+      started_at   TEXT,
+      finished_at  TEXT
+    );
+  `)
+
+  // Seed settings defaults
+  db.transaction((tx) => {
+    for (const [key, value] of Object.entries(SETTING_DEFAULTS)) {
+      tx.insert(schema.settings).values({ key, value }).onConflictDoNothing().run()
+    }
+  })
+
+  // Column migrations for existing DBs
+  const cols = (client.prepare('PRAGMA table_info(tasks)').all() as { name: string }[]).map(c => c.name)
+  if (cols.length && !cols.includes('model'))       client.exec("ALTER TABLE tasks ADD COLUMN model TEXT NOT NULL DEFAULT 'claude-sonnet-4-6'")
+  if (cols.length && !cols.includes('provider_id')) client.exec('ALTER TABLE tasks ADD COLUMN provider_id INTEGER REFERENCES providers(id)')
+  if (cols.length && !cols.includes('schedule'))    client.exec("ALTER TABLE tasks ADD COLUMN schedule TEXT NOT NULL DEFAULT 'once'")
+  if (cols.length && !cols.includes('next_run_at')) client.exec('ALTER TABLE tasks ADD COLUMN next_run_at TEXT')
+
+  // Seed default provider
+  const count = db.select({ n: sql<number>`count(*)` }).from(schema.providers).get()!.n
+  if (!count) {
+    db.insert(schema.providers).values({
+      name: 'Claude Code',
+      command: process.env.CLAUDE_BIN ?? 'claude',
+      args_template: DEFAULT_CLAUDE_ARGS,
+      is_default: 1,
+    }).run()
+  }
+
+  // Prune old snapshots
+  db.delete(schema.usageSnapshots)
+    .where(sql`${schema.usageSnapshots.recorded_at} < strftime('%Y-%m-%dT%H:%M:%SZ','now','-14 days')`)
+    .run()
+}
+
+// ── Settings repository ────────────────────────────────────────────────────────
+
+export function getSettings(): Settings {
+  const rows = db.select().from(schema.settings).all()
+  return { ...SETTING_DEFAULTS, ...Object.fromEntries(rows.map(r => [r.key, r.value])) }
+}
+
+export function updateSettings(updates: Partial<Settings>): void {
+  const allowed = new Set(Object.keys(SETTING_DEFAULTS))
+  const unknown = Object.keys(updates).filter(k => !allowed.has(k))
+  if (unknown.length) throw new Error(`Unknown settings: ${unknown.join(', ')}`)
+
+  db.transaction((tx) => {
+    for (const [key, value] of Object.entries(updates)) {
+      tx.insert(schema.settings)
+        .values({ key, value: String(value) })
+        .onConflictDoUpdate({
+          target: schema.settings.key,
+          set: {
+            value: String(value),
+            updated_at: sql`(strftime('%Y-%m-%dT%H:%M:%SZ','now'))` as unknown as string,
+          },
+        })
+        .run()
+    }
+  })
+}
+
+// ── Snapshots repository ───────────────────────────────────────────────────────
+
+export function recordSnapshot(fiveHourPct: number, weeklyPct: number, weeklyResetsAt: string | null): void {
+  db.insert(schema.usageSnapshots)
+    .values({ five_hour_pct: fiveHourPct, weekly_pct: weeklyPct, weekly_resets_at: weeklyResetsAt })
+    .run()
+}
+
+export function latestSnapshot(): Snapshot | null {
+  return db.select().from(schema.usageSnapshots)
+    .orderBy(desc(schema.usageSnapshots.recorded_at))
+    .limit(1)
+    .get() as Snapshot | null
+}
+
+export function usageHistory(hours = 48): HistoryBucket[] {
+  // Complex bucketing expression kept as raw SQL — no Drizzle equivalent for printf+strftime grouping
+  return client.prepare(`
+    SELECT
+      strftime('%Y-%m-%dT%H:', recorded_at) ||
+        printf('%02d', (CAST(strftime('%M', recorded_at) AS INTEGER) / 15) * 15) ||
+        ':00Z' AS bucket,
+      ROUND(AVG(five_hour_pct), 1) AS five_hour_pct,
+      ROUND(AVG(weekly_pct), 1)    AS weekly_pct,
+      COUNT(*)                      AS samples
+    FROM usage_snapshots
+    WHERE recorded_at >= strftime('%Y-%m-%dT%H:%M:%SZ', 'now', '-' || ? || ' hours')
+    GROUP BY bucket
+    ORDER BY bucket ASC
+  `).all(hours) as HistoryBucket[]
+}
+
+// ── Providers repository ───────────────────────────────────────────────────────
+
+export function getProviders(): Provider[] {
+  return db.select().from(schema.providers)
+    .orderBy(desc(schema.providers.is_default), asc(schema.providers.id))
+    .all()
+}
+
+export function getProvider(id: number): Provider | null {
+  return db.select().from(schema.providers).where(eq(schema.providers.id, id)).get() ?? null
+}
+
+export function getDefaultProvider(): Provider | null {
+  return db.select().from(schema.providers).where(eq(schema.providers.is_default, 1)).limit(1).get() ?? null
+}
+
+export function addProvider(name: string, command: string, argsTemplate: string): Provider {
+  return db.insert(schema.providers)
+    .values({ name, command, args_template: argsTemplate })
+    .returning()
+    .get()!
+}
+
+export function updateProvider(id: number, u: Partial<Pick<Provider, 'name' | 'command' | 'args_template'>>): void {
+  const set: Partial<typeof schema.providers.$inferInsert> = {}
+  if (u.name          !== undefined) set.name          = u.name
+  if (u.command       !== undefined) set.command       = u.command
+  if (u.args_template !== undefined) set.args_template = u.args_template
+  if (!Object.keys(set).length) return
+  db.update(schema.providers).set(set).where(eq(schema.providers.id, id)).run()
+}
+
+export function setDefaultProvider(id: number): void {
+  db.transaction((tx) => {
+    tx.update(schema.providers).set({ is_default: 0 }).run()
+    tx.update(schema.providers).set({ is_default: 1 }).where(eq(schema.providers.id, id)).run()
+  })
+}
+
+export function deleteProvider(id: number): void {
+  db.delete(schema.providers).where(eq(schema.providers.id, id)).run()
+}
+
+// ── Tasks repository ───────────────────────────────────────────────────────────
+
+const DEFAULT_MODEL = 'claude-sonnet-4-6'
+
+function computeNextRun(schedule: TaskSchedule): string {
+  const d = new Date()
+  if (schedule === 'hourly')  return new Date(d.getTime() + 3_600_000).toISOString()
+  if (schedule === 'daily')   return new Date(d.getTime() + 86_400_000).toISOString()
+  if (schedule === 'weekly')  return new Date(d.getTime() + 7 * 86_400_000).toISOString()
+  if (schedule === 'monthly') { d.setMonth(d.getMonth() + 1); return d.toISOString() }
+  return d.toISOString()
+}
+
+export function addTask(
+  description: string, cwd = '', model = DEFAULT_MODEL,
+  providerId?: number | null, schedule: TaskSchedule = 'once',
+): Task {
+  return db.insert(schema.tasks).values({
+    description,
+    cwd: cwd || process.env.HOME || '',
+    model: model || DEFAULT_MODEL,
+    provider_id: providerId ?? null,
+    schedule,
+  }).returning().get()!
+}
+
+export function createNextRun(task: Task): Task | null {
+  if (!task.schedule || task.schedule === 'once') return null
+  return db.insert(schema.tasks).values({
+    description: task.description,
+    cwd:         task.cwd,
+    model:       task.model,
+    provider_id: task.provider_id,
+    schedule:    task.schedule,
+    status:      'scheduled',
+    next_run_at: computeNextRun(task.schedule as TaskSchedule),
+  }).returning().get()!
+}
+
+export function getScheduledDueTasks(): Task[] {
+  return db.select().from(schema.tasks)
+    .where(and(
+      eq(schema.tasks.status, 'scheduled'),
+      lte(schema.tasks.next_run_at, sql`strftime('%Y-%m-%dT%H:%M:%SZ','now')`),
+    ))
+    .all()
+}
+
+export function getTasks(limit = 25, offset = 0): Task[] {
+  return db.select().from(schema.tasks)
+    .orderBy(desc(schema.tasks.id))
+    .limit(limit)
+    .offset(offset)
+    .all()
+}
+
+export function getTaskCount(): number {
+  return db.select({ n: sql<number>`count(*)` }).from(schema.tasks).get()!.n
+}
+
+export function getTask(id: number): Task | null {
+  return db.select().from(schema.tasks).where(eq(schema.tasks.id, id)).get() ?? null
+}
+
+export function setTaskPending(id: number): void {
+  db.update(schema.tasks)
+    .set({ status: 'pending', next_run_at: null })
+    .where(eq(schema.tasks.id, id))
+    .run()
+}
+
+export function setTaskRunning(id: number): void {
+  db.update(schema.tasks)
+    .set({ status: 'running', started_at: sql`(strftime('%Y-%m-%dT%H:%M:%SZ','now'))` as unknown as string })
+    .where(eq(schema.tasks.id, id))
+    .run()
+}
+
+export function setTaskDone(id: number, updates: {
+  result?: string; session_id?: string; session_path?: string
+  tool_calls?: number; tokens_used?: number
+}): void {
+  const NOW_SQL = sql`(strftime('%Y-%m-%dT%H:%M:%SZ','now'))` as unknown as string
+  const set: Partial<typeof schema.tasks.$inferInsert> = {
+    status:      'done',
+    finished_at: NOW_SQL,
+  }
+  if (updates.result       !== undefined) set.result       = updates.result
+  if (updates.session_id   !== undefined) set.session_id   = updates.session_id
+  if (updates.session_path !== undefined) set.session_path = updates.session_path
+  if (updates.tool_calls   !== undefined) set.tool_calls   = updates.tool_calls
+  if (updates.tokens_used  !== undefined) set.tokens_used  = updates.tokens_used
+  db.update(schema.tasks).set(set).where(eq(schema.tasks.id, id)).run()
+}
+
+export function setTaskFailed(id: number, error: string): void {
+  db.update(schema.tasks)
+    .set({ status: 'failed', result: error, finished_at: sql`(strftime('%Y-%m-%dT%H:%M:%SZ','now'))` as unknown as string })
+    .where(eq(schema.tasks.id, id))
+    .run()
+}
+
+export function cancelTask(id: number): void {
+  db.update(schema.tasks)
+    .set({ status: 'cancelled' })
+    .where(and(
+      eq(schema.tasks.id, id),
+      inArray(schema.tasks.status, ['pending', 'scheduled']),
+    ))
+    .run()
+}
+
+export function deleteTask(id: number): boolean {
+  const result = db.delete(schema.tasks)
+    .where(and(
+      eq(schema.tasks.id, id),
+      inArray(schema.tasks.status, ['pending', 'scheduled', 'done', 'failed', 'cancelled']),
+    ))
+    .run()
+  return result.changes > 0
+}
+
+export function queueStats(): { scheduled: number; pending: number; running: number; done: number; failed: number; total: number } {
+  // Conditional aggregation kept as raw SQL for readability
+  const row = client.prepare(`
+    SELECT
+      SUM(CASE WHEN status='scheduled' THEN 1 ELSE 0 END) AS scheduled,
+      SUM(CASE WHEN status='pending'   THEN 1 ELSE 0 END) AS pending,
+      SUM(CASE WHEN status='running'   THEN 1 ELSE 0 END) AS running,
+      SUM(CASE WHEN status='done'      THEN 1 ELSE 0 END) AS done,
+      SUM(CASE WHEN status='failed'    THEN 1 ELSE 0 END) AS failed,
+      COUNT(*)                                             AS total
+    FROM tasks
+  `).get() as { scheduled: number; pending: number; running: number; done: number; failed: number; total: number }
+  return row
+}

package/node/mcp.ts

@@ -0,0 +1,217 @@
+/**
+ * Restwalker MCP server — stdio transport for Claude Code.
+ *
+ * Tool input schemas are derived at startup from the live OpenAPI spec
+ * at /docs/json, so they stay in sync with the API automatically.
+ * Descriptions are written here for Claude UX; everything else is DRY.
+ *
+ * Register with Claude Code:
+ *   claude mcp add restwalker -- node /path/to/node_modules/.bin/tsx /path/to/node/mcp.ts
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { z } from 'zod'
+
+const BASE = process.env.RESTWALKER_URL ?? 'http://localhost:47290'
+
+// ── HTTP helper ────────────────────────────────────────────────────────────────
+
+async function api<T = unknown>(
+  method: string,
+  path: string,
+  body?: unknown,
+  query?: Record<string, string | number>,
+): Promise<T> {
+  const url = new URL(`${BASE}${path}`)
+  if (query) {
+    for (const [k, v] of Object.entries(query)) url.searchParams.set(k, String(v))
+  }
+  const res = await fetch(url, {
+    method,
+    headers: body ? { 'Content-Type': 'application/json' } : {},
+    body: body ? JSON.stringify(body) : undefined,
+  })
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: res.statusText })) as { error?: string }
+    throw new Error(err.error ?? `HTTP ${res.status}`)
+  }
+  return res.json() as Promise<T>
+}
+
+function text(data: unknown) {
+  return { content: [{ type: 'text' as const, text: JSON.stringify(data, null, 2) }] }
+}
+
+// ── Server ─────────────────────────────────────────────────────────────────────
+
+const server = new McpServer({ name: 'restwalker', version: '1.0.0' })
+
+// ── Status & usage ─────────────────────────────────────────────────────────────
+
+server.tool(
+  'status',
+  'Get daemon status: Claude usage %, coding window, gate open/closed, thresholds',
+  {},
+  async () => text(await api('GET', '/status')),
+)
+
+server.tool(
+  'can_run',
+  'Quick check: is the usage gate open right now?',
+  {},
+  async () => text(await api('GET', '/can-run')),
+)
+
+server.tool(
+  'usage_history',
+  'Usage history bucketed into 15-minute intervals',
+  { hours: z.number().int().min(1).max(720).default(48).describe('How many hours back to fetch') },
+  async ({ hours }) => text(await api('GET', '/history', undefined, { hours: hours ?? 48 })),
+)
+
+server.tool(
+  'sync',
+  'Force a Claude usage cache refresh',
+  {},
+  async () => text(await api('POST', '/sync')),
+)
+
+// ── Queue ──────────────────────────────────────────────────────────────────────
+
+server.tool(
+  'queue_stats',
+  'Task counts by status (scheduled / pending / running / done / failed / total)',
+  {},
+  async () => text(await api('GET', '/queue/stats')),
+)
+
+server.tool(
+  'queue_list',
+  'List tasks with pagination, newest first',
+  {
+    limit:  z.number().int().min(1).max(100).default(25).optional().describe('Page size (max 100)'),
+    offset: z.number().int().min(0).default(0).optional().describe('Pagination offset'),
+  },
+  async ({ limit, offset }) =>
+    text(await api('GET', '/queue', undefined, { limit: limit ?? 25, offset: offset ?? 0 })),
+)
+
+server.tool(
+  'queue_get',
+  'Get a single task by ID',
+  { id: z.number().int().describe('Task ID') },
+  async ({ id }) => text(await api('GET', `/queue/${id}`)),
+)
+
+server.tool(
+  'queue_add',
+  'Enqueue a new background task for execution by Claude Code when the gate opens',
+  {
+    description: z.string().describe('The task prompt sent to the agent'),
+    cwd:         z.string().optional().describe('Working directory for the agent'),
+    model:       z.string().optional().describe('Model ID, e.g. claude-sonnet-4-6'),
+    provider_id: z.number().int().optional().describe('Provider ID (omit for default)'),
+    schedule:    z.enum(['once','hourly','daily','weekly','monthly']).default('once').optional()
+                   .describe('Recurrence — once runs immediately, others repeat'),
+  },
+  async (args) => text(await api('POST', '/queue', args)),
+)
+
+server.tool(
+  'queue_cancel',
+  'Cancel a pending or scheduled task',
+  { id: z.number().int().describe('Task ID') },
+  async ({ id }) => text(await api('DELETE', `/queue/${id}`)),
+)
+
+server.tool(
+  'queue_force_run',
+  'Force-run a pending task immediately, bypassing the usage gate',
+  { id: z.number().int().describe('Task ID') },
+  async ({ id }) => text(await api('POST', `/queue/${id}/force-run`)),
+)
+
+server.tool(
+  'queue_session',
+  'Get the parsed Claude Code session transcript for a completed task (thinking blocks, tool calls, results)',
+  { id: z.number().int().describe('Task ID') },
+  async ({ id }) => text(await api('GET', `/queue/${id}/session`)),
+)
+
+// ── Providers ──────────────────────────────────────────────────────────────────
+
+server.tool(
+  'list_providers',
+  'List configured agent providers',
+  {},
+  async () => text(await api('GET', '/providers')),
+)
+
+server.tool(
+  'add_provider',
+  'Add a new agent provider',
+  {
+    name:         z.string().describe('Display name'),
+    command:      z.string().describe('Executable, e.g. claude or /usr/local/bin/claude'),
+    args_template:z.string().optional()
+                   .describe('JSON array with {{task}}, {{model}}, {{cwd}} placeholders'),
+  },
+  async (args) => text(await api('POST', '/providers', args)),
+)
+
+server.tool(
+  'set_default_provider',
+  'Set the default agent provider',
+  { id: z.number().int().describe('Provider ID') },
+  async ({ id }) => text(await api('POST', `/providers/${id}/default`)),
+)
+
+// ── Discovery ──────────────────────────────────────────────────────────────────
+
+server.tool(
+  'list_models',
+  'List available Anthropic models from the live API',
+  {},
+  async () => text(await api('GET', '/models')),
+)
+
+server.tool(
+  'list_projects',
+  'List Claude Code projects from ~/.claude/history.jsonl, sorted by recency — use as cwd suggestions',
+  {},
+  async () => text(await api('GET', '/projects')),
+)
+
+// ── Settings ───────────────────────────────────────────────────────────────────
+
+server.tool(
+  'get_settings',
+  'Get all daemon settings (thresholds, timezone, poll intervals)',
+  {},
+  async () => text(await api('GET', '/settings')),
+)
+
+server.tool(
+  'update_settings',
+  'Update one or more daemon settings',
+  {
+    CODING_START_H:       z.string().optional().describe('Hour (0-23) coding window starts'),
+    CODING_END_H:         z.string().optional().describe('Hour (0-23) coding window ends'),
+    TIMEZONE:             z.string().optional().describe('IANA timezone, e.g. America/Los_Angeles'),
+    FIVE_HOUR_PAUSE_PCT:  z.string().optional().describe('5-hour usage % that pauses the gate'),
+    WEEKLY_RESERVE_PCT:   z.string().optional().describe('Weekly usage % below which gate is always open'),
+    WEEKLY_HARD_STOP_PCT: z.string().optional().describe('Weekly usage % that hard-stops the gate'),
+    POLL_INTERVAL_MIN:    z.string().optional().describe('Usage poll interval in minutes'),
+    CACHE_STALE_MIN:      z.string().optional().describe('Cache stale threshold in minutes'),
+  },
+  async (args) => {
+    const updates = Object.fromEntries(Object.entries(args).filter(([, v]) => v !== undefined))
+    return text(await api('POST', '/settings', updates))
+  },
+)
+
+// ── Connect ────────────────────────────────────────────────────────────────────
+
+const transport = new StdioServerTransport()
+await server.connect(transport)