kennel 0.2.1 → 0.2.2

package/dist/cli/src/publish/config.js

@@ -0,0 +1,178 @@
+import { join } from 'node:path';
+import { isObject } from '../shared/object.js';
+import { localBin } from '../shared/package-manager.js';
+import { normalizeHostname, slugifyHostname } from '../shared/path.js';
+import { rendererBuildCommand } from '../site/renderers.js';
+export function publicationConfig(config) {
+    if (isObject(config.publication))
+        return config.publication;
+    if (isObject(config.publish))
+        return config.publish;
+    return {};
+}
+export function publicationDomains(config) {
+    const publication = publicationConfig(config);
+    if (isObject(publication.domains))
+        return publication.domains;
+    return {};
+}
+export function publicationAccess(config) {
+    const publication = publicationConfig(config);
+    if (isObject(publication.access))
+        return publication.access;
+    if (isObject(publication.auth))
+        return publication.auth;
+    return {};
+}
+export function publicationAdminMcp(config) {
+    const publication = publicationConfig(config);
+    if (isObject(publication.adminMcp))
+        return publication.adminMcp;
+    if (isObject(publication.adminMCP))
+        return publication.adminMCP;
+    return {};
+}
+export function publishAuthDefaults(config) {
+    const existing = publicationAccess(config);
+    return {
+        mode: existing.mode ?? 'email-code-worker',
+        allowedDomains: Array.isArray(existing.allowedDomains) ? existing.allowedDomains : [],
+        allowedEmails: Array.isArray(existing.allowedEmails) ? existing.allowedEmails : [],
+        fromEmail: existing.fromEmail ?? '',
+        emailSubject: existing.emailSubject ?? 'Your sign-in code',
+    };
+}
+export function splitCsv(value) {
+    if (typeof value !== 'string')
+        return [];
+    return value
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+export function publishAuthWithWranglerFallbacks(auth, vars) {
+    const allowedDomains = auth.allowedDomains.length > 0
+        ? auth.allowedDomains
+        : splitCsv(vars.KENNEL_AUTH_ALLOWED_DOMAINS ?? vars.CDP_AUTH_ALLOWED_DOMAINS);
+    const allowedEmails = auth.allowedEmails.length > 0
+        ? auth.allowedEmails
+        : splitCsv(vars.KENNEL_AUTH_ALLOWED_EMAILS ?? vars.CDP_AUTH_ALLOWED_EMAILS);
+    const fromEmail = auth.fromEmail
+        || vars.KENNEL_AUTH_FROM_EMAIL
+        || vars.CDP_AUTH_FROM_EMAIL
+        || '';
+    const emailSubject = auth.emailSubject
+        || vars.KENNEL_AUTH_EMAIL_SUBJECT
+        || vars.CDP_AUTH_EMAIL_SUBJECT
+        || 'Your sign-in code';
+    return {
+        ...auth,
+        allowedDomains,
+        allowedEmails,
+        fromEmail,
+        emailSubject,
+    };
+}
+export function publishHostname(config, options) {
+    const publication = publicationConfig(config);
+    const domains = publicationDomains(config);
+    const hostname = options.hostname
+        || domains.primary
+        || publication.hostname
+        || publication.domain
+        || publication.url;
+    if (typeof hostname !== 'string' || hostname.trim() === '')
+        return '';
+    return normalizeHostname(hostname);
+}
+export function publishHostnames(config, options) {
+    const publication = publicationConfig(config);
+    const domains = publicationDomains(config);
+    const adminMcp = publicationAdminMcp(config);
+    const candidates = [
+        publishHostname(config, options),
+        typeof adminMcp.hostname === 'string' ? adminMcp.hostname : undefined,
+        ...(Array.isArray(domains.aliases) ? domains.aliases : []),
+        ...(Array.isArray(domains.hostnames) ? domains.hostnames : []),
+        ...(Array.isArray(publication.hostnames) ? publication.hostnames : []),
+        ...(Array.isArray(publication.aliases) ? publication.aliases : []),
+    ];
+    return [...new Set(candidates.map(normalizeHostname).filter(Boolean))];
+}
+export function publishProjectName(config, root) {
+    const raw = config.name ?? config.project?.name ?? config.title ?? root.split('/').pop();
+    const slug = typeof raw === 'string' ? slugifyHostname(raw) : '';
+    return slug || 'kennel-docs';
+}
+export function publishWorkerName(config, root) {
+    const publication = publicationConfig(config);
+    if (typeof publication.workerName === 'string' && publication.workerName.trim())
+        return publication.workerName.trim();
+    return `${publishProjectName(config, root)}-gate`;
+}
+export function publishCloudflareConfig(config) {
+    const publication = publicationConfig(config);
+    return isObject(publication.cloudflare) ? publication.cloudflare : {};
+}
+export function publishAccountId(config) {
+    const publication = publicationConfig(config);
+    const cloudflare = publishCloudflareConfig(config);
+    if (typeof publication.accountId === 'string' && publication.accountId.trim())
+        return publication.accountId.trim();
+    if (typeof cloudflare.accountId === 'string' && cloudflare.accountId.trim())
+        return cloudflare.accountId.trim();
+    if (typeof process.env.KENNEL_CLOUDFLARE_ACCOUNT_ID === 'string' && process.env.KENNEL_CLOUDFLARE_ACCOUNT_ID.trim()) {
+        return process.env.KENNEL_CLOUDFLARE_ACCOUNT_ID.trim();
+    }
+    if (typeof process.env.CLOUDFLARE_ACCOUNT_ID === 'string' && process.env.CLOUDFLARE_ACCOUNT_ID.trim()) {
+        return process.env.CLOUDFLARE_ACCOUNT_ID.trim();
+    }
+    return '';
+}
+export function publishDopplerTokenConfig(config) {
+    const cloudflare = publishCloudflareConfig(config);
+    if (isObject(cloudflare.token))
+        return cloudflare.token;
+    if (isObject(cloudflare.dopplerToken))
+        return cloudflare.dopplerToken;
+    return {};
+}
+export function hasDopplerTokenConfig(config) {
+    const token = publishDopplerTokenConfig(config);
+    return typeof token.secret === 'string' && token.secret.trim() !== '';
+}
+export function dopplerTokenCommand(config) {
+    const token = publishDopplerTokenConfig(config);
+    const secret = typeof token.secret === 'string' && token.secret.trim() ? token.secret.trim() : '';
+    if (!secret)
+        return null;
+    const args = ['secrets', 'get', secret];
+    if (typeof token.scope === 'string' && token.scope.trim())
+        args.push('--scope', token.scope.trim());
+    if (typeof token.project === 'string' && token.project.trim())
+        args.push('--project', token.project.trim());
+    if (typeof token.config === 'string' && token.config.trim())
+        args.push('--config', token.config.trim());
+    args.push('--plain', '--raw');
+    return { command: 'doppler', args };
+}
+export function publishBuildCommand(root, pkg) {
+    return rendererBuildCommand(root, pkg);
+}
+export function publishWranglerCommand(root) {
+    const wrangler = localBin(root, 'wrangler');
+    if (wrangler)
+        return wrangler;
+    return 'npx';
+}
+export function publishWranglerArgs(root, args) {
+    return localBin(root, 'wrangler') ? args : ['wrangler', ...args];
+}
+export function publishTestUrl(hostname) {
+    if (!hostname)
+        return '';
+    return hostname.startsWith('http://') || hostname.startsWith('https://') ? hostname : `https://${hostname}`;
+}
+export function packageJsonPath(root) {
+    return join(root, 'package.json');
+}

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

@@ -0,0 +1,13 @@
+export type PublishOptions = {
+    targetPath: string;
+    configFile: string;
+    force: boolean;
+    dryRun: boolean;
+    skipTest: boolean;
+    hostname: string;
+    testEmail: string;
+    deploy: boolean;
+    build: boolean;
+    useDopplerToken: boolean;
+};
+export declare function splitPublishArgs(input: string[]): PublishOptions;

package/dist/cli/src/publish/options.js

@@ -0,0 +1,78 @@
+import { DEFAULT_PROJECT_CONFIG } from '../shared/project-config.js';
+export function splitPublishArgs(input) {
+    const options = {
+        targetPath: '.',
+        configFile: DEFAULT_PROJECT_CONFIG,
+        force: false,
+        dryRun: false,
+        skipTest: false,
+        hostname: '',
+        testEmail: '',
+        deploy: true,
+        build: true,
+        useDopplerToken: false,
+    };
+    const positional = [];
+    for (let index = 0; index < input.length; index += 1) {
+        const arg = input[index];
+        if (arg === '--force') {
+            options.force = true;
+            continue;
+        }
+        if (arg === '--dry-run') {
+            options.dryRun = true;
+            continue;
+        }
+        if (arg === '--skip-test') {
+            options.skipTest = true;
+            continue;
+        }
+        if (arg === '--no-build') {
+            options.build = false;
+            continue;
+        }
+        if (arg === '--no-deploy') {
+            options.deploy = false;
+            continue;
+        }
+        if (arg === '--use-doppler-token') {
+            options.useDopplerToken = true;
+            continue;
+        }
+        if (arg === '--config') {
+            options.configFile = input[index + 1] ?? '';
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--config=')) {
+            options.configFile = arg.slice('--config='.length);
+            continue;
+        }
+        if (arg === '--hostname') {
+            options.hostname = input[index + 1] ?? '';
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--hostname=')) {
+            options.hostname = arg.slice('--hostname='.length);
+            continue;
+        }
+        if (arg === '--test-email') {
+            options.testEmail = input[index + 1] ?? '';
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--test-email=')) {
+            options.testEmail = arg.slice('--test-email='.length);
+            continue;
+        }
+        if (arg.startsWith('-'))
+            throw new Error(`Unknown publish option: ${arg}`);
+        positional.push(arg);
+    }
+    if (positional.length > 0)
+        options.targetPath = positional[0];
+    if (!options.configFile)
+        throw new Error('publish requires a config file name');
+    return options;
+}

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

@@ -0,0 +1,9 @@
+export declare const VERCEL_CONFIG = "vercel.json";
+export type VercelSetup = {
+    root: string;
+    configPath: string;
+    config: any;
+    vercelPath: string;
+    hostname: string;
+};
+export declare function publishInitVercel(input: string[]): VercelSetup;

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

@@ -0,0 +1,52 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { readJson, writeJson } from '../shared/json.js';
+import { displayPath } from '../shared/path.js';
+import { commandLine } from '../shared/process.js';
+import { projectConfigPath } from '../shared/project-config.js';
+import { rendererDeploymentDescriptor } from '../site/renderers.js';
+import { packageJsonPath, publicationConfig, publicationDomains, publishBuildCommand, publishHostname, publishProjectName, } from './config.js';
+import { splitPublishArgs } from './options.js';
+export const VERCEL_CONFIG = 'vercel.json';
+function vercelBuildCommand(root, pkg) {
+    return commandLine(publishBuildCommand(root, pkg).command, publishBuildCommand(root, pkg).args).replace(/\s--$/u, '');
+}
+export function publishInitVercel(input) {
+    const options = splitPublishArgs(input);
+    const configPath = projectConfigPath(options.targetPath, options.configFile);
+    const root = dirname(configPath);
+    const config = readJson(configPath);
+    const packagePath = packageJsonPath(root);
+    if (!existsSync(packagePath))
+        throw new Error(`No package.json found next to ${configPath}`);
+    const pkg = readJson(packagePath);
+    const deployment = rendererDeploymentDescriptor(root, pkg);
+    const publication = publicationConfig(config);
+    const domains = publicationDomains(config);
+    const hostname = publishHostname(config, options);
+    config.publication = {
+        ...publication,
+        provider: 'vercel',
+        projectName: typeof publication.projectName === 'string' && publication.projectName.trim()
+            ? publication.projectName.trim()
+            : publishProjectName(config, root),
+        domains: {
+            ...domains,
+            ...(hostname ? { primary: hostname } : {}),
+        },
+    };
+    delete config.publish;
+    writeJson(configPath, config);
+    const vercelPath = join(root, VERCEL_CONFIG);
+    const vercel = existsSync(vercelPath) ? readJson(vercelPath) : {};
+    vercel.$schema = vercel.$schema ?? 'https://openapi.vercel.sh/vercel.json';
+    vercel.buildCommand = vercelBuildCommand(root, pkg);
+    vercel.cleanUrls = deployment.cleanUrls;
+    vercel.outputDirectory = deployment.outputDirectory;
+    writeJson(vercelPath, vercel);
+    console.log(`ok ${displayPath(configPath)}`);
+    console.log(`ok ${displayPath(vercelPath)}`);
+    if (!hostname)
+        console.log('optional: set publication.domains.primary or pass --hostname to record a production hostname');
+    return { root, configPath, config, vercelPath, hostname };
+}

package/dist/cli/src/shared/json.d.ts

@@ -0,0 +1,4 @@
+export declare function readJson<T = any>(filePath: string): T;
+export declare function stripJsonComments(content: string): string;
+export declare function readJsonc<T = any>(filePath: string): T;
+export declare function writeJson(filePath: string, value: unknown): void;

package/dist/cli/src/shared/json.js

@@ -0,0 +1,56 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+export function readJson(filePath) {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+}
+export function stripJsonComments(content) {
+    let output = '';
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < content.length; index += 1) {
+        const char = content[index];
+        const next = content[index + 1];
+        if (inString) {
+            output += char;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (char === '"')
+                inString = false;
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            output += char;
+            continue;
+        }
+        if (char === '/' && next === '/') {
+            while (index < content.length && content[index] !== '\n')
+                index += 1;
+            output += '\n';
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            index += 2;
+            while (index < content.length && !(content[index] === '*' && content[index + 1] === '/')) {
+                if (content[index] === '\n')
+                    output += '\n';
+                index += 1;
+            }
+            index += 1;
+            continue;
+        }
+        output += char;
+    }
+    return output;
+}
+export function readJsonc(filePath) {
+    return JSON.parse(stripJsonComments(readFileSync(filePath, 'utf8')));
+}
+export function writeJson(filePath, value) {
+    writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}

