agentic-orchestrator 0.1.25 → 0.1.26

package/packages/web-dashboard/src/lib/aop-client.ts

@@ -3,6 +3,8 @@ import path from 'node:path';
 import YAML from 'yaml';
 import { getProjectByName, readMultiProjectConfig } from '@/lib/multi-project-config.js';
 import type {
+  AgentPipelineStatus,
+  CostSummary,
   DashboardStatusPayload,
   EvidenceArtifact,
   FeatureDetail,
@@ -10,6 +12,12 @@ import type {
   FeatureLogEntry,
   FeaturesIndex,
   FeatureSummary,
+  GateRunEvidence,
+  LockLease,
+  QaTestIndex,
+  ReviewBrief,
+  RoleStatus,
+  RuntimeSession,
 } from '@/lib/types.js';
 
 const AOP_ROOT = process.env.AOP_ROOT ?? process.cwd();
@@ -48,18 +56,39 @@ function isActivityState(value: unknown): value is NonNullable<FeatureSummary['a
   );
 }
 
-function parseRoleStatus(frontMatter: Record<string, unknown>): Record<string, string> | null {
+function normalizeRoleStatus(value: unknown): RoleStatus {
+  if (typeof value !== 'string') {
+    return 'unknown';
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === 'running' || normalized === 'in_progress' || normalized === 'active') {
+    return 'running';
+  }
+  if (normalized === 'blocked' || normalized === 'waiting') {
+    return 'blocked';
+  }
+  if (normalized === 'done' || normalized === 'complete' || normalized === 'completed') {
+    return 'done';
+  }
+  if (normalized === 'ready' || normalized === 'pending' || normalized === 'queued') {
+    return 'ready';
+  }
+  return 'unknown';
+}
+
+function parseRoleStatus(frontMatter: Record<string, unknown>): AgentPipelineStatus | null {
   const raw = frontMatter.role_status;
   if (!raw || typeof raw !== 'object') {
     return null;
   }
-  const entries = Object.entries(raw as Record<string, unknown>).filter(
-    (entry): entry is [string, string] => typeof entry[1] === 'string',
-  );
-  if (entries.length === 0) {
+  const record = raw as Record<string, unknown>;
+  const planner = normalizeRoleStatus(record.planner);
+  const builder = normalizeRoleStatus(record.builder);
+  const qa = normalizeRoleStatus(record.qa);
+  if (planner === 'unknown' && builder === 'unknown' && qa === 'unknown') {
     return null;
   }
-  return Object.fromEntries(entries);
+  return { planner, builder, qa };
 }
 
 function firstValidTimestamp(frontMatter: Record<string, unknown>): number | null {
@@ -133,6 +162,99 @@ function parseFrontMatter(raw: string): ParsedFrontMatter {
   return { frontMatter, body: normalized.slice(match[0].length) };
 }
 
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object' ? (value as Record<string, unknown>) : null;
+}
+
+async function readJsonFile<T>(filePath: string): Promise<T | null> {
+  try {
+    const raw = await readFile(filePath, 'utf-8');
+    return JSON.parse(raw) as T;
+  } catch {
+    return null;
+  }
+}
+
+function normalizeRuntimeSession(value: unknown): RuntimeSession | undefined {
+  const record = asRecord(value);
+  if (!record) {
+    return undefined;
+  }
+  return {
+    run_id: typeof record.run_id === 'string' ? record.run_id : undefined,
+    owner_instance_id:
+      typeof record.owner_instance_id === 'string' ? record.owner_instance_id : undefined,
+    provider: typeof record.provider === 'string' ? record.provider : null,
+    model: typeof record.model === 'string' ? record.model : null,
+    started_at: typeof record.started_at === 'string' ? record.started_at : null,
+    last_heartbeat_at:
+      typeof record.last_heartbeat_at === 'string' ? record.last_heartbeat_at : null,
+    lease_expires_at: typeof record.lease_expires_at === 'string' ? record.lease_expires_at : null,
+    orchestrator_epoch:
+      typeof record.orchestrator_epoch === 'number' ? record.orchestrator_epoch : undefined,
+  };
+}
+
+function normalizeLockMap(index: FeaturesIndex): LockLease[] {
+  const lockLeases = asRecord(index.lock_leases);
+  if (!lockLeases) {
+    return [];
+  }
+  const now = Date.now();
+  return Object.entries(lockLeases)
+    .map(([resource, lease]) => {
+      const record = asRecord(lease);
+      if (!record) {
+        return null;
+      }
+      const holder = typeof record.holder === 'string' ? record.holder : null;
+      const expiresAt =
+        typeof record.expires_at === 'string'
+          ? record.expires_at
+          : typeof record.lease_expires_at === 'string'
+            ? record.lease_expires_at
+            : null;
+      const parsedExpiry = expiresAt ? Date.parse(expiresAt) : Number.NaN;
+      const stale = Number.isNaN(parsedExpiry) ? false : parsedExpiry < now;
+      return {
+        resource,
+        holder,
+        expires_at: expiresAt,
+        is_stale: stale,
+      } satisfies LockLease;
+    })
+    .filter((entry): entry is LockLease => entry != null)
+    .sort((left, right) => left.resource.localeCompare(right.resource));
+}
+
+function normalizeDepBlocked(index: FeaturesIndex): Array<{
+  feature_id: string;
+  depends_on_unresolved: string[];
+}> {
+  if (!Array.isArray(index.dep_blocked)) {
+    return [];
+  }
+  return index.dep_blocked
+    .map((entry) => {
+      const featureId = typeof entry?.feature_id === 'string' ? entry.feature_id : null;
+      const deps = Array.isArray(entry?.depends_on_unresolved)
+        ? entry.depends_on_unresolved.filter((item): item is string => typeof item === 'string')
+        : [];
+      if (!featureId) {
+        return null;
+      }
+      return { feature_id: featureId, depends_on_unresolved: deps };
+    })
+    .filter(
+      (
+        entry,
+      ): entry is {
+        feature_id: string;
+        depends_on_unresolved: string[];
+      } => entry != null,
+    );
+}
+
 function normalizeFeatureSummary(
   featureId: string,
   frontMatter: Record<string, unknown>,
@@ -172,14 +294,47 @@ function normalizeFeatureSummary(
               : undefined,
         }
       : undefined;
+  const roleStatus = parseRoleStatus(frontMatter);
+  const rawLocks =
+    frontMatter.locks && typeof frontMatter.locks === 'object'
+      ? (frontMatter.locks as Record<string, unknown>)
+      : null;
+  const locksHeldRaw = rawLocks?.held;
+  const locksHeld = Array.isArray(locksHeldRaw)
+    ? locksHeldRaw.filter((item): item is string => typeof item === 'string')
+    : Array.isArray(frontMatter.locks)
+      ? frontMatter.locks.filter((item): item is string => typeof item === 'string')
+      : undefined;
+
+  const planVersionRaw = frontMatter.plan_version;
+  const planVersion =
+    typeof planVersionRaw === 'number'
+      ? planVersionRaw
+      : typeof planVersionRaw === 'string'
+        ? Number.parseInt(planVersionRaw, 10)
+        : undefined;
+
+  const revisionOfRaw = frontMatter.revision_of;
+  const revisionOf =
+    typeof revisionOfRaw === 'number'
+      ? revisionOfRaw
+      : typeof revisionOfRaw === 'string'
+        ? Number.parseInt(revisionOfRaw, 10)
+        : null;
   return {
     id: featureId,
     feature_id: featureId,
     status,
     phase,
-    plan_version:
-      typeof frontMatter.plan_version === 'number' ? frontMatter.plan_version : undefined,
-    locks_held: Array.isArray(frontMatter.locks) ? (frontMatter.locks as string[]) : undefined,
+    plan_version: Number.isNaN(planVersion) ? undefined : planVersion,
+    revision_of: Number.isNaN(revisionOf) ? null : revisionOf,
+    revision_reason:
+      typeof frontMatter.revision_reason === 'string' ? frontMatter.revision_reason : null,
+    role_status: roleStatus ?? undefined,
+    gate_retry_count:
+      typeof frontMatter.gate_retry_count === 'number' ? frontMatter.gate_retry_count : undefined,
+    last_retry_at: typeof frontMatter.last_retry_at === 'string' ? frontMatter.last_retry_at : null,
+    locks_held: locksHeld,
     gates,
     gate_profile:
       typeof frontMatter.gate_profile === 'string' ? frontMatter.gate_profile : undefined,
@@ -234,7 +389,62 @@ export async function readFeaturesIndex(repoRoot = AOP_ROOT): Promise<FeaturesIn
   const indexPath = path.join(repoRoot, '.aop', 'features', 'index.json');
   try {
     const raw = await readFile(indexPath, 'utf-8');
-    return JSON.parse(raw) as FeaturesIndex;
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+    const normalized: FeaturesIndex = {
+      active: Array.isArray(parsed.active)
+        ? parsed.active.filter((item): item is string => typeof item === 'string')
+        : [],
+      blocked: Array.isArray(parsed.blocked)
+        ? parsed.blocked.filter((item): item is string => typeof item === 'string')
+        : [],
+      merged: Array.isArray(parsed.merged)
+        ? parsed.merged.filter((item): item is string => typeof item === 'string')
+        : [],
+      blocked_queue: Array.isArray(parsed.blocked_queue)
+        ? parsed.blocked_queue
+            .map((entry) => {
+              const record = asRecord(entry);
+              const featureId =
+                record && typeof record.feature_id === 'string' ? record.feature_id : null;
+              const detectedAt =
+                record && typeof record.detected_at === 'string' ? record.detected_at : null;
+              const collisionFingerprint =
+                record && typeof record.collision_fingerprint === 'string'
+                  ? record.collision_fingerprint
+                  : null;
+              if (!featureId || !detectedAt || !collisionFingerprint) {
+                return null;
+              }
+              return {
+                feature_id: featureId,
+                detected_at: detectedAt,
+                collision_fingerprint: collisionFingerprint,
+              };
+            })
+            .filter(
+              (
+                entry,
+              ): entry is {
+                feature_id: string;
+                detected_at: string;
+                collision_fingerprint: string;
+              } => entry != null,
+            )
+        : [],
+    };
+
+    const lockLeases = asRecord(parsed.lock_leases);
+    if (lockLeases) {
+      normalized.lock_leases = lockLeases as FeaturesIndex['lock_leases'];
+    }
+    if (Array.isArray(parsed.dep_blocked)) {
+      normalized.dep_blocked = parsed.dep_blocked as FeaturesIndex['dep_blocked'];
+    }
+    const runtimeSessions = normalizeRuntimeSession(parsed.runtime_sessions);
+    if (runtimeSessions) {
+      normalized.runtime_sessions = runtimeSessions;
+    }
+    return normalized;
   } catch {
     return { active: [], blocked: [], merged: [], blocked_queue: [] };
   }
@@ -272,6 +482,137 @@ export async function readFeaturePlan(
   }
 }
 
+export async function readFeatureCost(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+): Promise<CostSummary | null> {
+  const costPath = path.join(getFeatureRoot(featureId, repoRoot), 'cost.json');
+  const parsed = await readJsonFile<Record<string, unknown>>(costPath);
+  if (!parsed) {
+    return null;
+  }
+  return {
+    feature_id: featureId,
+    tokens_used: typeof parsed.tokens_used === 'number' ? parsed.tokens_used : 0,
+    estimated_cost_usd:
+      typeof parsed.estimated_cost_usd === 'number' ? parsed.estimated_cost_usd : 0,
+    recorded_at:
+      typeof parsed.recorded_at === 'string'
+        ? parsed.recorded_at
+        : typeof parsed.last_updated === 'string'
+          ? parsed.last_updated
+          : null,
+  };
+}
+
+export async function readFeatureQaTestIndex(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+): Promise<QaTestIndex | null> {
+  const indexPath = path.join(getFeatureRoot(featureId, repoRoot), 'qa_test_index.json');
+  const parsed = await readJsonFile<Record<string, unknown>>(indexPath);
+  if (!parsed || !Array.isArray(parsed.items)) {
+    return null;
+  }
+
+  const items = parsed.items
+    .map((item) => {
+      const record = asRecord(item);
+      if (!record || typeof record.path !== 'string' || typeof record.status !== 'string') {
+        return null;
+      }
+      const status = record.status.toLowerCase();
+      if (!['pending', 'running', 'passed', 'failed', 'waived'].includes(status)) {
+        return null;
+      }
+      const normalizedStatus = status as QaTestIndex['items'][number]['status'];
+      const nextItem: QaTestIndex['items'][number] = {
+        path: record.path,
+        status: normalizedStatus,
+        required_tests: Array.isArray(record.required_tests)
+          ? record.required_tests.filter((test): test is string => typeof test === 'string')
+          : [],
+      };
+      if (typeof record.last_run_at === 'string') {
+        nextItem.last_run_at = record.last_run_at;
+      }
+      return nextItem;
+    })
+    .filter((entry): entry is QaTestIndex['items'][number] => entry != null);
+
+  const version =
+    typeof parsed.version === 'number'
+      ? parsed.version
+      : typeof parsed.version === 'string'
+        ? Number.parseInt(parsed.version, 10)
+        : 1;
+
+  return {
+    feature_id: typeof parsed.feature_id === 'string' ? parsed.feature_id : featureId,
+    version: Number.isNaN(version) ? 1 : version,
+    items,
+  };
+}
+
+export async function readFeatureReviewBrief(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+): Promise<ReviewBrief | null> {
+  const briefPath = path.join(getFeatureRoot(featureId, repoRoot), 'review_brief.json');
+  const parsed = await readJsonFile<Record<string, unknown>>(briefPath);
+  if (!parsed) {
+    return null;
+  }
+
+  const intent =
+    typeof parsed.intent_summary === 'string'
+      ? parsed.intent_summary
+      : typeof parsed.intent === 'string'
+        ? parsed.intent
+        : '';
+  const scope =
+    typeof parsed.scope_summary === 'string'
+      ? parsed.scope_summary
+      : typeof parsed.scope === 'string'
+        ? parsed.scope
+        : '';
+  const contractRisk =
+    typeof parsed.contract_risk_summary === 'string'
+      ? parsed.contract_risk_summary
+      : typeof parsed.contract_risk === 'string'
+        ? parsed.contract_risk
+        : '';
+  const generatedAt =
+    typeof parsed.generated_at === 'string' ? parsed.generated_at : new Date().toISOString();
+
+  if (intent.length === 0 && scope.length === 0 && contractRisk.length === 0) {
+    return null;
+  }
+
+  return {
+    intent_summary: intent,
+    scope_summary: scope,
+    contract_risk_summary: contractRisk,
+    feasibility_score:
+      typeof parsed.feasibility_score === 'number' ? parsed.feasibility_score : undefined,
+    feasibility_breakdown:
+      parsed.feasibility_breakdown && typeof parsed.feasibility_breakdown === 'object'
+        ? (parsed.feasibility_breakdown as Record<string, number>)
+        : undefined,
+    gate_matrix:
+      parsed.gate_matrix && typeof parsed.gate_matrix === 'object'
+        ? (parsed.gate_matrix as Record<string, string>)
+        : {},
+    unresolved_questions: Array.isArray(parsed.unresolved_questions)
+      ? parsed.unresolved_questions.filter((item): item is string => typeof item === 'string')
+      : [],
+    evidence_refs: Array.isArray(parsed.evidence_refs)
+      ? parsed.evidence_refs.filter((item): item is string => typeof item === 'string')
+      : [],
+    generated_at: generatedAt,
+  };
+}
+
 export async function readFeatureDiff(featureId: string, repoRoot = AOP_ROOT): Promise<string> {
   const diffPath = path.join(getFeatureRoot(featureId, repoRoot), 'evidence', 'diff.patch');
   try {
@@ -307,6 +648,99 @@ export async function listEvidenceArtifacts(
   }
 }
 
+async function readOutputTail(logPath: unknown, maxLines = 50): Promise<string[] | undefined> {
+  if (typeof logPath !== 'string' || logPath.length === 0) {
+    return undefined;
+  }
+  try {
+    const raw = await readFile(logPath, 'utf-8');
+    const lines = raw.replace(/\r\n/g, '\n').split('\n');
+    return lines.slice(Math.max(0, lines.length - maxLines));
+  } catch {
+    return undefined;
+  }
+}
+
+export async function readLatestGateEvidence(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+): Promise<GateRunEvidence | null> {
+  const evidenceDir = path.join(getFeatureRoot(featureId, repoRoot), 'evidence');
+  try {
+    const files = await readdir(evidenceDir);
+    const gateJsons = files.filter(
+      (name) =>
+        /^latest-(fast|full|merge)\.json$/.test(name) || /^gate-(fast|full|merge)-/.test(name),
+    );
+    if (gateJsons.length === 0) {
+      return null;
+    }
+
+    let latest: { file: string; finishedAt: number; raw: Record<string, unknown> } | null = null;
+    for (const file of gateJsons) {
+      const fullPath = path.join(evidenceDir, file);
+      const parsed = await readJsonFile<Record<string, unknown>>(fullPath);
+      if (!parsed) {
+        continue;
+      }
+      const finishedAt =
+        typeof parsed.finished_at === 'string' ? Date.parse(parsed.finished_at) : Number.NaN;
+      const statInfo = await stat(fullPath);
+      const score = Number.isNaN(finishedAt) ? statInfo.mtime.getTime() : finishedAt;
+      if (!latest || score > latest.finishedAt) {
+        latest = { file, finishedAt: score, raw: parsed };
+      }
+    }
+
+    if (!latest) {
+      return null;
+    }
+
+    const rawSteps = Array.isArray(latest.raw.step_results) ? latest.raw.step_results : [];
+    const steps = await Promise.all(
+      rawSteps.map(async (step) => {
+        const record = asRecord(step) ?? {};
+        const startedAt =
+          typeof record.started_at === 'string' ? Date.parse(record.started_at) : NaN;
+        const finishedAt =
+          typeof record.finished_at === 'string' ? Date.parse(record.finished_at) : NaN;
+        const duration =
+          Number.isNaN(startedAt) || Number.isNaN(finishedAt)
+            ? null
+            : Math.max(0, finishedAt - startedAt);
+        const exitCode = typeof record.exit_code === 'number' ? record.exit_code : null;
+        const timeout = record.timeout === true;
+        const status: 'pass' | 'fail' | 'unknown' =
+          exitCode == null ? 'unknown' : exitCode === 0 && !timeout ? 'pass' : 'fail';
+        return {
+          name: typeof record.name === 'string' ? record.name : 'step',
+          command: Array.isArray(record.cmd)
+            ? record.cmd.filter((token): token is string => typeof token === 'string').join(' ')
+            : typeof record.command === 'string'
+              ? record.command
+              : '',
+          status,
+          exit_code: exitCode,
+          duration_ms: duration,
+          log_path: typeof record.log_path === 'string' ? record.log_path : null,
+          output_tail: await readOutputTail(record.log_path),
+        };
+      }),
+    );
+
+    return {
+      mode: typeof latest.raw.mode === 'string' ? latest.raw.mode : 'unknown',
+      profile: typeof latest.raw.profile === 'string' ? latest.raw.profile : null,
+      overall: typeof latest.raw.overall === 'string' ? latest.raw.overall : 'unknown',
+      finished_at: typeof latest.raw.finished_at === 'string' ? latest.raw.finished_at : null,
+      steps,
+      raw: latest.raw,
+    };
+  } catch {
+    return null;
+  }
+}
+
 export async function readEvidenceArtifact(
   featureId: string,
   artifactName: string,
@@ -399,6 +833,49 @@ export async function readFeatureLog(featureId: string, repoRoot = AOP_ROOT): Pr
   };
 }
 
+function buildMergeHistogram14d(features: FeatureSummary[]): number[] {
+  const days = 14;
+  const buckets = new Array<number>(days).fill(0);
+  const now = Date.now();
+  for (const feature of features) {
+    if (feature.phase !== 'merged' || typeof feature.last_updated !== 'string') {
+      continue;
+    }
+    const stamp = Date.parse(feature.last_updated);
+    if (Number.isNaN(stamp) || stamp > now) {
+      continue;
+    }
+    const ageDays = Math.floor((now - stamp) / 86_400_000);
+    if (ageDays < 0 || ageDays >= days) {
+      continue;
+    }
+    buckets[days - 1 - ageDays] += 1;
+  }
+  return buckets;
+}
+
+async function readFlakySuspects(repoRoot = AOP_ROOT): Promise<string[]> {
+  const candidates = [
+    path.join(repoRoot, '.aop', 'runtime', 'flaky.json'),
+    path.join(repoRoot, '.aop', 'analytics', 'flaky.json'),
+  ];
+
+  for (const candidate of candidates) {
+    const parsed = await readJsonFile<Record<string, unknown>>(candidate);
+    if (!parsed) {
+      continue;
+    }
+    if (Array.isArray(parsed.suspects)) {
+      return parsed.suspects.filter((item): item is string => typeof item === 'string');
+    }
+    if (Array.isArray(parsed.tests)) {
+      return parsed.tests.filter((item): item is string => typeof item === 'string');
+    }
+  }
+
+  return [];
+}
+
 export async function readDashboardStatus(repoRoot = AOP_ROOT): Promise<DashboardStatusPayload> {
   const index = await readFeaturesIndex(repoRoot);
   const allFeatureIds = new Set<string>([
@@ -409,6 +886,7 @@ export async function readDashboardStatus(repoRoot = AOP_ROOT): Promise<Dashboar
   ]);
 
   const features: FeatureSummary[] = [];
+  let totalCostUsd = 0;
   for (const featureId of [...allFeatureIds].sort((a, b) => a.localeCompare(b))) {
     const statePath = path.join(getFeatureRoot(featureId, repoRoot), 'state.md');
     try {
@@ -439,9 +917,26 @@ export async function readDashboardStatus(repoRoot = AOP_ROOT): Promise<Dashboar
         pr: null,
       });
     }
+
+    const cost = await readFeatureCost(featureId, repoRoot);
+    if (cost) {
+      totalCostUsd += cost.estimated_cost_usd;
+    }
   }
 
-  return { index, features };
+  const depBlocked = normalizeDepBlocked(index);
+  return {
+    index,
+    features,
+    runtime: index.runtime_sessions,
+    lock_map: normalizeLockMap(index),
+    dep_blocked: depBlocked,
+    flaky_suspects: await readFlakySuspects(repoRoot),
+    metrics: {
+      total_cost_today_usd: Number(totalCostUsd.toFixed(4)),
+      merge_histogram_14d: buildMergeHistogram14d(features),
+    },
+  };
 }
 
 export async function readFeatureDetail(
@@ -457,5 +952,9 @@ export async function readFeatureDetail(
     plan: await readFeaturePlan(featureId, repoRoot),
     diff: await readFeatureDiff(featureId, repoRoot),
     evidence: await listEvidenceArtifacts(featureId, repoRoot),
+    gate_evidence: await readLatestGateEvidence(featureId, repoRoot),
+    cost: await readFeatureCost(featureId, repoRoot),
+    qa_test_index: await readFeatureQaTestIndex(featureId, repoRoot),
+    review_brief: await readFeatureReviewBrief(featureId, repoRoot),
   };
 }

package/packages/web-dashboard/src/lib/api-envelope.ts

@@ -0,0 +1,48 @@
+export interface ApiSuccessEnvelope<TData> {
+  ok: true;
+  data: TData;
+  meta: {
+    stale: boolean;
+    source: 'tool' | 'artifact' | 'derived';
+  };
+}
+
+export interface ApiErrorEnvelope {
+  ok: false;
+  error: {
+    code: string;
+    message: string;
+    retryable: boolean;
+  };
+}
+
+export type ApiEnvelope<TData> = ApiSuccessEnvelope<TData> | ApiErrorEnvelope;
+
+export function okEnvelope<TData>(
+  data: TData,
+  options: { stale?: boolean; source?: 'tool' | 'artifact' | 'derived' } = {},
+): ApiSuccessEnvelope<TData> {
+  return {
+    ok: true,
+    data,
+    meta: {
+      stale: options.stale ?? false,
+      source: options.source ?? 'artifact',
+    },
+  };
+}
+
+export function errorEnvelope(
+  code: string,
+  message: string,
+  options: { retryable?: boolean } = {},
+): ApiErrorEnvelope {
+  return {
+    ok: false,
+    error: {
+      code,
+      message,
+      retryable: options.retryable ?? false,
+    },
+  };
+}

package/packages/web-dashboard/src/lib/authz-adapter.ts

@@ -0,0 +1,33 @@
+export interface DashboardAuthorizationContext {
+  action: string;
+  project: string | null;
+  request: Request;
+}
+
+export interface DashboardAuthorizationResult {
+  allowed: boolean;
+  code?: string;
+  message?: string;
+}
+
+export interface DashboardAuthorizationAdapter {
+  authorize(context: DashboardAuthorizationContext): Promise<DashboardAuthorizationResult>;
+}
+
+class AllowAllAuthorizationAdapter implements DashboardAuthorizationAdapter {
+  async authorize(): Promise<DashboardAuthorizationResult> {
+    return { allowed: true };
+  }
+}
+
+let adapter: DashboardAuthorizationAdapter = new AllowAllAuthorizationAdapter();
+
+export function setDashboardAuthorizationAdapter(nextAdapter: DashboardAuthorizationAdapter): void {
+  adapter = nextAdapter;
+}
+
+export async function authorizeDashboardAction(
+  context: DashboardAuthorizationContext,
+): Promise<DashboardAuthorizationResult> {
+  return await adapter.authorize(context);
+}