availsync 0.1.0

package/src/lib/activity.ts

@@ -0,0 +1,137 @@
+import type { AgentAuthenticatedRequest, AnyAuthenticatedRequest, WorkspaceAuthenticatedRequest } from '../middleware/auth';
+import { isAgentAuth } from '../middleware/auth';
+import pool from '../db/client';
+import { log } from './logger';
+import { getPlanConfig, getOrgPlan } from './plans';
+
+export type ActivityStatus = 'success' | 'error';
+
+export type ActivityInput = {
+  org_id?: string | null;
+  agent_id?: string | null;
+  activity_type: string;
+  endpoint?: string | null;
+  method?: string | null;
+  status_code?: number | null;
+  status?: ActivityStatus;
+  actor_type?: string | null;
+  actor_id?: string | null;
+  actor_label?: string | null;
+  client_name?: string | null;
+  latency_ms?: number | null;
+  error_code?: string | null;
+  error_message?: string | null;
+  provider?: string | null;
+  model?: string | null;
+  input_tokens?: number | null;
+  output_tokens?: number | null;
+  total_tokens?: number | null;
+  estimated_cost_usd?: number | null;
+  metadata?: Record<string, unknown>;
+};
+
+export function actorFromAuth(req: AnyAuthenticatedRequest) {
+  if (isAgentAuth(req)) {
+    return {
+      actor_type: 'agent',
+      actor_id: req.agent.id,
+      actor_label: req.agent.name,
+    };
+  }
+
+  return {
+    actor_type: 'workspace',
+    actor_id: req.user.id,
+    actor_label: req.user.email,
+  };
+}
+
+export function agentActor(req: AgentAuthenticatedRequest) {
+  return {
+    actor_type: 'agent',
+    actor_id: req.agent.id,
+    actor_label: req.agent.name,
+  };
+}
+
+export function workspaceActor(req: WorkspaceAuthenticatedRequest) {
+  return {
+    actor_type: 'workspace',
+    actor_id: req.user.id,
+    actor_label: req.user.email,
+  };
+}
+
+export async function logActivity(input: ActivityInput): Promise<void> {
+  try {
+    await pool.query(
+      `INSERT INTO agent_activity_events (
+         org_id,
+         agent_id,
+         activity_type,
+         endpoint,
+         method,
+         status_code,
+         status,
+         actor_type,
+         actor_id,
+         actor_label,
+         client_name,
+         latency_ms,
+         error_code,
+         error_message,
+         provider,
+         model,
+         input_tokens,
+         output_tokens,
+         total_tokens,
+         estimated_cost_usd,
+         metadata
+       )
+       VALUES (
+         $1, $2, $3, $4, $5, $6, $7, $8, $9, $10,
+         $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21
+       )`,
+      [
+        input.org_id ?? null,
+        input.agent_id ?? null,
+        input.activity_type,
+        input.endpoint ?? null,
+        input.method ?? null,
+        input.status_code ?? null,
+        input.status ?? 'success',
+        input.actor_type ?? null,
+        input.actor_id ?? null,
+        input.actor_label ?? null,
+        input.client_name ?? null,
+        input.latency_ms ?? null,
+        input.error_code ?? null,
+        input.error_message ?? null,
+        input.provider ?? null,
+        input.model ?? null,
+        input.input_tokens ?? null,
+        input.output_tokens ?? null,
+        input.total_tokens ?? null,
+        input.estimated_cost_usd ?? null,
+        JSON.stringify(input.metadata ?? {}),
+      ],
+    );
+
+    if (input.org_id) {
+      const plan = await getOrgPlan(input.org_id);
+      const retentionDays = getPlanConfig(plan).limits.activity_retention_days;
+      await pool.query(
+        `DELETE FROM agent_activity_events
+         WHERE org_id = $1
+           AND created_at < NOW() - ($2::text::interval)`,
+        [input.org_id, `${retentionDays} days`],
+      );
+    }
+  } catch (err) {
+    log.warn('[activity] failed to write activity event', { error: (err as Error).message });
+  }
+}
+
+export function durationSince(startedAt: number): number {
+  return Math.max(0, Date.now() - startedAt);
+}

package/src/lib/apiKeys.ts

