@tuturuuu/utils 0.27.1 → 0.29.0

package/src/coordination-protocol.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+
+const digest = z.string().regex(/^[a-f0-9]{64}$/);
+const base = {
+  key: digest,
+  owner: z.string().uuid(),
+};
+export const coordinationRequestSchema = z.union([
+  z
+    .object({
+      ...base,
+      namespace: z.literal('authenticator'),
+      action: z.literal('acquire'),
+    })
+    .strict(),
+  z
+    .object({
+      ...base,
+      namespace: z.literal('meeting'),
+      action: z.literal('acquire'),
+      fingerprint: digest,
+    })
+    .strict(),
+  z
+    .object({
+      ...base,
+      namespace: z.enum(['authenticator', 'meeting']),
+      action: z.enum(['check', 'release']),
+    })
+    .strict(),
+  z
+    .object({
+      ...base,
+      namespace: z.literal('meeting'),
+      action: z.literal('complete'),
+    })
+    .strict(),
+]);
+export type CoordinationRequest = z.infer<typeof coordinationRequestSchema>;
+export const coordinationResultSchema = z.union([
+  z
+    .object({
+      outcome: z.literal('acquired'),
+      fresh: z.boolean(),
+      completed: z.boolean(),
+    })
+    .strict(),
+  z
+    .object({
+      outcome: z.enum([
+        'busy',
+        'conflict',
+        'owned',
+        'lost',
+        'released',
+        'completed',
+      ]),
+    })
+    .strict(),
+]);
+export type CoordinationResult = z.infer<typeof coordinationResultSchema>;

package/src/coordination.test.ts

