@tuturuuu/utils 0.28.0 → 0.29.1

package/src/commercial-comparison-2.ts

@@ -0,0 +1,262 @@
+import type { ComparisonFeature } from './commercial-comparison-types';
+export const features2: ComparisonFeature[] = [
+  {
+    id: 'lettin_0',
+    app: 'lettin',
+    category: 'learning',
+    values: ['preview', 'preview', 'preview', 'preview'],
+    detail: 'standard',
+  },
+  {
+    id: 'colab_0',
+    app: 'colab',
+    category: 'learning',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'ai',
+  },
+  {
+    id: 'colab_1',
+    app: 'colab',
+    category: 'learning',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'ai',
+  },
+  {
+    id: 'colab_2',
+    app: 'colab',
+    category: 'learning',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'ai',
+  },
+  {
+    id: 'colab_3',
+    app: 'colab',
+    category: 'learning',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'ai',
+  },
+  {
+    id: 'learn_0',
+    app: 'learn',
+    category: 'learning',
+    values: ['preview', 'preview', 'preview', 'preview'],
+    detail: 'standard',
+  },
+  {
+    id: 'teach_0',
+    app: 'teach',
+    category: 'learning',
+    values: ['preview', 'preview', 'preview', 'preview'],
+    detail: 'standard',
+  },
+  {
+    id: 'rewise_0',
+    app: 'rewise',
+    category: 'learning',
+    values: ['preview', 'preview', 'preview', 'preview'],
+    detail: 'standard',
+  },
+  {
+    id: 'nova_0',
+    app: 'nova',
+    category: 'learning',
+    values: ['preview', 'preview', 'preview', 'preview'],
+    detail: 'standard',
+  },
+  {
+    id: 'git_0',
+    app: 'git',
+    category: 'developer',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'standard',
+  },
+  {
+    id: 'git_1',
+    app: 'git',
+    category: 'developer',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'standard',
+  },
+  {
+    id: 'git_2',
+    app: 'git',
+    category: 'developer',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'standard',
+  },
+  {
+    id: 'external_0',
+    app: 'external',
+    category: 'developer',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'standard',
+  },
+  {
+    id: 'external_1',
+    app: 'external',
+    category: 'developer',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'standard',
+  },
+  {
+    id: 'mobile_0',
+    app: 'mobile',
+    category: 'work',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'standard',
+  },
+  {
+    id: 'mobile_1',
+    app: 'mobile',
+    category: 'work',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'standard',
+  },
+  {
+    id: 'pay_0',
+    app: 'pay',
+    category: 'operations',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'standard',
+  },
+  {
+    id: 'pay_1',
+    app: 'pay',
+    category: 'operations',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'standard',
+  },
+  {
+    id: 'pay_2',
+    app: 'pay',
+    category: 'operations',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'standard',
+  },
+  {
+    id: 'apps_0',
+    app: 'apps',
+    category: 'work',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'standard',
+  },
+  {
+    id: 'tools_0',
+    app: 'tools',
+    category: 'work',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'standard',
+  },
+  {
+    id: 'shortener_0',
+    app: 'shortener',
+    category: 'work',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'standard',
+  },
+  {
+    id: 'storefront_0',
+    app: 'storefront',
+    category: 'operations',
+    values: ['preview', 'preview', 'preview', 'preview'],
+    detail: 'standard',
+  },
+  {
+    id: 'playground_0',
+    app: 'playground',
+    category: 'developer',
+    values: ['preview', 'preview', 'preview', 'preview'],
+    detail: 'standard',
+  },
+  {
+    id: 'discord_0',
+    app: 'discord',
+    category: 'developer',
+    values: ['preview', 'preview', 'preview', 'preview'],
+    detail: 'standard',
+  },
+  {
+    id: 'docs_0',
+    app: 'docs',
+    category: 'developer',
+    values: ['included', 'included', 'included', 'included'],
+    detail: 'standard',
+  },
+  {
+    id: 'backend_0',
+    app: 'backend',
+    category: 'internal',
+    values: ['internal', 'internal', 'internal', 'internal'],
+    detail: 'standard',
+  },
+  {
+    id: 'database_0',
+    app: 'database',
+    category: 'internal',
+    values: ['internal', 'internal', 'internal', 'internal'],
+    detail: 'standard',
+  },
+  {
+    id: 'redis_0',
+    app: 'redis',
+    category: 'internal',
+    values: ['internal', 'internal', 'internal', 'internal'],
+    detail: 'standard',
+  },
+  {
+    id: 'supermemory_0',
+    app: 'supermemory',
+    category: 'internal',
+    values: ['internal', 'internal', 'internal', 'internal'],
+    detail: 'standard',
+  },
+  {
+    id: 'storage-unzip-proxy_0',
+    app: 'storage-unzip-proxy',
+    category: 'internal',
+    values: ['internal', 'internal', 'internal', 'internal'],
+    detail: 'standard',
+  },
+  {
+    id: 'chat-realtime_0',
+    app: 'chat-realtime',
+    category: 'internal',
+    values: ['internal', 'internal', 'internal', 'internal'],
+    detail: 'standard',
+  },
+  {
+    id: 'coordination_0',
+    app: 'coordination',
+    category: 'internal',
+    values: ['internal', 'internal', 'internal', 'internal'],
+    detail: 'standard',
+  },
+  {
+    id: 'meet-realtime_0',
+    app: 'meet-realtime',
+    category: 'internal',
+    values: ['internal', 'internal', 'internal', 'internal'],
+    detail: 'standard',
+  },
+  {
+    id: 'hive-realtime_0',
+    app: 'hive-realtime',
+    category: 'internal',
+    values: ['internal', 'internal', 'internal', 'internal'],
+    detail: 'standard',
+  },
+  {
+    id: 'tanstack-web_0',
+    app: 'tanstack-web',
+    category: 'internal',
+    values: ['internal', 'internal', 'internal', 'internal'],
+    detail: 'standard',
+  },
+  {
+    id: 'infrastructure_0',
+    app: 'infrastructure',
+    category: 'internal',
+    values: ['internal', 'internal', 'internal', 'internal'],
+    detail: 'standard',
+  },
+];

