@goliapkg/sentori-cli 0.6.0 → 1.1.0

package/src/issue.ts

@@ -1,26 +1,26 @@
-// `sentori-cli issue list / resolve / silence` — CI triage helpers.
+// `sentori-cli issue list / resolve` — CI triage over the AI
+// surface (`/api/*`, api-scope token; the same loop an agent runs).
 
 type Issue = {
-  errorType: string
-  eventCount: number
   id: string
-  lastSeen: string
+  kind: string
+  title: string
   messageSample: string
-  status: 'active' | 'closed' | 'resolved' | 'silenced'
+  status: string
+  eventCount: number
+  usersCount: number
+  maxPerUser: number
+  lastSeen: string
+  regressed: boolean
 }
 
-type AdminConfig = {
+export type ApiConfig = {
   apiUrl: string
-  projectId: string
   token: string
 }
 
-function url(c: AdminConfig, path: string): string {
-  return `${c.apiUrl.replace(/\/+$/, '')}/admin/api/projects/${c.projectId}${path}`
-}
-
-async function adminFetch<T>(c: AdminConfig, path: string, init?: RequestInit): Promise<T> {
-  const resp = await fetch(url(c, path), {
+async function apiFetch<T>(c: ApiConfig, path: string, init?: RequestInit): Promise<T> {
+  const resp = await fetch(`${c.apiUrl.replace(/\/+$/, '')}${path}`, {
     ...init,
     headers: {
       Authorization: `Bearer ${c.token}`,
@@ -29,53 +29,54 @@ async function adminFetch<T>(c: AdminConfig, path: string, init?: RequestInit):
     },
   })
   if (!resp.ok) {
-    let detail = ''
-    try {
-      detail = await resp.text()
-    } catch {
-      // ignore
-    }
+    const detail = await resp.text().catch(() => '')
     throw new Error(
       `${resp.status} ${resp.statusText}${detail ? ` — ${detail.slice(0, 300)}` : ''}`,
     )
   }
-  // PATCH /issues/<id> returns the row; some endpoints might return no
-  // content — handle both.
-  const txt = await resp.text()
-  return (txt ? JSON.parse(txt) : null) as T
+  return (await resp.json()) as T
 }
 
-export type IssueListOptions = {
-  config: AdminConfig
-  errorType?: string
-  limit?: number
-  status?: 'active' | 'closed' | 'resolved' | 'silenced'
-}
-
-export async function issueList(opts: IssueListOptions): Promise<Issue[]> {
+export async function listIssues(
+  c: ApiConfig,
+  opts: { status?: string; kind?: string } = {},
+): Promise<Issue[]> {
   const q = new URLSearchParams()
   if (opts.status) q.set('status', opts.status)
-  if (opts.limit) q.set('limit', String(opts.limit))
-  if (opts.errorType) q.set('errorType', opts.errorType)
+  if (opts.kind) q.set('kind', opts.kind)
   const qs = q.toString()
-  return adminFetch<Issue[]>(opts.config, `/issues${qs ? '?' + qs : ''}`)
+  const body = await apiFetch<{ issues: Issue[] }>(c, `/api/issues${qs ? `?${qs}` : ''}`)
+  return body.issues
 }
 
-export async function issuePatch(
-  config: AdminConfig,
+export async function resolveIssue(
+  c: ApiConfig,
   issueId: string,
-  body: { resolvedInRelease?: string; status: 'active' | 'closed' | 'resolved' | 'silenced' },
-): Promise<Issue> {
-  return adminFetch<Issue>(config, `/issues/${encodeURIComponent(issueId)}`, {
-    body: JSON.stringify(body),
-    method: 'PATCH',
+  release?: string,
+): Promise<void> {
+  await apiFetch(c, `/api/issues/${encodeURIComponent(issueId)}/resolve`, {
+    method: 'POST',
+    body: JSON.stringify(release ? { release } : {}),
+  })
+}
+
+export async function noteIssue(c: ApiConfig, issueId: string, body: string): Promise<void> {
+  await apiFetch(c, `/api/issues/${encodeURIComponent(issueId)}/notes`, {
+    method: 'POST',
+    body: JSON.stringify({ body }),
   })
 }
 
-/** Format one issue for terminal output — short, one line, scannable. */
+export async function fetchBundle(c: ApiConfig, issueId: string): Promise<string> {
+  const resp = await fetch(
+    `${c.apiUrl.replace(/\/+$/, '')}/api/issues/${encodeURIComponent(issueId)}/bundle`,
+    { headers: { Authorization: `Bearer ${c.token}` } },
+  )
+  if (!resp.ok) throw new Error(`${resp.status} ${resp.statusText}`)
+  return resp.text()
+}
+
 export function formatIssueLine(i: Issue): string {
-  const status = i.status.padEnd(9)
-  const title = `${i.errorType}${i.messageSample ? `: ${i.messageSample}` : ''}`
-  const events = `${i.eventCount}×`
-  return `${i.id}  ${status}  ${title.slice(0, 80).padEnd(80)}  ${events}`
+  const flag = i.regressed ? ' REGRESSED' : ''
+  return `${i.id}  [${i.kind}] ${i.title}  ${i.usersCount}u×${i.maxPerUser}  ${i.eventCount}ev${flag}`
 }

package/src/lenient.ts

@@ -0,0 +1,39 @@
+// The iron rule reaches build-time (design.md §6 dim 3): an upload
+// failure must never break the customer's build or release. Every
+// upload-family command runs through this wrapper — on failure it
+// prints a friendly, actionable note and exits 0. `--strict` opts
+// into a real non-zero exit for pipelines that want the hard
+// guarantee.
+
+export type LenientOutcome = {
+  /** What failed, one line. */
+  failure: string
+  /** What it means for the customer, one or two lines. */
+  impact: string
+  /** A copy-pasteable retry command. */
+  retry: string
+}
+
+export const isStrict = (argv: string[]): boolean => argv.includes('--strict')
+
+/** Strip --strict before handing argv to parseArgs. */
+export const stripStrict = (argv: string[]): string[] =>
+  argv.filter((a) => a !== '--strict')
+
+export const lenientFail = (strict: boolean, o: LenientOutcome): number => {
+  console.error(`[sentori] ⚠ ${o.failure}`)
+  if (!strict) {
+    console.error('[sentori]   Your build is NOT blocked by this.')
+  }
+  console.error(`[sentori]   Impact: ${o.impact}`)
+  console.error('[sentori]   Retry anytime:')
+  console.error(`[sentori]     ${o.retry}`)
+  console.error(
+    '[sentori]   Events received in the meantime are re-symbolicated automatically after upload.',
+  )
+  if (strict) {
+    console.error('[sentori]   (--strict: exiting non-zero)')
+    return 1
+  }
+  return 0
+}

package/src/mcp.ts

@@ -19,8 +19,6 @@
 
 import { createInterface } from 'node:readline'
 
-import type { AdminUpload } from './native-artifacts.js'
-
 type JsonRpcRequest = {
   id?: number | string | null
   jsonrpc: '2.0'
@@ -44,7 +42,7 @@ type ToolDef = {
   handler: ToolHandler
 }
 
-type McpCtx = AdminUpload
+type McpCtx = { apiUrl: string; token: string }
 
 /** Run the MCP server over stdio. Returns when stdin closes. */
 export async function runMcpServer(ctx: McpCtx): Promise<void> {
@@ -135,265 +133,98 @@ async function dispatch(
   }
 }
 
-// ── Tool implementations ─────────────────────────────────────────
+// ── Tool implementations — the /api closed loop ──────────────────
+//
+// Four tools, mirroring exactly what an agent needs (design.md §9):
+// pick work, pull the evidence, write back, resolve. The bundle is
+// the product; everything else is triage plumbing.
 
-async function adminGet<T>(ctx: McpCtx, path: string): Promise<T> {
-  const url = `${ctx.apiUrl.replace(/\/+$/, '')}/admin/api${path}`
-  const resp = await fetch(url, {
-    headers: { Authorization: `Bearer ${ctx.token}` },
-  })
+async function apiGet(ctx: McpCtx, path: string, raw = false): Promise<unknown> {
+  const url = `${ctx.apiUrl.replace(/\/+$/, '')}${path}`
+  const resp = await fetch(url, { headers: { Authorization: `Bearer ${ctx.token}` } })
   if (!resp.ok) throw new Error(`GET ${path} → ${resp.status} ${resp.statusText}`)
-  return (await resp.json()) as T
+  return raw ? resp.text() : resp.json()
 }
 
-async function adminPatch<T>(ctx: McpCtx, path: string, body: unknown): Promise<T> {
-  const url = `${ctx.apiUrl.replace(/\/+$/, '')}/admin/api${path}`
+async function apiPost(ctx: McpCtx, path: string, body: unknown): Promise<unknown> {
+  const url = `${ctx.apiUrl.replace(/\/+$/, '')}${path}`
   const resp = await fetch(url, {
     body: JSON.stringify(body),
     headers: {
       Authorization: `Bearer ${ctx.token}`,
       'Content-Type': 'application/json',
     },
-    method: 'PATCH',
-  })
-  if (!resp.ok) throw new Error(`PATCH ${path} → ${resp.status} ${resp.statusText}`)
-  return (await resp.json()) as T
-}
-
-async function adminPost<T>(ctx: McpCtx, path: string, body: unknown): Promise<T> {
-  const url = `${ctx.apiUrl.replace(/\/+$/, '')}/admin/api${path}`
-  const resp = await fetch(url, {
-    body: body !== undefined ? JSON.stringify(body) : undefined,
-    headers: {
-      Authorization: `Bearer ${ctx.token}`,
-      'Content-Type': 'application/json',
-    },
     method: 'POST',
   })
   if (!resp.ok) throw new Error(`POST ${path} → ${resp.status} ${resp.statusText}`)
-  if (resp.status === 204) return null as T
-  return (await resp.json()) as T
-}
-
-async function adminPut<T>(ctx: McpCtx, path: string): Promise<T> {
-  const url = `${ctx.apiUrl.replace(/\/+$/, '')}/admin/api${path}`
-  const resp = await fetch(url, {
-    headers: { Authorization: `Bearer ${ctx.token}` },
-    method: 'PUT',
-  })
-  if (!resp.ok) throw new Error(`PUT ${path} → ${resp.status} ${resp.statusText}`)
-  if (resp.status === 204) return null as T
-  return (await resp.json()) as T
-}
-
-async function adminDelete<T>(ctx: McpCtx, path: string): Promise<T> {
-  const url = `${ctx.apiUrl.replace(/\/+$/, '')}/admin/api${path}`
-  const resp = await fetch(url, {
-    headers: { Authorization: `Bearer ${ctx.token}` },
-    method: 'DELETE',
-  })
-  if (!resp.ok) throw new Error(`DELETE ${path} → ${resp.status} ${resp.statusText}`)
-  if (resp.status === 204) return null as T
-  return (await resp.json()) as T
+  return resp.json()
 }
 
 function asString(v: unknown, name: string): string {
-  if (typeof v !== 'string' || v.length === 0) {
-    throw new Error(`${name} is required (string)`)
-  }
-  return v
-}
-
-function asOptionalString(v: unknown): string | undefined {
-  if (v === undefined || v === null) return undefined
-  if (typeof v !== 'string') throw new Error('expected string')
+  if (typeof v !== 'string' || v.length === 0) throw new Error(`${name} must be a non-empty string`)
   return v
 }
 
 export function buildTools(): ToolDef[] {
   return [
     {
+      name: 'sentori_issue_list',
       description:
-        'List issues for a Sentori project, with optional status / priority / label filters.',
-      handler: async (args, ctx) => {
-        const projectId = asString(args.projectId, 'projectId')
-        const usp = new URLSearchParams()
-        const status = asOptionalString(args.status) ?? 'any'
-        usp.set('status', status)
-        if (args.priority) usp.set('priority', String(args.priority))
-        if (args.label) usp.set('labels', String(args.label))
-        if (typeof args.limit === 'number') usp.set('limit', String(args.limit))
-        return await adminGet(ctx, `/projects/${projectId}/issues?${usp}`)
-      },
+        'List issues (default: open, ordered by objective importance — regressed first, then breadth × depth). Filter with status (open|resolved|ignored) and kind (error|warn|trace|assert|probe).',
       inputSchema: {
-        properties: {
-          label: { type: 'string' },
-          limit: { type: 'number' },
-          priority: { type: 'string' },
-          projectId: { type: 'string' },
-          status: { type: 'string' },
-        },
-        required: ['projectId'],
         type: 'object',
-      },
-      name: 'sentori_issue_list',
-    },
-    {
-      description: 'Get full detail for one Sentori issue including its activity feed.',
-      handler: async (args, ctx) => {
-        const projectId = asString(args.projectId, 'projectId')
-        const issueId = asString(args.issueId, 'issueId')
-        const [issue, activity] = await Promise.all([
-          adminGet(ctx, `/projects/${projectId}/issues/${issueId}`),
-          adminGet(ctx, `/projects/${projectId}/issues/${issueId}/activity`),
-        ])
-        return { activity, issue }
-      },
-      inputSchema: {
         properties: {
-          issueId: { type: 'string' },
-          projectId: { type: 'string' },
+          status: { type: 'string', enum: ['open', 'resolved', 'ignored'] },
+          kind: { type: 'string', enum: ['assert', 'error', 'probe', 'trace', 'warn'] },
         },
-        required: ['projectId', 'issueId'],
-        type: 'object',
       },
-      name: 'sentori_issue_get',
-    },
-    {
-      description: 'Add a comment to a Sentori issue.',
       handler: async (args, ctx) => {
-        const projectId = asString(args.projectId, 'projectId')
-        const issueId = asString(args.issueId, 'issueId')
-        const body = asString(args.body, 'body')
-        return await adminPost(ctx, `/projects/${projectId}/issues/${issueId}/comments`, {
-          body,
-        })
-      },
-      inputSchema: {
-        properties: {
-          body: { type: 'string' },
-          issueId: { type: 'string' },
-          projectId: { type: 'string' },
-        },
-        required: ['projectId', 'issueId', 'body'],
-        type: 'object',
+        const q = new URLSearchParams()
+        if (typeof args.status === 'string') q.set('status', args.status)
+        if (typeof args.kind === 'string') q.set('kind', args.kind)
+        const qs = q.toString()
+        return apiGet(ctx, `/api/issues${qs ? `?${qs}` : ''}`)
       },
-      name: 'sentori_issue_comment',
     },
     {
+      name: 'sentori_issue_bundle',
       description:
-        'Transition an issue to a new status (active|silenced|muted|resolved|closed).',
-      handler: async (args, ctx) => {
-        const projectId = asString(args.projectId, 'projectId')
-        const issueId = asString(args.issueId, 'issueId')
-        const status = asString(args.status, 'status')
-        return await adminPatch(ctx, `/projects/${projectId}/issues/${issueId}`, {
-          status,
-        })
-      },
+        'Fetch the full evidence bundle for one issue as markdown — read it and you have everything needed to fix: stack, user timeline, environment, distribution, guard-probe status.',
       inputSchema: {
-        properties: {
-          issueId: { type: 'string' },
-          projectId: { type: 'string' },
-          status: {
-            enum: ['active', 'silenced', 'muted', 'resolved', 'closed'],
-            type: 'string',
-          },
-        },
-        required: ['projectId', 'issueId', 'status'],
         type: 'object',
+        properties: { issueId: { type: 'string' } },
+        required: ['issueId'],
       },
-      name: 'sentori_issue_transition',
+      handler: async (args, ctx) =>
+        apiGet(ctx, `/api/issues/${encodeURIComponent(asString(args.issueId, 'issueId'))}/bundle`, true),
     },
     {
-      description: 'Assign an issue to a user, or pass userId=null to unassign.',
-      handler: async (args, ctx) => {
-        const projectId = asString(args.projectId, 'projectId')
-        const issueId = asString(args.issueId, 'issueId')
-        const userId = args.userId === null ? null : asOptionalString(args.userId)
-        return await adminPatch(ctx, `/projects/${projectId}/issues/${issueId}`, {
-          assigneeUserId: userId ?? null,
-        })
-      },
-      inputSchema: {
-        properties: {
-          issueId: { type: 'string' },
-          projectId: { type: 'string' },
-          userId: { type: ['string', 'null'] },
-        },
-        required: ['projectId', 'issueId', 'userId'],
-        type: 'object',
-      },
-      name: 'sentori_issue_assign',
-    },
-    {
-      description: 'Set the triage priority on an issue.',
-      handler: async (args, ctx) => {
-        const projectId = asString(args.projectId, 'projectId')
-        const issueId = asString(args.issueId, 'issueId')
-        const priority = asString(args.priority, 'priority')
-        return await adminPatch(ctx, `/projects/${projectId}/issues/${issueId}`, {
-          priority,
-        })
-      },
-      inputSchema: {
-        properties: {
-          issueId: { type: 'string' },
-          priority: { enum: ['p0', 'p1', 'p2', 'p3'], type: 'string' },
-          projectId: { type: 'string' },
-        },
-        required: ['projectId', 'issueId', 'priority'],
-        type: 'object',
-      },
-      name: 'sentori_issue_set_priority',
-    },
-    {
-      description: 'Replace the label set on an issue. Pass [] to clear all.',
-      handler: async (args, ctx) => {
-        const projectId = asString(args.projectId, 'projectId')
-        const issueId = asString(args.issueId, 'issueId')
-        if (!Array.isArray(args.labels)) throw new Error('labels must be string[]')
-        const labels = args.labels.map((l) => {
-          if (typeof l !== 'string') throw new Error('each label must be a string')
-          return l
-        })
-        return await adminPatch(ctx, `/projects/${projectId}/issues/${issueId}`, {
-          labels,
-        })
-      },
+      name: 'sentori_issue_note',
+      description:
+        'Append a note to an issue — write back what you did ("fixed in abc123, probe SENT-42 planted").',
       inputSchema: {
-        properties: {
-          issueId: { type: 'string' },
-          labels: { items: { type: 'string' }, type: 'array' },
-          projectId: { type: 'string' },
-        },
-        required: ['projectId', 'issueId', 'labels'],
         type: 'object',
+        properties: { issueId: { type: 'string' }, body: { type: 'string' } },
+        required: ['issueId', 'body'],
       },
-      name: 'sentori_issue_set_labels',
+      handler: async (args, ctx) =>
+        apiPost(ctx, `/api/issues/${encodeURIComponent(asString(args.issueId, 'issueId'))}/notes`, {
+          body: asString(args.body, 'body'),
+        }),
     },
     {
+      name: 'sentori_issue_resolve',
       description:
-        'Subscribe (watch=true) or unsubscribe (watch=false) the configured caller to an issue.',
-      handler: async (args, ctx) => {
-        const projectId = asString(args.projectId, 'projectId')
-        const issueId = asString(args.issueId, 'issueId')
-        const watch = args.watch === true
-        if (watch) {
-          return await adminPut(ctx, `/projects/${projectId}/issues/${issueId}/watch`)
-        }
-        return await adminDelete(ctx, `/projects/${projectId}/issues/${issueId}/watch`)
-      },
+        'Resolve an issue, anchored on the release that carries the fix — only a recurrence in that release or newer counts as a regression.',
       inputSchema: {
-        properties: {
-          issueId: { type: 'string' },
-          projectId: { type: 'string' },
-          watch: { type: 'boolean' },
-        },
-        required: ['projectId', 'issueId', 'watch'],
         type: 'object',
+        properties: { issueId: { type: 'string' }, release: { type: 'string' } },
+        required: ['issueId'],
       },
-      name: 'sentori_issue_watch',
+      handler: async (args, ctx) =>
+        apiPost(ctx, `/api/issues/${encodeURIComponent(asString(args.issueId, 'issueId'))}/resolve`, {
+          release: typeof args.release === 'string' ? args.release : undefined,
+        }),
     },
   ]
 }

package/src/native-artifacts.ts

@@ -1,47 +1,46 @@
-// `sentori-cli upload dsym` (iOS) + `sentori-cli upload mapping` (Android).
-// Both endpoints take the raw artifact bytes (NOT multipart) with a few
-// headers / query params.
+// `sentori-cli upload dsym` (iOS) + `sentori-cli upload mapping`
+// (Android). dwarfdump slice discovery stays local; the bytes land
+// on the unified artifacts endpoint (multipart kind + file).
 
 import { spawnSync } from 'node:child_process'
 import { readFile } from 'node:fs/promises'
 import { basename, extname, join } from 'node:path'
 import { statSync, readdirSync } from 'node:fs'
 
+import { gzipForWire, wireArrayBuffer } from './upload.js'
+
 export type AdminUpload = {
   apiUrl: string
-  projectId: string
   release?: string
   token: string
 }
 
-async function postBytes(
-  url: string,
-  body: Buffer,
-  token: string,
-  headers: Record<string, string> = {},
-): Promise<unknown> {
+async function uploadBytes(opts: {
+  apiUrl: string
+  token: string
+  release: string
+  kind: 'dsym' | 'proguard'
+  name: string
+  bytes: Buffer
+}): Promise<void> {
+  // Gzip on the wire — DWARF ~3:1, R8 mapping ~10:1; a real app's
+  // main dSYM only fits the server's transport cap compressed.
+  const { wire, wireName } = gzipForWire(opts.bytes, opts.name)
+  const form = new FormData()
+  form.append('kind', opts.kind)
+  form.append('file', new Blob([wireArrayBuffer(wire)]), wireName)
+  const url = `${opts.apiUrl.replace(/\/+$/, '')}/v1/releases/${encodeURIComponent(opts.release)}/artifacts`
   const resp = await fetch(url, {
-    body,
-    headers: {
-      Authorization: `Bearer ${token}`,
-      'Content-Type': 'application/octet-stream',
-      ...headers,
-    },
+    body: form,
+    headers: { Authorization: `Bearer ${opts.token}` },
     method: 'POST',
   })
   if (!resp.ok) {
-    let detail = ''
-    try {
-      detail = await resp.text()
-    } catch {
-      // ignore
-    }
+    const detail = await resp.text().catch(() => '')
     throw new Error(
       `${resp.status} ${resp.statusText}${detail ? ` — ${detail.slice(0, 300)}` : ''}`,
     )
   }
-  const txt = await resp.text()
-  return txt ? JSON.parse(txt) : null
 }
 
 // ── dSYM ──────────────────────────────────────────────────────────
@@ -135,20 +134,19 @@ export async function uploadDsym(opts: DsymUploadOptions): Promise<DsymUploadRes
     slices.push(...found)
   }
 
-  const base = opts.apiUrl.replace(/\/+$/, '')
-  const q = new URLSearchParams()
-  if (opts.release) q.set('release', opts.release)
-  if (opts.objectName ?? basename(opts.path).replace(/\.dSYM$/, ''))
-    q.set('objectName', opts.objectName ?? basename(opts.path).replace(/\.dSYM$/, ''))
-  const qs = q.toString()
-  const url = `${base}/admin/api/projects/${encodeURIComponent(opts.projectId)}/dsyms${qs ? '?' + qs : ''}`
-
+  const objectName = opts.objectName ?? basename(opts.path).replace(/\.dSYM$/, '')
   const uploaded: { arch: string; debugId: string }[] = []
   for (const s of slices) {
-    const body = await readFile(s.file)
-    await postBytes(url, body, opts.token, {
-      'x-sentori-arch': s.arch,
-      'x-sentori-debug-id': s.debugId,
+    const bytes = await readFile(s.file)
+    // One artifact per slice; the name carries the lookup identity
+    // (object-arch-debugId) until the dwarf wiring lands server-side.
+    await uploadBytes({
+      apiUrl: opts.apiUrl,
+      token: opts.token,
+      release: opts.release ?? '',
+      kind: 'dsym',
+      name: `${objectName}-${s.arch}-${s.debugId}`,
+      bytes,
     })
     uploaded.push({ arch: s.arch, debugId: s.debugId })
   }
@@ -171,12 +169,12 @@ export async function uploadMapping(opts: MappingUploadOptions): Promise<void> {
   const body = await readFile(opts.path)
   if (body.length === 0) throw new Error(`empty mapping file: ${opts.path}`)
 
-  const base = opts.apiUrl.replace(/\/+$/, '')
-  const q = new URLSearchParams()
-  if (opts.release) q.set('release', opts.release)
-  const qs = q.toString()
-  const url = `${base}/admin/api/projects/${encodeURIComponent(opts.projectId)}/mappings${qs ? '?' + qs : ''}`
-  const headers: Record<string, string> = {}
-  if (opts.debugId) headers['x-sentori-debug-id'] = opts.debugId
-  await postBytes(url, body, opts.token, headers)
+  await uploadBytes({
+    apiUrl: opts.apiUrl,
+    token: opts.token,
+    release: opts.release ?? '',
+    kind: 'proguard',
+    name: opts.debugId ? `mapping-${opts.debugId}.txt` : basename(opts.path),
+    bytes: body,
+  })
 }