kennel 0.1.8

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Raggle AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,203 @@
+# Kennel CLI
+
+Schema-backed folder ledger validator for structured workspaces.
+
+Kennel keeps structured folders easy to inspect and validate. It looks upward from the target path for the nearest `schema.json` or `_schema.json`, then validates schema-declared YAML files or Markdown frontmatter documents.
+
+## Usage
+
+```bash
+npm install
+npm test
+node bin/kennel.mjs --help
+```
+
+Install locally from this checkout:
+
+```bash
+npm install /Users/andrew/Documents/GitHub/kennel/cli
+kennel --help
+```
+
+Install from npm after publication:
+
+```bash
+npm install --global kennel
+kennel --help
+```
+
+Publish to npm:
+
+```bash
+cd /Users/andrew/Documents/GitHub/kennel/cli
+npm publish --access public --registry=https://registry.npmjs.org
+```
+
+Run against folder schemas:
+
+```bash
+kennel schema clients/reapit
+kennel validate clients
+kennel validate projects
+kennel validate partners
+kennel doctor clients/reapit
+kennel dev /Users/andrewmagu/src/cdp-index --config index.json
+kennel publish init cloudflare .
+kennel deploy .
+kennel dp .
+```
+
+Kennel does not create schemas or new records. Manage `schema.json` or `_schema.json` files and folder templates outside the CLI, then use Kennel to inspect and validate them.
+
+`kennel publish init cloudflare` is the exception for deploy wiring: it scaffolds
+a Cloudflare Worker email-code gate for an existing docs workspace by writing
+`publication` in `raggle.json` by default, then writing generated Cloudflare
+files under `.kennel/generated/cloudflare/`. The generated Worker comes from the
+CLI's packaged `templates/cloudflare/email-code-worker.js` asset, and the
+generated Wrangler config is derived from the selected local JSON config file,
+so Kennel can protect any static site output that deploys through the Kennel
+Cloudflare path.
+
+`kennel publish`, `kennel deploy`, and the short alias `kennel dp` read the
+selected local config file, build the docs, set a generated
+`KENNEL_AUTH_SECRET`, deploy with Wrangler, and smoke-test the protected URL.
+Pass `--config <json-file>` to use another local JSON config name such as
+`index.json`. If the selected config defines `publication.cloudflare.token`,
+Kennel loads `CLOUDFLARE_API_TOKEN` from Doppler only for the publish command.
+`kennel publish cloudflare` remains available when the provider should be
+explicit.
+
+## Folder Shape
+
+```text
+clients/
+  schema.json
+  example-client/
+    client.yml
+    people/
+    notes/
+    comms/
+    evidence/
+```
+
+The nearest parent `schema.json` or `_schema.json` owns the expected shape for folders below it. When both names exist in the same folder, `schema.json` is preferred.
+
+`kennel validate` discovers files from the nearest schema's `x-kennel.documents` declaration. If a schema omits that declaration, Kennel keeps the compatibility default of `client.yml` and `index.md`.
+
+Markdown files are validated using YAML frontmatter. YAML files are parsed as YAML.
+
+## Folder Requirements
+
+Schemas can include a Kennel-only extension for folder shape checks:
+
+```json
+{
+  "x-kennel": {
+    "documents": [
+      "client.yml",
+      { "path": "index.md", "parser": "markdown-frontmatter" },
+      { "glob": "*.yml", "parser": "yaml" }
+    ],
+    "requiredDirectories": ["people", "notes", "comms", "evidence"],
+    "requiredFiles": ["README.md"],
+    "directoryContents": [
+      {
+        "path": "people",
+        "glob": "*.md",
+        "minFiles": 1,
+        "whenPointerMinItems": "/contacts"
+      }
+    ],
+    "fileReferences": [
+      {
+        "pointer": "/contacts/*/path",
+        "required": true,
+        "whenPointerMinItems": "/contacts"
+      }
+    ]
+  }
+}
+```
+
+String document entries match a file name anywhere under the schema root. Object entries can use `path` or `glob` plus an optional parser.
+
+`requiredDirectories` and `requiredFiles` are checked next to each validated document and by `kennel doctor`.
+
+`directoryContents` checks that a sibling directory contains enough matching files. Use `whenPointerMinItems` to apply the rule only when an array in the document is non-empty, or `whenPointerIn` with `{ "pointer": "/client/status", "values": ["active-client"] }` to apply it for selected field values.
+
+`fileReferences` checks that document path fields point to existing files under the same folder. It supports JSON pointers with `*` wildcards, such as `/contacts/*/path`.
+
+## MCP Analytics
+
+Generated MCP runtimes can emit tool-call metadata and explicit conversation snapshots to analytics providers. Use `mcp.analytics.provider` for one provider, or `mcp.analytics.providers` to fan out to multiple providers:
+
+```json
+{
+  "mcp": {
+    "analytics": {
+      "enabled": true,
+      "providers": ["raggle", "posthog", "langfuse"],
+      "raggle": {
+        "projectId": "cdp-index",
+        "apiTokenEnv": "RAGGLE_OTEL_API_TOKEN"
+      },
+      "posthog": {
+        "apiKeyEnv": "POSTHOG_PROJECT_API_KEY"
+      },
+      "langfuse": {
+        "baseUrl": "https://cloud.langfuse.com",
+        "publicKeyEnv": "LANGFUSE_PUBLIC_KEY",
+        "secretKeyEnv": "LANGFUSE_SECRET_KEY"
+      }
+    }
+  }
+}
+```
+
+The Raggle provider uses the `raggle-otel` package and defaults to `RAGGLE_OTEL_API_TOKEN`, `RAGGLE_OTEL_PROJECT_ID`, and `RAGGLE_OTEL_BASE_URL` when values are not set in config. PostHog keeps the existing `/capture/` behavior. Langfuse sends trace events through its public ingestion API with Langfuse basic auth credentials.
+
+## MCP Repo Integrations
+
+`kennel mcp generate` also emits an MCP server runtime (`@raggle-ai/kennel-mcp`) with core tools for searching index docs and tracked repositories. The runtime additionally exposes repo integration tools that let an agent run basic GitHub or GitLab commands against a repository linked from the index registry (`repos/index.yaml`):
+
+- `submit_repo_feature_request` — open a feature request issue on a tracked repo, submitted on behalf of a user.
+- `list_repo_issues` — list recent issues on a tracked repo.
+- `get_repo_issue` — read one issue by number.
+
+The provider (GitHub or GitLab) is detected from each registry entry's `url`, or can be declared with an optional `provider` field. By default the tools read `GITHUB_TOKEN` and `GITLAB_TOKEN` from the runtime environment, so they work without extra configuration once a token is present.
+
+To let people supply their own GitHub or GitLab setup (custom token env, self-hosted/Enterprise API base URL, allowed repos, default labels), add an `mcp.repoIntegrations` block to the local config:
+
+```json
+{
+  "mcp": {
+    "repoIntegrations": {
+      "enabled": true,
+      "github": {
+        "tokenEnv": "CDP_INDEX_GITHUB_TOKEN",
+        "apiBaseUrl": "https://github.example.com/api/v3"
+      },
+      "gitlab": {
+        "tokenEnv": "CDP_INDEX_GITLAB_TOKEN",
+        "apiBaseUrl": "https://gitlab.example.com/api/v4"
+      },
+      "allowedRepos": ["cdp-index", "index"],
+      "defaultLabels": ["feature-request"]
+    }
+  }
+}
+```
+
+`allowedRepos` is an optional allowlist of registry repo names; when omitted, every registry repo is available. Set `enabled: false` to disable the repo integration tools while keeping the rest of the MCP server active.
+
+Registry entries that should support issue creation need a `url` (and optionally `provider`):
+
+```yaml
+repos:
+  - name: index
+    url: https://github.com/bakerstreetco/index
+    provider: github
+  - name: cdp-index
+    url: https://gitlab.com/baker-street/cdp-index
+    provider: gitlab
+```

