kennel 0.2.0 → 0.2.2

package/dist/cli/src/core/init.js

@@ -0,0 +1,141 @@
+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 { existsSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { pathToFileURL } from 'node:url';
+function parseArgs(args) {
+    let folder = '.';
+    const options = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--force' || arg === '-f')
+            options.force = true;
+        else if (arg === '--list' || arg === '-l')
+            options.list = true;
+        else if (arg === '--plugin') {
+            const value = args[index + 1];
+            if (!value)
+                throw new Error('--plugin requires a plugin id (tasks, calendar)');
+            options.plugin = value;
+            index += 1;
+        }
+        else if (arg === '-h' || arg === '--help') {
+            console.log(initUsage());
+            process.exit(0);
+        }
+        else if (!arg.startsWith('-'))
+            folder = arg;
+        else
+            throw new Error(`Unknown flag: ${arg}`);
+    }
+    return { folder, options };
+}
+function initUsage() {
+    return `Usage:
+  kennel init [path] [--plugin <id>] [--force] [--list]
+
+Scaffold starter content files for folder plugins (todo.json, calendar.json)
+into the given folder (default: current directory). Existing files are left
+untouched unless --force is passed.
+
+  --plugin <id>   only scaffold one plugin (tasks, calendar)
+  --force         overwrite existing starter files
+  --list          show which files each plugin would create, without writing`;
+}
+async function scaffoldExternalPlugins(folder, options) {
+    const { ensureKernel } = await import('../plugins/external.js');
+    const kernel = await ensureKernel();
+    const created = [];
+    const skipped = [];
+    const supported = [];
+    for (const entry of kernel.serverEntries) {
+        const imported = await import(__rewriteRelativeImportExtension(pathToFileURL(entry.module).href));
+        const value = imported[entry.symbol];
+        const plugin = (typeof value === 'function' ? value({}) : value);
+        if (!plugin.init)
+            continue;
+        const result = await plugin.init({ folder });
+        const files = result.files.filter((file) => {
+            const target = resolve(folder, file.path);
+            const contained = target === folder || target.startsWith(folder + sep);
+            return contained && file.path !== '.' && !isAbsolute(file.path) && !relative(folder, target).startsWith('..');
+        });
+        supported.push({ id: plugin.id, files: files.map((file) => file.path) });
+        for (const file of files) {
+            const target = resolve(folder, file.path);
+            if (existsSync(target) && !options.force) {
+                skipped.push({ path: file.path, plugin: plugin.id });
+                continue;
+            }
+            if (options.write === false)
+                continue;
+            await mkdir(dirname(target), { recursive: true });
+            await writeFile(target, file.content);
+            created.push({ path: file.path, plugin: plugin.id });
+        }
+    }
+    return { created, skipped, supported };
+}
+function filterByPlugin(result, plugin) {
+    if (!plugin)
+        return result;
+    return {
+        created: result.created.filter((file) => file.plugin === plugin),
+        skipped: result.skipped.filter((file) => file.plugin === plugin),
+        supported: result.supported.filter((item) => item.id === plugin),
+    };
+}
+export async function init(args) {
+    const { folder, options } = parseArgs(args);
+    const target = resolve(folder);
+    const { scaffoldFolderPlugins } = await import('../site/server-plugins.js');
+    const write = options.list === true ? false : true;
+    const bundled = await scaffoldFolderPlugins(target, {
+        force: options.force,
+        write,
+    });
+    const external = await scaffoldExternalPlugins(target, {
+        force: options.force,
+        write,
+    });
+    const result = filterByPlugin({
+        created: [...bundled.created, ...external.created],
+        skipped: [...bundled.skipped, ...external.skipped],
+        supported: [...bundled.supported, ...external.supported],
+    }, options.plugin);
+    if (options.list) {
+        console.log(`Plugins that can scaffold content in ${target}:`);
+        for (const item of result.supported) {
+            for (const file of item.files) {
+                console.log(`  ${item.id}  →  ${file}`);
+            }
+        }
+        if (result.supported.length === 0) {
+            console.log('  (none)');
+        }
+        return;
+    }
+    if (result.created.length > 0) {
+        for (const file of result.created) {
+            console.log(`Created ${file.path} (${file.plugin} plugin)`);
+        }
+    }
+    if (result.skipped.length > 0) {
+        for (const file of result.skipped) {
+            console.log(`Skipped ${file.path} — already exists (use --force to overwrite)`);
+        }
+    }
+    if (result.created.length === 0 && result.skipped.length === 0) {
+        console.log(`No plugin scaffolding to create in ${target}.`);
+    }
+    if (result.created.length > 0) {
+        console.log(`\n${result.created.length} file${result.created.length === 1 ? '' : 's'} created. Open the folder in Kennel to see the new plugin views.`);
+    }
+}

