odoro 1.0.9 → 2.1.0

package/dist/chunk-DL3NPC4H.js

@@ -1,113 +0,0 @@
-#!/usr/bin/env node
-import { guessAliasPaths } from './chunk-T6RLHSCW.js';
-import { mkdir, writeFile, rm } from 'fs/promises';
-import { existsSync } from 'fs';
-import { resolve, join } from 'path';
-import { pathToFileURL } from 'url';
-import { build } from 'esbuild';
-
-function defineConfig(config) {
-  return config;
-}
-var CONFIG_FILES = ["odoro.config.ts", "odoro.config.js", "odoro.config.mjs"];
-async function importConfigFile(file, root) {
-  const directory = join(root, "node_modules", ".odoro");
-  const output = join(directory, `config.${Date.now().toString(36)}.mjs`);
-  await mkdir(directory, { recursive: true });
-  try {
-    const result = await build({
-      entryPoints: [file],
-      bundle: true,
-      format: "esm",
-      platform: "node",
-      target: "node20",
-      write: false,
-      // Seul le code du projet est inline ; ses dependances restent externes,
-      // sans quoi il faudrait resoudre tout node_modules pour lire trois lignes.
-      packages: "external",
-      // `packages: 'external'` ne suffit pas : un `baseUrl` dans le
-      // `tsconfig.json` fait chercher les imports nus depuis la racine du
-      // projet, ou `odoro.json` — le fichier du registre — est trouve avant le
-      // paquet. L'import cesse alors d'etre un import de paquet, la regle
-      // ci-dessus ne s'applique plus, et la compilation echoue sur un
-      // `defineConfig` introuvable dans un fichier de configuration.
-      //
-      // Le nommer explicitement le met hors d'atteinte de cette resolution. La
-      // liste vaut pour les projets deja crees : eux portent encore un
-      // `baseUrl`, et on ne peut pas reecrire leur tsconfig.
-      external: ["odoro"]
-    });
-    const code = result.outputFiles[0]?.text;
-    if (code === void 0) {
-      throw new Error(`[odoro] La configuration "${file}" n'a produit aucun code.`);
-    }
-    await writeFile(output, code, "utf8");
-    const module = await import(pathToFileURL(output).href);
-    if (module.default === void 0) {
-      throw new Error(
-        `[odoro] La configuration "${file}" doit avoir un export par defaut.`
-      );
-    }
-    return module.default;
-  } finally {
-    await rm(output, { force: true });
-  }
-}
-async function loadConfig(root, overrides = {}) {
-  const absoluteRoot = resolve(root);
-  let file;
-  let loaded = {};
-  for (const candidate of CONFIG_FILES) {
-    const path = join(absoluteRoot, candidate);
-    if (existsSync(path)) {
-      file = path;
-      loaded = await importConfigFile(path, absoluteRoot);
-      break;
-    }
-  }
-  const merged = {
-    ...loaded,
-    ...overrides,
-    server: { ...loaded.server, ...overrides.server },
-    build: { ...loaded.build, ...overrides.build },
-    alias: { ...loaded.alias, ...overrides.alias },
-    define: { ...loaded.define, ...overrides.define }
-  };
-  const base = merged.base ?? "/";
-  const projectRoot = merged.root === void 0 ? absoluteRoot : resolve(absoluteRoot, merged.root);
-  return {
-    root: projectRoot,
-    base: base.endsWith("/") ? base : `${base}/`,
-    publicDir: resolve(projectRoot, merged.publicDir ?? "public"),
-    outDir: resolve(projectRoot, merged.build?.outDir ?? "dist"),
-    server: {
-      port: merged.server?.port ?? 5180,
-      host: merged.server?.host ?? "localhost",
-      proxy: merged.server?.proxy ?? {}
-    },
-    build: {
-      outDir: merged.build?.outDir ?? "dist",
-      minify: merged.build?.minify ?? true,
-      sourcemap: merged.build?.sourcemap ?? true,
-      target: merged.build?.target ?? "es2022",
-      // Actif par defaut : une feuille qui contient toutes les classes
-      // possibles est un accident de generation, pas une intention.
-      elaguer: merged.build?.elaguer ?? true,
-      safelist: merged.build?.safelist ?? []
-    },
-    // Les alias declares dans `tsconfig.json` sont repris d'office. Sans
-    // cela, un projet qui suit `odoro init` — lequel deduit son prefixe du
-    // tsconfig — aurait a redeclarer le meme alias ici pour que le serveur
-    // sache le resoudre. Deux endroits pour la meme verite, et une erreur
-    // qui n'apparait qu'au premier import.
-    //
-    // La configuration l'emporte : c'est elle qu'on ecrit pour corriger un
-    // cas que la deduction n'attrape pas.
-    alias: { ...await guessAliasPaths(projectRoot), ...merged.alias },
-    define: merged.define ?? {},
-    envPrefix: merged.envPrefix ?? "ODORO_",
-    configFile: file
-  };
-}
-
-export { defineConfig, loadConfig };

