@tuturuuu/utils 0.28.0 → 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,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'];

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

@@ -19,3 +19,14 @@ describe('online meeting creator domain', () => {
     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

@@ -1,6 +1,12 @@
-/** Apply only to an authenticated account email, never editable profile metadata. */
+/** Use a current authenticated email and server-resolved personal subscription tier. */
 export function canCreateOnlineMeeting(
-  email: string | null | undefined
+  email: string | null | undefined,
+  tier: string = 'FREE'
 ): boolean {
-  return typeof email === 'string' && /^[^\s@]+@tuturuuu\.com$/iu.test(email);
+  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');
+    }
+  );
+});

package/src/meeting-invitations.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+
+export const MeetingResponseSchema = z.enum([
+  'needsAction',
+  'accepted',
+  'declined',
+  'tentative',
+]);
+export type MeetingResponse = z.infer<typeof MeetingResponseSchema>;
+
+export const MeetingGuestSchema = z.object({
+  email: z
+    .email()
+    .max(254)
+    .transform((value) => value.trim().toLowerCase()),
+  name: z.string().trim().max(200).optional(),
+  optional: z.boolean().optional(),
+});
+
+/** Guest responses are provider-owned, never accepted from organizer input. */
+export const MeetingInvitationInputSchema = z
+  .object({
+    guests: z.array(MeetingGuestSchema).min(1).max(100),
+    timeZone: z
+      .string()
+      .max(100)
+      .refine((value) => {
+        try {
+          new Intl.DateTimeFormat('en', { timeZone: value });
+          return true;
+        } catch {
+          return false;
+        }
+      }, 'Invalid time zone'),
+  })
+  .superRefine((value, context) => {
+    const emails = new Set<string>();
+    value.guests.forEach((guest, index) => {
+      if (emails.has(guest.email))
+        context.addIssue({
+          code: 'custom',
+          message: 'Duplicate guest',
+          path: ['guests', index, 'email'],
+        });
+      emails.add(guest.email);
+    });
+  });
+export type MeetingInvitationInput = z.infer<
+  typeof MeetingInvitationInputSchema
+>;
+
+export type MeetingAttendee = z.infer<typeof MeetingGuestSchema> & {
+  response: MeetingResponse;
+  self?: boolean;
+};
+export interface MeetingInvitationState {
+  organizer: { email: string; name?: string; self: boolean };
+  attendees: MeetingAttendee[];
+  timeZone?: string;
+  iCalUid?: string;
+  cancelled: boolean;
+}
+
+export function normalizeGoogleResponse(value: unknown): MeetingResponse {
+  const parsed = MeetingResponseSchema.safeParse(value);
+  return parsed.success ? parsed.data : 'needsAction';
+}
+
+export function normalizeMicrosoftResponse(value: unknown): MeetingResponse {
+  switch (value) {
+    case 'accepted':
+    case 'organizer':
+      return 'accepted';
+    case 'declined':
+      return 'declined';
+    case 'tentativelyAccepted':
+      return 'tentative';
+    default:
+      return 'needsAction';
+  }
+}

package/src/onboarding.ts

@@ -109,6 +109,7 @@ const MISSIONS = [
     'confirmation_required',
     ['store', 'preview', 'checkout'],
   ],
+  ['lettin', 'build', 'confirmation_required', ['world', 'write', 'publish']],
   ['learn', 'learn', 'reversible', ['courses', 'study', 'progress']],
   ['mail', 'focus', 'confirmation_required', ['inbox', 'compose', 'follow_up']],
   ['meet', 'collaborate', 'confirmation_required', ['room', 'invite', 'meet']],

package/src/platform-release.test.ts

@@ -7,7 +7,7 @@ import {
 
 describe('platform release metadata', () => {
   it('uses the centralized shared browser app version', () => {
-    expect(TUTURUUU_PLATFORM_VERSION).toBe('0.46.0'); // x-release-please-version
+    expect(TUTURUUU_PLATFORM_VERSION).toBe('0.52.0'); // x-release-please-version
   });
 
   it('preserves the source timestamp in builtAt and derives a short hash', () => {

package/src/platform-release.ts

@@ -1,6 +1,6 @@
 import { PLATFORM_BUILD_METADATA } from './generated/platform-build-metadata';
 
-export const TUTURUUU_PLATFORM_VERSION = '0.46.0'; // x-release-please-version
+export const TUTURUUU_PLATFORM_VERSION = '0.52.0'; // x-release-please-version
 
 export type PlatformBuildMetadataInput = {
   /** ISO timestamp of the source commit used for the build, not deployment time. */

package/src/portless.ts

@@ -24,6 +24,7 @@ export const TUTURUUU_PORTLESS_APP_ORIGINS = {
   infra: `https://infra.${TUTURUUU_PORTLESS_ROOT_HOST}`,
   inventory: `https://inventory.${TUTURUUU_PORTLESS_ROOT_HOST}`,
   learn: `https://learn.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  lettin: `https://lettin.${TUTURUUU_PORTLESS_ROOT_HOST}`,
   mail: `https://mail.${TUTURUUU_PORTLESS_ROOT_HOST}`,
   meet: `https://meet.${TUTURUUU_PORTLESS_ROOT_HOST}`,
   mind: `https://mind.${TUTURUUU_PORTLESS_ROOT_HOST}`,