create-discord-https 1.0.0

package/README.md

@@ -0,0 +1,15 @@
+# Initialize discord.https Project
+
+## Install:
+
+```bash
+npm create discord-https@latest
+```
+
+Then follow the prompts to initialize your Discord.https project.
+
+## Currently Supported Server Environments
+
+- NodeJS(persistent)
+- Vercel Serverless
+- Cloudflare Worker

package/index.js

@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import mri from "mri";
+import * as prompts from "@clack/prompts";
+import colors from "picocolors";
+const { blueBright, greenBright, magenta, reset, yellow, white, yellowBright, cyanBright, } = colors;
+const argv = mri(process.argv.slice(2), {
+    alias: { h: "help", t: "template" },
+    boolean: ["help", "overwrite"],
+    string: ["template"],
+});
+const cwd = process.cwd();
+// prettier-ignore
+const helpMessage = `\
+Usage: create-discord-https [OPTION]... [DIRECTORY]
+
+Create a new discord.https project in JavaScript or TypeScript.
+With no arguments, start the CLI in interactive mode.
+
+Options:
+  -t, --template NAME        use a specific template
+
+Available templates:
+${greenBright('node-js')}
+${white('vercel-js')}
+${yellowBright('cloudflare-js')}
+${blueBright('node-ts')}
+${magenta('vercel-ts')}
+${cyanBright('cloudflare-ts')}`;
+const SERVERTYPE = [
+    {
+        name: "node",
+        display: "⬡ Nodejs (persistent)",
+        color: greenBright,
+        flavour: [
+            {
+                name: "node",
+                display: "JavaScript",
+                color: yellow,
+                secret: {
+                    token: [10 - 1, 11 - 1],
+                    publicKey: [11 - 1, 15 - 1],
+                },
+            },
+            {
+                name: "node-ts",
+                display: "TypeScript (recommend)",
+                color: blueBright,
+                secret: {
+                    token: [10 - 1, 11 - 1],
+                    publicKey: [11 - 1, 15 - 1],
+                },
+            },
+        ],
+    },
+    {
+        name: "vercel",
+        display: "▲ Vercel serverless",
+        color: white,
+        flavour: [
+            {
+                name: "vercel",
+                display: "JavaScript",
+                color: yellow,
+                secret: {
+                    token: [10 - 1, 11 - 1],
+                    publicKey: [11 - 1, 15 - 1],
+                },
+            },
+            {
+                name: "vercel-ts",
+                display: "TypeScript (recommend)",
+                color: blueBright,
+                secret: {
+                    token: [10 - 1, 11 - 1],
+                    publicKey: [11 - 1, 15 - 1],
+                },
+            },
+        ],
+    },
+    {
+        name: "cloudflare",
+        // https://www.compart.com/en/unicode/U+2601
+        display: "☁ Cloudflare worker",
+        color: yellowBright,
+        flavour: [
+            {
+                name: "cloudflare",
+                display: "JavaScript",
+                color: yellow,
+                secret: {
+                    token: [12 - 1, 15 - 1],
+                    publicKey: [13 - 1, 19 - 1],
+                },
+            },
+            {
+                name: "cloudflare-ts",
+                display: "TypeScript (recommend)",
+                color: blueBright,
+                secret: {
+                    token: [12 - 1, 15 - 1],
+                    publicKey: [13 - 1, 19 - 1],
+                },
+            },
+        ],
+    },
+];
+const TEMPLATES = SERVERTYPE.map((f) => f.flavour.map((v) => v.name)).reduce((a, b) => a.concat(b), []);
+const renameFiles = {
+    _gitignore: ".gitignore",
+};
+const defaultTargetDir = "mybot";
+async function init() {
+    const argTargetDir = argv._[0]
+        ? formatTargetDir(String(argv._[0]))
+        : undefined;
+    const argTemplate = argv.template;
+    const argOverwrite = argv.overwrite;
+    const help = argv.help;
+    if (help) {
+        console.log(helpMessage);
+        return;
+    }
+    const pkgInfo = pkgFromUserAgent(process.env.npm_config_user_agent);
+    const cancel = () => prompts.cancel("Operation cancelled");
+    // 1. Get project name and target dir
+    let targetDir = argTargetDir;
+    if (!targetDir) {
+        const projectName = await prompts.text({
+            message: "Project name:",
+            defaultValue: defaultTargetDir,
+            placeholder: defaultTargetDir,
+            validate: (value) => {
+                return value.length === 0 || formatTargetDir(value).length > 0
+                    ? undefined
+                    : "Invalid project name";
+            },
+        });
+        if (prompts.isCancel(projectName))
+            return cancel();
+        targetDir = formatTargetDir(projectName);
+    }
+    // 2. Handle directory if exist and not empty
+    if (fs.existsSync(targetDir) && !isEmpty(targetDir)) {
+        const overwrite = argOverwrite
+            ? "yes"
+            : await prompts.select({
+                message: (targetDir === "."
+                    ? "Current directory"
+                    : `Target directory "${targetDir}"`) +
+                    ` is not empty. choose how to proceed:`,
+                options: [
+                    {
+                        label: "Cancel operation",
+                        value: "no",
+                    },
+                    {
+                        label: "Remove existing files and continue",
+                        value: "yes",
+                    },
+                    {
+                        label: "Ignore files and continue",
+                        value: "ignore",
+                    },
+                ],
+            });
+        if (prompts.isCancel(overwrite))
+            return cancel();
+        switch (overwrite) {
+            case "yes":
+                emptyDir(targetDir);
+                break;
+            case "no":
+                cancel();
+                return;
+        }
+    }
+    // 3. Get package name
+    let packageName = path.basename(path.resolve(targetDir));
+    if (!isValidPackageName(packageName)) {
+        const packageNameResult = await prompts.text({
+            message: "Package name:",
+            defaultValue: toValidPackageName(packageName),
+            placeholder: toValidPackageName(packageName),
+            validate(dir) {
+                if (!isValidPackageName(dir)) {
+                    return "Invalid package.json name";
+                }
+            },
+        });
+        if (prompts.isCancel(packageNameResult))
+            return cancel();
+        packageName = packageNameResult;
+    }
+    // 4. Choose a framework and flavour
+    let template = argTemplate;
+    let hasInvalidArgTemplate = false;
+    if (argTemplate && !TEMPLATES.includes(argTemplate)) {
+        template = undefined;
+        hasInvalidArgTemplate = true;
+    }
+    if (!template) {
+        const framework = await prompts.select({
+            message: hasInvalidArgTemplate
+                ? `"${argTemplate}" isn't a valid template. choose from below: `
+                : "Select a environment:",
+            options: SERVERTYPE.map((framework) => {
+                const frameworkColor = framework.color;
+                return {
+                    label: frameworkColor(framework.display || framework.name),
+                    value: framework,
+                };
+            }),
+        });
+        if (prompts.isCancel(framework))
+            return cancel();
+        const flavour = await prompts.select({
+            message: "Select a flavour:",
+            options: framework.flavour.map((flavour) => {
+                const flavourColor = flavour.color;
+                return {
+                    label: flavourColor(flavour.display || flavour.name),
+                    value: flavour.name,
+                };
+            }),
+        });
+        if (prompts.isCancel(flavour))
+            return cancel();
+        template = flavour;
+    }
+    const root = path.join(cwd, targetDir);
+    fs.mkdirSync(root, { recursive: true });
+    const pkgManager = pkgInfo ? pkgInfo.name : "npm";
+    const { secret } = SERVERTYPE.flatMap((f) => f.flavour).find((v) => v.name === template);
+    prompts.log.step(`Initializing project...`);
+    const templateDir = path.resolve(fileURLToPath(import.meta.url), "../..", `templates/${template}`);
+    const write = (file, content) => {
+        const targetPath = path.join(root, renameFiles[file] ?? file);
+        if (content) {
+            fs.writeFileSync(targetPath, content);
+        }
+        else {
+            copy(path.join(templateDir, file), targetPath);
+        }
+    };
+    const files = fs.readdirSync(templateDir);
+    for (const file of files.filter((f) => f !== "package.json")) {
+        write(file);
+    }
+    const pkg = JSON.parse(fs.readFileSync(path.join(templateDir, `package.json`), "utf-8"));
+    pkg.name = packageName;
+    write("package.json", JSON.stringify(pkg, null, 2) + "\n");
+    const ext = template.split("-")[1] ? "ts" : "js";
+    await setupSecret(root, `src/index.${ext}`, secret);
+    await setupSubdomain(root, `src/DevLayer.${ext}`);
+    let doneMessage = "";
+    const cdProjectName = path.relative(cwd, root);
+    doneMessage += `All done! Execute:\n`;
+    if (root !== cwd) {
+        doneMessage += `\n  cd ${cdProjectName.includes(" ") ? `"${cdProjectName}"` : cdProjectName}`;
+    }
+    switch (pkgManager) {
+        case "yarn":
+            doneMessage += "\n  yarn";
+            doneMessage += "\n  yarn dev";
+            break;
+        default:
+            doneMessage += `\n  ${pkgManager} install`;
+            doneMessage += `\n  ${pkgManager} run dev`;
+            break;
+    }
+    prompts.outro(doneMessage);
+}
+function formatTargetDir(targetDir) {
+    return targetDir.trim().replace(/\/+$/g, "");
+}
+function copy(src, dest) {
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+        copyDir(src, dest);
+    }
+    else {
+        fs.copyFileSync(src, dest);
+    }
+}
+function isValidPackageName(projectName) {
+    return /^(?:@[a-z\d\-*~][a-z\d\-*._~]*\/)?[a-z\d\-~][a-z\d\-._~]*$/.test(projectName);
+}
+function toValidPackageName(projectName) {
+    return projectName
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, "-")
+        .replace(/^[._]/, "")
+        .replace(/[^a-z\d\-~]+/g, "-");
+}
+function copyDir(srcDir, destDir) {
+    fs.mkdirSync(destDir, { recursive: true });
+    for (const file of fs.readdirSync(srcDir)) {
+        const srcFile = path.resolve(srcDir, file);
+        const destFile = path.resolve(destDir, file);
+        copy(srcFile, destFile);
+    }
+}
+function isEmpty(path) {
+    const files = fs.readdirSync(path);
+    return files.length === 0 || (files.length === 1 && files[0] === ".git");
+}
+function emptyDir(dir) {
+    if (!fs.existsSync(dir)) {
+        return;
+    }
+    for (const file of fs.readdirSync(dir)) {
+        if (file === ".git") {
+            continue;
+        }
+        fs.rmSync(path.resolve(dir, file), { recursive: true, force: true });
+    }
+}
+function pkgFromUserAgent(userAgent) {
+    if (!userAgent)
+        return undefined;
+    const pkgSpec = userAgent.split(" ")[0];
+    const pkgSpecArr = pkgSpec.split("/");
+    return {
+        name: pkgSpecArr[0],
+        version: pkgSpecArr[1],
+    };
+}
+async function setupSecret(root, entryPoint, secret) {
+    const botToken = await prompts.text({
+        message: "Enter your Discord Bot Token:",
+        validate: (value) => value.length === 0 ? "Token cannot be empty" : undefined,
+    });
+    if (prompts.isCancel(botToken))
+        return prompts.cancel("Operation cancelled");
+    const publicKey = await prompts.text({
+        message: "Enter your Discord Public Key:",
+        validate: (value) => value.length === 0 ? "Public Key cannot be empty" : undefined,
+    });
+    if (prompts.isCancel(publicKey))
+        return prompts.cancel("Operation cancelled");
+    const entryFile = path.join(root, entryPoint);
+    if (!fs.existsSync(entryFile)) {
+        prompts.cancel("Error while writing token: file not found.");
+        return; // stop execution
+    }
+    let fileContent = fs.readFileSync(entryFile, "utf-8").split("\n");
+    const tokenPlaceholder = "PUT_YOUR_TOKEN_HERE";
+    const publickeyPlaceholder = "PUT_YOUR_PUBLIC_KEY_HERE";
+    const tokenLine = fileContent[secret.token[0]];
+    fileContent[secret.token[0]] =
+        tokenLine.slice(0, secret.token[1]) +
+            botToken +
+            tokenLine.slice(secret.token[1] + tokenPlaceholder.length);
+    const publicKeyLine = fileContent[secret.publicKey[0]];
+    fileContent[secret.publicKey[0]] =
+        publicKeyLine.slice(0, secret.publicKey[1]) +
+            publicKey +
+            publicKeyLine.slice(secret.publicKey[1] + publickeyPlaceholder.length);
+    fs.writeFileSync(entryFile, fileContent.join("\n"));
+    prompts.log.success("Done, Secrets have been hardcoded however, it is recommended to switch to environment variables!");
+}
+async function setupSubdomain(root, DevLayerEntryPoint) {
+    const entryFile = path.join(root, DevLayerEntryPoint);
+    if (!fs.existsSync(entryFile)) {
+        prompts.cancel("Error while writing sub domain: file not found.");
+        return; // stop execution
+    }
+    let fileContent = fs.readFileSync(entryFile, "utf-8").split("\n");
+    const SubDomainPrefix = "discord-https";
+    // discord-https-timestamp-number
+    const subdomain = `${SubDomainPrefix}-${Date.now()}-${Math.floor(Math.random() * 9)}`;
+    const row = 48 - 1; //0th index
+    const column = 19 - 1; //0th index
+    const tokenLine = fileContent[row];
+    fileContent[row] =
+        tokenLine.slice(0, column) +
+            subdomain +
+            tokenLine.slice(column + SubDomainPrefix.length);
+    fs.writeFileSync(entryFile, fileContent.join("\n"));
+    prompts.log.info("Use `npm run dev` over directly invoking the command, as this will create a tunnel layer except for server environment `nodejs` with a flavor of `typescript`.");
+    prompts.log.info("For more information, see the README.md file.");
+}
+init().catch((e) => {
+    console.error(e);
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "create-discord-https",
+  "description": "Create Discord.https-powered bots with one command.",
+  "version": "1.0.0",
+  "bin": {
+    "create-discord-https": "index.js"
+  },
+  "author": "discord.https",
+  "type": "module",
+  "files": [
+    "index.js",
+    "templates"
+  ],
+  "scripts": {
+    "build": "tsc --build"
+  },
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/discordhttps/create-discord-https.git"
+  },
+  "bugs": {
+    "url": "https://github.com/discordhttps/create-discord-https/issues"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/discordhttps/create-discord-https#readme",
+  "devDependencies": {
+    "@clack/prompts": "^0.11.0",
+    "@types/node": "^24.3.1",
+    "mri": "^1.2.0",
+    "picocolors": "^1.1.1"
+  }
+}

package/templates/cloudflare/README.md

@@ -0,0 +1,32 @@
+## Discord.https
+
+Cloudflare Workers let you run serverless functions at the edge. Your Discord interactions endpoint must be deployed as a Worker script.
+
+By default, the URL is: <your_worker_subdomain>.workers.dev/interactions
+
+**Note:** You can ignore any warnings in src\DevLayer.js, as the code will not run in production as long as the environment is set to production, which npm run deploy does automatically.
+
+More details:
+
+- [cloudflare](https://cloudflare.com)
+- [cloudflare Workers](https://workers.cloudflare.com)
+
+### How to deploy
+
+Run this command to deploy to production:
+
+```bash
+npm run deploy
+```
+
+### Local development
+
+Run your project locally with:
+
+```bash
+npx wrangler dev
+```
+
+**A layer of local tunnel is embedded into the code for easier development**. This means requests pass through multiple layers: Discord → local tunnel → local Vercel server on your computer → your functions. The Induced latency is usually just a few milliseconds and depends on your internet connection. **This local tunneling layer only runs on your machine during development and can be removed if desired.**
+
+For more information, view `DevLayer.ts` or, `DevLayer.js`

package/templates/cloudflare/_gitignore

@@ -0,0 +1,3 @@
+node_modules
+.git
+.env

package/templates/cloudflare/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "vercel",
+  "version": "1.0.0",
+  "description": "Discord HTTPS interaction callback bot powered by discord.https",
+  "main": "index.js",
+  "scripts": {
+    "dev": "node src/spawner.js",
+    "deploy": "npx wrangler deploy --env production",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "type": "module",
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@discordhttps/cloudflare-adapter": "^1.0.2",
+    "@discordhttps/vercel-adapter": "^1.0.4",
+    "@vercel/functions": "^3.1.1",
+    "chalk": "^5.6.2",
+    "discord.https": "^3.0.15"
+  },
+  "devDependencies": {
+    "fast-deep-equal": "^3.1.3",
+    "localtunnel": "^2.0.2",
+    "wrangler": "^4.42.0"
+  }
+}

package/templates/cloudflare/src/DevLayer.js

@@ -0,0 +1,139 @@
+/*
+
+------------It is recommended not to modify this layer of code without proper knowledge------------
+
+
+For Info:
+
+Summary: This code is a development layer designed to ease development, with automation features such as auto local tunnel and automatic command registration.
+
+
+1. Automatic command registration
+
+This layer provides support for automatic command registration by storing the last run command definitions in a file.
+Later, these definitions are read and compared with the current command definitions.
+If they are the same, there is no need to re-register, as nothing has changed.
+If they are different, the command definitions have changed and require re-registration.
+
+
+2.Local Tunnel
+
+Local tunnels establish secure pathways between your localhost and the Internet, making it possible to expose web applications for access from anywhere.
+
+What LocalTunnel does:
+
+- Imagine you’re running a website on your computer at http://localhost:3000.
+- Normally, only you can see it because it’s “local” — it is only on your computer.
+- LocalTunnel gives it a public URL, like https://awesome-name.domain.com, so discord can send a request to your computer.
+
+
+Why this matters for Discord:
+
+- Normally, when you open Discord, your computer sends requests to Discord’s servers — everything works because Discord is public.
+- But if you want Discord to **send data to your computer** (like a webhook), your computer needs a public address.
+- LocalTunnel provides that public URL, so Discord knows where to send the requests.
+
+Why it’s useful:
+
+- Testing webhooks (like Discord)
+- Debugging APIs without deploying to a server
+*/
+
+export async function tunnelLayer() {
+  if (process.env.NODE_ENV !== "production") {
+    const chalk = await import("chalk");
+    const localtunnel = (
+      await import("localtunnel").catch((e) => {
+        throw new Error("localtunnel module not found");
+      })
+    ).default;
+    const tunnel = await localtunnel({
+      port: 3000,
+      subdomain: "discord-https",
+    });
+    console.log(
+      chalk.default.yellow(
+        "[DevLayer] Warning: This URL is intended only for testing and developing your bot.\n" +
+          "Never use it in production or hosting.\n" +
+          "1. It may be slower, but this is not an issue for bot development.\n" +
+          "2. This message should not appear in a production/hosting environment. If it does, your environment variables are incorrect and need to be fixed.\n" +
+          "For more information, visit https://discord.com/invite/pSgfJ4K5ej\n\n"
+      )
+    );
+    console.log(
+      chalk.default.blue(
+        `[DevLayer] Interactions Endpoint URL: ${tunnel.url}/interactions\n`
+      )
+    );
+
+    console.log(
+      chalk.default.yellow(
+        `[DevLayer] Modify your interaction url with the above\n`
+      )
+    );
+
+    process.on("SIGINT", async () => {
+      tunnel.close();
+      console.log("[DevLayer] Tunnel has been shut down");
+      process.exit();
+    });
+  }
+}
+
+export async function commandRegistrarLayer(client, guildId) {
+  if (process.env.NODE_ENV !== "production") {
+    const FILENAME = "__dev_layer_cache__";
+    const chalk = (await import("chalk")).default;
+    const isEqual = (await import("fast-deep-equal")).default;
+    const { writeFile, access, readFile, constants } = await import(
+      "node:fs/promises"
+    );
+    const { join } = await import("node:path");
+
+    let localDump = [];
+    const filePath = join(import.meta.dirname, FILENAME);
+
+    try {
+      await access(filePath, constants.F_OK);
+      const contains = await readFile(filePath, {
+        encoding: "utf-8",
+      });
+      const json = JSON.parse(contains);
+      localDump = json;
+    } catch {
+      await writeFile(filePath, "[]");
+    }
+
+    try {
+      // https://github.com/discordhttps/discord.https/blob/main/src/interactionRouter/internal.ts#L271
+      if (
+        !isEqual(
+          localDump,
+          // To remove undefined properties
+          JSON.parse(JSON.stringify(client.router.CommandDefinitions))
+        )
+      ) {
+        console.log(
+          chalk.yellowBright(
+            `[DevLayer] Command change detected, re-registering with discord in ${
+              guildId ? `Guild - ${guildId}` : "Global"
+            }...`
+          )
+        );
+        const registar = await client.getRegistar();
+
+        if (guildId) {
+          await registar.localSlashRegistar(guildId);
+        } else {
+          await registar.globalSlashRegistar();
+        }
+        writeFile(filePath, JSON.stringify(client.router.CommandDefinitions));
+        console.log(
+          chalk.greenBright("[DevLayer] Commands synced successfully!")
+        );
+      }
+    } catch (err) {
+      console.error("[DevLayer] Failed to sync commands:", err);
+    }
+  }
+}