package/bin/kennel.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../dist/main.js';

package/dist/automations/notifications.d.ts

@@ -0,0 +1,40 @@
+export type SlackMessageResult = {
+    ts: string;
+};
+export type EmailSendRequest = {
+    notificationType?: string;
+    preheader?: string;
+    priority?: string;
+    recipients: string[];
+    subject: string;
+    template?: string;
+    text: string;
+};
+export type CloudflareEmailSenderOptions = {
+    endpoint: string;
+    fetch?: typeof fetch;
+    token: string;
+};
+export type SlackNotifierOptions = {
+    fetch?: typeof fetch;
+    token: string;
+};
+export declare function readEmailRecipients(filePath: string, root?: string): Promise<string[]>;
+export declare function createSlackNotifier({ fetch: fetchImpl, token }: SlackNotifierOptions): ({ channelId, text, }: {
+    channelId: string;
+    text: string;
+}) => Promise<SlackMessageResult>;
+export declare function createCloudflareEmailSender({ endpoint, fetch: fetchImpl, token, }: CloudflareEmailSenderOptions): ({ notificationType, preheader, priority, recipients, subject, template, text }: EmailSendRequest) => Promise<any>;
+export declare function sendEmail({ recipients, sendmailPath, subject, text, }: EmailSendRequest & {
+    sendmailPath?: string;
+}): Promise<{
+    recipients: string[];
+    provider: string;
+}>;
+export declare function markdownToEmailHtml(markdown: string): string;
+export declare function formatSendSummary({ emailRecipients, emailSent, slackChannelId, slackTs, }: {
+    emailRecipients: string[];
+    emailSent: boolean;
+    slackChannelId: string;
+    slackTs?: string;
+}): string;

