@spacefast/common 0.0.2

package/dist/utils/build-settings.js

@@ -0,0 +1,366 @@
+import { parse as parseToml } from "smol-toml";
+export const BUILD_ANALYZER_CANDIDATE_ROOTS = ["apps", "packages", "sites", "docs"];
+const PACKAGE_MANAGER_ONLY_FILES = new Set([
+    "package.json",
+    "bun.lock",
+    "bun.lockb",
+    "pnpm-lock.yaml",
+    "yarn.lock",
+    "package-lock.json",
+]);
+export function hasWorkspaceSignal(fileNames, packageJsonText) {
+    const names = new Set(fileNames);
+    if (names.has("pnpm-workspace.yaml") ||
+        names.has("turbo.json") ||
+        names.has("nx.json") ||
+        names.has("lerna.json")) {
+        return true;
+    }
+    if (!packageJsonText) {
+        return false;
+    }
+    try {
+        const parsed = JSON.parse(packageJsonText);
+        return (Array.isArray(parsed.workspaces) ||
+            (parsed.workspaces &&
+                typeof parsed.workspaces === "object" &&
+                Array.isArray(parsed.workspaces.packages)));
+    }
+    catch {
+        return false;
+    }
+}
+export function rankBuildAnalyzerCandidate(input) {
+    const names = new Set(input.fileNames);
+    const reasons = [];
+    let confidence = 0;
+    if (input.detected.platformPreset) {
+        confidence += 40;
+        reasons.push(`${input.detected.platformPreset} config`);
+    }
+    if (input.detected.frameworkPreset) {
+        confidence += 30;
+        reasons.push(`${input.detected.frameworkPreset} framework`);
+    }
+    if (input.detected.buildCommand) {
+        confidence += 20;
+        reasons.push("build script");
+    }
+    if (names.has("index.html")) {
+        confidence += 8;
+        reasons.push("static index");
+    }
+    if (input.rootDirectory === null) {
+        confidence += 2;
+        reasons.push("repository root");
+    }
+    else {
+        confidence += 5;
+        reasons.push("workspace app directory");
+    }
+    return { confidence, reasons };
+}
+export function hasBuildAnalyzerCandidateSignal(input) {
+    const names = new Set(input.fileNames);
+    return (input.detected.detectedFiles.some((file) => !PACKAGE_MANAGER_ONLY_FILES.has(file)) ||
+        input.detected.frameworkPreset !== null ||
+        input.detected.platformPreset !== null ||
+        input.detected.buildCommand !== null ||
+        names.has("index.html"));
+}
+function parseJsonObject(value) {
+    if (!value) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseJsonObjectWithComments(value) {
+    return parseJsonObject(value
+        ?.replace(/^\uFEFF/, "")
+        .replace(/(^|[^:])\/\/.*$/gm, "$1")
+        .replace(/\/\*[\s\S]*?\*\//g, ""));
+}
+function parseTomlObject(value) {
+    if (!value) {
+        return null;
+    }
+    try {
+        const parsed = parseToml(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function stringField(value, key) {
+    const field = value?.[key];
+    return typeof field === "string" && field.trim() ? field.trim() : null;
+}
+export function numberField(value, key) {
+    const field = value?.[key];
+    return typeof field === "number" ? field : null;
+}
+function objectField(value, key) {
+    const field = value?.[key];
+    return field && typeof field === "object" && !Array.isArray(field)
+        ? field
+        : null;
+}
+function arrayField(value, key) {
+    const field = value?.[key];
+    return Array.isArray(field)
+        ? field.filter((entry) => entry !== null && typeof entry === "object" && !Array.isArray(entry))
+        : [];
+}
+function vercelConfig(value) {
+    const config = parseJsonObjectWithComments(value);
+    if (!config) {
+        return null;
+    }
+    return {
+        platform: "vercel",
+        rootDirectory: stringField(config, "rootDirectory"),
+        installDirectory: null,
+        installCommand: stringField(config, "installCommand"),
+        buildCommand: stringField(config, "buildCommand"),
+        outputDirectory: stringField(config, "outputDirectory"),
+        redirects: arrayField(config, "redirects"),
+        rewrites: arrayField(config, "rewrites"),
+        headers: arrayField(config, "headers"),
+        unsupportedFeatures: [
+            ...("functions" in config ? ["Vercel functions are not converted."] : []),
+            ...("middleware" in config ? ["Vercel middleware is not converted."] : []),
+            ...("images" in config ? ["Vercel image optimization config is not converted."] : []),
+            ...("crons" in config ? ["Vercel cron jobs are not converted."] : []),
+        ],
+    };
+}
+function netlifyConfig(value) {
+    const config = parseTomlObject(value);
+    if (!config) {
+        return null;
+    }
+    const build = objectField(config, "build");
+    return {
+        platform: "netlify",
+        rootDirectory: stringField(build, "base") ?? stringField(config, "base"),
+        installDirectory: null,
+        installCommand: null,
+        buildCommand: stringField(build, "command"),
+        outputDirectory: stringField(build, "publish"),
+        redirects: arrayField(config, "redirects"),
+        rewrites: [],
+        headers: arrayField(config, "headers"),
+        unsupportedFeatures: [
+            ...("functions" in config ? ["Netlify functions are not converted."] : []),
+            ...("edge_functions" in config ? ["Netlify edge functions are not converted."] : []),
+            ...("plugins" in config ? ["Netlify build plugins are not converted."] : []),
+            ...("processing" in config ? ["Netlify post-processing config is not converted."] : []),
+        ],
+    };
+}
+function cloudflarePagesConfig(input) {
+    const toml = parseTomlObject(input.wranglerToml);
+    const json = parseJsonObjectWithComments(input.wranglerJson);
+    const config = json ?? toml;
+    if (!config) {
+        return null;
+    }
+    const build = objectField(config, "build");
+    const assets = objectField(config, "assets");
+    const unsupportedFeatures = [
+        ...("main" in config ? ["Cloudflare Worker entrypoints are not converted."] : []),
+        ...("kv_namespaces" in config ||
+            "r2_buckets" in config ||
+            "d1_databases" in config ||
+            "durable_objects" in config ||
+            "services" in config ||
+            "queues" in config ||
+            "vars" in config
+            ? ["Wrangler bindings are not converted."]
+            : []),
+        ...(assets && "run_worker_first" in assets
+            ? ["Cloudflare Worker-first static asset routing is not converted."]
+            : []),
+        ...(assets && "not_found_handling" in assets
+            ? ["Cloudflare static asset not-found handling is not converted."]
+            : []),
+    ];
+    return {
+        platform: "cloudflare-pages",
+        rootDirectory: null,
+        installDirectory: null,
+        installCommand: null,
+        buildCommand: stringField(config, "command") ?? stringField(build, "command"),
+        outputDirectory: stringField(assets, "directory") ?? stringField(config, "pages_build_output_dir"),
+        redirects: [],
+        rewrites: [],
+        headers: [],
+        unsupportedFeatures,
+    };
+}
+export function detectPlatformConfigs(input) {
+    return [
+        vercelConfig(input.vercelJson),
+        netlifyConfig(input.netlifyToml),
+        cloudflarePagesConfig(input),
+    ].filter((config) => Boolean(config));
+}
+function parsePackageJson(value) {
+    const parsed = parseJsonObject(value);
+    if (!parsed) {
+        return null;
+    }
+    const scripts = parsed.scripts;
+    const dependencies = parsed.dependencies;
+    const devDependencies = parsed.devDependencies;
+    return {
+        scripts: scripts && typeof scripts === "object" ? scripts : {},
+        dependencies: dependencies && typeof dependencies === "object"
+            ? dependencies
+            : {},
+        devDependencies: devDependencies && typeof devDependencies === "object"
+            ? devDependencies
+            : {},
+    };
+}
+function packageManagerForFiles(files) {
+    if (files.has("bun.lock") || files.has("bun.lockb"))
+        return "bun";
+    if (files.has("pnpm-lock.yaml"))
+        return "pnpm";
+    if (files.has("yarn.lock"))
+        return "yarn";
+    return "npm";
+}
+function detectFrameworkPreset(files, dependencies) {
+    if ("next" in dependencies)
+        return "next";
+    if ("@tanstack/react-start" in dependencies)
+        return "tanstack-start";
+    if ("vite" in dependencies)
+        return "vite";
+    if ("astro" in dependencies)
+        return "astro";
+    if ("@sveltejs/kit" in dependencies)
+        return "sveltekit";
+    if ("gatsby" in dependencies)
+        return "gatsby";
+    if ("@remix-run/dev" in dependencies)
+        return "remix";
+    if ("@docusaurus/core" in dependencies)
+        return "docusaurus";
+    if (files.has("hugo.toml") || files.has("config.toml"))
+        return "hugo";
+    if (files.has("_config.yml") || files.has("_config.yaml"))
+        return "jekyll";
+    return null;
+}
+function outputDirectoryForFramework(frameworkPreset, files) {
+    switch (frameworkPreset) {
+        case "next":
+            return "out";
+        case "tanstack-start":
+            return "dist/client";
+        case "gatsby":
+            return "public";
+        case "sveltekit":
+            return "build";
+        case "remix":
+            return "build/client";
+        case "docusaurus":
+            return "build";
+        case "hugo":
+            return "public";
+        case "jekyll":
+            return "_site";
+        default:
+            return files.has("dist") ? "dist" : null;
+    }
+}
+function installCommandForManager(packageManager, packageJson) {
+    switch (packageManager) {
+        case "bun":
+            return "bun install --frozen-lockfile";
+        case "pnpm":
+            return "corepack enable && pnpm install --frozen-lockfile";
+        case "yarn":
+            return "corepack enable && (yarn install --immutable || yarn install --frozen-lockfile)";
+        default:
+            return packageJson ? "npm ci" : null;
+    }
+}
+function buildCommandForDefaults(packageJson, run, frameworkPreset) {
+    if (packageJson?.scripts?.build)
+        return `${run} build`;
+    if (frameworkPreset === "hugo")
+        return "hugo";
+    if (frameworkPreset === "jekyll")
+        return "bundle exec jekyll build";
+    return null;
+}
+function packageDefaults(files, packageJsonText) {
+    const packageJson = parsePackageJson(packageJsonText);
+    const dependencies = {
+        ...packageJson?.dependencies,
+        ...packageJson?.devDependencies,
+    };
+    const packageManager = packageManagerForFiles(files);
+    const run = packageManager === "npm" ? "npm run" : packageManager === "bun" ? "bun run" : packageManager;
+    const frameworkPreset = detectFrameworkPreset(files, dependencies);
+    return {
+        frameworkPreset,
+        installCommand: installCommandForManager(packageManager, packageJson),
+        buildCommand: buildCommandForDefaults(packageJson, run, frameworkPreset),
+        outputDirectory: outputDirectoryForFramework(frameworkPreset, files),
+    };
+}
+export function detectBuildSettings(input) {
+    const files = new Set(input.fileNames);
+    const defaults = {
+        ...packageDefaults(files, input.packageJson),
+        rootDirectory: input.rootDirectory ?? null,
+        platformPreset: null,
+        detectedFiles: [
+            input.packageJson ? "package.json" : null,
+            files.has("bun.lock") ? "bun.lock" : null,
+            files.has("bun.lockb") ? "bun.lockb" : null,
+            files.has("pnpm-lock.yaml") ? "pnpm-lock.yaml" : null,
+            files.has("yarn.lock") ? "yarn.lock" : null,
+            files.has("package-lock.json") ? "package-lock.json" : null,
+        ].filter((file) => Boolean(file)),
+    };
+    const vercelFramework = input.vercelJson
+        ? stringField(parseJsonObjectWithComments(input.vercelJson), "framework")
+        : null;
+    for (const config of detectPlatformConfigs(input)) {
+        defaults.platformPreset = defaults.platformPreset ?? config.platform;
+        defaults.rootDirectory = config.rootDirectory ?? defaults.rootDirectory;
+        defaults.installCommand = config.installCommand ?? defaults.installCommand;
+        defaults.buildCommand = config.buildCommand ?? defaults.buildCommand;
+        defaults.outputDirectory = config.outputDirectory ?? defaults.outputDirectory;
+        if (config.platform === "vercel") {
+            defaults.frameworkPreset = vercelFramework ?? defaults.frameworkPreset;
+        }
+    }
+    if (input.vercelJson) {
+        defaults.detectedFiles.push("vercel.json");
+    }
+    if (input.netlifyToml) {
+        defaults.detectedFiles.push("netlify.toml");
+    }
+    if (input.wranglerJson || input.wranglerToml) {
+        defaults.detectedFiles.push(input.wranglerJson ? "wrangler.json" : "wrangler.toml");
+    }
+    return defaults;
+}

package/dist/utils/claim-token.d.ts

@@ -0,0 +1 @@
+export declare function normalizeClaimToken(token: string | null | undefined): string | undefined;

package/dist/utils/claim-token.js

@@ -0,0 +1,9 @@
+export function normalizeClaimToken(token) {
+    const normalized = token
+        ?.trim()
+        .toLowerCase()
+        .split(/[\s_-]+/)
+        .filter(Boolean)
+        .join("-");
+    return normalized || undefined;
+}

package/dist/utils/collections.d.ts

@@ -0,0 +1 @@
+export declare function sortCopy<T>(values: readonly T[], compareFn: (left: T, right: T) => number): T[];

package/dist/utils/collections.js

@@ -0,0 +1,5 @@
+export function sortCopy(values, compareFn) {
+    const copy = [...values];
+    copy.sort(compareFn);
+    return copy;
+}

package/dist/utils/concurrency.d.ts

@@ -0,0 +1 @@
+export declare function mapConcurrent<T, R>(items: readonly T[], limit: number, mapper: (item: T, index: number) => Promise<R>): Promise<R[]>;

package/dist/utils/concurrency.js

@@ -0,0 +1,18 @@
+export async function mapConcurrent(items, limit, mapper) {
+    if (!Number.isInteger(limit) || limit < 1) {
+        throw new Error("Concurrency limit must be a positive integer.");
+    }
+    const results = [];
+    let nextIndex = 0;
+    async function worker() {
+        const index = nextIndex;
+        nextIndex += 1;
+        if (index >= items.length) {
+            return;
+        }
+        results[index] = await mapper(items[index], index);
+        await worker();
+    }
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+    return results;
+}

package/dist/utils/content-type.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Map a file extension to a Content-Type header value. Returns
+ * `application/octet-stream` when the extension is not recognized.
+ *
+ * This is the superset of the extensions handled by the control-plane
+ * runtime service and the spacefast-cli uploader, so both sides agree on the
+ * same content types when uploading and serving version files.
+ */
+export declare function contentTypeForPath(filePath: string): string;
+export declare function contentTypeForBytes(filePath: string, bytes: Uint8Array): string;

package/dist/utils/content-type.js

@@ -0,0 +1,145 @@
+/**
+ * Map a file extension to a Content-Type header value. Returns
+ * `application/octet-stream` when the extension is not recognized.
+ *
+ * This is the superset of the extensions handled by the control-plane
+ * runtime service and the spacefast-cli uploader, so both sides agree on the
+ * same content types when uploading and serving version files.
+ */
+export function contentTypeForPath(filePath) {
+    const extensionIndex = filePath.lastIndexOf(".");
+    const extension = extensionIndex >= 0 ? filePath.slice(extensionIndex).toLowerCase() : "";
+    switch (extension) {
+        case ".html":
+        case ".htm":
+            return "text/html; charset=utf-8";
+        case ".css":
+            return "text/css; charset=utf-8";
+        case ".js":
+        case ".mjs":
+        case ".cjs":
+            return "text/javascript; charset=utf-8";
+        case ".json":
+        case ".map":
+            return "application/json; charset=utf-8";
+        case ".webmanifest":
+            return "application/manifest+json; charset=utf-8";
+        case ".gz":
+        case ".tgz":
+            return "application/gzip";
+        case ".txt":
+        case ".sh":
+            return "text/plain; charset=utf-8";
+        case ".md":
+            return "text/markdown; charset=utf-8";
+        case ".csv":
+            return "text/csv; charset=utf-8";
+        case ".xml":
+            return "application/xml; charset=utf-8";
+        case ".svg":
+            return "image/svg+xml";
+        case ".png":
+            return "image/png";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".gif":
+            return "image/gif";
+        case ".webp":
+            return "image/webp";
+        case ".avif":
+            return "image/avif";
+        case ".ico":
+            return "image/x-icon";
+        case ".pdf":
+            return "application/pdf";
+        case ".woff":
+            return "font/woff";
+        case ".woff2":
+            return "font/woff2";
+        case ".ttf":
+            return "font/ttf";
+        case ".otf":
+            return "font/otf";
+        case ".wasm":
+            return "application/wasm";
+        default:
+            return "application/octet-stream";
+    }
+}
+function hasPrefix(bytes, prefix) {
+    return prefix.every((value, index) => bytes[index] === value);
+}
+function hasAsciiPrefix(bytes, prefix) {
+    return hasPrefix(bytes, Array.from(prefix, (char) => char.charCodeAt(0)));
+}
+function textTypeForPath(filePath) {
+    const contentType = contentTypeForPath(filePath);
+    const normalized = contentType.split(";")[0]?.trim().toLowerCase();
+    return normalized &&
+        (normalized.startsWith("text/") ||
+            normalized === "application/json" ||
+            normalized === "application/manifest+json" ||
+            normalized === "application/xml" ||
+            normalized === "image/svg+xml")
+        ? contentType
+        : null;
+}
+function bytesLookTextual(bytes) {
+    const sample = bytes.slice(0, Math.min(bytes.length, 512));
+    if (sample.length === 0) {
+        return true;
+    }
+    for (const byte of sample) {
+        if (byte === 0) {
+            return false;
+        }
+        if (byte < 0x08 || (byte > 0x0d && byte < 0x20)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function contentTypeForBytes(filePath, bytes) {
+    if (hasPrefix(bytes, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) {
+        return "image/png";
+    }
+    if (hasPrefix(bytes, [0xff, 0xd8, 0xff])) {
+        return "image/jpeg";
+    }
+    if (hasAsciiPrefix(bytes, "GIF87a") || hasAsciiPrefix(bytes, "GIF89a")) {
+        return "image/gif";
+    }
+    if (hasAsciiPrefix(bytes, "RIFF") && hasAsciiPrefix(bytes.slice(8), "WEBP")) {
+        return "image/webp";
+    }
+    if (hasAsciiPrefix(bytes.slice(4), "ftypavif") || hasAsciiPrefix(bytes.slice(4), "ftypavis")) {
+        return "image/avif";
+    }
+    if (hasPrefix(bytes, [0x00, 0x00, 0x01, 0x00])) {
+        return "image/x-icon";
+    }
+    if (hasAsciiPrefix(bytes, "%PDF-")) {
+        return "application/pdf";
+    }
+    if (hasPrefix(bytes, [0x1f, 0x8b, 0x08])) {
+        return "application/gzip";
+    }
+    if (hasAsciiPrefix(bytes, "wOFF")) {
+        return "font/woff";
+    }
+    if (hasAsciiPrefix(bytes, "wOF2")) {
+        return "font/woff2";
+    }
+    if (hasPrefix(bytes, [0x00, 0x01, 0x00, 0x00]) || hasAsciiPrefix(bytes, "true")) {
+        return "font/ttf";
+    }
+    if (hasAsciiPrefix(bytes, "OTTO")) {
+        return "font/otf";
+    }
+    const textType = textTypeForPath(filePath);
+    if (textType && bytesLookTextual(bytes)) {
+        return textType;
+    }
+    return "application/octet-stream";
+}

package/dist/utils/error-display.d.ts

@@ -0,0 +1,7 @@
+type ErrorDescription = {
+    message: string;
+    details: string[];
+};
+export declare function describeError(error: unknown): ErrorDescription;
+export declare function formatErrorMessage(error: unknown): string;
+export {};

package/dist/utils/error-display.js

@@ -0,0 +1,42 @@
+import { ApiError } from "./api.js";
+function baseMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function detailLines(error) {
+    if (!(error instanceof ApiError) || !error.details) {
+        return [];
+    }
+    const lines = [];
+    const { details } = error;
+    const missingPaths = details.missingPaths;
+    if (Array.isArray(missingPaths)) {
+        const paths = missingPaths.filter((entry) => typeof entry === "string");
+        if (paths.length > 0) {
+            lines.push(`Missing files: ${paths.join(", ")}`);
+        }
+    }
+    const path = details.path;
+    if (typeof path === "string" && path && lines.length === 0) {
+        lines.push(`Path: ${path}`);
+    }
+    if (error.requestId) {
+        lines.push(`Request ID: ${error.requestId}`);
+    }
+    return lines;
+}
+export function describeError(error) {
+    return {
+        message: baseMessage(error),
+        details: detailLines(error),
+    };
+}
+export function formatErrorMessage(error) {
+    const description = describeError(error);
+    if (description.details.length === 0) {
+        return description.message;
+    }
+    return `${description.message} ${description.details.join(" ")}`;
+}

package/dist/utils/error.d.ts

@@ -0,0 +1 @@
+export declare function errorMessage(error: unknown): string;

package/dist/utils/error.js

@@ -0,0 +1,3 @@
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/utils/generate-space-name.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Generates a whimsical, WordPress-flavored space title.
+ *
+ * The pool mixes WordPress jargon (Codex, Permalink, Gutenberg, Pingback)
+ * with engineering/web adjectives so the output reads like a tiny inside
+ * joke instead of an auto-increment. Users can rename later, so the only
+ * requirement is that two back-to-back calls almost never collide.
+ *
+ * Pool size: 32 × 32 = 1024 combinations. Combined with the collision
+ * handling in `uniqueSpaceSlug`, per-team conflicts are very
+ * unlikely. The generator is intentionally dependency-free so it can be
+ * shared by the control-plane, the CLI, and any future surface.
+ */
+export declare function generateSpaceTitle(): string;