availsync 0.1.0

package/src/routes/onboarding.ts

@@ -0,0 +1,273 @@
+import { randomUUID } from 'crypto';
+import express from 'express';
+import { addMinutes } from 'date-fns';
+import { z } from 'zod';
+import pool from '../db/client';
+import { claimWorkSlot, insertWorkClaimEvent } from '../core/work';
+import { determineWinnerWithReason, type ConflictRuleApplied } from '../core/conflict';
+import { durationSince, logActivity, workspaceActor } from '../lib/activity';
+import { log } from '../lib/logger';
+import { requireWorkspaceSession, type WorkspaceAuthenticatedRequest } from '../middleware/auth';
+import type { Agent, AgentPreferences, Hold } from '../types';
+
+const router = express.Router();
+
+const VerifySchema = z.object({
+  agent_a_id: z.string().uuid().optional(),
+  agent_b_id: z.string().uuid().optional(),
+});
+
+const AGENT_TYPE_RANK: Record<Agent['agent_type'], number> = {
+  external_meeting: 4,
+  internal: 3,
+  focus: 2,
+  generic: 1,
+};
+
+function syntheticHold(agent: Agent, createdAt: Date): Hold {
+  const start = new Date();
+  return {
+    id: agent.id,
+    agent_id: agent.id,
+    org_id: agent.org_id,
+    start_at: start,
+    end_at: addMinutes(start, 5),
+    status: 'confirmed',
+    created_at: createdAt,
+  };
+}
+
+function explainRule(rule: ConflictRuleApplied, winner: Agent, loser: Agent) {
+  if (rule === 'priority_over_agents') {
+    return `${winner.name} won because its preferences explicitly outrank ${loser.name}.`;
+  }
+  if (rule === 'agent_type') {
+    return `${winner.name} won because agent_type '${winner.agent_type}' (rank ${AGENT_TYPE_RANK[winner.agent_type]}) outranks '${loser.agent_type}' (rank ${AGENT_TYPE_RANK[loser.agent_type]}).`;
+  }
+  if (rule === 'priority') {
+    return `${winner.name} won because priority ${winner.priority} is higher than ${loser.name}'s priority ${loser.priority}.`;
+  }
+  if (rule === 'first_created') {
+    return `${winner.name} won because both agents tied on rules and priority, so Availsync used deterministic submission order.`;
+  }
+  return `${winner.name} won because no stronger competing rule applied.`;
+}
+
+function outcome(agent: Agent, input: {
+  claim_id: string | null;
+  completed_at: string;
+  outcome: 'claimed' | 'blocked';
+  retry_after?: string | null;
+}) {
+  return {
+    agent_id: agent.id,
+    agent_name: agent.name,
+    agent_type: agent.agent_type,
+    priority: agent.priority,
+    claim_id: input.claim_id,
+    completed_at: input.completed_at,
+    outcome: input.outcome,
+    ...(input.retry_after !== undefined ? { retry_after: input.retry_after } : {}),
+  };
+}
+
+async function resolveAgents(orgId: string, input: z.infer<typeof VerifySchema>) {
+  if (input.agent_a_id && input.agent_b_id) {
+    if (input.agent_a_id === input.agent_b_id) {
+      return { error: 'same_agent' as const, agents: [] as Agent[] };
+    }
+    const result = await pool.query<Agent>(
+      `SELECT *
+       FROM agents
+       WHERE org_id = $1
+         AND id = ANY($2::uuid[])
+       ORDER BY created_at ASC`,
+      [orgId, [input.agent_a_id, input.agent_b_id]],
+    );
+    if (result.rows.length !== 2) {
+      return { error: 'foreign_agent' as const, agents: [] as Agent[] };
+    }
+    return {
+      error: null,
+      agents: [
+        result.rows.find((agent) => agent.id === input.agent_a_id) as Agent,
+        result.rows.find((agent) => agent.id === input.agent_b_id) as Agent,
+      ],
+    };
+  }
+
+  const result = await pool.query<Agent>(
+    `SELECT *
+     FROM agents
+     WHERE org_id = $1
+     ORDER BY created_at ASC
+     LIMIT 2`,
+    [orgId],
+  );
+  return { error: null, agents: result.rows };
+}
+
+router.post('/onboarding/verify', requireWorkspaceSession, async (req, res) => {
+  const startedAt = Date.now();
+  const parsed = VerifySchema.safeParse(req.body ?? {});
+  if (!parsed.success) {
+    return res.status(422).json({ error: 'validation_error', details: parsed.error.flatten() });
+  }
+
+  const authReq = req as WorkspaceAuthenticatedRequest;
+  const selected = await resolveAgents(authReq.org.id, parsed.data);
+  if (selected.error === 'same_agent') {
+    return res.status(422).json({ error: 'same_agent', message: 'Pick two different agents to run verification' });
+  }
+  if (selected.error === 'foreign_agent') {
+    return res.status(403).json({ error: 'forbidden', message: 'Selected agents must belong to your workspace' });
+  }
+  if (selected.agents.length < 2) {
+    return res.status(422).json({
+      error: 'insufficient_agents',
+      message: 'Create at least 2 agents to run verification',
+    });
+  }
+
+  const [agentA, agentB] = selected.agents;
+  const preferences = await pool.query<AgentPreferences>(
+    'SELECT * FROM agent_preferences WHERE agent_id = ANY($1::uuid[])',
+    [[agentA.id, agentB.id]],
+  );
+  const rule = determineWinnerWithReason(
+    syntheticHold(agentA, new Date(0)),
+    agentA,
+    syntheticHold(agentB, new Date(1)),
+    agentB,
+    preferences.rows,
+  );
+  const winnerAgent = rule.winner.agent_id === agentA.id ? agentA : agentB;
+  const loserAgent = winnerAgent.id === agentA.id ? agentB : agentA;
+  const runId = randomUUID();
+  const resourceKey = `verify-${runId}`;
+  const startAt = new Date();
+  const endAt = addMinutes(startAt, 5);
+  const metadata = { source: 'onboarding_verification', run_id: runId, resource_key: resourceKey };
+  const actor = workspaceActor(authReq);
+
+  const client = await pool.connect();
+  try {
+    await client.query('BEGIN');
+    const winnerClaimed = await claimWorkSlot(client, {
+      org_id: authReq.org.id,
+      agent_id: winnerAgent.id,
+      resource_type: 'project',
+      resource_key: resourceKey,
+      label: 'Availsync verification resource',
+      start_at: startAt,
+      end_at: endAt,
+      reason: 'Availsync onboarding verification',
+      metadata,
+      actor,
+    });
+    if (winnerClaimed.outcome !== 'claimed') {
+      throw new Error(`Expected verification winner to claim, got ${winnerClaimed.outcome}`);
+    }
+
+    const winnerCompletedAt = new Date().toISOString();
+    const loserBlocked = await claimWorkSlot(client, {
+      org_id: authReq.org.id,
+      agent_id: loserAgent.id,
+      resource_type: 'project',
+      resource_key: resourceKey,
+      label: 'Availsync verification resource',
+      start_at: startAt,
+      end_at: endAt,
+      reason: 'Availsync onboarding verification',
+      metadata,
+      actor,
+    });
+    if (loserBlocked.outcome !== 'blocked') {
+      throw new Error(`Expected verification loser to be blocked, got ${loserBlocked.outcome}`);
+    }
+    const loserCompletedAt = new Date().toISOString();
+
+    await client.query(
+      `UPDATE work_claims
+       SET status = 'released'
+       WHERE id = $1
+       RETURNING *`,
+      [winnerClaimed.claim.id],
+    );
+    await insertWorkClaimEvent({
+      db: client,
+      claim_id: winnerClaimed.claim.id,
+      event_type: 'released',
+      agent_id: winnerAgent.id,
+      org_id: authReq.org.id,
+      resource_id: winnerClaimed.resource.id,
+      metadata,
+      ...actor,
+    });
+
+    await client.query('DELETE FROM work_resources WHERE id = $1 AND org_id = $2', [
+      winnerClaimed.resource.id,
+      authReq.org.id,
+    ]);
+    const org = await client.query<{ verified_at: Date }>(
+      `UPDATE orgs
+       SET verified_at = COALESCE(verified_at, NOW())
+       WHERE id = $1
+       RETURNING verified_at`,
+      [authReq.org.id],
+    );
+    await client.query('COMMIT');
+
+    await logActivity({
+      org_id: authReq.org.id,
+      agent_id: winnerAgent.id,
+      activity_type: 'verification_run',
+      endpoint: '/v1/onboarding/verify',
+      method: 'POST',
+      status_code: 200,
+      status: 'success',
+      ...actor,
+      latency_ms: durationSince(startedAt),
+      metadata: {
+        ...metadata,
+        winner_agent_id: winnerAgent.id,
+        loser_agent_id: loserAgent.id,
+        winner_claim_id: winnerClaimed.claim.id,
+        loser_winning_claim_id: loserBlocked.winning_claim_id,
+      },
+    });
+
+    return res.json({
+      verified_at: org.rows[0].verified_at.toISOString(),
+      resource_key: resourceKey,
+      duration_ms: durationSince(startedAt),
+      winner: outcome(winnerAgent, {
+        claim_id: winnerClaimed.claim.id,
+        completed_at: winnerCompletedAt,
+        outcome: 'claimed',
+      }),
+      loser: outcome(loserAgent, {
+        claim_id: null,
+        completed_at: loserCompletedAt,
+        outcome: 'blocked',
+        retry_after: loserBlocked.suggested_retry_at?.toISOString() ?? null,
+      }),
+      rule_applied: loserBlocked.rule_applied,
+      rule_explanation: explainRule(rule.rule_applied, winnerAgent, loserAgent),
+      ...(rule.rule_applied === 'first_created'
+        ? {
+            tie_warning:
+              'Both agents tied on priority - winner was decided by submission order. Set agent_type or priority to make resolutions deterministic.',
+          }
+        : {}),
+    });
+  } catch (err) {
+    await client.query('ROLLBACK');
+    log.error('[onboarding] verify error', { error: (err as Error).message });
+    return res.status(500).json({ error: 'internal_error', message: 'An unexpected error occurred' });
+  } finally {
+    client.release();
+  }
+});
+
+export default router;