availsync 0.1.0

package/src/routes/preferences.ts

@@ -0,0 +1,132 @@
+import express from 'express';
+import { z } from 'zod';
+import pool from '../db/client';
+import { log } from '../lib/logger';
+import {
+  canAccessAgent,
+  requireWorkspaceOrAgent,
+  type AnyAuthenticatedRequest,
+} from '../middleware/auth';
+
+const router = express.Router();
+
+const PreferencesSchema = z.object({
+  buffer_minutes_after: z.number().int().min(0).max(120).optional(),
+  buffer_minutes_before: z.number().int().min(0).max(120).optional(),
+  focus_blocks: z
+    .array(
+      z.object({
+        weekday: z.number().int().min(0).max(6),
+        start_time: z.string().regex(/^\d{2}:\d{2}$/),
+        end_time: z.string().regex(/^\d{2}:\d{2}$/),
+      }),
+    )
+    .max(20)
+    .optional(),
+  priority_over_agents: z.array(z.string().uuid()).max(50).optional(),
+  booking_window_days: z.number().int().min(1).max(365).optional(),
+  allow_back_to_back: z.boolean().optional(),
+});
+
+async function ensureOrgAgent(agentId: string, orgId: string): Promise<boolean> {
+  const result = await pool.query('SELECT 1 FROM agents WHERE id = $1 AND org_id = $2', [
+    agentId,
+    orgId,
+  ]);
+  return result.rows.length > 0;
+}
+
+router.get('/preferences/:agent_id', requireWorkspaceOrAgent, async (req, res) => {
+  const authReq = req as AnyAuthenticatedRequest;
+  const agentId = z.string().uuid().safeParse(req.params.agent_id);
+  if (!agentId.success) {
+    return res.status(400).json({ error: 'validation_error', details: agentId.error.flatten() });
+  }
+
+  try {
+    if (!(await ensureOrgAgent(agentId.data, authReq.org.id))) {
+      return res.status(403).json({ error: 'forbidden', message: 'Agent is outside your org' });
+    }
+    if (!canAccessAgent(authReq, agentId.data)) {
+      return res.status(403).json({ error: 'forbidden', message: 'Agent key cannot act for another agent' });
+    }
+
+    const preferences = await pool.query('SELECT * FROM agent_preferences WHERE agent_id = $1', [
+      agentId.data,
+    ]);
+    return res.json({ preferences: preferences.rows[0] });
+  } catch (err) {
+    log.error('[preferences] unexpected error', { error: (err as Error).message });
+    return res.status(500).json({ error: 'internal_error', message: 'An unexpected error occurred' });
+  }
+});
+
+router.put('/preferences/:agent_id', requireWorkspaceOrAgent, async (req, res) => {
+  const agentId = z.string().uuid().safeParse(req.params.agent_id);
+  if (!agentId.success) {
+    return res.status(400).json({ error: 'validation_error', details: agentId.error.flatten() });
+  }
+
+  const parsed = PreferencesSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(422).json({ error: 'validation_error', details: parsed.error.flatten() });
+  }
+
+  const authReq = req as AnyAuthenticatedRequest;
+
+  try {
+    if (!(await ensureOrgAgent(agentId.data, authReq.org.id))) {
+      return res.status(403).json({ error: 'forbidden', message: 'Agent is outside your org' });
+    }
+    if (!canAccessAgent(authReq, agentId.data)) {
+      return res.status(403).json({ error: 'forbidden', message: 'Agent key cannot act for another agent' });
+    }
+
+    const existing = await pool.query('SELECT * FROM agent_preferences WHERE agent_id = $1', [
+      agentId.data,
+    ]);
+    const merged = {
+      ...existing.rows[0],
+      ...parsed.data,
+    };
+
+    const updated = await pool.query(
+      `INSERT INTO agent_preferences (
+         agent_id,
+         buffer_minutes_after,
+         buffer_minutes_before,
+         focus_blocks,
+         priority_over_agents,
+         booking_window_days,
+         allow_back_to_back,
+         updated_at
+       )
+       VALUES ($1, $2, $3, $4, $5, $6, $7, NOW())
+       ON CONFLICT (agent_id) DO UPDATE SET
+         buffer_minutes_after = EXCLUDED.buffer_minutes_after,
+         buffer_minutes_before = EXCLUDED.buffer_minutes_before,
+         focus_blocks = EXCLUDED.focus_blocks,
+         priority_over_agents = EXCLUDED.priority_over_agents,
+         booking_window_days = EXCLUDED.booking_window_days,
+         allow_back_to_back = EXCLUDED.allow_back_to_back,
+         updated_at = NOW()
+       RETURNING *`,
+      [
+        agentId.data,
+        merged.buffer_minutes_after ?? 15,
+        merged.buffer_minutes_before ?? 0,
+        JSON.stringify(merged.focus_blocks ?? []),
+        JSON.stringify(merged.priority_over_agents ?? []),
+        merged.booking_window_days ?? 30,
+        merged.allow_back_to_back ?? false,
+      ],
+    );
+
+    return res.json({ preferences: updated.rows[0] });
+  } catch (err) {
+    log.error('[preferences] unexpected error', { error: (err as Error).message });
+    return res.status(500).json({ error: 'internal_error', message: 'An unexpected error occurred' });
+  }
+});
+
+export default router;