package/dist/cli/src/shared/object.d.ts

@@ -0,0 +1,2 @@
+export type JsonObject = Record<string, unknown>;
+export declare function isObject(value: unknown): value is JsonObject;

package/dist/cli/src/shared/object.js

@@ -0,0 +1,3 @@
+export function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/cli/src/shared/package-manager.d.ts

@@ -0,0 +1,11 @@
+type PackageJson = {
+    dependencies?: Record<string, unknown>;
+    devDependencies?: Record<string, unknown>;
+    peerDependencies?: Record<string, unknown>;
+    optionalDependencies?: Record<string, unknown>;
+};
+export declare function packageManagerFor(root: string): string;
+export declare function runArgsFor(packageManager: string, script: string, scriptArgs: string[]): string[];
+export declare function localBin(root: string, name: string): string | null;
+export declare function hasDependency(pkg: PackageJson, name: string): boolean;
+export {};

package/dist/cli/src/shared/package-manager.js

@@ -0,0 +1,39 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { isObject } from './object.js';
+const LOCKFILE_PACKAGE_MANAGERS = [
+    ['bun.lock', 'bun'],
+    ['bun.lockb', 'bun'],
+    ['pnpm-lock.yaml', 'pnpm'],
+    ['yarn.lock', 'yarn'],
+    ['package-lock.json', 'npm'],
+];
+export function packageManagerFor(root) {
+    for (const [lockfile, packageManager] of LOCKFILE_PACKAGE_MANAGERS) {
+        if (existsSync(join(root, lockfile)))
+            return packageManager;
+    }
+    return 'npm';
+}
+export function runArgsFor(packageManager, script, scriptArgs) {
+    if (packageManager === 'npm')
+        return ['run', script, '--', ...scriptArgs];
+    return ['run', script, ...scriptArgs];
+}
+export function localBin(root, name) {
+    const suffixes = process.platform === 'win32' ? ['.cmd', '.ps1', ''] : [''];
+    for (const suffix of suffixes) {
+        const binPath = join(root, 'node_modules', '.bin', `${name}${suffix}`);
+        if (existsSync(binPath))
+            return binPath;
+    }
+    return null;
+}
+export function hasDependency(pkg, name) {
+    return [
+        pkg.dependencies,
+        pkg.devDependencies,
+        pkg.peerDependencies,
+        pkg.optionalDependencies,
+    ].some((dependencies) => isObject(dependencies) && dependencies[name] !== undefined);
+}

