odoro 0.1.0

package/dist/commands-V44Y5G4F.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+import { writeDatabaseUrl, assertEnvIgnored } from './chunk-PEMYUK2D.js';
+import { info, success, colors, warn, error } from './chunk-JMEHF3KN.js';
+import { randomBytes } from 'crypto';
+import { readFile, mkdir, writeFile, chmod } from 'fs/promises';
+import { platform, homedir } from 'os';
+import { dirname, join } from 'path';
+
+function configPath(env = processEnv()) {
+  const xdg = env["XDG_CONFIG_HOME"];
+  if (xdg !== void 0 && xdg.length > 0) return join(xdg, "odoro", "config.json");
+  if (platform() === "win32") {
+    const appData = env["APPDATA"];
+    if (appData !== void 0 && appData.length > 0) {
+      return join(appData, "odoro", "config.json");
+    }
+  }
+  return join(homedir(), ".config", "odoro", "config.json");
+}
+function processEnv() {
+  return process.env;
+}
+async function readUserConfig(path = configPath()) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function writeUserConfig(config, path = configPath()) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  if (platform() === "win32") return { path, restricted: false };
+  try {
+    await chmod(path, 384);
+    return { path, restricted: true };
+  } catch {
+    return { path, restricted: false };
+  }
+}
+async function storeToken(apiUrl, token, path = configPath()) {
+  const current = await readUserConfig(path);
+  return await writeUserConfig(
+    {
+      ...current,
+      tokens: { ...current.tokens, [apiUrl]: token },
+      defaultApiUrl: current.defaultApiUrl ?? apiUrl
+    },
+    path
+  );
+}
+async function findToken(apiUrl, path = configPath(), env = processEnv()) {
+  const fromEnv = env["ODORO_TOKEN"];
+  if (fromEnv !== void 0 && fromEnv.length > 0) return fromEnv;
+  const config = await readUserConfig(path);
+  return config.tokens?.[apiUrl];
+}
+
+// src/db/sdk.ts
+var SDK_PACKAGE = "@odoro/cloud-sdk";
+async function loadSdk() {
+  try {
+    const specifier = SDK_PACKAGE;
+    const sdk = await import(specifier);
+    return { ok: true, sdk };
+  } catch {
+    return {
+      ok: false,
+      reason: `Cette commande a besoin de ${SDK_PACKAGE}, qui n'est pas installe.
+
+  npm install --save-dev ${SDK_PACKAGE}
+
+Il n'est pas fourni avec odoro : ce binaire est telecharge a chaque
+creation de projet, et la plupart n'emploient pas la plateforme.`
+    };
+  }
+}
+
+// src/db/commands.ts
+var DEFAULT_API_URL = "https://api.odoro.dev";
+function idempotencyKey() {
+  return randomBytes(24).toString("hex");
+}
+async function connect(options) {
+  const apiUrl = options.apiUrl ?? DEFAULT_API_URL;
+  const load = await loadSdk();
+  if (!load.ok) {
+    error(load.reason);
+    return void 0;
+  }
+  const token = await findToken(apiUrl);
+  if (token === void 0) {
+    error(
+      `Aucun jeton pour ${apiUrl}.
+
+  odoro db:login
+
+Ou fournissez-le par la variable ODORO_TOKEN, ce que fait une
+integration continue.`
+    );
+    return void 0;
+  }
+  return { client: load.sdk.createClient({ baseUrl: apiUrl, token }), sdk: load.sdk };
+}
+async function loginCommand(options) {
+  const apiUrl = options.apiUrl ?? DEFAULT_API_URL;
+  const prompts = await import('@clack/prompts');
+  const value = await prompts.password({
+    message: `Jeton pour ${apiUrl}`,
+    validate: (input) => input.startsWith("odk_") ? void 0 : "Un jeton commence par odk_live_ ou odk_test_"
+  });
+  if (prompts.isCancel(value)) {
+    info("Annule.");
+    return 0;
+  }
+  const report = await storeToken(apiUrl, value);
+  success(`Jeton enregistre dans ${colors.dim(report.path)}`);
+  if (!report.restricted) {
+    warn(
+      "Les droits restrictifs du fichier n ont pas pu etre poses sur ce systeme : verifiez que ce dossier n est pas partage ni synchronise."
+    );
+  }
+  return 0;
+}
+async function statusCommand(options) {
+  const connection = await connect(options);
+  if (connection === void 0) return 1;
+  const { databases } = await connection.client.databases.list(
+    options.env === void 0 ? {} : { environmentId: options.env }
+  );
+  if (databases.length === 0) {
+    info("Aucune base. `odoro db:create` en provisionne une.");
+    return 0;
+  }
+  for (const base of databases) {
+    const etat = base.state === "ready" ? colors.green(base.state) : base.state === "failed" || base.state === "quarantined" ? colors.red(base.state) : colors.dim(base.state);
+    console.log(`  ${base.id}  ${etat}  ${colors.dim(base.region)}`);
+  }
+  return 0;
+}
+async function createCommand(options) {
+  const connection = await connect(options);
+  if (connection === void 0) return 1;
+  const environmentId = options.env;
+  if (environmentId === void 0) {
+    error("Precisez l environnement : `odoro db:create --env production`.");
+    return 1;
+  }
+  const prompts = await import('@clack/prompts');
+  const spinner = prompts.spinner();
+  spinner.start("Provisionnement");
+  const abort = new AbortController();
+  const onInterrupt = () => abort.abort();
+  process.once("SIGINT", onInterrupt);
+  try {
+    const fini = await connection.client.databases.createAndWait(
+      { idempotencyKey: idempotencyKey(), environmentId, region: "eu-central-1" },
+      { signal: abort.signal }
+    );
+    spinner.stop("Base provisionnee");
+    const databaseId = fini.subject;
+    if (databaseId === void 0) {
+      warn(
+        "L operation a abouti sans nommer la base creee. `odoro db:status` la montrera."
+      );
+      return 0;
+    }
+    const { connectionString } = await connection.client.credentials.rotate({
+      databaseId
+    });
+    await writeDatabaseUrl(options.root, connectionString);
+    success("DATABASE_URL ecrite dans .env");
+    const risque = await assertEnvIgnored(options.root);
+    if (risque !== void 0) warn(risque);
+    return 0;
+  } catch (cause) {
+    spinner.stop("Provisionnement interrompu");
+    if (abort.signal.aborted) {
+      info(
+        "Attente abandonnee. Le provisionnement continue : `odoro db:status` en montrera l aboutissement."
+      );
+      return 0;
+    }
+    error(describe(cause, connection.sdk));
+    return 1;
+  } finally {
+    process.off("SIGINT", onInterrupt);
+  }
+}
+async function branchCommand(options) {
+  const connection = await connect(options);
+  if (connection === void 0) return 1;
+  if (options.from === void 0 || options.name === void 0) {
+    error("Usage : `odoro db:branch --from production --name preview-42`");
+    return 1;
+  }
+  const prompts = await import('@clack/prompts');
+  const spinner = prompts.spinner();
+  spinner.start(`Branche depuis ${options.from}`);
+  try {
+    const fini = await connection.client.databases.branchAndWait({
+      idempotencyKey: idempotencyKey(),
+      parentEnvironmentId: options.from,
+      name: options.name,
+      // Sans regle declaree, la plateforme refuse. On ne devine pas a sa
+      // place : une regle inventee ici anonymiserait la mauvaise colonne, ou
+      // aucune.
+      anonymization: []
+    });
+    spinner.stop("Branche creee");
+    info(`Base : ${fini.subject ?? "voir odoro db:status"}`);
+    return 0;
+  } catch (cause) {
+    spinner.stop("Branche refusee");
+    error(describe(cause, connection.sdk));
+    return 1;
+  }
+}
+function describe(cause, sdk) {
+  if (sdk.isApiError(cause, "VALIDATION")) {
+    const errors = cause.options?.errors;
+    return [
+      "La demande a ete refusee :",
+      ...(errors ?? []).map(({ field, message }) => `  ${field} \u2014 ${message}`)
+    ].join("\n");
+  }
+  if (sdk.isApiError(cause, "RATE_LIMIT")) {
+    return "Trop de demandes. Les routes qui provisionnent sont volontairement limitees : chaque creation coute.";
+  }
+  if (sdk.isApiError(cause, "UNAUTHORIZED")) {
+    return `Jeton refuse. \`odoro db:login\` en enregistre un autre.`;
+  }
+  return cause instanceof Error ? cause.message : String(cause);
+}
+var DB_HELP = [
+  "  db:login              Enregistre un jeton de plateforme",
+  "  db:status             Liste les bases du projet",
+  "  db:create --env <e>   Provisionne une base et ecrit .env",
+  "  db:branch --from <e> --name <n>",
+  "                        Cree une previsualisation par branche",
+  `                        (necessite ${SDK_PACKAGE})`
+].join("\n");
+
+export { DB_HELP, branchCommand, createCommand, loginCommand, statusCommand };

