@offlocal/mcp 0.1.0 → 0.3.0

package/dist/tools/deploy.js

@@ -1,6 +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, ui } from "../ui.js";
 import { bundleDirectory } from "../zip.js";
 export const DeployInputShape = {
     sourceDir: z
@@ -25,6 +26,9 @@ export async function deployHandler(input) {
     const detected = await detect(input.sourceDir);
     const appName = input.appName ?? detected.appName;
     const port = input.port ?? detected.port;
+    if (detected.strategy === "unknown") {
+        return needsDockerfile(input.sourceDir, port);
+    }
     const bundle = await bundleDirectory(input.sourceDir);
     const created = await createDeployment({
         appName,
@@ -36,17 +40,25 @@ export async function deployHandler(input) {
     });
     await uploadBundle(created.upload.url, bundle.buffer);
     await markUploadComplete(created.deploymentId);
+    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,
         bundle: {
             fileCount: bundle.fileCount,
             bytes: bundle.byteSize,
         },
         status: "uploaded",
-        expectedUrl: `https://${appName}.offlocal.ai`,
+        expectedUrl,
         pollAfterSeconds: 45,
         expectedTotalSeconds: 180,
     };
@@ -54,26 +66,78 @@ export async function deployHandler(input) {
         content: [
             {
                 type: "text",
-                text: `Deployment created and source uploaded.\n\n` +
-                    `  deploymentId: ${summary.deploymentId}\n` +
-                    `  appName:      ${summary.appName}\n` +
-                    `  framework:    ${summary.framework}\n` +
-                    `  port:         ${summary.port}\n` +
-                    `  bundle:       ${summary.bundle.fileCount} files, ${summary.bundle.bytes} bytes\n` +
-                    `  expectedUrl:  ${summary.expectedUrl}\n\n` +
-                    `WAIT — this is a normal, slow operation.\n` +
-                    `Typical end-to-end time: 2-4 minutes (CodeBuild cold start + ECS rollout).\n` +
-                    `Do NOT poll offlocal_status faster than once every 30 seconds. ` +
-                    `Repeated polling does not speed anything up; the only thing that helps is time.\n\n` +
-                    `Recommended sequence:\n` +
+                text: `${ICON.rocket} **Deploying \`${summary.appName}\`** — source uploaded, build started.\n\n` +
+                    `| | |\n|---|---|\n` +
+                    `| ${ICON.web} URL | ${summary.expectedUrl} |\n` +
+                    `| ${ICON.spark} Framework | ${summary.framework} (${summary.buildSource}) |\n` +
+                    `| Port | ${summary.port} |\n` +
+                    `| Bundle | ${summary.bundle.fileCount} files · ${summary.bundle.bytes} bytes |\n\n` +
+                    `———\n` +
+                    `${ICON.arrow} **Next (you, the agent):** tell the user it's building (2–4 min) and you'll ` +
+                    `report back when it's live. Then:\n` +
                     `  1. Sleep 45 seconds.\n` +
-                    `  2. Call offlocal_status({ deploymentId: "${summary.deploymentId}" }).\n` +
-                    `  3. The response will include "pollAfterSeconds" — sleep that long, then call status again.\n` +
-                    `  4. Continue until status is 'live' or 'failed'.\n\n` +
-                    `Tell the user the deploy is in progress and you'll report back when it's live.`,
+                    `  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` +
+                    `Keep the **projectId** from the live status for any database step.`,
+            },
+        ],
+        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",
+        sourceDir,
+        suggestedPort: port,
+    };
+    return {
+        content: [
+            {
+                type: "text",
+                text: `I couldn't confidently detect this project's stack, so I didn't upload anything yet.\n\n` +
+                    `To deploy it, add a Dockerfile to the project root, then run offlocal_deploy again.\n\n` +
+                    `Write a production Dockerfile at:\n` +
+                    `  ${sourceDir}/Dockerfile\n\n` +
+                    `Requirements for it to work on Offlocal:\n` +
+                    `  - It must build the app and end with a CMD or ENTRYPOINT that starts the server.\n` +
+                    `  - The server must listen on the port in the PORT environment variable\n` +
+                    `    (default to ${port} if PORT is unset), bound to 0.0.0.0 - not localhost.\n` +
+                    `  - EXPOSE that same port.\n` +
+                    `  - Use a multi-stage build for compiled languages to keep the image small.\n\n` +
+                    `Base the Dockerfile on the actual files in the project (language, package\n` +
+                    `manager, build and start commands). Once it's saved, call offlocal_deploy again\n` +
+                    `with the same sourceDir - Offlocal will use your Dockerfile as-is.`,
             },
         ],
         structuredContent: summary,
     };
 }
-//# sourceMappingURL=deploy.js.map

package/dist/tools/logs.js

@@ -35,4 +35,3 @@ export async function logsHandler(input) {
         structuredContent: { logs },
     };
 }
