create-ailk 0.1.0 → 0.2.0

package/dist/lib/extract-module-bundle.js

@@ -0,0 +1,184 @@
+/**
+ * Paid-module-bundle tar.gz extract, with path-traversal protection (K1,
+ * #5089 — Flavor 3).
+ *
+ * Security posture is a line-for-line port of
+ * `packages/cli/src/lib/extract-bundle.ts` (`extractBundle`) — fail-closed on
+ * every unsafe entry:
+ *   - Reject entries whose normalized path escapes the staging root (any
+ *     `..` segment, absolute paths, or any path that resolves outside).
+ *   - Reject ANY symlink / hardlink entry.
+ *   - Cap extracted-entry count + cumulative size to prevent zip-bomb-style
+ *     denial-of-service.
+ *   - Strip setuid/setgid mode bits.
+ *
+ * NOT a straight import of `extractBundle` — see `fetch-module.ts`'s file
+ * doc for why `create-ailk` (the one publicly-published package in this
+ * monorepo) cannot take a runtime dependency on anything in
+ * `packages/cli/src/lib/`, which is `publishConfig.access: "restricted"`.
+ * This is a deliberate, named duplication of the guard logic, not a
+ * reimplementation of a different one.
+ *
+ * ONE difference from `extractBundle`, required by the caller's shape:
+ * `extractBundle` extracts into an EMPTY staging dir that then swap-renames
+ * over the (possibly pre-existing) install target — appropriate for a single
+ * self-contained skill directory. A fetched module's files are scattered
+ * across an ALREADY-SCAFFOLDED tree (`apps/api/src/routes/...`,
+ * `apps/web/app/...`), so there is no single directory to rename over.
+ * `extractModuleBundle` therefore extracts into a throwaway temp dir first
+ * (same validation, same guards), and ONLY on full success copies each
+ * validated file into its place under `targetDir` — so a rejected or
+ * partially-decompressed bundle never touches the scaffold at all.
+ */
+import { copyFileSync, createReadStream, existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { createGunzip } from "node:zlib";
+import * as tar from "tar";
+/** Soft limits to prevent decompression-bomb / zip-bomb attacks. Same values as extractBundle. */
+const MAX_ENTRIES = 1000;
+const MAX_TOTAL_SIZE_BYTES = 50 * 1024 * 1024; // 50 MiB
+/**
+ * Extract a fetched module bundle into `targetDir`, merging its files onto
+ * the tree `copyTemplate` already wrote. Throws on any unsafe entry,
+ * decompress error, or limit overrun — `targetDir` is left untouched on
+ * failure (validation completes in a throwaway staging dir before any file
+ * is copied into place).
+ */
+export async function extractModuleBundle(options) {
+    const { bytes, targetDir, moduleName } = options;
+    const targetAbs = resolve(targetDir);
+    if (!existsSync(targetAbs)) {
+        throw new Error(`extractModuleBundle: target directory does not exist: ${targetAbs}`);
+    }
+    const stagingDir = mkdtempSync(join(tmpdir(), `ailk-module-${moduleName}-`));
+    const stagingTar = join(stagingDir, "bundle.tar.gz");
+    try {
+        writeFileSync(stagingTar, bytes);
+        const extractedRoot = join(stagingDir, "extracted");
+        mkdirSync(extractedRoot, { recursive: true });
+        await safeExtractTarGz(stagingTar, extractedRoot, moduleName);
+        // Full validation passed — merge into targetDir. Copies only (never
+        // deletes anything): a fetched module's files ADD to the free scaffold,
+        // they never remove what the free copy already wrote.
+        copyTree(extractedRoot, targetAbs);
+    }
+    finally {
+        rmSync(stagingDir, { recursive: true, force: true });
+    }
+}
+/**
+ * Recursively copy every file from `srcRoot` into `destRoot`, creating parent
+ * directories as needed. Runs ONLY after `safeExtractTarGz` has validated
+ * every entry, so no additional path-safety check is needed here — `srcRoot`
+ * is our own staging tree, not attacker-controlled input.
+ */
+function copyTree(srcRoot, destRoot) {
+    const stack = [srcRoot];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        if (dir === undefined)
+            break;
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const srcPath = join(dir, entry.name);
+            const rel = relative(srcRoot, srcPath);
+            const destPath = join(destRoot, rel);
+            if (entry.isDirectory()) {
+                mkdirSync(destPath, { recursive: true });
+                stack.push(srcPath);
+            }
+            else if (entry.isFile()) {
+                mkdirSync(join(destPath, ".."), { recursive: true });
+                copyFileSync(srcPath, destPath);
+            }
+            // symlinks: never present — safeExtractTarGz rejects them outright.
+        }
+    }
+}
+/**
+ * `extractBundle`'s validating-filter tar extraction, ported verbatim (see
+ * file doc for why this is a port and not an import). Extracts `tarGzPath`
+ * into `targetDir`, which the caller guarantees is empty.
+ */
+async function safeExtractTarGz(tarGzPath, targetDir, moduleName) {
+    const resolvedTarget = resolve(targetDir);
+    let entryCount = 0;
+    let totalSize = 0;
+    const captured = { error: null };
+    const reject = (msg) => {
+        if (captured.error === null) {
+            captured.error = new Error(`module "${moduleName}": ${msg}`);
+        }
+        return false;
+    };
+    const validate = (entryPath, rawEntry) => {
+        if (captured.error !== null)
+            return false;
+        entryCount += 1;
+        if (entryCount > MAX_ENTRIES) {
+            return reject(`unsafe bundle: entry count exceeds ${MAX_ENTRIES}`);
+        }
+        const declaredSize = typeof rawEntry.size === "number" ? rawEntry.size : 0;
+        totalSize += declaredSize;
+        if (totalSize > MAX_TOTAL_SIZE_BYTES) {
+            return reject(`unsafe bundle: cumulative size exceeds ${MAX_TOTAL_SIZE_BYTES} bytes`);
+        }
+        if (typeof entryPath !== "string" || entryPath.length === 0) {
+            return reject("unsafe path: bundle entry has empty path");
+        }
+        if (isAbsolute(entryPath)) {
+            return reject(`unsafe path: bundle entry uses absolute path "${entryPath}"`);
+        }
+        const normalized = normalize(entryPath);
+        if (normalized === ".." ||
+            normalized.startsWith(`..${sep}`) ||
+            normalized.split(sep).includes("..")) {
+            return reject(`unsafe path: bundle entry "${entryPath}" contains path traversal`);
+        }
+        const fullPath = resolve(resolvedTarget, entryPath);
+        if (!isPathInside(resolvedTarget, fullPath)) {
+            return reject(`unsafe path: bundle entry "${entryPath}" resolves outside target`);
+        }
+        const entryType = rawEntry.type;
+        if (entryType === "SymbolicLink" ||
+            entryType === "Link" ||
+            entryType === "symlink" ||
+            entryType === "link") {
+            return reject(`unsafe link: bundle entry "${entryPath}" is a ${entryType} (rejected)`);
+        }
+        return true;
+    };
+    const extractStream = tar.x({
+        cwd: resolvedTarget,
+        strict: true,
+        filter: validate,
+        onentry: (entry) => {
+            if (typeof entry.mode === "number") {
+                entry.mode = entry.mode & 0o777;
+            }
+        },
+    });
+    try {
+        await pipeline(createReadStream(tarGzPath), createGunzip(), extractStream);
+    }
+    catch (err) {
+        if (captured.error !== null)
+            throw captured.error;
+        throw err;
+    }
+    if (captured.error !== null) {
+        throw captured.error;
+    }
+}
+/** True iff `child` is the same path as `parent` or a descendant of it. */
+function isPathInside(parent, child) {
+    const rel = relative(parent, child);
+    if (rel === "")
+        return true;
+    if (rel.startsWith(".."))
+        return false;
+    if (isAbsolute(rel))
+        return false;
+    return true;
+}

