@offlocal/mcp 0.1.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # @offlocal/mcp
 
-The MCP (Model Context Protocol) server for [Offlocal](https://offlocal.ai) —
+The MCP (Model Context Protocol) server for [Offlocal](https://offlocal.ai) -
 lets your AI coding agent (Claude Code, Cursor, Codex, Windsurf, etc.) deploy
 apps directly from a coding session.
 

package/dist/client.js

@@ -18,7 +18,7 @@ export async function pingApi() {
             const body = await res.text().catch(() => "");
             return {
                 ok: false,
-                reason: `${res.status} ${res.statusText} from ${url}${body ? ` — ${body.slice(0, 200)}` : ""}`,
+                reason: `${res.status} ${res.statusText} from ${url}${body ? ` - ${body.slice(0, 200)}` : ""}`,
             };
         }
         const data = (await res.json());
@@ -28,7 +28,7 @@ export async function pingApi() {
         const message = err instanceof Error ? err.message : String(err);
         return {
             ok: false,
-            reason: `fetch ${url} failed — ${message}`,
+            reason: `fetch ${url} failed - ${message}`,
         };
     }
 }
@@ -77,8 +77,107 @@ export async function getDeploymentLogs(deploymentId, options) {
     const json = (await res.json());
     return json.logs;
 }
+export async function listConnections() {
+    const res = await fetch(`${API_URL}/api/providers`, {
+        headers: { ...authHeaders() },
+    });
+    if (!res.ok)
+        throw new Error(await failureText(res, "list_connections"));
+    const json = (await res.json());
+    return json.providers;
+}
+export async function resolveRequirement(need) {
+    const res = await fetch(`${API_URL}/api/providers/resolve?need=${encodeURIComponent(need)}`, { headers: { ...authHeaders() } });
+    if (!res.ok)
+        throw new Error(await failureText(res, "resolve_requirement"));
+    return (await res.json());
+}
+export async function getConnectLink(provider) {
+    const res = await fetch(`${API_URL}/api/providers/${encodeURIComponent(provider)}/connect-link`, { headers: { ...authHeaders() } });
+    if (!res.ok)
+        throw new Error(await failureText(res, "connect_link"));
+    return (await res.json());
+}
+export async function provisionResource(provider, spec, opts) {
+    const res = await fetch(`${API_URL}/api/providers/${encodeURIComponent(provider)}/provision`, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...authHeaders() },
+        body: JSON.stringify({
+            ...spec,
+            confirm: opts?.confirm ?? false,
+            projectId: opts?.projectId,
+        }),
+    });
+    if (!res.ok && res.status !== 502) {
+        throw new Error(await failureText(res, "provision"));
+    }
+    return (await res.json());
+}
+export async function pollProvision(actionId) {
+    const res = await fetch(`${API_URL}/api/providers/provision/${encodeURIComponent(actionId)}/poll`, { method: "POST", headers: { ...authHeaders() } });
+    if (!res.ok && res.status !== 502) {
+        throw new Error(await failureText(res, "poll_provision"));
+    }
+    return (await res.json());
+}
+export async function getPreferences() {
+    const res = await fetch(`${API_URL}/api/me/preferences`, {
+        headers: { ...authHeaders() },
+    });
+    if (!res.ok)
+        return {};
+    const json = (await res.json());
+    return json.preferences ?? {};
+}
+export async function setPreference(capability, platform) {
+    const res = await fetch(`${API_URL}/api/me/preferences`, {
+        method: "PUT",
+        headers: { "content-type": "application/json", ...authHeaders() },
+        body: JSON.stringify({ capability, platform }),
+    });
+    if (!res.ok)
+        throw new Error(await failureText(res, "set_preference"));
+}
+export async function createManagedDatabase(projectId) {
+    const res = await fetch(`${API_URL}/api/projects/${encodeURIComponent(projectId)}/database/create`, { method: "POST", headers: { ...authHeaders() } });
+    const json = (await res.json().catch(() => ({})));
+    if (!res.ok) {
+        return { error: json.error ?? String(res.status), message: json.message };
+    }
+    return json;
+}
+export async function setProjectEnv(projectId, vars) {
+    const res = await fetch(`${API_URL}/api/projects/${encodeURIComponent(projectId)}/env`, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...authHeaders() },
+        body: JSON.stringify({ vars }),
+    });
+    const json = (await res.json().catch(() => ({})));
+    if (!res.ok)
+        return { error: json.error ?? String(res.status), message: json.message };
+    return json;
+}
+export async function rollback(projectId, toDeploymentId) {
+    const res = await fetch(`${API_URL}/api/projects/${encodeURIComponent(projectId)}/rollback`, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...authHeaders() },
+        body: JSON.stringify(toDeploymentId ? { toDeploymentId } : {}),
+    });
+    const json = (await res.json().catch(() => ({})));
+    if (!res.ok) {
+        return { error: json.error ?? String(res.status), message: json.message };
+    }
+    return json;
+}
+export async function getPlanInfo() {
+    const res = await fetch(`${API_URL}/api/me/plan`, {
+        headers: { ...authHeaders() },
+    });
+    if (!res.ok)
+        throw new Error(await failureText(res, "get_plan"));
+    return (await res.json());
+}
 async function failureText(res, kind) {
     const body = await res.text().catch(() => "");
-    return `${kind} failed: ${res.status} ${res.statusText}${body ? ` — ${body.slice(0, 400)}` : ""}`;
+    return `${kind} failed: ${res.status} ${res.statusText}${body ? ` - ${body.slice(0, 400)}` : ""}`;
 }
