@nomad-e/bluma-cli 0.18.0 → 0.19.0

package/dist/config/skills/factorai-sh/SKILL.md

@@ -37,7 +37,7 @@ Always read `factorai.sh.json` in the project root before editing a deployed app
 2. edit_tool / file_write under ./my-app/ using shadcn components + semantic Tailwind (bg-background, etc.)
 3. Avoid npm run build before deploy (.next inflates ZIP); optional npx tsc --noEmit
 4. factorai.sh.deploy_app({ projectDir: "./my-app", name: "my-app" })
-5. Poll get_app_status until ready (see Polling)
+5. factorai.sh.get_app_status({ appId, wait: true }) until ready or failed (see Polling)
 6. message(result) with factor-sh-url-app from manifest after ready
 ```
 
@@ -53,7 +53,7 @@ Always read `factorai.sh.json` in the project root before editing a deployed app
      ],
      deploy: true,
    })
-4. Poll until building → ready
+4. get_app_status({ appId, wait: true }) until ready or failed
 5. message(result) with factor-sh-url-app from manifest after ready
 ```
 
@@ -67,9 +67,9 @@ Always read `factorai.sh.json` in the project root before editing a deployed app
 
 ## Polling checklist
 
-1. Call `factorai.sh.get_app_status({ appId })` every 5–10s
-2. Require seeing `building` after apply/deploy before trusting `ready`
-3. Verify the live route from `appContext.appUrl` (absolute URL); reject `Service Unavailable` JSON as "not live yet"
+1. Prefer `factorai.sh.get_app_status({ appId, wait: true })` — blocks until `ready` or `failed`
+2. On `failed`: read `data.typescriptErrors`, `data.buildLogTail`, `data.summary` — fix code, retry apply/deploy
+3. Do not report live URL until `data.success === true` and `data.status === "ready"`
 4. Typical rebuild: 30–90 seconds
 
 ## Tool reference

package/dist/main.js

@@ -20269,7 +20269,7 @@ async function uploadToSeverino(zipPath, severinoUrl, name, apiKey, appId) {
       name: data.name,
       status: data.status || "building",
       url: appContext.appUrl || severinoUrl.replace(/\/$/, "") + `/app/${resolvedAppId}`,
-      message: data.message || "Deploy iniciado",
+      message: data.message || "Deploy iniciado. Chama factorai.sh.get_app_status({ appId, wait: true }) at\xE9 status ready ou failed; se failed, l\xEA typescriptErrors/buildLogTail e corrige o c\xF3digo.",
       isRedeploy: !!appId,
       appContext
     };
@@ -20413,6 +20413,102 @@ async function deployApp(args) {
   }
 }
 
