@fluxy-chat/create-fluxy-chat 0.5.8 → 0.5.9

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.5.9] - 2026-08-21
+
+### Added
+
+- `--mode self-host` (alias of `local`). Interactive Worker URL, console URL, and optional Groq key. Writes `.fluxy/answers.json` and `.fluxy/worker.dev.vars` to paste into `apps/worker/.dev.vars`.
+- `pnpm setup:self-host` on the full template. If the Worker is down, setup asks for a URL instead of exiting immediately.
+
 ## [0.5.8] - 2026-08-19
 
 ### Fixed

package/dist/index.js

@@ -5,6 +5,7 @@ import { intro, log, note, outro, spinner } from "@clack/prompts";
 import pc from "picocolors";
 
 // src/prompts.ts
+import { randomBytes } from "crypto";
 import {
   confirm,
   isCancel,
@@ -97,11 +98,15 @@ function templatesDir() {
 }
 
 // src/prompts.ts
+var DEFAULT_WORKER_URL = "http://127.0.0.1:8787";
+var DEFAULT_CONSOLE_URL = "http://localhost:3000";
+function generateJwtSigningKey() {
+  return randomBytes(32).toString("hex");
+}
 var DEFAULT_PROJECT_NAME = "my-fluxy-bot";
 var DEFAULT_FULL_PROJECT_NAME = "my-fluxy-app";
 async function runPrompts(inputs) {
   const full = inputs.full ?? inputs.adapter === "full";
-  const mode = inputs.mode ?? (full ? "local" : void 0);
   let name = inputs.name;
   if (!name) {
     if (inputs.yes) {
@@ -197,6 +202,64 @@ async function runPrompts(inputs) {
     initialValue: true
   }));
   if (isCancel(shouldInitGit)) return null;
+  const isFull = full || adapter === "full";
+  let resolvedMode = inputs.mode;
+  let workerUrl;
+  let consoleUrl;
+  let groqApiKey;
+  let jwtSigningKey;
+  if (isFull) {
+    if (!resolvedMode) {
+      if (inputs.yes) {
+        resolvedMode = "local";
+      } else {
+        const picked = await select({
+          message: "Where does the Worker run?",
+          options: [
+            {
+              label: "Hosted (fluxychat.com + Clerk \u2014 no wrangler)",
+              value: "hosted"
+            },
+            {
+              label: "Self-host (your Worker / wrangler dev)",
+              value: "local"
+            }
+          ]
+        });
+        if (isCancel(picked)) return null;
+        resolvedMode = picked;
+      }
+    }
+    if (resolvedMode === "local") {
+      jwtSigningKey = generateJwtSigningKey();
+      if (inputs.yes) {
+        workerUrl = DEFAULT_WORKER_URL;
+        consoleUrl = DEFAULT_CONSOLE_URL;
+      } else {
+        const workerResult = await text({
+          message: "Worker URL:",
+          placeholder: DEFAULT_WORKER_URL,
+          initialValue: DEFAULT_WORKER_URL
+        });
+        if (isCancel(workerResult)) return null;
+        workerUrl = String(workerResult).trim() || DEFAULT_WORKER_URL;
+        const consoleResult = await text({
+          message: "Console URL (dashboard):",
+          placeholder: DEFAULT_CONSOLE_URL,
+          initialValue: DEFAULT_CONSOLE_URL
+        });
+        if (isCancel(consoleResult)) return null;
+        consoleUrl = String(consoleResult).trim() || DEFAULT_CONSOLE_URL;
+        const groqResult = await text({
+          message: "Groq API key (optional, for @assistant):",
+          placeholder: "gsk_\u2026"
+        });
+        if (isCancel(groqResult)) return null;
+        const groq = String(groqResult).trim();
+        if (groq) groqApiKey = groq;
+      }
+    }
+  }
   return {
     name,
     adapter: adapter ?? "react",
@@ -205,8 +268,12 @@ async function runPrompts(inputs) {
     shouldInstall,
     shouldInitGit,
     minimal: minimal || inputs.minimal === true,
-    full: full || adapter === "full",
-    mode: mode ?? (adapter === "full" ? "local" : void 0)
+    full: isFull,
+    mode: resolvedMode ?? (isFull ? "local" : void 0),
+    workerUrl,
+    consoleUrl,
+    groqApiKey,
+    jwtSigningKey
   };
 }
 
@@ -831,14 +898,12 @@ function parseArgs(argv) {
       args.adapter = "full";
     } else if (arg === "--mode") {
       const value = argv[++i]?.trim().toLowerCase();
-      if (value === "local" || value === "hosted") {
-        args.mode = value;
-        if (value === "hosted") {
-          args.full = true;
-          args.adapter = "full";
-        }
+      if (value === "local" || value === "hosted" || value === "self-host") {
+        args.mode = value === "self-host" ? "local" : value;
+        args.full = true;
+        args.adapter = "full";
       } else {
-        console.error(`Invalid mode: ${value}. Choose: local, hosted`);
+        console.error(`Invalid mode: ${value}. Choose: local, self-host, hosted`);
         process.exit(1);
       }
     } else if (arg === "--skip-install") {
@@ -894,7 +959,7 @@ function parseArgs(argv) {
   return args;
 }
 var HELP_TEXT = `
-${pc.bold("create-fluxy-chat")} \u2014 Scaffold a new FluxyChat bot project
+${pc.bold("create-fluxy-chat")} \u2014 Scaffold a FluxyChat app or bot worker
 
 ${pc.bold("Usage:")}
   npx @fluxy-chat/create-fluxy-chat [project-name] [options]
@@ -906,22 +971,19 @@ ${pc.bold("Options:")}
   -l, --language <lang>      Language: typescript (default) or javascript
   -y, --yes                  Skip prompts and accept defaults
   --full                     Full stack: chat + @assistant + setup scripts (recommended)
-  --mode <local|hosted>      hosted = no wrangler (uses fluxychat.com demo session)
-  --minimal                  Chat-only widget (ui-kit) \u2014 no platform modules
+  --mode <hosted|local|self-host>
+                             hosted = Clerk on fluxychat.com (no wrangler)
+                             local / self-host = your Worker (asks for URL + keys)
+  --minimal                  Chat-only widget (ui-kit)
   --skip-install             Skip dependency installation
   --no-git                   Skip git repository initialization
   -h, --help                 Show this help
 
 ${pc.bold("Examples:")}
-  ${pc.cyan("npx @fluxy-chat/create-fluxy-chat my-app --mode hosted -y")}
-  ${pc.cyan("npx @fluxy-chat/create-fluxy-chat my-app --full -y")}
-  ${pc.cyan("npx create-fluxy-chat my-chat --minimal")}
-  ${pc.cyan("npx create-fluxy-chat my-hr-bot --template hr-feedback")}
-  ${pc.cyan("npx create-fluxy-chat my-chat --template react")}
-  ${pc.cyan("npx create-fluxy-chat my-bot --adapter basic")}
-  ${pc.cyan("npx create-fluxy-chat my-bot --adapter slack")}
-  ${pc.cyan("npx create-fluxy-chat my-bot --adapter telegram --pm pnpm")}
-  ${pc.cyan("npx create-fluxy-chat my-bot -y --adapter discord")}
+  ${pc.cyan("npx @fluxy-chat/create-fluxy-chat@latest my-app --mode hosted -y")}
+  ${pc.cyan("npx @fluxy-chat/create-fluxy-chat@latest my-app --mode self-host")}
+  ${pc.cyan("npx @fluxy-chat/create-fluxy-chat@latest my-chat --minimal")}
+  ${pc.cyan("npx @fluxy-chat/create-fluxy-chat@latest my-bot --adapter slack")}
 `;
 async function main() {
   const args = parseArgs(process.argv.slice(2));
@@ -979,12 +1041,39 @@ async function main() {
       if (config.full || config.adapter === "full") {
         fs2.mkdirSync(path2.join(projectDir, ".fluxy"), { recursive: true });
         const setupMode = config.mode === "hosted" ? "hosted" : "local";
+        writeFile(projectDir, ".fluxy/mode", `${setupMode}
+`);
         writeFile(
           projectDir,
-          ".fluxy/mode",
-          `${setupMode}
+          ".fluxy/answers.json",
+          `${JSON.stringify(
+            {
+              mode: setupMode,
+              workerUrl: config.workerUrl ?? null,
+              consoleUrl: config.consoleUrl ?? null,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            null,
+            2
+          )}
 `
         );
+        if (setupMode === "local") {
+          const groqLine = config.groqApiKey ? `GROQ_API_KEY=${config.groqApiKey}` : "# GROQ_API_KEY=";
+          writeFile(
+            projectDir,
+            ".fluxy/worker.dev.vars",
+            [
+              "# Merge into fluxychat/apps/worker/.dev.vars (or paste after clone).",
+              "# Member JWTs are per-project in D1. This signing key is for bootstrap/secrets.",
+              "ALLOW_DEV_PROVISION=true",
+              `JWT_SIGNING_KEY=${config.jwtSigningKey ?? ""}`,
+              groqLine,
+              "AI_MODEL=openai/gpt-oss-20b",
+              ""
+            ].join("\n")
+          );
+        }
       }
       s.stop(
         config.mode === "hosted" ? "Full stack app created (hosted mode \u2014 run pnpm setup:hosted)." : "Full stack app created (chat + agent + setup scripts)."
@@ -1059,13 +1148,12 @@ async function main() {
     `${devCmd} dev            # http://localhost:5173`,
     `# Keep this project: https://fluxychat.com/onboarding?from=cli`
   ].join("\n") : [
-    `# Terminal 1 \u2014 FluxyChat monorepo (if not already running)`,
-    `pnpm --filter @fluxy-chat/worker dev`,
-    ``,
     `cd ${config.name}`,
-    `${devCmd} setup   # provision worker \u2192 writes .env`,
-    `${devCmd} dev     # http://localhost:5173 (+ dashboard if monorepo nearby)`,
-    `# Keep / import .env: http://localhost:3000/onboarding?from=cli`
+    `# 1. Clone FluxyChat and run: pnpm run self-host`,
+    `#    Merge .fluxy/worker.dev.vars into apps/worker/.dev.vars`,
+    `# 2. Start Worker: pnpm --filter @fluxy-chat/worker dev`,
+    `${devCmd} setup:local   # POST /dev/provision \u2192 writes .env`,
+    `${devCmd} dev           # http://localhost:5173`
   ].join("\n") : config.adapter === "react" || config.minimal ? [
     `cd ${config.name}`,
     "cp .env.example .env",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluxy-chat/create-fluxy-chat",
-  "version": "0.5.8",
+  "version": "0.5.9",
   "description": "Scaffold a new FluxyChat bot project with a single command",
   "type": "module",
   "main": "./dist/index.js",

package/readme.md

@@ -1,41 +1,33 @@
 # create-fluxy-chat
 
-Scaffold a new [FluxyChat](https://github.com/AlessandroFare/fluxychat) bot project with a single command.
+Scaffold a FluxyChat Vite app or bot worker.
 
 ## Quick start
 
 ```bash
-# Full stack — chat + @assistant + setup scripts (recommended)
-npx @fluxy-chat/create-fluxy-chat my-app --full -y
-cd my-app && pnpm setup && pnpm dev
+# Hosted — Clerk, no wrangler
+npx @fluxy-chat/create-fluxy-chat@latest my-app --mode hosted -y
+cd my-app && pnpm setup:hosted && pnpm dev
 
-# Minimal chat widget
-npx create-fluxy-chat my-chat --minimal
+# Your Worker
+npx @fluxy-chat/create-fluxy-chat@latest my-app --mode self-host
+cd my-app && pnpm setup:local && pnpm dev
 
-# React + useChat only (bring your own worker URL)
-npx create-fluxy-chat my-chat --template react
+# Minimal widget
+npx @fluxy-chat/create-fluxy-chat@latest my-chat --minimal
 ```
 
-## Non-interactive usage
-
-```bash
-# Full stack (chat + agent + setup)
-npx create-fluxy-chat my-app --full -y
-
-# React + Vite + useChat
-npx create-fluxy-chat my-chat --template react -y
+Always use `@fluxy-chat/create-fluxy-chat`. Bare `npx create-fluxy-chat` is not this package.
 
-# Create a Slack bot with pnpm
-npx create-fluxy-chat my-bot --adapter slack --pm pnpm
+Self-host writes `.fluxy/worker.dev.vars` (Worker URL, Groq key, signing key). Merge that into `apps/worker/.dev.vars` after `pnpm run self-host` in the FluxyChat repo.
 
-# Create a Telegram bot, skip install
-npx create-fluxy-chat my-bot --adapter telegram --skip-install
-
-# Create a Discord bot with defaults
-npx create-fluxy-chat my-bot -y --adapter discord
+## Non-interactive usage
 
-# Create a basic webhook bot (includes fluxy.config.ts template)
-npx create-fluxy-chat my-bot --adapter basic
+```bash
+npx @fluxy-chat/create-fluxy-chat@latest my-app --mode hosted -y
+npx @fluxy-chat/create-fluxy-chat@latest my-app --full -y
+npx @fluxy-chat/create-fluxy-chat@latest my-chat --template react -y
+npx @fluxy-chat/create-fluxy-chat@latest my-bot --adapter slack --pm pnpm
 ```
 
 ## Options

package/templates/full/README.md

@@ -16,23 +16,29 @@ pnpm dev
 
 Localhost opens a 3-step tour. Last step is sign in. After Clerk you come back to a simple chat. Open a second tab to try realtime. Use Open dashboard for rooms and agents.
 
-**Local worker:**
+**Self-host (your Worker):**
 
 ```bash
+# In the FluxyChat repo
+pnpm run self-host
 pnpm --filter @fluxy-chat/worker dev
-npx @fluxy-chat/create-fluxy-chat@latest my-app --full -y
+
+# In another terminal
+npx @fluxy-chat/create-fluxy-chat@latest my-app --mode self-host
 cd my-app
 pnpm install
-pnpm setup
+pnpm setup:local
 pnpm dev
 ```
 
+If the Worker is down, `setup:local` asks for the URL. Merge `.fluxy/worker.dev.vars` into `apps/worker/.dev.vars` (Groq key + `ALLOW_DEV_PROVISION=true`).
+
 ## Scripts
 
 | Command | Description |
 |---------|-------------|
 | `pnpm setup:hosted` | Writes worker + console URLs. Auth happens in the browser via Clerk. |
-| `pnpm setup:local` | Local `/dev/provision` |
+| `pnpm setup:local` / `pnpm setup:self-host` | `POST /dev/provision` on your Worker |
 | `pnpm doctor` | Health check |
 | `pnpm dev` | Start Vite |
 

package/templates/full/package.json

@@ -7,6 +7,7 @@
     "setup": "node scripts/fluxy-setup.mjs",
     "setup:hosted": "node scripts/fluxy-setup.mjs --mode hosted",
     "setup:local": "node scripts/fluxy-setup.mjs --mode local",
+    "setup:self-host": "node scripts/fluxy-setup.mjs --mode self-host",
     "doctor": "node scripts/fluxy-doctor.mjs",
     "dev": "node scripts/fluxy-dev.mjs",
     "dev:app": "vite",

package/templates/full/scripts/fluxy-setup.mjs

@@ -3,22 +3,25 @@
  * Provision credentials and write .env for the full template.
  *
  * Modes:
- *   local  (default) — POST /dev/provision on local worker (ALLOW_DEV_PROVISION=true)
- *   hosted           — GET /demo/session on fluxychat.com (no wrangler required)
+ *   local / self-host — POST /dev/provision on your worker (ALLOW_DEV_PROVISION=true)
+ *   hosted            — Clerk on fluxychat.com (no wrangler)
  *
  * Usage:
  *   pnpm setup
  *   pnpm setup -- --mode hosted
+ *   pnpm setup -- --mode self-host
  *   FLUXY_SETUP_MODE=hosted pnpm setup
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const envPath = join(root, ".env");
 const metaPath = join(root, ".fluxy", "setup.json");
 const modePath = join(root, ".fluxy", "mode");
+const answersPath = join(root, ".fluxy", "answers.json");
 
 const HOSTED_WORKER_DEFAULT = "https://api.fluxychat.com";
 const HOSTED_CONSOLE_DEFAULT = "https://fluxychat.com";
@@ -41,11 +44,40 @@ function fail(msg) {
   process.exit(1);
 }
 
+function parseSetupMode(raw) {
+  const m = String(raw || "").trim().toLowerCase();
+  if (m === "hosted") return "hosted";
+  if (m === "local" || m === "self-host") return "local";
+  return null;
+}
+
+function readAnswers() {
+  if (!existsSync(answersPath)) return {};
+  try {
+    return JSON.parse(readFileSync(answersPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function promptLine(question, fallback) {
+  if (!process.stdin.isTTY) return Promise.resolve(fallback);
+  return new Promise((resolveAnswer) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`${question} [${fallback}]: `, (answer) => {
+      rl.close();
+      resolveAnswer(String(answer || "").trim() || fallback);
+    });
+  });
+}
+
 function readDefaultMode() {
   if (existsSync(modePath)) {
-    const m = readFileSync(modePath, "utf8").trim().toLowerCase();
-    if (m === "hosted" || m === "local") return m;
+    const parsed = parseSetupMode(readFileSync(modePath, "utf8"));
+    if (parsed) return parsed;
   }
+  const fromAnswers = parseSetupMode(readAnswers().mode);
+  if (fromAnswers) return fromAnswers;
   return "local";
 }
 
@@ -53,12 +85,12 @@ function resolveMode() {
   const argv = process.argv.slice(2);
   const flagIdx = argv.indexOf("--mode");
   if (flagIdx >= 0 && argv[flagIdx + 1]) {
-    const m = String(argv[flagIdx + 1]).trim().toLowerCase();
-    if (m === "hosted" || m === "local") return m;
-    fail(`Unknown mode "${argv[flagIdx + 1]}". Use: local | hosted`);
+    const parsed = parseSetupMode(argv[flagIdx + 1]);
+    if (parsed) return parsed;
+    fail(`Unknown mode "${argv[flagIdx + 1]}". Use: local | self-host | hosted`);
   }
-  const fromEnv = String(process.env.FLUXY_SETUP_MODE || "").trim().toLowerCase();
-  if (fromEnv === "hosted" || fromEnv === "local") return fromEnv;
+  const fromEnv = parseSetupMode(process.env.FLUXY_SETUP_MODE);
+  if (fromEnv) return fromEnv;
   return readDefaultMode();
 }
 
@@ -218,20 +250,43 @@ async function setupHosted() {
 }
 
 async function setupLocal() {
-  const workerUrl =
-    process.env.FLUXY_WORKER_URL || process.env.FLUXYCHAT_WORKER_URL || LOCAL_WORKER_DEFAULT;
-  const consoleUrl = process.env.FLUXY_CONSOLE_URL || LOCAL_CONSOLE_DEFAULT;
+  const answers = readAnswers();
+  let workerUrl =
+    process.env.FLUXY_WORKER_URL ||
+    process.env.FLUXYCHAT_WORKER_URL ||
+    answers.workerUrl ||
+    LOCAL_WORKER_DEFAULT;
+  const consoleUrl =
+    process.env.FLUXY_CONSOLE_URL || answers.consoleUrl || LOCAL_CONSOLE_DEFAULT;
 
   console.log(dim(`  mode: local · worker: ${workerUrl}`));
 
   if (!(await isWorkerUp(workerUrl))) {
-    fail(
-      `Worker not reachable at ${workerUrl}\n` +
-        "  Start it from the FluxyChat monorepo:\n" +
-        "    pnpm --filter @fluxy-chat/worker dev\n" +
-        "  Or use hosted mode:\n" +
-        "    pnpm setup -- --mode hosted",
+    console.log(
+      dim(
+        `\n  Worker not reachable at ${workerUrl}.\n` +
+          "  Clone FluxyChat, then:\n" +
+          "    pnpm install && pnpm run self-host\n" +
+          "    pnpm --filter @fluxy-chat/worker dev\n" +
+          "  Merge this project's .fluxy/worker.dev.vars into apps/worker/.dev.vars\n",
+      ),
     );
+    if (process.stdin.isTTY) {
+      for (let i = 0; i < 3; i += 1) {
+        workerUrl = await promptLine("Worker URL", workerUrl);
+        if (await isWorkerUp(workerUrl)) break;
+        console.log(dim(`  Still down at ${workerUrl}`));
+      }
+    }
+    if (!(await isWorkerUp(workerUrl))) {
+      fail(
+        `Worker not reachable at ${workerUrl}\n` +
+          "  Start it from the FluxyChat monorepo:\n" +
+          "    pnpm run self-host && pnpm --filter @fluxy-chat/worker dev\n" +
+          "  Or use hosted mode:\n" +
+          "    pnpm setup -- --mode hosted",
+      );
+    }
   }
   ok(`worker healthy at ${workerUrl}`);
 

package/templates/react/src/App.tsx

@@ -8,7 +8,9 @@ const publicRoomId = import.meta.env.VITE_FLUXYCHAT_PUBLIC_ROOM_ID?.trim();
 const configuredRoomId = import.meta.env.VITE_FLUXYCHAT_ROOM_ID?.trim() || "demo";
 
 interface FluxySession {
-  client: FluxyChatClient;
+  workerUrl: string;
+  token: string;
+  userId: string;
   roomId: string;
   mode: "member" | "guest";
 }
@@ -30,11 +32,9 @@ function useFluxySession(): {
 
     if (memberJwt) {
       setSession({
-        client: new FluxyChatClient({
-          baseUrl: workerUrl,
-          userId: "demo-user",
-          token: memberJwt,
-        }),
+        workerUrl,
+        token: memberJwt,
+        userId: "demo-user",
         roomId: configuredRoomId,
         mode: "member",
       });
@@ -50,11 +50,9 @@ function useFluxySession(): {
         .then((guest) => {
           if (cancelled) return;
           setSession({
-            client: new FluxyChatClient({
-              baseUrl: workerUrl,
-              userId: guest.userId,
-              token: guest.token,
-            }),
+            workerUrl,
+            token: guest.token,
+            userId: guest.userId,
             roomId: guest.roomId,
             mode: "guest",
           });
@@ -180,7 +178,11 @@ export function App() {
           <input value={roomId} onChange={(e) => setRoomId(e.target.value)} />
         </label>
       ) : null}
-      <FluxyRealtimeProvider client={session.client}>
+      <FluxyRealtimeProvider
+        workerUrl={session.workerUrl}
+        authTokenProvider={session.token}
+        userId={session.userId}
+      >
         <ChatPanel roomId={activeRoomId} />
       </FluxyRealtimeProvider>
     </main>