elanous 0.2.11 → 0.2.13

package/src/hooks/consult-intake.ts

@@ -0,0 +1,153 @@
+import { randomUUID } from 'node:crypto';
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+export const CONSULT_MAX_BYTES = 8 * 1024;
+export const CONSULT_QUEUE_MAX_AGE_MS = 7 * 24 * 3600_000;
+
+export interface ConsultInput {
+  name: string;
+  org?: string;
+  kind: 'company' | 'personal';
+  interest: 'A' | 'B';
+  contact: string;
+  consent: true;
+}
+
+export interface QueuedConsult { id: string; receivedAt: string; consult: ConsultInput }
+
+const singleLine = (value: string): string => value.trim().replace(/[\r\n\u2028\u2029]+/g, ' ');
+
+/** The Primary accepts optional org and requires nonblank name/contact, kind, interest and explicit consent. */
+export function validateConsult(body: unknown): { ok: true; consult: ConsultInput } | { ok: false; field: string } {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return { ok: false, field: 'body' };
+  const b = body as Record<string, unknown>;
+  if (typeof b.name !== 'string' || !b.name.trim() || b.name.length > 256) return { ok: false, field: 'name' };
+  if (b.org !== undefined && (typeof b.org !== 'string' || !b.org.trim() || b.org.length > 256)) return { ok: false, field: 'org' };
+  if (b.kind !== 'company' && b.kind !== 'personal') return { ok: false, field: 'kind' };
+  if (b.interest !== 'A' && b.interest !== 'B') return { ok: false, field: 'interest' };
+  if (typeof b.contact !== 'string' || !b.contact.trim() || b.contact.length > 512) return { ok: false, field: 'contact' };
+  if (b.consent !== true) return { ok: false, field: 'consent' };
+  return { ok: true, consult: { name: singleLine(b.name), ...(typeof b.org === 'string' ? { org: singleLine(b.org) } : {}),
+    kind: b.kind, interest: b.interest, contact: b.contact.trim(), consent: true } };
+}
+
+/** Sliding windows; neither rejected hits nor invalid submissions consume quota. */
+export class ConsultLimiter {
+  private readonly ips = new Map<string, number[]>();
+  private daily: number[] = [];
+  constructor(private readonly now: () => number = Date.now) {}
+
+  admit(ip: string): number | null {
+    const t = this.now();
+    const hits = (this.ips.get(ip) ?? []).filter(x => t - x < 600_000);
+    this.daily = this.daily.filter(x => t - x < 86_400_000);
+    const wait = hits.length >= 3 ? 600_000 - (t - hits[0]!) :
+      this.daily.length >= 200 ? 86_400_000 - (t - this.daily[0]!) : null;
+    if (wait !== null) { this.ips.set(ip, hits); return Math.max(1, Math.ceil(wait / 1000)); }
+    hits.push(t);
+    this.ips.set(ip, hits);
+    this.daily.push(t);
+    return null;
+  }
+}
+
+/** Atomic JSONL rewrite on every mutation, with a private file and directory. */
+export class ConsultQueue {
+  readonly path: string;
+  constructor(root: string, private readonly log: (event: string, data: Record<string, unknown>) => void = () => {}) {
+    this.path = join(root, 'hooks', 'consult-queue.jsonl');
+    mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 });
+  }
+
+  private read(): QueuedConsult[] {
+    try { return readFileSync(this.path, 'utf8').split('\n').filter(Boolean).map(line => JSON.parse(line) as QueuedConsult); }
+    catch (error) { if ((error as NodeJS.ErrnoException).code === 'ENOENT') return []; throw error; }
+  }
+
+  private write(items: QueuedConsult[]): void {
+    const temp = `${this.path}.${randomUUID()}.tmp`;
+    try {
+      const fd = openSync(temp, 'wx', 0o600);
+      try { writeSync(fd, items.map(item => JSON.stringify(item)).join('\n') + (items.length ? '\n' : '')); fsyncSync(fd); }
+      finally { closeSync(fd); }
+      renameSync(temp, this.path);
+    } finally { rmSync(temp, { force: true }); }
+  }
+
+  enqueue(item: QueuedConsult): void { this.write([...this.read(), item]); }
+  entries(now: number = Date.now()): QueuedConsult[] {
+    const items = this.read();
+    const kept = items.filter(item => Number.isFinite(Date.parse(item.receivedAt)) && now - Date.parse(item.receivedAt) <= CONSULT_QUEUE_MAX_AGE_MS);
+    if (kept.length !== items.length) { this.write(kept); this.log('dropped', { expired: items.length - kept.length }); }
+    return kept;
+  }
+  count(): number { return existsSync(this.path) ? this.read().length : 0; }
+  delivered(id: string): void { this.write(this.read().filter(item => item.id !== id)); }
+}
+
+/** Accept only a validated body; responses and logs never contain user-provided values. */
+export async function handleConsultPost(request: Request, deps: {
+  limiter: ConsultLimiter; queue: ConsultQueue; now?: () => number; ip?: string;
+  log?: (event: string, data: Record<string, unknown>) => void; wake?: () => void;
+}): Promise<Response> {
+  const log = deps.log ?? (() => {});
+  const declared = Number(request.headers.get('content-length') ?? '0');
+  if (declared > CONSULT_MAX_BYTES) { log('rejected', { reason: 'too-large' }); return Response.json({ error: 'too-large' }, { status: 413 }); }
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  const reader = request.body?.getReader();
+  try {
+    if (reader) {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        size += value.byteLength;
+        if (size > CONSULT_MAX_BYTES) {
+          await reader.cancel().catch(() => {});
+          log('rejected', { reason: 'too-large' });
+          return Response.json({ error: 'too-large' }, { status: 413 });
+        }
+        chunks.push(value);
+      }
+    }
+  } catch {
+    log('rejected', { reason: 'body' });
+    return Response.json({ error: 'invalid', field: 'body' }, { status: 400 });
+  } finally { reader?.releaseLock(); }
+  let body: unknown;
+  try {
+    const raw = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) { raw.set(chunk, offset); offset += chunk.byteLength; }
+    body = JSON.parse(new TextDecoder().decode(raw));
+  }
+  catch { log('rejected', { reason: 'body' }); return Response.json({ error: 'invalid', field: 'body' }, { status: 400 }); }
+  const checked = validateConsult(body);
+  if (!checked.ok) { log('rejected', { reason: checked.field }); return Response.json({ error: 'invalid', field: checked.field }, { status: 400 }); }
+  const ip = deps.ip ?? 'unknown';
+  const wait = deps.limiter.admit(ip);
+  if (wait !== null) {
+    log('rejected', { reason: 'rate-limited' });
+    return Response.json({ error: 'rate-limited', retryAfterSec: wait }, { status: 429, headers: { 'Retry-After': String(wait) } });
+  }
+  const id = randomUUID();
+  try { deps.queue.enqueue({ id, receivedAt: new Date((deps.now ?? Date.now)()).toISOString(), consult: checked.consult }); }
+  catch { log('rejected', { reason: 'queue-unavailable' }); return Response.json({ error: 'queue-unavailable' }, { status: 503 }); }
+  log('received', { queued: true, kind: checked.consult.kind, interest: checked.consult.interest,
+    nameLength: checked.consult.name.length, contactLength: checked.consult.contact.length, orgLength: checked.consult.org?.length ?? 0 });
+  deps.wake?.();
+  return Response.json({ id }, { status: 202 });
+}
+
+/** Forward in arrival order; a failure leaves that item and all following items queued. */
+export async function drainConsults(queue: ConsultQueue, forward: (item: QueuedConsult) => Promise<boolean>, now: number = Date.now()): Promise<{ delivered: number; failed: number }> {
+  let delivered = 0;
+  let failed = 0;
+  for (const item of queue.entries(now)) {
+    let ok = false;
+    try { ok = await forward(item); } catch { ok = false; }
+    if (ok) { queue.delivered(item.id); delivered++; } else { failed++; break; }
+  }
+  return { delivered, failed };
+}

