availsync 0.1.0

package/src/routes/account.ts

@@ -0,0 +1,168 @@
+import express from 'express';
+import Stripe from 'stripe';
+import { z } from 'zod';
+import pool from '../db/client';
+import {
+  clearWorkspaceSessionCookie,
+  requireWorkspaceSession,
+  type WorkspaceAuthenticatedRequest,
+} from '../middleware/auth';
+import { requestIdFrom } from '../middleware/requestId';
+import { log } from '../lib/logger';
+
+const router = express.Router();
+
+const DeleteWorkspaceSchema = z.object({
+  confirmation: z.literal('DELETE'),
+});
+
+const terminalSubscriptionStatuses = new Set(['canceled', 'incomplete_expired']);
+
+function getStripe(secret: string) {
+  return new Stripe(secret);
+}
+
+async function cancelStripeSubscription(subscriptionId: string) {
+  const secret = process.env.STRIPE_SECRET_KEY;
+  if (!secret) {
+    return {
+      ok: false as const,
+      status: 501,
+      body: {
+        error: 'billing_not_configured',
+        message: 'Stripe must be configured before deleting a workspace with an active subscription.',
+      },
+    };
+  }
+
+  try {
+    const stripe = getStripe(secret);
+    await stripe.subscriptions.cancel(subscriptionId);
+    return { ok: true as const };
+  } catch (err) {
+    const stripeError = err as { code?: string; message?: string };
+    if (stripeError.code === 'resource_missing') {
+      log.warn('[account] Stripe subscription missing during workspace delete', {
+        subscription_id: subscriptionId,
+      });
+      return { ok: true as const };
+    }
+
+    log.error('[account] Stripe subscription cancellation failed', {
+      subscription_id: subscriptionId,
+      error: stripeError.message,
+    });
+    return {
+      ok: false as const,
+      status: 502,
+      body: {
+        error: 'stripe_cancellation_failed',
+        message: 'Could not cancel the active Stripe subscription. Try again or contact support.',
+      },
+    };
+  }
+}
+
+router.delete('/account/workspace', requireWorkspaceSession, async (req, res) => {
+  const parsed = DeleteWorkspaceSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(422).json({
+      error: 'validation_error',
+      message: 'Type DELETE to confirm permanent workspace deletion.',
+      details: parsed.error.flatten(),
+    });
+  }
+
+  const authReq = req as WorkspaceAuthenticatedRequest;
+  const orgId = authReq.org.id;
+
+  try {
+    const orgResult = await pool.query<{
+      id: string;
+      stripe_subscription_id: string | null;
+      subscription_status: string | null;
+    }>(
+      `SELECT id, stripe_subscription_id, subscription_status
+       FROM orgs
+       WHERE id = $1`,
+      [orgId],
+    );
+
+    const org = orgResult.rows[0];
+    if (!org) {
+      clearWorkspaceSessionCookie(res);
+      return res.status(404).json({ error: 'org_not_found', message: 'Workspace not found' });
+    }
+
+    if (org.stripe_subscription_id && !terminalSubscriptionStatuses.has(org.subscription_status ?? '')) {
+      const cancellation = await cancelStripeSubscription(org.stripe_subscription_id);
+      if (!cancellation.ok) {
+        return res.status(cancellation.status).json({
+          ...cancellation.body,
+          request_id: requestIdFrom(res),
+        });
+      }
+    }
+
+    const client = await pool.connect();
+    try {
+      await client.query('BEGIN');
+
+      await client.query(
+        `DELETE FROM workspace_sessions
+         USING workspace_users
+         WHERE workspace_sessions.user_id = workspace_users.id
+           AND workspace_users.org_id = $1`,
+        [orgId],
+      );
+      await client.query('DELETE FROM hold_events WHERE org_id = $1', [orgId]);
+      await client.query('DELETE FROM work_claim_events WHERE org_id = $1', [orgId]);
+      await client.query('DELETE FROM holds WHERE org_id = $1', [orgId]);
+      await client.query('DELETE FROM work_claims WHERE org_id = $1', [orgId]);
+      await client.query('DELETE FROM work_resources WHERE org_id = $1', [orgId]);
+      await client.query('DELETE FROM agent_activity_events WHERE org_id = $1', [orgId]);
+      await client.query('DELETE FROM conflict_rules WHERE org_id = $1', [orgId]);
+      await client.query('DELETE FROM support_tickets WHERE org_id = $1', [orgId]);
+      await client.query(
+        `DELETE FROM paid_plan_waitlist
+         WHERE org_id = $1
+            OR user_id = $2
+            OR lower(email) = lower($3)`,
+        [orgId, authReq.user.id, authReq.user.email],
+      );
+      await client.query('DELETE FROM agents WHERE org_id = $1', [orgId]);
+      await client.query('DELETE FROM workspace_users WHERE org_id = $1', [orgId]);
+      await client.query('DELETE FROM orgs WHERE id = $1', [orgId]);
+
+      await client.query('COMMIT');
+    } catch (err) {
+      await client.query('ROLLBACK').catch(() => {});
+      throw err;
+    } finally {
+      client.release();
+    }
+
+    clearWorkspaceSessionCookie(res);
+    log.info('[account] workspace deleted', {
+      request_id: requestIdFrom(res),
+      org_id: orgId,
+      user_id: authReq.user.id,
+      canceled_subscription: Boolean(org.stripe_subscription_id),
+    });
+
+    return res.json({ ok: true });
+  } catch (err) {
+    log.error('[account] workspace delete error', {
+      request_id: requestIdFrom(res),
+      org_id: orgId,
+      error: (err as Error).message,
+    });
+    return res.status(500).json({
+      error: 'internal_error',
+      message: 'Could not delete the workspace. Try again or contact support.',
+      request_id: requestIdFrom(res),
+    });
+  }
+});
+
+export default router;