package/dist/lib/fetch-module.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Authenticated paid-module-bundle fetch (K1, #5089 — Flavor 3).
+ *
+ * Posture lifted verbatim from `packages/cli/src/lib/fetch-bundle.ts`
+ * (`fetchBundle`, the skill-registry twin of this function):
+ *   - Bearer-JWT auth on every request.
+ *   - `redirect: "error"` so a maliciously redirected response can't drop us
+ *     onto an unintended host — the CLI must hit the configured module
+ *     distribution only.
+ *   - Empty-token guard before any network call (defense in depth — the
+ *     caller should already have gated on an empty/absent key).
+ *   - Status-code mapping: 401 → license invalid/revoked/lapsed, 404 →
+ *     module content not yet available, other 4xx/5xx → upstream body.
+ *
+ * Deliberately DOES NOT depend on `@working-theory/license` or
+ * `@working-theory/cli` — both are `publishConfig.access: "restricted"` and
+ * `create-ailk` is the one package in this monorepo published to PUBLIC npm
+ * (Apache-2.0, A1 disposed it `oss`). A runtime dependency on a restricted
+ * package would break `pnpm install` for every free-tier consumer, not just
+ * gate the paid modules — so this file re-states fetchBundle's POSTURE
+ * rather than importing it. Named in the K1 PR body as the public-package
+ * boundary this card had to draw.
+ *
+ * Also deliberately skips fetchBundle's caller-side `checkLicense()` local
+ * JWT pre-check (install-skill.ts's step 2): that local verification lives
+ * in `@working-theory/license`, which for the same publish-boundary reason
+ * above cannot be a runtime dependency here. Instead the module distribution
+ * endpoint's own 401 response IS the license verdict — exactly the signal
+ * `fetchBundle` already surfaces via `isLicenseError`. This trades one local,
+ * no-network check for one authoritative, server-verified one; the caller-
+ * visible contract (present-but-invalid key ⟹ the honest "does not cover
+ * this" message) is unchanged.
+ *
+ * Returns the response body bytes on 200; throws a descriptive
+ * `FetchModuleError` on any failure path so the caller can map to an honest
+ * exit uniformly.
+ */
+export declare const DEFAULT_AILK_MODULE_REGISTRY_URL = "https://ailaunchkit.ai/api/modules";
+export interface FetchModuleOptions {
+    moduleName: string;
+    /** JWT used as `Authorization: Bearer <token>`. Must be non-empty. */
+    token: string;
+    /** Registry root; the module name is appended as a single path segment. */
+    registryUrl?: string;
+    /** Override for tests; defaults to `globalThis.fetch`. Never a live call in CI. */
+    fetchImpl?: typeof fetch;
+}
+export declare class FetchModuleError extends Error {
+    /** True iff the failure was a license-gating signal (HTTP 401). */
+    readonly isLicenseError: boolean;
+    constructor(message: string, 
+    /** True iff the failure was a license-gating signal (HTTP 401). */
+    isLicenseError?: boolean);
+}
+export declare function fetchModule(options: FetchModuleOptions): Promise<Uint8Array>;

package/dist/lib/fetch-module.js

@@ -0,0 +1,125 @@
+/**
+ * Authenticated paid-module-bundle fetch (K1, #5089 — Flavor 3).
+ *
+ * Posture lifted verbatim from `packages/cli/src/lib/fetch-bundle.ts`
+ * (`fetchBundle`, the skill-registry twin of this function):
+ *   - Bearer-JWT auth on every request.
+ *   - `redirect: "error"` so a maliciously redirected response can't drop us
+ *     onto an unintended host — the CLI must hit the configured module
+ *     distribution only.
+ *   - Empty-token guard before any network call (defense in depth — the
+ *     caller should already have gated on an empty/absent key).
+ *   - Status-code mapping: 401 → license invalid/revoked/lapsed, 404 →
+ *     module content not yet available, other 4xx/5xx → upstream body.
+ *
+ * Deliberately DOES NOT depend on `@working-theory/license` or
+ * `@working-theory/cli` — both are `publishConfig.access: "restricted"` and
+ * `create-ailk` is the one package in this monorepo published to PUBLIC npm
+ * (Apache-2.0, A1 disposed it `oss`). A runtime dependency on a restricted
+ * package would break `pnpm install` for every free-tier consumer, not just
+ * gate the paid modules — so this file re-states fetchBundle's POSTURE
+ * rather than importing it. Named in the K1 PR body as the public-package
+ * boundary this card had to draw.
+ *
+ * Also deliberately skips fetchBundle's caller-side `checkLicense()` local
+ * JWT pre-check (install-skill.ts's step 2): that local verification lives
+ * in `@working-theory/license`, which for the same publish-boundary reason
+ * above cannot be a runtime dependency here. Instead the module distribution
+ * endpoint's own 401 response IS the license verdict — exactly the signal
+ * `fetchBundle` already surfaces via `isLicenseError`. This trades one local,
+ * no-network check for one authoritative, server-verified one; the caller-
+ * visible contract (present-but-invalid key ⟹ the honest "does not cover
+ * this" message) is unchanged.
+ *
+ * Returns the response body bytes on 200; throws a descriptive
+ * `FetchModuleError` on any failure path so the caller can map to an honest
+ * exit uniformly.
+ */
+export const DEFAULT_AILK_MODULE_REGISTRY_URL = "https://ailaunchkit.ai/api/modules";
+export class FetchModuleError extends Error {
+    isLicenseError;
+    constructor(message, 
+    /** True iff the failure was a license-gating signal (HTTP 401). */
+    isLicenseError = false) {
+        super(message);
+        this.isLicenseError = isLicenseError;
+        this.name = "FetchModuleError";
+    }
+}
+/**
+ * Build the fetch URL by joining `registryUrl` with `moduleName` as a single
+ * trailing path segment. `encodeURIComponent` on the module name is defense
+ * in depth — `parse-args.ts`'s `parseModules` already restricts the value to
+ * `RECOGNIZED_MODULES`, but a hostile value can never smuggle a path
+ * separator or query string here regardless.
+ */
+function buildUrl(registryUrl, moduleName) {
+    const trimmed = registryUrl.replace(/\/+$/, "");
+    return `${trimmed}/${encodeURIComponent(moduleName)}`;
+}
+export async function fetchModule(options) {
+    const { moduleName, token } = options;
+    if (token.length === 0) {
+        throw new FetchModuleError("internal error: fetchModule called without a token");
+    }
+    const registryUrl = options.registryUrl ??
+        process.env["AILK_MODULE_REGISTRY_URL"] ??
+        DEFAULT_AILK_MODULE_REGISTRY_URL;
+    const url = buildUrl(registryUrl, moduleName);
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    let response;
+    try {
+        response = await fetchImpl(url, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: "application/gzip, application/octet-stream",
+            },
+            redirect: "error",
+        });
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        throw new FetchModuleError(`module registry unreachable: ${detail}`);
+    }
+    if (response.status === 401) {
+        throw new FetchModuleError(`your licence does not cover the "${moduleName}" module (invalid, revoked, or lapsed)`, 
+        /* isLicenseError */ true);
+    }
+    if (response.status === 404) {
+        throw new FetchModuleError(`"${moduleName}" module content not yet available — ping us at hello@ailaunchkit.ai`);
+    }
+    if (!response.ok) {
+        const body = await safeReadBody(response);
+        throw new FetchModuleError(`module registry returned ${response.status} for "${moduleName}": ${body}`);
+    }
+    const buf = await response.arrayBuffer();
+    return new Uint8Array(buf);
+}
+/**
+ * Best-effort error body extraction. Tries JSON first (registry uses
+ * `{ error: "..." }` shapes), falls back to text, swallows any read failure
+ * so the caller's error message remains useful. Verbatim copy of
+ * `fetch-bundle.ts`'s helper of the same name.
+ */
+async function safeReadBody(response) {
+    try {
+        const text = await response.text();
+        try {
+            const parsed = JSON.parse(text);
+            if (parsed !== null &&
+                typeof parsed === "object" &&
+                "error" in parsed &&
+                typeof parsed.error === "string") {
+                return parsed.error;
+            }
+        }
+        catch {
+            /* not JSON — fall through to raw text */
+        }
+        return text || response.statusText;
+    }
+    catch {
+        return response.statusText;
+    }
+}

package/dist/lib/module-license-gate.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Paid-module license gate (K1, #5089 — Flavor 3). Orchestrates
+ * `module-tier.ts`'s classification + `fetch-module.ts`'s authenticated
+ * fetch into the three honest states the CLI must surface:
+ *
+ *   (a) no key + a paid module requested  → conversion hint, non-zero, ZERO
+ *       network (mirrors `install-skill.ts`'s free-tier short-circuit).
+ *   (b) a lapsed/invalid key + a paid module → "your licence does not cover
+ *       this", non-zero (the module distribution's own 401 — see
+ *       `fetch-module.ts`'s file doc for why there is no local JWT
+ *       pre-check here).
+ *   (c) a valid key → every requested paid module's bundle bytes, ready for
+ *       `extract-module-bundle.ts` to merge into the scaffold.
+ *
+ * A Free-only request (no paid modules) never reaches the key check at all —
+ * `resolvePaidModules` returns immediately, before touching `process.env` or
+ * the network, so a bare/all-Free scaffold is provably unaffected by this
+ * gate (K1's regression floor).
+ */
+import type { ModuleName } from "../parse-args.js";
+export declare const CONVERSION_HINT_URL = "https://ailaunchkit.ai/pro";
+/**
+ * Thrown for both honest-denial states (no key, and an invalid/lapsed key).
+ * The CLI does not distinguish them in its exit code — both are "this run
+ * cannot proceed without a paid module you don't have entitlement to" — but
+ * the MESSAGE always says which state it is, per the honest-state contract.
+ */
+export declare class LicenseRequiredError extends Error {
+    constructor(message: string);
+}
+export interface ResolvePaidModulesOptions {
+    /** The requested module set's paid subset (see `module-tier.ts`). */
+    paidModules: ModuleName[];
+    /** Defaults to `process.env["AILK_LICENSE_KEY"]`. Injectable for tests. */
+    licenseKey?: string | undefined;
+    /** Forwarded to `fetchModule`; defaults to `AILK_MODULE_REGISTRY_URL` / the built-in default. */
+    registryUrl?: string;
+    /** Forwarded to `fetchModule`; defaults to `globalThis.fetch`. Never a live call in tests. */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Resolve every requested paid module to its fetched bundle bytes, or throw
+ * `LicenseRequiredError` naming exactly why the run cannot proceed. Never
+ * partially resolves: on the first denial or failure, no further modules are
+ * fetched and the caller has written nothing to disk yet (the gate runs
+ * BEFORE the scaffold copy — see `programmatic.ts`'s `scaffold()`).
+ */
+export declare function resolvePaidModules(options: ResolvePaidModulesOptions): Promise<Map<ModuleName, Uint8Array>>;

package/dist/lib/module-license-gate.js

@@ -0,0 +1,67 @@
+import { FetchModuleError, fetchModule } from "./fetch-module.js";
+export const CONVERSION_HINT_URL = "https://ailaunchkit.ai/pro";
+/**
+ * Thrown for both honest-denial states (no key, and an invalid/lapsed key).
+ * The CLI does not distinguish them in its exit code — both are "this run
+ * cannot proceed without a paid module you don't have entitlement to" — but
+ * the MESSAGE always says which state it is, per the honest-state contract.
+ */
+export class LicenseRequiredError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "LicenseRequiredError";
+    }
+}
+/**
+ * Resolve every requested paid module to its fetched bundle bytes, or throw
+ * `LicenseRequiredError` naming exactly why the run cannot proceed. Never
+ * partially resolves: on the first denial or failure, no further modules are
+ * fetched and the caller has written nothing to disk yet (the gate runs
+ * BEFORE the scaffold copy — see `programmatic.ts`'s `scaffold()`).
+ */
+export async function resolvePaidModules(options) {
+    const { paidModules } = options;
+    if (paidModules.length === 0) {
+        // Regression floor: zero key reads, zero network, for any request that
+        // names no paid module.
+        return new Map();
+    }
+    const token = options.licenseKey ?? process.env["AILK_LICENSE_KEY"];
+    if (token === undefined || token.length === 0) {
+        throw new LicenseRequiredError(conversionHint(paidModules));
+    }
+    const bundles = new Map();
+    for (const moduleName of paidModules) {
+        try {
+            const bytes = await fetchModule({
+                moduleName,
+                token,
+                ...(options.registryUrl !== undefined
+                    ? { registryUrl: options.registryUrl }
+                    : {}),
+                ...(options.fetchImpl !== undefined
+                    ? { fetchImpl: options.fetchImpl }
+                    : {}),
+            });
+            bundles.set(moduleName, bytes);
+        }
+        catch (err) {
+            if (err instanceof FetchModuleError) {
+                if (err.isLicenseError) {
+                    throw new LicenseRequiredError(`${err.message} → ${CONVERSION_HINT_URL}`);
+                }
+                // Not a license-gating signal (e.g. 404 "not yet available", or the
+                // registry unreachable) — a generic failure, not the honest-denial
+                // state. Re-thrown as-is; the CLI's top-level catch still turns this
+                // into a `[create-ailk] <message>` stderr write + non-zero exit.
+                throw err;
+            }
+            throw err;
+        }
+    }
+    return bundles;
+}
+function conversionHint(paidModules) {
+    const list = paidModules.join(", ");
+    return `Pro module(s) requested (${list}) — set AILK_LICENSE_KEY first → ${CONVERSION_HINT_URL}`;
+}

package/dist/lib/module-tier.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Free vs paid module classification (K1, #5089 — REL-015.3 "AI Launch Kit —
+ * Commercial line", D-17 "Flavor 3").
+ *
+ * The commercial line is decided: the paid modules do NOT ship on public npm
+ * — delivery itself is the gate. `create-ailk` scaffolds Free's modules from
+ * `templates/` with no key (today's path, unchanged); a paid module is
+ * FETCHED from the internal module distribution when `AILK_LICENSE_KEY`
+ * verifies (see `fetch-module.ts` + `module-license-gate.ts`).
+ *
+ * `FREE_MODULES` is the one hand-authored list (today just `marketing`, the
+ * always-available default). `PAID_MODULES` is derived from it — every other
+ * `RECOGNIZED_MODULES` entry — so adding a new module to the vocabulary
+ * (`parse-args.ts`) defaults it to "paid" until someone deliberately adds it
+ * to `FREE_MODULES`, rather than silently shipping it free.
+ */
+import { type ModuleName } from "../parse-args.js";
+/** Modules scaffolded from `templates/` with no license — today's free path. */
+export declare const FREE_MODULES: readonly ModuleName[];
+/**
+ * Modules requiring a verified `AILK_LICENSE_KEY` — delivered via the paid
+ * module fetch path rather than bundled in the published `create-ailk` npm
+ * package. Derived (not hand-listed) so the free/paid split can never drift
+ * from `RECOGNIZED_MODULES` silently.
+ */
+export declare const PAID_MODULES: readonly ModuleName[];
+export interface ModuleClassification {
+    free: ModuleName[];
+    paid: ModuleName[];
+}
+/**
+ * Split a requested (already-validated, `ModuleName`) module set into its
+ * free and paid subsets, each preserving the input's relative order.
+ */
+export declare function classifyModules(modules: ModuleName[]): ModuleClassification;

package/dist/lib/module-tier.js

@@ -0,0 +1,37 @@
+/**
+ * Free vs paid module classification (K1, #5089 — REL-015.3 "AI Launch Kit —
+ * Commercial line", D-17 "Flavor 3").
+ *
+ * The commercial line is decided: the paid modules do NOT ship on public npm
+ * — delivery itself is the gate. `create-ailk` scaffolds Free's modules from
+ * `templates/` with no key (today's path, unchanged); a paid module is
+ * FETCHED from the internal module distribution when `AILK_LICENSE_KEY`
+ * verifies (see `fetch-module.ts` + `module-license-gate.ts`).
+ *
+ * `FREE_MODULES` is the one hand-authored list (today just `marketing`, the
+ * always-available default). `PAID_MODULES` is derived from it — every other
+ * `RECOGNIZED_MODULES` entry — so adding a new module to the vocabulary
+ * (`parse-args.ts`) defaults it to "paid" until someone deliberately adds it
+ * to `FREE_MODULES`, rather than silently shipping it free.
+ */
+import { RECOGNIZED_MODULES } from "../parse-args.js";
+/** Modules scaffolded from `templates/` with no license — today's free path. */
+export const FREE_MODULES = ["marketing"];
+/**
+ * Modules requiring a verified `AILK_LICENSE_KEY` — delivered via the paid
+ * module fetch path rather than bundled in the published `create-ailk` npm
+ * package. Derived (not hand-listed) so the free/paid split can never drift
+ * from `RECOGNIZED_MODULES` silently.
+ */
+export const PAID_MODULES = RECOGNIZED_MODULES.filter((m) => !FREE_MODULES.includes(m));
+/**
+ * Split a requested (already-validated, `ModuleName`) module set into its
+ * free and paid subsets, each preserving the input's relative order.
+ */
+export function classifyModules(modules) {
+    const paidSet = new Set(PAID_MODULES);
+    return {
+        free: modules.filter((m) => !paidSet.has(m)),
+        paid: modules.filter((m) => paidSet.has(m)),
+    };
+}