package/src/routes/session.ts

@@ -0,0 +1,16 @@
+import express from 'express';
+import { requireWorkspaceSession, type WorkspaceAuthenticatedRequest } from '../middleware/auth';
+
+const router = express.Router();
+
+router.get('/session', requireWorkspaceSession, (req, res) => {
+  const authenticatedReq = req as WorkspaceAuthenticatedRequest;
+  const { password_hash: _passwordHash, ...user } = authenticatedReq.user;
+
+  return res.json({
+    org: authenticatedReq.org,
+    user,
+  });
+});
+
+export default router;

package/src/routes/support.ts

@@ -0,0 +1,77 @@
+import express from 'express';
+import { z } from 'zod';
+import pool from '../db/client';
+import { requireWorkspaceSession, type WorkspaceAuthenticatedRequest } from '../middleware/auth';
+import { log } from '../lib/logger';
+import { billingUpgradesEnabled } from '../lib/billingConfig';
+
+const router = express.Router();
+
+const TicketCreateSchema = z.object({
+  email: z.string().email().max(240),
+  subject: z.string().trim().min(3).max(160),
+  category: z.enum(['billing', 'setup', 'sdk', 'agent_error', 'bug', 'other']),
+  message: z.string().trim().min(10).max(5000),
+  context: z.record(z.string(), z.unknown()).optional(),
+});
+
+router.post('/support/tickets', requireWorkspaceSession, async (req, res) => {
+  const authReq = req as WorkspaceAuthenticatedRequest;
+  if (authReq.org.plan === 'free') {
+    return res.status(402).json({
+      error: 'plan_limit_reached',
+      limit_type: 'support_tickets',
+      plan: authReq.org.plan,
+      upgrade_plan: 'individual',
+      message: billingUpgradesEnabled()
+        ? 'Support tickets are available on paid plans.'
+        : 'Support tickets are available on paid plans. Paid upgrades are currently waitlist-only.',
+    });
+  }
+
+  const parsed = TicketCreateSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: 'validation_error', details: parsed.error.flatten() });
+  }
+
+  try {
+    const context = {
+      source: 'dashboard_support',
+      submitted_path: typeof parsed.data.context?.path === 'string' ? parsed.data.context.path : undefined,
+      user_agent: req.header('user-agent')?.slice(0, 240),
+      app_url: typeof parsed.data.context?.app_url === 'string' ? parsed.data.context.app_url : undefined,
+    };
+
+    const result = await pool.query(
+      `INSERT INTO support_tickets (
+         org_id,
+         user_id,
+         email,
+         subject,
+         category,
+         message,
+         plan,
+         context
+       )
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+       RETURNING id, org_id, user_id, email, subject, category, message, status, priority, plan, context, created_at, updated_at`,
+      [
+        authReq.org.id,
+        authReq.user.id,
+        parsed.data.email,
+        parsed.data.subject,
+        parsed.data.category,
+        parsed.data.message,
+        authReq.org.plan,
+        JSON.stringify(context),
+      ],
+    );
+
+    return res.status(201).json({ ticket: result.rows[0] });
+  } catch (err) {
+    log.error('[support] create ticket error', { error: (err as Error).message, org_id: authReq.org.id });
+    return res.status(500).json({ error: 'internal_error', message: 'An unexpected error occurred' });
+  }
+});
+
+export default router;

