availsync 0.1.0

package/frontend/lib/billing.ts

@@ -0,0 +1,6 @@
+export function billingUpgradesEnabled() {
+  return process.env.NEXT_PUBLIC_BILLING_UPGRADES_ENABLED === 'true';
+}
+
+export const PAID_PLAN_WAITLIST_HREF =
+  '/pricing#waitlist';

package/frontend/lib/cookieConsent.ts

@@ -0,0 +1,113 @@
+'use client';
+
+export const COOKIE_CONSENT_VERSION = 1;
+export const COOKIE_CONSENT_NAME = 'availsync_cookie_consent';
+const SIX_MONTHS_SECONDS = 60 * 60 * 24 * 183;
+
+export type OptionalConsentCategory = 'analytics' | 'marketing';
+
+export type CookieConsent = {
+  version: number;
+  decided_at: string;
+  categories: {
+    necessary: true;
+    analytics: boolean;
+    marketing: boolean;
+  };
+};
+
+const CONSENT_CHANGED_EVENT = 'availsync:cookie-consent-changed';
+export const OPEN_COOKIE_SETTINGS_EVENT = 'availsync:open-cookie-settings';
+
+function canUseDocument() {
+  return typeof document !== 'undefined';
+}
+
+function consentCookieAttributes() {
+  const secure = typeof window !== 'undefined' && window.location.protocol === 'https:' ? '; Secure' : '';
+  return `Path=/; Max-Age=${SIX_MONTHS_SECONDS}; SameSite=Lax${secure}`;
+}
+
+function createConsent(analytics: boolean, marketing: boolean): CookieConsent {
+  return {
+    version: COOKIE_CONSENT_VERSION,
+    decided_at: new Date().toISOString(),
+    categories: {
+      necessary: true,
+      analytics,
+      marketing,
+    },
+  };
+}
+
+export function getCookieConsent(): CookieConsent | null {
+  if (!canUseDocument()) return null;
+
+  const prefix = `${COOKIE_CONSENT_NAME}=`;
+  const raw = document.cookie
+    .split(';')
+    .map((value) => value.trim())
+    .find((value) => value.startsWith(prefix));
+
+  if (!raw) return null;
+
+  try {
+    const parsed = JSON.parse(decodeURIComponent(raw.slice(prefix.length))) as CookieConsent;
+    if (parsed.version !== COOKIE_CONSENT_VERSION) return null;
+    if (parsed.categories?.necessary !== true) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+export function setCookieConsent(input: {
+  analytics: boolean;
+  marketing: boolean;
+}): CookieConsent {
+  const consent = createConsent(input.analytics, input.marketing);
+
+  if (canUseDocument()) {
+    document.cookie = `${COOKIE_CONSENT_NAME}=${encodeURIComponent(JSON.stringify(consent))}; ${consentCookieAttributes()}`;
+    window.dispatchEvent(new CustomEvent(CONSENT_CHANGED_EVENT, { detail: consent }));
+  }
+
+  return consent;
+}
+
+export function clearCookieConsent() {
+  if (!canUseDocument()) return;
+  document.cookie = `${COOKIE_CONSENT_NAME}=; Path=/; Max-Age=0; SameSite=Lax`;
+  window.dispatchEvent(new CustomEvent(CONSENT_CHANGED_EVENT, { detail: null }));
+}
+
+export function hasConsent(category: OptionalConsentCategory): boolean {
+  return getCookieConsent()?.categories[category] === true;
+}
+
+export function subscribeCookieConsent(
+  listener: (consent: CookieConsent | null) => void,
+): () => void {
+  if (typeof window === 'undefined') return () => {};
+
+  const handler = (event: Event) => {
+    listener((event as CustomEvent<CookieConsent | null>).detail ?? getCookieConsent());
+  };
+
+  window.addEventListener(CONSENT_CHANGED_EVENT, handler);
+  return () => window.removeEventListener(CONSENT_CHANGED_EVENT, handler);
+}
+
+export function runWhenConsent(
+  category: OptionalConsentCategory,
+  callback: () => void,
+): () => void {
+  if (hasConsent(category)) {
+    callback();
+    return () => {};
+  }
+
+  return subscribeCookieConsent((consent) => {
+    if (consent?.categories[category]) callback();
+  });
+}

package/frontend/lib/format.ts

@@ -0,0 +1,16 @@
+export function toLocalInputValue(date: Date): string {
+  const offset = date.getTimezoneOffset();
+  const local = new Date(date.getTime() - offset * 60_000);
+  return local.toISOString().slice(0, 16);
+}
+
+export function fromLocalInputValue(value: string): string {
+  return new Date(value).toISOString();
+}
+
+export function formatDateTime(value: string): string {
+  return new Intl.DateTimeFormat(undefined, {
+    dateStyle: 'medium',
+    timeStyle: 'short',
+  }).format(new Date(value));
+}

package/frontend/lib/plans.ts

@@ -0,0 +1,62 @@
+export const plans = [
+  {
+    id: 'free',
+    name: 'Free',
+    price: '$0',
+    period: '',
+    description: 'For testing Availsync with up to 3 agents.',
+    cta: 'Start free',
+    href: '/signup?plan=free',
+    agentLimit: '3 agents',
+    limits: {
+      agents: 3,
+      protectedResources: 2,
+      activeWorkClaims: 1,
+      apiCallsMonth: 1000,
+      activityRetentionDays: 7,
+    },
+    features: ['3 agents', '2 protected resources', '1 active work claim', 'Node SDK alpha', 'Observe-only pilot mode', '1,000 API calls/month', '7-day pilot history target'],
+  },
+  {
+    id: 'individual',
+    name: 'Individual',
+    price: '$10',
+    period: '/mo',
+    description: 'For solo operators running multiple AI or coding agents.',
+    cta: 'Start individual',
+    href: '/checkout?plan=individual',
+    agentLimit: '15 agents',
+    limits: {
+      agents: 15,
+      protectedResources: 10,
+      activeWorkClaims: 5,
+      apiCallsMonth: 25000,
+      activityRetentionDays: 30,
+    },
+    features: ['15 agents', '10 protected resources', '5 active work claims', 'Node SDK alpha', 'Observe-only pilot mode', '25,000 API calls/month', '30-day pilot history target'],
+  },
+  {
+    id: 'team',
+    name: 'Team',
+    price: '$25',
+    period: '/mo',
+    description: 'For larger agent fleets. Single workspace user for now; multi-user invites are coming later.',
+    cta: 'Start team',
+    href: '/checkout?plan=team',
+    agentLimit: 'Unlimited agents',
+    limits: {
+      agents: null,
+      protectedResources: 100,
+      activeWorkClaims: 25,
+      apiCallsMonth: 250000,
+      activityRetentionDays: 90,
+    },
+    features: ['Unlimited agents', '100 protected resources', '25 active work claims', 'Single workspace user for now', 'Node SDK alpha', 'Observe-only pilot mode', '250,000 API calls/month', '90-day pilot history target'],
+  },
+] as const;
+
+export type PlanId = (typeof plans)[number]['id'];
+
+export function findPlan(planId: string) {
+  return plans.find((plan) => plan.id === planId) ?? plans[0];
+}

package/frontend/lib/schemas.ts

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+
+export const agentTypeSchema = z.enum(['external_meeting', 'internal', 'focus', 'generic']);
+
+export const orgSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  plan: z.enum(['free', 'individual', 'team']),
+  agent_limit: z.number(),
+  verified_at: z.string().nullable().optional(),
+  created_at: z.string(),
+});
+
+export const agentSchema = z.object({
+  id: z.string().uuid(),
+  org_id: z.string().uuid(),
+  name: z.string(),
+  agent_type: agentTypeSchema,
+  priority: z.number(),
+  enforcement_mode: z.enum(['enforce', 'observe']).default('enforce'),
+  last_seen_at: z.string().nullable().optional(),
+  mcp_last_seen_at: z.string().nullable().optional(),
+  mcp_client_name: z.string().nullable().optional(),
+  last_used_at: z.string().nullable().optional(),
+  last_activity_at: z.string().nullable().optional(),
+  last_error_at: z.string().nullable().optional(),
+  last_error_code: z.string().nullable().optional(),
+  created_at: z.string(),
+});
+
+export const holdSchema = z.object({
+  id: z.string().uuid(),
+  agent_id: z.string().uuid(),
+  org_id: z.string().uuid(),
+  start_at: z.string(),
+  end_at: z.string(),
+  reason: z.string().nullable().optional(),
+  status: z.enum(['confirmed', 'superseded', 'released']),
+  booked_by_agent_id: z.string().uuid().nullable().optional(),
+  metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+  created_at: z.string(),
+});
+
+export const slotSchema = z.object({
+  start: z.string(),
+  end: z.string(),
+  confidence: z.number(),
+  competing_holds_count: z.number(),
+});
+
+export const availabilityWindowSchema = z.object({
+  id: z.string().uuid(),
+  agent_id: z.string().uuid(),
+  start_at: z.string(),
+  end_at: z.string(),
+  window_type: z.enum(['available', 'focus', 'blocked']),
+  recurrence: z.string().nullable().optional(),
+});
+
+export const workResourceSchema = z.object({
+  id: z.string().uuid().nullable().optional(),
+  org_id: z.string().uuid().optional(),
+  resource_type: z.enum(['project', 'repo']),
+  resource_key: z.string(),
+  label: z.string(),
+  active_claims_count: z.number().optional(),
+  last_claim_at: z.string().nullable().optional(),
+  created_at: z.string().optional(),
+});
+
+export const workClaimSchema = z.object({
+  id: z.string().uuid(),
+  org_id: z.string().uuid(),
+  agent_id: z.string().uuid(),
+  agent_name: z.string().nullable().optional(),
+  resource_id: z.string().uuid(),
+  resource_type: z.enum(['project', 'repo']).optional(),
+  resource_key: z.string().optional(),
+  resource_label: z.string().nullable().optional(),
+  start_at: z.string(),
+  end_at: z.string(),
+  expires_at: z.string(),
+  last_renewed_at: z.string(),
+  renewal_count: z.number(),
+  seconds_until_expiry: z.number().nullable().optional(),
+  status: z.enum(['active', 'superseded', 'released', 'expired', 'blocked']),
+  reason: z.string().nullable().optional(),
+  metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+  created_at: z.string(),
+});
+
+export const workspaceUserSchema = z.object({
+  id: z.string().uuid(),
+  org_id: z.string().uuid(),
+  email: z.string().email(),
+  role: z.enum(['owner', 'admin']).optional(),
+  created_at: z.string(),
+});
+
+export type AgentType = z.infer<typeof agentTypeSchema>;
+export type Org = z.infer<typeof orgSchema>;
+export type Agent = z.infer<typeof agentSchema>;
+export type Hold = z.infer<typeof holdSchema>;
+export type Slot = z.infer<typeof slotSchema>;
+export type AvailabilityWindow = z.infer<typeof availabilityWindowSchema>;
+export type WorkResource = z.infer<typeof workResourceSchema>;
+export type WorkClaim = z.infer<typeof workClaimSchema>;
+export type WorkspaceUser = z.infer<typeof workspaceUserSchema>;