package/dist/cli/src/core/runtime.d.ts

@@ -0,0 +1,14 @@
+/** Replaced at build time by the Node bundle of packages/api/src/server/index.ts. */
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function createKennelApi(options: {
+    root: string;
+    host?: string;
+    remoteAccess?: boolean;
+    restrictToRoot?: boolean;
+    lockedFile?: string;
+    webRoot?: string;
+}): {
+    handle(request: IncomingMessage, response: ServerResponse, next?: () => void): Promise<void>;
+    listen(port?: number): Promise<unknown>;
+    close(): Promise<void>;
+};

package/dist/cli/src/core/runtime.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/src/deploy/cloudflare.d.ts

@@ -0,0 +1,6 @@
+import { type ChildCommand } from '../shared/process.js';
+import { type PublishOptions } from '../publish/options.js';
+export declare function runPublishCommand(root: string, child: ChildCommand, options: Pick<PublishOptions, 'dryRun'>): void;
+export declare function publishCloudflare(input: string[]): void;
+export declare function publish(input: string[]): void;
+export declare function deploy(input: string[]): void;

package/dist/cli/src/deploy/cloudflare.js

@@ -0,0 +1,100 @@
+import { spawnSync } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { relative } from 'node:path';
+import { readJson } from '../shared/json.js';
+import { localBin } from '../shared/package-manager.js';
+import { projectConfigPath } from '../shared/project-config.js';
+import { commandLine } from '../shared/process.js';
+import { packageJsonPath, publishBuildCommand, publishTestUrl, publishWranglerArgs, publishWranglerCommand, publicationAccess, publicationConfig, } from '../publish/config.js';
+import { publishInitCloudflare } from '../publish/cloudflare-init.js';
+import { splitPublishArgs } from '../publish/options.js';
+import { withCloudflareEnvironment } from './environment.js';
+import { runAccessHttpTest, runHttpTest } from './smoke-tests.js';
+import { syncTriggerDev } from './trigger-dev.js';
+import { publishVercel } from './vercel.js';
+export function runPublishCommand(root, child, options) {
+    console.log(commandLine(child.command, child.args));
+    if (options.dryRun)
+        return;
+    const result = spawnSync(child.command, child.args, {
+        cwd: root,
+        stdio: 'inherit',
+        env: process.env,
+    });
+    if (result.status !== 0)
+        process.exit(result.status ?? 1);
+}
+export function publishCloudflare(input) {
+    const options = splitPublishArgs(input);
+    const setup = publishInitCloudflare([
+        '--force',
+        '--config',
+        options.configFile,
+        ...(options.hostname ? ['--hostname', options.hostname] : []),
+        options.targetPath,
+    ]);
+    const { root, configPath, config, wranglerPath, hostname } = setup;
+    const packagePath = packageJsonPath(root);
+    if (!existsSync(packagePath))
+        throw new Error(`No package.json found next to ${configPath}`);
+    const pkg = readJson(packagePath);
+    withCloudflareEnvironment(root, config, options, () => {
+        if (options.build) {
+            runPublishCommand(root, publishBuildCommand(root, pkg), options);
+        }
+        const wrangler = publishWranglerCommand(root);
+        const configArg = relative(root, wranglerPath);
+        const secret = randomBytes(48).toString('base64');
+        const secretCommand = localBin(root, 'wrangler')
+            ? `printf %s [generated-secret] | ${commandLine(wrangler, ['secret', 'put', 'KENNEL_AUTH_SECRET', '--config', configArg])}`
+            : `printf %s [generated-secret] | ${commandLine(wrangler, ['wrangler', 'secret', 'put', 'KENNEL_AUTH_SECRET', '--config', configArg])}`;
+        console.log(secretCommand);
+        if (!options.dryRun) {
+            const result = spawnSync('sh', ['-c', `printf %s "$KENNEL_AUTH_SECRET_VALUE" | ${commandLine(wrangler, publishWranglerArgs(root, ['secret', 'put', 'KENNEL_AUTH_SECRET', '--config', configArg]))}`], {
+                cwd: root,
+                stdio: 'inherit',
+                env: {
+                    ...process.env,
+                    KENNEL_AUTH_SECRET_VALUE: secret,
+                },
+            });
+            if (result.status !== 0)
+                process.exit(result.status ?? 1);
+        }
+        if (options.deploy) {
+            runPublishCommand(root, {
+                command: wrangler,
+                args: publishWranglerArgs(root, ['deploy', '--config', configArg]),
+            }, options);
+        }
+        syncTriggerDev(root, config, options);
+        if (!options.skipTest) {
+            if (publicationAccess(config).mode === 'cloudflare-access') {
+                runAccessHttpTest(root, hostname, options);
+            }
+            else {
+                runHttpTest(root, hostname, options.testEmail, options);
+            }
+        }
+        const url = publishTestUrl(hostname);
+        if (url)
+            console.log(`url ${url}`);
+    });
+}
+export function publish(input) {
+    if (input[0] === 'cloudflare' || input[0] === 'cloudflare-workers') {
+        return publishCloudflare(input.slice(1));
+    }
+    if (input[0] === 'vercel')
+        return publishVercel(input.slice(1));
+    const options = splitPublishArgs(input);
+    const config = readJson(projectConfigPath(options.targetPath, options.configFile));
+    const provider = publicationConfig(config).provider;
+    if (provider === 'vercel')
+        return publishVercel(input);
+    return publishCloudflare(input);
+}
+export function deploy(input) {
+    return publish(input);
+}

