@sellable/install 0.1.1 → 0.1.3

package/README.md

@@ -6,6 +6,8 @@ Installs Sellable MCP for Claude Code and Codex.
 npx -y @sellable/install --host all
 ```
 
+If you do not pass a token, the installer prompts you for one and shows where to get it.
+
 The installer uses package stdio MCP by default:
 
 ```bash
@@ -18,7 +20,7 @@ Get a Sellable API token from:
 https://app.sellable.dev/settings
 ```
 
-Then pass it with `--token` or `SELLABLE_TOKEN`.
+Then paste it into the installer, or pass it with `--token` / `SELLABLE_TOKEN`.
 
 Auth is stored once at:
 
@@ -27,3 +29,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` 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,12 +1,15 @@
 #!/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";
+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.3";
 
 function usage() {
   return `Sellable agent installer
@@ -30,7 +33,8 @@ Options:
 
 Auth:
   Sign up or log in at ${DEFAULT_API_URL}/settings, create an API token, then
-  pass it with --token or SELLABLE_TOKEN.
+  pass it with --token or SELLABLE_TOKEN. In an interactive terminal, the
+  installer will prompt for missing auth values.
 `;
 }
 
@@ -124,6 +128,87 @@ function commandExists(command) {
   return result.status === 0;
 }
 
+function isInteractive() {
+  return Boolean(input.isTTY && output.isTTY);
+}
+
+function authPath() {
+  return join(homedir(), ".sellable", "config.json");
+}
+
+function normalizeStoredAuth(raw) {
+  if (raw?.activeEnv && raw?.environments) {
+    const env = raw.environments[raw.activeEnv];
+    if (!env) return null;
+    return {
+      token: env.token,
+      workspaceId: env.activeWorkspaceId || env.workspaceId,
+      apiUrl: env.apiUrl,
+    };
+  }
+
+  return {
+    token: raw?.token,
+    workspaceId: raw?.activeWorkspaceId || raw?.workspaceId,
+    apiUrl: raw?.apiUrl,
+  };
+}
+
+function readStoredAuth() {
+  const raw = readExisting(authPath());
+  return raw ? normalizeStoredAuth(raw) : null;
+}
+
+async function promptForMissingAuth(opts) {
+  if (opts.token && opts.workspaceId) return opts;
+
+  const stored = readStoredAuth();
+  if (stored?.token && stored?.workspaceId) {
+    opts.token ||= stored.token;
+    opts.workspaceId ||= stored.workspaceId;
+    opts.apiUrl = opts.apiUrl || stored.apiUrl || DEFAULT_API_URL;
+    opts.authFromExistingConfig = true;
+    console.log(`Using existing Sellable auth config: ${authPath()}`);
+    return opts;
+  }
+
+  if (!isInteractive()) {
+    throw new Error(
+      [
+        "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>",
+        "",
+        "You can also use SELLABLE_TOKEN and SELLABLE_WORKSPACE_ID.",
+      ].join("\n")
+    );
+  }
+
+  console.log("");
+  console.log("Sellable needs one API token to connect Claude/Codex to your workspace.");
+  console.log(`Open ${opts.apiUrl}/settings, create a token, then paste the values below.`);
+  console.log(`Auth will be stored once at ${authPath()}.`);
+  console.log("");
+
+  const rl = createInterface({ input, output });
+  try {
+    if (!opts.token) {
+      opts.token = (await rl.question("Sellable API token: ")).trim();
+    }
+    if (!opts.workspaceId) {
+      opts.workspaceId = (await rl.question("Sellable workspace id: ")).trim();
+    }
+  } finally {
+    rl.close();
+  }
+
+  if (!opts.token || !opts.workspaceId) {
+    throw new Error("Sellable token and workspace id are both required.");
+  }
+
+  return opts;
+}
+
 function writeJson(path, data, opts) {
   const redacted = JSON.stringify({ ...data, token: redact(data.token) }, null, 2);
   console.log(`Writing ${path}: ${redacted}`);
@@ -141,6 +226,198 @@ 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],
+      },
+    },
+  };
+}
+
+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);
+
+  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);
+
+  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(
@@ -154,7 +431,12 @@ function writeAuth(opts) {
     apiUrl: opts.apiUrl,
   };
 
-  const sellablePath = join(homedir(), ".sellable", "config.json");
+  if (opts.authFromExistingConfig) {
+    console.log(`Leaving existing Sellable auth config unchanged: ${authPath()}`);
+    return;
+  }
+
+  const sellablePath = authPath();
   writeJson(sellablePath, config, opts);
 }
 
