@rezti/dsh-rez-suite 0.1.0

package/src/routes.ts

@@ -0,0 +1,191 @@
+/**
+ * /api/dsh-rez-suite route family: config read/update, connectivity test,
+ * live status, and the audit ledger. Loopback-only trust fence plus browser
+ * same-origin markers — these endpoints read/write credentials on the host.
+ */
+
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import type { WebRoute } from '@deepseek-ai/dsh-host-webserver'
+import type { RezConfig, RezMcpServerSpec, RezRoleId } from './protocol.ts'
+import { REZ_API } from './protocol.ts'
+import type { McpHost } from './mcp-host.ts'
+import type { TokenManager } from './token-manager.ts'
+import { publicConfig } from './store.ts'
+
+const MAX_JSON_BODY_BYTES = 256 * 1024
+const SECRET_MASK = '********'
+
+/** Loopback literal check plus browser same-origin markers. */
+function isLoopbackRequest(request: IncomingMessage): boolean {
+  const address = request.socket.remoteAddress
+  if (address !== '127.0.0.1' && address !== '::1' && address !== '::ffff:127.0.0.1') return false
+  const host = request.headers.host
+  if (typeof host !== 'string') return false
+  let hostUrl: URL
+  try {
+    hostUrl = new URL('http://' + host)
+  } catch {
+    return false
+  }
+  if (hostUrl.hostname !== '127.0.0.1' && hostUrl.hostname !== 'localhost' && hostUrl.hostname !== '[::1]') return false
+  if (request.headers['sec-fetch-site'] === 'cross-site') return false
+  const origin = request.headers.origin
+  if (origin === undefined) return true
+  try {
+    return new URL(origin).host === hostUrl.host
+  } catch {
+    return false
+  }
+}
+
+function writeJson(res: ServerResponse, status: number, body: unknown): void {
+  const payload = JSON.stringify(body)
+  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'referrer-policy': 'no-referrer' })
+  res.end(payload)
+}
+
+async function readJsonBody(req: IncomingMessage): Promise<Record<string, unknown> | undefined> {
+  const chunks: Buffer[] = []
+  let size = 0
+  for await (const chunk of req) {
+    const buffer = chunk as Buffer
+    size += buffer.length
+    if (size > MAX_JSON_BODY_BYTES) return undefined
+    chunks.push(buffer)
+  }
+  try {
+    const parsed: unknown = JSON.parse(Buffer.concat(chunks).toString('utf8'))
+    return typeof parsed === 'object' && parsed !== null ? parsed as Record<string, unknown> : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/** Merge record values while keeping masked secrets. */
+function mergeMaskedRecord(base: Record<string, string> | undefined, incoming: unknown): Record<string, string> {
+  const next: Record<string, string> = { ...(base ?? {}) }
+  if (typeof incoming !== 'object' || incoming === null) return next
+  for (const [key, value] of Object.entries(incoming as Record<string, unknown>)) {
+    if (typeof value !== 'string') continue
+    if (value === SECRET_MASK) continue
+    next[key] = value
+  }
+  return next
+}
+
+/** Apply a browser-safe public patch without overwriting masked secrets. */
+function applyPublicPatch(current: RezConfig, patch: Record<string, unknown>): RezConfig {
+  const next: RezConfig = JSON.parse(JSON.stringify(current)) as RezConfig
+  if (typeof patch.enabled === 'boolean') next.enabled = patch.enabled
+  if (patch.role === 'engineer' || patch.role === 'sales' || patch.role === 'operations' || patch.role === 'all') next.role = patch.role as RezRoleId
+
+  if (typeof patch.servers === 'object' && patch.servers !== null) {
+    for (const [id, raw] of Object.entries(patch.servers as Record<string, unknown>)) {
+      if (typeof raw !== 'object' || raw === null) continue
+      const incoming = raw as Record<string, unknown>
+      const existing = next.servers[id] ?? { enabled: false, transport: 'stdio' as const }
+      const merged: RezMcpServerSpec = { ...existing }
+      if (typeof incoming.enabled === 'boolean') merged.enabled = incoming.enabled
+      if (incoming.transport === 'stdio' || incoming.transport === 'streamable-http') merged.transport = incoming.transport
+      if (typeof incoming.command === 'string') merged.command = incoming.command
+      if (Array.isArray(incoming.args)) merged.args = incoming.args.map(String)
+      if (typeof incoming.cwd === 'string') merged.cwd = incoming.cwd
+      if (typeof incoming.url === 'string') merged.url = incoming.url
+      if (typeof incoming.toolCallTimeoutMs === 'number') merged.toolCallTimeoutMs = incoming.toolCallTimeoutMs
+      if (incoming.env !== undefined) merged.env = mergeMaskedRecord(existing.env, incoming.env)
+      if (incoming.headers !== undefined) merged.headers = mergeMaskedRecord(existing.headers, incoming.headers)
+      next.servers[id] = merged
+    }
+  }
+
+  if (typeof patch.billing === 'object' && patch.billing !== null) {
+    const value = patch.billing as Record<string, unknown>
+    if (typeof value.inputCostPer1k === 'number') next.billing.inputCostPer1k = value.inputCostPer1k
+    if (typeof value.outputCostPer1k === 'number') next.billing.outputCostPer1k = value.outputCostPer1k
+    if (typeof value.monthlyBudget === 'number') next.billing.monthlyBudget = value.monthlyBudget
+  }
+  return next
+}
+
+export interface RezRoutesDeps {
+  getConfig: () => RezConfig
+  /** Persist a full/patched config and re-sync the MCP host. */
+  updateConfig: (next: RezConfig) => Promise<RezConfig>
+  host: McpHost
+  tokens: TokenManager
+}
+
+/** Build every /api/dsh-rez-suite route (exact paths). */
+export function makeRoutes(deps: RezRoutesDeps): WebRoute[] {
+  const { getConfig, updateConfig, host, tokens } = deps
+
+  const guard = (req: IncomingMessage, res: ServerResponse, method: string): boolean => {
+    if (!isLoopbackRequest(req)) {
+      writeJson(res, 403, { error: 'forbidden: loopback-only' })
+      return false
+    }
+    if (req.method !== method) {
+      writeJson(res, 405, { error: 'method not allowed: ' + (req.method ?? '') })
+      return false
+    }
+    return true
+  }
+
+  return [
+    {
+      kind: 'exact',
+      path: REZ_API.config,
+      handler: async (req, res) => {
+        if (!guard(req, res, req.method === 'GET' ? 'GET' : 'PUT')) return
+        if (req.method === 'GET') {
+          writeJson(res, 200, { config: publicConfig(getConfig()) })
+          return
+        }
+        const body = await readJsonBody(req)
+        if (body === undefined) {
+          writeJson(res, 400, { error: 'invalid JSON body' })
+          return
+        }
+        const next = applyPublicPatch(getConfig(), body)
+        const saved = await updateConfig(next)
+        writeJson(res, 200, { config: publicConfig(saved) })
+      },
+    },
+    {
+      kind: 'exact',
+      path: REZ_API.test,
+      handler: async (req, res) => {
+        if (!guard(req, res, 'POST')) return
+        const results = await host.test(getConfig())
+        writeJson(res, 200, { results })
+      },
+    },
+    {
+      kind: 'exact',
+      path: REZ_API.status,
+      handler: async (req, res) => {
+        if (!guard(req, res, 'GET')) return
+        const servers = host.status()
+        const totalRegisteredTools = servers.reduce((sum, server) => sum + server.registeredTools, 0)
+        writeJson(res, 200, { role: getConfig().role, servers, totalRegisteredTools })
+      },
+    },
+    {
+      kind: 'exact',
+      path: REZ_API.audit,
+      handler: async (req, res) => {
+        if (!guard(req, res, 'GET')) return
+        writeJson(res, 200, { audit: tokens.summary(getConfig().billing.monthlyBudget) })
+      },
+    },
+    {
+      kind: 'exact',
+      path: REZ_API.auditReset,
+      handler: async (req, res) => {
+        if (!guard(req, res, 'POST')) return
+        tokens.reset()
+        writeJson(res, 200, { ok: true })
+      },
+    },
+  ]
+}

package/src/store.ts

@@ -0,0 +1,152 @@
+/**
+ * Host config store: one JSON file (~/.dsh/dsh-rez-suite.json) holding the
+ * suite configuration. Server env/header values (API keys, passwords) live in
+ * this user-owned file in plaintext — same trust model as dsh-ssh; document
+ * it, never log it.
+ */
+
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import type { RezConfig, RezMcpServerSpec, RezPublicConfig } from './protocol.ts'
+
+/** File format version. */
+const FORMAT_VERSION = 1
+
+/** Config store location: <home>/.dsh/dsh-rez-suite.json. */
+export function rezStorePath(): string {
+  return join(homedir(), '.dsh', 'dsh-rez-suite.json')
+}
+
+/** Audit SQLite location: <home>/.dsh/dsh-rez-suite.sqlite. */
+export function rezDbPath(): string {
+  return join(homedir(), '.dsh', 'dsh-rez-suite.sqlite')
+}
+
+/** Default bundled filesystem root. */
+export function rezFsRoot(): string {
+  return join(homedir(), '.dsh', 'dsh-rez-suite', 'fs')
+}
+
+/** Expand a leading ~ (or empty string) to an absolute path. */
+export function expandHome(path: string): string {
+  if (path === '') return ''
+  if (path === '~') return homedir()
+  if (path.startsWith('~/')) return join(homedir(), path.slice(2))
+  return resolve(path)
+}
+
+/** Defaults: panel-only. Company MCP rows live in cordis.patch.yml. */
+export function defaultConfig(): RezConfig {
+  return {
+    enabled: true,
+    announceToAgent: true,
+    role: 'all',
+    servers: {},
+    billing: {
+      inputCostPer1k: 0.001,
+      outputCostPer1k: 0.002,
+      monthlyBudget: 0,
+    },
+  }
+}
+
+/** Mask every env/header value before it leaves the host. */
+function maskRecord(value: Record<string, string> | undefined): Record<string, string> {
+  const out: Record<string, string> = {}
+  for (const [key, item] of Object.entries(value ?? {})) {
+    out[key] = item === '' ? '' : '********'
+  }
+  return out
+}
+
+function maskServer(server: RezMcpServerSpec): RezMcpServerSpec {
+  return {
+    ...server,
+    env: maskRecord(server.env),
+    headers: maskRecord(server.headers),
+  }
+}
+
+/** Project a full config to a browser-safe shape. */
+export function publicConfig(config: RezConfig): RezPublicConfig {
+  const servers: Record<string, RezMcpServerSpec> = {}
+  for (const [id, server] of Object.entries(config.servers)) {
+    servers[id] = maskServer(server)
+  }
+  return {
+    enabled: config.enabled,
+    role: config.role,
+    servers,
+    billing: { ...config.billing },
+  }
+}
+
+interface StoreFile {
+  version: number
+  config: RezConfig
+}
+
+/** Merge a user-edited store file over the built-in defaults. */
+export function mergeConfig(base: RezConfig, override: unknown): RezConfig {
+  if (typeof override !== 'object' || override === null || Array.isArray(override)) return base
+  const value = override as Record<string, unknown>
+  const result: RezConfig = JSON.parse(JSON.stringify(base)) as RezConfig
+  if (typeof value.enabled === 'boolean') result.enabled = value.enabled
+  if (typeof value.announceToAgent === 'boolean') result.announceToAgent = value.announceToAgent
+  if (value.role === 'engineer' || value.role === 'sales' || value.role === 'operations' || value.role === 'all') result.role = value.role
+
+  if (typeof value.servers === 'object' && value.servers !== null) {
+    for (const [id, raw] of Object.entries(value.servers as Record<string, unknown>)) {
+      if (typeof raw !== 'object' || raw === null) continue
+      const incoming = raw as Record<string, unknown>
+      const existing = result.servers[id] ?? { enabled: false, transport: 'stdio' as const }
+      const merged: RezMcpServerSpec = { ...existing }
+      if (typeof incoming.enabled === 'boolean') merged.enabled = incoming.enabled
+      if (incoming.transport === 'stdio' || incoming.transport === 'streamable-http') merged.transport = incoming.transport
+      if (typeof incoming.command === 'string') merged.command = incoming.command
+      if (Array.isArray(incoming.args)) merged.args = incoming.args.map(String)
+      if (typeof incoming.cwd === 'string') merged.cwd = incoming.cwd
+      if (typeof incoming.url === 'string') merged.url = incoming.url
+      if (typeof incoming.toolCallTimeoutMs === 'number') merged.toolCallTimeoutMs = incoming.toolCallTimeoutMs
+      if (typeof incoming.env === 'object' && incoming.env !== null) {
+        merged.env = { ...(existing.env ?? {}), ...(incoming.env as Record<string, string>) }
+      }
+      if (typeof incoming.headers === 'object' && incoming.headers !== null) {
+        merged.headers = { ...(existing.headers ?? {}), ...(incoming.headers as Record<string, string>) }
+      }
+      result.servers[id] = merged
+    }
+  }
+
+  const billing = value.billing
+  if (typeof billing === 'object' && billing !== null) {
+    result.billing = { ...result.billing, ...(billing as object) }
+  }
+  return result
+}
+
+/** Load the config, or defaults when the file is absent/invalid. */
+export function loadConfig(): RezConfig {
+  const base = defaultConfig()
+  const path = rezStorePath()
+  if (!existsSync(path)) return base
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'))
+    if (typeof parsed !== 'object' || parsed === null) return base
+    const file = parsed as Partial<StoreFile>
+    return mergeConfig(base, file.config)
+  } catch {
+    return base
+  }
+}
+
+/** Atomically persist the config (tmp + rename) with 0600 permissions. */
+export function saveConfig(config: RezConfig): void {
+  const path = rezStorePath()
+  mkdirSync(dirname(path), { recursive: true })
+  const payload: StoreFile = { version: FORMAT_VERSION, config }
+  const tmp = path + '.tmp'
+  writeFileSync(tmp, JSON.stringify(payload, null, 2), { mode: 0o600 })
+  renameSync(tmp, path)
+}

package/src/token-manager.ts

@@ -0,0 +1,252 @@
+/**
+ * Token / audit manager: a SQLite ledger under ~/.dsh/dsh-rez-suite.sqlite.
+ * Token counts are estimates (JSON/text length / 4); cost uses the panel's
+ * per-1k-token rates. The manager never throws into the tool pipeline — a
+ * storage failure logs and continues in memory-only mode.
+ */
+
+import { DatabaseSync } from 'node:sqlite'
+import { mkdirSync } from 'node:fs'
+import { dirname } from 'node:path'
+import type { RezAuditRecord, RezAuditResponse, RezRoleId } from './protocol.ts'
+
+export interface AuditEntry {
+  server: string
+  tool: string
+  role: RezRoleId | string
+  inputTokens: number
+  outputTokens: number
+  cost: number
+  durationMs: number
+  ok: boolean
+  error?: string
+}
+
+/** Rough token estimate: 4 chars ≈ 1 token, with a minimum of 1. */
+export function estimateTokens(value: unknown): number {
+  let text = ''
+  try {
+    text = typeof value === 'string' ? value : JSON.stringify(value) ?? ''
+  } catch {
+    text = String(value)
+  }
+  const length = text.trim().length
+  return length === 0 ? 0 : Math.max(1, Math.ceil(length / 4))
+}
+
+export class TokenManager {
+  private db: DatabaseSync | null = null
+  private memory: RezAuditRecord[] = []
+  private nextId = 1
+  private readonly dbPath: string
+
+  constructor(dbPath: string) {
+    this.dbPath = dbPath
+    try {
+      mkdirSync(dirname(dbPath), { recursive: true })
+      const db = new DatabaseSync(dbPath)
+      db.exec([
+        'CREATE TABLE IF NOT EXISTS usage_log (',
+        '  id INTEGER PRIMARY KEY AUTOINCREMENT,',
+        '  ts INTEGER NOT NULL,',
+        '  server TEXT NOT NULL,',
+        '  tool TEXT NOT NULL,',
+        '  role TEXT NOT NULL,',
+        '  input_tokens INTEGER NOT NULL,',
+        '  output_tokens INTEGER NOT NULL,',
+        '  cost REAL NOT NULL,',
+        '  duration_ms INTEGER NOT NULL,',
+        '  ok INTEGER NOT NULL,',
+        '  error TEXT',
+        ');',
+        'CREATE INDEX IF NOT EXISTS idx_usage_log_ts ON usage_log(ts);',
+      ].join('\n'))
+      this.db = db
+    } catch (error) {
+      console.warn('[dsh-rez-suite] sqlite unavailable, audit falls back to memory:', error)
+    }
+  }
+
+  record(entry: AuditEntry): void {
+    const row: RezAuditRecord = {
+      id: this.nextId++,
+      ts: Date.now(),
+      server: entry.server,
+      tool: entry.tool,
+      role: entry.role,
+      inputTokens: Math.max(0, entry.inputTokens),
+      outputTokens: Math.max(0, entry.outputTokens),
+      cost: Math.max(0, entry.cost),
+      durationMs: Math.max(0, entry.durationMs),
+      ok: entry.ok,
+      error: entry.error,
+    }
+    if (this.db !== null) {
+      try {
+        const statement = this.db.prepare(
+          'INSERT INTO usage_log (ts, server, tool, role, input_tokens, output_tokens, cost, duration_ms, ok, error) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
+        )
+        statement.run(
+          row.ts,
+          row.server,
+          row.tool,
+          row.role,
+          row.inputTokens,
+          row.outputTokens,
+          row.cost,
+          row.durationMs,
+          row.ok ? 1 : 0,
+          row.error ?? null,
+        )
+        row.id = Number(this.lastInsertRowId())
+        return
+      } catch (error) {
+        console.warn('[dsh-rez-suite] audit write failed, using memory:', error)
+      }
+    }
+    this.memory.push(row)
+  }
+
+  private lastInsertRowId(): number | bigint {
+    if (this.db === null) return 0
+    const row = this.db.prepare('SELECT last_insert_rowid() AS id').get() as { id?: number | bigint } | undefined
+    return row?.id ?? 0
+  }
+
+  private rows(): RezAuditRecord[] {
+    if (this.db === null) return [...this.memory]
+    try {
+      const rows = this.db.prepare([
+        'SELECT id, ts, server, tool, role, input_tokens AS inputTokens, output_tokens AS outputTokens,',
+        '       cost, duration_ms AS durationMs, ok, error',
+        'FROM usage_log',
+        'ORDER BY id DESC',
+        'LIMIT 500',
+      ].join('\n')).all() as Array<Record<string, unknown>>
+      return rows.map(row => ({
+        id: Number(row.id),
+        ts: Number(row.ts),
+        server: String(row.server),
+        tool: String(row.tool),
+        role: String(row.role),
+        inputTokens: Number(row.inputTokens),
+        outputTokens: Number(row.outputTokens),
+        cost: Number(row.cost),
+        durationMs: Number(row.durationMs),
+        ok: Boolean(row.ok),
+        error: row.error === null || row.error === undefined ? undefined : String(row.error),
+      }))
+    } catch (error) {
+      console.warn('[dsh-rez-suite] audit read failed:', error)
+      return [...this.memory]
+    }
+  }
+
+  private recent(limit: number): RezAuditRecord[] {
+    if (this.db === null) return this.memory.slice(-limit).reverse()
+    try {
+      const rows = this.db.prepare(
+        'SELECT id, ts, server, tool, role, input_tokens AS inputTokens, output_tokens AS outputTokens, cost, duration_ms AS durationMs, ok, error FROM usage_log ORDER BY id DESC LIMIT ?',
+      ).all(limit) as Array<Record<string, unknown>>
+      return rows.map(row => ({
+        id: Number(row.id),
+        ts: Number(row.ts),
+        server: String(row.server),
+        tool: String(row.tool),
+        role: String(row.role),
+        inputTokens: Number(row.inputTokens),
+        outputTokens: Number(row.outputTokens),
+        cost: Number(row.cost),
+        durationMs: Number(row.durationMs),
+        ok: Boolean(row.ok),
+        error: row.error === null || row.error === undefined ? undefined : String(row.error),
+      }))
+    } catch (error) {
+      console.warn('[dsh-rez-suite] audit recent read failed:', error)
+      return this.memory.slice(-limit).reverse()
+    }
+  }
+
+  summary(monthlyBudget: number): RezAuditResponse {
+    const monthStart = new Date()
+    monthStart.setDate(1)
+    monthStart.setHours(0, 0, 0, 0)
+    const monthStartMs = monthStart.getTime()
+
+    if (this.db !== null) {
+      try {
+        const totals = this.db.prepare(
+          'SELECT COUNT(*) AS calls, COALESCE(SUM(input_tokens),0) AS inputTokens, COALESCE(SUM(output_tokens),0) AS outputTokens, COALESCE(SUM(cost),0) AS cost, COALESCE(SUM(CASE WHEN ts >= ? THEN cost ELSE 0 END),0) AS monthCost FROM usage_log',
+        ).get(monthStartMs) as Record<string, unknown>
+        const serverRows = this.db.prepare(
+          'SELECT server, COUNT(*) AS calls, COALESCE(SUM(input_tokens + output_tokens),0) AS tokens, COALESCE(SUM(cost),0) AS cost FROM usage_log GROUP BY server ORDER BY server',
+        ).all() as Array<Record<string, unknown>>
+        const byServer: Record<string, { calls: number; tokens: number; cost: number }> = {}
+        for (const row of serverRows) {
+          byServer[String(row.server)] = { calls: Number(row.calls), tokens: Number(row.tokens), cost: Number(row.cost) }
+        }
+        return {
+          totalCalls: Number(totals.calls),
+          totalInputTokens: Number(totals.inputTokens),
+          totalOutputTokens: Number(totals.outputTokens),
+          totalCost: Number(totals.cost),
+          monthlyBudget,
+          monthCost: Number(totals.monthCost),
+          byServer,
+          recent: this.recent(50),
+        }
+      } catch (error) {
+        console.warn('[dsh-rez-suite] audit summary read failed, using memory:', error)
+      }
+    }
+
+    const rows = [...this.memory].reverse()
+    let totalCalls = 0
+    let totalInputTokens = 0
+    let totalOutputTokens = 0
+    let totalCost = 0
+    let monthCost = 0
+    const byServer: Record<string, { calls: number; tokens: number; cost: number }> = {}
+    for (const row of rows) {
+      totalCalls += 1
+      totalInputTokens += row.inputTokens
+      totalOutputTokens += row.outputTokens
+      totalCost += row.cost
+      if (row.ts >= monthStartMs) monthCost += row.cost
+      const bucket = byServer[row.server] ?? (byServer[row.server] = { calls: 0, tokens: 0, cost: 0 })
+      bucket.calls += 1
+      bucket.tokens += row.inputTokens + row.outputTokens
+      bucket.cost += row.cost
+    }
+    return {
+      totalCalls,
+      totalInputTokens,
+      totalOutputTokens,
+      totalCost,
+      monthlyBudget,
+      monthCost,
+      byServer,
+      recent: rows.slice(0, 50),
+    }
+  }
+
+  reset(): void {
+    if (this.db !== null) {
+      try {
+        this.db.exec('DELETE FROM usage_log')
+      } catch (error) {
+        console.warn('[dsh-rez-suite] audit reset failed:', error)
+      }
+    }
+    this.memory = []
+  }
+
+  close(): void {
+    try {
+      this.db?.close()
+    } catch {
+      // ignore
+    }
+    this.db = null
+  }
+}