@tokmo/create-buildroom 0.0.0-stage → 0.2.0

package/dist/cli.js

@@ -0,0 +1,418 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli.ts
+import { mkdir, readFile, writeFile, access } from "fs/promises";
+import { dirname, resolve } from "path";
+import { parseArgs } from "util";
+// package.json
+var package_default = {
+  name: "@tokmo/create-buildroom",
+  version: "0.2.0",
+  type: "module",
+  bin: {
+    "create-buildroom": "dist/cli.js"
+  },
+  files: ["dist"],
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    test: "bun test",
+    typecheck: "tsc --noEmit",
+    build: "bun build src/cli.ts --target bun --outfile dist/cli.js"
+  },
+  devDependencies: {
+    typescript: "^5.0.0",
+    "@types/bun": "latest"
+  }
+};
+
+// src/text.ts
+function toLF(text) {
+  return text.replace(/^\uFEFF/, "").replace(/\r\n?/g, `
+`);
+}
+function toLines(text) {
+  if (text === null)
+    return [];
+  const lf = toLF(text);
+  if (lf === "")
+    return [];
+  return (lf.endsWith(`
+`) ? lf.slice(0, -1) : lf).split(`
+`);
+}
+function fromLines(lines) {
+  return lines.length === 0 ? "" : lines.join(`
+`) + `
+`;
+}
+
+// src/bunfig.ts
+var SECTION = "[install.scopes]";
+function upsertScope(existing, scope, url, tokenVar) {
+  const lines = toLines(existing);
+  const entry = `"${scope}" = { url = "${url}", token = "$${tokenVar}" }`;
+  const tableForms = new Set([`[install.scopes."${scope}"]`, `[install.scopes.'${scope}']`]);
+  if (lines.some((l) => tableForms.has(l.trim())))
+    return fromLines(lines);
+  const header = lines.findIndex((l) => l.trim() === SECTION);
+  if (header === -1) {
+    const body = [...lines];
+    while (body.length > 0 && body[body.length - 1].trim() === "")
+      body.pop();
+    return fromLines([...body, ...body.length > 0 ? [""] : [], SECTION, entry]);
+  }
+  let end = lines.length;
+  for (let i = header + 1;i < lines.length; i++) {
+    if (lines[i].trimStart().startsWith("[")) {
+      end = i;
+      break;
+    }
+  }
+  const keyForms = [`"${scope}"`, `'${scope}'`];
+  const present = lines.slice(header + 1, end).some((l) => {
+    const t = l.trimStart();
+    return keyForms.some((k) => t.startsWith(k) && t.slice(k.length).trimStart().startsWith("="));
+  });
+  if (present)
+    return fromLines(lines);
+  return fromLines([...lines.slice(0, header + 1), entry, ...lines.slice(header + 1)]);
+}
+
+// src/config.ts
+var REGISTRY_URL = "https://gitlab.com/api/v4/projects/tokmo%2Fbuildroom/packages/npm/";
+var SCOPE = "@tokmo";
+var TOKEN_VAR = "BUILDROOM_TOKEN";
+var PACKAGE = "@tokmo/buildroom";
+var ENV_EXAMPLE_BLOCK = [
+  "# Jeton GitLab pour installer @tokmo/buildroom (scope read_api).",
+  "# Copie ce fichier en .env et colle ton jeton : https://gitlab.com/-/user_settings/personal_access_tokens",
+  `${TOKEN_VAR}=`
+].join(`
+`);
+
+// src/dotenv.ts
+function definesVar(line, name) {
+  const t = line.trimStart();
+  if (t === "" || t.startsWith("#"))
+    return false;
+  return t.startsWith(`${name}=`);
+}
+function unquote(raw) {
+  const v = raw.trim();
+  if (v.length >= 2) {
+    const q = v[0];
+    if ((q === '"' || q === "'") && v[v.length - 1] === q)
+      return v.slice(1, -1).trim();
+  }
+  return v;
+}
+function readEnvVar(content, name) {
+  for (const line of toLines(content)) {
+    if (!definesVar(line, name))
+      continue;
+    const value = unquote(line.trimStart().slice(name.length + 1));
+    return value === "" ? null : value;
+  }
+  return null;
+}
+function upsertEnvVar(existing, name, value) {
+  const out = [];
+  let done = false;
+  for (const line of toLines(existing)) {
+    if (definesVar(line, name)) {
+      if (!done)
+        out.push(`${name}=${value}`);
+      done = true;
+      continue;
+    }
+    out.push(line);
+  }
+  if (!done)
+    out.push(`${name}=${value}`);
+  return fromLines(out);
+}
+function ensureEnvExample(existing) {
+  const lines = toLines(existing);
+  if (lines.some((l) => definesVar(l, TOKEN_VAR)))
+    return fromLines(lines);
+  return fromLines([...lines, ...ENV_EXAMPLE_BLOCK.split(`
+`)]);
+}
+
+// src/lines.ts
+function ensureLine(existing, line, equivalents = []) {
+  const lines = toLines(existing);
+  const wanted = new Set([line, ...equivalents]);
+  if (lines.some((l) => wanted.has(l.trim())))
+    return fromLines(lines);
+  return fromLines([...lines, line]);
+}
+
+// src/package-json.ts
+function minimalPackageJson(folderName) {
+  const name = folderName.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "project";
+  return JSON.stringify({ name, private: true }, null, 2) + `
+`;
+}
+
+// src/steps.ts
+var FOREIGN_LOCKFILES = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock"];
+function sanitizeToken(raw) {
+  let value = raw.trim();
+  if (value.length >= 2) {
+    const q = value[0];
+    if ((q === '"' || q === "'") && value[value.length - 1] === q)
+      value = value.slice(1, -1).trim();
+  }
+  if (!/^[A-Za-z0-9_.-]+$/.test(value))
+    return null;
+  return value;
+}
+function sameContent(current, next) {
+  const norm = (s) => toLF(s).replace(/\n$/, "");
+  return norm(current) === norm(next);
+}
+function folderNameOf(cwd) {
+  return cwd.split(/[\\/]/).filter(Boolean).pop() ?? "";
+}
+async function runInstaller(io, args) {
+  const writeIfChanged = async (path, current, next) => {
+    if (current !== null && sameContent(current, next))
+      return false;
+    await io.writeFile(path, next);
+    return true;
+  };
+  for (const lock of FOREIGN_LOCKFILES) {
+    if (await io.exists(lock)) {
+      io.err(`Attention : ${lock} d\xE9tect\xE9. Buildroom s'installe avec Bun ; l'installation continue avec Bun.`);
+    }
+  }
+  const envRaw = io.env[TOKEN_VAR];
+  const envFile = await io.readFile(".env");
+  let raw = envRaw !== undefined && envRaw.trim() !== "" ? envRaw : null;
+  if (raw === null && envFile !== null)
+    raw = readEnvVar(envFile, TOKEN_VAR);
+  const fromEnv = raw !== null && envRaw !== undefined && envRaw.trim() !== "";
+  let typed = false;
+  if (raw === null) {
+    if (!io.isTTY) {
+      io.err(`${TOKEN_VAR} est absent et ce terminal n'est pas interactif : rien n'a \xE9t\xE9 \xE9crit.`);
+      io.err("D\xE9finis la variable, puis relance la commande :");
+      io.err(`  macOS / WSL : export ${TOKEN_VAR}=\u2026`);
+      io.err(`  Windows     : setx ${TOKEN_VAR} "\u2026"  (puis ouvre un nouveau terminal)`);
+      io.err(`  ou ajoute la ligne ${TOKEN_VAR}=\u2026 dans le fichier .env du dossier courant.`);
+      return 1;
+    }
+    const answer = await io.readSecret(`Jeton GitLab (${TOKEN_VAR}, scope read_api) : `);
+    if (answer === null) {
+      io.err("Saisie annul\xE9e : rien n'a \xE9t\xE9 \xE9crit.");
+      return 1;
+    }
+    raw = answer;
+    typed = true;
+  }
+  const token = sanitizeToken(raw);
+  if (token === null) {
+    io.err(`${TOKEN_VAR} est vide ou invalide (seuls lettres, chiffres, \xAB _ \xBB, \xAB . \xBB et \xAB - \xBB sont permis) : rien n'a \xE9t\xE9 \xE9crit.`);
+    io.err("V\xE9rifie le jeton copi\xE9 depuis GitLab, puis relance la commande.");
+    return 1;
+  }
+  const gitignore = await io.readFile(".gitignore");
+  if (await writeIfChanged(".gitignore", gitignore, ensureLine(gitignore, ".env", ["/.env"]))) {
+    io.out(".gitignore : ligne .env ajout\xE9e");
+  }
+  if (typed) {
+    if (await writeIfChanged(".env", envFile, upsertEnvVar(envFile, TOKEN_VAR, token))) {
+      io.out(`.env : ${TOKEN_VAR} enregistr\xE9`);
+    }
+  }
+  const example = await io.readFile(".env.example");
+  if (await writeIfChanged(".env.example", example, ensureEnvExample(example))) {
+    io.out(".env.example : compl\xE9t\xE9");
+  }
+  if (!await io.exists("package.json")) {
+    await io.writeFile("package.json", minimalPackageJson(folderNameOf(io.cwd)));
+    io.out("package.json : cr\xE9\xE9");
+  }
+  const bunfig = await io.readFile("bunfig.toml");
+  if (await writeIfChanged("bunfig.toml", bunfig, upsertScope(bunfig, SCOPE, REGISTRY_URL, TOKEN_VAR))) {
+    io.out(`bunfig.toml : registre ${SCOPE} configur\xE9`);
+  }
+  const env = {};
+  for (const [k, v] of Object.entries(io.env))
+    if (v !== undefined)
+      env[k] = v;
+  env[TOKEN_VAR] = token;
+  io.out(`Installation de ${PACKAGE}\u2026`);
+  const add = await io.spawn(["bun", "add", "-d", PACKAGE], env);
+  if (add.code !== 0) {
+    if (/\b40[13]\b/.test(add.output)) {
+      const where = fromEnv ? "(variable d'environnement)" : "dans .env";
+      io.err(`Jeton refus\xE9 par GitLab : v\xE9rifie ${TOKEN_VAR} ${where} (scope read_api).`);
+    } else if (/\b404\b/.test(add.output)) {
+      io.err(`Paquet ${PACKAGE} introuvable : le jeton a-t-il acc\xE8s au projet tokmo/buildroom ?`);
+    } else {
+      io.err(add.output.split(token).join("***").trimEnd());
+    }
+    return 1;
+  }
+  const init = await io.spawn(["bun", "x", "build-room", "init", ...args.key ? ["--key", args.key] : []], env, {
+    inherit: true
+  });
+  return init.code;
+}
+
+// src/cli.ts
+var HELP = `Installateur Buildroom (${package_default.name} ${package_default.version})
+
+Usage :
+  bun create @tokmo/buildroom [--key <CL\xC9>]
+
+Options :
+  --key <CL\xC9>   Cl\xE9 du projet (ex. YT), transmise \xE0 \`build-room init\`.
+  --help        Affiche cette aide.
+
+Le jeton GitLab est lu dans BUILDROOM_TOKEN (environnement ou .env),
+sinon il est demand\xE9 en saisie masqu\xE9e.`;
+function readSecretFromStdin(question) {
+  const stdin = process.stdin;
+  if (!stdin.isTTY || typeof stdin.setRawMode !== "function")
+    return Promise.resolve(null);
+  return new Promise((done) => {
+    let value = "";
+    const finish = (result) => {
+      stdin.off("data", onData);
+      stdin.off("end", onEnd);
+      stdin.off("close", onEnd);
+      stdin.off("error", onEnd);
+      stdin.setRawMode(false);
+      stdin.pause();
+      process.stdout.write(`
+`);
+      done(result);
+    };
+    const onData = (chunk) => {
+      for (const ch of chunk.toString()) {
+        if (ch === "\x03")
+          return finish(null);
+        if (ch === "\r" || ch === `
+`)
+          return finish(value);
+        if (ch === "\b" || ch === "\x7F") {
+          if (value.length > 0) {
+            value = value.slice(0, -1);
+            process.stdout.write("\b \b");
+          }
+        } else if (ch >= " ") {
+          value += ch;
+          process.stdout.write("*");
+        }
+      }
+    };
+    const onEnd = () => finish(null);
+    process.stdout.write(question);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on("data", onData);
+    stdin.on("end", onEnd);
+    stdin.on("close", onEnd);
+    stdin.on("error", onEnd);
+  });
+}
+function createNodeInstallerIo() {
+  const cwd = process.cwd();
+  const abs = (p) => resolve(cwd, p);
+  return {
+    cwd,
+    env: process.env,
+    isTTY: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    out: (line) => void process.stdout.write(line + `
+`),
+    err: (line) => void process.stderr.write(line + `
+`),
+    readSecret: readSecretFromStdin,
+    async readFile(path) {
+      try {
+        return await readFile(abs(path), "utf8");
+      } catch (e) {
+        if (e.code === "ENOENT")
+          return null;
+        throw e;
+      }
+    },
+    async writeFile(path, content) {
+      await mkdir(dirname(abs(path)), { recursive: true });
+      await writeFile(abs(path), content, "utf8");
+    },
+    async exists(path) {
+      try {
+        await access(abs(path));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async spawn(cmd, env, opts) {
+      try {
+        if (opts?.inherit) {
+          const p = Bun.spawn(cmd, { cwd, env, stdin: "inherit", stdout: "inherit", stderr: "inherit" });
+          return { code: await p.exited, output: "" };
+        }
+        const p = Bun.spawn(cmd, { cwd, env, stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+        const [stdout, stderr, code] = await Promise.all([new Response(p.stdout).text(), new Response(p.stderr).text(), p.exited]);
+        return { code, output: stdout + stderr };
+      } catch (e) {
+        return { code: 1, output: e instanceof Error ? e.message : String(e) };
+      }
+    }
+  };
+}
+function translateParseError(error) {
+  const raw = error instanceof Error ? error.message : String(error);
+  const code = error?.code;
+  const flag = /'(-[^'\s]+)/.exec(raw)?.[1];
+  if (code === "ERR_PARSE_ARGS_UNKNOWN_OPTION" && flag)
+    return `Option inconnue : ${flag}`;
+  if (code === "ERR_PARSE_ARGS_INVALID_OPTION_VALUE" && flag)
+    return `L'option ${flag} attend une valeur.`;
+  if (code === "ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL") {
+    const arg = /'([^']*)'/.exec(raw)?.[1];
+    return `Argument inattendu${arg === undefined ? "" : ` : \xAB ${arg} \xBB`}. Lance la commande depuis le dossier du projet.`;
+  }
+  return `Arguments invalides : ${raw}`;
+}
+async function main(argv, io) {
+  let values;
+  try {
+    values = parseArgs({
+      args: argv,
+      options: { key: { type: "string" }, help: { type: "boolean" } },
+      strict: true,
+      allowPositionals: false
+    }).values;
+  } catch (e) {
+    io.err(translateParseError(e));
+    io.err(HELP);
+    return 2;
+  }
+  if (values.help) {
+    io.out(HELP);
+    return 0;
+  }
+  try {
+    return await runInstaller(io, { key: values.key });
+  } catch (e) {
+    io.err(`Erreur inattendue : ${e instanceof Error ? e.message : String(e)}`);
+    return 1;
+  }
+}
+if (import.meta.main) {
+  process.exit(await main(process.argv.slice(2), createNodeInstallerIo()));
+}
+export {
+  createNodeInstallerIo,
+  main
+};

package/package.json

@@ -1,6 +1,21 @@
 {
   "name": "@tokmo/create-buildroom",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "type": "module",
+  "bin": {
+    "create-buildroom": "dist/cli.js"
+  },
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "build": "bun build src/cli.ts --target bun --outfile dist/cli.js"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/bun": "latest"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.