package/src/hooks/github-shadow.ts

@@ -1,5 +1,9 @@
 import { createHash } from 'node:crypto';
-import { join } from 'node:path';
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, mkdtempSync, rmSync, symlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { debug } from '../debug/log.js';
 import { openMsgStore } from '../msg/msg-store.js';
 import { CardStore, redactSecrets } from '../task-cards/card-store.js';
 import { isGithubSpamText, PUBLIC_GITHUB_REPO } from './providers.js';
@@ -72,8 +76,57 @@ function object(value: unknown): Record<string, unknown> | undefined {
 }
 function gitSha(value: unknown): value is string { return typeof value === 'string' && /^[0-9a-f]{40}$/i.test(value); }
 
+export interface ShadowReviewResult {
+  reviewed: boolean;
+  verdict: 'pass' | 'warn' | 'fail' | null;
+  summary: string;
+}
+
+/** Runs the read-only self-review command from a detached, disposable worktree of trusted HEAD.
+ * The PR is never checked out: only its remote diff enters the reviewer prompt. */
+export async function runGithubShadowReview(number: number, repo = resolve(process.cwd())): Promise<ShadowReviewResult> {
+  if (!Number.isSafeInteger(number) || number < 1) throw new Error('invalid PR number');
+  const dir = mkdtempSync(join(tmpdir(), 'elanous-review-shadow-'));
+  const worktree = join(dir, 'repo');
+  let attached = false;
+  try {
+    const added = spawnSync('git', ['-C', repo, 'worktree', 'add', '--detach', worktree, 'HEAD'], { encoding: 'utf8', timeout: 30_000 });
+    if (added.status !== 0) throw new Error('isolated worktree unavailable');
+    attached = true;
+    if (existsSync(join(repo, 'node_modules'))) symlinkSync(join(repo, 'node_modules'), join(worktree, 'node_modules'), 'dir');
+    const output = await new Promise<string>((done, fail) => {
+      const child = spawn(process.execPath, [join(worktree, 'bin/elanous.mjs'), '--test', 'self', 'review', String(number), '--json'], {
+        cwd: worktree, env: { ...process.env, GH_REPO: PUBLIC_GITHUB_REPO }, stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      let stdout = '';
+      let stderr = '';
+      const timer = setTimeout(() => child.kill(), 360_000);
+      child.stdout.on('data', (chunk: Buffer) => { stdout += chunk.toString(); if (stdout.length > 100_000) child.kill(); });
+      child.stderr.on('data', (chunk: Buffer) => { stderr += chunk.toString(); if (stderr.length > 100_000) child.kill(); });
+      child.on('error', error => { clearTimeout(timer); fail(error); });
+      child.on('close', code => { clearTimeout(timer); code === 0 ? done(stdout) : fail(new Error(`self review exited ${code}: ${stderr.slice(0, 200)}`)); });
+    });
+    const parsed: unknown = JSON.parse(output);
+    const result = object(parsed);
+    if (!result) throw new Error('self review returned no result');
+    const verdict = result.reviewed === true && ['pass', 'warn', 'fail'].includes(String(result.verdict))
+      ? result.verdict as 'pass' | 'warn' | 'fail' : null;
+    const findings = [...(Array.isArray(result.mustFix) ? result.mustFix : []), ...(Array.isArray(result.shouldFix) ? result.shouldFix : [])]
+      .filter((item): item is string => typeof item === 'string').slice(0, 8);
+    return { reviewed: result.reviewed === true && verdict !== null, verdict,
+      summary: redactSecrets(verdict ? `${verdict}: ${findings.join('; ') || 'no findings'}` : `review unavailable: ${String(result.error ?? 'not reviewed')}`).slice(0, 2000) };
+  } finally {
+    if (attached) {
+      rmSync(join(worktree, 'node_modules'), { force: true });
+      spawnSync('git', ['-C', repo, 'worktree', 'remove', '--force', worktree], { timeout: 30_000 });
+    }
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
 /** Separate shadow ledger/card path: never enter dispatchHook's seat wake or steward launch/report stages. */
-export async function recordGithubShadow(event: QueuedHook, root: string, fetchFn: typeof fetch = fetch): Promise<void> {
+export async function recordGithubShadow(event: QueuedHook, root: string, fetchFn: typeof fetch = fetch,
+  review: (number: number) => Promise<ShadowReviewResult> = runGithubShadowReview): Promise<void> {
   const github = event.task.github;
   if (event.provider !== 'github' || !github || github.repository !== PUBLIC_GITHUB_REPO ||
       !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(event.eventId) ||
@@ -94,6 +147,7 @@ export async function recordGithubShadow(event: QueuedHook, root: string, fetchF
       .run(key, github.repository, github.type, github.number, judgment.verdict, judgment.reason, event.task.external.url ?? '');
     const recorded = store.db.query('SELECT verdict, reason FROM github_shadow_judgments WHERE event_key = ?')
       .get(key) as ShadowJudgment;
+    debug.log('steward.intake', 'judged', { eventKey: key, number: github.number, type: github.type, verdict: recorded.verdict, reason: recorded.reason });
     const cards = new CardStore(root);
     try {
       const goalId = `github:${github.repository}:${github.type}:${github.number}`;
@@ -104,5 +158,21 @@ export async function recordGithubShadow(event: QueuedHook, root: string, fetchF
       if (!card.sections.some(section => section.key === sectionKey))
         cards.appendSection(card.id, { key: sectionKey, owner: 'steward', content: redactSecrets(content) });
     } finally { cards.close(); }
+    if (github.type === 'pull_request' && recorded.verdict === 'accepted') {
+      store.db.exec(`CREATE TABLE IF NOT EXISTS github_shadow_reviews (
+        event_key TEXT PRIMARY KEY, repository TEXT NOT NULL, item_number INTEGER NOT NULL,
+        reviewed INTEGER NOT NULL, verdict TEXT, summary TEXT NOT NULL
+      )`);
+      if (!store.db.query('SELECT event_key FROM github_shadow_reviews WHERE event_key = ?').get(key)) {
+        let result: ShadowReviewResult;
+        try { result = await review(github.number); }
+        catch (error) { result = { reviewed: false, verdict: null, summary: `review unavailable: ${error instanceof Error ? error.message : String(error)}` }; }
+        store.db.query(`INSERT OR IGNORE INTO github_shadow_reviews
+          (event_key, repository, item_number, reviewed, verdict, summary) VALUES (?, ?, ?, ?, ?, ?)`)
+          .run(key, github.repository, github.number, result.reviewed ? 1 : 0, result.verdict,
+            redactSecrets(result.summary).slice(0, 2000));
+        debug.log('steward.review-shadow', 'recorded', { eventKey: key, number: github.number, reviewed: result.reviewed, verdict: result.verdict });
+      }
+    }
   } finally { store.close(); }
 }

package/src/hooks/receiver.ts

@@ -4,9 +4,10 @@ import { getUserConfig, parseEventsConfig, userConfigPath, type EventsConfig } f
 import { dispatchHook, type HookWake } from './dispatch.js';
 import { getSecretAsync } from '../nexus/config/secrets/index.js';
 import { HookQueue, type QueuedHook } from './queue.js';
-import { recordGithubShadow } from './github-shadow.js';
+import { recordGithubShadow, type ShadowReviewResult } from './github-shadow.js';
 import { toExternalTask, verifyWebhook, type HookProvider } from './providers.js';
 import { drainReports, handleReportPost, ReportLimiter, ReportQueue, type ReceivedReport } from './error-report.js';
+import { ConsultLimiter, ConsultQueue, drainConsults, handleConsultPost, type QueuedConsult } from './consult-intake.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 
 export interface HookSecrets {
@@ -27,8 +28,15 @@ export interface HookReceiverOptions {
   wakeSeat?: HookWake;
   /** ER2 — forward one queued error report to the Primary; default = POST /v1/reports/ingest over the tailnet. */
   forwardReport?: (item: ReceivedReport) => Promise<boolean>;
+  /** CS1 — forward a queued consultation to the Primary's consult ledger. */
+  forwardConsult?: (item: QueuedConsult) => Promise<boolean>;
+  /** CS1 — the public consult route is a write path from the open internet, so it stays closed (404) until
+   *  `hooks.consult.enabled === true` in user config (대표 decision D-20261003-09). Tests pass it directly. */
+  consultEnabled?: boolean;
   /** GET-only public metadata lookup; failure forces human review. */
   githubFetch?: typeof fetch;
+  /** Test seam for the isolated read-only self review; never publishes externally. */
+  githubShadowReview?: (number: number) => Promise<ShadowReviewResult>;
 }
 
 /** `/v1/tasks` lives on the Primary's nexus API, not on the control plane — so the address is its own setting. */
@@ -53,11 +61,66 @@ async function forwardReportToPrimary(item: ReceivedReport): Promise<boolean> {
   return response.ok;
 }
 
+async function forwardConsultToPrimary(item: QueuedConsult): Promise<boolean> {
+  const config = JSON.parse(readFileSync(userConfigPath(), 'utf8')) as { hooks?: { primaryTokenRef?: string; primaryUrl?: unknown } };
+  const ref = config.hooks?.primaryTokenRef;
+  if (!ref) throw new Error('primary token reference missing');
+  const token = await getSecretAsync(ref);
+  if (!token) throw new Error('primary token missing');
+  const response = await fetch(new URL('/v1/consult-requests', hooksPrimaryUrl(config)), {
+    method: 'POST', headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },
+    body: JSON.stringify(item.consult), signal: AbortSignal.timeout(10_000),
+  });
+  return response.ok;
+}
+
+/** Raw read like the report forwarder: only an explicit `hooks.consult.enabled: true` opens the route. */
+function consultRouteEnabled(): boolean {
+  try {
+    const config = JSON.parse(readFileSync(userConfigPath(), 'utf8')) as { hooks?: { consult?: { enabled?: unknown } } };
+    return config.hooks?.consult?.enabled === true;
+  } catch {
+    return false;
+  }
+}
+
+function consultOrigin(origin: string | null): string | null {
+  if (!origin) return null;
+  try {
+    const url = new URL(origin);
+    if (url.protocol !== 'https:' || url.origin !== origin) return null;
+    return url.hostname === 'elanous.ai' || url.hostname === 'www.elanous.ai' ||
+      /^[a-z0-9-]+\.vercel\.app$/i.test(url.hostname) ? origin : null;
+  } catch { return null; }
+}
+
 export function startHookReceiver(options: HookReceiverOptions): { url: string; stop: () => void; queue: HookQueue } {
   const queue = new HookQueue(options.root);
   const reportQueue = new ReportQueue(options.root ?? effectiveInstanceRoot(), (event, data) => debug.log('hooks.reports', event, data));
   const reportLimiter = new ReportLimiter(options.now ?? Date.now);
   const forwardReport = options.forwardReport ?? forwardReportToPrimary;
+  const consultEnabled = options.consultEnabled ?? consultRouteEnabled();
+  debug.log('hooks.consult', consultEnabled ? 'route-open' : 'route-closed', {});
+  const consultQueue = new ConsultQueue(options.root ?? effectiveInstanceRoot(), (_event, data) =>
+    debug.log('hooks.consult', 'rejected', { reason: 'expired', ...data }));
+  const consultLimiter = new ConsultLimiter(options.now ?? Date.now);
+  const forwardConsult = options.forwardConsult ?? forwardConsultToPrimary;
+  let consultFailures = 0;
+  let consultNextAt = 0;
+  let consultsDraining = false;
+  async function drainConsultQueue(): Promise<void> {
+    if (stopped || consultsDraining || Date.now() < consultNextAt) return;
+    consultsDraining = true;
+    try {
+      const result = await drainConsults(consultQueue, forwardConsult, (options.now ?? Date.now)());
+      if (result.delivered) debug.log('hooks.consult', 'forwarded', { queued: consultQueue.count(), delivered: result.delivered });
+      if (result.failed) {
+        consultFailures++;
+        consultNextAt = Date.now() + Math.min(300_000, Math.max(1, options.retryBaseMs ?? 1000) * 2 ** Math.min(consultFailures - 1, 20));
+        debug.log('hooks.consult', 'forward-failed', { queued: consultQueue.count(), reason: 'delivery-failed' });
+      } else consultFailures = 0;
+    } finally { consultsDraining = false; }
+  }
   let reportFailures = 0;
   let reportNextAt = 0;
   let reportsDraining = false;
@@ -79,7 +142,7 @@ export function startHookReceiver(options: HookReceiverOptions): { url: string;
   // L14: public-repository intake events take the shadow ledger path; every other event keeps the seat dispatch path.
   const dispatch = options.forward ?? ((event: QueuedHook) => dispatchHook(event, options.root ?? effectiveInstanceRoot(), events, options.wakeSeat).then(() => 204));
   const forward = (event: QueuedHook) => event.provider === 'github' && event.task.github
-    ? recordGithubShadow(event, options.root ?? effectiveInstanceRoot(), options.githubFetch).then(() => 204)
+    ? recordGithubShadow(event, options.root ?? effectiveInstanceRoot(), options.githubFetch, options.githubShadowReview).then(() => 204)
     : dispatch(event);
   const attempts = new Map<string, { next: number; failures: number }>();
   const pending = new Set<string>();
@@ -111,18 +174,34 @@ export function startHookReceiver(options: HookReceiverOptions): { url: string;
       }
     } finally {
       void drainReportQueue();
+      void drainConsultQueue();
       draining = false;
       if (!stopped) timer = setTimeout(() => { void drain(); }, Math.min(1000, options.retryBaseMs ?? 1000));
     }
   }
   const server = Bun.serve({ hostname: options.host ?? '127.0.0.1', port: options.port,
-    async fetch(request) {
+    async fetch(request, server) {
       const url = new URL(request.url);
       if (request.method === 'GET' && url.pathname === '/hooks/health')
         return Response.json({ ok: true, queued: queue.count(), reportsQueued: reportQueue.count() });
       if (request.method === 'POST' && url.pathname === '/v1/reports')
         return handleReportPost(request, { limiter: reportLimiter, queue: reportQueue, ...(options.now ? { now: options.now } : {}),
           log: (event, data) => debug.log('hooks.reports', event, data), wake: () => { reportNextAt = 0; void drainReportQueue(); } });
+      if (consultEnabled && url.pathname === '/v1/consult' && (request.method === 'POST' || request.method === 'OPTIONS')) {
+        const origin = consultOrigin(request.headers.get('origin'));
+        if (!origin) {
+          debug.log('hooks.consult', 'rejected', { reason: 'origin' });
+          return Response.json({ error: 'forbidden' }, { status: 403 });
+        }
+        const headers = { 'Access-Control-Allow-Origin': origin, Vary: 'Origin',
+          'Access-Control-Allow-Methods': 'POST, OPTIONS', 'Access-Control-Allow-Headers': 'Content-Type' };
+        if (request.method === 'OPTIONS') return new Response(null, { status: 204, headers });
+        const response = await handleConsultPost(request, { limiter: consultLimiter, queue: consultQueue, ...(options.now ? { now: options.now } : {}),
+          ip: server.requestIP(request)?.address ?? 'unknown',
+          log: (event, data) => debug.log('hooks.consult', event, data), wake: () => { consultNextAt = 0; void drainConsultQueue(); } });
+        for (const [key, value] of Object.entries(headers)) response.headers.set(key, value);
+        return response;
+      }
       if (request.method !== 'POST' || !/^\/hooks\/(linear|asana|github)$/.test(url.pathname)) return new Response('Not Found', { status: 404 });
       const provider = url.pathname.slice('/hooks/'.length) as HookProvider;
       const reject = (reason: string) => {