package/dist/cli/src/deploy/environment.d.ts

@@ -0,0 +1,2 @@
+import type { PublishOptions } from '../publish/options.js';
+export declare function withCloudflareEnvironment<T>(root: string, config: any, options: PublishOptions, callback: () => T): T;

package/dist/cli/src/deploy/environment.js

@@ -0,0 +1,47 @@
+import { spawnSync } from 'node:child_process';
+import { Effect } from 'effect';
+import { commandLine } from '../shared/process.js';
+import { dopplerTokenCommand, hasDopplerTokenConfig, publishAccountId, } from '../publish/config.js';
+function captureEnvironment(root, config, options) {
+    const previous = {
+        token: process.env.CLOUDFLARE_API_TOKEN,
+        account: process.env.CLOUDFLARE_ACCOUNT_ID,
+    };
+    const accountId = publishAccountId(config);
+    if (accountId)
+        process.env.CLOUDFLARE_ACCOUNT_ID = accountId;
+    const tokenCommand = options.useDopplerToken || hasDopplerTokenConfig(config)
+        ? dopplerTokenCommand(config)
+        : null;
+    if (tokenCommand) {
+        console.log(`${commandLine(tokenCommand.command, tokenCommand.args)} -> CLOUDFLARE_API_TOKEN`);
+        if (!options.dryRun) {
+            const result = spawnSync(tokenCommand.command, tokenCommand.args, {
+                cwd: root,
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'inherit'],
+            });
+            if (result.status !== 0)
+                process.exit(result.status ?? 1);
+            process.env.CLOUDFLARE_API_TOKEN = result.stdout.trim();
+        }
+    }
+    return previous;
+}
+function restoreEnvironment(previous) {
+    if (previous.token === undefined) {
+        delete process.env.CLOUDFLARE_API_TOKEN;
+    }
+    else {
+        process.env.CLOUDFLARE_API_TOKEN = previous.token;
+    }
+    if (previous.account === undefined) {
+        delete process.env.CLOUDFLARE_ACCOUNT_ID;
+    }
+    else {
+        process.env.CLOUDFLARE_ACCOUNT_ID = previous.account;
+    }
+}
+export function withCloudflareEnvironment(root, config, options, callback) {
+    return Effect.runSync(Effect.acquireUseRelease(Effect.sync(() => captureEnvironment(root, config, options)), () => Effect.sync(callback), (previous) => Effect.sync(() => restoreEnvironment(previous))));
+}

