@fluxy-chat/create-fluxy-chat 0.1.0

package/package.json

@@ -0,0 +1,45 @@
+{
+    "name":  "@fluxy-chat/create-fluxy-chat",
+    "version":  "0.1.0",
+    "type":  "module",
+    "main":  "./dist/index.js",
+    "bin":  {
+                "create-fluxy-chat":  "./dist/index.js"
+            },
+    "engines":  {
+                    "node":  "\u003e=20.12"
+                },
+    "files":  [
+                  "dist",
+                  "templates",
+                  "README.md"
+              ],
+    "scripts":  {
+                    "build":  "tsup src/index.ts --format esm --dts",
+                    "dev":  "tsup src/index.ts --format esm --watch",
+                    "typecheck":  "tsc --noEmit",
+                    "prepublishOnly":  "pnpm run build"
+                },
+    "dependencies":  {
+                         "@clack/prompts":  "^0.7.0",
+                         "picocolors":  "^1.1.1"
+                     },
+    "devDependencies":  {
+                            "@types/node":  "^22.0.0",
+                            "tsup":  "^8.3.5",
+                            "typescript":  "^5.6.0"
+                        },
+    "repository":  {
+                       "type":  "git",
+                       "url":  "git+https://github.com/AlessandroFare/fluxychat.git",
+                       "directory":  "packages/create-fluxy-chat"
+                   },
+    "homepage":  "https://github.com/AlessandroFare/fluxychat/tree/main/packages/create-fluxy-chat#readme",
+    "bugs":  {
+                 "url":  "https://github.com/AlessandroFare/fluxychat/issues"
+             },
+    "publishConfig":  {
+                          "access":  "public"
+                      },
+    "license":  "MIT"
+}

package/readme.md

