@offlocal/mcp 0.3.3 → 0.3.4

package/dist/client.js

@@ -81,8 +81,28 @@ export async function getDeployment(deploymentId) {
     const res = await fetch(`${API_URL}/api/deployments/${encodeURIComponent(deploymentId)}`, { headers: { ...authHeaders() } });
     if (!res.ok)
         throw new Error(await failureText(res, "get_deployment"));
+    return (await res.json());
+}
+export async function detectApp(dir) {
+    const res = await fetch(`${API_URL}/api/detect`, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...authHeaders() },
+        body: JSON.stringify({ dir }),
+    });
+    if (!res.ok)
+        throw new Error(await failureText(res, "detect"));
     const json = (await res.json());
-    return json.deployment;
+    return json.detected;
+}
+export async function planProject(snapshot) {
+    const res = await fetch(`${API_URL}/api/plan`, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...authHeaders() },
+        body: JSON.stringify({ snapshot }),
+    });
+    if (!res.ok)
+        throw new Error(await failureText(res, "plan"));
+    return (await res.json());
 }
 export async function getDeploymentLogs(deploymentId, options) {
     const params = new URLSearchParams();
@@ -139,15 +159,6 @@ export async function pollProvision(actionId) {
     }
     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",

package/dist/detect.js

@@ -1,434 +1,5 @@
-import { readdir, readFile, stat } from "node:fs/promises";
-import { basename, join } from "node:path";
-const NO_BUILD = "echo no-build";
-const FROM_DOCKERFILE = "(provided by Dockerfile)";
+import { gatherDirSnapshot } from "./snapshot.js";
+import { detectApp } from "./client.js";
 export async function detect(sourceDir) {
-    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" });
-    }
-    const wantsObjectStorage = has("@aws-sdk/client-s3") ||
-        has("@aws-sdk/lib-storage") ||
-        has("aws-sdk") ||
-        has("@google-cloud/storage") ||
-        has("@azure/storage-blob") ||
-        has("minio") ||
-        has("multer-s3") ||
-        has("cloudinary") ||
-        /\b(s3_bucket|bucket_name|storage_bucket|r2_bucket|spaces_bucket|cloudinary_url)\b/.test(envText);
-    if (wantsObjectStorage) {
-        reqs.push({
-            capability: "object_storage",
-            reason: "object-storage client or bucket config detected",
-        });
-    }
-    return reqs;
-}
-const WEB_FRAMEWORKS = new Set([
-    "nextjs",
-    "nuxt",
-    "remix",
-    "astro",
-    "vite",
-    "cra",
-    "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 {
-            entries = (await readdir(baseDir, { withFileTypes: true }))
-                .filter((e) => e.isDirectory())
-                .map((e) => e.name);
-        }
-        catch {
-            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 "cra":
-            return { key: "REACT_APP_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 deps = {
-        ...(pkg?.dependencies ?? {}),
-        ...(pkg?.devDependencies ?? {}),
-    };
-    const scripts = pkg?.scripts ?? {};
-    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";
-    const notes = [];
-    if (hasManage || manifest.includes("django")) {
-        framework = "django";
-        const wsgi = await findDjangoWsgiModule(sourceDir);
-        startCommand = `python manage.py migrate --noinput && gunicorn ${wsgi}:application --bind 0.0.0.0:$PORT`;
-        notes.push("Django runs under gunicorn (production) and migrates on start. IMPORTANT: a default project's `ALLOWED_HOSTS` is empty and will 400 every request. Make settings.py read it from the environment — e.g. `ALLOWED_HOSTS = os.environ.get('ALLOWED_HOSTS', '').split(',')` — and offlocal will set ALLOWED_HOSTS to the live host automatically. Use a real database (SQLite resets on every cold start), and run `collectstatic` in a build step if you serve static files.");
-    }
-    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: "python-3.12",
-        framework,
-        buildCommand: NO_BUILD,
-        startCommand,
-        port: 8000,
-        strategy: "template",
-        notes: notes.length ? notes : undefined,
-    };
-}
-async function findDjangoWsgiModule(sourceDir) {
-    const manage = await readTextSafe(join(sourceDir, "manage.py"));
-    const m = /DJANGO_SETTINGS_MODULE['"]\s*,\s*['"]([\w.]+)\.settings['"]/.exec(manage);
-    if (m?.[1])
-        return `${m[1]}.wsgi`;
-    try {
-        const entries = await readdir(sourceDir, { withFileTypes: true });
-        for (const e of entries) {
-            if (e.isDirectory() &&
-                (await fileExists(join(sourceDir, e.name, "wsgi.py")))) {
-                return `${e.name}.wsgi`;
-            }
-        }
-    }
-    catch {
-    }
-    return "wsgi";
-}
-function pickNodeFramework(deps) {
-    if ("next" in deps)
-        return "nextjs";
-    if ("nuxt" in deps)
-        return "nuxt";
-    if ("@remix-run/serve" in deps || "@remix-run/node" in deps)
-        return "remix";
-    if ("astro" in deps)
-        return "astro";
-    if ("vite" in deps)
-        return "vite";
-    if ("react-scripts" in deps || "@craco/craco" in deps)
-        return "cra";
-    if ("fastify" in deps)
-        return "fastify";
-    if ("hono" in deps)
-        return "hono";
-    if ("express" in deps)
-        return "express";
-    if ("koa" in deps)
-        return "koa";
-    return "node";
-}
-function nodePort(framework) {
-    switch (framework) {
-        case "astro":
-            return 4321;
-        case "vite":
-            return 4173;
-        case "cra":
-            return 80;
-        default:
-            return 3000;
-    }
-}
-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);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return detectApp(await gatherDirSnapshot(sourceDir));
 }

