@kya-os/create-molti 0.1.0-canary.1

package/dist/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+/**
+ * @kya-os/create-molti
+ *
+ * Scaffold a Moltworker project with MCP-I identity.
+ *
+ * Usage:
+ *   npx @kya-os/create-molti my-agent
+ *   npx @kya-os/create-molti my-agent --instance-type standard-1
+ */
+import { run } from './cli.js';
+run().catch((error) => {
+    console.error('Error:', error.message);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;;;;;;GAQG;AAEH,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;IACpB,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IACvC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist/templates/auth-module.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Auth Module Template (src/auth.ts)
+ *
+ * Generates Cloudflare Access middleware for JWT verification.
+ */
+export declare function generateAuthModule(): string;
+//# sourceMappingURL=auth-module.d.ts.map

package/dist/templates/auth-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-module.d.ts","sourceRoot":"","sources":["../../src/templates/auth-module.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,wBAAgB,kBAAkB,IAAI,MAAM,CA6D3C"}

package/dist/templates/auth-module.js

@@ -0,0 +1,68 @@
+/**
+ * Auth Module Template (src/auth.ts)
+ *
+ * Generates Cloudflare Access middleware for JWT verification.
+ */
+export function generateAuthModule() {
+    return `/**
+ * Cloudflare Access Authentication Middleware
+ *
+ * Verifies CF Access JWT tokens for protected routes.
+ * Skips auth in dev mode for local development.
+ */
+
+import type { Context, Next } from "hono";
+import type { AppEnv } from "./types";
+
+interface AccessMiddlewareOptions {
+  type: "api" | "admin";
+  redirectOnMissing?: boolean;
+}
+
+/**
+ * Create CF Access authentication middleware
+ */
+export function createAccessMiddleware(options: AccessMiddlewareOptions) {
+  return async (c: Context<AppEnv>, next: Next) => {
+    const env = c.env;
+
+    // Skip auth in dev mode
+    if (env.DEV_MODE === "true") {
+      c.set("accessUser", { email: "dev@localhost", name: "Dev User" });
+      return next();
+    }
+
+    // Skip auth if CF Access is not configured
+    if (!env.CF_ACCESS_TEAM_DOMAIN || !env.CF_ACCESS_AUD) {
+      c.set("accessUser", { email: "unconfigured@localhost" });
+      return next();
+    }
+
+    // Extract JWT from CF-Access-JWT-Assertion header or cookie
+    const jwt =
+      c.req.header("CF-Access-JWT-Assertion") ||
+      getCookie(c.req.header("cookie") || "", "CF_Authorization");
+
+    if (!jwt) {
+      if (options.redirectOnMissing) {
+        return c.redirect(
+          \`https://\${env.CF_ACCESS_TEAM_DOMAIN}/cdn-cgi/access/login\`
+        );
+      }
+      return c.json({ error: "Authentication required" }, 401);
+    }
+
+    // For production, verify JWT with CF Access JWKS
+    // Simplified: trust CF Access header in Workers environment
+    c.set("accessUser", { email: "authenticated@user" });
+    await next();
+  };
+}
+
+function getCookie(cookieHeader: string, name: string): string | undefined {
+  const match = cookieHeader.match(new RegExp(\`(?:^|;\\\\s*)\${name}=([^;]*)\`));
+  return match?.[1];
+}
+`;
+}
+//# sourceMappingURL=auth-module.js.map

package/dist/templates/auth-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-module.js","sourceRoot":"","sources":["../../src/templates/auth-module.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,UAAU,kBAAkB;IAChC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DR,CAAC;AACF,CAAC"}

package/dist/templates/dockerfile.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Dockerfile Template
+ *
+ * Generates a Dockerfile for the Moltworker container.
+ * Based on the Cloudflare sandbox base image with Node.js and moltbot CLI.
+ */
+export declare function generateDockerfile(): string;
+//# sourceMappingURL=dockerfile.d.ts.map

package/dist/templates/dockerfile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dockerfile.d.ts","sourceRoot":"","sources":["../../src/templates/dockerfile.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,wBAAgB,kBAAkB,IAAI,MAAM,CAgC3C"}

package/dist/templates/dockerfile.js

@@ -0,0 +1,40 @@
+/**
+ * Dockerfile Template
+ *
+ * Generates a Dockerfile for the Moltworker container.
+ * Based on the Cloudflare sandbox base image with Node.js and moltbot CLI.
+ */
+export function generateDockerfile() {
+    return `FROM docker.io/cloudflare/sandbox:0.7.0
+
+# Install Node.js 22 (required by moltbot)
+ENV NODE_VERSION=22.13.1
+RUN apt-get update && apt-get install -y xz-utils ca-certificates rsync \\
+ && curl -fsSLk https://nodejs.org/dist/v\${NODE_VERSION}/node-v\${NODE_VERSION}-linux-x64.tar.xz -o /tmp/node.tar.xz \\
+ && tar -xJf /tmp/node.tar.xz -C /usr/local --strip-components=1 \\
+ && rm /tmp/node.tar.xz
+
+# Install pnpm
+RUN npm install -g pnpm
+
+# Install moltbot CLI
+RUN npm install -g clawdbot@2026.1.24-3
+
+# Create directories
+RUN mkdir -p /root/.clawdbot \\
+ && mkdir -p /root/.clawdbot-templates \\
+ && mkdir -p /root/clawd \\
+ && mkdir -p /root/clawd/skills
+
+# Copy startup script
+COPY start-moltbot.sh /usr/local/bin/start-moltbot.sh
+RUN chmod +x /usr/local/bin/start-moltbot.sh
+
+# Copy config template
+COPY moltbot.json.template /root/.clawdbot-templates/moltbot.json.template
+
+WORKDIR /root/clawd
+EXPOSE 18789
+`;
+}
+//# sourceMappingURL=dockerfile.js.map

package/dist/templates/dockerfile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dockerfile.js","sourceRoot":"","sources":["../../src/templates/dockerfile.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,UAAU,kBAAkB;IAChC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BR,CAAC;AACF,CAAC"}

package/dist/templates/gateway.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Gateway Module Template (src/gateway.ts)
+ *
+ * Generates the gateway management code that ensures the
+ * Moltbot process is running inside the container.
+ */
+export declare function generateGatewayModule(): string;
+//# sourceMappingURL=gateway.d.ts.map

package/dist/templates/gateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway.d.ts","sourceRoot":"","sources":["../../src/templates/gateway.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,wBAAgB,qBAAqB,IAAI,MAAM,CAwG9C"}

package/dist/templates/gateway.js

@@ -0,0 +1,112 @@
+/**
+ * Gateway Module Template (src/gateway.ts)
+ *
+ * Generates the gateway management code that ensures the
+ * Moltbot process is running inside the container.
+ */
+export function generateGatewayModule() {
+    return `/**
+ * Moltbot Gateway Management
+ *
+ * Ensures the Moltbot process is running inside the container
+ * and waits for the gateway port to be ready.
+ */
+
+export const MOLTBOT_PORT = 18789;
+const STARTUP_TIMEOUT_MS = 180_000; // 3 minutes
+
+/**
+ * Ensure the Moltbot gateway is running and ready
+ */
+export async function ensureMoltbotGateway(
+  sandbox: any,
+  env: Record<string, unknown>
+): Promise<void> {
+  // Check for existing process
+  const processes = await sandbox.ps();
+  const existing = processes.find(
+    (p: { command: string; status: string }) =>
+      (p.command.includes("start-moltbot.sh") || p.command.includes("clawdbot gateway")) &&
+      p.status === "running"
+  );
+
+  if (existing) {
+    await waitForPort(sandbox, MOLTBOT_PORT, STARTUP_TIMEOUT_MS);
+    return;
+  }
+
+  // Build environment variables for the container process
+  const envVars = buildEnvVars(env);
+
+  // Start the moltbot process
+  await sandbox.start("/usr/local/bin/start-moltbot.sh", {
+    env: envVars,
+  });
+
+  await waitForPort(sandbox, MOLTBOT_PORT, STARTUP_TIMEOUT_MS);
+}
+
+/**
+ * Build environment variables to pass to the container
+ */
+function buildEnvVars(env: Record<string, unknown>): Record<string, string> {
+  const vars: Record<string, string> = {};
+
+  // AI Gateway priority
+  if (env.AI_GATEWAY_API_KEY) {
+    const baseUrl = String(env.AI_GATEWAY_BASE_URL || "");
+    if (baseUrl.includes("openai")) {
+      vars.OPENAI_API_KEY = String(env.AI_GATEWAY_API_KEY);
+      vars.OPENAI_BASE_URL = baseUrl.replace(/\\/$/, "");
+    } else {
+      vars.ANTHROPIC_API_KEY = String(env.AI_GATEWAY_API_KEY);
+      vars.ANTHROPIC_BASE_URL = baseUrl.replace(/\\/$/, "");
+    }
+  } else {
+    if (env.ANTHROPIC_API_KEY) vars.ANTHROPIC_API_KEY = String(env.ANTHROPIC_API_KEY);
+    if (env.OPENAI_API_KEY) vars.OPENAI_API_KEY = String(env.OPENAI_API_KEY);
+  }
+
+  // Gateway token
+  if (env.MOLTBOT_GATEWAY_TOKEN) {
+    vars.CLAWDBOT_GATEWAY_TOKEN = String(env.MOLTBOT_GATEWAY_TOKEN);
+  }
+
+  // Bot tokens
+  if (env.TELEGRAM_BOT_TOKEN) vars.TELEGRAM_BOT_TOKEN = String(env.TELEGRAM_BOT_TOKEN);
+  if (env.DISCORD_BOT_TOKEN) vars.DISCORD_BOT_TOKEN = String(env.DISCORD_BOT_TOKEN);
+  if (env.SLACK_BOT_TOKEN) vars.SLACK_BOT_TOKEN = String(env.SLACK_BOT_TOKEN);
+
+  if (env.DEV_MODE) vars.DEV_MODE = String(env.DEV_MODE);
+
+  return vars;
+}
+
+/**
+ * Wait for a port to become available
+ */
+async function waitForPort(
+  sandbox: any,
+  port: number,
+  timeoutMs: number
+): Promise<void> {
+  const start = Date.now();
+
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const response = await sandbox.containerFetch(
+        new Request(\`http://localhost:\${port}/\`),
+        port
+      );
+      if (response.status < 500) return;
+    } catch {
+      // Port not ready yet
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+
+  throw new Error(\`Moltbot gateway did not start within \${timeoutMs / 1000}s\`);
+}
+`;
+}
+//# sourceMappingURL=gateway.js.map

package/dist/templates/gateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway.js","sourceRoot":"","sources":["../../src/templates/gateway.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,UAAU,qBAAqB;IACnC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsGR,CAAC;AACF,CAAC"}

package/dist/templates/github-workflow.d.ts

@@ -0,0 +1,7 @@
+/**
+ * GitHub Actions Workflow Template
+ *
+ * Generates the deploy.yml for CI/CD to Cloudflare.
+ */
+export declare function generateDeployWorkflow(): string;
+//# sourceMappingURL=github-workflow.d.ts.map

package/dist/templates/github-workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github-workflow.d.ts","sourceRoot":"","sources":["../../src/templates/github-workflow.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,wBAAgB,sBAAsB,IAAI,MAAM,CAyC/C"}

package/dist/templates/github-workflow.js

@@ -0,0 +1,48 @@
+/**
+ * GitHub Actions Workflow Template
+ *
+ * Generates the deploy.yml for CI/CD to Cloudflare.
+ */
+export function generateDeployWorkflow() {
+    return `name: Deploy to Cloudflare
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+    inputs:
+      reason:
+        description: 'Reason for manual deployment'
+        required: false
+        default: 'Manual deployment'
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    name: Deploy Moltworker
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Deploy to Cloudflare
+        uses: cloudflare/wrangler-action@v3
+        with:
+          apiToken: \${{ secrets.CLOUDFLARE_API_TOKEN }}
+          secrets: |
+            MCP_IDENTITY_PRIVATE_KEY
+            AGENTSHIELD_API_KEY
+            ANTHROPIC_API_KEY
+        env:
+          MCP_IDENTITY_PRIVATE_KEY: \${{ secrets.MCP_IDENTITY_PRIVATE_KEY }}
+          AGENTSHIELD_API_KEY: \${{ secrets.AGENTSHIELD_API_KEY }}
+          ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
+`;
+}
+//# sourceMappingURL=github-workflow.js.map

package/dist/templates/github-workflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"github-workflow.js","sourceRoot":"","sources":["../../src/templates/github-workflow.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,UAAU,sBAAsB;IACpC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCR,CAAC;AACF,CAAC"}

package/dist/templates/health-module.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Health Module Template (src/routes/public.ts)
+ *
+ * Generates public routes including health checks and status endpoints.
+ */
+export declare function generateHealthModule(projectName: string): string;
+//# sourceMappingURL=health-module.d.ts.map

package/dist/templates/health-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-module.d.ts","sourceRoot":"","sources":["../../src/templates/health-module.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAuDhE"}

package/dist/templates/health-module.js

@@ -0,0 +1,62 @@
+/**
+ * Health Module Template (src/routes/public.ts)
+ *
+ * Generates public routes including health checks and status endpoints.
+ */
+export function generateHealthModule(projectName) {
+    return `/**
+ * Public Routes
+ *
+ * Health checks and status endpoints — no authentication required.
+ */
+
+import { Hono } from "hono";
+import type { AppEnv } from "../types";
+
+export const publicRoutes = new Hono<AppEnv>();
+
+/**
+ * Basic health check
+ */
+publicRoutes.get("/sandbox-health", (c) => {
+  return c.json({
+    status: "ok",
+    service: "${projectName}",
+    timestamp: new Date().toISOString(),
+  });
+});
+
+/**
+ * Detailed status with gateway check
+ */
+publicRoutes.get("/api/status", async (c) => {
+  const sandbox = c.get("sandbox");
+
+  try {
+    const processes = await sandbox.ps();
+    const moltbot = processes.find(
+      (p: { command: string; status: string }) =>
+        (p.command.includes("start-moltbot.sh") || p.command.includes("clawdbot gateway")) &&
+        p.status === "running"
+    );
+
+    return c.json({
+      status: moltbot ? "running" : "starting",
+      service: "${projectName}",
+      identity: {
+        did: c.env.MCP_IDENTITY_AGENT_DID,
+      },
+      gateway: moltbot
+        ? { pid: moltbot.pid, status: moltbot.status }
+        : null,
+    });
+  } catch {
+    return c.json({
+      status: "unknown",
+      service: "${projectName}",
+    });
+  }
+});
+`;
+}
+//# sourceMappingURL=health-module.js.map

package/dist/templates/health-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-module.js","sourceRoot":"","sources":["../../src/templates/health-module.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,UAAU,oBAAoB,CAAC,WAAmB;IACtD,OAAO;;;;;;;;;;;;;;;;;gBAiBO,WAAW;;;;;;;;;;;;;;;;;;;;;kBAqBT,WAAW;;;;;;;;;;;kBAWX,WAAW;;;;CAI5B,CAAC;AACF,CAAC"}

package/dist/templates/identity-json.d.ts

@@ -0,0 +1,15 @@
+/**
+ * .mcpi/identity.json Template
+ *
+ * Generates the public identity file that is committed to the repo.
+ * Contains the agent DID and public key — private key is a secret.
+ */
+interface IdentityJsonOptions {
+    did: string;
+    publicKey: string;
+    agentName?: string;
+    agentDescription?: string;
+}
+export declare function generateIdentityJson(opts: IdentityJsonOptions): string;
+export {};
+//# sourceMappingURL=identity-json.d.ts.map

package/dist/templates/identity-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity-json.d.ts","sourceRoot":"","sources":["../../src/templates/identity-json.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,UAAU,mBAAmB;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,mBAAmB,GAAG,MAAM,CActE"}

package/dist/templates/identity-json.js

@@ -0,0 +1,18 @@
+/**
+ * .mcpi/identity.json Template
+ *
+ * Generates the public identity file that is committed to the repo.
+ * Contains the agent DID and public key — private key is a secret.
+ */
+export function generateIdentityJson(opts) {
+    return JSON.stringify({
+        version: '1.0',
+        type: 'molti-agent',
+        did: opts.did,
+        publicKey: opts.publicKey,
+        agentName: opts.agentName || undefined,
+        agentDescription: opts.agentDescription || undefined,
+        createdAt: new Date().toISOString(),
+    }, null, 2);
+}
+//# sourceMappingURL=identity-json.js.map

package/dist/templates/identity-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity-json.js","sourceRoot":"","sources":["../../src/templates/identity-json.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,MAAM,UAAU,oBAAoB,CAAC,IAAyB;IAC5D,OAAO,IAAI,CAAC,SAAS,CACnB;QACE,OAAO,EAAE,KAAK;QACd,IAAI,EAAE,aAAa;QACnB,GAAG,EAAE,IAAI,CAAC,GAAG;QACb,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,SAAS,EAAE,IAAI,CAAC,SAAS,IAAI,SAAS;QACtC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB,IAAI,SAAS;QACpD,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;KACpC,EACD,IAAI,EACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/templates/identity-module.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Identity Module Template (src/identity.ts)
+ *
+ * Generates the MCP-I identity provider initialization code.
+ * Uses @kya-os/mcp-i-cloudflare for Cloudflare-specific providers.
+ */
+export declare function generateIdentityModule(): string;
+//# sourceMappingURL=identity-module.d.ts.map

package/dist/templates/identity-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity-module.d.ts","sourceRoot":"","sources":["../../src/templates/identity-module.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,wBAAgB,sBAAsB,IAAI,MAAM,CAiF/C"}

package/dist/templates/identity-module.js

@@ -0,0 +1,89 @@
+/**
+ * Identity Module Template (src/identity.ts)
+ *
+ * Generates the MCP-I identity provider initialization code.
+ * Uses @kya-os/mcp-i-cloudflare for Cloudflare-specific providers.
+ */
+export function generateIdentityModule() {
+    return `/**
+ * MCP-I Identity Provider
+ *
+ * Initializes cryptographic identity from environment variables.
+ * Uses @kya-os/mcp-i-cloudflare for Cloudflare Workers-compatible
+ * Ed25519 signing via Web Crypto API.
+ */
+
+import {
+  WebCryptoProvider,
+  KVNonceCacheProvider,
+  CloudflareProofGenerator,
+} from "@kya-os/mcp-i-cloudflare";
+
+interface IdentityConfig {
+  did: string;
+  publicKey: string;
+  privateKey: string;
+}
+
+interface IdentityProviderResult {
+  proofGenerator: InstanceType<typeof CloudflareProofGenerator>;
+  config: IdentityConfig;
+}
+
+/**
+ * Get the identity provider from environment
+ */
+export function getIdentityProvider(env: {
+  MCP_IDENTITY_AGENT_DID: string;
+  MCP_IDENTITY_PUBLIC_KEY: string;
+  MCP_IDENTITY_PRIVATE_KEY: string;
+  NONCE_CACHE: KVNamespace;
+  PROOF_ARCHIVE: KVNamespace;
+}): IdentityProviderResult {
+  const config: IdentityConfig = {
+    did: env.MCP_IDENTITY_AGENT_DID,
+    publicKey: env.MCP_IDENTITY_PUBLIC_KEY,
+    privateKey: env.MCP_IDENTITY_PRIVATE_KEY,
+  };
+
+  const cryptoProvider = new WebCryptoProvider();
+  const nonceCache = new KVNonceCacheProvider(env.NONCE_CACHE);
+
+  const proofGenerator = new CloudflareProofGenerator(
+    cryptoProvider,
+    nonceCache,
+    {
+      did: config.did,
+      privateKey: config.privateKey,
+      publicKey: config.publicKey,
+    }
+  );
+
+  return { proofGenerator, config };
+}
+
+/**
+ * Generate a proof for a tool execution
+ */
+export async function generateProof(
+  proofGenerator: InstanceType<typeof CloudflareProofGenerator>,
+  toolName: string,
+  input: unknown,
+  output: unknown
+): Promise<string | null> {
+  try {
+    const proof = await proofGenerator.generateProof({
+      toolName,
+      input: JSON.stringify(input),
+      output: JSON.stringify(output),
+      timestamp: new Date().toISOString(),
+    });
+    return proof;
+  } catch {
+    // Proof generation is non-critical — don't block tool execution
+    return null;
+  }
+}
+`;
+}
+//# sourceMappingURL=identity-module.js.map

package/dist/templates/identity-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity-module.js","sourceRoot":"","sources":["../../src/templates/identity-module.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,UAAU,sBAAsB;IACpC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+ER,CAAC;AACF,CAAC"}

package/dist/templates/moltbot-config.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Moltbot Config Template (moltbot.json.template)
+ *
+ * Default configuration for the Moltbot gateway.
+ */
+export declare function generateMoltbotConfig(): string;
+//# sourceMappingURL=moltbot-config.d.ts.map

package/dist/templates/moltbot-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moltbot-config.d.ts","sourceRoot":"","sources":["../../src/templates/moltbot-config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,wBAAgB,qBAAqB,IAAI,MAAM,CAgB9C"}

package/dist/templates/moltbot-config.js

@@ -0,0 +1,19 @@
+/**
+ * Moltbot Config Template (moltbot.json.template)
+ *
+ * Default configuration for the Moltbot gateway.
+ */
+export function generateMoltbotConfig() {
+    return JSON.stringify({
+        agents: {
+            defaults: {
+                workspace: '/root/clawd',
+            },
+        },
+        gateway: {
+            port: 18789,
+            mode: 'local',
+        },
+    }, null, 2);
+}
+//# sourceMappingURL=moltbot-config.js.map

package/dist/templates/moltbot-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"moltbot-config.js","sourceRoot":"","sources":["../../src/templates/moltbot-config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,UAAU,qBAAqB;IACnC,OAAO,IAAI,CAAC,SAAS,CACnB;QACE,MAAM,EAAE;YACN,QAAQ,EAAE;gBACR,SAAS,EAAE,aAAa;aACzB;SACF;QACD,OAAO,EAAE;YACP,IAAI,EAAE,KAAK;YACX,IAAI,EAAE,OAAO;SACd;KACF,EACD,IAAI,EACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/templates/package-json.d.ts

@@ -0,0 +1,13 @@
+/**
+ * package.json Template
+ *
+ * Generates the package.json for the scaffolded Moltworker project.
+ */
+import type { MoltiPackageVersions } from '../helpers/get-package-versions.js';
+interface PackageJsonOptions {
+    projectName: string;
+    versions: MoltiPackageVersions;
+}
+export declare function generatePackageJson(opts: PackageJsonOptions): string;
+export {};
+//# sourceMappingURL=package-json.d.ts.map

package/dist/templates/package-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-json.d.ts","sourceRoot":"","sources":["../../src/templates/package-json.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAE/E,UAAU,kBAAkB;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,oBAAoB,CAAC;CAChC;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,CAgCpE"}