@moloodev/platform 0.0.0-stage → 0.1.0

package/src/naming.ts

@@ -0,0 +1,128 @@
+type CopySeparator = "-" | "_";
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+const COMPOUND_EXTENSIONS = [
+  ".layout.json",
+  ".loop.json",
+  ".table.json",
+  ".catalog.json",
+  ".bundle.json",
+  ".tar.gz",
+  ".tar.bz2",
+  ".tar.xz",
+  ".tar.zst",
+] as const;
+
+const SINGLE_EXTENSION = /^(.+)(\.(?=[A-Za-z0-9]{1,10}$)[0-9]*[A-Za-z][A-Za-z0-9]*)$/;
+
+/**
+ * Split a file name into stem and extension, recognizing compound extensions
+ * (`.layout.json`, `.tar.gz`, …) before single extensions (`.md`, `.png`, …).
+ * Dotfiles (`.keep`, `.env`) and version-like tails (`v1.0`) have `extension: ""`.
+ */
+export function splitFileName(name: string): {
+  stem: string;
+  extension: string;
+} {
+  const lower = name.toLowerCase();
+  for (const compound of COMPOUND_EXTENSIONS) {
+    if (lower.endsWith(compound) && name.length > compound.length) {
+      const stem = name.slice(0, name.length - compound.length);
+      if (stem && stem !== ".") {
+        return {
+          stem,
+          extension: name.slice(name.length - compound.length),
+        };
+      }
+    }
+  }
+  const match = SINGLE_EXTENSION.exec(name);
+  if (!match) return { stem: name, extension: "" };
+  return { stem: match[1]!, extension: match[2]! };
+}
+
+/**
+ * Split an uploaded file name into single stem and extension (`notes.md` →
+ * `notes` + `.md`, `archive.tar.gz` → `archive.tar` + `.gz`).
+ */
+export function splitFileExtension(name: string): {
+  stem: string;
+  extension: string;
+} {
+  const match = SINGLE_EXTENSION.exec(name);
+  if (!match) return { stem: name, extension: "" };
+  return { stem: match[1]!, extension: match[2]! };
+}
+
+/**
+ * Next numbered copy name among siblings: `{stem}{separator}2{extension}`,
+ * `{stem}{separator}3{extension}`, …
+ * Bare `{stem}{extension}` counts as 1; gaps ignored (uses max). Separator defaults to "-".
+ */
+export function nextNumberedCopyName(
+  stem: string,
+  siblingNames: readonly string[],
+  opts?: { bareWhenFree?: true; separator?: CopySeparator; extension?: string },
+): string {
+  const separator = opts?.separator ?? "-";
+  const extension = opts?.extension ?? "";
+  const pattern = new RegExp(
+    `^${escapeRegExp(stem)}(?:${escapeRegExp(separator)}(\\d+))?${escapeRegExp(extension)}$`,
+    "i",
+  );
+  let max = 0;
+  let bareTaken = false;
+  for (const name of siblingNames) {
+    const match = pattern.exec(name);
+    if (!match) continue;
+    if (!match[1]) bareTaken = true;
+    const n = match[1] ? Number(match[1]) : 1;
+    if (Number.isFinite(n) && n > max) max = n;
+  }
+  if (opts?.bareWhenFree && !bareTaken) return `${stem}${extension}`;
+  if (max === 0) return `${stem}${separator}2${extension}`;
+  return `${stem}${separator}${max + 1}${extension}`;
+}
+
+/**
+ * Strip one trailing `{separator}{n}` from the stem of `sourceName` (preserving
+ * any file extension) so `coin-spin-2.png` shares the `coin-spin.png` series.
+ */
+export function duplicateSeriesStem(
+  sourceName: string,
+  separator: CopySeparator = "-",
+): string {
+  const { stem, extension } = splitFileName(sourceName);
+  const match = new RegExp(`^(.*)${escapeRegExp(separator)}(\\d+)$`).exec(stem);
+  if (!match || !match[1]) return sourceName;
+  return `${match[1]}${extension}`;
+}
+
+/**
+ * Next duplicate asset/file name: `{stem}-2{extension}`, `{stem}-3{extension}`, …
+ */
+export function nextDuplicateName(
+  sourceName: string,
+  siblingNames: readonly string[],
+): string {
+  const { stem, extension } = splitFileName(duplicateSeriesStem(sourceName));
+  return nextNumberedCopyName(stem, siblingNames, { extension });
+}
+
+/**
+ * Allocate a free name for create: prefer bare `{stem}{extension}`, then
+ * `{stem}-2{extension}`, `{stem}-3{extension}`, …
+ */
+export function allocateCreateName(
+  desiredName: string,
+  siblingNames: readonly string[],
+): string {
+  const { stem, extension } = splitFileName(desiredName);
+  return nextNumberedCopyName(stem, siblingNames, {
+    bareWhenFree: true,
+    extension,
+  });
+}