-//# sourceMappingURL=client.js.map

package/dist/detect.js

@@ -1,46 +1,310 @@
-import { readFile, stat } from "node:fs/promises";
+import { readdir, readFile, stat } from "node:fs/promises";
 import { basename, join } from "node:path";
-const DEFAULTS = {
-    runtime: "node-20",
-    framework: "node",
-    buildCommand: "echo no-build",
-    startCommand: "npm start",
-    port: 3000,
-};
+const NO_BUILD = "echo no-build";
+const FROM_DOCKERFILE = "(provided by Dockerfile)";
 export async function detect(sourceDir) {
-    const pkgPath = join(sourceDir, "package.json");
-    let pkg = null;
-    if (await fileExists(pkgPath)) {
+    const appName = await resolveAppName(sourceDir);
+    const hasDockerfile = await fileExists(join(sourceDir, "Dockerfile"));
+    if (hasDockerfile) {
+        const dockerfile = await readTextSafe(join(sourceDir, "Dockerfile"));
+        return {
+            appName,
+            runtime: "dockerfile",
+            framework: "dockerfile",
+            buildCommand: FROM_DOCKERFILE,
+            startCommand: FROM_DOCKERFILE,
+            port: parseExpose(dockerfile) ?? 3000,
+            strategy: "dockerfile",
+            hasDockerfile: true,
+        };
+    }
+    if (await fileExists(join(sourceDir, "package.json"))) {
+        return { ...(await detectNode(sourceDir, appName)), hasDockerfile: false };
+    }
+    if ((await fileExists(join(sourceDir, "requirements.txt"))) ||
+        (await fileExists(join(sourceDir, "pyproject.toml"))) ||
+        (await fileExists(join(sourceDir, "Pipfile")))) {
+        return { ...(await detectPython(sourceDir, appName)), hasDockerfile: false };
+    }
+    if (await fileExists(join(sourceDir, "go.mod"))) {
+        return {
+            appName,
+            runtime: "go-1.22",
+            framework: "go",
+            buildCommand: NO_BUILD,
+            startCommand: "/usr/local/bin/app",
+            port: 8080,
+            strategy: "template",
+            hasDockerfile: false,
+        };
+    }
+    if (await fileExists(join(sourceDir, "Cargo.toml"))) {
+        return {
+            appName,
+            runtime: "rust-1",
+            framework: "rust",
+            buildCommand: NO_BUILD,
+            startCommand: "/usr/local/bin/app",
+            port: 8080,
+            strategy: "template",
+            hasDockerfile: false,
+        };
+    }
+    if (await fileExists(join(sourceDir, "index.html"))) {
+        return {
+            appName,
+            runtime: "static",
+            framework: "static",
+            buildCommand: NO_BUILD,
+            startCommand: "nginx -g 'daemon off;'",
+            port: 80,
+            strategy: "template",
+            hasDockerfile: false,
+        };
+    }
+    return {
+        appName,
+        runtime: "unknown",
+        framework: "unknown",
+        buildCommand: NO_BUILD,
+        startCommand: NO_BUILD,
+        port: 3000,
+        strategy: "unknown",
+        hasDockerfile: false,
+    };
+}
+export async function detectRequirements(sourceDir) {
+    let deps = {};
+    try {
+        const pkg = JSON.parse(await readFile(join(sourceDir, "package.json"), "utf8"));
+        deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+    }
+    catch {
+        deps = {};
+    }
+    const has = (name) => name in deps;
+    const prisma = await readTextSafe(join(sourceDir, "prisma", "schema.prisma"));
+    const prismaProvider = /provider\s*=\s*"(postgresql|mysql|sqlite|mongodb)"/i
+        .exec(prisma)?.[1]
+        ?.toLowerCase();
+    const envText = ((await readTextSafe(join(sourceDir, ".env.example"))) +
+        "\n" +
+        (await readTextSafe(join(sourceDir, ".env")))).toLowerCase();
+    const reqs = [];
+    const wantsPg = has("pg") ||
+        has("postgres") ||
+        prismaProvider === "postgresql" ||
+        /database_url\s*=\s*['"]?postgres/.test(envText);
+    const wantsMysql = has("mysql2") ||
+        has("mysql") ||
+        has("@planetscale/database") ||
+        prismaProvider === "mysql" ||
+        /database_url\s*=\s*['"]?mysql/.test(envText);
+    const wantsGenericDb = has("@prisma/client") ||
+        has("prisma") ||
+        has("drizzle-orm") ||
+        has("typeorm") ||
+        has("sequelize") ||
+        has("knex") ||
+        /\bdatabase_url\b/.test(envText);
+    if (wantsPg)
+        reqs.push({ capability: "postgres", reason: "Postgres driver/ORM detected" });
+    else if (wantsMysql)
+        reqs.push({ capability: "mysql", reason: "MySQL driver detected" });
+    else if (wantsGenericDb)
+        reqs.push({ capability: "postgres", reason: "the app reads DATABASE_URL" });
+    if (has("redis") || has("ioredis")) {
+        reqs.push({ capability: "redis", reason: "Redis client detected" });
+    }
+    return reqs;
+}
+const WEB_FRAMEWORKS = new Set([
+    "nextjs",
+    "nuxt",
+    "remix",
+    "astro",
+    "vite",
+    "static",
+]);
+const API_FRAMEWORKS = new Set(["fastify", "hono", "express", "koa", "nestjs"]);
+const COMPONENT_DIRS = ["apps", "packages", "services"];
+export async function detectComponents(sourceDir) {
+    const candidates = await collectComponentDirs(sourceDir);
+    const components = [];
+    const seen = new Set();
+    for (const dir of candidates) {
+        if (seen.has(dir))
+            continue;
+        seen.add(dir);
+        const app = await detect(dir);
+        if (app.framework === "unknown" && dir !== sourceDir)
+            continue;
+        components.push({
+            name: componentName(sourceDir, dir),
+            relPath: relPath(sourceDir, dir),
+            absPath: dir,
+            role: roleFor(app.framework),
+            framework: app.framework,
+        });
+    }
+    if (components.length === 0) {
+        const app = await detect(sourceDir);
+        return [
+            {
+                name: "app",
+                relPath: "",
+                absPath: sourceDir,
+                role: roleFor(app.framework),
+                framework: app.framework,
+            },
+        ];
+    }
+    if (components.length === 1)
+        return components;
+    const roles = new Set(components.map((c) => c.role));
+    if (roles.size < 2 && !components.some((c) => c.relPath !== "")) {
+        return [components[0]];
+    }
+    return components;
+}
+async function collectComponentDirs(sourceDir) {
+    const out = [];
+    const rootPkg = await readJsonSafe(join(sourceDir, "package.json"));
+    const hasWorkspaces = Boolean(rootPkg?.workspaces) ||
+        (await fileExists(join(sourceDir, "pnpm-workspace.yaml"))) ||
+        (await fileExists(join(sourceDir, "turbo.json")));
+    if (!hasWorkspaces) {
+        if (rootPkg && (rootPkg.dependencies || rootPkg.scripts))
+            out.push(sourceDir);
+        return out;
+    }
+    for (const base of COMPONENT_DIRS) {
+        const baseDir = join(sourceDir, base);
+        let entries = [];
         try {
-            const raw = await readFile(pkgPath, "utf8");
-            pkg = JSON.parse(raw);
+            entries = (await readdir(baseDir, { withFileTypes: true }))
+                .filter((e) => e.isDirectory())
+                .map((e) => e.name);
         }
         catch {
-            pkg = null;
+            continue;
         }
+        for (const name of entries) {
+            const dir = join(baseDir, name);
+            if ((await fileExists(join(dir, "package.json"))) ||
+                (await fileExists(join(dir, "Dockerfile"))) ||
+                (await fileExists(join(dir, "go.mod"))) ||
+                (await fileExists(join(dir, "requirements.txt")))) {
+                out.push(dir);
+            }
+        }
+    }
+    return out;
+}
+function roleFor(framework) {
+    if (WEB_FRAMEWORKS.has(framework))
+        return "web";
+    if (API_FRAMEWORKS.has(framework))
+        return "api";
+    return "app";
+}
+export function apiUrlEnvVar(framework) {
+    switch (framework) {
+        case "nextjs":
+            return { key: "NEXT_PUBLIC_API_URL", buildTime: true };
+        case "vite":
+            return { key: "VITE_API_URL", buildTime: true };
+        case "nuxt":
+            return { key: "NUXT_PUBLIC_API_URL", buildTime: true };
+        case "astro":
+            return { key: "PUBLIC_API_URL", buildTime: true };
+        default:
+            return { key: "API_URL", buildTime: false };
+    }
+}
+function componentName(root, dir) {
+    if (dir === root)
+        return "root";
+    const raw = basename(dir).toLowerCase();
+    if (["frontend", "client", "site", "www", "ui"].includes(raw))
+        return "web";
+    if (["backend", "server", "service"].includes(raw))
+        return "api";
+    return raw.replace(/[^a-z0-9-]+/g, "-") || "app";
+}
+function relPath(root, dir) {
+    if (dir === root)
+        return "";
+    const r = dir.slice(root.length).replace(/^[\\/]+/, "").replace(/\\/g, "/");
+    return r;
+}
+async function readJsonSafe(path) {
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function detectNode(sourceDir, appName) {
+    let pkg = null;
+    try {
+        pkg = JSON.parse(await readFile(join(sourceDir, "package.json"), "utf8"));
+    }
+    catch {
+        pkg = null;
     }
-    const appName = pkg?.name ?? slugifyDirName(sourceDir) ?? "app";
     const deps = {
         ...(pkg?.dependencies ?? {}),
         ...(pkg?.devDependencies ?? {}),
     };
     const scripts = pkg?.scripts ?? {};
-    const framework = pickFramework(deps);
-    const port = portFor(framework);
-    const buildCommand = scripts.build ? "npm run build" : DEFAULTS.buildCommand;
-    const startCommand = scripts.start
-        ? "npm start"
-        : pickFallbackStart(framework);
+    const framework = pickNodeFramework(deps);
+    return {
+        appName: pkg?.name ?? appName,
+        runtime: "node-20",
+        framework,
+        buildCommand: scripts.build ? "npm run build" : NO_BUILD,
+        startCommand: scripts.start ? "npm start" : nodeFallbackStart(framework),
+        port: nodePort(framework),
+        strategy: "template",
+    };
+}
+async function detectPython(sourceDir, appName) {
+    const manifest = ((await readTextSafe(join(sourceDir, "requirements.txt"))) +
+        "\n" +
+        (await readTextSafe(join(sourceDir, "pyproject.toml"))) +
+        "\n" +
+        (await readTextSafe(join(sourceDir, "Pipfile")))).toLowerCase();
+    const hasManage = await fileExists(join(sourceDir, "manage.py"));
+    let framework = "python";
+    let startCommand = "python app.py";
+    if (hasManage || manifest.includes("django")) {
+        framework = "django";
+        startCommand = "python manage.py runserver 0.0.0.0:$PORT";
+    }
+    else if (manifest.includes("fastapi")) {
+        framework = "fastapi";
+        startCommand = "uvicorn main:app --host 0.0.0.0 --port $PORT";
+    }
+    else if (manifest.includes("flask")) {
+        framework = "flask";
+        startCommand = "gunicorn app:app -b 0.0.0.0:$PORT";
+    }
+    else if (await fileExists(join(sourceDir, "main.py"))) {
+        startCommand = "python main.py";
+    }
     return {
         appName,
-        runtime: DEFAULTS.runtime,
+        runtime: "python-3.12",
         framework,
-        buildCommand,
+        buildCommand: NO_BUILD,
         startCommand,
-        port,
+        port: 8000,
+        strategy: "template",
     };
 }
-function pickFramework(deps) {
+function pickNodeFramework(deps) {
     if ("next" in deps)
         return "nextjs";
     if ("nuxt" in deps)
@@ -61,41 +325,60 @@ function pickFramework(deps) {
         return "vite";
     return "node";
 }
-function portFor(framework) {
+function nodePort(framework) {
     switch (framework) {
-        case "nextjs":
-            return 3000;
-        case "nuxt":
-            return 3000;
-        case "remix":
-            return 3000;
         case "astro":
             return 4321;
         case "vite":
             return 4173;
-        case "fastify":
-            return 3000;
-        case "hono":
-            return 3000;
-        case "express":
-            return 3000;
-        case "koa":
-            return 3000;
         default:
             return 3000;
     }
 }
-function pickFallbackStart(framework) {
+function nodeFallbackStart(framework) {
     if (framework === "nextjs")
         return "npx next start";
     if (framework === "nuxt")
         return "node .output/server/index.mjs";
     return "node index.js";
 }
+async function resolveAppName(sourceDir) {
+    try {
+        const pkg = JSON.parse(await readFile(join(sourceDir, "package.json"), "utf8"));
+        if (pkg.name)
+            return pkg.name;
+    }
+    catch {
+    }
+    const cargo = await readTextSafe(join(sourceDir, "Cargo.toml"));
+    const cargoName = /name\s*=\s*"([^"]+)"/.exec(cargo)?.[1];
+    if (cargoName)
+        return cargoName;
+    const pyproject = await readTextSafe(join(sourceDir, "pyproject.toml"));
+    const pyName = /name\s*=\s*"([^"]+)"/.exec(pyproject)?.[1];
+    if (pyName)
+        return pyName;
+    return slugifyDirName(sourceDir) ?? "app";
+}
+function parseExpose(dockerfile) {
+    const m = /^\s*EXPOSE\s+(\d{1,5})/im.exec(dockerfile);
+    if (!m)
+        return null;
+    const port = Number.parseInt(m[1], 10);
+    return port >= 1 && port <= 65535 ? port : null;
+}
 function slugifyDirName(dir) {
     const name = basename(dir).toLowerCase().replace(/[^a-z0-9-]+/g, "-");
     return name || null;
 }
+async function readTextSafe(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
 async function fileExists(path) {
     try {
         await stat(path);
@@ -105,4 +388,3 @@ async function fileExists(path) {
         return false;
     }
 }
-//# sourceMappingURL=detect.js.map

package/dist/index.js

@@ -3,25 +3,53 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { pingApi } from "./client.js";
-import { DeployInputShape, deployHandler } from "./tools/deploy.js";
+import { DeployInputShape, RollbackInputShape, deployHandler, rollbackHandler, } from "./tools/deploy.js";
+import { PlansInputShape, plansHandler } from "./tools/plans.js";
 import { StatusInputShape, statusHandler } from "./tools/status.js";
 import { LogsInputShape, logsHandler } from "./tools/logs.js";
 import { PingInputShape, pingHandler } from "./tools/ping.js";
+import { ConnectInputShape, CreateManagedDatabaseInputShape, ListConnectionsInputShape, ProvisionInputShape, ProvisionStatusInputShape, ResolveRequirementInputShape, SetEnvInputShape, connectHandler, createManagedDatabaseHandler, listConnectionsHandler, provisionHandler, provisionStatusHandler, resolveRequirementHandler, setEnvHandler, } from "./tools/providers.js";
+import { PlanInputShape, SetPreferenceInputShape, planHandler, setPreferenceHandler, } from "./tools/plan.js";
 const DeploySchema = z.object(DeployInputShape);
 const StatusSchema = z.object(StatusInputShape);
 const LogsSchema = z.object(LogsInputShape);
 const PingSchema = z.object(PingInputShape);
+const ResolveRequirementSchema = z.object(ResolveRequirementInputShape);
+const ConnectSchema = z.object(ConnectInputShape);
+const ProvisionSchema = z.object(ProvisionInputShape);
+const ProvisionStatusSchema = z.object(ProvisionStatusInputShape);
+const CreateManagedDatabaseSchema = z.object(CreateManagedDatabaseInputShape);
+const SetEnvSchema = z.object(SetEnvInputShape);
+const PlanSchema = z.object(PlanInputShape);
+const SetPreferenceSchema = z.object(SetPreferenceInputShape);
+const RollbackSchema = z.object(RollbackInputShape);
+const PlansSchema = z.object(PlansInputShape);
 async function main() {
     const server = new McpServer({
         name: "offlocal",
         version: "0.1.0",
     });
-    server.tool("offlocal_ping", "Verify the Offlocal connection. Returns the signed-in email if connected, or an error message if not. This tool does NOT deploy anything, upload anything, or call AWS — it is the right tool to call when the user asks to 'check my Offlocal connection' or similar.", PingInputShape, async (args) => pingHandler(PingSchema.parse(args)));
-    server.tool("offlocal_deploy", "Deploy an app from a local directory to Offlocal. Returns a deploymentId you can poll with offlocal_status. Detects runtime/framework/port automatically; you can override appName and port. Only call this when the user explicitly asks to deploy.", DeployInputShape, async (args) => deployHandler(DeploySchema.parse(args)));
+    server.tool("offlocal_ping", "Verify the Offlocal connection. Returns the signed-in email if connected, or an error message if not. This tool does NOT deploy anything, upload anything, or provision any resources - it is the right tool to call when the user asks to 'check my Offlocal connection' or similar.", PingInputShape, async (args) => pingHandler(PingSchema.parse(args)));
+    server.tool("offlocal_plan", "START HERE when the user asks to deploy/ship/set up a project. Detects the app + the resources it needs (e.g. a Postgres database), applies the user's saved platform preferences, and returns a complete proposed plan (which platform for each piece — Offlocal.ai by default, or Supabase/PlanetScale/DigitalOcean/Railway). Present the plan to the user verbatim and let them confirm with 'go' or switch any line. Then execute the steps the plan lists. Do NOT deploy or provision anything until the user confirms the plan.", PlanInputShape, async (args) => planHandler(PlanSchema.parse(args)));
+    server.tool("offlocal_set_preference", "Remember the user's platform choice for a capability (e.g. capability:'postgres', platform:'supabase'), so future plans default to it. Call this when the user says 'use X for Y', then re-run offlocal_plan.", SetPreferenceInputShape, async (args) => setPreferenceHandler(SetPreferenceSchema.parse(args)));
+    server.tool("offlocal_deploy", "Deploy an app from a local directory to Offlocal. Returns a deploymentId you can poll with offlocal_status. Supports Node, Python, Go, Rust, and static sites out of the box (auto-detecting runtime/framework/port), and uses the project's own Dockerfile as-is when one exists. For an unrecognized stack with no Dockerfile, it returns instructions asking you to add a Dockerfile and re-run - follow them, then call this again. You can override appName and port. Only call this when the user explicitly asks to deploy.", DeployInputShape, async (args) => deployHandler(DeploySchema.parse(args)));
     server.tool("offlocal_status", "Get the current status of a deployment. Poll this every few seconds after offlocal_deploy until status is 'live' or 'failed'.", StatusInputShape, async (args) => statusHandler(StatusSchema.parse(args)));
     server.tool("offlocal_logs", "Read recent container logs for a deployment. Useful for debugging a failed deploy or watching live output.", LogsInputShape, async (args) => logsHandler(LogsSchema.parse(args)));
-    // Fire-and-forget ping so the dashboard knows the agent is connected.
-    // Don't block startup if it fails — agent will still work.
+    server.tool("offlocal_rollback", "Roll a project back to a previous build. Re-deploys an existing image (skips the build, ~1 min), so it's fast and safe. Defaults to the most recent prior build; pass toDeploymentId to target a specific one. Use when a new deploy is broken or the user wants the last working version back.", RollbackInputShape, async (args) => rollbackHandler(RollbackSchema.parse(args)));
+    server.tool("offlocal_plans", "Show the user's current Offlocal.ai plan, the full tier catalog (prices, limits, features), and upcoming features. Use it to answer plan and pricing questions, and to show upgrade options when the user needs more capacity (projects, databases, custom domains). Includes the billing link.", PlansInputShape, async () => plansHandler());
+    server.tool("offlocal_resolve_requirement", "When a deploy needs an external resource (a database, hosting, etc.) that the project doesn't already have, call this with the capability (e.g. 'postgres') to get the providers that can supply it and their connection status. Present the options to the user and let them choose; the user can also just paste an existing connection string as an env var instead.", ResolveRequirementInputShape, async (args) => resolveRequirementHandler(ResolveRequirementSchema.parse(args)));
+    server.tool("offlocal_connect", "Get a browser link for the user to connect a chosen provider via OAuth. You CANNOT complete OAuth yourself - share the link, then poll offlocal_list_connections until the provider is 'connected'. Only call this if the user chose a provider that isn't connected yet.", ConnectInputShape, async (args) => connectHandler(ConnectSchema.parse(args)));
+    server.tool("offlocal_list_connections", "List the user's provider connections and their status. Use this to poll after offlocal_connect (no faster than every 5 seconds) until a provider becomes 'connected'.", ListConnectionsInputShape, async () => listConnectionsHandler());
+    server.tool("offlocal_provision", "Provision a real resource (e.g. a database) on a CONNECTED provider. ALWAYS call first with confirm omitted/false to get a PREVIEW + cost, show the user, and get explicit confirmation — then call again with confirm:true. Pass projectId (from offlocal_deploy) so the resulting DATABASE_URL is auto-injected. May return status 'provisioning' for DigitalOcean/Railway — poll with offlocal_provision_status.", ProvisionInputShape, async (args) => provisionHandler(ProvisionSchema.parse(args)));
+    server.tool("offlocal_provision_status", "Poll an in-progress provision (DigitalOcean/Railway) by its actionId until it's ready. Poll no faster than once every ~20 seconds.", ProvisionStatusInputShape, async (args) => provisionStatusHandler(ProvisionStatusSchema.parse(args)));
+    server.tool("offlocal_create_managed_database", "Create an Offlocal Managed Postgres database for a project (the 'Offlocal' platform option for postgres). Pass the projectId from offlocal_deploy. DATABASE_URL is wired into the project automatically; redeploy to apply. Requires a Hobby+ plan.", CreateManagedDatabaseInputShape, async (args) => createManagedDatabaseHandler(CreateManagedDatabaseSchema.parse(args)));
+    server.tool("offlocal_set_env", "Set environment variables on a project (stored encrypted, injected on the next deploy). Use this for cross-app wiring in a monorepo — e.g. set NEXT_PUBLIC_API_URL on the web project to the API project's live URL so the frontend can reach the backend. Build-time vars (NEXT_PUBLIC_*, VITE_*) require a fresh deploy to take effect.", SetEnvInputShape, async (args) => setEnvHandler(SetEnvSchema.parse(args)));
+    process.on("uncaughtException", (err) => {
+        console.error("offlocal-mcp uncaught exception (continuing):", err);
+    });
+    process.on("unhandledRejection", (reason) => {
+        console.error("offlocal-mcp unhandled rejection (continuing):", reason);
+    });
     pingApi().catch(() => { });
     const transport = new StdioServerTransport();
     await server.connect(transport);
@@ -30,4 +58,3 @@ main().catch((err) => {
     console.error("offlocal-mcp fatal:", err);
     process.exit(1);
 });
-//# sourceMappingURL=index.js.map