@@ -0,0 +1,32 @@
+import { randomBytes } from 'crypto';
+import bcrypt from 'bcrypt';
+
+export const AGENT_API_KEY_PREFIX = 'avs_live';
+
+const PREFIX_BYTES = 8;
+const SECRET_BYTES = 32;
+const AGENT_API_KEY_PATTERN = /^avs_live_([a-f0-9]{16})_[a-f0-9]{64}$/;
+
+function urlSafeToken(bytes: number) {
+  return randomBytes(bytes).toString('hex');
+}
+
+export function parseAgentApiKey(token: string): { prefix: string } | null {
+  const match = AGENT_API_KEY_PATTERN.exec(token);
+  if (!match) return null;
+  return { prefix: match[1] };
+}
+
+export async function createAgentApiKey() {
+  const prefix = urlSafeToken(PREFIX_BYTES);
+  const secret = urlSafeToken(SECRET_BYTES);
+  const apiKey = `${AGENT_API_KEY_PREFIX}_${prefix}_${secret}`;
+  const saltRounds = Number.parseInt(process.env.API_KEY_SALT_ROUNDS || '10', 10);
+  const apiKeyHash = await bcrypt.hash(apiKey, saltRounds);
+
+  return {
+    apiKey,
+    apiKeyHash,
+    apiKeyPrefix: prefix,
+  };
+}

package/src/lib/appInfo.ts

@@ -0,0 +1,26 @@
+import fs from 'fs';
+import path from 'path';
+
+let cachedVersion: string | null = null;
+
+export function appVersion() {
+  if (cachedVersion) return cachedVersion;
+  try {
+    const packagePath = path.resolve(process.cwd(), 'package.json');
+    const parsed = JSON.parse(fs.readFileSync(packagePath, 'utf8')) as { version?: string };
+    cachedVersion = parsed.version || '0.0.0';
+  } catch {
+    cachedVersion = '0.0.0';
+  }
+  return cachedVersion;
+}
+
+export function gitCommit() {
+  return (
+    process.env.GIT_COMMIT ||
+    process.env.COOLIFY_COMMIT_SHA ||
+    process.env.COOLIFY_COMMIT ||
+    process.env.VERCEL_GIT_COMMIT_SHA ||
+    'unknown'
+  );
+}

package/src/lib/billingConfig.ts

@@ -0,0 +1,3 @@
+export function billingUpgradesEnabled() {
+  return process.env.BILLING_UPGRADES_ENABLED === 'true' || process.env.NEXT_PUBLIC_BILLING_UPGRADES_ENABLED === 'true';
+}

package/src/lib/env.ts

@@ -0,0 +1,75 @@
+import { billingUpgradesEnabled } from './billingConfig';
+
+export type EnvCheck = {
+  name: string;
+  required: boolean;
+  configured: boolean;
+};
+
+const baseRequired = ['DATABASE_URL', 'API_KEY_SALT_ROUNDS', 'SESSION_SECRET'] as const;
+const productionOnlyRequired = [
+  'APP_URL',
+  'CORS_ORIGINS',
+  'ADMIN_EMAILS',
+] as const;
+const billingRequired = [
+  'STRIPE_SECRET_KEY',
+  'STRIPE_WEBHOOK_SECRET',
+  'STRIPE_PRICE_INDIVIDUAL',
+  'STRIPE_PRICE_TEAM',
+] as const;
+
+export function requiredEnvNames(isProduction = process.env.NODE_ENV === 'production') {
+  if (!isProduction) return [...baseRequired];
+  return billingUpgradesEnabled()
+    ? [...baseRequired, ...productionOnlyRequired, ...billingRequired]
+    : [...baseRequired, ...productionOnlyRequired];
+}
+
+export function envReadiness(isProduction = process.env.NODE_ENV === 'production'): {
+  mode: string;
+  required: EnvCheck[];
+  optional: EnvCheck[];
+  missing: string[];
+  ok: boolean;
+} {
+  const requiredNames = requiredEnvNames(isProduction);
+  const optionalNames = [
+    'PORT',
+    'BILLING_UPGRADES_ENABLED',
+    'NEXT_PUBLIC_BILLING_UPGRADES_ENABLED',
+    ...billingRequired,
+    ...(isProduction ? [] : productionOnlyRequired),
+  ] as string[];
+  const required = requiredNames.map((name) => ({
+    name,
+    required: true,
+    configured: Boolean(process.env[name]),
+  }));
+  const optional = optionalNames
+    .filter((name, index, list) => list.indexOf(name) === index && !requiredNames.includes(name as never))
+    .map((name) => ({
+      name,
+      required: false,
+      configured: Boolean(process.env[name]),
+    }));
+  const missing = required.filter((item) => !item.configured).map((item) => item.name);
+
+  return {
+    mode: isProduction ? 'production' : process.env.NODE_ENV || 'development',
+    required,
+    optional,
+    missing,
+    ok: missing.length === 0,
+  };
+}
+
+export function stripeReadiness() {
+  return {
+    billing_upgrades_enabled: billingUpgradesEnabled(),
+    configured: Boolean(process.env.STRIPE_SECRET_KEY),
+    webhook_configured: Boolean(process.env.STRIPE_WEBHOOK_SECRET),
+    individual_price_configured: Boolean(process.env.STRIPE_PRICE_INDIVIDUAL),
+    team_price_configured: Boolean(process.env.STRIPE_PRICE_TEAM),
+  };
+}

