@codexa/cli 9.0.33 → 9.0.34

package/db/connection.ts

@@ -6,8 +6,11 @@ import { join, dirname } from "path";
 let client: Client | null = null;
 let dbProvisioned = false;
 
+const TURSO_API = "https://api.turso.tech/v1";
+const CONFIG_PATH = () => join(process.cwd(), ".codexa", "config.json");
+
 // ═══════════════════════════════════════════════════════════════
-// Resolucao de DB URL: env → config local → derivacao do git
+// Resolucao de DB URL: env → config local → provisionar via API
 // ═══════════════════════════════════════════════════════════════
 
 function resolveDbUrl(): string {
@@ -15,7 +18,7 @@ function resolveDbUrl(): string {
   if (process.env.CODEXA_DB_URL) return process.env.CODEXA_DB_URL;
 
   // 2. Cache local (.codexa/config.json)
-  const configPath = join(process.cwd(), ".codexa", "config.json");
+  const configPath = CONFIG_PATH();
   if (existsSync(configPath)) {
     try {
       const config = JSON.parse(readFileSync(configPath, "utf-8"));
@@ -23,48 +26,33 @@ function resolveDbUrl(): string {
     } catch { /* config invalido, continuar */ }
   }
 
-  // 3. Derivar do git remote
-  const org = process.env.TURSO_ORG;
-  if (!org) {
-    throw new Error(
-      "Banco de dados nao configurado.\n\n" +
-      "Opcao 1 — Configurar automaticamente:\n" +
-      "  export TURSO_ORG=sua-org\n" +
-      "  export TURSO_AUTH_TOKEN=eyJ...\n" +
-      "  codexa init\n\n" +
-      "Opcao 2 — Configurar manualmente:\n" +
-      "  export CODEXA_DB_URL=libsql://seu-db.turso.io\n" +
-      "  export TURSO_AUTH_TOKEN=eyJ..."
-    );
-  }
-
-  const slug = deriveSlugFromGit();
-  const url = `libsql://codexa-${slug}-${org}.turso.io`;
-
-  // Salvar no cache para proximas execucoes
-  saveConfig(configPath, url);
+  // 3. Precisa provisionar — retorna placeholder que sera resolvido em ensureDatabase()
+  // Nao temos a URL real sem chamar a API (por causa da regiao no hostname)
+  throw new NeedsProvisioningError();
+}
 
-  return url;
+class NeedsProvisioningError extends Error {
+  constructor() {
+    super("DB_NEEDS_PROVISIONING");
+  }
 }
 
-function deriveSlugFromGit(): string {
+function deriveDbNameFromGit(): string {
   try {
     const remote = execSync("git remote get-url origin", { encoding: "utf-8" }).trim();
-    // github.com/leandro/meu-saas.git → leandro--meu-saas
-    // git@github.com:leandro/meu-saas.git → leandro--meu-saas
     const match = remote.match(/[/:]([^/]+)\/([^/]+?)(?:\.git)?$/);
     if (match) {
-      return `${match[1]}--${match[2]}`.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+      return match[2].toLowerCase().replace(/[^a-z0-9-]/g, "-");
     }
   } catch { /* git nao disponivel */ }
 
-  // Fallback: nome da pasta atual
   const dirName = process.cwd().split(/[/\\]/).pop() || "unknown";
   return dirName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
 }
 
-function saveConfig(configPath: string, url: string): void {
+function saveConfig(url: string): void {
   try {
+    const configPath = CONFIG_PATH();
     const dir = dirname(configPath);
     if (!existsSync(dir)) {
       mkdirSync(dir, { recursive: true });
@@ -73,70 +61,165 @@ function saveConfig(configPath: string, url: string): void {
   } catch { /* falha ao salvar cache, nao e critico */ }
 }
 
+function tursoHeaders(): Record<string, string> {
+  const authToken = process.env.TURSO_AUTH_TOKEN;
+  if (!authToken) {
+    throw new Error(
+      "TURSO_AUTH_TOKEN nao configurado.\n\n" +
+      "  export TURSO_AUTH_TOKEN=$(turso auth token)\n" +
+      "  export TURSO_ORG=sua-org"
+    );
+  }
+  return {
+    "Authorization": `Bearer ${authToken}`,
+    "Content-Type": "application/json",
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Turso API: buscar hostname real do DB (inclui regiao)
+// GET /v1/organizations/{org}/databases/{name}
+// Retorna { database: { Hostname: "name-org.region.turso.io" } }
+// ═══════════════════════════════════════════════════════════════
+
+async function fetchDatabaseUrl(org: string, dbName: string): Promise<string | null> {
+  try {
+    const response = await fetch(
+      `${TURSO_API}/organizations/${org}/databases/${dbName}`,
+      { headers: tursoHeaders() }
+    );
+
+    if (response.status === 404) return null;
+
+    if (response.status === 401 || response.status === 403) {
+      const body = await response.text();
+      throw new Error(
+        `Autenticacao Turso falhou (${response.status}).\n` +
+        `  ${body}\n\n` +
+        "Verifique:\n" +
+        "  1. TURSO_AUTH_TOKEN esta correto e nao expirado\n" +
+        "  2. TURSO_ORG corresponde a sua organizacao no Turso\n\n" +
+        "  Gerar novo token: turso auth token"
+      );
+    }
+
+    if (!response.ok) return null;
+
+    const data = await response.json() as any;
+    const hostname = data.database?.Hostname;
+    if (hostname) return `libsql://${hostname}`;
+    return null;
+  } catch (e: any) {
+    if (e.message?.includes("Autenticacao Turso")) throw e;
+    return null;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Turso API: criar DB e retornar hostname real
+// POST /v1/organizations/{org}/databases
+// ═══════════════════════════════════════════════════════════════
+
+async function createDatabase(org: string, dbName: string): Promise<string> {
+  const group = process.env.TURSO_GROUP || "default";
+
+  const response = await fetch(
+    `${TURSO_API}/organizations/${org}/databases`,
+    {
+      method: "POST",
+      headers: tursoHeaders(),
+      body: JSON.stringify({ name: dbName, group }),
+    }
+  );
+
+  if (response.ok) {
+    console.log(`[codexa] Banco criado no Turso: ${dbName}`);
+    await new Promise((r) => setTimeout(r, 2000));
+
+    // Buscar hostname real (a resposta do POST pode nao ter o formato completo)
+    const url = await fetchDatabaseUrl(org, dbName);
+    if (url) return url;
+
+    // Fallback: construir URL sem regiao (pode funcionar em algumas configs)
+    return `libsql://${dbName}-${org}.turso.io`;
+  }
+
+  if (response.status === 409) {
+    // Ja existe — buscar hostname real
+    const url = await fetchDatabaseUrl(org, dbName);
+    if (url) return url;
+    return `libsql://${dbName}-${org}.turso.io`;
+  }
+
+  if (response.status === 401 || response.status === 403) {
+    const body = await response.text();
+    throw new Error(
+      `Autenticacao Turso falhou (${response.status}).\n` +
+      `  ${body}\n\n` +
+      "Verifique:\n" +
+      "  1. TURSO_AUTH_TOKEN esta correto e nao expirado\n" +
+      "  2. TURSO_ORG corresponde a sua organizacao no Turso\n\n" +
+      "  Gerar novo token: turso auth token"
+    );
+  }
+
+  const body = await response.text();
+  throw new Error(
+    `Falha ao criar banco no Turso (${response.status}): ${body}\n` +
+    `  DB: ${dbName} | Org: ${org} | Group: ${group}`
+  );
+}
+
 // ═══════════════════════════════════════════════════════════════
-// Provisioning: cria o DB no Turso se nao existir
-// Usa API-first (POST idempotente) para evitar bug de
-// compatibilidade Bun no @libsql/hrana-client (resp.body.cancel)
+// Provisioning: garante que o DB existe e resolve a URL real
 // ═══════════════════════════════════════════════════════════════
 
 export async function ensureDatabase(): Promise<void> {
   if (dbProvisioned) return;
 
-  const url = resolveDbUrl();
-
-  // Somente provisionar para URLs Turso (nao para file: ou :memory:)
-  if (!url.startsWith("libsql://")) {
+  // Se ja tem URL resolvida (env ou config), apenas marcar como provisionado
+  try {
+    resolveDbUrl();
     dbProvisioned = true;
     return;
+  } catch (e) {
+    if (!(e instanceof NeedsProvisioningError)) throw e;
   }
 
-  const authToken = process.env.TURSO_AUTH_TOKEN;
+  // Precisa provisionar via API
   const org = process.env.TURSO_ORG;
-  if (!authToken || !org) {
-    dbProvisioned = true;
-    return;
+  if (!org) {
+    throw new Error(
+      "Banco de dados nao configurado.\n\n" +
+      "Opcao 1 — Configurar automaticamente:\n" +
+      "  export TURSO_ORG=sua-org\n" +
+      "  export TURSO_AUTH_TOKEN=eyJ...\n" +
+      "  codexa init\n\n" +
+      "Opcao 2 — Configurar manualmente:\n" +
+      "  export CODEXA_DB_URL=libsql://seu-db.turso.io\n" +
+      "  export TURSO_AUTH_TOKEN=eyJ..."
+    );
   }
 
-  // Extrair nome do DB da URL: libsql://codexa-slug-org.turso.io → codexa-slug
-  const hostname = url.replace("libsql://", "").replace(".turso.io", "");
-  // O nome do DB no Turso e o hostname completo (sem .turso.io)
-  // Mas a API espera o nome curto. O hostname = name-org, entao name = hostname sem -org no final
-  const dbName = hostname.endsWith(`-${org}`)
-    ? hostname.slice(0, -(org.length + 1))
-    : hostname;
-
-  // API-first: tenta criar. 409 = ja existe (ok). 200 = criado.
-  // Isso evita o bug Bun no @libsql/hrana-client que ocorre quando
-  // tentamos conectar a um DB inexistente (resp.body?.cancel not a function)
-  const group = process.env.TURSO_GROUP || "default";
-  try {
-    const response = await fetch(
-      `https://api.turso.tech/v1/organizations/${org}/databases`,
-      {
-        method: "POST",
-        headers: {
-          "Authorization": `Bearer ${authToken}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({ name: dbName, group }),
-      }
-    );
+  const dbName = deriveDbNameFromGit();
 
-    if (response.ok) {
-      console.log(`[codexa] Banco criado no Turso: ${dbName}`);
-      // Aguardar um momento para o DB ficar disponivel
-      await new Promise((r) => setTimeout(r, 2000));
-    } else if (response.status === 409) {
-      // Ja existe — tudo certo
-    } else {
-      const body = await response.text();
-      console.error(`[codexa] Falha ao criar banco (${response.status}): ${body}`);
-    }
-  } catch (e: any) {
-    console.error(`[codexa] Erro ao provisionar banco: ${e.message}`);
+  // 1. Verificar se o DB ja existe
+  let url = await fetchDatabaseUrl(org, dbName);
+
+  // 2. Se nao existe, criar
+  if (!url) {
+    url = await createDatabase(org, dbName);
   }
 
+  // 3. Salvar no config para proximas execucoes
+  saveConfig(url);
   dbProvisioned = true;
+
+  // 4. Resetar client para usar a nova URL
+  if (client) {
+    client.close();
+    client = null;
+  }
 }
 
 // ═══════════════════════════════════════════════════════════════

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codexa/cli",
-  "version": "9.0.33",
+  "version": "9.0.34",
   "description": "Orchestrated workflow system for Claude Code - manages feature development through parallel subagents with structured phases, gates, and quality enforcement.",
   "type": "module",
   "bin": {