package/dist/automations/notifications.js

@@ -0,0 +1,220 @@
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { isAbsolute, resolve } from 'node:path';
+const SLACK_API_BASE_URL = 'https://slack.com/api/';
+export async function readEmailRecipients(filePath, root = process.cwd()) {
+    const text = await readFile(isAbsolute(filePath) ? filePath : resolve(root, filePath), 'utf8');
+    return text
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('#'));
+}
+export function createSlackNotifier({ fetch: fetchImpl = fetch, token }) {
+    return async function postSlackMessage({ channelId, text, }) {
+        const response = await fetchImpl(new URL('chat.postMessage', SLACK_API_BASE_URL), {
+            body: JSON.stringify({
+                channel: channelId,
+                text,
+            }),
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json; charset=utf-8',
+            },
+            method: 'POST',
+        });
+        const body = (await response.json());
+        if (!body.ok) {
+            throw new Error(`Slack chat.postMessage failed: ${body.error ?? JSON.stringify(body)}`);
+        }
+        return { ts: body.ts };
+    };
+}
+export function createCloudflareEmailSender({ endpoint, fetch: fetchImpl = fetch, token, }) {
+    return async function sendCloudflareEmail({ notificationType, preheader, priority, recipients, subject, template, text }) {
+        if (recipients.length === 0) {
+            throw new Error('No email recipients configured.');
+        }
+        const response = await fetchImpl(endpoint, {
+            body: JSON.stringify({
+                html: markdownToEmailHtml(text),
+                ...(notificationType ? { notificationType } : {}),
+                ...(preheader ? { preheader } : {}),
+                ...(priority ? { priority } : {}),
+                subject,
+                ...(template ? { template } : {}),
+                text,
+                to: recipients,
+            }),
+            headers: {
+                authorization: `Bearer ${token}`,
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        });
+        const body = await response.json().catch(async () => ({ error: await response.text() }));
+        if (!response.ok) {
+            throw new Error(`Cloudflare email failed (${response.status}): ${JSON.stringify(body)}`);
+        }
+        return body;
+    };
+}
+export async function sendEmail({ recipients, sendmailPath = process.env.SENDMAIL_PATH ?? '/usr/sbin/sendmail', subject, text, }) {
+    if (recipients.length === 0) {
+        throw new Error('No email recipients configured.');
+    }
+    if (process.env.CLOUDFLARE_EMAIL_ENDPOINT && process.env.CLOUDFLARE_EMAIL_TOKEN) {
+        const sender = createCloudflareEmailSender({
+            endpoint: process.env.CLOUDFLARE_EMAIL_ENDPOINT,
+            token: process.env.CLOUDFLARE_EMAIL_TOKEN,
+        });
+        await sender({ recipients, subject, text });
+        return { recipients, provider: 'cloudflare' };
+    }
+    const message = [
+        `To: ${recipients.join(', ')}`,
+        `Subject: ${sanitizeHeader(subject)}`,
+        'Content-Type: text/plain; charset=utf-8',
+        '',
+        text,
+    ].join('\n');
+    await runSendmail(sendmailPath, message);
+    return { recipients, provider: 'sendmail' };
+}
+export function markdownToEmailHtml(markdown) {
+    const lines = markdown.replace(/\r\n/gu, '\n').split('\n');
+    const blocks = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line.trim() === '') {
+            continue;
+        }
+        const codeFence = line.match(/^```([a-zA-Z0-9_-]*)\s*$/u);
+        if (codeFence) {
+            const code = [];
+            index += 1;
+            while (index < lines.length && !lines[index].startsWith('```')) {
+                code.push(lines[index]);
+                index += 1;
+            }
+            const language = codeFence[1] ? ` class="language-${escapeAttribute(codeFence[1])}"` : '';
+            blocks.push(`<pre><code${language}>${escapeHtml(code.join('\n').trim())}</code></pre>`);
+            continue;
+        }
+        if (isTableHeader(lines, index)) {
+            const { html, nextIndex } = renderTable(lines, index);
+            blocks.push(html);
+            index = nextIndex;
+            continue;
+        }
+        if (line.startsWith('- ')) {
+            const items = [];
+            while (index < lines.length && lines[index].startsWith('- ')) {
+                items.push(`<li>${renderInline(lines[index].slice(2))}</li>`);
+                index += 1;
+            }
+            blocks.push(`<ul>\n${items.join('\n')}\n</ul>`);
+            index -= 1;
+            continue;
+        }
+        const paragraph = [line];
+        while (index + 1 < lines.length &&
+            lines[index + 1].trim() !== '' &&
+            !lines[index + 1].startsWith('- ') &&
+            !lines[index + 1].startsWith('```') &&
+            !isTableHeader(lines, index + 1)) {
+            paragraph.push(lines[index + 1]);
+            index += 1;
+        }
+        blocks.push(`<p>${paragraph.map(renderInline).join('<br>')}</p>`);
+    }
+    return `<!doctype html>
+<html>
+<body style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; line-height: 1.45; color: #111827;">
+${blocks.join('\n')}
+</body>
+</html>`;
+}
+export function formatSendSummary({ emailRecipients, emailSent, slackChannelId, slackTs, }) {
+    const parts = [
+        slackTs ? `Slack posted to ${slackChannelId} at ${slackTs}` : `Slack not posted to ${slackChannelId}`,
+        emailSent ? `email sent to ${emailRecipients.join(', ')}` : 'email not sent',
+    ];
+    return parts.join('; ');
+}
+async function runSendmail(sendmailPath, message) {
+    await new Promise((resolvePromise, reject) => {
+        const child = spawn(sendmailPath, ['-t'], {
+            stdio: ['pipe', 'ignore', 'pipe'],
+        });
+        let stderr = '';
+        child.stderr.on('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolvePromise();
+                return;
+            }
+            reject(new Error(`sendmail exited with code ${code}: ${stderr.trim()}`));
+        });
+        child.stdin.end(message);
+    });
+}
+function isTableHeader(lines, index) {
+    return hasTableCells(lines[index]) && Boolean(lines[index + 1] && isTableDivider(lines[index + 1]));
+}
+function renderTable(lines, startIndex) {
+    const headers = splitTableRow(lines[startIndex]);
+    const rows = [];
+    let index = startIndex + 2;
+    while (index < lines.length && hasTableCells(lines[index]) && lines[index].trim() !== '') {
+        rows.push(splitTableRow(lines[index]));
+        index += 1;
+    }
+    const html = [
+        '<table style="border-collapse: collapse; margin: 12px 0;">',
+        '<thead>',
+        `<tr>${headers
+            .map((header) => `<th style="border: 1px solid #d1d5db; padding: 4px 8px; text-align: left;">${renderInline(header)}</th>`)
+            .join('')}</tr>`,
+        '</thead>',
+        '<tbody>',
+        ...rows.map((row) => `<tr>${headers
+            .map((_, cellIndex) => `<td style="border: 1px solid #d1d5db; padding: 4px 8px;">${renderInline(row[cellIndex] ?? '')}</td>`)
+            .join('')}</tr>`),
+        '</tbody>',
+        '</table>',
+    ].join('\n');
+    return { html, nextIndex: index - 1 };
+}
+function hasTableCells(line) {
+    return Boolean(line && line.includes('|'));
+}
+function isTableDivider(line) {
+    return splitTableRow(line).every((cell) => /^:?-{3,}:?$/u.test(cell));
+}
+function splitTableRow(line) {
+    return line
+        .trim()
+        .replace(/^\|/u, '')
+        .replace(/\|$/u, '')
+        .split('|')
+        .map((cell) => cell.trim());
+}
+function renderInline(value) {
+    return escapeHtml(value).replace(/\*([^*\n]+)\*/gu, '<strong>$1</strong>');
+}
+function escapeHtml(value) {
+    return value
+        .replace(/&/gu, '&amp;')
+        .replace(/</gu, '&lt;')
+        .replace(/>/gu, '&gt;')
+        .replace(/"/gu, '&quot;');
+}
+function escapeAttribute(value) {
+    return escapeHtml(value).replace(/'/gu, '&#39;');
+}
+function sanitizeHeader(value) {
+    return value.replace(/[\r\n]+/gu, ' ').trim();
+}

package/dist/cli/dispatch.d.ts

@@ -0,0 +1 @@
+export declare function dispatch(argv: string[]): Promise<void>;

package/dist/cli/dispatch.js

@@ -0,0 +1,51 @@
+import { deploy, publish } from '../deploy/cloudflare.js';
+import { generateMcp } from '../mcp/generate.js';
+import { doctor } from '../schema/doctor.js';
+import { schemaFor, validateTarget } from '../schema/validation.js';
+import { dev } from '../site/dev.js';
+import { publishInitCloudflare } from '../publish/cloudflare-init.js';
+import { usage } from './usage.js';
+export async function dispatch(argv) {
+    const [, , command, ...args] = argv;
+    if (!command || command === '-h' || command === '--help') {
+        usage();
+        return;
+    }
+    if (command === 'schema') {
+        schemaFor(args[0] ?? '.');
+        return;
+    }
+    if (command === 'validate') {
+        const valid = validateTarget(args[0] ?? '.');
+        process.exit(valid ? 0 : 1);
+    }
+    if (command === 'doctor') {
+        doctor(args[0] ?? '.');
+        return;
+    }
+    if (command === 'dev') {
+        dev(args);
+        return;
+    }
+    if (command === 'mcp' && args[0] === 'generate') {
+        await generateMcp(args.slice(1));
+        return;
+    }
+    if (command === 'publish' && args[0] === 'init' && args[1] === 'cloudflare') {
+        publishInitCloudflare(args.slice(2));
+        return;
+    }
+    if (command === 'publish') {
+        publish(args);
+        return;
+    }
+    if (command === 'deploy') {
+        deploy(args);
+        return;
+    }
+    if (command === 'dp') {
+        deploy(args);
+        return;
+    }
+    throw new Error(`Unknown command: ${command}`);
+}

package/dist/cli/usage.d.ts

@@ -0,0 +1 @@
+export declare function usage(): void;

package/dist/cli/usage.js

@@ -0,0 +1,14 @@
+export function usage() {
+    console.log(`Usage:
+  kennel schema <path>
+  kennel validate <path>
+  kennel doctor <path>
+  kennel dev [path] [--config <json-file>] [--port <port>] [--script <script>] [--dry-run] [-- <args...>]
+  kennel mcp generate [path] [--config <json-file>] [--data-only|--function-only]
+  kennel publish init cloudflare [path] [--config <json-file>] [--force] [--hostname <hostname>]
+  kennel publish [path] [--config <json-file>] [--dry-run] [--force] [--hostname <hostname>] [--test-email <email>] [--skip-test] [--use-doppler-token]
+  kennel publish cloudflare [path] [--config <json-file>] [--dry-run] [--force] [--hostname <hostname>] [--test-email <email>] [--skip-test] [--use-doppler-token]
+  kennel deploy [path] [--config <json-file>] [legacy alias for publish]
+  kennel dp [path] [--config <json-file>] [legacy alias for publish]
+`);
+}

package/dist/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/deploy/cloudflare.js

@@ -0,0 +1,91 @@
+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 { commandLine } from '../shared/process.js';
+import { packageJsonPath, publishBuildCommand, publishTestUrl, publishWranglerArgs, publishWranglerCommand, publicationAccess, } 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';
+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));
+    }
+    return publishCloudflare(input);
+}
+export function deploy(input) {
+    return publish(input);
+}

package/dist/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;