@offlocal/mcp 0.3.0 → 0.3.1

package/dist/detect.js

@@ -313,6 +313,8 @@ function pickNodeFramework(deps) {
         return "remix";
     if ("astro" in deps)
         return "astro";
+    if ("vite" in deps)
+        return "vite";
     if ("fastify" in deps)
         return "fastify";
     if ("hono" in deps)
@@ -321,8 +323,6 @@ function pickNodeFramework(deps) {
         return "express";
     if ("koa" in deps)
         return "koa";
-    if ("vite" in deps)
-        return "vite";
     return "node";
 }
 function nodePort(framework) {

package/dist/tools/deploy.js

@@ -72,13 +72,17 @@ export async function deployHandler(input) {
                     `| ${ICON.spark} Framework | ${summary.framework} (${summary.buildSource}) |\n` +
                     `| Port | ${summary.port} |\n` +
                     `| Bundle | ${summary.bundle.fileCount} files · ${summary.bundle.bytes} bytes |\n\n` +
+                    (bundle.warnings.length
+                        ? bundle.warnings.map((w) => `${ICON.warn} ${w}`).join("\n") + "\n\n"
+                        : "") +
                     `———\n` +
-                    `${ICON.arrow} **Next (you, the agent):** tell the user it's building (2–4 min) and you'll ` +
+                    `${ICON.arrow} **Next (you, the agent):** tell the user it's building (usually 2–8 min) and you'll ` +
                     `report back when it's live. Then:\n` +
                     `  1. Sleep 45 seconds.\n` +
                     `  2. \`offlocal_status({ deploymentId: "${summary.deploymentId}" })\`.\n` +
                     `  3. Sleep the \`pollAfterSeconds\` it returns, then call status again — exactly once per interval.\n` +
-                    `  4. Repeat until \`live\` or \`failed\`. Polling faster does NOT speed up the build.\n` +
+                    `  4. Repeat until \`live\` or \`failed\`. **Slow is normal — don't panic or declare failure on a slow deploy.** ` +
+                    `The status tool tells you if it's genuinely stuck; only then should you stop and suggest a retry.\n` +
                     `Keep the **projectId** from the live status for any database step.`,
             },
         ],

package/dist/tools/providers.js

@@ -110,7 +110,10 @@ export async function connectHandler(input) {
     };
 }
 export const ProvisionInputShape = {
-    provider: z.string().min(1).describe("The connected provider to provision on."),
+    provider: z
+        .string()
+        .min(1)
+        .describe("The CONNECTED external provider to provision on: supabase, planetscale, digitalocean, or railway. For Offlocal's own managed Postgres, use offlocal_create_managed_database instead — not this."),
     type: z
         .enum(["project", "database", "deployment", "env_vars", "branch"])
         .describe("The kind of resource to create."),
@@ -131,6 +134,11 @@ export const ProvisionInputShape = {
 };
 export async function provisionHandler(input) {
     const { provider, confirm, projectId, ...spec } = input;
+    if (["offlocal", "offlocal.ai"].includes(provider.toLowerCase())) {
+        return text(`${ICON.warn} "offlocal" isn't a provision provider. For an Offlocal Managed Postgres database, call ` +
+            `\`offlocal_create_managed_database({ projectId })\`. \`offlocal_provision\` is only for connected external ` +
+            `providers: **supabase, planetscale, digitalocean, railway**.`);
+    }
     const res = await provisionResource(provider, spec, {
         confirm: confirm ?? false,
         projectId,

package/dist/tools/status.js

@@ -24,6 +24,9 @@ export async function statusHandler(input) {
     const isTerminal = dep.status === "live" || dep.status === "failed";
     const pollAfterSeconds = isTerminal ? 0 : pollIntervalFor(dep.status);
     const etaSeconds = isTerminal ? 0 : etaFor(dep.status);
+    const secondsSinceUpdate = Math.max(0, Math.round((Date.now() - new Date(dep.updatedAt).getTime()) / 1000));
+    const STUCK_AFTER = 9 * 60;
+    const stalled = !isTerminal && secondsSinceUpdate > STUCK_AFTER;
     const summary = {
         deploymentId: dep.id,
         projectId: dep.projectId,
@@ -32,6 +35,8 @@ export async function statusHandler(input) {
         isTerminal,
         pollAfterSeconds,
         etaSeconds,
+        secondsSinceUpdate,
+        stalled,
         liveUrl: dep.liveUrl,
         errorType: dep.errorType,
         errorMessage: dep.errorMessage,
@@ -61,9 +66,19 @@ export async function statusHandler(input) {
         lines.push("");
         lines.push(bar);
         lines.push("");
-        lines.push(`Still in progress (typical end-to-end deploy: 2–4 min). Do NOT call this tool ` +
-            `again for at least ${pollAfterSeconds}s — polling doesn't speed it up. ` +
-            `Sleep ${pollAfterSeconds}s, then call it exactly once.`);
+        if (stalled) {
+            lines.push(`${ICON.warn} It's been at "${phase}" for ~${Math.round(secondsSinceUpdate / 60)} min with no change — ` +
+                `longer than a normal deploy. It may be stuck.\n` +
+                `Tell the user it's taking unusually long. You can wait a little longer, but do NOT keep polling indefinitely — ` +
+                `if it doesn't move within another couple of minutes, suggest re-running \`offlocal_deploy\` (a retry usually clears a stuck deploy).`);
+        }
+        else {
+            lines.push(`Building / rolling out — **this is normal and can take 2–8 minutes** (occasionally a bit more). Stay calm and don't treat slowness as failure:\n` +
+                `• A deploy is only failed when the status is literally **failed** — nothing else means it broke.\n` +
+                `• "starting container" can mean the container is already healthy but not yet promoted; it'll flip to **live** shortly.\n` +
+                `• Empty \`offlocal_logs\` during build / before live is expected (container logs only exist once it's running) — not an error.\n` +
+                `Sleep ${pollAfterSeconds}s, then call this exactly once. Polling faster does not help.`);
+        }
     }
     return {
         content: [{ type: "text", text: lines.join("\n") }],

package/dist/zip.js

@@ -20,13 +20,16 @@ const IGNORED_DIRS = new Set([
     ".idea",
     ".vscode",
 ]);
-const IGNORED_FILE_RE = /^(\.env(\..+)?|.*\.log|\.DS_Store|Thumbs\.db|.*\.tsbuildinfo)$/;
+const IGNORED_FILE_RE = /^(\.env(\..+)?|\.DS_Store|Thumbs\.db)$|\.(log|tsbuildinfo|exe|dll|dylib|so|msi|dmg|pdb|class|o|obj|lib)$/i;
 const MAX_FILE_BYTES = 50 * 1024 * 1024;
 const MAX_BUNDLE_BYTES = 250 * 1024 * 1024;
+const WARN_BUNDLE_BYTES = 25 * 1024 * 1024;
+const WARN_FILE_BYTES = 5 * 1024 * 1024;
 export async function bundleDirectory(sourceDir) {
     const zip = new AdmZip();
     let fileCount = 0;
     let totalBytes = 0;
+    const bigFiles = [];
     await walk(sourceDir, async (absolute) => {
         const rel = relative(sourceDir, absolute);
         if (!rel)
@@ -42,14 +45,26 @@ export async function bundleDirectory(sourceDir) {
         zip.addFile(zipPath, content);
         fileCount++;
         totalBytes += st.size;
+        if (st.size > WARN_FILE_BYTES)
+            bigFiles.push({ rel: zipPath, bytes: st.size });
         if (totalBytes > MAX_BUNDLE_BYTES) {
-            throw new Error(`bundle exceeds ${MAX_BUNDLE_BYTES} bytes. Trim node_modules-like outputs or add a .offlocalignore.`);
+            throw new Error(`bundle exceeds ${MAX_BUNDLE_BYTES} bytes. Trim node_modules-like outputs or add a .gitignore.`);
         }
     });
     if (fileCount === 0) {
         throw new Error(`no files to bundle under ${sourceDir}`);
     }
-    return { buffer: zip.toBuffer(), fileCount, byteSize: totalBytes };
+    const warnings = [];
+    if (totalBytes > WARN_BUNDLE_BYTES) {
+        warnings.push(`Bundle is ${mb(totalBytes)} — large for a deploy. Add a .gitignore for build output/binaries you don't need to ship.`);
+    }
+    for (const f of bigFiles.sort((a, b) => b.bytes - a.bytes).slice(0, 3)) {
+        warnings.push(`Large file bundled: ${f.rel} (${mb(f.bytes)}). Gitignore it if it isn't needed at runtime.`);
+    }
+    return { buffer: zip.toBuffer(), fileCount, byteSize: totalBytes, warnings };
+}
+function mb(bytes) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 async function walk(root, onFile) {
     const stack = [root];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@offlocal/mcp",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "MCP server for Offlocal - lets your AI coding agent deploy apps via offlocal_deploy, offlocal_status, offlocal_logs, offlocal_ping.",
   "keywords": [
     "mcp",