package/src/network.ts

@@ -0,0 +1,88 @@
+const NETWORK_LIMIT = 20;
+const RESERVED_SUFFIXES = ["moloo.dev", "moloo.sh"];
+
+function invalid(detail: string): never {
+  throw new Error(`Invalid editor manifest: ${detail}`);
+}
+
+/** A trailing DNS dot still names the host, so the block check ignores it. */
+function policyHost(hostname: string): string {
+  let host = hostname;
+  while (host.endsWith(".")) host = host.slice(0, -1);
+  return host;
+}
+
+function reservedHost(hostname: string): string | undefined {
+  const host = policyHost(hostname);
+  const suffix = RESERVED_SUFFIXES.find(
+    (item) => host === item || host.endsWith(`.${item}`),
+  );
+  return suffix === undefined ? undefined : host;
+}
+
+function requireOrigin(value: unknown, index: number): string {
+  const field = `network.${index}`;
+  if (typeof value !== "string") {
+    invalid(`${field} must be an https origin`);
+  }
+  if (/^http:\/\//i.test(value)) {
+    invalid(`${field} must not use http`);
+  }
+  if (value.includes("*")) {
+    invalid(`${field} must not use a wildcard`);
+  }
+  if (/[A-Z]/.test(value)) {
+    invalid(`${field} must be lowercase`);
+  }
+  if (value.includes("@")) {
+    invalid(`${field} must not include userinfo`);
+  }
+  if (value.includes("?")) {
+    invalid(`${field} must not include a query`);
+  }
+  if (value.includes("#")) {
+    invalid(`${field} must not include a fragment`);
+  }
+  if (value.startsWith("https://") && value.slice("https://".length).includes("/")) {
+    invalid(`${field} must not include a path`);
+  }
+
+  let url: URL;
+  try {
+    url = new URL(value);
+  } catch {
+    invalid(`${field} must be an https origin (https://host[:port])`);
+  }
+  if (url.protocol !== "https:") {
+    invalid(`${field} must use https`);
+  }
+  if (value !== url.origin) {
+    invalid(`${field} must be an https origin (https://host[:port])`);
+  }
+  const blocked = reservedHost(url.hostname);
+  if (blocked !== undefined) {
+    invalid(`${field} must not target ${blocked}`);
+  }
+  return value;
+}
+
+/**
+ * HTTPS origins a manifest may declare.
+ * Missing means none. Entries are returned unchanged.
+ */
+export function parseNetwork(input: unknown): string[] {
+  if (input === undefined) return [];
+  if (!Array.isArray(input)) invalid("network must be an array");
+  if (input.length > NETWORK_LIMIT) {
+    invalid(`network accepts at most ${NETWORK_LIMIT} origins`);
+  }
+  const seen = new Set<string>();
+  const origins: string[] = [];
+  for (const [index, value] of input.entries()) {
+    const origin = requireOrigin(value, index);
+    if (seen.has(origin)) invalid(`network.${index} duplicates ${origin}`);
+    seen.add(origin);
+    origins.push(origin);
+  }
+  return origins;
+}

package/src/occupancy-protocol.ts