@@ -0,0 +1,84 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('server-only', () => ({}));
+
+import {
+  CoordinationUnavailableError,
+  coordinate,
+  coordinationKey,
+} from './coordination';
+
+const input = {
+  namespace: 'authenticator' as const,
+  key: 'a'.repeat(64),
+  owner: '0199619a-9154-7000-8000-000000000001',
+  action: 'acquire' as const,
+};
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.unstubAllEnvs();
+});
+function setup() {
+  vi.stubEnv('CLOUDFLARE_COORDINATION_URL', 'https://coordination.example.com');
+  vi.stubEnv(
+    'CLOUDFLARE_COORDINATION_TOKEN',
+    'test-only-placeholder'.repeat(3)
+  );
+  const fetchMock = vi
+    .fn()
+    .mockResolvedValue(
+      Response.json({ outcome: 'acquired', fresh: true, completed: false })
+    );
+  vi.stubGlobal('fetch', fetchMock);
+  return fetchMock;
+}
+describe('server coordination client', () => {
+  it('hashes identities and sends bounded uncached authenticated requests', async () => {
+    const fetchMock = setup();
+    expect(coordinationKey('user')).toMatch(/^[a-f0-9]{64}$/);
+    await expect(coordinate(input)).resolves.toMatchObject({
+      outcome: 'acquired',
+    });
+    expect(fetchMock).toHaveBeenCalledWith(
+      new URL('https://coordination.example.com/v1/coordinate'),
+      expect.objectContaining({
+        cache: 'no-store',
+        redirect: 'error',
+        method: 'POST',
+        signal: expect.any(AbortSignal),
+      })
+    );
+  });
+  it('fails closed without configuration or with an insecure URL', async () => {
+    const fetchMock = setup();
+    for (const url of [
+      '',
+      'http://example.com',
+      'https://user:password@example.com',
+    ]) {
+      vi.stubEnv('CLOUDFLARE_COORDINATION_URL', url);
+      await expect(coordinate(input)).rejects.toBeInstanceOf(
+        CoordinationUnavailableError
+      );
+    }
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+  it('sanitizes provider failures and does not retry ambiguous mutations', async () => {
+    const fetchMock = setup();
+    fetchMock.mockRejectedValueOnce(new Error('sensitive provider detail'));
+    await expect(coordinate(input)).rejects.toThrow(
+      'Shared coordination is temporarily unavailable'
+    );
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    fetchMock.mockResolvedValueOnce(Response.json({ unexpected: 'value' }));
+    await expect(coordinate(input)).rejects.toBeInstanceOf(
+      CoordinationUnavailableError
+    );
+    fetchMock.mockResolvedValueOnce(
+      new Response('private error', { status: 503 })
+    );
+    await expect(coordinate(input)).rejects.toBeInstanceOf(
+      CoordinationUnavailableError
+    );
+  });
+});

package/src/coordination.ts

@@ -0,0 +1,57 @@
+import 'server-only';
+
+import { createHash } from 'node:crypto';
+import {
+  type CoordinationRequest,
+  coordinationResultSchema,
+} from './coordination-protocol';
+import { Effect } from './effect';
+
+export class CoordinationUnavailableError extends Error {
+  constructor() {
+    super('Shared coordination is temporarily unavailable');
+  }
+}
+export function coordinationKey(value: string) {
+  return createHash('sha256').update(value).digest('hex');
+}
+
+/** Server-only, bounded requests. Do not retry mutations after an ambiguous
+ * network failure: their expiring lease may already have been committed. */
+export async function coordinate(input: CoordinationRequest) {
+  const result = await Effect.runPromise(
+    Effect.either(
+      Effect.tryPromise({
+        try: async () => {
+          const origin = new URL(process.env.CLOUDFLARE_COORDINATION_URL ?? '');
+          const token = process.env.CLOUDFLARE_COORDINATION_TOKEN;
+          if (
+            origin.protocol !== 'https:' ||
+            origin.username ||
+            origin.password ||
+            !token ||
+            token.length < 32
+          )
+            throw new CoordinationUnavailableError();
+          const response = await fetch(new URL('/v1/coordinate', origin), {
+            method: 'POST',
+            headers: {
+              Authorization: `Bearer ${token}`,
+              'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(input),
+            cache: 'no-store',
+            redirect: 'error',
+            signal: AbortSignal.timeout(5000),
+          });
+          if (!response.ok) throw new CoordinationUnavailableError();
+          return coordinationResultSchema.parse(await response.json());
+        },
+        // Never expose URLs, request bodies, or authorization headers in errors.
+        catch: () => new CoordinationUnavailableError(),
+      })
+    )
+  );
+  if (result._tag === 'Left') throw result.left;
+  return result.right;
+}

package/src/feature-tier-policy.ts

@@ -0,0 +1,26 @@
+import type { WorkspaceProductTier } from '@tuturuuu/types/db';
+export const FEATURE_TIERS = {
+  // FREE tier features
+  dashboard: 'FREE',
+  tasks: 'FREE',
+  calendar: 'FREE',
+  notifications: 'FREE',
+  qr_generator: 'FREE',
+  finance: 'FREE',
+  users: 'FREE',
+  inventory: 'FREE',
+  whiteboards: 'FREE',
+  drive: 'FREE',
+  realtime_cursors: 'FREE',
+  documents: 'FREE',
+  time_tracker: 'FREE',
+  voice_assistant: 'FREE',
+
+  // PLUS tier features
+  chat: 'PLUS',
+
+  // PRO tier features
+  workforce: 'PRO',
+  ai_lab: 'PRO',
+  mira: 'PRO',
+} as const satisfies Record<string, WorkspaceProductTier>;

package/src/internal-domains.ts

@@ -4,6 +4,8 @@ import {
 } from './portless';
 
 export const PRODUCTION_INTERNAL_APP_DOMAINS = [
+  { name: 'lettin', url: 'https://lettin.tuturuuu.com' },
+  { name: 'colab', url: 'https://colab.tuturuuu.com' },
   {
     name: 'ai',
     url: 'https://ai.tuturuuu.com',
@@ -131,6 +133,8 @@ export const PRODUCTION_INTERNAL_APP_DOMAINS = [
 ] as const;
 
 export const PORTLESS_INTERNAL_APP_DOMAINS = [
+  { name: 'lettin', url: getTuturuuuPortlessAppOrigin('lettin') },
+  { name: 'colab', url: getTuturuuuPortlessAppOrigin('colab') },
   {
     name: 'ai',
     url: getTuturuuuPortlessAppOrigin('ai'),
@@ -250,6 +254,8 @@ export const PORTLESS_INTERNAL_APP_DOMAINS = [
 ] as const;
 
 export const LOCALHOST_INTERNAL_APP_DOMAINS = [
+  { name: 'lettin', url: 'http://localhost:7833' },
+  { name: 'colab', url: 'http://localhost:8795' },
   {
     name: 'ai',
     url: 'http://localhost:7829',

package/src/keyboard-shortcuts.ts

@@ -0,0 +1,40 @@
+/** Shared guards for document/window keyboard commands. */
+export function isEditableShortcutTarget(target: EventTarget | null): boolean {
+  return (
+    typeof Element !== 'undefined' &&
+    target instanceof Element &&
+    Boolean(
+      target.closest(
+        'input, textarea, select, [contenteditable]:not([contenteditable="false"]), [role="textbox"], [role="combobox"]'
+      )
+    )
+  );
+}
+
+export function isShortcutEventIgnored(
+  event: Pick<KeyboardEvent, 'defaultPrevented' | 'isComposing' | 'repeat'>
+): boolean {
+  return event.defaultPrevented || event.isComposing || event.repeat;
+}
+
+export function isPageShortcutBlocked(event: KeyboardEvent): boolean {
+  if (isShortcutEventIgnored(event) || isEditableShortcutTarget(event.target))
+    return true;
+  const target = event.target;
+  if (
+    typeof Element !== 'undefined' &&
+    target instanceof Element &&
+    target.closest(
+      '[role="menu"], [role="listbox"], [role="dialog"], [role="alertdialog"]'
+    )
+  )
+    return true;
+  return (
+    typeof document !== 'undefined' &&
+    Boolean(
+      document.querySelector(
+        '[role="dialog"][data-state="open"], [role="alertdialog"][data-state="open"]'
+      )
+    )
+  );
+}

package/src/launchable-apps.ts

@@ -387,6 +387,31 @@ export const LAUNCHABLE_APPS = [
     title: 'Track',
     workspacePathResolver: workspaceRootPath,
   },
+  {
+    aliases: ['Prompt engineering', 'Team workshops', 'Multiplayer learning'],
+    appRoot: 'apps/colab',
+    category: 'learning',
+    defaultPath: '/',
+    localhostOrigin: 'http://localhost:8795',
+    packageName: '@tuturuuu/colab',
+    portlessApp: 'colab',
+    productionUrl: 'https://colab.tuturuuu.com',
+    slug: 'colab',
+    title: 'Colab',
+  },
+  {
+    aliases: ['Worldbuilding', 'Wiki', 'Characters', 'Stories', 'Bulletin'],
+    appRoot: 'apps/lettin',
+    category: 'productivity',
+    defaultPath: '/dashboard',
+    localhostOrigin: 'http://localhost:7833',
+    packageName: '@tuturuuu/lettin',
+    portlessApp: 'lettin',
+    productionUrl: 'https://lettin.tuturuuu.com',
+    slug: 'lettin',
+    title: '(Tu)lettin',
+    workspacePathResolver: workspaceRootPath,
+  },
 ] as const satisfies readonly LaunchableApp[];
 
 export type LaunchableAppSlug = (typeof LAUNCHABLE_APPS)[number]['slug'];

package/src/meet-creation-policy.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { canCreateOnlineMeeting } from './meet-creation-policy';
+
+describe('online meeting creator domain', () => {
+  it.each(['host@tuturuuu.com', 'Host@TUTURUUU.COM'])('allows %s', (email) => {
+    expect(canCreateOnlineMeeting(email)).toBe(true);
+  });
+  it.each([
+    null,
+    undefined,
+    '',
+    '@tuturuuu.com',
+    'host@gmail.com',
+    'host@sub.tuturuuu.com',
+    'host@tuturuuu.com.evil.test',
+    'host@evil.test@tuturuuu.com',
+    ' host@tuturuuu.com',
+  ])('rejects %s', (email) => {
+    expect(canCreateOnlineMeeting(email)).toBe(false);
+  });
+});
+
+it.each(['PLUS', 'PRO', 'ENTERPRISE'])(
+  'allows verified external %s eligibility',
+  (tier) => {
+    expect(canCreateOnlineMeeting('host@example.test', tier)).toBe(true);
+    expect(canCreateOnlineMeeting('bad@@example.test', tier)).toBe(false);
+  }
+);
+it('does not unlock hosting for an unknown tier', () => {
+  expect(canCreateOnlineMeeting('host@example.test', 'UNKNOWN')).toBe(false);
+});

package/src/meet-creation-policy.ts

@@ -0,0 +1,12 @@
+/** Use a current authenticated email and server-resolved personal subscription tier. */
+export function canCreateOnlineMeeting(
+  email: string | null | undefined,
+  tier: string = 'FREE'
+): boolean {
+  if (typeof email !== 'string' || !/^[^\s@]+@[^\s@]+$/u.test(email))
+    return false;
+  return (
+    /^[^\s@]+@tuturuuu\.com$/iu.test(email) ||
+    ['PLUS', 'PRO', 'ENTERPRISE'].includes(tier)
+  );
+}

package/src/meet-duration.ts

@@ -0,0 +1,71 @@
+import 'server-only';
+import { createAdminClient } from '@tuturuuu/supabase/next/server';
+import type { WorkspaceProductTier } from '@tuturuuu/types';
+import { extractTierFromSubscriptions } from './workspace-helper';
+export class MeetDurationError extends Error {
+  readonly status = 503;
+}
+
+export function meetingDurationSeconds(tier: string) {
+  return (
+    (tier === 'PLUS' ? 10 : tier === 'PRO' || tier === 'ENTERPRISE' ? 24 : 2) *
+    3600
+  );
+}
+
+/** Entitlements belong to the host's personal account, never the joining guest. */
+export async function getHostMeetingTier(
+  hostId: string
+): Promise<WorkspaceProductTier> {
+  const db = await createAdminClient({ noCookie: true });
+  const { data, error } = await db
+    .from('workspaces')
+    .select('id')
+    .eq('creator_id', hostId)
+    .eq('personal', true)
+    .or('deleted.is.null,deleted.eq.false')
+    .maybeSingle();
+  if (error) throw new MeetDurationError('Meeting entitlement lookup failed');
+  if (!data) return 'FREE';
+  const subscriptions = await db
+    .from('workspace_subscriptions')
+    .select('created_at, status, product_id')
+    .eq('ws_id', data.id)
+    .eq('status', 'active');
+  if (subscriptions.error)
+    throw new MeetDurationError('Meeting entitlement lookup failed');
+  const ids = [
+    ...new Set(
+      subscriptions.data
+        .map((subscription) => subscription.product_id)
+        .filter((id): id is string => !!id)
+    ),
+  ];
+  if (!ids.length) return 'FREE';
+  const products = await db
+    .schema('private')
+    .from('workspace_subscription_products')
+    .select('id, tier')
+    .in('id', ids);
+  if (products.error)
+    throw new MeetDurationError('Meeting entitlement lookup failed');
+  const tiers = new Map(
+    products.data.map((product) => [product.id, product.tier])
+  );
+  if (ids.some((id) => !tiers.get(id)))
+    throw new MeetDurationError('Meeting entitlement product unavailable');
+  const tier = extractTierFromSubscriptions(
+    subscriptions.data.map((subscription) => ({
+      ...subscription,
+      product_tier: subscription.product_id
+        ? (tiers.get(subscription.product_id) ?? null)
+        : null,
+    }))
+  );
+
+  return tier ?? 'FREE';
+}
+
+export async function getHostMeetingDurationSeconds(hostId: string) {
+  return meetingDurationSeconds(await getHostMeetingTier(hostId));
+}

package/src/meet-hosting.test.ts

@@ -0,0 +1,58 @@
+import { beforeEach, expect, it, vi } from 'vitest';
+
+const tier = vi.hoisted(() => vi.fn());
+vi.mock('server-only', () => ({}));
+vi.mock('./meet-duration', () => ({ getHostMeetingTier: tier }));
+
+import { canVerifiedAccountHostMeeting } from './meet-hosting';
+
+beforeEach(() => {
+  vi.resetAllMocks();
+  tier.mockResolvedValue('FREE');
+});
+it.each(['PLUS', 'PRO', 'ENTERPRISE'])(
+  'unlocks verified %s accounts',
+  async (value) => {
+    tier.mockResolvedValue(value);
+    expect(
+      await canVerifiedAccountHostMeeting('actor', {
+        email: 'host@example.com',
+        email_confirmed_at: '2026-01-01',
+      })
+    ).toBe(true);
+    expect(tier).toHaveBeenCalledWith('actor');
+  }
+);
+it('requires verification before considering a paid subscription', async () => {
+  tier.mockResolvedValue('PLUS');
+  expect(
+    await canVerifiedAccountHostMeeting('actor', { email: 'host@example.com' })
+  ).toBe(false);
+  expect(tier).not.toHaveBeenCalled();
+});
+it('preserves verified company hosting without paid entitlement', async () => {
+  expect(
+    await canVerifiedAccountHostMeeting('actor', {
+      email: 'host@tuturuuu.com',
+      email_confirmed_at: '2026-01-01',
+    })
+  ).toBe(true);
+  expect(tier).not.toHaveBeenCalled();
+});
+it('denies external Free accounts', async () => {
+  expect(
+    await canVerifiedAccountHostMeeting('actor', {
+      email: 'host@example.com',
+      email_confirmed_at: '2026-01-01',
+    })
+  ).toBe(false);
+});
+it('fails closed when entitlement cannot be resolved', async () => {
+  tier.mockRejectedValue(new Error('Unavailable'));
+  await expect(
+    canVerifiedAccountHostMeeting('actor', {
+      email: 'host@example.com',
+      email_confirmed_at: '2026-01-01',
+    })
+  ).rejects.toThrow('Unavailable');
+});

package/src/meet-hosting.ts

@@ -0,0 +1,19 @@
+import 'server-only';
+import { canCreateOnlineMeeting } from './meet-creation-policy';
+import { getHostMeetingTier } from './meet-duration';
+
+/** Pass only the current auth.admin.getUserById result, never handoff/profile metadata. */
+export async function canVerifiedAccountHostMeeting(
+  accountId: string,
+  identity:
+    | { email?: string | null; email_confirmed_at?: string | null }
+    | null
+    | undefined
+) {
+  if (!identity?.email_confirmed_at || !identity.email) return false;
+  if (canCreateOnlineMeeting(identity.email)) return true;
+  return canCreateOnlineMeeting(
+    identity.email,
+    await getHostMeetingTier(accountId)
+  );
+}

package/src/meeting-invitations.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from 'vitest';
+import {
+  MeetingInvitationInputSchema,
+  normalizeGoogleResponse,
+  normalizeMicrosoftResponse,
+} from './meeting-invitations';
+
+describe('meeting invitation contract', () => {
+  it('normalizes internal and external guests without accepting response spoofing', () => {
+    const invitation = MeetingInvitationInputSchema.parse({
+      guests: [
+        { email: 'NAME@TUTURUUU.COM', response: 'accepted' },
+        { email: 'friend@gmail.com', optional: true },
+      ],
+      timeZone: 'Asia/Ho_Chi_Minh',
+    });
+    expect(invitation.guests[0]).toEqual({ email: 'name@tuturuuu.com' });
+    expect(invitation.guests[1]?.optional).toBe(true);
+  });
+  it.each([
+    { guests: [], timeZone: 'UTC' },
+    { guests: [{ email: 'invalid' }], timeZone: 'UTC' },
+    { guests: [{ email: 'a@example.com' }], timeZone: 'fake/zone' },
+    {
+      guests: [{ email: 'a@example.com' }, { email: 'A@EXAMPLE.COM' }],
+      timeZone: 'UTC',
+    },
+    {
+      guests: Array.from({ length: 101 }, (_, i) => ({
+        email: `${i}@example.com`,
+      })),
+      timeZone: 'UTC',
+    },
+  ])('rejects invalid or ambiguous invitation input', (input) => {
+    expect(MeetingInvitationInputSchema.safeParse(input).success).toBe(false);
+  });
+  it.each(['accepted', 'declined', 'tentative', 'needsAction'])(
+    'preserves Google %s',
+    (value) => {
+      expect(normalizeGoogleResponse(value)).toBe(value);
+    }
+  );
+  it.each([
+    ['accepted', 'accepted'],
+    ['declined', 'declined'],
+    ['tentativelyAccepted', 'tentative'],
+    ['notResponded', 'needsAction'],
+    ['none', 'needsAction'],
+    ['unexpected', 'needsAction'],
+  ])('normalizes Microsoft %s', (value, expected) => {
+    expect(normalizeMicrosoftResponse(value)).toBe(expected);
+  });
+});
+
+describe('untrusted invitation input boundaries', () => {
+  it.each([
+    null,
+    undefined,
+    'accepted',
+    [],
+    { guests: [{ email: 'a@example.com', optional: 'yes' }], timeZone: 'UTC' },
+    {
+      guests: [{ email: 'a@example.com', name: 'a'.repeat(201) }],
+      timeZone: 'UTC',
+    },
+    {
+      guests: [{ email: 'a@example.com\r\nBcc: victim@example.com' }],
+      timeZone: 'UTC',
+    },
+    { guests: [{ email: 'a@example.com' }], timeZone: null },
+  ])('rejects malformed input without throwing from safeParse', (input) => {
+    expect(MeetingInvitationInputSchema.safeParse(input).success).toBe(false);
+  });
+
+  it('accepts the maximum guest count and strips organizer-controlled provider state', () => {
+    const result = MeetingInvitationInputSchema.parse({
+      guests: Array.from({ length: 100 }, (_, i) => ({
+        email: `guest${i}@example.com`,
+        self: true,
+        response: 'accepted',
+      })),
+      timeZone: 'UTC',
+      organizer: { email: 'spoof@example.com' },
+      cancelled: true,
+    });
+    expect(result.guests).toHaveLength(100);
+    expect(result).not.toHaveProperty('organizer');
+    expect(result).not.toHaveProperty('cancelled');
+    for (const guest of result.guests) {
+      expect(guest).not.toHaveProperty('self');
+      expect(guest).not.toHaveProperty('response');
+    }
+  });
+
+  it.each([null, undefined, {}, [], 0, 'ACCEPTED', '<script>'])(
+    'treats unknown provider responses as unanswered',
+    (value) => {
+      expect(normalizeGoogleResponse(value)).toBe('needsAction');
+      expect(normalizeMicrosoftResponse(value)).toBe('needsAction');
+    }
+  );
+});