package/src/routes/value.ts

@@ -0,0 +1,186 @@
+import express from 'express';
+import pool from '../db/client';
+import { requireWorkspaceSession, type WorkspaceAuthenticatedRequest } from '../middleware/auth';
+import { log } from '../lib/logger';
+
+const router = express.Router();
+
+const REAL_ACTIVITY_FILTER = `
+  NOT (
+    activity_type LIKE 'setup_test%'
+    OR activity_type IN ('verification_run', 'connection_test')
+    OR COALESCE(metadata->>'source', '') IN ('setup_test', 'onboarding_verification')
+  )
+`;
+
+const REAL_WORK_EVENT_FILTER = `
+  COALESCE(metadata->>'source', '') NOT IN ('setup_test', 'onboarding_verification')
+`;
+
+function nextBestAction(input: {
+  verified_at: Date | null;
+  agents_count: number;
+  latest_real_activity_at: Date | null;
+  errors_7d: number;
+  quiet_agents: number;
+  never_connected_agents: number;
+}) {
+  if (!input.verified_at) return 'run_verification';
+  if (input.agents_count === 0 || !input.latest_real_activity_at) return 'connect_first_agent';
+  if (input.errors_7d > 0) return 'review_errors';
+  if (input.quiet_agents > 0 || input.never_connected_agents > 0) return 'check_inactive_agents';
+  return 'none';
+}
+
+router.get('/value/health', requireWorkspaceSession, async (req, res) => {
+  const authReq = req as WorkspaceAuthenticatedRequest;
+
+  try {
+    const [summary, agents] = await Promise.all([
+      pool.query(
+        `WITH window AS (
+           SELECT NOW() AS ends_at, NOW() - INTERVAL '7 days' AS starts_at
+         ),
+         real_activity AS (
+           SELECT *
+           FROM agent_activity_events
+           WHERE org_id = $1
+             AND ${REAL_ACTIVITY_FILTER}
+         ),
+         work_value AS (
+           SELECT
+             COUNT(*) FILTER (WHERE event_type = 'blocked')::int AS blocked_work_runs_7d,
+             COUNT(*) FILTER (WHERE event_type = 'shadow_blocked')::int AS would_have_blocked_runs_7d
+           FROM work_claim_events, window
+           WHERE org_id = $1
+             AND event_type IN ('blocked', 'shadow_blocked')
+             AND created_at >= window.starts_at
+             AND ${REAL_WORK_EVENT_FILTER}
+         ),
+         calendar_value AS (
+           SELECT COUNT(*)::int AS calendar_conflicts_7d
+           FROM hold_events, window
+           WHERE org_id = $1
+             AND event_type IN ('conflict_won', 'conflict_lost', 'superseded')
+             AND created_at >= window.starts_at
+         )
+         SELECT
+           (SELECT starts_at FROM window) AS starts_at,
+           (SELECT ends_at FROM window) AS ends_at,
+           (SELECT blocked_work_runs_7d FROM work_value) AS blocked_work_runs_7d,
+           (SELECT would_have_blocked_runs_7d FROM work_value) AS would_have_blocked_runs_7d,
+           (SELECT calendar_conflicts_7d FROM calendar_value) AS calendar_conflicts_7d,
+           ((SELECT blocked_work_runs_7d FROM work_value) + (SELECT calendar_conflicts_7d FROM calendar_value))::int AS conflicts_prevented_7d,
+           (SELECT COUNT(*)::int FROM real_activity, window WHERE created_at >= window.starts_at) AS api_calls_7d,
+           (SELECT COUNT(*)::int FROM real_activity, window WHERE status = 'error' AND created_at >= window.starts_at) AS errors_7d,
+           (SELECT MAX(created_at) FROM real_activity) AS latest_real_activity_at,
+           (SELECT verified_at FROM orgs WHERE id = $1) AS verified_at,
+           (SELECT COUNT(*)::int FROM agents WHERE org_id = $1) AS agents_count`,
+        [authReq.org.id],
+      ),
+      pool.query(
+        `WITH real_activity AS (
+           SELECT *
+           FROM agent_activity_events
+           WHERE org_id = $1
+             AND ${REAL_ACTIVITY_FILTER}
+         ),
+         agent_stats AS (
+           SELECT
+             agents.id AS agent_id,
+             agents.name,
+             agents.last_seen_at,
+             agents.mcp_last_seen_at,
+             (SELECT MAX(created_at) FROM real_activity WHERE agent_id = agents.id) AS last_activity_at,
+             (SELECT MAX(created_at) FROM real_activity WHERE agent_id = agents.id AND status = 'success') AS last_success_at,
+             (SELECT MAX(created_at) FROM real_activity WHERE agent_id = agents.id AND status = 'error') AS last_error_at,
+             (
+               SELECT error_code
+               FROM real_activity
+               WHERE agent_id = agents.id
+                 AND status = 'error'
+               ORDER BY created_at DESC
+               LIMIT 1
+             ) AS last_error_code
+           FROM agents
+           WHERE agents.org_id = $1
+         )
+         SELECT
+           agent_id,
+           name,
+           last_seen_at,
+           last_activity_at,
+           last_success_at,
+           last_error_at,
+           last_error_code,
+           CASE
+             WHEN mcp_last_seen_at IS NULL THEN 'offline'
+             WHEN mcp_last_seen_at > NOW() - INTERVAL '2 minutes' THEN 'online'
+             WHEN mcp_last_seen_at > NOW() - INTERVAL '15 minutes' THEN 'recent'
+             ELSE 'offline'
+           END AS mcp_status,
+           CASE
+             WHEN last_error_at IS NOT NULL AND (last_success_at IS NULL OR last_error_at > last_success_at) THEN 'error'
+             WHEN last_activity_at IS NULL AND mcp_last_seen_at IS NULL AND last_seen_at IS NULL THEN 'never_connected'
+             WHEN GREATEST(COALESCE(last_activity_at, 'epoch'::timestamptz), COALESCE(mcp_last_seen_at, 'epoch'::timestamptz), COALESCE(last_seen_at, 'epoch'::timestamptz)) < NOW() - INTERVAL '3 days' THEN 'quiet'
+             ELSE 'healthy'
+           END AS status
+         FROM agent_stats
+         ORDER BY
+           CASE
+             WHEN last_error_at IS NOT NULL AND (last_success_at IS NULL OR last_error_at > last_success_at) THEN 0
+             WHEN last_activity_at IS NULL AND mcp_last_seen_at IS NULL AND last_seen_at IS NULL THEN 1
+             WHEN GREATEST(COALESCE(last_activity_at, 'epoch'::timestamptz), COALESCE(mcp_last_seen_at, 'epoch'::timestamptz), COALESCE(last_seen_at, 'epoch'::timestamptz)) < NOW() - INTERVAL '3 days' THEN 2
+             ELSE 3
+           END,
+           name ASC`,
+        [authReq.org.id],
+      ),
+    ]);
+
+    const summaryRow = summary.rows[0];
+    const quietAgents = agents.rows.filter((agent) => agent.status === 'quiet').length;
+    const neverConnectedAgents = agents.rows.filter((agent) => agent.status === 'never_connected').length;
+
+    return res.json({
+      window: {
+        starts_at: summaryRow.starts_at.toISOString(),
+        ends_at: summaryRow.ends_at.toISOString(),
+        days: 7,
+      },
+      summary: {
+        conflicts_prevented_7d: summaryRow.conflicts_prevented_7d,
+        blocked_work_runs_7d: summaryRow.blocked_work_runs_7d,
+        would_have_blocked_runs_7d: summaryRow.would_have_blocked_runs_7d,
+        calendar_conflicts_7d: summaryRow.calendar_conflicts_7d,
+        api_calls_7d: summaryRow.api_calls_7d,
+        errors_7d: summaryRow.errors_7d,
+        latest_real_activity_at: summaryRow.latest_real_activity_at?.toISOString() ?? null,
+      },
+      agent_health: agents.rows.map((agent) => ({
+        agent_id: agent.agent_id,
+        name: agent.name,
+        status: agent.status,
+        last_seen_at: agent.last_seen_at?.toISOString() ?? null,
+        last_activity_at: agent.last_activity_at?.toISOString() ?? null,
+        last_success_at: agent.last_success_at?.toISOString() ?? null,
+        last_error_at: agent.last_error_at?.toISOString() ?? null,
+        last_error_code: agent.last_error_code ?? null,
+        mcp_status: agent.mcp_status,
+      })),
+      next_best_action: nextBestAction({
+        verified_at: summaryRow.verified_at,
+        agents_count: summaryRow.agents_count,
+        latest_real_activity_at: summaryRow.latest_real_activity_at,
+        errors_7d: summaryRow.errors_7d,
+        quiet_agents: quietAgents,
+        never_connected_agents: neverConnectedAgents,
+      }),
+    });
+  } catch (err) {
+    log.error('[value] health error', { error: (err as Error).message });
+    return res.status(500).json({ error: 'internal_error', message: 'An unexpected error occurred' });
+  }
+});
+
+export default router;