package/dist/cli/src/deploy/smoke-tests.d.ts

@@ -0,0 +1,4 @@
+import type { PublishOptions } from '../publish/options.js';
+export declare function runHttpTest(root: string, hostname: string, testEmail: string, options: PublishOptions): void;
+export declare function runStaticHttpTest(root: string, hostname: string, options: PublishOptions): void;
+export declare function runAccessHttpTest(root: string, hostname: string, options: PublishOptions): void;

package/dist/cli/src/deploy/smoke-tests.js

@@ -0,0 +1,92 @@
+import { spawnSync } from 'node:child_process';
+import { commandExists, commandLine } from '../shared/process.js';
+import { publishTestUrl } from '../publish/config.js';
+export function runHttpTest(root, hostname, testEmail, options) {
+    const baseUrl = publishTestUrl(hostname);
+    if (!baseUrl) {
+        console.log('skip test: no hostname configured');
+        return;
+    }
+    if (!commandExists('curl')) {
+        console.log('skip test: curl is not available');
+        return;
+    }
+    const rootTest = {
+        command: 'curl',
+        args: ['-fsS', '-H', 'Cache-Control: no-cache', baseUrl],
+    };
+    console.log(`${commandLine(rootTest.command, rootTest.args)} | contains "Sign in with email"`);
+    if (!options.dryRun) {
+        const result = spawnSync(rootTest.command, rootTest.args, { cwd: root, encoding: 'utf8' });
+        if (result.status !== 0 || !result.stdout.includes('Sign in with email')) {
+            throw new Error(`${baseUrl} did not return the Kennel sign-in page`);
+        }
+    }
+    const invalidTest = {
+        command: 'curl',
+        args: ['-fsS', '-X', 'POST', `${baseUrl}/__kennel_auth/request`, '-F', 'email=outside@example.com', '-F', 'redirect=/'],
+    };
+    console.log(`${commandLine(invalidTest.command, invalidTest.args)} | contains "approved email"`);
+    if (!options.dryRun) {
+        const result = spawnSync(invalidTest.command, invalidTest.args, { cwd: root, encoding: 'utf8' });
+        if (result.status !== 0 || !result.stdout.includes('approved email')) {
+            throw new Error(`${baseUrl} did not reject an outside email address`);
+        }
+    }
+    if (!testEmail)
+        return;
+    const sendTest = {
+        command: 'curl',
+        args: ['-fsS', '-X', 'POST', `${baseUrl}/__kennel_auth/request`, '-F', `email=${testEmail}`, '-F', 'redirect=/'],
+    };
+    console.log(`${commandLine(sendTest.command, sendTest.args)} | contains "Check your email"`);
+    if (!options.dryRun) {
+        const result = spawnSync(sendTest.command, sendTest.args, { cwd: root, encoding: 'utf8' });
+        if (result.status !== 0 || !result.stdout.includes('Check your email')) {
+            throw new Error(`${baseUrl} did not advance an approved email to code entry`);
+        }
+    }
+}
+export function runStaticHttpTest(root, hostname, options) {
+    const baseUrl = publishTestUrl(hostname);
+    if (!baseUrl) {
+        console.log('skip test: no hostname configured');
+        return;
+    }
+    if (!commandExists('curl')) {
+        console.log('skip test: curl is not available');
+        return;
+    }
+    const rootTest = {
+        command: 'curl',
+        args: ['-fsS', '-H', 'Cache-Control: no-cache', baseUrl],
+    };
+    console.log(`${commandLine(rootTest.command, rootTest.args)} | returns 2xx`);
+    if (!options.dryRun) {
+        const result = spawnSync(rootTest.command, rootTest.args, { cwd: root, stdio: 'ignore' });
+        if (result.status !== 0)
+            throw new Error(`${baseUrl} did not return a successful response`);
+    }
+}
+export function runAccessHttpTest(root, hostname, options) {
+    const baseUrl = publishTestUrl(hostname);
+    if (!baseUrl) {
+        console.log('skip test: no hostname configured');
+        return;
+    }
+    if (!commandExists('curl')) {
+        console.log('skip test: curl is not available');
+        return;
+    }
+    const accessTest = {
+        command: 'curl',
+        args: ['-fsSI', '-H', 'Cache-Control: no-cache', baseUrl],
+    };
+    console.log(`${commandLine(accessTest.command, accessTest.args)} | redirects to Cloudflare Access`);
+    if (!options.dryRun) {
+        const result = spawnSync(accessTest.command, accessTest.args, { cwd: root, encoding: 'utf8' });
+        if (result.status !== 0 || !/cloudflareaccess\.com|cdn-cgi\/access/i.test(result.stdout)) {
+            throw new Error(`${baseUrl} did not redirect to Cloudflare Access`);
+        }
+    }
+}