@@ -0,0 +1,85 @@
+export type OccupancyClientMessage =
+  | { type: "join"; assetId: string; tabId?: string }
+  | { type: "leave"; assetId: string };
+
+type OccupancyServerMessage = {
+  type: "snapshot";
+  editors: Record<string, string[]>;
+};
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.length > 0;
+}
+
+export function parseOccupancyClient(
+  raw: string,
+): OccupancyClientMessage | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const rec = parsed as Record<string, unknown>;
+  if (
+    (rec.type === "join" || rec.type === "leave") &&
+    isNonEmptyString(rec.assetId)
+  ) {
+    if (rec.type === "join" && isNonEmptyString(rec.tabId)) {
+      return { type: "join", assetId: rec.assetId, tabId: rec.tabId };
+    }
+    return { type: rec.type, assetId: rec.assetId };
+  }
+  return null;
+}
+
+export function parseOccupancyServer(
+  raw: string,
+): OccupancyServerMessage | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const rec = parsed as Record<string, unknown>;
+  if (rec.type !== "snapshot" || !rec.editors || typeof rec.editors !== "object") {
+    return null;
+  }
+  const editors: Record<string, string[]> = {};
+  for (const [assetId, userIds] of Object.entries(
+    rec.editors as Record<string, unknown>,
+  )) {
+    if (!Array.isArray(userIds) || !userIds.every((id) => typeof id === "string")) {
+      return null;
+    }
+    editors[assetId] = userIds;
+  }
+  return { type: "snapshot", editors };
+}
+
+export function stringifyOccupancyClient(message: OccupancyClientMessage): string {
+  return JSON.stringify(message);
+}
+
+export function stringifyOccupancyServer(message: OccupancyServerMessage): string {
+  return JSON.stringify(message);
+}
+
+export function occupancyCanSend(ready: boolean): boolean {
+  return ready;
+}
+
+export function applyOccupancyIntent(
+  wanted: string | null,
+  action: OccupancyClientMessage,
+): { wanted: string | null; send: OccupancyClientMessage | null } {
+  if (action.type === "join") {
+    if (wanted === action.assetId) return { wanted, send: null };
+    return { wanted: action.assetId, send: action };
+  }
+  if (wanted !== action.assetId) return { wanted, send: null };
+  return { wanted: null, send: action };
+}

package/src/origins.ts

@@ -0,0 +1,45 @@
+import { IDENTITY_ISSUER, MARKETING_SITE, resolveSiteOrigin } from "./platform";
+import { resolveSiteEnv, type SiteEnv } from "./url";
+import { getWorkspaceHostUrl } from "./workspace-host";
+
+/** Marketing apex (`apps/web`). */
+export function getMarketingOrigin(
+  env: SiteEnv = resolveSiteEnv(),
+): string {
+  return resolveSiteOrigin(MARKETING_SITE, env);
+}
+
+/** Identity issuer (`apps/id`). Production is `https://id.moloo.dev`; otherwise the catalog local origin. */
+export function getIdOrigin(env: SiteEnv = resolveSiteEnv()): string {
+  return resolveSiteOrigin(IDENTITY_ISSUER, env);
+}
+
+/** Account settings on the identity issuer. */
+export function getIdAccountUrl(
+  env: SiteEnv = resolveSiteEnv(),
+): string {
+  return `${getIdOrigin(env)}/account/profile`;
+}
+
+/** Sign-in page on the identity issuer. */
+export function getIdSignInUrl(
+  env: SiteEnv = resolveSiteEnv(),
+): string {
+  return `${getIdOrigin(env)}/sign-in`;
+}
+
+/** Workspace on the app host (`https://app.moloo.dev/w/{slug}`). */
+export function getWorkspaceUrl(
+  slug: string,
+  env: SiteEnv = resolveSiteEnv(),
+): string {
+  return `${getWorkspaceHostUrl(env)}/w/${slug}`;
+}
+
+/** Invite accept page on the app host. The invitation id selects the workspace. */
+export function getInviteUrl(
+  invitationId: string,
+  env: SiteEnv = resolveSiteEnv(),
+): string {
+  return `${getWorkspaceHostUrl(env)}/invite/${invitationId}`;
+}

package/src/platform.ts

