@offlocal/mcp 0.1.0 → 0.2.0

package/dist/tools/deploy.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { createDeployment, markUploadComplete, uploadBundle, } from "../client.js";
 import { detect } from "../detect.js";
+import { ICON } 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,10 +40,15 @@ 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 summary = {
         deploymentId: created.deploymentId,
+        projectId: created.projectId,
         appName,
         framework: detected.framework,
+        buildSource,
         port,
         bundle: {
             fileCount: bundle.fileCount,
@@ -54,26 +63,50 @@ 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,
+    };
+}
+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,331 @@
+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 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 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, ` +
+        `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/providers.js

@@ -0,0 +1,223 @@
+import { z } from "zod";
+import { createManagedDatabase, getConnectLink, listConnections, pollProvision, provisionResource, resolveRequirement, setProjectEnv, } from "../client.js";
+import { ICON } from "../ui.js";
+function text(t, structured) {
+    return {
+        content: [{ type: "text", text: t }],
+        structuredContent: structured,
+    };
+}
+export const ListConnectionsInputShape = {};
+export async function listConnectionsHandler() {
+    const providers = await listConnections();
+    const lines = providers.map((p) => {
+        const icon = p.status === "connected"
+            ? ICON.connected
+            : p.availability === "coming_soon"
+                ? "🔜"
+                : p.configured
+                    ? ICON.open
+                    : "⛔";
+        return (`  ${icon} **${p.label}** (${p.provider}) — ${p.status}` +
+            (p.account?.name ? ` · ${p.account.name}` : "") +
+            (p.capabilities.length ? ` · _${p.capabilities.join(", ")}_` : ""));
+    });
+    return {
+        content: [
+            {
+                type: "text",
+                text: `${ICON.plug} **Provider connections**\n${lines.join("\n")}`,
+            },
+        ],
+        structuredContent: { providers },
+    };
+}
+export const ResolveRequirementInputShape = {
+    need: z
+        .enum([
+        "hosting",
+        "postgres",
+        "mysql",
+        "redis",
+        "object_storage",
+        "email",
+        "domain",
+    ])
+        .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);
+    if (options.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `No Offlocal providers can supply "${need}" yet.\n` +
+                        `Ask the user to paste a value for it as an env var instead.`,
+                },
+            ],
+            structuredContent: { need, options, pasteEnvVar },
+        };
+    }
+    const lines = options.map((o) => {
+        const tag = o.status === "connected"
+            ? "connected ✓"
+            : o.connectable
+                ? "connect required"
+                : o.status === "coming_soon"
+                    ? "coming soon"
+                    : "not configured";
+        return `  - ${o.label} (${o.provider}) - ${tag}`;
+    });
+    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` +
+                    `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` +
+                    `Alternative: ${pasteEnvVar.hint}`,
+            },
+        ],
+        structuredContent: { need, options, pasteEnvVar },
+    };
+}
+export const ConnectInputShape = {
+    provider: z
+        .string()
+        .min(1)
+        .describe("The provider to connect, e.g. 'supabase' (from offlocal_resolve_requirement options)."),
+};
+export async function connectHandler(input) {
+    const { provider, url } = await getConnectLink(input.provider);
+    return {
+        content: [
+            {
+                type: "text",
+                text: `${ICON.plug} **Connect ${provider}** — first time only (~30s)\n\n` +
+                    `Open this link to authorize:\n\n${url}\n\n` +
+                    `You'll be redirected back when it's done.\n\n` +
+                    `———\n` +
+                    `${ICON.arrow} **Next (you, the agent):** share the link above, then wait. Poll ` +
+                    `\`offlocal_list_connections\` no faster than every 5s. When **${provider}** shows ` +
+                    `${ICON.connected} connected, continue to \`offlocal_provision\`. You cannot ` +
+                    `complete the OAuth yourself.`,
+            },
+        ],
+        structuredContent: { provider, url, pollWith: "offlocal_list_connections" },
+    };
+}
+export const ProvisionInputShape = {
+    provider: z.string().min(1).describe("The connected provider to provision on."),
+    type: z
+        .enum(["project", "database", "deployment", "env_vars", "branch"])
+        .describe("The kind of resource to create."),
+    confirm: z
+        .boolean()
+        .optional()
+        .describe("Leave false/omitted to get a PREVIEW + cost (no charge). Set true ONLY after the user explicitly confirmed the cost — this creates a real, billable resource."),
+    projectId: z
+        .string()
+        .optional()
+        .describe("The Offlocal projectId (from offlocal_deploy). If set, the resulting DATABASE_URL is stored on that project and auto-injected on its next deploy."),
+    name: z.string().max(128).optional(),
+    region: z.string().max(64).optional(),
+    framework: z.string().max(64).optional(),
+    repo: z.string().max(256).optional(),
+    envVars: z.record(z.string()).optional(),
+    metadata: z.record(z.unknown()).optional(),
+};
+export async function provisionHandler(input) {
+    const { provider, confirm, projectId, ...spec } = input;
+    const res = await provisionResource(provider, spec, {
+        confirm: confirm ?? false,
+        projectId,
+    });
+    if (res.error || res.action?.status === "failed") {
+        return text(`${ICON.fail} Provisioning ${spec.type} on ${provider} failed: ${res.error ?? res.result?.error ?? "unknown error"}`, res);
+    }
+    const result = res.result;
+    if (!result)
+        return text(`Provision ${spec.type} on ${provider}: no result.`, res);
+    if (res.preview || result.status === "preview") {
+        const cost = result.cost ? `\n${ICON.spark} **Cost:** ${result.cost.note}` : "";
+        return text(`${ICON.warn} **PREVIEW — nothing created yet, no charge.**\n${result.preview.summary}${cost}\n\n` +
+            `———\n` +
+            `${ICON.arrow} **Next (you, the agent):** show the user exactly what this creates AND the cost, ` +
+            `and get explicit confirmation. Only then call \`offlocal_provision\` again with ` +
+            `\`confirm: true\` and \`projectId\` (to auto-inject the DATABASE_URL).`, res);
+    }
+    if (result.status === "provisioning") {
+        return text(`${ICON.busy} **Provisioning on ${provider}** (a few minutes).\n\n` +
+            `———\n` +
+            `${ICON.arrow} **Next (you, the agent):** tell the user it's being created and you'll continue ` +
+            `when it's online. Poll \`offlocal_provision_status({ actionId: "${res.action?.id}" })\` every ~20s ` +
+            `until it reports ready.`, res);
+    }
+    const envKeys = result.envVars ? Object.keys(result.envVars) : [];
+    return text(`${ICON.done} ${result.preview.summary}` +
+        (envKeys.length ? `\nProduced: ${envKeys.join(", ")}.` : "") +
+        (res.envStored
+            ? `\n${ICON.spark} Stored on the project — **redeploy** to inject it.`
+            : envKeys.length
+                ? `\n(Pass \`projectId\` next time to auto-inject these.)`
+                : ""), res);
+}
+export const ProvisionStatusInputShape = {
+    actionId: z
+        .string()
+        .min(1)
+        .describe("The action id offlocal_provision returned when status was 'provisioning'."),
+};
+export async function provisionStatusHandler(input) {
+    const res = await pollProvision(input.actionId);
+    const result = res.result;
+    if (res.error || res.action?.status === "failed") {
+        return text(`${ICON.fail} Provisioning failed: ${res.error ?? result?.error ?? "unknown"}`, res);
+    }
+    if (res.action?.status === "succeeded" || result?.status === "succeeded") {
+        const envKeys = result?.envVars ? Object.keys(result.envVars) : [];
+        return text(`${ICON.done} **Ready.**${envKeys.length ? ` Produced: ${envKeys.join(", ")}.` : ""}` +
+            `${res.envStored ? ` ${ICON.spark} Stored on the project — **redeploy** to inject it.` : ""}`, res);
+    }
+    return text(`${ICON.busy} Still provisioning… ${result?.preview.summary ?? ""} Poll again in ~20s.`, res);
+}
+export const CreateManagedDatabaseInputShape = {
+    projectId: z
+        .string()
+        .min(1)
+        .describe("The Offlocal projectId (from offlocal_deploy) to attach an Offlocal Managed Postgres database to."),
+};
+export const SetEnvInputShape = {
+    projectId: z
+        .string()
+        .min(1)
+        .describe("The Offlocal projectId (from offlocal_deploy) to set env vars on."),
+    vars: z
+        .record(z.string())
+        .describe('Env vars to set, e.g. { "NEXT_PUBLIC_API_URL": "https://my-api.offlocal.ai" }. ' +
+        "Keys are normalized to UPPER_SNAKE_CASE. Stored encrypted, injected on the next deploy."),
+};
+export async function setEnvHandler(input) {
+    const res = await setProjectEnv(input.projectId, input.vars);
+    if (res.error) {
+        return text(`${ICON.fail} Couldn't set env vars: ${res.message ?? res.error}.`, res);
+    }
+    const keys = Object.keys(input.vars).map((k) => k.trim().toUpperCase().replace(/[^A-Z0-9_]/g, "_"));
+    return text(`${ICON.done} Set ${keys.length} env var${keys.length === 1 ? "" : "s"} (${keys.join(", ")}). ` +
+        `${ICON.spark} Stored encrypted — **redeploy** this project to apply ` +
+        `(build-time vars like \`NEXT_PUBLIC_*\` only take effect on a fresh build).`, res);
+}
+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."
+            : "";
+        return text(`${ICON.fail} Couldn't create the managed database: ${res.message ?? res.error}.${upsell}`, 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);
+}