@tgcloud/create-bot 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Telegram Messenger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# @tgcloud/create-bot
+
+Scaffold a new project for the Telegram serverless platform:
+
+```sh
+npm create @tgcloud/bot example_bot
+```
+
+It installs [`@tgcloud/cli`](https://www.npmjs.com/package/@tgcloud/cli) as a local
+dev-dependency, then uses it (`tgcloud init`) to scaffold a starter project and offers
+to link your bot — printing the next steps when it's done.
+
+The argument is the target folder — pass `.` to scaffold into the current folder,
+or any path. It works in an existing folder too and never overwrites your files.
+
+Requires Node.js 18 or newer.
+
+## Documentation
+
+Full documentation: https://core.telegram.org/bots/serverless
+
+## License
+
+MIT

package/bin/index.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+// @tgcloud/create-bot — bootstrap invoked via `npm create @tgcloud/bot <directory>`.
+//
+// A THIN bootstrap: it does only the things that must happen BEFORE @tgcloud/cli
+// exists in the project — create the target directory, write a minimal package.json
+// (only if none exists), and `npm install --save-dev @tgcloud/cli` — then delegates
+// ALL scaffolding to `tgcloud init` (run through the freshly installed local CLI).
+// This keeps a single source of truth for the project layout (init) and makes a
+// create-bot project byte-identical to an `init` one (including .tgcloud/state.json).
+// It mirrors `init`: works in an empty OR existing folder and never overwrites your files.
+//
+// It has no dependency on @tgcloud/cli (runs via npx before anything is installed)
+// and uses node builtins only.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { execSync } from 'node:child_process';
+import { basename } from 'node:path';
+
+function fail(msg) {
+  console.error(msg);
+  process.exit(1);
+}
+
+function askYesNo(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (a) => {
+      rl.close();
+      resolve(/^y(es)?$/i.test(a.trim()));
+    });
+  });
+}
+
+async function main() {
+  // Parse args positionally: the first non-flag token is the target directory, and
+  // --no-git may appear anywhere (npm create passes flags through positionally).
+  const args = process.argv.slice(2);
+  const noGit = args.includes('--no-git');
+  const target = args.find((a) => !a.startsWith('-'));
+
+  if (!target) {
+    fail('Usage: npm create @tgcloud/bot <directory> [--no-git]');
+  }
+
+  // The argument is a directory path — a bare name (→ ./name), "." (current folder),
+  // or a relative/absolute path. The project name is the resolved folder's basename.
+  const targetDir = path.resolve(process.cwd(), target);
+  const name = basename(targetDir);
+  if (!name) {
+    fail(`Invalid target directory: ${target}`);
+  }
+
+  // 1. Create the target directory (if needed) and — only when there is no
+  //    package.json yet — a MINIMAL, frozen stub. `npm install --save-dev` needs a
+  //    manifest to write into; `tgcloud init` fills in the evolving shape (type,
+  //    scripts, version) below. We NEVER overwrite an existing package.json, so
+  //    create-bot is non-destructive in an existing folder — like `tgcloud init`.
+  const dirExisted = fs.existsSync(targetDir);
+  fs.mkdirSync(targetDir, { recursive: true });
+  const pkgPath = path.join(targetDir, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    fs.writeFileSync(pkgPath, JSON.stringify({ name, private: true }, null, 2) + '\n');
+  }
+
+  // 2. Install the CLI as a dev-dependency. On failure, remove the directory ONLY if
+  //    we created it — never delete a folder that was already there (e.g. `create-bot .`
+  //    in an existing project). A re-run is idempotent either way.
+  console.log('Installing @tgcloud/cli...');
+  try {
+    execSync('npm install --save-dev @tgcloud/cli', { cwd: targetDir, stdio: 'inherit' });
+  } catch {
+    if (!dirExisted) fs.rmSync(targetDir, { recursive: true, force: true });
+    fail('\nFailed to install @tgcloud/cli. Check the error above and try again.');
+  }
+
+  // 3. Delegate scaffolding to the installed CLI. `npx` run from targetDir resolves
+  //    the local node_modules/.bin/tgcloud we just installed (NOT the unrelated
+  //    `tgcloud` npm package — the successful install above guarantees the local
+  //    bin exists). init owns the whole scaffold; --no-git passes through.
+  try {
+    execSync('npx tgcloud init' + (noGit ? ' --no-git' : ''), {
+      cwd: targetDir,
+      stdio: 'inherit',
+      // create-bot owns the final "Next steps" — it alone knows the cd target,
+      // the npx runner, and whether the user links a bot below. Suppress init's
+      // own tail so there aren't two contradictory "Next steps" blocks.
+      env: { ...process.env, TGCLOUD_INIT_QUIET_NEXT: '1' },
+    });
+  } catch {
+    fail('\nScaffolding failed. Fix the error above and run "npx tgcloud init" in the project.');
+  }
+
+  // 4. Optionally link the bot now. Interactive only; delegates to the real
+  //    `tgcloud login` (no duplicated prompt).
+  let loggedIn = false;
+  if (process.stdin.isTTY) {
+    if (await askYesNo('\nLink your bot now? [y/N] ')) {
+      try {
+        execSync('npx tgcloud login', { cwd: targetDir, stdio: 'inherit' });
+        loggedIn = true;
+      } catch {
+        console.log('Skipped — run "npx tgcloud login" later.');
+      }
+    }
+  }
+
+  // 5. The single "Next steps" for the whole bootstrap (init's was suppressed;
+  //    init still printed "Project ready" + the files note above). Leads with
+  //    `cd` — the one thing init can't say, since a child process can't change
+  //    the parent shell's cwd — then npx commands, skipping login if the user
+  //    just linked. Plain text: create-bot has no chalk.
+  console.log('\nNext steps:');
+  if (target !== '.') console.log(`  cd ${target}`);
+  if (!loggedIn) console.log(`  ${'npx tgcloud login'.padEnd(17)}  # link your bot`);
+  console.log(`  ${'npx tgcloud push'.padEnd(17)}  # deploy to the cloud`);
+}
+
+main();

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@tgcloud/create-bot",
+  "version": "0.1.0",
+  "description": "Scaffold a new tgcloud bot project (npm create @tgcloud/bot)",
+  "keywords": [
+    "telegram",
+    "telegram-bot",
+    "bot",
+    "serverless",
+    "tgcloud",
+    "scaffold",
+    "starter"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "create-bot": "bin/index.js"
+  },
+  "files": [
+    "bin"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}