+// src/app/agent/runtime/factorai_deploy_feedback.ts
+var FAILED_STATUSES = /* @__PURE__ */ new Set(["failed", "error", "build_failed"]);
+var READY_STATUSES = /* @__PURE__ */ new Set(["ready", "running", "live"]);
+var BUILDING_STATUSES = /* @__PURE__ */ new Set(["building", "deploying", "installing", "pending"]);
+function extractTypeScriptErrors(logText) {
+  if (!logText.trim()) return [];
+  const lines = logText.split("\n");
+  const blocks = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.includes("Type error:") || line.includes("Failed to compile") || /^\s*>\s*\d+\s*\|/.test(line)) {
+      const start = Math.max(0, i - 3);
+      const end = Math.min(lines.length, i + 8);
+      blocks.push(lines.slice(start, end).join("\n").trim());
+    }
+  }
+  return [...new Set(blocks)].slice(0, 6);
+}
+function normalizeFactorAiAppStatus(raw, appId) {
+  const envelope = raw && typeof raw === "object" ? raw : {};
+  const data = envelope.data && typeof envelope.data === "object" && !Array.isArray(envelope.data) ? envelope.data : envelope;
+  const status = String(data.status ?? "unknown").toLowerCase();
+  const logs = typeof data.logs === "string" ? data.logs : "";
+  const logTail = logs.length > 12e3 ? logs.slice(-12e3) : logs;
+  const lastError = typeof data.lastError === "string" && data.lastError || typeof data.error === "string" && data.error || void 0;
+  const slug = typeof data.slug === "string" ? data.slug : void 0;
+  const url = typeof data.url === "string" ? data.url : void 0;
+  const tsErrors = extractTypeScriptErrors(logTail);
+  if (FAILED_STATUSES.has(status) || lastError) {
+    const error = lastError || tsErrors[0] || (logTail.includes("next build falhou") ? logTail.split("\n").slice(-5).join("\n") : "") || "Deploy/build failed on FactorAI.sh";
+    return {
+      success: false,
+      terminal: true,
+      status: "failed",
+      appId,
+      slug,
+      url,
+      error,
+      buildLogTail: logTail || void 0,
+      typescriptErrors: tsErrors.length > 0 ? tsErrors : void 0,
+      agentGuidance: "O build falhou no servidor. Corrige os erros TypeScript/compila\xE7\xE3o no projeto local (ex.: components/ui/card.tsx), confirma com npx tsc --noEmit se poss\xEDvel, depois factorai.sh.apply_app_changes ou deploy_app. N\xE3o digas ao utilizador que a app est\xE1 online."
+    };
+  }
+  if (READY_STATUSES.has(status)) {
+    return {
+      success: true,
+      terminal: true,
+      status: "ready",
+      appId,
+      slug,
+      url,
+      buildLogTail: logTail || void 0
+    };
+  }
+  if (BUILDING_STATUSES.has(status)) {
+    return {
+      success: true,
+      terminal: false,
+      status,
+      appId,
+      slug,
+      url,
+      buildLogTail: logTail || void 0
+    };
+  }
+  return {
+    success: true,
+    terminal: false,
+    status,
+    appId,
+    slug,
+    url,
+    buildLogTail: logTail || void 0
+  };
+}
+function formatFactorAiDeployStatusForAgent(result) {
+  const lines = [`status=${result.status}`, `appId=${result.appId}`];
+  if (result.slug) lines.push(`slug=${result.slug}`);
+  if (result.url) lines.push(`url=${result.url}`);
+  if (result.error) lines.push(`error=${result.error}`);
+  if (result.typescriptErrors?.length) {
+    lines.push("typescriptErrors:");
+    for (const block of result.typescriptErrors) {
+      lines.push(block);
+    }
+  } else if (result.buildLogTail) {
+    lines.push("buildLogTail:");
+    lines.push(result.buildLogTail);
+  }
+  if (result.agentGuidance) lines.push(`guidance=${result.agentGuidance}`);
+  return lines.join("\n");
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
 // src/app/agent/runtime/native_tool_catalog.ts
 init_sandbox_policy();
 function getFactorAiBaseUrl() {
@@ -20494,9 +20590,81 @@ async function resolveFactorAiAppId(explicitAppId) {
     "appId em falta: passa o UUID de factorai.sh.json (appContext.appId) ou faz deploy_app primeiro nesta sess\xE3o."
   );
 }
+function isFactorAiNotFoundError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /not found/i.test(msg) || /404/.test(msg);
+}
+async function fetchAndNormalizeAppStatus(appId) {
+  const payload = await requestFactorAi(`/api/v1/apps/${encodeURIComponent(appId)}`);
+  return normalizeFactorAiAppStatus(payload, appId);
+}
 async function factorAiGetAppStatus(args) {
   const appId = await resolveFactorAiAppId(args?.appId);
-  return requestFactorAi(`/api/v1/apps/${encodeURIComponent(appId)}`);
+  const wait = args?.wait === true;
+  const timeoutMs = Math.max(5, args?.timeoutSeconds ?? 480) * 1e3;
+  const pollMs = Math.max(2, args?.pollIntervalSeconds ?? 5) * 1e3;
+  const deadline = Date.now() + timeoutMs;
+  const finalize = (result) => ({
+    success: true,
+    data: {
+      ...result,
+      summary: formatFactorAiDeployStatusForAgent(result)
+    }
+  });
+  if (!wait) {
+    try {
+      return finalize(await fetchAndNormalizeAppStatus(appId));
+    } catch (err) {
+      if (isFactorAiNotFoundError(err)) {
+        return finalize({
+          success: false,
+          terminal: true,
+          status: "failed",
+          appId,
+          error: String(err instanceof Error ? err.message : err),
+          agentGuidance: "App n\xE3o encontrada no FactorAI.sh \u2014 o deploy provavelmente falhou e o registo foi limpo, ou o appId est\xE1 errado. L\xEA factorai.sh.json, confirma FACTORAI_BASE_URL=SEVERINO_URL, e faz deploy de novo ap\xF3s corrigir o c\xF3digo."
+        });
+      }
+      throw err;
+    }
+  }
+  let sawBuilding = false;
+  while (Date.now() < deadline) {
+    try {
+      const result = await fetchAndNormalizeAppStatus(appId);
+      if (!result.terminal && result.status !== "failed") {
+        sawBuilding = true;
+      }
+      if (result.terminal) {
+        if (result.status === "ready" && !sawBuilding) {
+          await sleep(pollMs);
+          continue;
+        }
+        return finalize(result);
+      }
+    } catch (err) {
+      if (isFactorAiNotFoundError(err)) {
+        return finalize({
+          success: false,
+          terminal: true,
+          status: "failed",
+          appId,
+          error: String(err instanceof Error ? err.message : err),
+          agentGuidance: "Deploy falhou: a app desapareceu do registry (build error no servidor). Corrige o c\xF3digo e volta a deploy_app."
+        });
+      }
+      throw err;
+    }
+    await sleep(pollMs);
+  }
+  return finalize({
+    success: true,
+    terminal: false,
+    status: "building",
+    appId,
+    error: `Timeout ap\xF3s ${Math.round(timeoutMs / 1e3)}s \xE0 espera de ready/failed`,
+    agentGuidance: "Continua a pollar get_app_status ou verifica logs no FactorAI.sh."
+  });
 }
 async function factorAiApplyAppChanges(args) {
   const appId = await resolveFactorAiAppId(args?.appId);
@@ -20512,7 +20680,13 @@ async function factorAiApplyAppChanges(args) {
     })
   });
   await persistFactorAiWorkspaceManifestFromResponse(response);