package/src/routes/activity.ts

@@ -0,0 +1,126 @@
+import express from 'express';
+import { z } from 'zod';
+import pool from '../db/client';
+import { log } from '../lib/logger';
+import { agentActor, logActivity } from '../lib/activity';
+import { enforcePlanLimit } from '../lib/plans';
+import {
+  requireAgentKey,
+  requireWorkspaceSession,
+  type AgentAuthenticatedRequest,
+  type WorkspaceAuthenticatedRequest,
+} from '../middleware/auth';
+
+const router = express.Router();
+
+const ActivityQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(200).optional().default(50),
+  offset: z.coerce.number().int().min(0).optional().default(0),
+  agent_id: z.string().uuid().optional(),
+  activity_type: z.string().max(80).optional(),
+  status: z.enum(['success', 'error']).optional(),
+  from: z.string().datetime({ offset: true }).optional(),
+  to: z.string().datetime({ offset: true }).optional(),
+});
+
+const UsageSchema = z.object({
+  activity_type: z.string().min(1).max(80).optional().default('agent_run'),
+  provider: z.string().max(80).optional(),
+  model: z.string().max(120).optional(),
+  input_tokens: z.number().int().min(0).optional(),
+  output_tokens: z.number().int().min(0).optional(),
+  total_tokens: z.number().int().min(0).optional(),
+  estimated_cost_usd: z.number().min(0).optional(),
+  client_name: z.string().max(100).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+router.get('/activity', requireWorkspaceSession, async (req, res) => {
+  const parsed = ActivityQuerySchema.safeParse(req.query);
+  if (!parsed.success) {
+    return res.status(400).json({ error: 'validation_error', details: parsed.error.flatten() });
+  }
+
+  const authReq = req as WorkspaceAuthenticatedRequest;
+
+  try {
+    const result = await pool.query(
+      `SELECT
+         agent_activity_events.*,
+         agents.name AS agent_name
+       FROM agent_activity_events
+       LEFT JOIN agents ON agents.id = agent_activity_events.agent_id
+       WHERE agent_activity_events.org_id = $1
+         AND ($4::uuid IS NULL OR agent_activity_events.agent_id = $4)
+         AND ($5::text IS NULL OR agent_activity_events.activity_type = $5)
+         AND ($6::text IS NULL OR agent_activity_events.status = $6)
+         AND ($7::timestamptz IS NULL OR agent_activity_events.created_at >= $7)
+         AND ($8::timestamptz IS NULL OR agent_activity_events.created_at < $8)
+       ORDER BY agent_activity_events.created_at DESC
+       LIMIT $2 OFFSET $3`,
+      [
+        authReq.org.id,
+        parsed.data.limit,
+        parsed.data.offset,
+        parsed.data.agent_id ?? null,
+        parsed.data.activity_type ?? null,
+        parsed.data.status ?? null,
+        parsed.data.from ? new Date(parsed.data.from) : null,
+        parsed.data.to ? new Date(parsed.data.to) : null,
+      ],
+    );
+
+    return res.json({
+      events: result.rows,
+      limit: parsed.data.limit,
+      offset: parsed.data.offset,
+      count: result.rows.length,
+    });
+  } catch (err) {
+    log.error('[activity] unexpected error', { error: (err as Error).message });
+    return res.status(500).json({ error: 'internal_error', message: 'An unexpected error occurred' });
+  }
+});
+
+router.post('/activity/usage', requireAgentKey, async (req, res) => {
+  const parsed = UsageSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(422).json({ error: 'validation_error', details: parsed.error.flatten() });
+  }
+
+  const authReq = req as AgentAuthenticatedRequest;
+  if (!(await enforcePlanLimit({
+    org_id: authReq.org.id,
+    limit_type: 'api_calls_month',
+    res,
+  }))) {
+    return;
+  }
+
+  const totalTokens =
+    parsed.data.total_tokens ??
+    ((parsed.data.input_tokens ?? 0) + (parsed.data.output_tokens ?? 0) || undefined);
+
+  await logActivity({
+    org_id: authReq.org.id,
+    agent_id: authReq.agent.id,
+    activity_type: parsed.data.activity_type,
+    endpoint: '/v1/activity/usage',
+    method: 'POST',
+    status_code: 201,
+    status: 'success',
+    ...agentActor(authReq),
+    client_name: parsed.data.client_name ?? null,
+    provider: parsed.data.provider ?? null,
+    model: parsed.data.model ?? null,
+    input_tokens: parsed.data.input_tokens ?? null,
+    output_tokens: parsed.data.output_tokens ?? null,
+    total_tokens: totalTokens ?? null,
+    estimated_cost_usd: parsed.data.estimated_cost_usd ?? null,
+    metadata: parsed.data.metadata ?? {},
+  });
+
+  return res.status(201).json({ ok: true });
+});
+
+export default router;