@sellable/mcp 0.1.0

package/dist/tools/bootstrap.js

@@ -0,0 +1,246 @@
+import { resetApi } from "../api.js";
+import { getAuthStatus } from "./auth.js";
+import { getCampaignContext } from "./context.js";
+import { getCampaignFramework } from "./framework.js";
+import { getSubskillPrompt, listSubskillPrompts, } from "./prompts.js";
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function toGuidance(check, message) {
+    if (check === "auth") {
+        return "Run get_auth_status and fix auth/workspace setup before continuing.";
+    }
+    if (check === "framework") {
+        return "Fix framework files and rerun bootstrap_create_campaign.";
+    }
+    if (check === "resume_context") {
+        return "Confirm the campaignId exists and is accessible, then retry bootstrap_create_campaign.";
+    }
+    if (check === "subskill_catalog") {
+        return "Ensure MCP skills are readable from mcp/sellable/skills before retrying.";
+    }
+    if (check === "create_campaign_subskill") {
+        return "Ensure create-campaign subskill exists and can be loaded via get_subskill_prompt.";
+    }
+    return `Resolve: ${message}`;
+}
+function pushBlockingError(blockingErrors, check, message) {
+    blockingErrors.push({
+        check,
+        message,
+        guidance: toGuidance(check, message),
+    });
+}
+export const bootstrapToolDefinitions = [
+    {
+        name: "bootstrap_create_campaign",
+        description: "Run canonical create-campaign preflight in deterministic order: auth, framework, optional resume context, and create-campaign subskill loading.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                campaignId: {
+                    type: "string",
+                    description: "Optional campaign ID. When provided, bootstrap checks resume context and returns resume diagnostics.",
+                },
+                flowVersion: {
+                    type: "string",
+                    enum: ["v1", "v2"],
+                    description: "Framework flow version (default: v1).",
+                },
+                includeTableCheck: {
+                    type: "boolean",
+                    description: "When resuming with campaignId, include workflow table readiness check in context lookup (default: true).",
+                },
+                refreshContext: {
+                    type: "boolean",
+                    description: "When true and campaignId is provided, force refresh campaign context cache.",
+                },
+            },
+            additionalProperties: false,
+        },
+    },
+];
+export async function bootstrapCreateCampaign(input = {}) {
+    const flowVersion = input.flowVersion || "v1";
+    const campaignId = input.campaignId || null;
+    const includeTableCheck = input.includeTableCheck !== false;
+    const refreshContext = input.refreshContext === true;
+    const requiredChecks = [];
+    const blockingErrors = [];
+    let auth = null;
+    let framework = null;
+    let campaignContext = null;
+    let subskillCatalog = null;
+    let createCampaignSubskill = null;
+    const runAuthCheck = async () => {
+        let status = await getAuthStatus();
+        let retried = false;
+        // Some local-dev stacks can return transient 404 HTML during route warmup.
+        // Retry once with a fresh API client to avoid false-negative bootstrap blocks.
+        if (!status.ok && status.error?.type === "api") {
+            retried = true;
+            resetApi();
+            status = await getAuthStatus();
+        }
+        return { status, retried };
+    };
+    try {
+        const authCheck = await runAuthCheck();
+        auth = authCheck.status;
+        const ok = authCheck.status.ok === true;
+        requiredChecks.push({
+            key: "auth",
+            ok,
+            blocking: !ok,
+            detail: ok
+                ? authCheck.retried
+                    ? "Authenticated with active workspace (after retry)."
+                    : "Authenticated with active workspace."
+                : authCheck.status.error?.message || "Authentication check failed.",
+        });
+        if (!ok) {
+            pushBlockingError(blockingErrors, "auth", authCheck.status.error?.message || "Authentication check failed.");
+        }
+    }
+    catch (error) {
+        const message = toErrorMessage(error);
+        requiredChecks.push({
+            key: "auth",
+            ok: false,
+            blocking: true,
+            detail: message,
+        });
+        pushBlockingError(blockingErrors, "auth", message);
+    }
+    try {
+        framework = getCampaignFramework({
+            flowVersion,
+            includePlugins: true,
+        });
+        requiredChecks.push({
+            key: "framework",
+            ok: true,
+            blocking: false,
+            detail: `Framework ${framework.flowVersion} loaded.`,
+        });
+    }
+    catch (error) {
+        const message = toErrorMessage(error);
+        requiredChecks.push({
+            key: "framework",
+            ok: false,
+            blocking: true,
+            detail: message,
+        });
+        pushBlockingError(blockingErrors, "framework", message);
+    }
+    if (campaignId) {
+        try {
+            campaignContext = await getCampaignContext({
+                campaignId,
+                flowVersion,
+                includeTableCheck,
+                refresh: refreshContext,
+            });
+            requiredChecks.push({
+                key: "resume_context",
+                ok: true,
+                blocking: false,
+                detail: "Resume context loaded.",
+            });
+        }
+        catch (error) {
+            const message = toErrorMessage(error);
+            requiredChecks.push({
+                key: "resume_context",
+                ok: false,
+                blocking: true,
+                detail: message,
+            });
+            pushBlockingError(blockingErrors, "resume_context", message);
+        }
+    }
+    else {
+        requiredChecks.push({
+            key: "resume_context",
+            ok: true,
+            blocking: false,
+            detail: "No campaignId provided; running fresh create flow bootstrap.",
+        });
+    }
+    try {
+        subskillCatalog = listSubskillPrompts(50, true, true);
+        requiredChecks.push({
+            key: "subskill_catalog",
+            ok: true,
+            blocking: false,
+            detail: `${subskillCatalog.total} subskill prompt(s) indexed.`,
+        });
+    }
+    catch (error) {
+        const message = toErrorMessage(error);
+        requiredChecks.push({
+            key: "subskill_catalog",
+            ok: false,
+            blocking: true,
+            detail: message,
+        });
+        pushBlockingError(blockingErrors, "subskill_catalog", message);
+    }
+    try {
+        const subskillName = flowVersion === "v2" ? "create-campaign-v2" : "create-campaign";
+        createCampaignSubskill = getSubskillPrompt(subskillName);
+        requiredChecks.push({
+            key: "create_campaign_subskill",
+            ok: true,
+            blocking: false,
+            detail: `${subskillName} subskill loaded.`,
+        });
+    }
+    catch (error) {
+        const message = toErrorMessage(error);
+        requiredChecks.push({
+            key: "create_campaign_subskill",
+            ok: false,
+            blocking: true,
+            detail: message,
+        });
+        pushBlockingError(blockingErrors, "create_campaign_subskill", message);
+    }
+    const resumeDetected = Boolean(campaignId && campaignContext);
+    const safeToProceed = blockingErrors.length === 0;
+    const workspaceLabel = auth?.activeWorkspaceName || auth?.activeWorkspaceId;
+    const workspaceNotice = workspaceLabel
+        ? ` IMPORTANT: Tell the user which workspace is active: "${workspaceLabel}".`
+        : "";
+    const nextStep = safeToProceed
+        ? resumeDetected
+            ? `Bootstrap complete.${workspaceNotice} Resume using campaign context, then load ${createCampaignSubskill?.name ?? "create-campaign"} instructions with get_subskill_prompt({ subskillName: "${createCampaignSubskill?.name ?? "create-campaign"}" }).`
+            : flowVersion === "v2"
+                ? `Bootstrap complete.${workspaceNotice} Load create-campaign-v2 instructions with get_subskill_prompt({ subskillName: "create-campaign-v2" }), then start with the create-campaign-brief interview stage. Do not call create_campaign until the v2 approval gate returns approve.`
+                : `Bootstrap complete.${workspaceNotice} Load ${createCampaignSubskill?.name ?? "create-campaign"} instructions with get_subskill_prompt({ subskillName: "${createCampaignSubskill?.name ?? "create-campaign"}" }) and follow that flow before calling create_campaign.`
+        : "Bootstrap incomplete. Resolve blockingErrors and rerun bootstrap_create_campaign before provider/search/import tools.";
+    // Strip prompt body from createCampaignSubskill — it's loaded via the host
+    // skill prompt. Only return metadata to save context tokens.
+    const subskillMeta = createCampaignSubskill
+        ? {
+            name: createCampaignSubskill.name,
+            description: createCampaignSubskill.description,
+            visibility: createCampaignSubskill.visibility,
+        }
+        : null;
+    return {
+        requiredChecks,
+        blockingErrors,
+        resumeDetected,
+        nextStep,
+        safeToProceed,
+        flowVersion,
+        campaignId,
+        auth,
+        framework,
+        campaignContext,
+        subskillCatalog,
+        createCampaignSubskill: subskillMeta,
+    };
+}