@sellable/install 0.1.2 → 0.1.4

package/README.md

@@ -30,4 +30,8 @@ Auth is stored once at:
 
 Claude Code and Codex are configured to launch the same packaged MCP server.
 
+For Codex Desktop, the installer also writes a local Sellable plugin bundle into
+`~/.sellable/codex-marketplace`, includes the Sellable skill entrypoints, and
+enables it in `~/.codex/config.toml`.
+
 If only one host is installed, `--host all` installs the available host and tells you how to add the other one later.

package/bin/sellable-install.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { stdin as input, stdout as output } from "node:process";
@@ -9,6 +9,8 @@ import { createInterface } from "node:readline/promises";
 const DEFAULT_API_URL = "https://app.sellable.dev";
 const DEFAULT_SERVER_PACKAGE =
   process.env.SELLABLE_MCP_PACKAGE || "@sellable/mcp";
+const CODEX_PLUGIN_VERSION = "0.1.4";
+const INSTALL_PACKAGE_SPEC = `@sellable/install@${CODEX_PLUGIN_VERSION}`;
 
 function usage() {
   return `Sellable agent installer
@@ -176,7 +178,7 @@ async function promptForMissingAuth(opts) {
       [
         "Missing Sellable token/workspace id.",
         `Create a token at ${opts.apiUrl}/settings, then rerun:`,
-        "  npx -y @sellable/install --host all --token <token> --workspace-id <workspace_id>",
+        `  npx -y ${INSTALL_PACKAGE_SPEC} --host all --token <token> --workspace-id <workspace_id>`,
         "",
         "You can also use SELLABLE_TOKEN and SELLABLE_WORKSPACE_ID.",
       ].join("\n")
@@ -225,6 +227,441 @@ function readExisting(path) {
   }
 }
 
+function codexHome() {
+  return process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
+}
+
+function quoteToml(value) {
+  return `"${String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function upsertTomlTable(content, tableName, block) {
+  const tablePattern = new RegExp(
+    `(^|\\n)\\[${escapeRegExp(tableName)}\\]\\n[\\s\\S]*?(?=\\n\\[[^\\n]+\\]|$)`
+  );
+  const normalizedBlock = block.trimEnd();
+
+  if (tablePattern.test(content)) {
+    return content.replace(tablePattern, (_, prefix) => `${prefix}${normalizedBlock}`);
+  }
+
+  return `${content.trimEnd()}\n\n${normalizedBlock}\n`;
+}
+
+function writeFile(path, content, opts, mode = 0o644) {
+  console.log(`Writing ${path}`);
+  if (opts.dryRun) return;
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  writeFileSync(path, content, { mode });
+}
+
+function codexPluginManifest(opts) {
+  return {
+    name: "sellable",
+    version: CODEX_PLUGIN_VERSION,
+    description:
+      "Sellable MCP tools for campaign creation, engagement, interviews, and workflow sequencing.",
+    author: {
+      name: "Sellable",
+      url: "https://sellable.dev/",
+    },
+    homepage: "https://sellable.dev/",
+    repository: "https://github.com/csreyes/sellable",
+    license: "UNLICENSED",
+    keywords: ["sellable", "linkedin", "outbound", "campaigns", "mcp"],
+    mcpServers: "./.mcp.json",
+    interface: {
+      displayName: "Sellable",
+      shortDescription: "Sellable MCP tools for outbound campaign workflows",
+      longDescription:
+        "Loads the Sellable MCP server into Codex Desktop so Sellable skills can create campaigns, find leads, draft messages, and manage approval-gated launch workflows.",
+      developerName: "Sellable",
+      category: "Productivity",
+      capabilities: ["Interactive", "Write"],
+      websiteURL: "https://sellable.dev/",
+      privacyPolicyURL: "https://sellable.dev/privacy",
+      termsOfServiceURL: "https://sellable.dev/terms",
+      defaultPrompt: [
+        "Create a Sellable campaign",
+        "Find LinkedIn leads",
+        "Build an outbound sequence",
+      ],
+      brandColor: "#8B5CF6",
+      screenshots: [],
+    },
+  };
+}
+
+function codexPluginMcp(opts) {
+  if (opts.server === "hosted") {
+    return {
+      mcpServers: {
+        sellable: {
+          type: "http",
+          url: opts.hostedUrl,
+        },
+      },
+    };
+  }
+
+  if (opts.server === "local") {
+    const [command, args] = mcpCommand(opts);
+    return {
+      mcpServers: {
+        sellable: {
+          type: "stdio",
+          command,
+          args,
+        },
+      },
+    };
+  }
+
+  return {
+    mcpServers: {
+      sellable: {
+        type: "stdio",
+        command: "npx",
+        args: ["-y", opts.mcpPackage],
+      },
+    },
+  };
+}
+
+const CREATE_CAMPAIGN_ALLOWED_TOOLS = [
+  "mcp__sellable__get_auth_status",
+  "mcp__sellable__bootstrap_create_campaign",
+  "mcp__sellable__get_subskill_prompt",
+  "mcp__sellable__search_subskill_prompts",
+  "mcp__sellable__get_provider_prompt",
+  "mcp__sellable__get_message_prompt",
+  "mcp__sellable__get_active_workspace",
+  "mcp__sellable__list_senders",
+  "mcp__sellable__get_sender",
+  "mcp__sellable__enrich_sender",
+  "mcp__sellable__complete_sender_research",
+  "mcp__sellable__fetch_linkedin_profile",
+  "mcp__sellable__fetch_linkedin_posts",
+  "mcp__sellable__get_linkedin_profile",
+  "mcp__sellable__fetch_company",
+  "mcp__sellable__fetch_company_posts",
+  "mcp__sellable__lookup_sales_nav_filter",
+  "mcp__sellable__search_sales_nav",
+  "mcp__sellable__search_prospeo",
+  "mcp__sellable__search_signals",
+  "mcp__sellable__fetch_post_engagers",
+  "mcp__sellable__enrich_with_prospeo",
+  "mcp__sellable__bulk_enrich_with_prospeo",
+  "mcp__sellable__save_domain_filters",
+  "mcp__sellable__add_rubric_item",
+  "mcp__sellable__upsert_rubric",
+  "mcp__sellable__set_headline_icp_criteria",
+  "mcp__sellable__check_rubric",
+  "mcp__sellable__create_campaign",
+  "mcp__sellable__save_rubrics",
+  "mcp__sellable__wait_for_rubric_results",
+  "mcp__sellable__update_campaign_brief",
+  "mcp__sellable__update_campaign",
+  "mcp__sellable__get_campaign",
+  "mcp__sellable__get_campaign_context",
+  "mcp__sellable__get_campaign_framework",
+  "mcp__sellable__get_campaign_navigation_state",
+  "mcp__sellable__confirm_lead_list",
+  "mcp__sellable__import_leads",
+  "mcp__sellable__wait_for_lead_list_ready",
+  "mcp__sellable__wait_for_campaign_table_ready",
+  "mcp__sellable__get_rows",
+  "mcp__sellable__get_rows_minimal",
+  "mcp__sellable__get_table_rows",
+  "mcp__sellable__load_csv_linkedin_leads",
+  "mcp__sellable__load_csv_domains",
+  "mcp__sellable__queue_cells",
+  "mcp__sellable__generate_messages",
+  "mcp__sellable__get_campaign_messages_preview",
+  "mcp__sellable__attach_sequence",
+  "mcp__sellable__attach_recommended_sequence",
+  "mcp__sellable__start_campaign",
+];
+
+function allowedToolsYaml(tools) {
+  return tools.map((tool) => `  - ${tool}`).join("\n");
+}
+
+function codexSkillOpenAiYaml(displayName, description) {
+  return `interface:
+  display_name: "${displayName.replaceAll('"', '\\"')}"
+  short_description: "${description.replaceAll('"', '\\"')}"
+
+dependencies:
+  tools:
+    - type: "mcp"
+      value: "sellable"
+      description: "Sellable MCP server"
+`;
+}
+
+function createCampaignSkillMd() {
+  return `---
+name: sellable:create-campaign
+description: Create a Sellable campaign through the approval-gated workflow.
+allowed-tools:
+${allowedToolsYaml(CREATE_CAMPAIGN_ALLOWED_TOOLS)}
+---
+
+# Sellable Create Campaign
+
+Use this as the customer-facing entrypoint for Sellable campaign creation.
+
+## Bootstrap
+
+MCP tool access is required. First load the bootstrap tools in one tool-discovery
+pass:
+
+- \`ToolSearch("select:mcp__sellable__get_auth_status")\`
+- \`ToolSearch("select:mcp__sellable__bootstrap_create_campaign")\`
+- \`ToolSearch("select:mcp__sellable__get_subskill_prompt")\`
+- \`ToolSearch("select:mcp__sellable__search_subskill_prompts")\`
+
+Do not stop before attempting this ToolSearch preload. If the
+\`mcp__sellable__*\` tools are still not exposed after ToolSearch, stop and say
+this is a Codex install/reload problem, not a campaign problem. Tell the user to
+run \`npx -y ${INSTALL_PACKAGE_SPEC} --host all\` so the packaged MCP server,
+Codex Desktop plugin, and Sellable skill bundle are installed. If they want a
+CLI verification, tell them to run \`sellable --verify-only --host all\`. After
+that, they must fully quit and reopen Codex Desktop before starting a new
+thread. Do not use \`scripts/mcp/sellable-tool-call.mjs\`, \`npm run\`,
+\`node\`, or any local harness as a fallback for this interactive skill.
+
+1. Call \`mcp__sellable__get_auth_status({})\`.
+2. If auth is not OK, stop and show the returned guidance.
+3. Detect optional campaign id in the user request (\`cmp_...\`).
+4. If no campaign id is provided, stay in fresh-create mode and do not call campaign discovery/resume helpers to find one.
+   - Do not call \`mcp__sellable__get_campaigns\`.
+   - Do not call \`mcp__sellable__get_campaign\` to hunt for IDs.
+   - Do not call \`mcp__sellable__create_campaign({ campaignId: ... })\` unless the user supplied that id.
+5. Call \`mcp__sellable__bootstrap_create_campaign({ flowVersion: "v2", campaignId? })\`.
+6. If \`safeToProceed !== true\`, stop and show \`blockingErrors\` + \`nextStep\`.
+
+## Execute Workflow
+
+1. Load canonical prompt via
+   \`mcp__sellable__get_subskill_prompt({ subskillName: "create-campaign-v2" })\`.
+2. Follow that prompt exactly.
+3. For message generation, load the full \`generate-messages\` prompt in the
+   same run with chunked
+   \`mcp__sellable__get_subskill_prompt({ subskillName: "generate-messages", offset, limit })\`
+   calls until \`hasMore\` is false. Do not synthesize
+   \`message-validation.md\` from the brief, lead review, or general knowledge.
+4. Treat message quality as the gate before minting. Do not create a campaign,
+   show a commit gate, or mint anything until \`message-validation.md\` proves
+   the full generate-messages workflow ran and \`message-review.md\` recommends
+   \`approve-message\` against the gold-standard rules.
+5. Do not create or mutate the live campaign until the approval gate returns
+   \`approve\`.
+6. Do not ask the user to run another command.
+
+## Fallback
+
+If subskill lookup fails, use
+\`mcp__sellable__search_subskill_prompts({ query: "create-campaign-v2" })\`,
+then retry \`get_subskill_prompt\`.
+`;
+}
+
+function genericSellableSkillMd({ name, title, description }) {
+  return `---
+name: sellable:${name}
+description: ${description}
+allowed-tools:
+  - mcp__sellable__get_auth_status
+  - mcp__sellable__get_subskill_prompt
+  - mcp__sellable__search_subskill_prompts
+---
+
+# ${title}
+
+Use this as the customer-facing entrypoint for the Sellable \`${name}\` workflow.
+
+## Bootstrap
+
+MCP tool access is required. Do not inspect repo files, run shell commands, use
+\`npm\`, \`node\`, local harness scripts, or read local prompt files to emulate
+this workflow.
+
+Before giving up, try to load the required tools with ToolSearch:
+
+- \`ToolSearch("select:mcp__sellable__get_auth_status")\`
+- \`ToolSearch("select:mcp__sellable__get_subskill_prompt")\`
+- \`ToolSearch("select:mcp__sellable__search_subskill_prompts")\`
+
+If the \`mcp__sellable__*\` tools are still not exposed after ToolSearch, 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
+Desktop, then start a new thread.
+
+1. Call \`mcp__sellable__get_auth_status({})\`.
+2. If auth is not OK, stop and show the returned guidance.
+
+## Execute Workflow
+
+1. Load canonical prompt via \`mcp__sellable__get_subskill_prompt({ subskillName: "${name}" })\`.
+2. Follow that prompt exactly.
+
+## MCP Prompt Fallback
+
+If subskill lookup fails, use \`mcp__sellable__search_subskill_prompts({ query: "${name}" })\`, then retry \`get_subskill_prompt\`.
+`;
+}
+
+function codexPluginSkills() {
+  return [
+    {
+      dir: "sellable-create-campaign",
+      displayName: "Sellable Create Campaign",
+      description: "Create a Sellable campaign with approval gates",
+      skillMd: createCampaignSkillMd(),
+    },
+    {
+      dir: "sellable-engage",
+      displayName: "Sellable Engage",
+      description: "Discover posts and draft comments for a comment campaign",
+      skillMd: genericSellableSkillMd({
+        name: "engage",
+        title: "Sellable Engage",
+        description:
+          "Find high-signal LinkedIn posts and draft thoughtful engagement comments, then load approved comments into the sender's comment campaign.",
+      }),
+    },
+    {
+      dir: "sellable-interview",
+      displayName: "Sellable Interview",
+      description: "Build a commenting style guide and ICP profile",
+      skillMd: genericSellableSkillMd({
+        name: "interview",
+        title: "Sellable Interview",
+        description:
+          "Voice-first interview to build your commenting style guide and ICP profile.",
+      }),
+    },
+    {
+      dir: "sellable-workflow-sequences",
+      displayName: "Sellable Workflow Sequences",
+      description: "Create workflow tables and attach outbound sequences",
+      skillMd: genericSellableSkillMd({
+        name: "workflow-sequences",
+        title: "Sellable Workflow Sequences",
+        description:
+          "Create workflow tables via Sellable MCP, attach outbound sequence templates, and avoid manual sequence-column runCondition mistakes.",
+      }),
+    },
+  ];
+}
+
+function writeCodexPluginSkills(pluginRoot, opts) {
+  for (const skill of codexPluginSkills()) {
+    const skillRoot = join(pluginRoot, "skills", skill.dir);
+    writeFile(join(skillRoot, "SKILL.md"), skill.skillMd, opts);
+    writeFile(
+      join(skillRoot, "agents", "openai.yaml"),
+      codexSkillOpenAiYaml(skill.displayName, skill.description),
+      opts
+    );
+  }
+}
+
+function installCodexDesktopPlugin(opts) {
+  const home = codexHome();
+  const configPath = join(home, "config.toml");
+  const marketplaceRoot = join(homedir(), ".sellable", "codex-marketplace");
+  const marketplacePath = join(marketplaceRoot, ".agents", "plugins", "marketplace.json");
+  const pluginRoot = join(marketplaceRoot, "plugins", "sellable");
+  const cacheRoot = join(home, "plugins", "cache", "sellable", "sellable");
+  const pluginCache = join(cacheRoot, CODEX_PLUGIN_VERSION);
+
+  const marketplace = {
+    name: "sellable",
+    interface: {
+      displayName: "Sellable",
+    },
+    plugins: [
+      {
+        name: "sellable",
+        source: {
+          source: "local",
+          path: "./plugins/sellable",
+        },
+        policy: {
+          installation: "AVAILABLE",
+          authentication: "ON_INSTALL",
+        },
+        category: "Productivity",
+      },
+    ],
+  };
+
+  const manifest = codexPluginManifest(opts);
+  const mcp = codexPluginMcp(opts);
+
+  writeFile(marketplacePath, `${JSON.stringify(marketplace, null, 2)}\n`, opts);
+  writeFile(
+    join(pluginRoot, ".codex-plugin", "plugin.json"),
+    `${JSON.stringify(manifest, null, 2)}\n`,
+    opts
+  );
+  writeFile(join(pluginRoot, ".mcp.json"), `${JSON.stringify(mcp, null, 2)}\n`, opts);
+  writeCodexPluginSkills(pluginRoot, opts);
+
+  if (!opts.dryRun) {
+    rmSync(cacheRoot, { recursive: true, force: true });
+  }
+  writeFile(
+    join(pluginCache, ".codex-plugin", "plugin.json"),
+    `${JSON.stringify(manifest, null, 2)}\n`,
+    opts
+  );
+  writeFile(join(pluginCache, ".mcp.json"), `${JSON.stringify(mcp, null, 2)}\n`, opts);
+  writeCodexPluginSkills(pluginCache, opts);
+
+  if (!opts.dryRun) {
+    mkdirSync(home, { recursive: true, mode: 0o700 });
+    let content = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+    content = upsertTomlTable(
+      content,
+      "marketplaces.sellable",
+      `[marketplaces.sellable]
+source_type = "local"
+source = ${quoteToml(marketplaceRoot)}
+last_updated = ${quoteToml(new Date().toISOString())}`
+    );
+    content = upsertTomlTable(
+      content,
+      'plugins."sellable@sellable"',
+      `[plugins."sellable@sellable"]
+enabled = true`
+    );
+    content = upsertTomlTable(
+      content,
+      'plugins."sellable@sellable-local"',
+      `[plugins."sellable@sellable-local"]
+enabled = false`
+    );
+    writeFileSync(configPath, `${content.trimEnd()}\n`, { mode: 0o600 });
+  } else {
+    console.log(`+ upsert [marketplaces.sellable] in ${configPath}`);
+    console.log(`+ enable [plugins."sellable@sellable"] in ${configPath}`);
+    console.log(`+ disable stale [plugins."sellable@sellable-local"] in ${configPath}`);
+  }
+
+  console.log("Codex Desktop plugin installed:");
+  console.log(`- marketplace: ${marketplaceRoot}`);
+  console.log(`- plugin:      sellable@sellable`);
+  console.log(`- cache:       ${pluginCache}`);
+}
+
 function writeAuth(opts) {
   if (!opts.token || !opts.workspaceId) {
     throw new Error(
@@ -299,6 +736,7 @@ function installCodex(opts) {
   }
   if (opts.server === "hosted") {
     run("codex", ["mcp", "add", "sellable", "--url", opts.hostedUrl], opts);
+    installCodexDesktopPlugin(opts);
     return true;
   }
   const [command, args] = mcpCommand(opts);
@@ -308,6 +746,7 @@ function installCodex(opts) {
     allowFail: true,
   });
   run("codex", ["mcp", "add", "sellable", "--", command, ...args], opts);
+  installCodexDesktopPlugin(opts);
   return true;
 }
 
@@ -322,6 +761,29 @@ function verify(opts) {
   }
   if (opts.host === "codex" || opts.host === "all") {
     console.log(commandExists("codex") ? "Codex CLI present" : "Codex CLI missing");
+    const pluginPath = join(
+      codexHome(),
+      "plugins",
+      "cache",
+      "sellable",
+      "sellable",
+      CODEX_PLUGIN_VERSION,
+      ".codex-plugin",
+      "plugin.json"
+    );
+    const skillPath = join(
+      codexHome(),
+      "plugins",
+      "cache",
+      "sellable",
+      "sellable",
+      CODEX_PLUGIN_VERSION,
+      "skills",
+      "sellable-create-campaign",
+      "SKILL.md"
+    );
+    console.log(existsSync(pluginPath) ? "Codex Desktop plugin present" : "Codex Desktop plugin missing");
+    console.log(existsSync(skillPath) ? "Codex skill bundle present" : "Codex skill bundle missing");
   }
 }
 

package/package.json

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