@@ -0,0 +1,115 @@
+import type { AppIcon } from "./app-icon";
+import { resolveSiteEnv, type SiteEnv } from "./url";
+
+export type PlatformAppId = "api" | "status" | "admin";
+
+export type SiteOriginRef = {
+  localPort: number;
+  productionHost: string;
+};
+
+export type PlatformApp = SiteOriginRef & {
+  id: PlatformAppId;
+  name: string;
+  tagline: string;
+  icon: AppIcon;
+  color: string;
+  /** Path appended to the origin for chrome entry. */
+  entryPath?: string;
+  /** Hide from chrome unless the session user has the admin role. */
+  requiresAdmin?: boolean;
+  /**
+   * When false, omit from platform chrome lists.
+   * The app remains resolvable by id (e.g. user-menu deep links).
+   */
+  showInSwitcher?: boolean;
+};
+
+/** Marketing apex (`apps/web`) — not shown in the site switcher. */
+export const MARKETING_SITE: SiteOriginRef = {
+  localPort: 3000,
+  productionHost: "moloo.dev",
+};
+
+/** Identity issuer (`apps/id`) — not shown in the site switcher. */
+export const IDENTITY_ISSUER: SiteOriginRef = {
+  localPort: 3002,
+  productionHost: "id.moloo.dev",
+};
+
+/**
+ * Infrastructure apps shown only via explicit links (not the site switcher).
+ */
+export const PLATFORM_APPS: readonly PlatformApp[] = [
+  {
+    id: "api",
+    name: "API",
+    tagline: "게이트웨이",
+    icon: "code",
+    color: "#34d399",
+    localPort: 3004,
+    productionHost: "api.moloo.dev",
+    showInSwitcher: false,
+  },
+  {
+    id: "status",
+    name: "Status",
+    tagline: "상태",
+    icon: "activity",
+    color: "#fb7185",
+    localPort: 3005,
+    productionHost: "status.moloo.dev",
+    showInSwitcher: false,
+  },
+  {
+    id: "admin",
+    name: "Admin",
+    tagline: "운영",
+    icon: "shield",
+    color: "#a78bfa",
+    localPort: 3006,
+    productionHost: "admin.moloo.dev",
+    requiresAdmin: true,
+    showInSwitcher: false,
+  },
+];
+
+/** Dev server port from the site catalog. */
+export function resolveDevPort(site: Pick<SiteOriginRef, "localPort">): number {
+  return site.localPort;
+}
+
+function localHost(productionHost: string): string {
+  return productionHost === "moloo.dev"
+    ? "local.moloo.dev"
+    : productionHost.replace(".moloo.dev", ".local.moloo.dev");
+}
+
+/**
+ * `NODE_ENV=production` uses the production host.
+ * Every other value uses the local host and the catalog port.
+ */
+export function resolveSiteOrigin(
+  site: SiteOriginRef,
+  env: SiteEnv = resolveSiteEnv(),
+): string {
+  return env === "production"
+    ? `https://${site.productionHost}`
+    : `https://${localHost(site.productionHost)}:${site.localPort}`;
+}
+
+export function getPlatformAppById(
+  id: string,
+): PlatformApp | undefined {
+  return PLATFORM_APPS.find((app) => app.id === id);
+}
+
+export function getPlatformAppUrl(
+  app: Pick<PlatformApp, "localPort" | "productionHost" | "entryPath">,
+  env: SiteEnv = resolveSiteEnv(),
+): string {
+  const origin = resolveSiteOrigin(app, env);
+  const path = app.entryPath?.trim();
+  if (!path) return origin;
+  return `${origin}${path.startsWith("/") ? path : `/${path}`}`;
+}

package/src/qualified-name.ts

@@ -0,0 +1,21 @@
+/**
+ * VS Code identifier: `${publisher}.${name}`.
+ * Shared by editor ids and asset kind ids.
+ * @see https://code.visualstudio.com/api/references/extension-manifest
+ */
+const QUALIFIED_NAME = /^([a-z0-9A-Z][a-z0-9-A-Z]*)\.([a-z0-9A-Z][a-z0-9-A-Z]*)$/;
+
+export type QualifiedName = {
+  publisher: string;
+  name: string;
+};
+
+export function parseQualifiedName(id: string): QualifiedName | null {
+  const match = QUALIFIED_NAME.exec(id);
+  if (!match) return null;
+  return { publisher: match[1]!, name: match[2]! };
+}
+
+export function isQualifiedName(id: string): boolean {
+  return QUALIFIED_NAME.test(id);
+}