package/src/routes/waitlist.ts

@@ -0,0 +1,63 @@
+import express from 'express';
+import { z } from 'zod';
+import pool from '../db/client';
+import { authenticateWorkspaceSession } from '../middleware/auth';
+import { log } from '../lib/logger';
+
+const router = express.Router();
+
+const WaitlistCreateSchema = z.object({
+  email: z.string().trim().email().max(240),
+  plan: z.enum(['individual', 'team']),
+  source: z.enum(['pricing', 'settings', 'checkout', 'plan_limit', 'other']).optional().default('pricing'),
+  message: z.string().trim().max(1000).optional().default(''),
+  context: z.record(z.string(), z.unknown()).optional(),
+});
+
+router.post('/waitlist', async (req, res) => {
+  const parsed = WaitlistCreateSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: 'validation_error', details: parsed.error.flatten() });
+  }
+
+  try {
+    const workspace = await authenticateWorkspaceSession(req);
+    const context = {
+      source: 'paid_plan_waitlist',
+      submitted_path: typeof parsed.data.context?.path === 'string' ? parsed.data.context.path : undefined,
+      app_url: typeof parsed.data.context?.app_url === 'string' ? parsed.data.context.app_url : undefined,
+      user_agent: req.header('user-agent')?.slice(0, 240),
+    };
+
+    const result = await pool.query(
+      `INSERT INTO paid_plan_waitlist (
+         org_id,
+         user_id,
+         email,
+         plan,
+         source,
+         message,
+         context
+       )
+       VALUES ($1, $2, $3, $4, $5, $6, $7)
+       RETURNING id, org_id, user_id, email, plan, source, message, status, context, created_at, updated_at`,
+      [
+        workspace?.org.id ?? null,
+        workspace?.user.id ?? null,
+        parsed.data.email,
+        parsed.data.plan,
+        parsed.data.source,
+        parsed.data.message,
+        JSON.stringify(context),
+      ],
+    );
+
+    return res.status(201).json({ lead: result.rows[0] });
+  } catch (err) {
+    log.error('[waitlist] create lead error', { error: (err as Error).message });
+    return res.status(500).json({ error: 'internal_error', message: 'An unexpected error occurred' });
+  }
+});
+
+export default router;
+