@solcreek/cli 0.4.1 → 0.4.3

package/dist/commands/deploy.js

@@ -736,6 +736,7 @@ async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = f
                         ...resolved.compatibilityFlags.filter((f) => f !== "nodejs_compat"),
                     ] }),
             ...(resolved.cron.length > 0 ? { cron: resolved.cron } : {}),
+            ...(resolved.queue ? { queue: true } : {}),
         };
         await client.uploadDeploymentBundle(project.id, deployment.id, bundle);
         // Poll for async deploy progress
@@ -785,6 +786,9 @@ async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = f
                 if (resolved.cron.length > 0) {
                     consola.info(`  Cron: ${resolved.cron.join(", ")}`);
                 }
+                if (resolved.queue) {
+                    consola.info("  Queue: enabled");
+                }
                 // Contextual next-step hints (non-JSON only)
                 if (!jsonMode) {
                     printNextStepHint(renderMode, resolved);

package/dist/commands/dev.js

@@ -58,6 +58,45 @@ export const devCommand = defineCommand({
             await server.stop();
             process.exit(1);
         }
+        // Interactive trigger commands (only if cron/queue configured)
+        if (config.cron.length > 0 || config.queue) {
+            const { createInterface } = await import("node:readline");
+            const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+            rl.on("line", async (line) => {
+                const input = line.trim();
+                if (!input)
+                    return;
+                if (input === "cron" && config.cron.length > 0) {
+                    try {
+                        await server.triggerScheduled();
+                        consola.success("Triggered scheduled()");
+                    }
+                    catch (e) {
+                        consola.error(`scheduled() error: ${e.message}`);
+                    }
+                    return;
+                }
+                if (input.startsWith("queue ") && config.queue) {
+                    const payload = input.slice(6).trim();
+                    let parsed = payload;
+                    try {
+                        parsed = JSON.parse(payload);
+                    }
+                    catch {
+                        // Not JSON, send as string
+                    }
+                    try {
+                        await server.sendQueueMessage(parsed);
+                        consola.success(`Sent message to queue()`);
+                    }
+                    catch (e) {
+                        consola.error(`queue() error: ${e.message}`);
+                    }
+                    return;
+                }
+                consola.warn(`Unknown command: ${input}`);
+            });
+        }
     },
 });
 //# sourceMappingURL=dev.js.map

package/dist/commands/queue.d.ts

@@ -0,0 +1,2 @@
+export declare const queueCommand: import("citty").CommandDef<import("citty").ArgsDef>;
+//# sourceMappingURL=queue.d.ts.map

package/dist/commands/queue.js