package/src/trusted-origins.ts

@@ -0,0 +1,35 @@
+import {
+  IDENTITY_ISSUER,
+  MARKETING_SITE,
+  PLATFORM_APPS,
+  resolveSiteOrigin,
+} from "./platform";
+import type { SiteEnv } from "./url";
+import { WORKSPACE_HOST } from "./workspace-host";
+
+export function matchTrustedOrigin(
+  origin: string | null | undefined,
+  origins: readonly string[],
+): origin is string {
+  if (!origin) return false;
+  return origins.includes(origin);
+}
+
+export function isTrustedBrowserOrigin(
+  origin: string | null | undefined,
+  env: SiteEnv,
+): boolean {
+  if (!origin) return false;
+  let url: URL;
+  try {
+    url = new URL(origin);
+  } catch {
+    return false;
+  }
+  if (url.origin !== origin || url.protocol !== "https:" || url.hostname.endsWith(".")) {
+    return false;
+  }
+  const admin = PLATFORM_APPS.find((app) => app.id === "admin");
+  return [MARKETING_SITE, IDENTITY_ISSUER, WORKSPACE_HOST, ...(admin ? [admin] : [])]
+    .some((site) => url.origin === resolveSiteOrigin(site, env));
+}

package/src/url.ts

@@ -0,0 +1,16 @@
+export type SiteEnv = "development" | "production";
+
+export function resolveSiteEnv(
+  hint?: boolean | "development" | "production",
+): SiteEnv {
+  if (hint === "development" || hint === "production") return hint;
+  if (typeof hint === "boolean") return hint ? "development" : "production";
+  try {
+    const nodeEnv = (globalThis as { process?: { env?: { NODE_ENV?: string } } })
+      .process?.env?.NODE_ENV;
+    if (nodeEnv === "production") return "production";
+  } catch {
+    // ignore
+  }
+  return "development";
+}

package/src/workspace-host.ts

@@ -0,0 +1,46 @@
+import { resolveSiteOrigin, type SiteOriginRef } from "./platform";
+import { resolveSiteEnv, type SiteEnv } from "./url";
+
+/** First-party workspace host (`apps/app`). */
+export const WORKSPACE_HOST: SiteOriginRef = {
+  localPort: 3008,
+  productionHost: "app.moloo.dev",
+};
+
+/** Gateway product surface for the workspace host. */
+export const WORKSPACE_HOST_API = {
+  id: "app",
+  apiVersion: "v1",
+  name: "App",
+} as const;
+
+const SLUG_RE = /^[a-z0-9](?:[a-z0-9-]{0,30}[a-z0-9])$/;
+export const WORKSPACE_SLUG_MAX = 32;
+const SLUG_MIN = 2;
+
+/** Why a workspace slug was rejected. Hosts map codes to copy. */
+export type WorkspaceSlugInputError = "empty" | "too_short" | "invalid_chars";
+
+export function normalizeWorkspaceSlug(
+  raw: string,
+): { ok: true; slug: string } | { ok: false; error: WorkspaceSlugInputError } {
+  const slug = raw.trim().toLowerCase();
+  if (!slug) return { ok: false, error: "empty" };
+  if (slug.length < SLUG_MIN) {
+    return { ok: false, error: "too_short" };
+  }
+  if (!SLUG_RE.test(slug)) {
+    return { ok: false, error: "invalid_chars" };
+  }
+  return { ok: true, slug };
+}
+
+export function getWorkspaceHostUrl(
+  env: SiteEnv = resolveSiteEnv(),
+): string {
+  return resolveSiteOrigin(WORKSPACE_HOST, env);
+}
+
+export function resolveWorkspaceHostDevPort(): number {
+  return WORKSPACE_HOST.localPort;
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.