shraga 0.0.3 → 0.1.2

package/src/server/integrity-audit.ts

@@ -0,0 +1,132 @@
+/**
+ * Data integrity audit — compares current data/ against a git reference.
+ * Detects: missing files, truncated content, degraded JSON arrays/objects, invalid JSON.
+ *
+ * CLI:    bun run src/server/integrity-audit.ts [git-ref] [data-dir]
+ * API:    import { audit } from './integrity-audit.ts'
+ * Remote: run `bun run src/server/integrity-audit.ts` from $APP_DIR on the target host.
+ *
+ * When no ref is given, picks the most recent "auto: sync" commit as baseline.
+ * Exit code 1 if issues found.
+ */
+
+import { execSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import { readdirSync } from 'node:fs';
+
+// Self-contained: resolve DATA_DIR without importing paths.ts so the script works standalone.
+// Guard (mirrors paths.ts): never silently fall back to bare ./data when named env dirs (data-*)
+// exist — that targets a stale, env-less data/ folder. An explicit [data-dir]/DATA_DIR overrides.
+function resolveDataDir(): string {
+  if (process.argv[3]) return process.argv[3];
+  if (process.env.DATA_DIR) return process.env.DATA_DIR;
+  const root = process.cwd();
+  if (readdirSync(root).some((f) => f.startsWith('data-')))
+    throw new Error('DATA_DIR not set but named data dirs exist (data-*). Pass [data-dir] or set DATA_DIR.');
+  return resolve(root, 'data');
+}
+const DATA_DIR = resolveDataDir();
+
+const SIZE_RATIO = 0.5;
+const COUNT_SLACK = 2;
+const STRUCTURAL_JSON = ['schedules.json', 'contacts.json', 'skills-defaults.json', 'api-keys.json'];
+
+function git(cmd: string): string {
+  return execSync(`git -C "${DATA_DIR}" ${cmd}`, { encoding: 'utf-8' }).trim();
+}
+
+function gitShow(ref: string, file: string): string | null {
+  try { return execSync(`git -C "${DATA_DIR}" show ${ref}:${file}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }); }
+  catch { return null; }
+}
+
+function jsonEntryCount(text: string): number | null {
+  try {
+    const v = JSON.parse(text);
+    if (Array.isArray(v)) return v.length;
+    if (v && typeof v === 'object') return Object.keys(v).length;
+    return null;
+  } catch { return null; }
+}
+
+export interface Issue {
+  file: string;
+  kind: 'missing' | 'truncated' | 'degraded' | 'invalid-json';
+  detail: string;
+}
+
+export function audit(ref: string): Issue[] {
+  const issues: Issue[] = [];
+  const lsBlobs = (r: string) => git(`ls-tree -r ${r}`)
+    .split('\n').filter(Boolean)
+    .filter(l => !l.startsWith('160000 '))     // skip submodule gitlinks
+    .map(l => l.split('\t')[1]);
+  const refFiles = lsBlobs(ref);
+  const curSet = new Set(lsBlobs('HEAD'));
+
+  for (const f of refFiles) {
+    if (!curSet.has(f)) {
+      issues.push({ file: f, kind: 'missing', detail: 'in reference but not HEAD' });
+      continue;
+    }
+    const refContent = gitShow(ref, f);
+    const curContent = gitShow('HEAD', f);
+    if (!refContent || !curContent) continue;
+
+    // Size check
+    if (refContent.length > 200 && curContent.length < refContent.length * SIZE_RATIO) {
+      issues.push({ file: f, kind: 'truncated', detail: `${refContent.length}B → ${curContent.length}B (${Math.round(curContent.length / refContent.length * 100)}%)` });
+    }
+
+    // Structural JSON check
+    if (STRUCTURAL_JSON.includes(f)) {
+      const refCount = jsonEntryCount(refContent);
+      const curCount = jsonEntryCount(curContent);
+      if (refCount !== null && curCount !== null && curCount < refCount - COUNT_SLACK) {
+        issues.push({ file: f, kind: 'degraded', detail: `${refCount} → ${curCount} entries` });
+      }
+    }
+  }
+
+  // Invalid JSON check on all current .json files
+  for (const f of curSet) {
+    if (!f.endsWith('.json')) continue;
+    const content = gitShow('HEAD', f);
+    if (!content) continue;
+    try { JSON.parse(content); }
+    catch { issues.push({ file: f, kind: 'invalid-json', detail: 'parse error' }); }
+  }
+
+  return issues;
+}
+
+export function findBaselineRef(): string {
+  try {
+    const log = git('log --oneline -50 --format=%H\\ %s');
+    for (const line of log.split('\n')) {
+      const [hash, ...rest] = line.split(' ');
+      const msg = rest.join(' ');
+      if (msg.startsWith('auto: sync')) return hash;
+    }
+  } catch { /* no git history */ }
+  return 'HEAD~1';
+}
+
+// ── CLI ────────────────────────────────────────────────────────────────────
+
+if (import.meta.main) {
+  const ref = process.argv[2] || findBaselineRef();
+  console.log(`data-audit: HEAD vs ${ref.slice(0, 8)} (${DATA_DIR})\n`);
+
+  const issues = audit(ref);
+  if (!issues.length) {
+    console.log('✓ No issues found');
+    process.exit(0);
+  }
+
+  console.log(`⚠ ${issues.length} issue(s):\n`);
+  for (const { kind, file, detail } of issues) {
+    console.log(`  ${kind.padEnd(12)} ${file} — ${detail}`);
+  }
+  process.exit(1);
+}

package/src/server/mcp-catalog.ts

@@ -0,0 +1,70 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { DATA_DIR } from './paths.ts';
+
+/**
+ * Disk-persisted MCP catalog + failure-cooldown (survives restarts, TTL-stamped).
+ *
+ * Two concerns, one file (`.mcp-catalog.json` in DATA_DIR):
+ *  - `catalog`  — discovered tool specs, keyed by the lib's config hash. Implements the sync
+ *                 get/set `McpCatalogStore` shape an add-on engine's MCP mounter expects, so a cold
+ *                 boot reads specs from disk instead of reconnecting every server.
+ *  - `cooldown` — servers that failed/timed-out to mount, keyed by server name. Persisted so a
+ *                 known-down server (e.g. mcp-mac) isn't re-probed (10s) on the first boot after a
+ *                 restart. Both self-heal via TTL.
+ */
+interface CatalogEntry { specs: any[]; exp: number }
+interface DiskState { catalog: Record<string, CatalogEntry>; cooldown: Record<string, number> }
+
+export class FileMcpCatalog {
+  private file = path.join(DATA_DIR, '.mcp-catalog.json');
+  private catalog = new Map<string, CatalogEntry>();
+  private cooldown = new Map<string, number>();
+
+  constructor(private catalogTtlMs = 24 * 60 * 60_000) {
+    try {
+      if (existsSync(this.file)) {
+        const raw = JSON.parse(readFileSync(this.file, 'utf-8')) as Partial<DiskState>;
+        for (const [k, v] of Object.entries(raw.catalog ?? {})) this.catalog.set(k, v);
+        for (const [k, v] of Object.entries(raw.cooldown ?? {})) this.cooldown.set(k, v);
+      }
+    } catch (e) { console.warn('[mcp-catalog] load failed:', (e as Error).message); }
+  }
+
+  // ── McpCatalogStore (specs) ──────────────────────────────────────────────
+  get(key: string): any[] | null {
+    const e = this.catalog.get(key);
+    if (!e) return null;
+    if (e.exp < Date.now()) { this.catalog.delete(key); return null; }
+    return e.specs;
+  }
+  set(key: string, specs: any[]): void {
+    this.catalog.set(key, { specs, exp: Date.now() + this.catalogTtlMs });
+    this.flush();
+  }
+
+  // ── Failure cooldown (server name → cooldown-until) ──────────────────────
+  /** Currently-cooling server names (expired entries pruned). */
+  cooledServers(): Set<string> {
+    const now = Date.now();
+    const out = new Set<string>();
+    for (const [name, until] of this.cooldown) {
+      if (until > now) out.add(name);
+      else this.cooldown.delete(name);
+    }
+    return out;
+  }
+  cool(name: string, untilMs: number): void { this.cooldown.set(name, untilMs); this.flush(); }
+  clearCool(name: string): void { if (this.cooldown.delete(name)) this.flush(); }
+
+  private flush(): void {
+    try {
+      mkdirSync(DATA_DIR, { recursive: true });
+      const state: DiskState = { catalog: Object.fromEntries(this.catalog), cooldown: Object.fromEntries(this.cooldown) };
+      writeFileSync(this.file, JSON.stringify(state));
+    } catch (e) { console.warn('[mcp-catalog] flush failed:', (e as Error).message); }
+  }
+}
+
+/** Shared singleton — used by an add-on engine's MCP mount path + its boot warm-up. */
+export const fileMcpCatalog = new FileMcpCatalog();

package/src/server/mcp-oauth.ts

@@ -0,0 +1,198 @@
+/**
+ * Embedded OAuth 2.1 Authorization Server for the MCP endpoint (`/mcp`).
+ *
+ * Lets claude.ai (and any MCP client following the MCP Authorization spec) connect to the
+ * remote MCP server via the standard discovery → DCR → authorize → token handshake, instead
+ * of a static `uck_` API key.
+ *
+ * Provider-agnostic by design: the only place a user proves identity is `/oauth/authorize/consent`,
+ * which is guarded by `requireAuth` — the same seam that handles Firebase today and email-password
+ * later. Access/refresh tokens are stateless HMAC tokens (see auth.ts:signMcpToken). No DB:
+ * clients live in a flat JSON file, auth codes in a short-TTL in-memory map.
+ */
+import type { Express, Request, Response, NextFunction } from 'express';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { randomBytes, createHash } from 'node:crypto';
+import { requireAuth, signMcpToken, verifyMcpToken, type AuthUser } from './auth.ts';
+import { dataPath } from './paths.ts';
+
+const ACCESS_TTL = 3600; // 1h
+const REFRESH_TTL = 60 * 60 * 24 * 30; // 30d
+const CODE_TTL_MS = 60_000; // 1min
+
+const CLIENTS_PATH = () => dataPath('oauth-clients.json');
+
+interface OAuthClient {
+  client_id: string;
+  redirect_uris: string[];
+  client_name?: string;
+  created_at: number;
+}
+
+function loadClients(): Record<string, OAuthClient> {
+  const p = CLIENTS_PATH();
+  if (!existsSync(p)) return {};
+  try { return JSON.parse(readFileSync(p, 'utf8')); }
+  catch (e) { console.warn('[mcp-oauth] failed to parse oauth-clients.json:', e); return {}; }
+}
+
+function saveClients(clients: Record<string, OAuthClient>) {
+  writeFileSync(CLIENTS_PATH(), JSON.stringify(clients, null, 2));
+}
+
+interface AuthCode {
+  uid: string;
+  email: string;
+  clientId: string;
+  redirectUri: string;
+  challenge: string;       // PKCE code_challenge (S256)
+  resource?: string;
+  expiresAt: number;
+}
+const codes = new Map<string, AuthCode>();
+
+function pruneCodes() {
+  const now = Date.now();
+  for (const [k, v] of codes) if (v.expiresAt < now) codes.delete(k);
+}
+
+function baseUrl(req: Request): string {
+  const proto = (req.get('x-forwarded-proto') || req.protocol).split(',')[0];
+  return `${proto}://${req.get('host')}`;
+}
+
+function oauthCors(req: Request, res: Response, next: NextFunction) {
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  if (req.method === 'OPTIONS') return void res.sendStatus(204);
+  next();
+}
+
+function pkceVerify(verifier: string, challenge: string): boolean {
+  const computed = createHash('sha256').update(verifier).digest('base64url');
+  return computed === challenge;
+}
+
+export function registerMcpOAuthRoutes(app: Express) {
+  // ── Discovery: Protected Resource Metadata (RFC 9728) ───────────────────────
+  const prm = (req: Request, res: Response) => {
+    const base = baseUrl(req);
+    res.json({
+      resource: `${base}/mcp`,
+      authorization_servers: [base],
+      bearer_methods_supported: ['header'],
+    });
+  };
+  app.get('/.well-known/oauth-protected-resource', oauthCors, prm);
+  app.get('/.well-known/oauth-protected-resource/mcp', oauthCors, prm); // path-suffixed probe
+
+  // ── Discovery: Authorization Server Metadata (RFC 8414) ─────────────────────
+  app.get('/.well-known/oauth-authorization-server', oauthCors, (req: Request, res: Response) => {
+    const base = baseUrl(req);
+    res.json({
+      issuer: base,
+      authorization_endpoint: `${base}/oauth/authorize`,
+      token_endpoint: `${base}/oauth/token`,
+      registration_endpoint: `${base}/oauth/register`,
+      response_types_supported: ['code'],
+      grant_types_supported: ['authorization_code', 'refresh_token'],
+      code_challenge_methods_supported: ['S256'],
+      token_endpoint_auth_methods_supported: ['none'],
+      scopes_supported: ['mcp'],
+    });
+  });
+
+  // ── Dynamic Client Registration (RFC 7591) ──────────────────────────────────
+  app.post('/oauth/register', oauthCors, (req: Request, res: Response) => {
+    const body = (req.body ?? {}) as { redirect_uris?: string[]; client_name?: string };
+    const redirect_uris = Array.isArray(body.redirect_uris) ? body.redirect_uris.filter((u) => typeof u === 'string') : [];
+    if (redirect_uris.length === 0) {
+      return void res.status(400).json({ error: 'invalid_redirect_uri', error_description: 'redirect_uris required' });
+    }
+    const clients = loadClients();
+    const client_id = `mcpc_${randomBytes(16).toString('hex')}`;
+    const client: OAuthClient = { client_id, redirect_uris, client_name: body.client_name, created_at: Date.now() };
+    clients[client_id] = client;
+    saveClients(clients);
+    console.log(`[mcp-oauth] registered client ${client_id} (${body.client_name ?? 'unnamed'})`);
+    res.status(201).json({
+      client_id,
+      redirect_uris,
+      client_name: body.client_name,
+      token_endpoint_auth_method: 'none',
+      grant_types: ['authorization_code', 'refresh_token'],
+      response_types: ['code'],
+      client_id_issued_at: Math.floor(Date.now() / 1000),
+    });
+  });
+
+  // NOTE: GET /oauth/authorize is intentionally NOT handled here — it falls through to the SPA
+  // (index.html), which renders the consent screen and POSTs to /oauth/authorize/consent below.
+
+  // ── Consent → issue authorization code (identity via requireAuth seam) ───────
+  app.post('/oauth/authorize/consent', oauthCors, requireAuth, (req: Request, res: Response) => {
+    const user = (req as any).user as AuthUser;
+    const { client_id, redirect_uri, code_challenge, code_challenge_method, resource } = (req.body ?? {}) as Record<string, string>;
+    if (!client_id || !redirect_uri || !code_challenge) {
+      return void res.status(400).json({ error: 'invalid_request', error_description: 'client_id, redirect_uri, code_challenge required' });
+    }
+    if (code_challenge_method && code_challenge_method !== 'S256') {
+      return void res.status(400).json({ error: 'invalid_request', error_description: 'only S256 PKCE supported' });
+    }
+    const client = loadClients()[client_id];
+    if (!client) return void res.status(400).json({ error: 'invalid_client' });
+    if (!client.redirect_uris.includes(redirect_uri)) {
+      return void res.status(400).json({ error: 'invalid_redirect_uri', error_description: 'redirect_uri not registered for client' });
+    }
+    pruneCodes();
+    const code = randomBytes(32).toString('hex');
+    codes.set(code, {
+      uid: user.uid, email: user.email, clientId: client_id, redirectUri: redirect_uri,
+      challenge: code_challenge, resource, expiresAt: Date.now() + CODE_TTL_MS,
+    });
+    console.log(`[mcp-oauth] issued auth code for ${user.email} → client ${client_id}`);
+    res.json({ code });
+  });
+
+  // ── Token endpoint ──────────────────────────────────────────────────────────
+  app.post('/oauth/token', oauthCors, (req: Request, res: Response) => {
+    const b = (req.body ?? {}) as Record<string, string>;
+    const grant = b.grant_type;
+
+    if (grant === 'authorization_code') {
+      pruneCodes();
+      const entry = b.code ? codes.get(b.code) : undefined;
+      if (!entry) return void res.status(400).json({ error: 'invalid_grant', error_description: 'unknown or expired code' });
+      codes.delete(b.code); // single-use
+      if (entry.redirectUri !== b.redirect_uri) return void res.status(400).json({ error: 'invalid_grant', error_description: 'redirect_uri mismatch' });
+      if (entry.clientId !== b.client_id) return void res.status(400).json({ error: 'invalid_grant', error_description: 'client_id mismatch' });
+      if (!b.code_verifier || !pkceVerify(b.code_verifier, entry.challenge)) {
+        return void res.status(400).json({ error: 'invalid_grant', error_description: 'PKCE verification failed' });
+      }
+      return void res.json({
+        access_token: signMcpToken(entry.uid, entry.email, 'access', ACCESS_TTL),
+        token_type: 'Bearer',
+        expires_in: ACCESS_TTL,
+        refresh_token: signMcpToken(entry.uid, entry.email, 'refresh', REFRESH_TTL),
+        scope: 'mcp',
+      });
+    }
+
+    if (grant === 'refresh_token') {
+      const id = b.refresh_token ? verifyMcpToken(b.refresh_token) : null;
+      if (!id || id.kind !== 'refresh') return void res.status(400).json({ error: 'invalid_grant', error_description: 'invalid refresh_token' });
+      return void res.json({
+        access_token: signMcpToken(id.uid, id.email, 'access', ACCESS_TTL),
+        token_type: 'Bearer',
+        expires_in: ACCESS_TTL,
+        refresh_token: signMcpToken(id.uid, id.email, 'refresh', REFRESH_TTL),
+        scope: 'mcp',
+      });
+    }
+
+    res.status(400).json({ error: 'unsupported_grant_type' });
+  });
+
+  console.log('[mcp-oauth] OAuth routes mounted (.well-known, /oauth/register, /oauth/authorize/consent, /oauth/token)');
+}

package/src/server/mcp-progress.ts

@@ -0,0 +1,45 @@
+import type { McpProgressReporter } from 'edge.libx.js/build/main.js';
+import type { WsEvent } from './claude.ts';
+
+const THROTTLE_MS = 1000;
+
+/**
+ * Map agent stream events to MCP progress via `report` (from captureMcpProgress()).
+ * Throttles to ~1/s; terminal events (done/error) always flush. `report` is a no-op
+ * when the client didn't request progress, so this is always safe to wire up.
+ */
+export function makeProgressEmitter(report: McpProgressReporter): (ev: WsEvent) => void {
+  let lastSentAt = 0;
+  return (ev) => {
+    const message = eventToMessage(ev);
+    if (!message) return;
+    const terminal = ev.type === 'done' || ev.type === 'error';
+    const now = Date.now();
+    if (!terminal && now - lastSentAt < THROTTLE_MS) return;
+    lastSentAt = now;
+    report(message);
+  };
+}
+
+function eventToMessage(ev: WsEvent): string {
+  switch (ev.type) {
+    case 'thinking_delta':
+      return prefixed('💭', ev.text);
+    case 'text_delta':
+      return prefixed('💬', ev.text);
+    case 'tool_use':
+      return `🔧 ${ev.tool}`;
+    case 'done':
+      return '✓ done';
+    case 'error':
+      return prefixed('⚠️', ev.message) || '⚠️ error';
+    default:
+      return '';
+  }
+}
+
+/** First non-empty line of `v`, clipped to 80 chars, with an icon — or '' if blank. */
+function prefixed(icon: string, v: unknown): string {
+  const line = (String(v ?? '').trim().split('\n').find((l) => l.trim()) ?? '').slice(0, 80);
+  return line ? `${icon} ${line}` : '';
+}