@sellable/install 0.1.207 → 0.1.208

package/README.md

@@ -55,11 +55,13 @@ Agents should use the agent-readable handoff instead of guessing commands:
 Install Sellable CLI and skills using https://app.sellable.dev/agent-install.txt
 ```
 
-The direct npm installer remains available as a troubleshooting fallback when
-Node/npm/npx are already known-good:
+The direct npm installer is only a package-level troubleshooting fallback for
+maintainers. Public installs should keep using the curl endpoint above because
+it bootstraps Node, repairs legacy state, installs skills, and runs runtime
+verification in one path:
 
 ```bash
-npx -y @sellable/install@latest --host all
+curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh
 ```
 
 For CI/scripted installs, get a Sellable API token from:

package/bin/sellable-install.mjs

@@ -1315,7 +1315,7 @@ local harness scripts, or read local prompt files to emulate this workflow.
 
 If the Sellable MCP tool is unavailable, stop and say this is a Codex
 install/reload problem. Tell the user to run
-\`npx -y ${INSTALL_PACKAGE_SPEC} --host all\`, fully quit and reopen Codex
+\`curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh\`, fully quit and reopen Codex
 Desktop, then start a new thread.
 
 1. Call \`mcp__sellable__get_auth_status({})\`.
@@ -1363,7 +1363,7 @@ emulate this workflow.
 
 If the Sellable MCP prompt tools are unavailable, stop and say this is a Codex
 install/reload problem. Tell the user to run
-\`npx -y ${INSTALL_PACKAGE_SPEC} --host all\`, fully quit and reopen Codex
+\`curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh\`, fully quit and reopen Codex
 Desktop, then start a new thread.
 
 ## Execute Workflow
@@ -1440,7 +1440,7 @@ emulate this workflow.
 
 If the Sellable MCP prompt tools are unavailable, stop and say this is a Codex
 install/reload problem. Tell the user to run
-\`npx -y ${INSTALL_PACKAGE_SPEC} --host all\`, fully quit and reopen Codex
+\`curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh\`, fully quit and reopen Codex
 Desktop, then start a new thread.
 
 ## Execute Workflow
@@ -1512,7 +1512,7 @@ emulate this workflow.
 
 If the Sellable MCP prompt tools are unavailable, stop and say this is a Codex
 install/reload problem. Tell the user to run
-\`npx -y ${INSTALL_PACKAGE_SPEC} --host all\`, fully quit and reopen Codex
+\`curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh\`, fully quit and reopen Codex
 Desktop, then start a new thread.
 
 ## Execute Workflow
@@ -2690,8 +2690,8 @@ async function verify(opts) {
       (runtimeRequired ? requiredCheck : warningCheck)(
         runtimeMcp.ok,
         runtimeMcp.ok
-          ? `MCP runtime exposes required tools (${runtimeMcp.availableTools.length} total)`
-          : `MCP runtime missing tools: ${runtimeMcp.missingTools.join(", ") || runtimeMcp.error || "unknown failure"}`
+          ? `MCP runtime exposes required campaign tools (${runtimeMcp.availableTools.length} total) and create-campaign smoke passed`
+          : `MCP runtime verification failed: ${runtimeMcp.missingTools.join(", ") || runtimeMcp.createCampaignSmoke?.error || runtimeMcp.error || "unknown failure"}`
       )
     );
   }

package/lib/runtime-verify.mjs

@@ -6,12 +6,64 @@ const DEFAULT_VERIFY_TIMEOUT_MS = 10_000;
 
 export const REQUIRED_SELLABLE_MCP_TOOLS = [
   "get_auth_status",
+  "start_cli_login",
+  "wait_for_cli_login",
   "bootstrap_create_campaign",
+  "get_subskill_prompt",
+  "get_subskill_asset",
+  "search_subskill_prompts",
   "create_campaign",
   "import_leads",
+  "confirm_lead_list",
+  "wait_for_lead_list_ready",
+  "wait_for_campaign_table_ready",
   "update_campaign",
-  "get_subskill_prompt",
-  "get_subskill_asset",
+  "update_campaign_brief",
+  "get_campaign",
+  "get_campaign_context",
+  "get_campaign_framework",
+  "get_campaign_navigation_state",
+  "get_campaign_messages_preview",
+  "attach_sequence",
+  "attach_recommended_sequence",
+  "start_campaign_message_preparation",
+  "get_campaign_message_preparation_status",
+  "cancel_campaign_message_preparation",
+  "start_campaign",
+];
+
+export const CREATE_CAMPAIGN_SMOKE_CALLS = [
+  {
+    name: "get_auth_status",
+    arguments: {},
+  },
+  {
+    name: "bootstrap_create_campaign",
+    arguments: {
+      flowVersion: "v2",
+      includeTableCheck: false,
+      host: "sellable-install-verify",
+      model: "installer-smoke",
+      reasoningEffort: "none",
+    },
+  },
+  {
+    name: "get_subskill_prompt",
+    arguments: {
+      subskillName: "create-campaign-v2",
+      offset: 0,
+      limit: 1200,
+    },
+  },
+  {
+    name: "get_subskill_asset",
+    arguments: {
+      subskillName: "create-campaign-v2",
+      assetPath: "core/flow.v2.json",
+      offset: 0,
+      limit: 1200,
+    },
+  },
 ];
 
 function collectStderrLines(stream) {
@@ -73,6 +125,172 @@ export function missingRequiredTools(tools, requiredTools) {
   return requiredTools.filter((name) => !available.has(name));
 }
 
+function textFromToolResult(result) {
+  return (result?.content || [])
+    .filter((part) => part?.type === "text" && typeof part.text === "string")
+    .map((part) => part.text)
+    .join("\n");
+}
+
+function parseJsonText(text) {
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function summarizeToolResult(name, result) {
+  const text = redact(textFromToolResult(result));
+  const parsed = parseJsonText(text);
+  const summary = {
+    isError: result?.isError === true,
+    textChars: text.length,
+  };
+
+  if (name === "get_auth_status" && parsed) {
+    return {
+      ...summary,
+      authOk: parsed.ok === true,
+      errorType: parsed.error?.type || null,
+      activeWorkspaceId: parsed.activeWorkspaceId || null,
+      activeWorkspaceName: parsed.activeWorkspaceName || null,
+    };
+  }
+
+  if (name === "bootstrap_create_campaign" && parsed) {
+    return {
+      ...summary,
+      safeToProceed: parsed.safeToProceed === true,
+      flowVersion: parsed.flowVersion || null,
+      blockingChecks: Array.isArray(parsed.blockingErrors)
+        ? parsed.blockingErrors.map((entry) => entry?.check).filter(Boolean)
+        : [],
+      requiredChecks: Array.isArray(parsed.requiredChecks)
+        ? parsed.requiredChecks.map((entry) => ({
+            key: entry?.key || null,
+            ok: entry?.ok === true,
+            blocking: entry?.blocking === true,
+          }))
+        : [],
+      nextStepChars:
+        typeof parsed.nextStep === "string" ? parsed.nextStep.length : 0,
+    };
+  }
+
+  if (name === "get_subskill_prompt" && parsed) {
+    return {
+      ...summary,
+      subskillName: parsed.name || null,
+      promptChars: typeof parsed.prompt === "string" ? parsed.prompt.length : 0,
+      hasMore: parsed.hasMore === true,
+      nextOffset:
+        typeof parsed.nextOffset === "number" ? parsed.nextOffset : null,
+    };
+  }
+
+  if (name === "get_subskill_asset" && parsed) {
+    return {
+      ...summary,
+      subskillName: parsed.subskillName || null,
+      assetPath: parsed.assetPath || null,
+      assetChars: typeof parsed.content === "string" ? parsed.content.length : 0,
+      hasMore: parsed.hasMore === true,
+      nextOffset:
+        typeof parsed.nextOffset === "number" ? parsed.nextOffset : null,
+    };
+  }
+
+  return summary;
+}
+
+async function verifyCreateCampaignSmoke({
+  client,
+  availableTools,
+  timeoutMs,
+  smokeCalls = CREATE_CAMPAIGN_SMOKE_CALLS,
+}) {
+  const startedAt = new Date().toISOString();
+  const available = new Set(availableTools || []);
+  const missingTools = smokeCalls
+    .map((call) => call.name)
+    .filter((name) => !available.has(name));
+  const calls = [];
+
+  if (missingTools.length > 0) {
+    return {
+      ok: false,
+      missingTools,
+      calls,
+      error: `Missing smoke tool(s): ${missingTools.join(", ")}`,
+      startedAt,
+      completedAt: new Date().toISOString(),
+    };
+  }
+
+  for (const call of smokeCalls) {
+    const callStartedAt = new Date().toISOString();
+    try {
+      const result = await client.callTool(
+        { name: call.name, arguments: call.arguments },
+        undefined,
+        {
+          timeout: timeoutMs,
+          maxTotalTimeout: timeoutMs,
+        }
+      );
+      const summary = summarizeToolResult(call.name, result);
+      calls.push({
+        name: call.name,
+        arguments: call.arguments,
+        ok: summary.isError !== true,
+        summary,
+        startedAt: callStartedAt,
+        completedAt: new Date().toISOString(),
+      });
+      if (summary.isError === true) {
+        return {
+          ok: false,
+          missingTools: [],
+          calls,
+          error: `${call.name} returned an MCP tool error`,
+          startedAt,
+          completedAt: new Date().toISOString(),
+        };
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      calls.push({
+        name: call.name,
+        arguments: call.arguments,
+        ok: false,
+        summary: null,
+        error: redact(error),
+        startedAt: callStartedAt,
+        completedAt: new Date().toISOString(),
+      });
+      return {
+        ok: false,
+        missingTools: [],
+        calls,
+        error: redact(error),
+        startedAt,
+        completedAt: new Date().toISOString(),
+      };
+    }
+  }
+
+  return {
+    ok: true,
+    missingTools: [],
+    calls,
+    error: null,
+    startedAt,
+    completedAt: new Date().toISOString(),
+  };
+}
+
 export async function verifySellableMcpRuntime({
   command,
   args = [],
@@ -116,6 +334,7 @@ export async function verifySellableMcpRuntime({
 
   let availableTools = [];
   let missingTools = [...requiredTools];
+  let createCampaignSmoke = null;
   let error = null;
 
   try {
@@ -126,6 +345,25 @@ export async function verifySellableMcpRuntime({
     });
     availableTools = toolList.tools.map((tool) => tool.name).sort();
     missingTools = missingRequiredTools(toolList.tools, requiredTools);
+    if (missingTools.length === 0) {
+      createCampaignSmoke = await verifyCreateCampaignSmoke({
+        client,
+        availableTools,
+        timeoutMs,
+      });
+    } else {
+      createCampaignSmoke = {
+        ok: false,
+        missingTools: CREATE_CAMPAIGN_SMOKE_CALLS.map((call) => call.name).filter(
+          (name) => !availableTools.includes(name)
+        ),
+        calls: [],
+        error:
+          "Skipping create-campaign smoke because required MCP tools are missing.",
+        startedAt: new Date().toISOString(),
+        completedAt: new Date().toISOString(),
+      };
+    }
   } catch (err) {
     error = err instanceof Error ? err.message : String(err);
   } finally {
@@ -137,13 +375,14 @@ export async function verifySellableMcpRuntime({
   }
 
   return {
-    ok: !error && missingTools.length === 0,
+    ok: !error && missingTools.length === 0 && createCampaignSmoke?.ok === true,
     skipped: false,
     command,
     args,
     requiredTools,
     availableTools,
     missingTools,
+    createCampaignSmoke,
     stderrTail: stderrLines,
     error: error ? redact(error) : null,
     startedAt,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/install",
-  "version": "0.1.207",
+  "version": "0.1.208",
   "type": "module",
   "description": "One-command installer for Sellable MCP in Claude Code and Codex",
   "bin": {