@@ -0,0 +1,92 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { CreekClient, parseConfig } from "@solcreek/sdk";
+import { getToken, getApiUrl } from "../utils/config.js";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { globalArgs, resolveJsonMode, jsonOutput } from "../utils/output.js";
+function getProjectSlug() {
+    const configPath = join(process.cwd(), "creek.toml");
+    if (!existsSync(configPath)) {
+        consola.error("No creek.toml found. Run `creek init` first.");
+        process.exit(1);
+    }
+    return parseConfig(readFileSync(configPath, "utf-8")).project.name;
+}
+function getClient() {
+    const token = getToken();
+    if (!token) {
+        consola.error("Not authenticated. Run `creek login` first.");
+        process.exit(1);
+    }
+    return new CreekClient(getApiUrl(), token);
+}
+const queueSend = defineCommand({
+    meta: { name: "send", description: "Send a message to the project's queue" },
+    args: {
+        message: {
+            type: "positional",
+            description: "Message body (string, or use --json for JSON content)",
+            required: true,
+        },
+        parseJson: {
+            type: "boolean",
+            alias: "j",
+            description: "Parse message as JSON",
+            default: false,
+        },
+        project: {
+            type: "string",
+            description: "Project slug (defaults to current creek.toml)",
+        },
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const client = getClient();
+        const slug = args.project ?? getProjectSlug();
+        let payload = args.message;
+        if (args.parseJson) {
+            try {
+                payload = JSON.parse(args.message);
+            }
+            catch (err) {
+                if (jsonMode) {
+                    jsonOutput({ ok: false, error: "invalid_json", message: err instanceof Error ? err.message : String(err) }, 1, []);
+                }
+                consola.error(`Invalid JSON: ${err instanceof Error ? err.message : err}`);
+                process.exit(1);
+            }
+        }
+        try {
+            const result = await client.sendQueueMessage(slug, payload);
+            if (jsonMode) {
+                jsonOutput({ ok: true, project: slug, queueId: result.queueId }, 0, [
+                    { command: `creek deployments --project ${slug}`, description: "View deployment history" },
+                ]);
+            }
+            consola.success(`Sent message to ${slug} queue`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (jsonMode) {
+                jsonOutput({ ok: false, error: "send_failed", message: msg }, 1, [
+                    { command: `creek status --project ${slug}`, description: "Check project triggers" },
+                ]);
+            }
+            consola.error(`Failed to send: ${msg}`);
+            consola.info("Make sure your creek.toml has `queue = true` under [triggers] and the project is deployed.");
+            process.exit(1);
+        }
+    },
+});
+export const queueCommand = defineCommand({
+    meta: {
+        name: "queue",
+        description: "Send messages to the project's queue",
+    },
+    subCommands: {
+        send: queueSend,
+    },
+});
+//# sourceMappingURL=queue.js.map

package/dist/commands/status.js

@@ -2,9 +2,7 @@ import { defineCommand } from "citty";
 import consola from "consola";
 import { CreekClient } from "@solcreek/sdk";
 import { getToken, getApiUrl, getSandboxApiUrl } from "../utils/config.js";
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { parseConfig } from "@solcreek/sdk";
+import { resolveConfig, formatDetectionSummary, ConfigNotFoundError } from "@solcreek/sdk";
 import { globalArgs, resolveJsonMode, jsonOutput, AUTH_BREADCRUMBS, NO_PROJECT_BREADCRUMBS } from "../utils/output.js";
 export const statusCommand = defineCommand({
     meta: {
@@ -78,27 +76,32 @@ async function projectStatus(jsonMode) {
         consola.info("To check a sandbox: creek status <sandboxId>");
         process.exit(1);
     }
-    const configPath = join(process.cwd(), "creek.toml");
-    if (!existsSync(configPath)) {
-        if (jsonMode)
-            jsonOutput({ ok: false, error: "no_project", message: "No creek.toml found" }, 1, NO_PROJECT_BREADCRUMBS);
-        consola.error("No creek.toml found.");
-        consola.info("To check a sandbox: creek status <sandboxId>");
-        process.exit(1);
+    let resolved;
+    try {
+        resolved = resolveConfig(process.cwd());
+    }
+    catch (err) {
+        if (err instanceof ConfigNotFoundError) {
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "no_project", message: "No project config found" }, 1, NO_PROJECT_BREADCRUMBS);
+            consola.error("No project config found.");
+            consola.info("To check a sandbox: creek status <sandboxId>");
+            process.exit(1);
+        }
+        throw err;
     }
-    const config = parseConfig(readFileSync(configPath, "utf-8"));
     const client = new CreekClient(getApiUrl(), token);
     let project;
     try {
-        project = await client.getProject(config.project.name);
+        project = await client.getProject(resolved.projectName);
     }
     catch {
         if (jsonMode)
-            jsonOutput({ ok: false, error: "not_found", message: `Project "${config.project.name}" not found` }, 1, [
+            jsonOutput({ ok: false, error: "not_found", message: `Project "${resolved.projectName}" not found` }, 1, [
                 { command: "creek deploy", description: "Deploy to create the project" },
                 { command: "creek projects", description: "List existing projects" },
             ]);
-        consola.error(`Project "${config.project.name}" not found.`);
+        consola.error(`Project "${resolved.projectName}" not found.`);
         process.exit(1);
     }
     if (jsonMode) {
@@ -106,8 +109,12 @@ async function projectStatus(jsonMode) {
             ok: true,
             type: "project",
             project: project.slug,
+            config: resolved.source,
             framework: project.framework,
             productionDeploymentId: project.production_deployment_id,
+            bindings: resolved.bindings.map((b) => b.type),
+            cron: resolved.cron,
+            queue: resolved.queue,
             createdAt: project.created_at,
         }, 0, [
             { command: `creek deployments --project ${project.slug}`, description: "List deployment history" },
@@ -115,12 +122,18 @@ async function projectStatus(jsonMode) {
         ]);
     }
     const deployed = project.production_deployment_id ? "deployed" : "not deployed";
-    const framework = project.framework ? ` (${project.framework})` : "";
-    consola.log(`\n  Project ${project.slug}${framework}`);
+    consola.log(`\n  Project ${project.slug}`);
+    consola.log(`  Config:  ${formatDetectionSummary(resolved)}`);
     consola.log(`  Status:  ${deployed}`);
     if (project.production_deployment_id) {
         consola.log(`  Deploy:  ${project.production_deployment_id.slice(0, 8)}`);
     }
+    if (resolved.cron.length > 0) {
+        consola.log(`  Cron:    ${resolved.cron.join(", ")}`);
+    }
+    if (resolved.queue) {
+        consola.log("  Queue:   enabled");
+    }
     consola.log("");
 }
 //# sourceMappingURL=status.js.map

package/dist/dev/server.d.ts

@@ -13,6 +13,10 @@ export declare class DevServer {
     private proxy;
     constructor(options: DevServerOptions);
     start(): Promise<void>;
+    /** Trigger the worker's scheduled() handler. */
+    triggerScheduled(): Promise<void>;
+    /** Send a message to the worker's queue() handler. */
+    sendQueueMessage(message: unknown): Promise<void>;
     stop(): Promise<void>;
 }
 //# sourceMappingURL=server.d.ts.map

package/dist/dev/server.js

@@ -47,6 +47,8 @@ export class DevServer {
                 realtimeUrl: `http://127.0.0.1:${this.realtimeServer.getPort()}`,
                 projectSlug: config.projectName,
                 vars: config.vars,
+                cron: config.cron,
+                queue: config.queue,
                 onRebuild: (ms) => {
                     consola.info(`Worker rebuilt in ${ms}ms`);
                 },
@@ -117,8 +119,38 @@ export class DevServer {
         }
         consola.info(`Realtime:  ws://localhost:${actualPort}`);
         consola.info(`Data:      .creek/dev/`);
+        if (config.cron.length > 0 || config.queue) {
+            const triggers = [];
+            if (config.cron.length > 0)
+                triggers.push(`${config.cron.length} cron`);
+            if (config.queue)
+                triggers.push("queue");
+            consola.info(`Triggers:  ${triggers.join(", ")}`);
+        }
         console.log("");
         consola.success(`Ready in ${elapsed}ms`);
+        if (config.cron.length > 0 || config.queue) {
+            console.log("");
+            consola.info("Trigger commands (type and press Enter):");
+            if (config.cron.length > 0) {
+                consola.info("  cron                      Trigger scheduled() handler");
+            }
+            if (config.queue) {
+                consola.info('  queue <message>           Send a message to queue() handler');
+            }
+        }
+    }
+    /** Trigger the worker's scheduled() handler. */
+    async triggerScheduled() {
+        if (!this.workerRunner)
+            throw new Error("Worker not running");
+        await this.workerRunner.triggerScheduled();
+    }
+    /** Send a message to the worker's queue() handler. */
+    async sendQueueMessage(message) {
+        if (!this.workerRunner)
+            throw new Error("Worker not running");
+        await this.workerRunner.sendQueueMessage(message);
     }
     async stop() {
         // Stop in reverse order

package/dist/dev/worker-runner.d.ts

@@ -16,6 +16,10 @@ export interface WorkerRunnerOptions {
     vars?: Record<string, string>;
     /** Whether the project has client assets (Worker + SPA hybrid). */
     hasClientAssets?: boolean;
+    /** Cron schedules from creek.toml [triggers].cron */
+    cron?: string[];
+    /** Whether project uses a queue (auto-provisions a local queue) */
+    queue?: boolean;
     /** Callback when worker is rebuilt. */
     onRebuild?: (durationMs: number) => void;
     /**
@@ -42,6 +46,10 @@ export declare class WorkerRunner {
     /** Dispatch a fetch request to the worker (via Miniflare). */
     dispatchFetch(input: string, init?: RequestInit): Promise<Response>;
     private buildMiniflareOptions;
+    /** Trigger the scheduled() handler manually (for local cron simulation). */
+    triggerScheduled(scheduledTime?: number, cron?: string): Promise<Response>;
+    /** Send a message to the local queue (consumed by the worker's queue() handler). */
+    sendQueueMessage(message: unknown): Promise<void>;
     private get esbuildOptions();
     private bundle;
     private startWatching;

package/dist/dev/worker-runner.js

@@ -124,8 +124,37 @@ export class WorkerRunner {
             opts.r2Buckets = { [r2BindingName]: "creek-dev-r2" };
             opts.r2Persist = persistDir ? join(persistDir, "r2") : false;
         }
+        // Queue (producer + consumer wired to the same worker)
+        if (this.options.queue) {
+            opts.queueProducers = { QUEUE: "creek-dev-queue" };
+            opts.queueConsumers = {
+                "creek-dev-queue": {
+                    maxBatchSize: 10,
+                    maxBatchTimeout: 1,
+                    maxRetries: 3,
+                },
+            };
+        }
         return opts;
     }
+    /** Trigger the scheduled() handler manually (for local cron simulation). */
+    async triggerScheduled(scheduledTime = Date.now(), cron = "* * * * *") {
+        if (!this.mf)
+            throw new Error("WorkerRunner not started");
+        const worker = await this.mf.getWorker();
+        const url = `http://placeholder/cdn-cgi/handler/scheduled?time=${scheduledTime}&cron=${encodeURIComponent(cron)}`;
+        return worker.fetch(url);
+    }
+    /** Send a message to the local queue (consumed by the worker's queue() handler). */
+    async sendQueueMessage(message) {
+        if (!this.mf)
+            throw new Error("WorkerRunner not started");
+        if (!this.options.queue) {
+            throw new Error("Queue is not enabled. Add `queue = true` to [triggers] in creek.toml.");
+        }
+        const queue = await this.mf.getQueueProducer("QUEUE");
+        await queue.send(message);
+    }
     get esbuildOptions() {
         return {
             absWorkingDir: this.options.cwd,

package/dist/index.js

@@ -17,6 +17,7 @@ import { statusCommand } from "./commands/status.js";
 import { devCommand } from "./commands/dev.js";
 import { rollbackCommand } from "./commands/rollback.js";
 import { opsCommand } from "./commands/ops.js";
+import { queueCommand } from "./commands/queue.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const cliPkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
 // Read version from the "creek" facade package (what users install),
@@ -47,6 +48,7 @@ const main = defineCommand({
         init: initCommand,
         claim: claimCommand,
         env: envCommand,
+        queue: queueCommand,
         domains: domainsCommand,
         rollback: rollbackCommand,
         ops: opsCommand,

package/dist/utils/worker-bundle.js

@@ -86,6 +86,8 @@ export default {
       return new Response("Not Found", { status: 404 });
     });
   },
+  ${generateScheduledHandler()}
+  ${generateQueueHandler()}
 };
 `;
     }
@@ -114,9 +116,25 @@ export default {
       throw new Error("[creek] Worker must export default a fetch handler, Hono app, or { fetch() } object.");
     });
   },
+  ${generateScheduledHandler()}
+  ${generateQueueHandler()}
 };
 `;
 }
+function generateScheduledHandler() {
+    return `async scheduled(event, env, ctx) {
+    if (typeof handler.scheduled === "function") {
+      return _runRequest(env, ctx, () => handler.scheduled(event, env, ctx));
+    }
+  },`;
+}
+function generateQueueHandler() {
+    return `async queue(batch, env, ctx) {
+    if (typeof handler.queue === "function") {
+      return _runRequest(env, ctx, () => handler.queue(batch, env, ctx));
+    }
+  },`;
+}
 /**
  * Bundle a Worker entry point with Creek runtime auto-injection.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solcreek/cli",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "CLI for the Creek deployment platform",
   "type": "module",
   "main": "./dist/index.js",
@@ -28,7 +28,7 @@
   "homepage": "https://creek.dev",
   "repository": {
     "type": "git",
-    "url": "https://github.com/solcreek/creek.git",
+    "url": "git+https://github.com/solcreek/creek.git",
     "directory": "packages/cli"
   },
   "dependencies": {