package/src/commercial-comparison-types.ts

@@ -0,0 +1,20 @@
+import type { FEATURE_TIERS } from './feature-tier-policy';
+/** Source-backed feature inventory. Preview is availability, never an upgrade promise.
+ * Navigation and feature-tiers.ts own capabilities; capacity rows identify pending rollout.
+ * Internal services share the host workspace budget and are not separately sold. */
+export type ComparisonTier = 'free' | 'plus' | 'pro' | 'enterprise';
+export const COMPARISON_TIERS: ComparisonTier[] = [
+  'free',
+  'plus',
+  'pro',
+  'enterprise',
+];
+export interface ComparisonFeature {
+  id: string;
+  app: string;
+  category: string;
+  values: [string, string, string, string];
+  detail: string;
+  pending?: boolean;
+  gate?: keyof typeof FEATURE_TIERS;
+}

package/src/commercial-comparison.test.ts

@@ -0,0 +1,32 @@
+import { readdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { COMPARISON_FEATURES } from './commercial-comparison';
+
+describe('commercial inventory coverage', () => {
+  it('represents every app directory and avoids duplicate feature identifiers', () => {
+    const apps = readdirSync(resolve(__dirname, '../../../apps'), {
+      withFileTypes: true,
+    })
+      .filter((item) => item.isDirectory() && !item.name.startsWith('.'))
+      .map((item) => (item.name === 'web' ? 'platform' : item.name));
+    const represented = new Set(COMPARISON_FEATURES.map((row) => row.app));
+    expect(apps.filter((app) => !represented.has(app))).toEqual([]);
+    expect(new Set(COMPARISON_FEATURES.map((row) => row.id)).size).toBe(
+      COMPARISON_FEATURES.length
+    );
+  });
+  it('does not sell privileged internal services or promise public Meet access', () => {
+    for (const row of COMPARISON_FEATURES.filter(
+      (row) => row.category === 'internal'
+    ))
+      expect(row.values).toEqual([
+        'internal',
+        'internal',
+        'internal',
+        'internal',
+      ]);
+    for (const row of COMPARISON_FEATURES.filter((row) => row.app === 'meet'))
+      expect(row.values).toEqual(['preview', 'preview', 'preview', 'preview']);
+  });
+});

package/src/commercial-comparison.ts

@@ -0,0 +1,96 @@
+import type { ComparisonFeature } from './commercial-comparison-types';
+import { FEATURE_TIERS } from './feature-tier-policy';
+
+export * from './commercial-comparison-types';
+
+import { features0 } from './commercial-comparison-0';
+import { features1 } from './commercial-comparison-1';
+import { features2 } from './commercial-comparison-2';
+
+const gateOrder = ['FREE', 'PLUS', 'PRO', 'ENTERPRISE'];
+const advanced: ComparisonFeature[] = [
+  {
+    id: 'prioritySupport',
+    app: 'platform',
+    category: 'operations',
+    detail: 'support',
+    values: ['excluded', 'excluded', 'included', 'contract'],
+  },
+  {
+    id: 'customIntegrations',
+    app: 'platform',
+    category: 'operations',
+    detail: 'support',
+    values: ['excluded', 'excluded', 'preview', 'contract'],
+  },
+  {
+    id: 'dedicatedSupport',
+    app: 'platform',
+    category: 'operations',
+    detail: 'support',
+    values: ['excluded', 'excluded', 'excluded', 'contract'],
+  },
+  {
+    id: 'sla',
+    app: 'platform',
+    category: 'operations',
+    detail: 'support',
+    values: ['excluded', 'excluded', 'excluded', 'contract'],
+  },
+  {
+    id: 'selfHosting',
+    app: 'platform',
+    category: 'operations',
+    detail: 'support',
+    values: ['excluded', 'excluded', 'excluded', 'contract'],
+  },
+  {
+    id: 'aiLab',
+    app: 'platform',
+    category: 'work',
+    detail: 'standard',
+    values: ['included', 'included', 'included', 'included'],
+    gate: 'ai_lab',
+  },
+  {
+    id: 'voiceAssistant',
+    app: 'platform',
+    category: 'work',
+    detail: 'standard',
+    values: ['included', 'included', 'included', 'included'],
+    gate: 'voice_assistant',
+  },
+  {
+    id: 'mira',
+    app: 'platform',
+    category: 'work',
+    detail: 'standard',
+    values: ['included', 'included', 'included', 'included'],
+    gate: 'mira',
+  },
+  {
+    id: 'workforce',
+    app: 'platform',
+    category: 'work',
+    detail: 'standard',
+    values: ['included', 'included', 'included', 'included'],
+    gate: 'workforce',
+  },
+];
+export const COMPARISON_FEATURES = [
+  ...features0,
+  ...features1,
+  ...features2,
+  ...advanced,
+].map((row) => {
+  if (!row.gate) return row;
+  const required = FEATURE_TIERS[row.gate];
+  return {
+    ...row,
+    values: gateOrder.map((tier) =>
+      gateOrder.indexOf(tier) >= gateOrder.indexOf(required)
+        ? 'included'
+        : 'excluded'
+    ) as ComparisonFeature['values'],
+  };
+});

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,7 @@ 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',
@@ -132,6 +133,7 @@ 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',
@@ -252,6 +254,7 @@ 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',

package/src/launchable-apps.ts

@@ -399,6 +399,19 @@ export const LAUNCHABLE_APPS = [
     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'];