package/dist/cli/src/deploy/trigger-dev.d.ts

@@ -0,0 +1,2 @@
+import type { PublishOptions } from '../publish/options.js';
+export declare function syncTriggerDev(root: string, config: any, options: Pick<PublishOptions, 'deploy' | 'dryRun'>): void;

package/dist/cli/src/deploy/trigger-dev.js

@@ -0,0 +1,255 @@
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { isObject } from '../shared/object.js';
+import { commandLine } from '../shared/process.js';
+import { publicationConfig, publishProjectName } from '../publish/config.js';
+export function syncTriggerDev(root, config, options) {
+    const triggerDev = triggerDevConfig(config);
+    if (!triggerDev)
+        return;
+    if (!options.deploy)
+        return;
+    const secretKeyEnv = typeof triggerDev.secretKeyEnv === 'string' && triggerDev.secretKeyEnv.trim()
+        ? triggerDev.secretKeyEnv.trim()
+        : 'TRIGGER_SECRET_KEY';
+    const previousSecret = process.env[secretKeyEnv];
+    try {
+        hydrateTriggerSecret(root, triggerDev, secretKeyEnv, options);
+        syncTriggerDevWithSecret(root, config, triggerDev, secretKeyEnv, options);
+    }
+    finally {
+        if (previousSecret === undefined) {
+            delete process.env[secretKeyEnv];
+        }
+        else {
+            process.env[secretKeyEnv] = previousSecret;
+        }
+    }
+}
+function syncTriggerDevWithSecret(root, config, triggerDev, secretKeyEnv, options) {
+    const cwd = typeof triggerDev.cwd === 'string' && triggerDev.cwd.trim()
+        ? resolve(root, triggerDev.cwd.trim())
+        : root;
+    const deployCommand = typeof triggerDev.deployCommand === 'string' ? triggerDev.deployCommand.trim() : '';
+    if (deployCommand) {
+        runTriggerDevCommand(cwd, deployCommand, options);
+    }
+    const schedules = triggerDevSchedules(triggerDev, config, root);
+    if (schedules.length === 0)
+        return;
+    writeAutomationConfig(root, schedules, options);
+    logScheduleNotifications(schedules);
+    const apiUrl = triggerDevApiUrl(triggerDev);
+    const secretKey = process.env[secretKeyEnv];
+    if (!options.dryRun && !secretKey) {
+        throw new Error(`Trigger.dev schedules require ${secretKeyEnv}`);
+    }
+    for (const schedule of schedules) {
+        console.log(`trigger.dev schedule ${schedule.task} ${schedule.cron} ${schedule.timezone} dedup ${schedule.deduplicationKey}`);
+        if (options.dryRun)
+            continue;
+        createOrUpdateSchedule(apiUrl, secretKey ?? '', schedule);
+    }
+}
+function hydrateTriggerSecret(root, triggerDev, secretKeyEnv, options) {
+    const tokenCommand = triggerDevDopplerTokenCommand(triggerDev);
+    if (!tokenCommand)
+        return;
+    console.log(`${commandLine(tokenCommand.command, tokenCommand.args)} -> ${secretKeyEnv}`);
+    if (options.dryRun)
+        return;
+    const result = spawnSync(tokenCommand.command, tokenCommand.args, {
+        cwd: root,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'inherit'],
+    });
+    if (result.status !== 0)
+        process.exit(result.status ?? 1);
+    process.env[secretKeyEnv] = result.stdout.trim();
+}
+function triggerDevDopplerTokenCommand(triggerDev) {
+    const token = isObject(triggerDev.token)
+        ? triggerDev.token
+        : isObject(triggerDev.dopplerToken)
+            ? triggerDev.dopplerToken
+            : null;
+    if (!token)
+        return null;
+    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 };
+}
+function triggerDevConfig(config) {
+    const publication = publicationConfig(config);
+    if (isObject(publication.triggerDev))
+        return publication.triggerDev;
+    if (isObject(publication.trigger))
+        return publication.trigger;
+    return null;
+}
+function triggerDevSchedules(triggerDev, config, root) {
+    if (!Array.isArray(triggerDev.schedules))
+        return [];
+    const projectName = publishProjectName(config, root);
+    return triggerDev.schedules.map((entry, index) => normalizeSchedule(entry, publicationConfig(config), projectName, index));
+}
+function normalizeSchedule(entry, publication, projectName, index) {
+    if (!isObject(entry))
+        throw new Error(`Trigger.dev schedule ${index + 1} must be an object`);
+    const raw = entry;
+    const task = requiredString(raw.task, `Trigger.dev schedule ${index + 1} task`);
+    const cron = requiredString(raw.cron, `Trigger.dev schedule ${index + 1} cron`);
+    const timezone = optionalString(raw.timezone) ?? 'UTC';
+    const id = optionalString(raw.id) ?? task;
+    const deduplicationKey = optionalString(raw.deduplicationKey) ?? `kennel:${projectName}:${id}`;
+    const externalId = optionalString(raw.externalId);
+    const notifications = normalizeNotifications(raw.notifications, publication);
+    return {
+        cron,
+        deduplicationKey,
+        ...(externalId ? { externalId } : {}),
+        id,
+        notifications,
+        task,
+        timezone,
+    };
+}
+function normalizeNotifications(value, publication) {
+    if (!isObject(value))
+        return [];
+    const notificationConfig = isObject(publication.notifications) ? publication.notifications : {};
+    const slackConfig = isObject(notificationConfig.slack) ? notificationConfig.slack : {};
+    const emailConfig = isObject(notificationConfig.email) ? notificationConfig.email : {};
+    const notifications = [];
+    if (isObject(value.slack)) {
+        const channelId = requiredString(value.slack.channelId, 'automation Slack notification channelId');
+        const tokenSecret = optionalString(value.slack.tokenSecret) ?? optionalString(slackConfig.tokenSecret);
+        notifications.push({
+            channelId,
+            ...(tokenSecret ? { tokenSecret } : {}),
+            type: 'slack',
+        });
+    }
+    if (isObject(value.email)) {
+        const group = optionalString(value.email.group) ?? optionalString(emailConfig.defaultGroup);
+        if (!group)
+            throw new Error('automation email notification group is required');
+        const endpointSecret = optionalString(value.email.endpointSecret) ?? optionalString(emailConfig.endpointSecret);
+        const provider = optionalString(value.email.provider) ?? optionalString(emailConfig.provider) ?? 'email';
+        const tokenSecret = optionalString(value.email.tokenSecret) ?? optionalString(emailConfig.tokenSecret);
+        notifications.push({
+            ...(endpointSecret ? { endpointSecret } : {}),
+            group,
+            provider,
+            ...(tokenSecret ? { tokenSecret } : {}),
+            type: 'email',
+        });
+    }
+    return notifications;
+}
+function writeAutomationConfig(root, schedules, options) {
+    if (!schedules.some((schedule) => schedule.notifications.length > 0))
+        return;
+    const outputPath = join(root, '.kennel', 'generated', 'automations', 'config.json');
+    console.log(`write ${relative(root, outputPath)}`);
+    if (options.dryRun)
+        return;
+    mkdirSync(dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, `${JSON.stringify({
+        schedules: schedules.map((schedule) => ({
+            cron: schedule.cron,
+            id: schedule.id,
+            notifications: schedule.notifications,
+            task: schedule.task,
+            timezone: schedule.timezone,
+        })),
+    }, null, 2)}\n`);
+}
+function logScheduleNotifications(schedules) {
+    for (const schedule of schedules) {
+        for (const notification of schedule.notifications) {
+            if (notification.type === 'slack') {
+                const token = notification.tokenSecret ? ` token ${notification.tokenSecret}` : '';
+                console.log(`automation notification ${schedule.task} slack ${notification.channelId}${token}`);
+            }
+            else {
+                const endpoint = notification.endpointSecret ? ` endpoint ${notification.endpointSecret}` : '';
+                const token = notification.tokenSecret ? ` token ${notification.tokenSecret}` : '';
+                console.log(`automation notification ${schedule.task} email ${notification.group} via ${notification.provider}${endpoint}${token}`);
+            }
+        }
+    }
+}
+function requiredString(value, label) {
+    const stringValue = optionalString(value);
+    if (!stringValue)
+        throw new Error(`${label} is required`);
+    return stringValue;
+}
+function optionalString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function triggerDevApiUrl(triggerDev) {
+    const configured = optionalString(triggerDev.apiUrl) ?? process.env.TRIGGER_API_URL ?? 'https://api.trigger.dev';
+    return configured.replace(/\/+$/u, '');
+}
+function runTriggerDevCommand(cwd, command, options) {
+    console.log(command);
+    if (options.dryRun)
+        return;
+    const result = spawnSync('sh', ['-c', command], {
+        cwd,
+        env: process.env,
+        stdio: 'inherit',
+    });
+    if (result.status !== 0)
+        process.exit(result.status ?? 1);
+}
+function createOrUpdateSchedule(apiUrl, secretKey, schedule) {
+    const body = JSON.stringify({
+        task: schedule.task,
+        cron: schedule.cron,
+        deduplicationKey: schedule.deduplicationKey,
+        ...(schedule.externalId ? { externalId: schedule.externalId } : {}),
+        timezone: schedule.timezone,
+    });
+    const result = spawnSync('node', ['-e', `
+const [apiUrl, secretKey, body] = process.argv.slice(1);
+(async () => {
+  const response = await fetch(new URL('/api/v1/schedules', apiUrl), {
+    method: 'POST',
+    headers: {
+      Authorization: \`Bearer \${secretKey}\`,
+      'Content-Type': 'application/json; charset=utf-8',
+    },
+    body,
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    console.error(text || \`Trigger.dev schedule sync failed with status \${response.status}\`);
+    process.exit(1);
+  }
+})().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});
+`, apiUrl, secretKey, body], {
+        env: process.env,
+        stdio: 'inherit',
+    });
+    if (result.status !== 0)
+        process.exit(result.status ?? 1);
+}