@sellable/install 0.1.212 → 0.1.213

package/bin/sellable-install.mjs

@@ -330,10 +330,6 @@ function isWindowsPlatform(platform = process.platform) {
   return platform === "win32";
 }
 
-function packageRunnerCommand(platform = process.platform) {
-  return isWindowsPlatform(platform) ? "npx.cmd" : "npx";
-}
-
 function packageManagerCommand(platform = process.platform) {
   return isWindowsPlatform(platform) ? "npm.cmd" : "npm";
 }
@@ -551,6 +547,14 @@ function upsertTomlTable(content, tableName, block) {
   return `${content.trimEnd()}\n\n${normalizedBlock}\n`;
 }
 
+function readTomlTable(content, tableName) {
+  const tablePattern = new RegExp(
+    `(^|\\n)\\[${escapeRegExp(tableName)}\\]\\n([\\s\\S]*?)(?=\\n\\[[^\\n]+\\]|$)`
+  );
+  const match = content.match(tablePattern);
+  return match ? match[2] : "";
+}
+
 function upsertTomlBoolean(content, tableName, key, value) {
   const line = `${key} = ${value ? "true" : "false"}`;
   const tablePattern = new RegExp(
@@ -678,12 +682,13 @@ function codexPluginMcp(opts) {
     };
   }
 
+  const [command, args] = mcpCommand(opts);
   return {
     mcpServers: {
       sellable: {
         type: "stdio",
-        command: packageRunnerCommand(),
-        args: ["-y", opts.mcpPackage],
+        command,
+        args,
         env: {
           SELLABLE_WATCH_MODE_DRIVER: "codex",
         },
@@ -2386,6 +2391,7 @@ enabled = false`
       "default_mode_request_user_input",
       true
     );
+    content = upsertCodexMcpServerConfig(content, opts);
     content = upsertTomlTable(
       content,
       "agents",
@@ -2544,6 +2550,68 @@ function codexMcpAddArgs(opts) {
   ];
 }
 
+function upsertCodexMcpServerConfig(content, opts) {
+  if (opts.server === "hosted") {
+    content = upsertTomlTable(
+      content,
+      "mcp_servers.sellable",
+      `[mcp_servers.sellable]
+url = ${quoteToml(withHostedWatchModeDriver(opts.hostedUrl, "codex"))}`
+    );
+    content = removeTomlSection(content, "mcp_servers.sellable.env");
+    return content;
+  }
+
+  const [command, args] = mcpCommand(opts);
+  content = upsertTomlTable(
+    content,
+    "mcp_servers.sellable",
+    `[mcp_servers.sellable]
+command = ${quoteToml(command)}
+args = ${tomlArray(args)}`
+  );
+  content = upsertTomlTable(
+    content,
+    "mcp_servers.sellable.env",
+    `[mcp_servers.sellable.env]
+SELLABLE_WATCH_MODE_DRIVER = "codex"`
+  );
+  return content;
+}
+
+function codexMcpServerMatches(content, opts) {
+  const server = readTomlTable(content, "mcp_servers.sellable");
+  if (!server) return false;
+  if (opts.server === "hosted") {
+    return (
+      server.includes(
+        `url = ${quoteToml(withHostedWatchModeDriver(opts.hostedUrl, "codex"))}`
+      ) &&
+      !/\bcommand\s*=/.test(server) &&
+      !/\bargs\s*=/.test(server)
+    );
+  }
+
+  const [command, args] = mcpCommand(opts);
+  const env = readTomlTable(content, "mcp_servers.sellable.env");
+  return (
+    server.includes(`command = ${quoteToml(command)}`) &&
+    server.includes(`args = ${tomlArray(args)}`) &&
+    env.includes('SELLABLE_WATCH_MODE_DRIVER = "codex"')
+  );
+}
+
+function codexPluginMcpServerMatches(content, opts) {
+  if (!content) return false;
+  try {
+    const actual = JSON.parse(content)?.mcpServers?.sellable;
+    const expected = codexPluginMcp(opts).mcpServers.sellable;
+    return JSON.stringify(actual) === JSON.stringify(expected);
+  } catch {
+    return false;
+  }
+}
+
 function installClaude(opts) {
   if (!commandExists("claude")) {
     const message =
@@ -3027,6 +3095,30 @@ async function verify(opts) {
           : "Codex Desktop plugin watch mode driver missing"
       )
     );
+    const codexMcpEntriesCanonical = codexMcpServerMatches(
+      configContent,
+      opts
+    );
+    checks.push(
+      warningCheck(
+        codexMcpEntriesCanonical,
+        codexMcpEntriesCanonical
+          ? "Codex CLI Sellable MCP entry canonical"
+          : "Codex CLI Sellable MCP entry stale"
+      )
+    );
+    const codexPluginMcpEntryCanonical = codexPluginMcpServerMatches(
+      pluginMcpContent,
+      opts
+    );
+    checks.push(
+      warningCheck(
+        codexPluginMcpEntryCanonical,
+        codexPluginMcpEntryCanonical
+          ? "Codex Desktop plugin Sellable MCP entry canonical"
+          : "Codex Desktop plugin Sellable MCP entry stale"
+      )
+    );
     const hasCodexAgentRegistrations = codexCustomAgents().every((agent) =>
       configContent.includes(`[agents.${agent.name}]`)
     );

package/lib/runtime-verify.mjs

@@ -3,6 +3,8 @@ import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 
 const MAX_STDERR_LINES = 80;
 const DEFAULT_VERIFY_TIMEOUT_MS = 10_000;
+const DEFAULT_VERIFY_ATTEMPTS = 2;
+const DEFAULT_VERIFY_RETRY_DELAY_MS = 750;
 
 export const REQUIRED_SELLABLE_MCP_TOOLS = [
   "get_auth_status",
@@ -125,6 +127,15 @@ export function missingRequiredTools(tools, requiredTools) {
   return requiredTools.filter((name) => !available.has(name));
 }
 
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function numberFromEnv(name, fallback) {
+  const parsed = Number(process.env[name] || "");
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
 function textFromToolResult(result) {
   return (result?.content || [])
     .filter((part) => part?.type === "text" && typeof part.text === "string")
@@ -291,7 +302,39 @@ async function verifyCreateCampaignSmoke({
   };
 }
 
-export async function verifySellableMcpRuntime({
+function summarizeAttempt(result, attempt) {
+  return {
+    attempt,
+    ok: result.ok === true,
+    availableToolCount: result.availableTools?.length || 0,
+    missingToolCount: result.missingTools?.length || 0,
+    error: result.error || null,
+    createCampaignSmoke: result.createCampaignSmoke
+      ? {
+          ok: result.createCampaignSmoke.ok === true,
+          error: result.createCampaignSmoke.error || null,
+          missingTools: result.createCampaignSmoke.missingTools || [],
+          calls: (result.createCampaignSmoke.calls || []).map((call) => ({
+            name: call.name,
+            ok: call.ok === true,
+          })),
+        }
+      : null,
+    stderrTail: result.stderrTail || [],
+    startedAt: result.startedAt,
+    completedAt: result.completedAt,
+  };
+}
+
+function shouldRetryRuntimeVerification(result, requiredTools) {
+  if (result.ok || result.skipped) return false;
+  if (result.error) return true;
+  const availableToolCount = result.availableTools?.length || 0;
+  const missingToolCount = result.missingTools?.length || 0;
+  return availableToolCount === 0 || missingToolCount === requiredTools.length;
+}
+
+async function verifySellableMcpRuntimeOnce({
   command,
   args = [],
   cwd = process.cwd(),
@@ -389,3 +432,51 @@ export async function verifySellableMcpRuntime({
     completedAt: new Date().toISOString(),
   };
 }
+
+export async function verifySellableMcpRuntime({
+  command,
+  args = [],
+  cwd = process.cwd(),
+  env = process.env,
+  requiredTools = REQUIRED_SELLABLE_MCP_TOOLS,
+  timeoutMs = Number(process.env.SELLABLE_VERIFY_TIMEOUT_MS || "") ||
+    DEFAULT_VERIFY_TIMEOUT_MS,
+  attempts = numberFromEnv("SELLABLE_VERIFY_ATTEMPTS", DEFAULT_VERIFY_ATTEMPTS),
+  retryDelayMs = numberFromEnv(
+    "SELLABLE_VERIFY_RETRY_DELAY_MS",
+    DEFAULT_VERIFY_RETRY_DELAY_MS
+  ),
+}) {
+  const attemptSummaries = [];
+  let lastResult = null;
+
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const result = await verifySellableMcpRuntimeOnce({
+      command,
+      args,
+      cwd,
+      env,
+      requiredTools,
+      timeoutMs,
+    });
+    lastResult = result;
+    attemptSummaries.push(summarizeAttempt(result, attempt));
+
+    if (
+      attempt >= attempts ||
+      !shouldRetryRuntimeVerification(result, requiredTools)
+    ) {
+      return {
+        ...result,
+        attempts: attemptSummaries,
+      };
+    }
+
+    await sleep(retryDelayMs);
+  }
+
+  return {
+    ...lastResult,
+    attempts: attemptSummaries,
+  };
+}

package/package.json

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