package/src/lib/logger.ts

@@ -0,0 +1,8 @@
+export const log = {
+  info: (msg: string, meta?: object) =>
+    console.log(JSON.stringify({ level: 'info', msg, ...meta, ts: new Date().toISOString() })),
+  error: (msg: string, meta?: object) =>
+    console.error(JSON.stringify({ level: 'error', msg, ...meta, ts: new Date().toISOString() })),
+  warn: (msg: string, meta?: object) =>
+    console.warn(JSON.stringify({ level: 'warn', msg, ...meta, ts: new Date().toISOString() })),
+};

package/src/lib/plans.ts

@@ -0,0 +1,204 @@
+import type { Response } from 'express';
+import type { Pool, PoolClient } from 'pg';
+import pool from '../db/client';
+import { log } from './logger';
+import { billingUpgradesEnabled } from './billingConfig';
+import { requestIdFrom } from '../middleware/requestId';
+
+export type PlanId = 'free' | 'individual' | 'team';
+export type LimitType = 'agents' | 'protected_resources' | 'active_work_claims' | 'api_calls_month';
+
+export type PlanLimits = {
+  agents: number | null;
+  protected_resources: number;
+  active_work_claims: number;
+  api_calls_month: number;
+  activity_retention_days: number;
+};
+
+export const PLAN_CONFIG: Record<PlanId, {
+  id: PlanId;
+  name: string;
+  monthly_price_usd: number;
+  stripe_price_env?: string;
+  db_agent_limit: number;
+  limits: PlanLimits;
+}> = {
+  free: {
+    id: 'free',
+    name: 'Free',
+    monthly_price_usd: 0,
+    db_agent_limit: 3,
+    limits: {
+      agents: 3,
+      protected_resources: 2,
+      active_work_claims: 1,
+      api_calls_month: 1000,
+      activity_retention_days: 7,
+    },
+  },
+  individual: {
+    id: 'individual',
+    name: 'Individual',
+    monthly_price_usd: 10,
+    stripe_price_env: 'STRIPE_PRICE_INDIVIDUAL',
+    db_agent_limit: 15,
+    limits: {
+      agents: 15,
+      protected_resources: 10,
+      active_work_claims: 5,
+      api_calls_month: 25000,
+      activity_retention_days: 30,
+    },
+  },
+  team: {
+    id: 'team',
+    name: 'Team',
+    monthly_price_usd: 25,
+    stripe_price_env: 'STRIPE_PRICE_TEAM',
+    db_agent_limit: 9999,
+    limits: {
+      agents: null,
+      protected_resources: 100,
+      active_work_claims: 25,
+      api_calls_month: 250000,
+      activity_retention_days: 90,
+    },
+  },
+};
+
+export function parsePlan(plan: string | null | undefined): PlanId {
+  return plan === 'individual' || plan === 'team' ? plan : 'free';
+}
+
+export function getPlanConfig(plan: string | null | undefined) {
+  return PLAN_CONFIG[parsePlan(plan)];
+}
+
+export function paidPlanIds(): Array<Exclude<PlanId, 'free'>> {
+  return ['individual', 'team'];
+}
+
+export function upgradePlanFor(limitType: LimitType, currentPlan: PlanId): Exclude<PlanId, 'free'> | null {
+  if (currentPlan === 'free') return 'individual';
+  if (currentPlan === 'individual') return 'team';
+  return null;
+}
+
+export function serializableLimits(plan: string | null | undefined) {
+  return getPlanConfig(plan).limits;
+}
+
+export async function applyPlanToOrg(db: Pool | PoolClient, orgId: string, plan: PlanId) {
+  const config = PLAN_CONFIG[plan];
+  await db.query(
+    `UPDATE orgs
+     SET plan = $1,
+         agent_limit = $2
+     WHERE id = $3`,
+    [plan, config.db_agent_limit, orgId],
+  );
+}
+
+export async function getOrgPlan(orgId: string, db: Pool | PoolClient = pool): Promise<PlanId> {
+  const result = await db.query('SELECT plan FROM orgs WHERE id = $1', [orgId]);
+  return parsePlan(result.rows[0]?.plan);
+}
+
+export async function getPlanUsage(orgId: string, db: Pool | PoolClient = pool) {
+  const result = await db.query(
+    `SELECT
+       (SELECT COUNT(*)::int FROM agents WHERE org_id = $1) AS agents,
+       (SELECT COUNT(*)::int FROM work_resources WHERE org_id = $1) AS protected_resources,
+       (SELECT COUNT(*)::int FROM work_claims WHERE org_id = $1 AND status = 'active' AND expires_at >= NOW()) AS active_work_claims,
+       (SELECT COUNT(*)::int FROM agent_activity_events WHERE org_id = $1 AND created_at >= date_trunc('month', NOW())) AS api_calls_month`,
+    [orgId],
+  );
+  return result.rows[0] as {
+    agents: number;
+    protected_resources: number;
+    active_work_claims: number;
+    api_calls_month: number;
+  };
+}
+
+export function planLimitPayload(input: {
+  plan: PlanId;
+  limit_type: LimitType;
+  limit: number | null;
+  usage: number;
+}) {
+  const upgradePlan = upgradePlanFor(input.limit_type, input.plan);
+  const readable = input.limit_type.replaceAll('_', ' ');
+  const upgradesEnabled = billingUpgradesEnabled();
+  return {
+    error: 'plan_limit_reached',
+    limit_type: input.limit_type,
+    plan: input.plan,
+    limit: input.limit,
+    usage: input.usage,
+    upgrade_plan: upgradePlan,
+    message: upgradePlan
+      ? upgradesEnabled
+        ? `Your ${input.plan} plan has reached the ${readable} limit. Upgrade to ${upgradePlan} to continue.`
+        : `Your ${input.plan} plan has reached the ${readable} limit. Paid plans are currently waitlist-only.`
+      : `Your ${input.plan} plan has reached the ${readable} limit.`,
+  };
+}
+
+export async function enforcePlanLimit(input: {
+  org_id: string;
+  limit_type: LimitType;
+  increment?: number;
+  usage_override?: number;
+  db?: Pool | PoolClient;
+  res: Response;
+}): Promise<boolean> {
+  const db = input.db ?? pool;
+  const plan = await getOrgPlan(input.org_id, db);
+  const config = PLAN_CONFIG[plan];
+  const limit = config.limits[input.limit_type];
+  if (limit === null) return true;
+
+  const usage =
+    input.usage_override ??
+    (await getPlanUsage(input.org_id, db))[input.limit_type === 'api_calls_month' ? 'api_calls_month' : input.limit_type];
+  const nextUsage = usage + (input.increment ?? 1);
+  if (nextUsage <= limit) return true;
+
+  const payload = planLimitPayload({
+    plan,
+    limit_type: input.limit_type,
+    limit,
+    usage,
+  });
+  log.warn('[plan] limit reached', {
+    request_id: requestIdFrom(input.res),
+    org_id: input.org_id,
+    limit_type: input.limit_type,
+    plan,
+    limit,
+    usage,
+  });
+  input.res.status(402).json({ ...payload, request_id: requestIdFrom(input.res) });
+  return false;
+}
+
+export function upgradeReasons(plan: PlanId, usage: Awaited<ReturnType<typeof getPlanUsage>>) {
+  const limits = PLAN_CONFIG[plan].limits;
+  return (Object.keys(limits) as Array<keyof PlanLimits>)
+    .filter((key) => key !== 'activity_retention_days')
+    .flatMap((key) => {
+      const limit = limits[key];
+      const used = usage[key as keyof typeof usage];
+      if (typeof used !== 'number' || limit === null) return [];
+      if (used < Math.ceil(limit * 0.8)) return [];
+      return [{
+        limit_type: key,
+        usage: used,
+        limit,
+        state: used >= limit ? 'reached' : 'near',
+        upgrade_plan: upgradePlanFor(key as LimitType, plan),
+      }];
+    });
+}

package/src/mcp/server.js

@@ -0,0 +1,5 @@
+require('ts-node/register');
+
+const { main } = require('./server.ts');
+
+main();