@codexa/cli 9.0.32 → 9.0.34

package/db/connection.ts

@@ -4,9 +4,13 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 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 {
@@ -14,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"));
@@ -22,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 });
@@ -72,58 +61,164 @@ 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",
+  };
+}
+
 // ═══════════════════════════════════════════════════════════════
-// Provisioning: cria o DB no Turso se nao existir
+// Turso API: buscar hostname real do DB (inclui regiao)
+// GET /v1/organizations/{org}/databases/{name}
+// Retorna { database: { Hostname: "name-org.region.turso.io" } }
 // ═══════════════════════════════════════════════════════════════
 
-export async function ensureDatabase(): Promise<void> {
-  const url = resolveDbUrl();
+async function fetchDatabaseUrl(org: string, dbName: string): Promise<string | null> {
+  try {
+    const response = await fetch(
+      `${TURSO_API}/organizations/${org}/databases/${dbName}`,
+      { headers: tursoHeaders() }
+    );
 
-  // Somente provisionar para URLs Turso (nao para file: ou :memory:)
-  if (!url.startsWith("libsql://")) return;
+    if (response.status === 404) return null;
 
-  const authToken = process.env.TURSO_AUTH_TOKEN;
-  const org = process.env.TURSO_ORG;
-  if (!authToken || !org) return;
+    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"
+      );
+    }
 
-  // Extrair nome do DB da URL: libsql://codexa-slug-org.turso.io → codexa-slug
-  const hostMatch = url.match(/^libsql:\/\/(.+)-[^-]+\.turso\.io$/);
-  if (!hostMatch) return;
-  const dbName = hostMatch[1];
+    if (!response.ok) return null;
 
-  // Tentar conectar primeiro — se o DB ja existe, nao precisa criar
-  try {
-    const testClient = createClient({ url, authToken });
-    await testClient.execute("SELECT 1");
-    testClient.close();
-    return;
-  } catch { /* DB nao existe, criar */ }
+    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
+// ═══════════════════════════════════════════════════════════════
 
-  // Criar via Turso Platform API
+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: garante que o DB existe e resolve a URL real
+// ═══════════════════════════════════════════════════════════════
+
+export async function ensureDatabase(): Promise<void> {
+  if (dbProvisioned) return;
+
+  // Se ja tem URL resolvida (env ou config), apenas marcar como provisionado
   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 }),
-      }
+    resolveDbUrl();
+    dbProvisioned = true;
+    return;
+  } catch (e) {
+    if (!(e instanceof NeedsProvisioningError)) throw e;
+  }
+
+  // Precisa provisionar via API
+  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..."
     );
+  }
 
-    if (response.ok) {
-      console.log(`[codexa] Banco criado no Turso: ${dbName}`);
-    } 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}`);
+  const dbName = deriveDbNameFromGit();
+
+  // 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;
   }
 }
 
@@ -153,10 +248,12 @@ export function closeDb(): void {
 
 export function resetClient(): void {
   client = null;
+  dbProvisioned = false;
 }
 
 export function setClient(c: Client): void {
   client = c;
+  dbProvisioned = true;
 }
 
 export function getResolvedDbUrl(): string {

package/db/schema.ts

@@ -1,7 +1,8 @@
 import type { Client, Transaction } from "@libsql/client";
-import { getDb, setClient, dbGet, dbAll, dbRun, dbExec } from "./connection";
+import { getDb, setClient, dbGet, dbAll, dbRun, dbExec, ensureDatabase } from "./connection";
 
 export async function initSchema(): Promise<void> {
+  await ensureDatabase();
   await dbExec(`
     CREATE TABLE IF NOT EXISTS specs (
       id TEXT PRIMARY KEY,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codexa/cli",
-  "version": "9.0.32",
+  "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": {