package/dist/snapshot.js

@@ -0,0 +1,127 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { basename, join } from "node:path";
+const COMPONENT_DIRS = ["apps", "packages", "services"];
+async function readTextSafe(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+async function exists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function envSignals(dir) {
+    const text = ((await readTextSafe(join(dir, ".env.example"))) ?? "") +
+        "\n" +
+        ((await readTextSafe(join(dir, ".env"))) ?? "");
+    if (!text.trim())
+        return {};
+    const keys = new Set();
+    let dbUrlScheme = null;
+    for (const line of text.split(/\r?\n/)) {
+        const m = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=(.*)$/.exec(line);
+        if (!m)
+            continue;
+        const key = m[1];
+        keys.add(key);
+        if (key.toUpperCase() === "DATABASE_URL" && !dbUrlScheme) {
+            const val = (m[2] ?? "").trim().replace(/^['"]/, "");
+            if (/^postgres/i.test(val))
+                dbUrlScheme = "postgres";
+            else if (/^mysql/i.test(val))
+                dbUrlScheme = "mysql";
+        }
+    }
+    return { envKeys: keys.size ? [...keys] : undefined, dbUrlScheme };
+}
+async function wsgiDirs(dir) {
+    try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        const out = [];
+        for (const e of entries) {
+            if (e.isDirectory() && (await exists(join(dir, e.name, "wsgi.py")))) {
+                out.push(e.name);
+            }
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+export async function gatherDirSnapshot(dir) {
+    const [packageJson, requirementsTxt, pyprojectToml, pipfile, cargoToml, dockerfile, managePy, prismaSchema, env, hasIndexHtml, hasMainPy, hasGoMod, wsgi,] = await Promise.all([
+        readTextSafe(join(dir, "package.json")),
+        readTextSafe(join(dir, "requirements.txt")),
+        readTextSafe(join(dir, "pyproject.toml")),
+        readTextSafe(join(dir, "Pipfile")),
+        readTextSafe(join(dir, "Cargo.toml")),
+        readTextSafe(join(dir, "Dockerfile")),
+        readTextSafe(join(dir, "manage.py")),
+        readTextSafe(join(dir, "prisma", "schema.prisma")),
+        envSignals(dir),
+        exists(join(dir, "index.html")),
+        exists(join(dir, "main.py")),
+        exists(join(dir, "go.mod")),
+        wsgiDirs(dir),
+    ]);
+    return {
+        dirName: basename(dir),
+        packageJson,
+        requirementsTxt,
+        pyprojectToml,
+        pipfile,
+        cargoToml,
+        dockerfile,
+        managePy,
+        prismaSchema,
+        envKeys: env.envKeys,
+        dbUrlScheme: env.dbUrlScheme,
+        hasIndexHtml,
+        hasMainPy,
+        hasGoMod,
+        wsgiDirs: wsgi.length ? wsgi : undefined,
+    };
+}
+export async function gatherPlanSnapshot(rootDir) {
+    const [root, hasPnpmWorkspace, hasTurboJson] = await Promise.all([
+        gatherDirSnapshot(rootDir),
+        exists(join(rootDir, "pnpm-workspace.yaml")),
+        exists(join(rootDir, "turbo.json")),
+    ]);
+    const components = [];
+    for (const base of COMPONENT_DIRS) {
+        const baseDir = join(rootDir, base);
+        let names = [];
+        try {
+            names = (await readdir(baseDir, { withFileTypes: true }))
+                .filter((e) => e.isDirectory())
+                .map((e) => e.name);
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            const dir = join(baseDir, name);
+            const hasManifest = (await exists(join(dir, "package.json"))) ||
+                (await exists(join(dir, "Dockerfile"))) ||
+                (await exists(join(dir, "go.mod"))) ||
+                (await exists(join(dir, "requirements.txt")));
+            if (hasManifest) {
+                components.push({
+                    relPath: `${base}/${name}`,
+                    snapshot: await gatherDirSnapshot(dir),
+                });
+            }
+        }
+    }
+    return { root: { ...root, hasPnpmWorkspace, hasTurboJson }, components };
+}

package/dist/tools/plan.js

@@ -1,30 +1,8 @@
+import { join } from "node:path";
 import { z } from "zod";
-import { apiUrlEnvVar, detectComponents, detectRequirements, } from "../detect.js";
-import { getPreferences, listConnections, resolveRequirement, setPreference, } from "../client.js";
+import { gatherPlanSnapshot } from "../snapshot.js";
+import { listConnections, planProject, 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",
-    object_storage: "Object storage",
-};
-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()
@@ -32,68 +10,8 @@ export const PlanInputShape = {
         .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 snapshot = await gatherPlanSnapshot(input.sourceDir);
+    const { multi, components, requirements, items, links, dbTarget } = await planProject(snapshot);
     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)` : "";
@@ -135,7 +53,7 @@ export async function planHandler(input) {
         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");
+        executionSteps(items, links, dbTarget, input.sourceDir).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.`,
@@ -147,10 +65,13 @@ export async function planHandler(input) {
             items,
             links,
             checklist,
-            dbTargetComponent: dbTarget?.name ?? null,
+            dbTargetComponent: dbTarget,
         },
     });
 }
+function absPath(sourceDir, relPath) {
+    return relPath ? join(sourceDir, ...relPath.split("/")) : sourceDir;
+}
 function buildChecklist(items, links, dbTarget) {
     const out = [];
     let n = 0;
@@ -183,7 +104,7 @@ function buildChecklist(items, links, dbTarget) {
     }
     const redeploy = new Set();
     if (resources.length && hosting.length)
-        redeploy.add(dbTarget?.name);
+        redeploy.add(dbTarget ?? undefined);
     for (const l of links)
         redeploy.add(l.web);
     if (redeploy.size) {
@@ -201,13 +122,13 @@ function projName(name) {
         return "the app";
     return name;
 }
-function executionSteps(items, links, dbTarget) {
+function executionSteps(items, links, dbTarget, sourceDir) {
     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**.`);
+            lines.push(`• ${ICON.rocket} Deploy ${labelShort(it)}: \`offlocal_deploy({ sourceDir: "${absPath(sourceDir, it.componentRelPath)}" })\` → 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.)`}`);
@@ -215,14 +136,14 @@ function executionSteps(items, links, dbTarget) {
     }
     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.`);
+            lines.push(`• ${ICON.db} ${it.label} (Offlocal Managed Postgres): \`offlocal_create_managed_database({ projectId: <${projName(dbTarget)} 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.`);
+                `\`offlocal_provision({ provider: "${it.recommended}", type: "database" })\` for a PREVIEW + cost → confirm with the user → call again with \`confirm: true, projectId: <${projName(dbTarget)} projectId>\`. If it returns status **"provisioning"**, poll \`offlocal_provision_status({ actionId })\` until ready.`);
         }
     }
     for (const l of links) {
@@ -232,7 +153,7 @@ function executionSteps(items, links, dbTarget) {
     }
     const redeploy = new Set();
     if (resources.length && hosting.length)
-        redeploy.add(dbTarget?.name);
+        redeploy.add(dbTarget ?? undefined);
     for (const l of links)
         redeploy.add(l.web);
     if (redeploy.size) {
@@ -248,61 +169,6 @@ function humanComp(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()

package/dist/tools/providers.js

@@ -34,19 +34,11 @@ export async function listConnectionsHandler() {
 }
 export const ResolveRequirementInputShape = {
     need: z
-        .enum([
-        "hosting",
-        "postgres",
-        "mysql",
-        "redis",
-        "object_storage",
-        "email",
-        "domain",
-    ])
+        .enum(["hosting", "postgres", "mysql", "redis", "object_storage"])
         .describe("The capability the app needs (e.g. 'postgres' for a Postgres database)."),
 };
 export async function resolveRequirementHandler(input) {
-    const { need, options, pasteEnvVar } = await resolveRequirement(input.need);
+    const { need, options, connectorBudget, pasteEnvVar } = await resolveRequirement(input.need);
     if (options.length === 0) {
         return {
             content: [
@@ -60,21 +52,46 @@ export async function resolveRequirementHandler(input) {
         };
     }
     const lines = options.map((o) => {
-        const tag = o.status === "connected"
-            ? "connected ✓"
-            : o.connectable
-                ? "connect required"
+        const tag = o.managed
+            ? o.planEligible
+                ? "managed by Offlocal · included in your plan"
+                : "managed by Offlocal · needs a paid plan"
+            : o.status === "connected"
+                ? "connected ✓"
                 : o.status === "coming_soon"
                     ? "coming soon"
-                    : "not configured";
-        return `  - ${o.label} (${o.provider}) - ${tag}`;
+                    : o.planEligible === false
+                        ? "connect required · plan limit reached (upgrade)"
+                        : o.connectable
+                            ? "connect required"
+                            : "not configured";
+        const guide = [o.bestFor, o.cost, o.freeTier ? "free tier" : null]
+            .filter(Boolean)
+            .join(" · ");
+        return `  - ${o.label} (${o.provider}) — ${tag}` + (guide ? `\n      ${guide}` : "");
     });
+    const budgetLine = connectorBudget
+        ? `\n_Connectors: ${connectorBudget.used}/${connectorBudget.limit} used` +
+            (connectorBudget.remaining === 0
+                ? ` — limit reached. A new connection needs a plan upgrade (or paste an env var)._`
+                : ` (${connectorBudget.remaining} left)._`)
+        : "";
+    const hasActionable = options.some((o) => o.connected || o.connectable || (o.managed && o.planEligible));
+    const intro = hasActionable
+        ? `This app needs "${need}". Present these options and **recommend one** based on the ` +
+            `user's situation — use the "best for", cost, and free-tier notes (e.g. suggest a free tier ` +
+            `for a side project, or the managed option for zero setup):`
+        : `This app needs "${need}", but nothing is connectable on this account right now. ` +
+            `Simplest path: ask the user for a connection string and set it with offlocal_set_env ` +
+            `(or pick an upgrade/managed option if one is shown). Options:`;
     return {
         content: [
             {
                 type: "text",
-                text: `This app needs "${need}". Present these options to the user and let them choose:\n` +
-                    `${lines.join("\n")}\n\n` +
+                text: `${intro}\n` +
+                    `${lines.join("\n")}${budgetLine}\n\n` +
+                    `If they pick **Offlocal Managed Postgres** (provider "offlocal"), call ` +
+                    `offlocal_create_managed_database with the projectId — no connect step. ` +
                     `If they pick a provider that says "connect required", call offlocal_connect ` +
                     `with that provider to get a link for them to authorize. If one is already ` +
                     `connected, you can go straight to offlocal_provision.\n` +

package/dist/tools/status.js

@@ -19,24 +19,17 @@ export const StatusInputShape = {
         .describe("The deploymentId returned by offlocal_deploy."),
 };
 export async function statusHandler(input) {
-    const dep = await getDeployment(input.deploymentId);
-    const phase = phaseFor(dep.status);
-    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 { deployment: dep, progress } = await getDeployment(input.deploymentId);
     const summary = {
         deploymentId: dep.id,
         projectId: dep.projectId,
         status: dep.status,
-        phase,
-        isTerminal,
-        pollAfterSeconds,
-        etaSeconds,
-        secondsSinceUpdate,
-        stalled,
+        phase: progress.phase,
+        isTerminal: progress.isTerminal,
+        pollAfterSeconds: progress.pollAfterSeconds,
+        etaSeconds: progress.etaSeconds,
+        secondsSinceUpdate: progress.secondsSinceUpdate,
+        stalled: progress.stalled,
         liveUrl: dep.liveUrl,
         errorType: dep.errorType,
         errorMessage: dep.errorMessage,
@@ -66,12 +59,12 @@ export async function statusHandler(input) {
         }
     }
     else {
-        lines.push(`${ICON.busy} **${phase}**`);
+        lines.push(`${ICON.busy} **${progress.phase}**`);
         lines.push("");
         lines.push(bar);
         lines.push("");
-        if (stalled) {
-            lines.push(`${ICON.warn} It's been at "${phase}" for ~${Math.round(secondsSinceUpdate / 60)} min with no change — ` +
+        if (progress.stalled) {
+            lines.push(`${ICON.warn} It's been at "${progress.phase}" for ~${Math.round(progress.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).`);
@@ -81,7 +74,7 @@ export async function statusHandler(input) {
                 `• 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.`);
+                `Sleep ${progress.pollAfterSeconds}s, then call this exactly once. Polling faster does not help.`);
         }
     }
     return {
@@ -89,63 +82,3 @@ export async function statusHandler(input) {
         structuredContent: summary,
     };
 }
-function phaseFor(status) {
-    switch (status) {
-        case "created":
-        case "upload_pending":
-            return "waiting for source upload";
-        case "uploaded":
-        case "validating":
-            return "validating source";
-        case "queued":
-            return "queued for build";
-        case "building":
-        case "image_built":
-            return "building image";
-        case "deploying":
-            return "starting container";
-        case "live":
-            return "live";
-        case "failed":
-            return "failed";
-        case "deleted":
-            return "deleted";
-        default:
-            return "unknown";
-    }
-}
-function pollIntervalFor(status) {
-    switch (status) {
-        case "upload_pending":
-            return 5;
-        case "uploaded":
-        case "validating":
-            return 10;
-        case "queued":
-        case "building":
-        case "image_built":
-            return 30;
-        case "deploying":
-            return 30;
-        default:
-            return 15;
-    }
-}
-function etaFor(status) {
-    switch (status) {
-        case "upload_pending":
-            return 30;
-        case "uploaded":
-        case "validating":
-            return 15;
-        case "queued":
-            return 90;
-        case "building":
-        case "image_built":
-            return 75;
-        case "deploying":
-            return 90;
-        default:
-            return 0;
-    }
-}

package/package.json

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