@sellable/install 0.1.0

package/README.md

@@ -0,0 +1,21 @@
+# Sellable Installer
+
+Installs Sellable MCP for Claude Code and Codex.
+
+```bash
+npx -y @sellable/install --host all
+```
+
+The installer uses package stdio MCP by default:
+
+```bash
+npx -y @sellable/mcp
+```
+
+Get a Sellable API token from:
+
+```text
+https://app.sellable.dev/settings
+```
+
+Then pass it with `--token` or `SELLABLE_TOKEN`.

package/bin/sellable-install.mjs

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+const DEFAULT_API_URL = "https://app.sellable.dev";
+const DEFAULT_SERVER_PACKAGE =
+  process.env.SELLABLE_MCP_PACKAGE || "@sellable/mcp";
+
+function usage() {
+  return `Sellable agent installer
+
+Usage:
+  sellable-install [options]
+  npx -y @sellable/install -- [options]
+
+Options:
+  --host <host>             claude, codex, or all. Default: all
+  --server <mode>           package, local, or hosted. Default: package
+  --token <token>           Sellable API token. Also reads SELLABLE_TOKEN.
+  --workspace-id <id>       Sellable workspace id. Also reads SELLABLE_WORKSPACE_ID.
+  --api-url <url>           Sellable API URL. Default: ${DEFAULT_API_URL}
+  --mcp-package <pkg>       MCP server package. Default: ${DEFAULT_SERVER_PACKAGE}
+  --local-command <cmd>     Local MCP command for --server local.
+  --hosted-url <url>        Hosted MCP URL for --server hosted.
+  --dry-run                 Print actions without writing or running host commands.
+  --verify-only             Verify installed host config where possible.
+  --help                    Show help.
+
+Auth:
+  Sign up or log in at ${DEFAULT_API_URL}/settings, create an API token, then
+  pass it with --token or SELLABLE_TOKEN.
+`;
+}
+
+function parseArgs(argv) {
+  const opts = {
+    host: process.env.SELLABLE_INSTALL_HOST || "all",
+    server: process.env.SELLABLE_INSTALL_SERVER || "package",
+    token: process.env.SELLABLE_TOKEN || "",
+    workspaceId: process.env.SELLABLE_WORKSPACE_ID || "",
+    apiUrl: process.env.SELLABLE_API_URL || DEFAULT_API_URL,
+    mcpPackage: DEFAULT_SERVER_PACKAGE,
+    localCommand: process.env.SELLABLE_MCP_LOCAL_COMMAND || "",
+    hostedUrl: process.env.SELLABLE_MCP_HOSTED_URL || "",
+    dryRun: false,
+    verifyOnly: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    const next = () => {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+      i += 1;
+      return value;
+    };
+
+    if (arg === "--help" || arg === "-h") {
+      opts.help = true;
+    } else if (arg === "--host") {
+      opts.host = next();
+    } else if (arg === "--server") {
+      opts.server = next();
+    } else if (arg === "--token") {
+      opts.token = next();
+    } else if (arg === "--workspace-id") {
+      opts.workspaceId = next();
+    } else if (arg === "--api-url") {
+      opts.apiUrl = next();
+    } else if (arg === "--mcp-package") {
+      opts.mcpPackage = next();
+    } else if (arg === "--local-command") {
+      opts.localCommand = next();
+    } else if (arg === "--hosted-url") {
+      opts.hostedUrl = next();
+    } else if (arg === "--dry-run") {
+      opts.dryRun = true;
+    } else if (arg === "--verify-only") {
+      opts.verifyOnly = true;
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+
+  if (!["claude", "codex", "all"].includes(opts.host)) {
+    throw new Error("--host must be claude, codex, or all");
+  }
+  if (!["package", "local", "hosted"].includes(opts.server)) {
+    throw new Error("--server must be package, local, or hosted");
+  }
+
+  return opts;
+}
+
+function redact(value) {
+  if (!value) return "";
+  if (value.length <= 10) return "[redacted]";
+  return `${value.slice(0, 6)}...[redacted]...${value.slice(-4)}`;
+}
+
+function run(command, args, opts = {}) {
+  const rendered = [command, ...args].join(" ");
+  console.log(`+ ${rendered.replace(opts.token || "__NO_TOKEN__", "[redacted-token]")}`);
+  if (opts.dryRun) return { status: 0, stdout: "", stderr: "" };
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    stdio: "pipe",
+  });
+  if (result.status !== 0 && !opts.allowFail) {
+    const stderr = (result.stderr || "").trim();
+    throw new Error(`${command} failed${stderr ? `: ${stderr}` : ""}`);
+  }
+  return result;
+}
+
+function commandExists(command) {
+  const result = spawnSync("sh", ["-lc", `command -v ${command}`], {
+    encoding: "utf8",
+  });
+  return result.status === 0;
+}
+
+function writeJson(path, data, opts) {
+  const redacted = JSON.stringify({ ...data, token: redact(data.token) }, null, 2);
+  console.log(`Writing ${path}: ${redacted}`);
+  if (opts.dryRun) return;
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
+}
+
+function readExisting(path) {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeAuth(opts) {
+  if (!opts.token || !opts.workspaceId) {
+    throw new Error(
+      `Missing Sellable token/workspace id. Create a token at ${opts.apiUrl}/settings, then rerun with --token and --workspace-id or SELLABLE_TOKEN and SELLABLE_WORKSPACE_ID.`
+    );
+  }
+
+  const config = {
+    token: opts.token,
+    activeWorkspaceId: opts.workspaceId,
+    apiUrl: opts.apiUrl,
+  };
+
+  const sellablePath = join(homedir(), ".sellable", "config.json");
+  const claudePath = join(homedir(), ".claude", "sellable.json");
+  const codexPath = join(homedir(), ".codex", "sellable.json");
+
+  writeJson(sellablePath, config, opts);
+  if (opts.host === "claude" || opts.host === "all") writeJson(claudePath, config, opts);
+  if (opts.host === "codex" || opts.host === "all") writeJson(codexPath, config, opts);
+}
+
+function mcpCommand(opts) {
+  if (opts.server === "package") {
+    return ["npx", ["-y", opts.mcpPackage]];
+  }
+  if (opts.server === "local") {
+    if (!opts.localCommand) {
+      throw new Error("--server local requires --local-command");
+    }
+    return ["sh", ["-lc", opts.localCommand]];
+  }
+  if (!opts.hostedUrl) {
+    throw new Error(
+      "--server hosted requires --hosted-url. Hosted MCP is not the default until Sellable ships a hosted MCP endpoint."
+    );
+  }
+  return ["hosted", [opts.hostedUrl]];
+}
+
+function installClaude(opts) {
+  if (!commandExists("claude")) {
+    throw new Error("Missing Claude CLI. Install/login to Claude Code, then rerun this installer.");
+  }
+  if (opts.server === "hosted") {
+    run("claude", ["mcp", "add", "--transport", "http", "sellable", opts.hostedUrl], opts);
+    return;
+  }
+  const [command, args] = mcpCommand(opts);
+  run("claude", ["mcp", "remove", "sellable"], {
+    ...opts,
+    dryRun: opts.dryRun,
+    allowFail: true,
+  });
+  run("claude", ["mcp", "add", "--transport", "stdio", "sellable", "--", command, ...args], opts);
+}
+
+function installCodex(opts) {
+  if (!commandExists("codex")) {
+    throw new Error("Missing Codex CLI. Install/login to Codex, then rerun this installer.");
+  }
+  if (opts.server === "hosted") {
+    run("codex", ["mcp", "add", "sellable", "--url", opts.hostedUrl], opts);
+    return;
+  }
+  const [command, args] = mcpCommand(opts);
+  run("codex", ["mcp", "remove", "sellable"], {
+    ...opts,
+    dryRun: opts.dryRun,
+    allowFail: true,
+  });
+  run("codex", ["mcp", "add", "sellable", "--", command, ...args], opts);
+}
+
+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}`);
+  }
+  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");
+  }
+}
+
+function main() {
+  try {
+    const opts = parseArgs(process.argv.slice(2));
+    if (opts.help) {
+      console.log(usage());
+      return;
+    }
+
+    console.log("Sellable installer");
+    console.log(`- host: ${opts.host}`);
+    console.log(`- server: ${opts.server}`);
+    console.log(`- api: ${opts.apiUrl}`);
+    console.log(`- token: ${opts.token ? redact(opts.token) : "(missing)"}`);
+
+    if (!opts.verifyOnly) {
+      writeAuth(opts);
+      if (opts.host === "claude" || opts.host === "all") installClaude(opts);
+      if (opts.host === "codex" || opts.host === "all") installCodex(opts);
+    }
+    if (opts.dryRun) {
+      console.log("Dry run complete; verification skipped because no files were written.");
+    } else {
+      verify(opts);
+    }
+    console.log("Sellable install complete.");
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@sellable/install",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "One-command installer for Sellable MCP in Claude Code and Codex",
+  "bin": {
+    "sellable": "bin/sellable-install.mjs"
+  },
+  "files": [
+    "bin",
+    "README.md"
+  ],
+  "keywords": [
+    "sellable",
+    "mcp",
+    "claude-code",
+    "codex",
+    "linkedin",
+    "outbound"
+  ],
+  "author": "Sellable",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}