kennel 0.2.0 → 0.2.2

package/dist/cli/src/plugins/external.js

@@ -0,0 +1,503 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve, } from "node:path";
+import { pathToFileURL, fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+const CONFIG_FILE = join("kennel", "config.json");
+const VALID_ID = /^[a-z][a-z0-9-]*$/u;
+const CORE_IDS = new Set(["agents", "calendar", "mail", "notes", "projects", "tasks"]);
+const KENNEL_KERNEL_SCHEMA = 2;
+const BUILD_RUNTIME = `node-${process.versions.node}`;
+const BUILD_IDENTITY = "kennel-external-kernel-v2";
+function xdgConfigHome() {
+    return process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
+}
+function xdgCacheHome() {
+    return process.env.XDG_CACHE_HOME?.trim() || join(homedir(), ".cache");
+}
+export function kennelConfigPath() {
+    return join(xdgConfigHome(), CONFIG_FILE);
+}
+function cacheRoot() {
+    return join(xdgCacheHome(), "kennel");
+}
+function assertUnderCache(path) {
+    const root = resolve(cacheRoot());
+    const target = resolve(path);
+    const rel = relative(root, target);
+    if (target !== root && (rel.startsWith("..") || isAbsolute(rel))) {
+        throw new Error(`Refusing to touch path outside Kennel cache: ${path}`);
+    }
+}
+function hash(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 32);
+}
+function run(command, args, options = {}) {
+    const result = spawnSync(command, args, {
+        cwd: options.cwd,
+        env: { ...process.env, ...options.env },
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (result.error)
+        throw new Error(`${command} ${args.join(" ")} failed to start: ${result.error.message}`);
+    if (result.status !== 0) {
+        const detail = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
+        throw new Error(`${command} ${args.join(" ")} failed with exit code ${result.status}${detail ? `\n${detail}` : ""}`);
+    }
+    return result.stdout.trim();
+}
+function readJson(path) {
+    if (!existsSync(path))
+        return {};
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+function writeJsonAtomic(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    const temp = join(dirname(path), `.${basename(path)}.${process.pid}.tmp`);
+    writeFileSync(temp, `${JSON.stringify(value, null, 2)}\n`);
+    renameSync(temp, path);
+}
+function splitRepositoryUrl(input) {
+    const index = input.indexOf("#");
+    const url = index === -1 ? input : input.slice(0, index);
+    const requestedRef = index === -1 ? undefined : input.slice(index + 1);
+    if (!url.trim())
+        throw new Error("Plugin repository URL is empty");
+    if (requestedRef !== undefined && !requestedRef.trim())
+        throw new Error("Plugin repository ref is empty");
+    return { url, requestedRef };
+}
+function resolveCommit(url, requestedRef) {
+    if (!requestedRef) {
+        const output = run("git", ["ls-remote", url, "HEAD"]);
+        const commit = output.split(/\s+/u)[0] ?? "";
+        if (!/^[0-9a-f]{40}$/u.test(commit))
+            throw new Error(`Could not resolve HEAD for ${url}`);
+        return commit;
+    }
+    const output = run("git", ["ls-remote", url, requestedRef]);
+    const first = output.split("\n").find(Boolean) ?? "";
+    const commit = first.split(/\s+/u)[0] ?? "";
+    if (!/^[0-9a-f]{40}$/u.test(commit))
+        throw new Error(`Could not resolve ref ${requestedRef} for ${url}`);
+    return commit;
+}
+function sourceCheckout(url, commit) {
+    const dir = join(cacheRoot(), "plugins", "sources", hash(url), "repo");
+    assertUnderCache(dir);
+    mkdirSync(dirname(dir), { recursive: true });
+    if (!existsSync(join(dir, ".git")))
+        run("git", ["clone", "--no-checkout", url, dir]);
+    run("git", ["fetch", "--force", "origin", commit], { cwd: dir });
+    run("git", ["checkout", "--force", commit], { cwd: dir });
+    return realpathSync(dir);
+}
+function packageExportPath(exportsValue, key) {
+    if (!exportsValue || typeof exportsValue !== "object" || Array.isArray(exportsValue))
+        return undefined;
+    const value = exportsValue[key];
+    if (typeof value === "string")
+        return value;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        const record = value;
+        if (typeof record.import === "string")
+            return record.import;
+        if (typeof record.default === "string")
+            return record.default;
+    }
+    return undefined;
+}
+function safeRelativeFile(root, value, label) {
+    if (typeof value !== "string" || !value.trim())
+        throw new Error(`Missing ${label}`);
+    if (isAbsolute(value) || value.includes("\0"))
+        throw new Error(`Unsafe ${label}: ${value}`);
+    const target = resolve(root, value);
+    const rel = relative(root, target);
+    if (rel === "" || rel.startsWith("..") || isAbsolute(rel))
+        throw new Error(`Unsafe ${label}: ${value}`);
+    if (!existsSync(target) || !statSync(target).isFile())
+        throw new Error(`Missing ${label}: ${value}`);
+    return target;
+}
+function stringField(value, label) {
+    if (typeof value !== "string" || !value.trim())
+        throw new Error(`Missing ${label}`);
+    return value.trim();
+}
+function kernelSourceRoot() {
+    const root = cliRoot();
+    const workspace = resolve(root, "..");
+    if (existsSync(resolve(workspace, "apps/web/vite.config.ts")))
+        return workspace;
+    const packaged = resolve(root, "kernel");
+    if (existsSync(resolve(packaged, "apps/web/vite.config.ts")))
+        return packaged;
+    throw new Error("Kennel kernel source is missing from this CLI package");
+}
+function internalSourceAliases(root = kernelSourceRoot()) {
+    const aliases = {};
+    for (const [name, path] of Object.entries({
+        "@raggle-ai/agents": "packages/agents/src",
+        "@raggle-ai/calendar": "plugins/calendar/src",
+        "@raggle-ai/folder-plugin": "packages/folder-plugin/src",
+        "@raggle-ai/kennel-api": "packages/api/src",
+        "@raggle-ai/mail": "plugins/mail/src",
+        "@raggle-ai/markdown": "packages/markdown/src",
+        "@raggle-ai/notes": "packages/notes/src",
+        "@raggle-ai/projects": "plugins/projects/src",
+        "@raggle-ai/schemas": "packages/schemas/src",
+        "@raggle-ai/session-finding": "packages/session-finding/src",
+        "@raggle-ai/tasks": "plugins/tasks/src",
+        "@raggle-ai/ui": "packages/ui/src",
+        "kennel-client": "packages/api-client/src",
+    })) {
+        const target = resolve(root, path);
+        if (existsSync(target))
+            aliases[name] = target;
+    }
+    return aliases;
+}
+function resolveAliasPath(target, suffix) {
+    if (!suffix)
+        return resolve(target, "index.ts");
+    const clean = suffix.replace(/^\//u, "");
+    for (const candidate of [
+        resolve(target, `${clean}.ts`),
+        resolve(target, `${clean}.tsx`),
+        resolve(target, `${clean}.js`),
+        resolve(target, clean, "index.ts"),
+        resolve(target, clean, "index.tsx"),
+        resolve(target, clean),
+    ]) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return resolve(target, clean);
+}
+function esbuildAliasPlugin(root = kernelSourceRoot()) {
+    const sourceAliases = internalSourceAliases(root);
+    const hostPackages = ["@raggle-ai/barkdown", "@raggle-ai/scout-ui", "@tanstack/react-query", "@tanstack/react-router", "lucide-react", "react", "react-dom", "react/jsx-runtime", "yaml", "lexical"];
+    return {
+        name: "kennel-host-resolution",
+        setup(build) {
+            build.onResolve({ filter: /.*/ }, (args) => {
+                if (args.path.startsWith("node:"))
+                    return undefined;
+                for (const [name, target] of Object.entries(sourceAliases)) {
+                    if (args.path === name || args.path.startsWith(`${name}/`)) {
+                        return { path: resolveAliasPath(target, args.path.slice(name.length)) };
+                    }
+                }
+                if (hostPackages.some((name) => args.path === name || args.path.startsWith(`${name}/`))) {
+                    return { path: fileURLToPath(import.meta.resolve(args.path)) };
+                }
+                return undefined;
+            });
+        },
+    };
+}
+async function bundleForImport(entry, outfile, platform) {
+    const esbuild = await import("esbuild");
+    await esbuild.build({
+        absWorkingDir: kernelSourceRoot(),
+        banner: platform === "node"
+            ? { js: 'import { createRequire as __kennelCreateRequire } from "node:module"; const require = __kennelCreateRequire(import.meta.url);' }
+            : undefined,
+        bundle: true,
+        entryPoints: [entry],
+        external: ["bun:ffi", "koffi"],
+        format: "esm",
+        jsx: "automatic",
+        outfile,
+        platform,
+        plugins: [esbuildAliasPlugin()],
+        sourcemap: false,
+        target: platform === "node" ? "node20" : "es2022",
+    });
+}
+function assertManifest(value, id, label) {
+    if (!value || typeof value !== "object")
+        throw new Error(`${label} is not an object`);
+    if (value.id !== id)
+        throw new Error(`${label} id mismatch`);
+    if (typeof value.label !== "string" || !value.label.trim())
+        throw new Error(`${label} missing label`);
+}
+async function validateImports(entry) {
+    const dir = await mkdtemp(join(tmpdir(), "kennel-plugin-validate-"));
+    try {
+        const manifestOut = join(dir, "manifest.mjs");
+        const serverOut = join(dir, "server.mjs");
+        const clientOut = join(dir, "client.mjs");
+        await bundleForImport(entry.entries.manifest, manifestOut, "browser");
+        await bundleForImport(entry.entries.server, serverOut, "node");
+        await bundleForImport(entry.entries.client, clientOut, "node");
+        const manifestModule = await import(__rewriteRelativeImportExtension(pathToFileURL(manifestOut).href));
+        const serverModule = await import(__rewriteRelativeImportExtension(pathToFileURL(serverOut).href));
+        const clientModule = await import(__rewriteRelativeImportExtension(pathToFileURL(clientOut).href));
+        const manifest = manifestModule[entry.entries.manifestSymbol];
+        const serverExport = serverModule[entry.entries.serverSymbol];
+        const server = typeof serverExport === "function" ? serverExport({}) : serverExport;
+        const client = clientModule[entry.entries.clientSymbol];
+        assertManifest(manifest, entry.id, "manifest export");
+        if (!server || typeof server !== "object" || server.id !== entry.id)
+            throw new Error("server id mismatch");
+        if (typeof server.detect !== "function" || typeof server.handle !== "function")
+            throw new Error("server export missing detect/handle");
+        if (!client || typeof client !== "object" || client.id !== entry.id)
+            throw new Error("client id mismatch");
+        if (typeof client.component !== "function")
+            throw new Error("client export missing component");
+    }
+    finally {
+        await rm(dir, { force: true, recursive: true });
+    }
+}
+export async function validateExternalPlugin(inputUrl, existing = []) {
+    const { url, requestedRef } = splitRepositoryUrl(inputUrl);
+    const commit = resolveCommit(url, requestedRef);
+    const root = sourceCheckout(url, commit);
+    const pkgPath = join(root, "package.json");
+    if (!existsSync(pkgPath))
+        throw new Error("Plugin repository has no package.json at its root");
+    const pkg = JSON.parse(await readFile(pkgPath, "utf8"));
+    const packageName = stringField(pkg.name, "package name");
+    const metadata = pkg.kennel?.plugin;
+    if (!metadata || typeof metadata !== "object")
+        throw new Error("package.json must define kennel.plugin metadata");
+    if (!metadata.exports || typeof metadata.exports !== "object")
+        throw new Error("kennel.plugin.exports is required");
+    const id = stringField(metadata.id, "plugin id");
+    if (!VALID_ID.test(id))
+        throw new Error(`Invalid plugin id: ${id}`);
+    if (CORE_IDS.has(id))
+        throw new Error(`External plugin id collides with core plugin: ${id}`);
+    if (existing.some((plugin) => plugin.id === id))
+        throw new Error(`External plugin id is already installed: ${id}`);
+    const trigger = stringField(metadata.trigger, "trigger file");
+    if (trigger.includes("/") || trigger.includes("\\") || trigger === "." || trigger === "..")
+        throw new Error(`Invalid trigger file: ${trigger}`);
+    const exportsValue = pkg.exports;
+    const client = safeRelativeFile(root, packageExportPath(exportsValue, "./client"), "./client package export");
+    const server = safeRelativeFile(root, packageExportPath(exportsValue, "./server"), "./server package export");
+    const manifest = safeRelativeFile(root, packageExportPath(exportsValue, "./manifest"), "./manifest package export");
+    const cssValue = metadata.exports.css;
+    const css = cssValue === undefined ? undefined : safeRelativeFile(root, cssValue, "css export path");
+    const entry = {
+        url,
+        ...(requestedRef ? { requestedRef } : {}),
+        commit,
+        packageName,
+        id,
+        trigger,
+        entries: {
+            client,
+            clientSymbol: stringField(metadata.exports.clientSymbol, "client export symbol"),
+            server,
+            serverSymbol: stringField(metadata.exports.serverSymbol, "server export symbol"),
+            manifest,
+            manifestSymbol: stringField(metadata.exports.manifestSymbol, "manifest export symbol"),
+            ...(css ? { css } : {}),
+        },
+    };
+    await validateImports(entry);
+    return entry;
+}
+export function readExternalPlugins() {
+    const config = readJson(kennelConfigPath());
+    return Array.isArray(config.externalPlugins) ? config.externalPlugins : [];
+}
+export async function installExternalPlugin(url) {
+    const path = kennelConfigPath();
+    const config = readJson(path);
+    const externalPlugins = Array.isArray(config.externalPlugins) ? config.externalPlugins : [];
+    let entry;
+    try {
+        entry = await validateExternalPlugin(url, externalPlugins);
+        const nextPlugins = [...externalPlugins, entry];
+        await ensureKernel(nextPlugins);
+        writeJsonAtomic(path, { ...config, externalPlugins: nextPlugins });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to install external plugin from ${url}: ${message}`);
+    }
+    return entry;
+}
+function cliRoot() {
+    return resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+}
+export function kernelKey(plugins = readExternalPlugins()) {
+    return hash(JSON.stringify({
+        buildIdentity: BUILD_IDENTITY,
+        schema: KENNEL_KERNEL_SCHEMA,
+        runtime: BUILD_RUNTIME,
+        plugins: plugins.map((plugin) => ({
+            url: plugin.url,
+            requestedRef: plugin.requestedRef ?? null,
+            packageName: plugin.packageName,
+            id: plugin.id,
+            commit: plugin.commit,
+            trigger: plugin.trigger,
+            entries: plugin.entries,
+        })),
+    }));
+}
+function kernelRoot(key) {
+    return join(cacheRoot(), "kernels", key);
+}
+async function readKernelMarker(marker, key) {
+    if (!existsSync(marker))
+        return undefined;
+    try {
+        const kernel = JSON.parse(await readFile(marker, "utf8"));
+        if (kernel.buildIdentity !== BUILD_IDENTITY ||
+            kernel.schema !== KENNEL_KERNEL_SCHEMA ||
+            kernel.runtime !== BUILD_RUNTIME ||
+            kernel.key !== key ||
+            !existsSync(resolve(kernel.webRoot, "index.html")) ||
+            !Array.isArray(kernel.serverEntries) ||
+            kernel.serverEntries.some((entry) => !entry.id || !entry.module || !entry.symbol || !existsSync(entry.module)))
+            return undefined;
+        return kernel;
+    }
+    catch {
+        return undefined;
+    }
+}
+function acquireKernelLock(key) {
+    const locks = join(cacheRoot(), "kernels", ".locks");
+    mkdirSync(locks, { recursive: true });
+    const lock = join(locks, key);
+    assertUnderCache(lock);
+    for (let attempt = 0; attempt < 200; attempt += 1) {
+        try {
+            mkdirSync(lock);
+            return () => rmSync(lock, { force: true, recursive: true });
+        }
+        catch (error) {
+            if (error?.code !== "EEXIST")
+                throw error;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+        }
+    }
+    throw new Error(`Timed out waiting for kernel build lock ${key}`);
+}
+function moveIncompleteAside(target) {
+    if (!existsSync(target))
+        return;
+    assertUnderCache(target);
+    const broken = `${target}.incomplete-${process.pid}-${Date.now()}`;
+    assertUnderCache(broken);
+    renameSync(target, broken);
+    rmSync(broken, { force: true, recursive: true });
+}
+async function buildKernelTemp(temp, target, key, plugins) {
+    const sourceRoot = kernelSourceRoot();
+    const clientModule = join(temp, "external-plugins.tsx");
+    const serverDir = join(temp, "server");
+    mkdirSync(serverDir, { recursive: true });
+    const cssImports = plugins.map((plugin) => plugin.entries.css ? `import ${JSON.stringify(plugin.entries.css)};` : "").filter(Boolean).join("\n");
+    const clientImports = plugins.map((plugin, index) => `import { ${plugin.entries.manifestSymbol} as manifest${index} } from ${JSON.stringify(plugin.entries.manifest)};`).join("\n");
+    const clientItems = plugins.map((plugin, index) => `  { ...manifest${index}, component: lazy(async () => ({ default: (await import(${JSON.stringify(plugin.entries.client)}))[${JSON.stringify(plugin.entries.clientSymbol)}].component })) }`).join(",\n");
+    await writeFile(clientModule, `import { lazy } from "react";\nimport type { FolderPluginClient } from "@raggle-ai/folder-plugin/client";\n${cssImports}\n${clientImports}\nexport const externalFolderPlugins: FolderPluginClient[] = [\n${clientItems}\n];\n`);
+    const serverEntries = [];
+    for (const plugin of plugins) {
+        const outfile = join(serverDir, `${plugin.id}.js`);
+        await bundleForImport(plugin.entries.server, outfile, "node");
+        serverEntries.push({ id: plugin.id, module: join(target, "server", `${plugin.id}.js`), symbol: plugin.entries.serverSymbol, trigger: plugin.trigger });
+    }
+    const vite = await import("vite");
+    const previousClientModule = process.env.KENNEL_EXTERNAL_CLIENT_MODULE;
+    const previousSourceRoot = process.env.KENNEL_KERNEL_SOURCE_ROOT;
+    process.env.KENNEL_EXTERNAL_CLIENT_MODULE = clientModule;
+    process.env.KENNEL_KERNEL_SOURCE_ROOT = sourceRoot;
+    try {
+        await vite.build({
+            configFile: resolve(sourceRoot, "apps/web/vite.config.ts"),
+            root: resolve(sourceRoot, "apps/web"),
+            build: { outDir: join(temp, "web"), emptyOutDir: true },
+            envFile: false,
+            mode: "production",
+        });
+    }
+    finally {
+        if (previousClientModule === undefined)
+            delete process.env.KENNEL_EXTERNAL_CLIENT_MODULE;
+        else
+            process.env.KENNEL_EXTERNAL_CLIENT_MODULE = previousClientModule;
+        if (previousSourceRoot === undefined)
+            delete process.env.KENNEL_KERNEL_SOURCE_ROOT;
+        else
+            process.env.KENNEL_KERNEL_SOURCE_ROOT = previousSourceRoot;
+    }
+    const kernel = {
+        buildIdentity: BUILD_IDENTITY,
+        schema: KENNEL_KERNEL_SCHEMA,
+        runtime: BUILD_RUNTIME,
+        key,
+        webRoot: join(target, "web"),
+        serverEntries,
+    };
+    await writeFile(join(temp, "kernel.json"), JSON.stringify(kernel, null, 2));
+    return kernel;
+}
+export async function ensureKernel(plugins = readExternalPlugins()) {
+    if (plugins.length === 0) {
+        const webRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../../web");
+        return { buildIdentity: BUILD_IDENTITY, schema: KENNEL_KERNEL_SCHEMA, runtime: BUILD_RUNTIME, key: "core", webRoot, serverEntries: [] };
+    }
+    const key = kernelKey(plugins);
+    const target = kernelRoot(key);
+    assertUnderCache(target);
+    const marker = join(target, "kernel.json");
+    const cached = await readKernelMarker(marker, key);
+    if (cached)
+        return cached;
+    mkdirSync(dirname(target), { recursive: true });
+    const release = acquireKernelLock(key);
+    try {
+        const afterLock = await readKernelMarker(marker, key);
+        if (afterLock)
+            return afterLock;
+        if (existsSync(target))
+            moveIncompleteAside(target);
+        const temp = `${target}.tmp-${process.pid}-${Date.now()}`;
+        assertUnderCache(temp);
+        rmSync(temp, { force: true, recursive: true });
+        mkdirSync(temp, { recursive: true });
+        try {
+            const kernel = await buildKernelTemp(temp, target, key, plugins);
+            if (existsSync(target)) {
+                const completed = await readKernelMarker(marker, key);
+                if (completed) {
+                    rmSync(temp, { force: true, recursive: true });
+                    return completed;
+                }
+                moveIncompleteAside(target);
+            }
+            renameSync(temp, target);
+            return kernel;
+        }
+        catch (error) {
+            rmSync(temp, { force: true, recursive: true });
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to build kernel ${key}: ${message}`);
+        }
+    }
+    finally {
+        release();
+    }
+}

package/dist/cli/src/publish/cloudflare-init.d.ts

@@ -0,0 +1,12 @@
+export declare const CLOUDFLARE_WORKER_MAIN = ".kennel/generated/cloudflare/email-code-worker.js";
+export declare const CLOUDFLARE_WRANGLER_CONFIG = ".kennel/generated/cloudflare/wrangler.jsonc";
+export declare const LEGACY_CLOUDFLARE_WRANGLER_CONFIG = "wrangler.worker.jsonc";
+export type CloudflareSetup = {
+    root: string;
+    configPath: string;
+    config: any;
+    wranglerPath: string;
+    hostname: string;
+    hostnames: string[];
+};
+export declare function publishInitCloudflare(input: string[]): CloudflareSetup;

package/dist/cli/src/publish/cloudflare-init.js

@@ -0,0 +1,101 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { readJson, readJsonc, writeJson } from '../shared/json.js';
+import { isObject } from '../shared/object.js';
+import { displayPath } from '../shared/path.js';
+import { projectConfigPath } from '../shared/project-config.js';
+import { displayBasePath, rendererDeploymentDescriptor } from '../site/renderers.js';
+import { publishAccountId, publishAuthDefaults, publishAuthWithWranglerFallbacks, publicationAdminMcp, publishHostname, publishHostnames, publishWorkerName, publicationConfig, publicationDomains, } from './config.js';
+import { splitPublishArgs } from './options.js';
+export const CLOUDFLARE_WORKER_MAIN = '.kennel/generated/cloudflare/email-code-worker.js';
+export const CLOUDFLARE_WRANGLER_CONFIG = '.kennel/generated/cloudflare/wrangler.jsonc';
+export const LEGACY_CLOUDFLARE_WRANGLER_CONFIG = 'wrangler.worker.jsonc';
+function workerTemplate() {
+    return readFileSync(new URL('../../templates/cloudflare/email-code-worker.js', import.meta.url), 'utf8');
+}
+function readCloudflareWranglerConfig(root) {
+    for (const name of [CLOUDFLARE_WRANGLER_CONFIG, LEGACY_CLOUDFLARE_WRANGLER_CONFIG]) {
+        const filePath = join(root, name);
+        if (existsSync(filePath))
+            return readJsonc(filePath);
+    }
+    return {};
+}
+export function publishInitCloudflare(input) {
+    const options = splitPublishArgs(input);
+    const configPath = projectConfigPath(options.targetPath, options.configFile);
+    const root = dirname(configPath);
+    const config = readJson(configPath);
+    const packagePath = join(root, 'package.json');
+    const pkg = existsSync(packagePath) ? readJson(packagePath) : undefined;
+    const deployment = rendererDeploymentDescriptor(root, pkg);
+    const publication = publicationConfig(config);
+    const adminMcp = publicationAdminMcp(config);
+    const domains = publicationDomains(config);
+    const wranglerPath = join(root, CLOUDFLARE_WRANGLER_CONFIG);
+    const wrangler = readCloudflareWranglerConfig(root);
+    const vars = isObject(wrangler.vars) ? wrangler.vars : {};
+    const auth = publishAuthWithWranglerFallbacks(publishAuthDefaults(config), vars);
+    const workerName = publishWorkerName(config, root);
+    const hostname = publishHostname(config, options);
+    const hostnames = publishHostnames(config, options);
+    config.publication = {
+        ...publication,
+        provider: 'cloudflare-workers',
+        workerName,
+        domains: {
+            ...domains,
+            ...(hostname ? { primary: hostname } : {}),
+            ...(hostnames.length > 1 ? { aliases: hostnames.slice(1) } : {}),
+        },
+        access: auth,
+    };
+    delete config.publish;
+    writeJson(configPath, config);
+    const workerPath = join(root, CLOUDFLARE_WORKER_MAIN);
+    mkdirSync(dirname(workerPath), { recursive: true });
+    writeFileSync(workerPath, workerTemplate());
+    wrangler.name = workerName;
+    const accountId = publishAccountId(config);
+    if (accountId)
+        wrangler.account_id = accountId;
+    if (typeof wrangler.account_id !== 'string' && typeof process.env.CLOUDFLARE_ACCOUNT_ID === 'string') {
+        wrangler.account_id = process.env.CLOUDFLARE_ACCOUNT_ID;
+    }
+    wrangler.main = relative(dirname(wranglerPath), workerPath);
+    wrangler.compatibility_date = wrangler.compatibility_date ?? new Date().toISOString().slice(0, 10);
+    wrangler.assets = {
+        binding: 'ASSETS',
+        directory: relative(dirname(wranglerPath), join(root, deployment.outputDirectory)),
+        run_worker_first: true,
+    };
+    if (hostnames.length > 0) {
+        wrangler.routes = hostnames.map((pattern) => ({ pattern, custom_domain: true }));
+    }
+    if (auth.mode === 'email-code-worker') {
+        wrangler.send_email = [{ name: 'EMAIL', remote: true }];
+    }
+    else {
+        delete wrangler.send_email;
+    }
+    wrangler.vars = {
+        ...vars,
+        ...(auth.allowedDomains.length > 0 ? { KENNEL_AUTH_ALLOWED_DOMAINS: auth.allowedDomains.join(',') } : {}),
+        ...(auth.allowedEmails.length > 0 ? { KENNEL_AUTH_ALLOWED_EMAILS: auth.allowedEmails.join(',') } : {}),
+        ...(auth.fromEmail ? { KENNEL_AUTH_FROM_EMAIL: auth.fromEmail } : {}),
+        ...(auth.emailSubject ? { KENNEL_AUTH_EMAIL_SUBJECT: auth.emailSubject } : {}),
+        ...(typeof adminMcp.hostname === 'string' && adminMcp.hostname.trim() ? { KENNEL_ADMIN_MCP_HOSTNAMES: adminMcp.hostname.trim() } : {}),
+        ...(typeof adminMcp.role === 'string' && adminMcp.role.trim() ? { KENNEL_ADMIN_MCP_ROLE: adminMcp.role.trim() } : {}),
+        ...(typeof adminMcp.upstream === 'string' && adminMcp.upstream.trim() ? { KENNEL_ADMIN_MCP_UPSTREAM: adminMcp.upstream.trim() } : {}),
+        ...(typeof config.base === 'string' && config.base.trim() ? { KENNEL_SITE_BASE: displayBasePath(config) } : {}),
+    };
+    mkdirSync(dirname(wranglerPath), { recursive: true });
+    writeJson(wranglerPath, wrangler);
+    console.log(`ok ${displayPath(configPath)}`);
+    console.log(`ok ${displayPath(workerPath)}`);
+    console.log(`ok ${displayPath(wranglerPath)}`);
+    console.log('required secret: KENNEL_AUTH_SECRET');
+    if (!hostname)
+        console.log('optional: set publication.domains.primary or pass --hostname to attach a custom domain');
+    return { root, configPath, config, wranglerPath, hostname: hostnames[0] ?? hostname, hostnames };
+}

package/dist/cli/src/publish/config.d.ts

@@ -0,0 +1,28 @@
+import type { ChildCommand } from '../shared/process.js';
+import { type PackageJson } from '../site/renderers.js';
+import type { PublishOptions } from './options.js';
+export type DopplerTokenCommand = {
+    command: string;
+    args: string[];
+};
+export declare function publicationConfig(config: any): Record<string, any>;
+export declare function publicationDomains(config: any): Record<string, any>;
+export declare function publicationAccess(config: any): Record<string, any>;
+export declare function publicationAdminMcp(config: any): Record<string, any>;
+export declare function publishAuthDefaults(config: any): any;
+export declare function splitCsv(value: unknown): string[];
+export declare function publishAuthWithWranglerFallbacks(auth: any, vars: Record<string, unknown>): any;
+export declare function publishHostname(config: any, options: Pick<PublishOptions, 'hostname'>): string;
+export declare function publishHostnames(config: any, options: Pick<PublishOptions, 'hostname'>): string[];
+export declare function publishProjectName(config: any, root: string): string;
+export declare function publishWorkerName(config: any, root: string): string;
+export declare function publishCloudflareConfig(config: any): Record<string, any>;
+export declare function publishAccountId(config: any): string;
+export declare function publishDopplerTokenConfig(config: any): Record<string, any>;
+export declare function hasDopplerTokenConfig(config: any): boolean;
+export declare function dopplerTokenCommand(config: any): DopplerTokenCommand | null;
+export declare function publishBuildCommand(root: string, pkg: PackageJson): ChildCommand;
+export declare function publishWranglerCommand(root: string): string;
+export declare function publishWranglerArgs(root: string, args: string[]): string[];
+export declare function publishTestUrl(hostname: string): string;
+export declare function packageJsonPath(root: string): string;