package/frontend/lib/seo.ts

@@ -0,0 +1,376 @@
+import { plans } from '@/lib/plans';
+import { billingUpgradesEnabled } from '@/lib/billing';
+
+export const siteUrl = (
+  process.env.NEXT_PUBLIC_APP_URL ||
+  process.env.APP_URL ||
+  'https://availsync.dev'
+).replace(/\/$/, '');
+
+export const siteName = 'Availsync';
+
+export const siteDescription =
+  'Availsync gives AI and coding agents one shared place to claim repos and projects before they edit, deploy, schedule work, or run automations.';
+
+export const defaultOgImage = `${siteUrl}/marketing/hero-agent-coordination.png`;
+
+export const publicRoutes = [
+  {
+    path: '/',
+    changeFrequency: 'weekly',
+    priority: 1,
+  },
+  {
+    path: '/pricing',
+    changeFrequency: 'weekly',
+    priority: 0.8,
+  },
+  {
+    path: '/docs',
+    changeFrequency: 'monthly',
+    priority: 0.7,
+  },
+  {
+    path: '/docs/quickstart',
+    changeFrequency: 'weekly',
+    priority: 0.9,
+  },
+  {
+    path: '/docs/sdk/node',
+    changeFrequency: 'weekly',
+    priority: 0.85,
+  },
+  {
+    path: '/docs/api',
+    changeFrequency: 'weekly',
+    priority: 0.8,
+  },
+  {
+    path: '/docs/pilot',
+    changeFrequency: 'weekly',
+    priority: 0.85,
+  },
+  {
+    path: '/docs/reliability',
+    changeFrequency: 'monthly',
+    priority: 0.7,
+  },
+  {
+    path: '/security',
+    changeFrequency: 'monthly',
+    priority: 0.5,
+  },
+  {
+    path: '/privacy',
+    changeFrequency: 'monthly',
+    priority: 0.4,
+  },
+  {
+    path: '/terms',
+    changeFrequency: 'monthly',
+    priority: 0.4,
+  },
+  {
+    path: '/changelog',
+    changeFrequency: 'weekly',
+    priority: 0.55,
+  },
+] as const;
+
+export const faqSchemaItems = [
+  {
+    question: 'Is Availsync a calendar app?',
+    answer:
+      'No. Availsync is a coordination API for agents. It protects repos and projects first, and also supports availability holds for scheduling use cases.',
+  },
+  {
+    question: 'Does Availsync run my agents?',
+    answer:
+      'No. Your agents still run in Codex, Claude, Cursor, MCP, cron, or your server. Availsync is the coordination check they call before acting.',
+  },
+  {
+    question: 'Is Availsync the same as a policy enforcement tool like Sift or PolicyLayer?',
+    answer:
+      'No. Policy tools control what your agents are allowed to do. They sit between an agent and a tool call and ask: is this permitted?\n\nAvailsync controls when your agents can act. It asks: is this window, repo, or resource already claimed by another agent?\n\nAn agent can have full permission to deploy via a policy tool and still be blocked by Availsync because another agent owns that deploy window. They solve different problems and work well together.',
+  },
+  {
+    question: 'Does it stop agents automatically?',
+    answer:
+      'Only agents that call Availsync can be coordinated. Availsync returns proceed, skip_run, or observe-mode decisions; your agent or SDK wrapper must respect that response.',
+  },
+  {
+    question: 'Can coding agents use it?',
+    answer:
+      'Yes. Codex, Claude, Cursor, MCP clients, cron jobs, and server automations can call Availsync before they touch a repo or project.',
+  },
+  {
+    question: 'Can Availsync prevent stale context between agents?',
+    answer:
+      'Yes for the same resource when repo-level claims are used. Availsync does not automatically infer dependencies between different project keys yet.',
+  },
+  {
+    question: 'Do API keys appear again?',
+    answer:
+      'No. The raw key is never shown as text again. During creation you can copy it once, then store it in your agent or server environment.',
+  },
+  {
+    question: 'What happens when two agents want the same resource?',
+    answer:
+      'Availsync applies explicit priority rules, agent type hierarchy, agent priority, then first-created order. The blocked agent gets a clear skip_run response.',
+  },
+  {
+    question: 'What if an agent crashes before releasing its claim?',
+    answer:
+      'Availsync uses leases, not permanent locks. Every work claim has an expiry time, so a crashed agent cannot hold a repo or project forever.\n\nLong-running agents should extend the lease while they work and release it when they finish. The Node SDK withClaim helper does this cleanup in a finally path when a real claim exists.\n\nIf the agent crashes or disappears, the claim expires automatically and other agents can claim the resource again after the lease window.',
+  },
+  {
+    question: 'What happens if Availsync is unavailable?',
+    answer:
+      'The SDK and MCP package surface the failure. In enforce mode, the recommended production policy is fail-closed; see the Reliability docs for details.',
+  },
+];
+
+export function organizationSchema() {
+  return {
+    '@type': 'Organization',
+    '@id': `${siteUrl}/#organization`,
+    name: siteName,
+    url: siteUrl,
+    sameAs: [],
+  };
+}
+
+export function websiteSchema() {
+  return {
+    '@type': 'WebSite',
+    '@id': `${siteUrl}/#website`,
+    url: siteUrl,
+    name: siteName,
+    description: siteDescription,
+    publisher: { '@id': `${siteUrl}/#organization` },
+    inLanguage: 'en',
+  };
+}
+
+export function softwareApplicationSchema() {
+  return {
+    '@type': 'SoftwareApplication',
+    '@id': `${siteUrl}/#software`,
+    name: siteName,
+    applicationCategory: 'BusinessApplication',
+    operatingSystem: 'Web',
+    url: siteUrl,
+    image: defaultOgImage,
+    description: siteDescription,
+    featureList: [
+      'AI and coding agent coordination',
+      'Repo and project claim guardrails',
+      'Observe mode before enforcement',
+      'Proceed and skip_run runtime decisions',
+      'Automation pre-flight checks',
+      'Secondary availability and scheduling conflict previews',
+      'MCP and REST integration flows',
+      'Audit and activity logs for agent actions',
+      'Plan limits and API key management',
+    ],
+    offers: plans.map((plan) => ({
+      '@type': 'Offer',
+      name: `${plan.name} plan`,
+      price: plan.id !== 'free' && !billingUpgradesEnabled() ? '0' : plan.price.replace('$', '') || '0',
+      priceCurrency: 'USD',
+      url: plan.id !== 'free' && !billingUpgradesEnabled() ? `${siteUrl}/pricing#waitlist` : `${siteUrl}${plan.href}`,
+      availability: plan.id !== 'free' && !billingUpgradesEnabled()
+        ? 'https://schema.org/PreOrder'
+        : 'https://schema.org/InStock',
+      description: plan.description,
+    })),
+    provider: { '@id': `${siteUrl}/#organization` },
+  };
+}
+
+export function faqPageSchema() {
+  return {
+    '@type': 'FAQPage',
+    '@id': `${siteUrl}/#faq`,
+    mainEntity: faqSchemaItems.map((item) => ({
+      '@type': 'Question',
+      name: item.question,
+      acceptedAnswer: {
+        '@type': 'Answer',
+        text: item.answer,
+      },
+    })),
+  };
+}
+
+export function homePageSchema() {
+  return {
+    '@context': 'https://schema.org',
+    '@graph': [
+      organizationSchema(),
+      websiteSchema(),
+      softwareApplicationSchema(),
+      faqPageSchema(),
+      {
+        '@type': 'WebPage',
+        '@id': `${siteUrl}/#webpage`,
+        url: siteUrl,
+        name: 'Availsync - Coding-agent coordination guardrails',
+        description: siteDescription,
+        isPartOf: { '@id': `${siteUrl}/#website` },
+        about: { '@id': `${siteUrl}/#software` },
+        primaryImageOfPage: {
+          '@type': 'ImageObject',
+          url: defaultOgImage,
+        },
+      },
+    ],
+  };
+}
+
+export function pricingPageSchema() {
+  return {
+    '@context': 'https://schema.org',
+    '@graph': [
+      organizationSchema(),
+      softwareApplicationSchema(),
+      {
+        '@type': 'WebPage',
+        '@id': `${siteUrl}/pricing#webpage`,
+        url: `${siteUrl}/pricing`,
+        name: 'Availsync pricing',
+        description:
+          'Availsync pricing, including a free plan and waitlist-only Individual and Team plans for coding-agent coordination, protected resources, and API activity.',
+        isPartOf: { '@id': `${siteUrl}/#website` },
+      },
+    ],
+  };
+}
+
+export function docsPageSchema() {
+  return {
+    '@context': 'https://schema.org',
+    '@graph': [
+      organizationSchema(),
+      websiteSchema(),
+      {
+        '@type': 'TechArticle',
+        '@id': `${siteUrl}/docs#article`,
+        headline: 'Availsync API docs',
+        description:
+          'Documentation for using Availsync as the shared work-claim, resource-lock, and conflict-preview layer before AI and coding agents act.',
+        url: `${siteUrl}/docs`,
+        author: { '@id': `${siteUrl}/#organization` },
+        publisher: { '@id': `${siteUrl}/#organization` },
+      },
+    ],
+  };
+}
+
+export function quickstartPageSchema() {
+  return {
+    '@context': 'https://schema.org',
+    '@graph': [
+      organizationSchema(),
+      websiteSchema(),
+      {
+        '@type': 'HowTo',
+        '@id': `${siteUrl}/docs/quickstart#howto`,
+        name: 'Connect an AI or coding agent to Availsync',
+        description:
+          'Set up Availsync so coding agents can check, claim, extend, and release work slots before acting on a repo or project.',
+        totalTime: 'PT10M',
+        step: [
+          {
+            '@type': 'HowToStep',
+            name: 'Run dashboard setup test',
+            text: 'Validate the agent setup from the Availsync dashboard without exposing the raw API key.',
+          },
+          {
+            '@type': 'HowToStep',
+            name: 'Copy MCP or REST config',
+            text: 'Store the agent id and generated API key in the MCP, coding-agent, cron, or server environment.',
+          },
+          {
+            '@type': 'HowToStep',
+            name: 'Check and claim a work slot',
+            text: 'Call the automation guardrail endpoint before the agent starts work on a repo or project.',
+          },
+          {
+            '@type': 'HowToStep',
+            name: 'Extend and release',
+            text: 'Extend the lease while the agent is still working and release it when the run finishes.',
+          },
+          {
+            '@type': 'HowToStep',
+            name: 'Verify Activity',
+            text: 'Confirm heartbeat, work checks, claims, extensions, and releases in the Activity log.',
+          },
+        ],
+      },
+    ],
+  };
+}
+
+export function sdkNodePageSchema() {
+  return {
+    '@context': 'https://schema.org',
+    '@graph': [
+      organizationSchema(),
+      websiteSchema(),
+      {
+        '@type': 'TechArticle',
+        '@id': `${siteUrl}/docs/sdk/node#article`,
+        headline: 'Availsync Node SDK',
+        description:
+          'Install and use @availsync/node to guard coding-agent automations with repo claims, observe mode, skip_run handling, extend, and finish.',
+        url: `${siteUrl}/docs/sdk/node`,
+        author: { '@id': `${siteUrl}/#organization` },
+        publisher: { '@id': `${siteUrl}/#organization` },
+      },
+    ],
+  };
+}
+
+export function pilotPageSchema() {
+  return {
+    '@context': 'https://schema.org',
+    '@graph': [
+      organizationSchema(),
+      websiteSchema(),
+      {
+        '@type': 'HowTo',
+        '@id': `${siteUrl}/docs/pilot#howto`,
+        name: 'Pilot Availsync in 10 minutes',
+        description:
+          'A self-serve pilot flow for verifying Availsync, installing the Node SDK, running observe mode, and confirming real agent traffic.',
+        totalTime: 'PT10M',
+        step: [
+          { '@type': 'HowToStep', name: 'Start free', text: 'Create a workspace and first agent.' },
+          { '@type': 'HowToStep', name: 'Run verification', text: 'Use the dashboard verification to see a real conflict resolved.' },
+          { '@type': 'HowToStep', name: 'Install SDK', text: 'Install @availsync/node@alpha in the automation project.' },
+          { '@type': 'HowToStep', name: 'Use observe mode', text: 'Run without blocking and measure what Availsync would have stopped.' },
+          { '@type': 'HowToStep', name: 'Confirm value', text: 'Review Activity and Overview for real agent traffic and blocked or would-have-blocked runs.' },
+        ],
+      },
+    ],
+  };
+}
+
+export function webPageSchema(path: string, name: string, description: string) {
+  return {
+    '@context': 'https://schema.org',
+    '@graph': [
+      organizationSchema(),
+      websiteSchema(),
+      {
+        '@type': 'WebPage',
+        '@id': `${siteUrl}${path}#webpage`,
+        url: `${siteUrl}${path}`,
+        name,
+        description,
+        isPartOf: { '@id': `${siteUrl}/#website` },
+      },
+    ],
+  };
+}