package/dist/chunk-TQUJ3MFS.js

@@ -1,268 +0,0 @@
-#!/usr/bin/env node
-import { relative, resolve } from 'path';
-import { build } from 'esbuild';
-
-// src/shared/ecouter.ts
-var ESSAIS = 10;
-async function ecouter(server, port, host, essais = ESSAIS) {
-  for (let decalage = 0; decalage < essais; decalage += 1) {
-    const candidat = port + decalage;
-    const pris = await new Promise((resolve2, reject) => {
-      const surErreur = (cause) => {
-        server.removeListener("listening", surEcoute);
-        if (cause.code === "EADDRINUSE") {
-          resolve2(true);
-          return;
-        }
-        reject(cause);
-      };
-      const surEcoute = () => {
-        server.removeListener("error", surErreur);
-        resolve2(false);
-      };
-      server.once("error", surErreur);
-      server.once("listening", surEcoute);
-      server.listen(candidat, host);
-    });
-    if (!pris) {
-      const adresse = server.address();
-      const obtenu = typeof adresse === "object" && adresse !== null ? adresse.port : candidat;
-      return decalage === 0 ? { port: obtenu } : { port: obtenu, demande: port };
-    }
-  }
-  throw new Error(
-    `[odoro] Aucun port libre entre ${String(port)} et ${String(port + essais - 1)}.`
-  );
-}
-var DEPS_PREFIX = "/@deps/";
-var INTERNAL_PREFIX = "/@odoro/";
-var SOURCE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-var STYLE_EXTENSIONS = [".css"];
-var ASSET_EXTENSIONS = [
-  ".svg",
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".webp",
-  ".avif",
-  ".ico",
-  ".woff",
-  ".woff2",
-  ".mp4",
-  ".webm"
-];
-function depFileName(specifier) {
-  return `${specifier.replace(/^@/, "").split("/").join("_")}.js`;
-}
-function isBareSpecifier(specifier) {
-  return !specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.startsWith("\\") && !/^[a-zA-Z]:[\\/]/.test(specifier) && !specifier.startsWith("data:") && !specifier.startsWith("http:") && !specifier.startsWith("https:");
-}
-function hasExtension(path, extensions) {
-  const clean = path.split("?")[0] ?? path;
-  return extensions.some((extension) => clean.toLowerCase().endsWith(extension));
-}
-function fileToUrl(file, root) {
-  const relativePath = relative(root, file).split("\\").join("/");
-  if (!relativePath.startsWith("..")) return `/${relativePath}`;
-  return `/@fs/${file.split("\\").join("/").replace(/^\//, "")}`;
-}
-function urlToFile(url, root) {
-  const path = (url.split("?")[0] ?? url).split("#")[0] ?? url;
-  if (path.startsWith("/@fs/")) {
-    const absolute = path.slice("/@fs/".length);
-    return /^[a-zA-Z]:/.test(absolute) ? absolute : `/${absolute}`;
-  }
-  return resolve(root, `.${path}`);
-}
-function applyAlias(specifier, config) {
-  for (const [prefix, target] of Object.entries(config.alias)) {
-    if (specifier === prefix || specifier.startsWith(`${prefix}/`)) {
-      return resolve(
-        config.root,
-        target,
-        specifier.slice(prefix.length).replace(/^\//, "")
-      );
-    }
-  }
-  return specifier;
-}
-function externalizeImports(config, dependencies) {
-  return {
-    name: "odoro-externalize",
-    setup(builder) {
-      builder.onResolve({ filter: /.*/ }, async (args) => {
-        if (args.kind === "entry-point") return null;
-        if (args.pluginData?.resolving === true) {
-          return null;
-        }
-        if (args.path.startsWith(INTERNAL_PREFIX) || args.path.startsWith(DEPS_PREFIX)) {
-          return { path: args.path, external: true };
-        }
-        const aliased = applyAlias(args.path, config);
-        const isFileLike = hasExtension(aliased, STYLE_EXTENSIONS) || hasExtension(aliased, ASSET_EXTENSIONS);
-        if (isBareSpecifier(aliased) && !isFileLike) {
-          return { path: `${DEPS_PREFIX}${depFileName(aliased)}`, external: true };
-        }
-        const resolved = await builder.resolve(aliased, {
-          kind: "import-statement",
-          resolveDir: args.resolveDir,
-          importer: args.importer,
-          pluginData: { resolving: true }
-        });
-        if (resolved.errors.length > 0) {
-          return { path: args.path, external: true };
-        }
-        dependencies.add(resolved.path);
-        const url = fileToUrl(resolved.path, config.root);
-        return {
-          path: hasExtension(url, ASSET_EXTENSIONS) ? `${url}?import` : url,
-          external: true
-        };
-      });
-    }
-  };
-}
-async function transformModule(file, config, env) {
-  const dependencies = /* @__PURE__ */ new Set();
-  const result = await build({
-    entryPoints: [file],
-    bundle: true,
-    write: false,
-    format: "esm",
-    platform: "browser",
-    target: "es2022",
-    sourcemap: "inline",
-    jsx: "automatic",
-    jsxDev: true,
-    logLevel: "silent",
-    absWorkingDir: config.root,
-    define: {
-      "import.meta.env": JSON.stringify(env),
-      "process.env.NODE_ENV": JSON.stringify("development"),
-      ...config.define
-    },
-    plugins: [externalizeImports(config, dependencies)]
-  });
-  const code = result.outputFiles[0]?.text;
-  if (code === void 0) {
-    throw new Error(`[odoro] La compilation de "${file}" n'a produit aucun code.`);
-  }
-  return { code, dependencies: [...dependencies] };
-}
-var IDENTIFIANT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-var RESERVES = /* @__PURE__ */ new Set([
-  "arguments",
-  "await",
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "enum",
-  "eval",
-  "export",
-  "extends",
-  "false",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "implements",
-  "import",
-  "in",
-  "instanceof",
-  "interface",
-  "let",
-  "new",
-  "null",
-  "package",
-  "private",
-  "protected",
-  "public",
-  "return",
-  "static",
-  "super",
-  "switch",
-  "this",
-  "throw",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-  "yield"
-]);
-function wrapJson(json) {
-  let valeur;
-  try {
-    valeur = JSON.parse(json);
-  } catch {
-    return 'throw new SyntaxError("JSON illisible")';
-  }
-  const lignes = ["export default " + json.trim()];
-  if (typeof valeur === "object" && valeur !== null && !Array.isArray(valeur)) {
-    for (const [cle, contenu] of Object.entries(valeur)) {
-      if (!IDENTIFIANT.test(cle) || RESERVES.has(cle)) continue;
-      lignes.push("export const " + cle + " = " + JSON.stringify(contenu));
-    }
-  }
-  return lignes.join("\n");
-}
-var DESTINATIONS_RESSOURCE = /* @__PURE__ */ new Set([
-  "script",
-  "style",
-  "image",
-  "font",
-  "audio",
-  "video",
-  "track",
-  "manifest",
-  "worker",
-  "sharedworker",
-  "serviceworker"
-]);
-function estUneRessource(entetes) {
-  const destination = entetes["sec-fetch-dest"];
-  return typeof destination === "string" && DESTINATIONS_RESSOURCE.has(destination);
-}
-function feuilleDemandee(entetes, url) {
-  if (url.includes("?direct")) return true;
-  if (entetes["sec-fetch-dest"] === "style") return true;
-  const accepte = entetes["accept"];
-  return typeof accepte === "string" && accepte.includes("text/css");
-}
-function wrapStyle(url, css) {
-  return `const id = ${JSON.stringify(`odoro-style:${url}`)}
-const css = ${JSON.stringify(css)}
-
-let element = document.querySelector(\`style[data-odoro-id="\${id}"]\`)
-if (element === null) {
-  element = document.createElement('style')
-  element.setAttribute('data-odoro-id', id)
-  document.head.appendChild(element)
-}
-element.textContent = css
-
-import.meta.hot?.accept()
-import.meta.hot?.dispose(() => {
-  // La feuille suivante recreera l'element : le retirer evite d'empiler les
-  // regles mortes a chaque rechargement.
-  element?.remove()
-})
-`;
-}
-function wrapAsset(url) {
-  return `export default ${JSON.stringify(url)}
-`;
-}
-
-export { ASSET_EXTENSIONS, DEPS_PREFIX, INTERNAL_PREFIX, SOURCE_EXTENSIONS, STYLE_EXTENSIONS, applyAlias, depFileName, ecouter, estUneRessource, feuilleDemandee, fileToUrl, hasExtension, isBareSpecifier, transformModule, urlToFile, wrapAsset, wrapJson, wrapStyle };

package/dist/chunk-ZVL7EXJO.js

@@ -1,66 +0,0 @@
-#!/usr/bin/env node
-import { estUneRessource, ecouter } from './chunk-TQUJ3MFS.js';
-import { warn, success, info, colors } from './chunk-JMEHF3KN.js';
-import { existsSync, statSync, createReadStream } from 'fs';
-import { createServer } from 'http';
-import { normalize, join, extname } from 'path';
-
-var MIME = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "text/javascript; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".webp": "image/webp",
-  ".ico": "image/x-icon",
-  ".woff2": "font/woff2",
-  ".map": "application/json; charset=utf-8",
-  ".txt": "text/plain; charset=utf-8",
-  ".md": "text/markdown; charset=utf-8",
-  ".markdown": "text/markdown; charset=utf-8"
-};
-async function startPreviewServer(config, port = config.server.port + 1) {
-  if (!existsSync(config.outDir)) {
-    throw new Error(`[odoro] Rien a previsualiser : lancez "odoro build" d'abord.`);
-  }
-  const server = createServer((incoming, response) => {
-    const path = (incoming.url ?? "/").split("?")[0] ?? "/";
-    const relativePath = normalize(decodeURIComponent(path)).split(/[\\/]/).filter(Boolean).join("/");
-    const candidate = join(config.outDir, relativePath);
-    const dansLeDossier = ["index.html", "index.md"].map((nom) => join(candidate, nom)).find((chemin) => existsSync(chemin) && statSync(chemin).isFile());
-    const existant = existsSync(candidate) && statSync(candidate).isFile() ? candidate : dansLeDossier;
-    if (existant === void 0 && (extname(relativePath) !== "" || estUneRessource(incoming.headers))) {
-      response.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
-      response.end(`Introuvable : /${relativePath}`);
-      return;
-    }
-    const file = existant ?? join(config.outDir, "index.html");
-    if (!file.startsWith(config.outDir)) {
-      response.writeHead(403, { "Content-Type": "text/plain" });
-      response.end("Interdit");
-      return;
-    }
-    const type = MIME[extname(file).toLowerCase()] ?? "application/octet-stream";
-    const immutable = relativePath.startsWith("assets/");
-    response.writeHead(200, {
-      "Content-Type": type,
-      "Cache-Control": immutable ? "public, max-age=31536000, immutable" : "no-cache"
-    });
-    createReadStream(file).pipe(response);
-  });
-  const { port: obtenu, demande } = await ecouter(server, port, config.server.host);
-  if (demande !== void 0) {
-    warn(`port ${String(demande)} occupe \u2014 l apercu ecoute sur ${String(obtenu)}`);
-  }
-  const url = `http://${config.server.host}:${String(obtenu)}${config.base}`;
-  success("previsualisation du build de production");
-  info(`  ${colors.cyan(url)}`);
-  return {
-    url,
-    close: () => new Promise((done) => server.close(() => done()))
-  };
-}
-
-export { startPreviewServer };

package/dist/commands-4JRBD55Z.js

@@ -1,245 +0,0 @@
-#!/usr/bin/env node
-import { writeDatabaseUrl, assertEnvIgnored } from './chunk-3SZIN6VG.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-cli/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://db.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/preview-7DKEAQOQ.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-export { startPreviewServer } from './chunk-ZVL7EXJO.js';
-import './chunk-TQUJ3MFS.js';
-import './chunk-JMEHF3KN.js';