@@ -0,0 +1,89 @@
+# create-fluxy-chat
+
+Scaffold a new [FluxyChat](https://github.com/AlessandroFare/fluxychat) bot project with a single command.
+
+## Quick Start
+
+```bash
+npx create-fluxy-chat my-bot
+```
+
+This launches an interactive prompt to configure your bot project.
+
+## Non-Interactive Usage
+
+```bash
+# Create a Slack bot with pnpm
+npx create-fluxy-chat my-bot --adapter slack --pm pnpm
+
+# 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
+
+# Create a basic webhook bot
+npx create-fluxy-chat my-bot --adapter basic
+```
+
+## Options
+
+| Flag | Short | Description |
+| --- | --- | --- |
+| `--adapter <type>` | `-a` | Adapter: `basic`, `slack`, `telegram`, `discord`, `web` |
+| `--pm <manager>` | | Package manager: `npm`, `pnpm`, `yarn` |
+| `--language <lang>` | `-l` | Language: `typescript` (default) or `javascript` |
+| `--yes` | `-y` | Skip prompts and accept defaults |
+| `--skip-install` | | Skip dependency installation |
+| `--no-git` | | Skip git repository initialization |
+| `--help` | `-h` | Show help |
+
+## Adapters
+
+| Adapter | Description | Platform |
+| --- | --- | --- |
+| `basic` | Generic webhook bot | Cloudflare Workers |
+| `slack` | Slack Events API bot | Slack |
+| `telegram` | Telegram webhook bot | Telegram |
+| `discord` | Discord interactions bot | Discord |
+| `web` | Web chat HTTP API bot | Any HTTP client |
+
+## What You Get
+
+Each generated project includes:
+
+- **`src/index.ts`** — Cloudflare Workers entry point with route handling
+- **`src/bot.ts`** — Bot handler using `@fluxy-chat/sdk`
+- **`wrangler.toml`** — Cloudflare Workers deployment config
+- **`.dev.vars`** — Local development environment variables
+- **`.env.example`** — Example environment variables for your adapter
+- **`tsconfig.json`** — TypeScript configuration (for TS projects)
+- **`README.md`** — Project-specific setup instructions
+- **`.gitignore`** — Standard ignore patterns
+
+## Package Manager Detection
+
+The CLI auto-detects your package manager from lockfiles:
+
+- `pnpm-lock.yaml` → pnpm
+- `yarn.lock` → yarn
+- `package-lock.json` or none → npm
+
+You can override with `--pm`.
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build the CLI
+pnpm build
+
+# Run locally
+node dist/index.js my-test-bot -y --adapter basic
+```
+
+## License
+
+MIT

package/templates/basic/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "fluxy-bot-basic",
+  "version": "0.1.0",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "dev": "wrangler dev",
+    "deploy": "wrangler deploy",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@fluxy-chat/sdk": "latest"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.0.0",
+    "typescript": "^5.6.0",
+    "wrangler": "^3.0.0"
+  }
+}

package/templates/basic/readme.md

@@ -0,0 +1,36 @@
+# fluxy-bot-basic
+
+A basic webhook bot built with [FluxyChat](https://github.com/AlessandroFare/fluxychat) and deployed on Cloudflare Workers.
+
+## Getting Started
+
+1. Copy the example environment file:
+
+```bash
+cp .env.example .dev.vars
+```
+
+2. Start the dev server:
+
+```bash
+pnpm dev
+```
+
+3. Deploy to Cloudflare Workers:
+
+```bash
+pnpm deploy
+```
+
+## Endpoints
+
+- Health check: `/`
+- Webhook: `/webhook`
+
+## Environment Variables
+
+See `.env.example` for all required environment variables.
+
+## License
+
+MIT

package/templates/basic/src/bot.ts

@@ -0,0 +1,40 @@
+import { FluxyChatClient } from "@fluxy-chat/sdk";
+
+interface BotEnv {
+  FLUXY_BASE_URL: string;
+  FLUXY_API_KEY: string;
+}
+
+export async function handleWebhook(
+  request: Request,
+  env: BotEnv,
+): Promise<Response> {
+  const body = await request.json() as {
+    roomId?: string;
+    message?: string;
+    userId?: string;
+  };
+
+  const client = new FluxyChatClient({
+    baseUrl: env.FLUXY_BASE_URL,
+    userId: body.userId ?? "bot",
+    apiKey: env.FLUXY_API_KEY,
+  });
+
+  try {
+    if (body.roomId && body.message) {
+      await client.createMessage(body.roomId, body.message);
+    }
+
+    return new Response(
+      JSON.stringify({ ok: true }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  } catch (error) {
+    console.error("Webhook error:", error);
+    return new Response(
+      JSON.stringify({ error: "Internal server error" }),
+      { status: 500, headers: { "Content-Type": "application/json" } },
+    );
+  }
+}

package/templates/basic/src/index.ts

@@ -0,0 +1,17 @@
+import { handleWebhook } from "./bot.js";
+
+export default {
+  async fetch(request: Request, env: Record<string, string>): Promise<Response> {
+    const url = new URL(request.url);
+
+    if (url.pathname === "/webhook" && request.method === "POST") {
+      return handleWebhook(request, env);
+    }
+
+    if (url.pathname === "/") {
+      return new Response("FluxyChat bot is running!", { status: 200 });
+    }
+
+    return new Response("Not Found", { status: 404 });
+  },
+};

package/templates/basic/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "types": ["@cloudflare/workers-types"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/templates/basic/wrangler.toml

@@ -0,0 +1,9 @@
+name = "fluxy-bot-basic"
+main = "src/index.ts"
+compatibility_date = "2024-12-01"
+
+[vars]
+FLUXY_BASE_URL = "https://your-fluxychat-worker.example.com"
+
+# Set these via `wrangler secret put` for production
+# wrangler secret put FLUXY_API_KEY

package/templates/discord/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "fluxy-bot-discord",
+  "version": "0.1.0",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "dev": "wrangler dev",
+    "deploy": "wrangler deploy",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@fluxy-chat/sdk": "latest",
+    "discord.js": "^14.0.0"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.0.0",
+    "typescript": "^5.6.0",
+    "wrangler": "^3.0.0"
+  }
+}

package/templates/discord/readme.md

@@ -0,0 +1,37 @@
+# fluxy-bot-discord
+
+A Discord bot built with [FluxyChat](https://github.com/AlessandroFare/fluxychat) and deployed on Cloudflare Workers.
+
+## Getting Started
+
+1. Copy the example environment file:
+
+```bash
+cp .env.example .dev.vars
+```
+
+2. Create a Discord application at https://discord.com/developers/applications and get your bot token, application ID, and public key.
+
+3. Start the dev server:
+
+```bash
+pnpm dev
+```
+
+4. Set the Discord Interactions Endpoint URL to point to your worker's `/discord/interactions` endpoint.
+
+## Endpoints
+
+- Discord Interactions: `/discord/interactions`
+
+## Environment Variables
+
+- `FLUXY_BASE_URL` — Your FluxyChat worker URL
+- `FLUXY_API_KEY` — FluxyChat API key
+- `DISCORD_BOT_TOKEN` — Discord bot token
+- `DISCORD_APPLICATION_ID` — Discord application ID
+- `DISCORD_PUBLIC_KEY` — Discord public key (for signature verification)
+
+## License
+
+MIT

package/templates/discord/src/bot.ts

@@ -0,0 +1,59 @@
+import { FluxyChatClient } from "@fluxy-chat/sdk";
+
+interface BotEnv {
+  FLUXY_BASE_URL: string;
+  FLUXY_API_KEY: string;
+  DISCORD_BOT_TOKEN: string;
+  DISCORD_PUBLIC_KEY: string;
+}
+
+export async function handleDiscordInteraction(
+  request: Request,
+  env: BotEnv,
+): Promise<Response> {
+  const body = await request.text();
+
+  const client = new FluxyChatClient({
+    baseUrl: env.FLUXY_BASE_URL,
+    userId: "discord-bot",
+    apiKey: env.FLUXY_API_KEY,
+  });
+
+  try {
+    const interaction = JSON.parse(body);
+
+    // Handle Discord ping (verification)
+    if (interaction.type === 1) {
+      return new Response(JSON.stringify({ type: 1 }), {
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    // Handle application command
+    if (interaction.type === 2) {
+      const commandName = interaction.data?.name;
+
+      if (commandName === "chat") {
+        const userId = interaction.member?.user?.id ?? interaction.user?.id ?? "unknown";
+        const text = interaction.data?.options?.[0]?.value ?? "";
+
+        // Forward to FluxyChat
+        const roomId = `discord-${interaction.channel_id}`;
+        await client.createMessage(roomId, String(text));
+
+        return new Response(
+          JSON.stringify({
+            type: 4,
+            data: { content: "Message forwarded to FluxyChat!" },
+          }),
+          { headers: { "Content-Type": "application/json" } },
+        );
+      }
+    }
+
+    return new Response("Unknown interaction type", { status: 400 });
+  } catch (error) {
+    console.error("Discord interaction error:", error);
+    return new Response("Internal Server Error", { status: 500 });
+  }
+}

package/templates/discord/src/index.ts

@@ -0,0 +1,17 @@
+import { handleDiscordInteraction } from "./bot.js";
+
+export default {
+  async fetch(request: Request, env: Record<string, string>): Promise<Response> {
+    const url = new URL(request.url);
+
+    if (url.pathname === "/discord/interactions" && request.method === "POST") {
+      return handleDiscordInteraction(request, env);
+    }
+
+    if (url.pathname === "/") {
+      return new Response("FluxyChat Discord bot is running!", { status: 200 });
+    }
+
+    return new Response("Not Found", { status: 404 });
+  },
+};

package/templates/slack/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "fluxy-bot-slack",
+  "version": "0.1.0",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "dev": "wrangler dev",
+    "deploy": "wrangler deploy",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@fluxy-chat/sdk": "latest",
+    "@slack/bolt": "^4.0.0",
+    "@slack/web-api": "^7.0.0"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.0.0",
+    "typescript": "^5.6.0",
+    "wrangler": "^3.0.0"
+  }
+}

package/templates/slack/readme.md

@@ -0,0 +1,37 @@
+# fluxy-bot-slack
+
+A Slack bot built with [FluxyChat](https://github.com/AlessandroFare/fluxychat) and deployed on Cloudflare Workers.
+
+## Getting Started
+
+1. Copy the example environment file:
+
+```bash
+cp .env.example .dev.vars
+```
+
+2. Create a Slack app at https://api.slack.com/apps and get your bot token and signing secret.
+
+3. Start the dev server:
+
+```bash
+pnpm dev
+```
+
+4. Set up the Slack Event Subscriptions URL to point to your worker's `/slack/events` endpoint.
+
+## Endpoints
+
+- Slack Events API: `/slack/events`
+- Slack Interactive: `/slack/interactive`
+
+## Environment Variables
+
+- `FLUXY_BASE_URL` — Your FluxyChat worker URL
+- `FLUXY_API_KEY` — FluxyChat API key
+- `SLACK_BOT_TOKEN` — Slack bot token (xoxb-...)
+- `SLACK_SIGNING_SECRET` — Slack signing secret
+
+## License
+
+MIT

package/templates/slack/src/bot.ts

@@ -0,0 +1,58 @@
+import { FluxyChatClient } from "@fluxy-chat/sdk";
+
+interface BotEnv {
+  FLUXY_BASE_URL: string;
+  FLUXY_API_KEY: string;
+  SLACK_BOT_TOKEN: string;
+  SLACK_SIGNING_SECRET: string;
+}
+
+export interface SlackBot {
+  fluxyClient: FluxyChatClient;
+}
+
+export function createSlackBot(): SlackBot {
+  return {
+    fluxyClient: null as unknown as FluxyChatClient,
+  };
+}
+
+export async function handleSlackRequest(
+  request: Request,
+  env: BotEnv,
+  bot: SlackBot,
+): Promise<Response> {
+  const body = await request.text();
+
+  const client = new FluxyChatClient({
+    baseUrl: env.FLUXY_BASE_URL,
+    userId: "slack-bot",
+    apiKey: env.FLUXY_API_KEY,
+  });
+
+  try {
+    const payload = JSON.parse(body);
+
+    // Handle Slack URL verification challenge
+    if (payload.type === "url_verification") {
+      return new Response(JSON.stringify({ challenge: payload.challenge }), {
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    // Handle events
+    if (payload.event) {
+      const event = payload.event;
+
+      if (event.type === "message" && !event.bot_id) {
+        const roomId = `slack-${event.channel}`;
+        await client.createMessage(roomId, event.text || "");
+      }
+    }
+
+    return new Response("OK", { status: 200 });
+  } catch (error) {
+    console.error("Slack event error:", error);
+    return new Response("Internal Server Error", { status: 500 });
+  }
+}

package/templates/slack/src/index.ts

@@ -0,0 +1,19 @@
+import { handleSlackRequest, createSlackBot } from "./bot.js";
+
+const bot = createSlackBot();
+
+export default {
+  async fetch(request: Request, env: Record<string, string>): Promise<Response> {
+    const url = new URL(request.url);
+
+    if (url.pathname === "/slack/events" || url.pathname === "/slack/interactive") {
+      return handleSlackRequest(request, env, bot);
+    }
+
+    if (url.pathname === "/") {
+      return new Response("FluxyChat Slack bot is running!", { status: 200 });
+    }
+
+    return new Response("Not Found", { status: 404 });
+  },
+};

package/templates/telegram/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "fluxy-bot-telegram",
+  "version": "0.1.0",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "dev": "wrangler dev",
+    "deploy": "wrangler deploy",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@fluxy-chat/sdk": "latest",
+    "node-telegram-bot-api": "^0.66.0"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.0.0",
+    "typescript": "^5.6.0",
+    "wrangler": "^3.0.0"
+  }
+}

package/templates/telegram/readme.md

@@ -0,0 +1,39 @@
+# fluxy-bot-telegram
+
+A Telegram bot built with [FluxyChat](https://github.com/AlessandroFare/fluxychat) and deployed on Cloudflare Workers.
+
+## Getting Started
+
+1. Copy the example environment file:
+
+```bash
+cp .env.example .dev.vars
+```
+
+2. Create a Telegram bot via [@BotFather](https://t.me/BotFather) and get your bot token.
+
+3. Start the dev server:
+
+```bash
+pnpm dev
+```
+
+4. Set the Telegram webhook to point to your worker's `/telegram/webhook` endpoint:
+
+```bash
+curl "https://api.telegram.org/bot<YOUR_BOT_TOKEN>/setWebhook?url=https://your-worker.example.com/telegram/webhook"
+```
+
+## Endpoints
+
+- Telegram Webhook: `/telegram/webhook`
+
+## Environment Variables
+
+- `FLUXY_BASE_URL` — Your FluxyChat worker URL
+- `FLUXY_API_KEY` — FluxyChat API key
+- `TELEGRAM_BOT_TOKEN` — Telegram bot token from BotFather
+
+## License
+
+MIT

package/templates/telegram/src/bot.ts

@@ -0,0 +1,47 @@
+import { FluxyChatClient } from "@fluxy-chat/sdk";
+
+interface BotEnv {
+  FLUXY_BASE_URL: string;
+  FLUXY_API_KEY: string;
+  TELEGRAM_BOT_TOKEN: string;
+}
+
+export async function handleTelegramUpdate(
+  update: Record<string, unknown>,
+  env: BotEnv,
+): Promise<Response> {
+  const client = new FluxyChatClient({
+    baseUrl: env.FLUXY_BASE_URL,
+    userId: "telegram-bot",
+    apiKey: env.FLUXY_API_KEY,
+  });
+
+  try {
+    const message = update.message as
+      | { chat?: { id?: number }; text?: string; from?: { first_name?: string } }
+      | undefined;
+
+    if (message?.chat?.id && message.text) {
+      const roomId = `telegram-${message.chat.id}`;
+
+      // Forward to FluxyChat
+      await client.createMessage(roomId, message.text);
+
+      // Send reply back to Telegram
+      const telegramApiUrl = `https://api.telegram.org/bot${env.TELEGRAM_BOT_TOKEN}/sendMessage`;
+      await fetch(telegramApiUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          chat_id: message.chat.id,
+          text: `Hi ${message.from?.first_name ?? "there"}! Message received.`,
+        }),
+      });
+    }
+
+    return new Response("OK", { status: 200 });
+  } catch (error) {
+    console.error("Telegram update error:", error);
+    return new Response("Internal Server Error", { status: 500 });
+  }
+}

package/templates/telegram/src/index.ts

@@ -0,0 +1,18 @@
+import { handleTelegramUpdate } from "./bot.js";
+
+export default {
+  async fetch(request: Request, env: Record<string, string>): Promise<Response> {
+    const url = new URL(request.url);
+
+    if (url.pathname === "/telegram/webhook" && request.method === "POST") {
+      const update = await request.json();
+      return handleTelegramUpdate(update, env);
+    }
+
+    if (url.pathname === "/") {
+      return new Response("FluxyChat Telegram bot is running!", { status: 200 });
+    }
+
+    return new Response("Not Found", { status: 404 });
+  },
+};