@@ -178,11 +460,16 @@ function mcpCommand(opts) {
 
 function installClaude(opts) {
   if (!commandExists("claude")) {
-    throw new Error("Missing Claude CLI. Install/login to Claude Code, then rerun this installer.");
+    const message = "Claude CLI not found. Install/login to Claude Code, then rerun: sellable --host claude";
+    if (opts.host === "all") {
+      console.log(`Skipping Claude Code: ${message}`);
+      return false;
+    }
+    throw new Error(message);
   }
   if (opts.server === "hosted") {
     run("claude", ["mcp", "add", "--transport", "http", "sellable", opts.hostedUrl], opts);
-    return;
+    return true;
   }
   const [command, args] = mcpCommand(opts);
   run("claude", ["mcp", "remove", "sellable"], {
@@ -191,15 +478,22 @@ function installClaude(opts) {
     allowFail: true,
   });
   run("claude", ["mcp", "add", "--transport", "stdio", "sellable", "--", command, ...args], opts);
+  return true;
 }
 
 function installCodex(opts) {
   if (!commandExists("codex")) {
-    throw new Error("Missing Codex CLI. Install/login to Codex, then rerun this installer.");
+    const message = "Codex CLI not found. Install/login to Codex, then rerun: sellable --host codex";
+    if (opts.host === "all") {
+      console.log(`Skipping Codex: ${message}`);
+      return false;
+    }
+    throw new Error(message);
   }
   if (opts.server === "hosted") {
     run("codex", ["mcp", "add", "sellable", "--url", opts.hostedUrl], opts);
-    return;
+    installCodexDesktopPlugin(opts);
+    return true;
   }
   const [command, args] = mcpCommand(opts);
   run("codex", ["mcp", "remove", "sellable"], {
@@ -208,24 +502,49 @@ function installCodex(opts) {
     allowFail: true,
   });
   run("codex", ["mcp", "add", "sellable", "--", command, ...args], opts);
+  installCodexDesktopPlugin(opts);
+  return true;
 }
 
 function verify(opts) {
-  const authPath = join(homedir(), ".sellable", "config.json");
-  const auth = readExisting(authPath);
-  if (!auth?.token || !auth?.activeWorkspaceId) {
-    throw new Error(`Sellable auth config missing or incomplete: ${authPath}`);
+  const stored = readStoredAuth();
+  if (!stored?.token || !stored?.workspaceId) {
+    throw new Error(`Sellable auth config missing or incomplete: ${authPath()}`);
   }
-  console.log(`Sellable auth config present: ${authPath}`);
+  console.log(`Sellable auth config present: ${authPath()}`);
   if (opts.host === "claude" || opts.host === "all") {
     console.log(commandExists("claude") ? "Claude CLI present" : "Claude CLI missing");
   }
   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"
+    );
+    console.log(existsSync(pluginPath) ? "Codex Desktop plugin present" : "Codex Desktop plugin missing");
   }
 }
 
-function main() {
+function printNextSteps(installedHosts) {
+  console.log("");
+  console.log("Next steps:");
+  if (installedHosts.length > 0) {
+    console.log(`1. Fully quit and reopen ${installedHosts.join(" and ")} so MCP tools reload.`);
+    console.log("2. Start a new thread and choose Sellable Create Campaign.");
+    console.log("3. If tools do not appear, run: sellable --verify-only --host all");
+  } else {
+    console.log("1. Install Claude Code or Codex, then rerun this installer for that host.");
+    console.log("2. Verify auth later with: sellable --verify-only --host all");
+  }
+}
+
+async function main() {
   try {
     const opts = parseArgs(process.argv.slice(2));
     if (opts.help) {
@@ -239,10 +558,16 @@ function main() {
     console.log(`- api: ${opts.apiUrl}`);
     console.log(`- token: ${opts.token ? redact(opts.token) : "(missing)"}`);
 
+    const installedHosts = [];
     if (!opts.verifyOnly) {
+      await promptForMissingAuth(opts);
       writeAuth(opts);
-      if (opts.host === "claude" || opts.host === "all") installClaude(opts);
-      if (opts.host === "codex" || opts.host === "all") installCodex(opts);
+      if (opts.host === "claude" || opts.host === "all") {
+        if (installClaude(opts)) installedHosts.push("Claude Code");
+      }
+      if (opts.host === "codex" || opts.host === "all") {
+        if (installCodex(opts)) installedHosts.push("Codex");
+      }
     }
     if (opts.dryRun) {
       console.log("Dry run complete; verification skipped because no files were written.");
@@ -250,6 +575,7 @@ function main() {
       verify(opts);
     }
     console.log("Sellable install complete.");
+    if (!opts.verifyOnly && !opts.dryRun) printNextSteps(installedHosts);
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));
     process.exitCode = 1;

package/package.json

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