package/dist/cli/src/shared/path.d.ts

@@ -0,0 +1,4 @@
+export declare function displayPath(filePath: string): string;
+export declare function nearestFile(startPath: string, fileName: string): string | null;
+export declare function slugifyHostname(value: string): string;
+export declare function normalizeHostname(value: unknown): string;

package/dist/cli/src/shared/path.js

@@ -0,0 +1,40 @@
+import { existsSync, statSync } from 'node:fs';
+import { dirname, relative, resolve } from 'node:path';
+export function displayPath(filePath) {
+    const resolved = resolve(filePath);
+    const relativePath = relative(process.cwd(), resolved);
+    if (relativePath === '')
+        return '.';
+    if (relativePath.startsWith('..'))
+        return resolved;
+    return relativePath;
+}
+export function nearestFile(startPath, fileName) {
+    let current = resolve(startPath);
+    if (existsSync(current) && statSync(current).isFile())
+        current = dirname(current);
+    while (true) {
+        const filePath = resolve(current, fileName);
+        if (existsSync(filePath) && statSync(filePath).isFile())
+            return filePath;
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+export function slugifyHostname(value) {
+    const withoutScope = value.replace(/^@[^/]+\//, '');
+    return withoutScope
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+export function normalizeHostname(value) {
+    if (typeof value !== 'string' || value.trim() === '')
+        return '';
+    return value
+        .trim()
+        .replace(/^https?:\/\//, '')
+        .replace(/\/.*$/, '');
+}

package/dist/cli/src/shared/process.d.ts

@@ -0,0 +1,7 @@
+export type ChildCommand = {
+    command: string;
+    args: string[];
+    cwd?: string;
+};
+export declare function commandExists(command: string): boolean;
+export declare function commandLine(command: string, args: string[]): string;

package/dist/cli/src/shared/process.js

@@ -0,0 +1,12 @@
+import { spawnSync } from 'node:child_process';
+export function commandExists(command) {
+    const result = spawnSync('sh', ['-c', `command -v ${command} >/dev/null 2>&1`], {
+        stdio: 'ignore',
+    });
+    return result.status === 0;
+}
+export function commandLine(command, args) {
+    return [command, ...args]
+        .map((arg) => (/^[A-Za-z0-9_./:@=-]+$/.test(arg) ? arg : JSON.stringify(arg)))
+        .join(' ');
+}

package/dist/cli/src/shared/project-config.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_PROJECT_CONFIG = "raggle.json";
+export declare function projectConfigPath(targetPath: string, configFile?: string): string;

package/dist/cli/src/shared/project-config.js

@@ -0,0 +1,26 @@
+import { existsSync, statSync } from 'node:fs';
+import { dirname, isAbsolute, resolve } from 'node:path';
+import { nearestFile } from './path.js';
+export const DEFAULT_PROJECT_CONFIG = 'raggle.json';
+function targetDirectory(targetPath) {
+    const target = resolve(targetPath);
+    if (existsSync(target) && statSync(target).isFile())
+        return dirname(target);
+    return target;
+}
+export function projectConfigPath(targetPath, configFile = DEFAULT_PROJECT_CONFIG) {
+    if (!configFile.trim())
+        throw new Error('config file name is required');
+    if (configFile.includes('/') || configFile.includes('\\') || isAbsolute(configFile)) {
+        const configPath = isAbsolute(configFile)
+            ? configFile
+            : resolve(targetDirectory(targetPath), configFile);
+        if (existsSync(configPath) && statSync(configPath).isFile())
+            return configPath;
+        throw new Error(`No ${configFile} found from ${resolve(targetPath)}`);
+    }
+    const configPath = nearestFile(targetPath, configFile);
+    if (configPath)
+        return configPath;
+    throw new Error(`No ${configFile} found from ${resolve(targetPath)} upward`);
+}

package/dist/cli/src/site/dev.d.ts

@@ -0,0 +1,10 @@
+export type DevOptions = {
+    targetPath: string;
+    port: string;
+    script: string | null;
+    configFile: string;
+    dryRun: boolean;
+    extra: string[];
+};
+export declare function splitDevArgs(input: string[]): DevOptions;
+export declare function dev(input: string[]): void;