Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

6.0 KB
Raw Blame
#!/usr/bin/env node

/**
 * Auth-independent local-review bridge for unattended claim agents.
 * Reads one JSON request from stdin and writes the service result to stdout.
 */
import { getCodeReviewDefaults, pickAvailableReviewerGroups, reportReviewerFailure, reportReviewerSuccess, runLocalClaimCommentReview, runLocalCodeReview } from '../services/codeReview.js';

import { recordLocalReviewAttribution } from '../lib/localReviewAttribution.js';

import { Console } from 'node:console';
import { isReviewerConfigFault, reviewerModelsFromDefaults, reviewerEffortsFromDefaults } from '../lib/reviewerConfig.js';
import { localReviewBridgeRequest } from '../lib/localReviewBridge.js';
import { stopCodexAppServer } from '../services/codexAppServer.js';

// Provider/runtime diagnostics belong on stderr; stdout is exactly one JSON
// response for the claim procedure's jq gate.
globalThis.console = new Console({ stdout: process.stderr, stderr: process.stderr });

// CLI flag dispatch for explicit agent reporting or active tier queries
const args = process.argv.slice(2);
const flag = args[0];

if (flag === '--active-group' || flag === '--active-tier') {
  try {
    const defaults = await getCodeReviewDefaults().catch(() => null);
    const activeGroup = pickAvailableReviewerGroups(defaults);
    process.stdout.write(`${JSON.stringify({ ok: true, activeGroup })}\n`);
    process.exit(0);
  } catch (err) {
    process.stdout.write(`${JSON.stringify({ ok: false, error: err.message })}\n`);
    process.exit(1);
  }
}

if (flag === '--report-failure') {
  const backend = args[1];
  const reasonIdx = args.indexOf('--reason');
  const reason = reasonIdx >= 0 ? args[reasonIdx + 1] : undefined;
  const errorIdx = args.indexOf('--error');
  const error = errorIdx >= 0 ? args[errorIdx + 1] : undefined;
  try {
    const recorded = await reportReviewerFailure(backend, { reason, error });
    process.stdout.write(`${JSON.stringify({ ok: true, recorded })}\n`);
    process.exit(0);
  } catch (err) {
    process.stdout.write(`${JSON.stringify({ ok: false, error: err.message })}\n`);
    process.exit(1);
  }
}

if (flag === '--report-success') {
  const backend = args[1];
  try {
    const recorded = await reportReviewerSuccess(backend);
    process.stdout.write(`${JSON.stringify({ ok: true, recorded })}\n`);
    process.exit(0);
  } catch (err) {
    process.stdout.write(`${JSON.stringify({ ok: false, error: err.message })}\n`);
    process.exit(1);
  }
}

const chunks = [];
for await (const chunk of process.stdin) chunks.push(chunk);

try {
  const request = JSON.parse(Buffer.concat(chunks).toString('utf8'));

  if (request.action === 'active-group' || request.action === 'active-tier') {
    const defaults = await getCodeReviewDefaults().catch(() => null);
    const activeGroup = pickAvailableReviewerGroups(defaults);
    process.stdout.write(`${JSON.stringify({ ok: true, activeGroup })}\n`);
    process.exit(0);
  }

  if (request.action === 'report-failure' || request.reportFailure) {
    const backend = request.backend || request.reviewer;
    const recorded = await reportReviewerFailure(backend, {
      reason: request.reason,
      error: request.error || request.message,
    });
    process.stdout.write(`${JSON.stringify({ ok: true, recorded })}\n`);
    process.exit(0);
  }

  if (request.action === 'report-success' || request.reportSuccess) {
    const backend = request.backend || request.reviewer;
    const recorded = await reportReviewerSuccess(backend);
    process.stdout.write(`${JSON.stringify({ ok: true, recorded })}\n`);
    process.exit(0);
  }
  // Resolved follow-up pins already include defaults. An explicit task clear
  // must not re-inherit the global pins when it reaches this bridge.
  const defaults = request.inheritDefaults === false ? null : await getCodeReviewDefaults().catch(() => null);
  const model = request.model || reviewerModelsFromDefaults(defaults)[request.backend] || null;
  const effort = request.effort || reviewerEffortsFromDefaults(defaults)[request.backend] || null;
  const review = request.kind === 'claim-comments'
    ? runLocalClaimCommentReview
    : runLocalCodeReview;
  const result = await review({ ...localReviewBridgeRequest(request, process.cwd()), model, effort });
  const recordOutcome = result.ok
    ? reportReviewerSuccess(request.backend)
    : reportReviewerFailure(request.backend, result);
  await recordOutcome.catch((err) => {
    process.stderr.write(`Unable to persist reviewer health: ${err.message}\n`);
  });
  // Attribution is publication bookkeeping, not a reviewer verdict or health
  // failure. Retain the completed result so a receipt can be repaired without
  // spending another provider call.
  const attributionError = request.recordAttribution === true && request.kind !== 'claim-comments'
    ? await recordLocalReviewAttribution(process.cwd(), result).then(() => null, () => 'REVIEW_ATTRIBUTION_FAILED')
    : null;
  process.stdout.write(`${JSON.stringify(attributionError ? { ...result, attributionError } : result)}\n`);
  if (attributionError) {
    process.stderr.write('Review completed, but model attribution could not be persisted. Publication is blocked until attribution is repaired; do not rerun the reviewer.\n');
    process.exitCode = 1;
  }
  if (!result.ok) {
    // A reviewer that CAN'T be satisfied reads identically to one that merely
    // timed out, and the claim procedure answers both with `review-blocked` —
    // leaving the PR open to wait out an outage that will never end (#7660). Say
    // which it is, naming the reviewer, so the operator sees a config fault.
    process.stderr.write(isReviewerConfigFault(result.code)
      ? `Reviewer configuration fault (${result.code}) for ${request.backend}: ${result.error}\n`
      : `${result.error}\n`);
    process.exitCode = 1;
  }
} catch (err) {
  process.stdout.write(`${JSON.stringify({ ok: false, error: err.message })}\n`);
  process.stderr.write(`${err.message}\n`);
  process.exitCode = 1;
} finally {
  await stopCodexAppServer().catch((err) => {
    process.stderr.write(`Unable to stop Codex app-server: ${err.message}\n`);
  });
}