package/dist/create-SH2M722Y.js

@@ -0,0 +1,288 @@
+#!/usr/bin/env node
+import { writeDatabaseUrl, assertEnvIgnored, PROVIDER_PENDING, checkDatabaseUrl } from './chunk-PEMYUK2D.js';
+import { execSync } from 'child_process';
+import { existsSync, statSync, readdirSync } from 'fs';
+import { resolve, basename, dirname, join } from 'path';
+import * as prompts from '@clack/prompts';
+import colors from 'picocolors';
+import { readdir, rm, mkdir, copyFile, readFile, writeFile } from 'fs/promises';
+import { fileURLToPath } from 'url';
+
+var PACKAGE_MANAGERS = ["pnpm", "npm", "yarn", "bun"];
+function detectPackageManager(userAgent = process.env["npm_config_user_agent"]) {
+  if (userAgent === void 0) return "npm";
+  const name = userAgent.split(" ")[0]?.split("/")[0];
+  return PACKAGE_MANAGERS.find((candidate) => candidate === name) ?? "npm";
+}
+function installCommand(manager) {
+  return manager === "yarn" ? "yarn" : `${manager} install`;
+}
+function runCommand(manager, script) {
+  return manager === "npm" ? `npm run ${script}` : `${manager} ${script}`;
+}
+function toPackageName(input) {
+  return input.trim().toLowerCase().replace(/^[._]+/, "").replace(/[^a-z0-9\-~]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 214) || "odoro-app";
+}
+function validatePackageName(name) {
+  if (name.trim() === "") return "Le nom du projet ne peut pas etre vide.";
+  if (name.length > 214) return "Le nom du projet ne peut pas depasser 214 caracteres.";
+  if (/^[._]/.test(name)) return 'Le nom du projet ne peut pas commencer par "." ou "_".';
+  if (!/^[a-z0-9\-~][a-z0-9\-._~]*$/.test(name)) {
+    return "Le nom doit etre en minuscules, sans espace ni caractere special.";
+  }
+  return void 0;
+}
+function inspectTarget(directory) {
+  if (!existsSync(directory)) return "absent";
+  const entries = readdirSync(directory).filter((entry) => entry !== ".git");
+  return entries.length === 0 ? "vide" : "occupe";
+}
+function targetFileName(name) {
+  return name.startsWith("_") ? `.${name.slice(1)}` : name;
+}
+function templatesRoot(from = fileURLToPath(import.meta.url)) {
+  let directory = dirname(from);
+  for (let depth = 0; depth < 6; depth += 1) {
+    const candidate = join(directory, "templates");
+    if (existsSync(candidate) && statSync(candidate).isDirectory()) return candidate;
+    const parent = dirname(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+  throw new Error("[odoro] Dossier des templates introuvable depuis " + from);
+}
+function availableTemplates(root = templatesRoot()) {
+  return readdirSync(root).filter((entry) => statSync(resolve(root, entry)).isDirectory()).sort();
+}
+
+// src/scaffold/scaffold.ts
+async function copyDirectory(from, to, written, prefix = "") {
+  await mkdir(to, { recursive: true });
+  for (const entry of await readdir(from, { withFileTypes: true })) {
+    const source = join(from, entry.name);
+    const name = targetFileName(entry.name);
+    const destination = join(to, name);
+    const relativePath = prefix === "" ? name : `${prefix}/${name}`;
+    if (entry.isDirectory()) {
+      await copyDirectory(source, destination, written, relativePath);
+      continue;
+    }
+    await copyFile(source, destination);
+    written.push(relativePath);
+  }
+}
+async function renamePackage(target, packageName) {
+  const file = join(target, "package.json");
+  if (!existsSync(file)) return;
+  const manifest = JSON.parse(await readFile(file, "utf8"));
+  const renamed = { ...manifest, name: packageName };
+  await writeFile(file, `${JSON.stringify(renamed, null, 2)}
+`, "utf8");
+}
+async function scaffold(options) {
+  const root = options.root ?? templatesRoot();
+  const source = join(root, options.template);
+  if (!existsSync(source)) {
+    throw new Error(`[odoro] Template inconnu : "${options.template}".`);
+  }
+  if (options.overwrite === "ecraser" && existsSync(options.target)) {
+    for (const entry of await readdir(options.target)) {
+      if (entry === ".git") continue;
+      await rm(join(options.target, entry), { recursive: true, force: true });
+    }
+  }
+  const files = [];
+  await copyDirectory(source, options.target, files);
+  await renamePackage(options.target, options.packageName);
+  return { files };
+}
+
+// src/commands/create.ts
+var TEMPLATE_LABELS = {
+  "react-ts": "Application monopage \u2014 React, TypeScript, routeur et animations Odoro",
+  "react-ts-server": "Client et serveur \u2014 la meme application, plus un socle @odoro-cli/server modulaire et un Dockerfile"
+};
+async function askDatabase() {
+  const choice = ensure(
+    await prompts.select({
+      message: "Base de donnees",
+      initialValue: "url",
+      options: [
+        {
+          value: "provider",
+          label: "Fournisseur Odoro",
+          hint: "provisionnement automatique \u2014 bientot"
+        },
+        {
+          value: "url",
+          label: "URL PostgreSQL existante",
+          hint: "Neon, Supabase, RDS, la votre"
+        },
+        { value: "later", label: "Configurer plus tard", hint: ".env.example seul" }
+      ]
+    })
+  );
+  if (choice === "provider") {
+    prompts.log.warn(PROVIDER_PENDING);
+    return { choice, note: "Lancez `odoro db:create` des que la plateforme est la." };
+  }
+  if (choice === "later") {
+    return {
+      choice,
+      note: "Aucune base : le client demarrera, et /api/ready repondra 503 en disant ce qui manque."
+    };
+  }
+  const url = ensure(
+    await prompts.text({
+      message: "URL PostgreSQL",
+      placeholder: "postgres://utilisateur:motdepasse@hote:5432/base?sslmode=require",
+      validate: (value) => checkDatabaseUrl(value ?? "")
+    })
+  );
+  return {
+    choice,
+    url: url.trim(),
+    // Seule la forme a ete verifiee : le dire, plutot que de laisser croire
+    // que la connexion a ete etablie.
+    note: "Forme de l URL verifiee. La connexion sera etablie au premier demarrage."
+  };
+}
+function ensure(value) {
+  if (prompts.isCancel(value)) {
+    prompts.cancel("Creation annulee.");
+    process.exit(0);
+  }
+  return value;
+}
+async function createCommand(options) {
+  const root = templatesRoot();
+  const templates = availableTemplates(root);
+  const defaultTemplate = templates[0] ?? "react-ts";
+  prompts.intro(colors.bold(colors.magenta(" odoro ")));
+  const rawName = options.name ?? (options.yes === true ? "odoro-app" : ensure(
+    await prompts.text({
+      message: "Nom du projet",
+      placeholder: "mon-site",
+      defaultValue: "odoro-app",
+      validate: (value) => value === "" ? void 0 : validatePackageName(toPackageName(value))
+    })
+  ));
+  const target = resolve(process.cwd(), rawName);
+  const packageName = toPackageName(basename(target));
+  const invalid = validatePackageName(packageName);
+  if (invalid !== void 0) {
+    prompts.cancel(invalid);
+    return 1;
+  }
+  let overwrite = options.overwrite;
+  const state = inspectTarget(target);
+  if (state === "occupe" && overwrite === void 0) {
+    if (options.yes === true) {
+      prompts.cancel(
+        `Le dossier "${basename(target)}" n'est pas vide. Precisez --overwrite ou --merge.`
+      );
+      return 1;
+    }
+    const choice = ensure(
+      await prompts.select({
+        message: `Le dossier "${basename(target)}" n'est pas vide.`,
+        options: [
+          { value: "annuler", label: "Annuler" },
+          { value: "fusionner", label: "Fusionner \u2014 ecrase les fichiers de meme nom" },
+          { value: "ecraser", label: "Vider le dossier puis creer le projet" }
+        ]
+      })
+    );
+    if (choice === "annuler") {
+      prompts.cancel("Creation annulee.");
+      return 0;
+    }
+    overwrite = choice;
+  }
+  const template = options.template ?? (options.yes === true ? defaultTemplate : ensure(
+    await prompts.select({
+      message: "Template",
+      initialValue: defaultTemplate,
+      options: templates.map((name) => ({
+        value: name,
+        label: name,
+        hint: TEMPLATE_LABELS[name]
+      }))
+    })
+  ));
+  if (!templates.includes(template)) {
+    prompts.cancel(
+      `Template inconnu : "${template}". Disponibles : ${templates.join(", ")}.`
+    );
+    return 1;
+  }
+  const detected = detectPackageManager();
+  const manager = options.pm ?? (options.yes === true ? detected : ensure(
+    await prompts.select({
+      message: "Gestionnaire de paquets",
+      initialValue: detected,
+      options: PACKAGE_MANAGERS.map((name) => ({
+        value: name,
+        label: name,
+        hint: name === detected ? "detecte" : void 0
+      }))
+    })
+  ));
+  if (!PACKAGE_MANAGERS.includes(manager)) {
+    prompts.cancel(`Gestionnaire inconnu : "${manager}".`);
+    return 1;
+  }
+  const database = template === "react-ts-server" && options.yes !== true ? await askDatabase() : void 0;
+  const withGit = options.git ?? (options.yes === true ? true : ensure(await prompts.confirm({ message: "Initialiser un depot git ?" })));
+  const withInstall = options.install ?? (options.yes === true ? true : ensure(
+    await prompts.confirm({
+      message: `Installer les dependances avec ${manager} ?`
+    })
+  ));
+  const spinner2 = prompts.spinner();
+  spinner2.start("Creation du projet");
+  const scaffoldOptions = {
+    target,
+    template,
+    packageName,
+    root
+  };
+  if (overwrite !== void 0) scaffoldOptions.overwrite = overwrite;
+  const { files } = await scaffold(scaffoldOptions);
+  spinner2.stop(`${files.length} fichiers ecrits dans ${colors.cyan(basename(target))}`);
+  if (withGit && !existsSync(resolve(target, ".git"))) {
+    try {
+      execSync("git init -q", { cwd: target, stdio: "ignore" });
+      prompts.log.success("Depot git initialise.");
+    } catch {
+      prompts.log.warn("git est introuvable : depot non initialise.");
+    }
+  }
+  if (database?.url !== void 0) {
+    await writeDatabaseUrl(target, database.url);
+    prompts.log.success("URL de base ecrite dans .env");
+    const risque = await assertEnvIgnored(target);
+    if (risque !== void 0) prompts.log.warn(risque);
+  }
+  if (database !== void 0) prompts.log.info(database.note);
+  if (withInstall) {
+    const install = prompts.spinner();
+    install.start(`Installation avec ${manager}`);
+    try {
+      execSync(installCommand(manager), { cwd: target, stdio: "ignore" });
+      install.stop("Dependances installees.");
+    } catch {
+      install.stop("Installation echouee \u2014 a relancer a la main.");
+    }
+  }
+  const steps = [
+    `cd ${basename(target)}`,
+    ...withInstall ? [] : [installCommand(manager)],
+    runCommand(manager, "dev")
+  ];
+  prompts.note(steps.join("\n"), "Prochaines etapes");
+  prompts.outro(colors.green("Bon developpement."));
+  return 0;
+}
+
+export { createCommand };