@offlocal/mcp 0.2.0 → 0.3.0

package/dist/client.js

@@ -157,6 +157,26 @@ export async function setProjectEnv(projectId, vars) {
         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)}` : ""}`;

package/dist/index.js

@@ -3,7 +3,8 @@ 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";
@@ -21,6 +22,8 @@ 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",
@@ -32,6 +35,8 @@ async function main() {
     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)));
+    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());
@@ -39,6 +44,12 @@ async function main() {
     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);

package/dist/tools/deploy.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { createDeployment, markUploadComplete, uploadBundle, } from "../client.js";
+import { createDeployment, markUploadComplete, rollback, uploadBundle, } from "../client.js";
 import { detect } from "../detect.js";
-import { ICON } from "../ui.js";
+import { ICON, ui } from "../ui.js";
 import { bundleDirectory } from "../zip.js";
 export const DeployInputShape = {
     sourceDir: z
@@ -43,10 +43,13 @@ export async function deployHandler(input) {
     const buildSource = detected.strategy === "dockerfile"
         ? "your Dockerfile"
         : `auto-generated Dockerfile (${detected.framework})`;
+    const slug = created.slug ?? appName;
+    const expectedUrl = created.expectedUrl ?? `https://${slug}.offlocal.ai`;
     const summary = {
         deploymentId: created.deploymentId,
         projectId: created.projectId,
         appName,
+        slug,
         framework: detected.framework,
         buildSource,
         port,
@@ -55,7 +58,7 @@ export async function deployHandler(input) {
             bytes: bundle.byteSize,
         },
         status: "uploaded",
-        expectedUrl: `https://${appName}.offlocal.ai`,
+        expectedUrl,
         pollAfterSeconds: 45,
         expectedTotalSeconds: 180,
     };
@@ -82,6 +85,34 @@ export async function deployHandler(input) {
         structuredContent: summary,
     };
 }
+export const RollbackInputShape = {
+    projectId: z
+        .string()
+        .min(1)
+        .describe("The Offlocal projectId to roll back (from offlocal_deploy / offlocal_status)."),
+    toDeploymentId: z
+        .string()
+        .optional()
+        .describe("Optional: a specific previous deploymentId to roll back to. Omit to roll back to the most recent prior build."),
+};
+export async function rollbackHandler(input) {
+    const res = await rollback(input.projectId, input.toDeploymentId);
+    if (res.error || !res.deployment) {
+        const hint = res.error === "no_rollback_target" || res.error === "deployment_not_found"
+            ? " There's no earlier build with an image to roll back to (this project may only have one successful deploy)."
+            : "";
+        return ui({
+            show: `${ICON.fail} Rollback failed: ${res.message ?? res.error}.${hint}`,
+            structured: res,
+        });
+    }
+    const d = res.deployment;
+    return ui({
+        show: `${ICON.spark} **Rolling back** to the build from \`${res.rolledBackTo}\` — re-deploying that image (skips the build, ~1 min).`,
+        next: `Poll \`offlocal_status({ deploymentId: "${d.id}" })\` until it's \`live\`. It reuses the previous image, so there's no rebuild.`,
+        structured: { deployment: d, rolledBackTo: res.rolledBackTo ?? null },
+    });
+}
 function needsDockerfile(sourceDir, port) {
     const summary = {
         status: "needs_dockerfile",

package/dist/tools/plan.js

@@ -116,6 +116,9 @@ export async function planHandler(input) {
             (requirements.length
                 ? ` + ${requirements.map((r) => r.reason).join(", ")}`
                 : "");
+    const hasDatastore = requirements.some((r) => r.capability === "postgres" || r.capability === "mysql");
+    const hasServerComponent = components.some((c) => c.role !== "web");
+    const noteEphemeral = !hasDatastore && hasServerComponent;
     const show = `${ICON.search} **Offlocal.ai — deployment plan**\n\n` +
         `**Detected:** ${detectedLine}\n\n` +
         `**Plan**\n${planLines.join("\n")}\n` +
@@ -123,9 +126,13 @@ export async function planHandler(input) {
         `\n**Setup checklist**  ${progressBar(0, checklist.length)}\n${checklistLines.join("\n")}\n\n` +
         `Reply **"go"** to ship it ${ICON.rocket} — or switch any line ` +
         `(e.g. _"use Supabase for the database"_, _"host the API on Railway"_).`;
+    const persistenceCheck = noteEphemeral
+        ? `\n\nNote: this host's storage is ephemeral. Mention data persistence only if the user asks about keeping data between deploys — a database covers it.`
+        : "";
     const agentNote = `When the user switches a line, call \`offlocal_set_preference\` ` +
-        `(capability \`${multi ? "hosting:<component> or postgres/…" : "hosting/postgres/…"}\`) then re-run \`offlocal_plan\`.\n\n` +
-        `**Execution order once they confirm — walk the checklist top to bottom, ` +
+        `(capability \`${multi ? "hosting:<component> or postgres/…" : "hosting/postgres/…"}\`) then re-run \`offlocal_plan\`.` +
+        persistenceCheck +
+        `\n\n**Execution order once they confirm — walk the checklist top to bottom, ` +
         `re-showing it with ${ICON.done} on finished steps so they see live progress:**\n` +
         executionSteps(items, links, dbTarget).join("\n");
     return ui({

package/dist/tools/plans.js

@@ -0,0 +1,25 @@
+import { getPlanInfo } from "../client.js";
+import { ICON, ui } from "../ui.js";
+export const PlansInputShape = {};
+export async function plansHandler() {
+    const info = await getPlanInfo();
+    const tierLines = info.plans.map((p) => {
+        const isCurrent = p.plan === info.plan;
+        const head = isCurrent
+            ? `${ICON.connected} **${p.label} — ${p.priceLabel}** _(your plan)_`
+            : `${ICON.open} **${p.label} — ${p.priceLabel}**`;
+        const projects = `${p.projects} project${p.projects === 1 ? "" : "s"}`;
+        return `${head}\n     ${projects} · ${p.features.slice(0, 4).join(" · ")}`;
+    });
+    const upcoming = info.upcoming.length
+        ? `\n\n${ICON.soon} **On the roadmap:** ${info.upcoming.join(" · ")}`
+        : "";
+    return ui({
+        show: `${ICON.spark} **Offlocal.ai plans**\n\n` +
+            `You're on **${info.planLabel}** — using ${info.usage.projects}/${info.limits.projects} projects, ${info.limits.managedDbs} managed database${info.limits.managedDbs === 1 ? "" : "s"} included.\n\n` +
+            tierLines.join("\n\n") +
+            upcoming,
+        next: `Use this to answer the user's plan and pricing questions. If they need more capacity (projects, databases, custom domains), share ${info.billingUrl} where they can change plans.`,
+        structured: { ...info },
+    });
+}

package/dist/tools/providers.js

@@ -213,10 +213,10 @@ export async function setEnvHandler(input) {
 export async function createManagedDatabaseHandler(input) {
     const res = await createManagedDatabase(input.projectId);
     if (res.error) {
-        const upsell = res.error === "plan_not_allowed" || res.error === "limit_reached"
-            ? " Tell the user this needs a Hobby+ plan or they've hit their database limit — they can upgrade at /billing."
+        const planHint = res.error === "plan_not_allowed" || res.error === "limit_reached"
+            ? " A Hobby plan or higher is required, or the database limit was reached — plans can be changed at /billing."
             : "";
-        return text(`${ICON.fail} Couldn't create the managed database: ${res.message ?? res.error}.${upsell}`, res);
+        return text(`${ICON.fail} Couldn't create the managed database: ${res.message ?? res.error}.${planHint}`, res);
     }
     return text(`${ICON.db} **Offlocal Managed Postgres created** (${res.database?.status}). ` +
         `${ICON.spark} DATABASE_URL is wired into this project automatically — **redeploy** to apply.`, res);

package/package.json

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