-  return response;
+  const normalized = normalizeFactorAiAppStatus(response, appId);
+  const summary = formatFactorAiDeployStatusForAgent(normalized);
+  const message2 = args?.deploy !== false && !normalized.terminal ? "Changes accepted; build em curso. Chama factorai.sh.get_app_status({ wait: true }) at\xE9 ready ou failed." : normalized.success ? "Changes applied" : normalized.error;
+  return {
+    success: true,
+    data: { ...normalized, summary, message: message2 }
+  };
 }
 async function factorAiRedeployApp(args) {
   const appId = await resolveFactorAiAppId(args?.appId);
@@ -20520,7 +20694,13 @@ async function factorAiRedeployApp(args) {
     method: "POST"
   });
   await persistFactorAiWorkspaceManifestFromResponse(response);
-  return response;
+  const normalized = normalizeFactorAiAppStatus(response, appId);
+  const summary = formatFactorAiDeployStatusForAgent(normalized);
+  const message2 = normalized.terminal ? normalized.success ? "Redeploy complete" : normalized.error : "Redeploy started; poll get_app_status({ wait: true }).";
+  return {
+    success: true,
+    data: { ...normalized, summary, message: message2 }
+  };
 }
 function extractFactorAiResponseData(response) {
   if (response && typeof response === "object" && response.data && typeof response.data === "object") {
@@ -20607,13 +20787,25 @@ function getFactorAiSandboxToolDefinitions() {
       type: "function",
       function: {
         name: "factorai.sh.get_app_status",
-        description: "Poll deploy/rebuild status (building|ready|failed). Call after deploy_app or apply_app_changes until ready before telling the user the app is live.",
+        description: "Poll deploy/rebuild status. On failed returns buildLogTail + typescriptErrors so you can fix code. Use wait:true after deploy_app/apply_app_changes until ready or failed before message(result).",
         parameters: {
           type: "object",
           properties: {
             appId: {
               type: "string",
               description: "UUID from factorai.sh.json (appContext.appId). Optional if manifest exists in cwd. Do not use URL slug."
+            },
+            wait: {
+              type: "boolean",
+              description: "If true, poll until ready/failed/timeout (recommended after deploy)."
+            },
+            timeoutSeconds: {
+              type: "number",
+              description: "Max wait time when wait=true (default 480)."
+            },
+            pollIntervalSeconds: {
+              type: "number",
+              description: "Seconds between polls when wait=true (default 5)."
             }
           },
           required: [],
@@ -23791,11 +23983,11 @@ Use \`factorai.sh.redeploy_app({ appId })\` only when sources on the server are
 
 ## Polling after deploy / apply_app_changes
 
-1. \`factorai.sh.get_app_status({ appId })\` or GET \`/api/v1/apps/{appId}\`.
+1. **Always** \`factorai.sh.get_app_status({ appId, wait: true })\` after \`deploy_app\` or \`apply_app_changes\` (polls at\xE9 \`ready\` ou \`failed\`).
 2. Expect \`status: "building"\` during \`npm install\` / \`next build\` (~30\u201390s).
-3. **Do not** report "live" on the first \`ready\` if you have not seen \`building\` since this operation \u2014 stale \`ready\` can appear briefly.
-4. Wait until \`status\` is \`ready\` (or \`running\` / \`live\`) **after** a \`building\` phase, then verify the public route returns HTML (not \`Service Unavailable\`).
-5. On \`failed\` / \`error\`: read server/build logs if available; fix TS/scaffold issues; retry \`apply_app_changes\` or \`redeploy_app\`.
+3. **Do not** report "live" until \`success: true\` and \`status: "ready"\` no resultado do \`get_app_status\`.
+4. On \`success: false\` / \`status: "failed"\`: read \`typescriptErrors\`, \`buildLogTail\`, and \`summary\` from the tool result \u2014 fix the code like a human reading the Next build log, then \`apply_app_changes\` or \`deploy_app\` again.
+5. Never ignore deploy failures; never tell the user the app is online when \`get_app_status\` returned \`failed\`.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nomad-e/bluma-cli",
-	"version": "0.18.0",
+	"version": "0.19.0",
 	"description": "BluMa independent agent for automation and advanced software engineering.",
 	"author": "Alex Fonseca",
 	"license": "Apache-2.0",