-//# sourceMappingURL=logs.js.map

package/dist/tools/ping.js

@@ -11,7 +11,7 @@ export async function pingHandler(_input) {
                     text: "Not connected to Offlocal.\n\n" +
                         `Reason: ${result.reason}\n\n` +
                         "Common fixes:\n" +
-                        "  - If you're calling from WSL, make sure OFFLOCAL_API_URL points at the Windows host (http://host.docker.internal:4000) — not localhost.\n" +
+                        "  - If you're calling from WSL, make sure OFFLOCAL_API_URL points at the Windows host (http://host.docker.internal:4000) - not localhost.\n" +
                         "  - Make sure `pnpm dev:api` is running on the Windows side.\n" +
                         "  - Double-check OFFLOCAL_AGENT_KEY matches a key created in the dashboard.",
                 },
@@ -30,6 +30,4 @@ export async function pingHandler(_input) {
         structuredContent: { connected: true, email },
     };
 }
-// Silence unused-import warnings if z isn't used after init.
 void z;
-//# sourceMappingURL=ping.js.map

package/dist/tools/plan.js

@@ -0,0 +1,338 @@
+import { z } from "zod";
+import { apiUrlEnvVar, detectComponents, detectRequirements, } from "../detect.js";
+import { getPreferences, listConnections, resolveRequirement, setPreference, } from "../client.js";
+import { ICON, progressBar, step, ui } from "../ui.js";
+const OFFLOCAL_NATIVE = {
+    hosting: { label: "Offlocal.ai (managed)", cost: "instant · *.offlocal.ai" },
+    postgres: { label: "Offlocal Managed Postgres", cost: "included in your plan" },
+};
+const CAP_LABEL = {
+    hosting: "Web app",
+    postgres: "Postgres database",
+    mysql: "MySQL database",
+    redis: "Redis",
+};
+const ROLE_LABEL = {
+    web: "Web app",
+    api: "API / server",
+    app: "App",
+};
+const PROVIDER_COST = {
+    supabase: "free tier available",
+    planetscale: "no free tier (~$39/mo)",
+    digitalocean: "~$15/mo",
+    railway: "usage-based (paid plan)",
+    vercel: "coming soon",
+};
+export const PlanInputShape = {
+    sourceDir: z
+        .string()
+        .min(1)
+        .describe("Absolute path to the project root to deploy."),
+};
+export async function planHandler(input) {
+    const [components, connections, preferences] = await Promise.all([
+        detectComponents(input.sourceDir),
+        listConnections().catch(() => []),
+        getPreferences().catch(() => ({})),
+    ]);
+    const connected = new Set(connections.filter((c) => c.status === "connected").map((c) => c.provider));
+    const multi = components.length > 1;
+    const reqMap = new Map();
+    for (const c of components) {
+        const reqs = await detectRequirements(c.absPath).catch(() => []);
+        for (const r of reqs)
+            if (!reqMap.has(r.capability))
+                reqMap.set(r.capability, r);
+    }
+    const requirements = [...reqMap.values()];
+    const hostingOpts = (await resolveRequirement("hosting").catch(() => ({ options: [] }))).options;
+    const items = [];
+    for (const c of components) {
+        const prefCapability = multi ? `hosting:${c.name}` : "hosting";
+        const label = multi
+            ? `${ROLE_LABEL[c.role] ?? "App"} · \`${c.relPath || c.name}\` (${c.framework})`
+            : `${CAP_LABEL.hosting} · ${c.framework}`;
+        items.push(buildItem({
+            prefCapability,
+            capability: "hosting",
+            kind: "hosting",
+            label,
+            component: c,
+            preferences,
+            options: hostingOpts,
+            connected,
+        }));
+    }
+    for (const req of requirements) {
+        const opts = (await resolveRequirement(req.capability).catch(() => ({ options: [] }))).options;
+        items.push(buildItem({
+            prefCapability: req.capability,
+            capability: req.capability,
+            kind: "resource",
+            label: CAP_LABEL[req.capability] ?? req.capability,
+            preferences,
+            options: opts,
+            connected,
+            reason: req.reason,
+        }));
+    }
+    const dbTarget = components.find((c) => c.role === "api") ?? components[0];
+    const apiComp = components.find((c) => c.role === "api");
+    const links = apiComp
+        ? components
+            .filter((c) => c.role === "web")
+            .map((w) => {
+            const env = apiUrlEnvVar(w.framework);
+            return {
+                web: w.name,
+                webPath: w.absPath,
+                api: apiComp.name,
+                envVar: env.key,
+                buildTime: env.buildTime,
+            };
+        })
+        : [];
+    const planLines = items.map((it, i) => {
+        const emoji = it.isOfflocal ? ICON.offlocal : it.recommended ? ICON.connected : ICON.open;
+        const connect = it.needsConnect ? `  ${ICON.warn} first-time connect (~30s)` : "";
+        const saved = it.fromPreference ? " _(your saved choice)_" : "";
+        const note = it.note ? `  ${ICON.soon} _${it.note}_` : "";
+        return `  ${i + 1}. ${emoji} ${it.label} → **${it.recommendedLabel}**${saved}${connect}  ·  _${it.cost}_${note}`;
+    });
+    const wiringBlock = links.length
+        ? `\n**Wiring** _(automatic)_\n` +
+            links
+                .map((l) => `  ${ICON.plug} \`${l.web}\` reaches \`${l.api}\` via \`${l.envVar}\` (auto-set to ${l.api}'s live URL)`)
+                .join("\n") +
+            `\n`
+        : "";
+    const checklist = buildChecklist(items, links, dbTarget);
+    const checklistLines = checklist.map((c) => step("pending", c.text));
+    const detectedLine = multi
+        ? `monorepo · ${components.length} apps (${components.map((c) => c.name).join(", ")})` +
+            (requirements.length ? ` + ${requirements.map((r) => r.capability).join(", ")}` : "")
+        : `${components[0]?.framework ?? "app"} app` +
+            (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` +
+        wiringBlock +
+        `\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\`.` +
+        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({
+        show,
+        next: `Show the plan above to the user and wait for "go" (or an edit). Do NOT deploy or provision anything yet.`,
+        agentNote,
+        structured: {
+            multiComponent: multi,
+            components,
+            requirements,
+            items,
+            links,
+            checklist,
+            dbTargetComponent: dbTarget?.name ?? null,
+        },
+    });
+}
+function buildChecklist(items, links, dbTarget) {
+    const out = [];
+    let n = 0;
+    const hosting = items.filter((it) => it.kind === "hosting");
+    const resources = items.filter((it) => it.kind === "resource");
+    for (const it of hosting) {
+        n += 1;
+        out.push({
+            n,
+            kind: "hosting",
+            text: `Deploy ${labelShort(it)} → ${it.recommendedLabel}`,
+        });
+    }
+    for (const it of resources) {
+        n += 1;
+        const connect = it.needsConnect ? ` (connect ${it.recommendedLabel} first)` : "";
+        out.push({
+            n,
+            kind: "resource",
+            text: `Provision ${it.label} → ${it.recommendedLabel}${connect}`,
+        });
+    }
+    for (const l of links) {
+        n += 1;
+        out.push({
+            n,
+            kind: "link",
+            text: `Wire \`${l.web}\` → \`${l.api}\` URL (set ${l.envVar})`,
+        });
+    }
+    const redeploy = new Set();
+    if (resources.length && hosting.length)
+        redeploy.add(dbTarget?.name);
+    for (const l of links)
+        redeploy.add(l.web);
+    if (redeploy.size) {
+        n += 1;
+        out.push({
+            n,
+            kind: "redeploy",
+            text: `Redeploy ${[...redeploy].map(humanComp).join(" & ")} to apply injected env`,
+        });
+    }
+    return out;
+}
+function projName(name) {
+    if (!name || name === "root" || name === "app")
+        return "the app";
+    return name;
+}
+function executionSteps(items, links, dbTarget) {
+    const lines = [];
+    const hosting = items.filter((it) => it.kind === "hosting");
+    const resources = items.filter((it) => it.kind === "resource");
+    for (const it of hosting) {
+        if (it.isOfflocal) {
+            lines.push(`• ${ICON.rocket} Deploy ${labelShort(it)}: \`offlocal_deploy({ sourceDir: "${it.componentPath || "<root>"}" })\` → poll \`offlocal_status\` until live → note the **projectId** and **live URL**.`);
+        }
+        else if (it.recommended) {
+            lines.push(`• ${ICON.web} Host ${labelShort(it)} on ${it.recommendedLabel}: ${it.cost === "coming soon" ? `${it.recommendedLabel} support is coming soon.` : `if not connected, \`offlocal_connect\` → share link → poll \`offlocal_list_connections\`. (External hosting is provider-driven.)`}`);
+        }
+    }
+    for (const it of resources) {
+        if (it.isOfflocal) {
+            lines.push(`• ${ICON.db} ${it.label} (Offlocal Managed Postgres): \`offlocal_create_managed_database({ projectId: <${projName(dbTarget?.name)} projectId> })\`. DATABASE_URL is wired in automatically.`);
+        }
+        else {
+            lines.push(`• ${ICON.db} ${it.label} on ${it.recommendedLabel}: ` +
+                (it.needsConnect
+                    ? `\`offlocal_connect\` → share link → poll \`offlocal_list_connections\` until connected, then `
+                    : "") +
+                `\`offlocal_provision({ provider: "${it.recommended}", type: "database" })\` for a PREVIEW + cost → confirm with the user → call again with \`confirm: true, projectId: <${projName(dbTarget?.name)} projectId>\`. If it returns status **"provisioning"**, poll \`offlocal_provision_status({ actionId })\` until ready.`);
+        }
+    }
+    for (const l of links) {
+        lines.push(`• ${ICON.plug} Wire \`${l.web}\` → \`${l.api}\`: once \`${l.api}\` is live, take its URL from \`offlocal_status\` and ` +
+            `\`offlocal_set_env({ projectId: <${l.web} projectId>, vars: { "${l.envVar}": "<${l.api} live URL>" } })\`.` +
+            (l.buildTime ? ` _(build-time var — only applies on a fresh deploy)_` : ""));
+    }
+    const redeploy = new Set();
+    if (resources.length && hosting.length)
+        redeploy.add(dbTarget?.name);
+    for (const l of links)
+        redeploy.add(l.web);
+    if (redeploy.size) {
+        lines.push(`• ${ICON.spark} **Redeploy** ${[...redeploy].map(humanComp).join(" & ")} (\`offlocal_deploy\` on each sourceDir) so the injected env (DATABASE_URL / API URL) takes effect.`);
+    }
+    return lines;
+}
+function humanComp(name) {
+    if (!name || name === "root" || name === "app")
+        return "the app";
+    return `\`${name}\``;
+}
+function labelShort(it) {
+    return humanComp(it.componentName);
+}
+function buildItem(args) {
+    const { prefCapability, capability, kind, label, preferences, options, connected, component, reason } = args;
+    const native = OFFLOCAL_NATIVE[capability];
+    const offlocalAvailable = Boolean(native);
+    const pref = preferences[prefCapability];
+    const prefOption = options.find((o) => o.provider === pref);
+    const prefComingSoon = Boolean(prefOption && prefOption.status === "coming_soon");
+    const prefValid = Boolean(pref &&
+        !prefComingSoon &&
+        (pref === "offlocal" ? offlocalAvailable : Boolean(prefOption)));
+    const recommended = prefValid && pref
+        ? pref
+        : offlocalAvailable
+            ? "offlocal"
+            : (options.find((o) => o.connected)?.provider ??
+                options.find((o) => o.connectable)?.provider ??
+                null);
+    const isOfflocal = recommended === "offlocal";
+    const recommendedLabel = !recommended
+        ? "— no platform available —"
+        : isOfflocal
+            ? native.label
+            : (options.find((o) => o.provider === recommended)?.label ?? recommended);
+    const cost = isOfflocal
+        ? native.cost
+        : recommended
+            ? (PROVIDER_COST[recommended] ?? "provider pricing")
+            : "";
+    const needsConnect = Boolean(recommended) && !isOfflocal && !connected.has(recommended);
+    const note = prefComingSoon
+        ? `${prefOption?.label ?? pref} support is coming soon`
+        : undefined;
+    return {
+        prefCapability,
+        capability,
+        kind,
+        label,
+        componentName: component?.name,
+        componentPath: component?.absPath,
+        recommended,
+        recommendedLabel,
+        fromPreference: prefValid,
+        needsConnect,
+        isOfflocal,
+        cost,
+        reason,
+        note,
+        options: [
+            ...(offlocalAvailable
+                ? [{ platform: "offlocal", label: native.label, status: "available" }]
+                : []),
+            ...options.map((o) => ({ platform: o.provider, label: o.label, status: o.status })),
+        ],
+    };
+}
+export const SetPreferenceInputShape = {
+    capability: z
+        .string()
+        .min(1)
+        .max(40)
+        .describe('The capability to remember a platform for: "hosting", "postgres", "mysql", "redis", or per-component hosting like "hosting:web" / "hosting:api" (names come from offlocal_plan).'),
+    platform: z
+        .string()
+        .min(1)
+        .describe('The platform: "offlocal", "supabase", "planetscale", "digitalocean", "railway", or "vercel".'),
+};
+export async function setPreferenceHandler(input) {
+    const platform = input.platform.toLowerCase();
+    let comingSoon = false;
+    if (platform !== "offlocal") {
+        const conns = await listConnections().catch(() => []);
+        const meta = conns.find((c) => c.provider === platform);
+        comingSoon = meta?.availability === "coming_soon";
+    }
+    await setPreference(input.capability, platform);
+    if (comingSoon) {
+        return ui({
+            show: `${ICON.soon} **${platform}** support is coming soon. I've saved it for **${input.capability}** ` +
+                `and will switch to it automatically once it's available.`,
+            next: `Re-run \`offlocal_plan({ sourceDir })\` to see the updated plan.`,
+            structured: { capability: input.capability, platform, comingSoon: true },
+        });
+    }
+    return ui({
+        show: `${ICON.done} Saved — **${input.capability} → ${platform}**. I'll default to this from now on.`,
+        next: `Re-run \`offlocal_plan({ sourceDir })\` to show the user the updated plan.`,
+        structured: { capability: input.capability, platform },
+    });
+}

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 },
+    });
+}