@sellable/install 0.1.208 → 0.1.209

package/bin/sellable-install.mjs

@@ -136,13 +136,22 @@ function usage() {
   return `Sellable agent installer
 
 Usage:
+  curl -fsSL "https://app.sellable.dev/api/v2/cli/install" | sh
   sellable create
+  sellable prefs set prompt-sharing true|false
+  sellable setup claude-permissions --allow-common-setup
   sellable-install [options]
+
+Advanced fallback:
   npx -y @sellable/install@latest -- [options]
 
 Commands:
   create                   Show how to launch public Sellable workflows.
   auth set <token>         Save a Sellable API token for first-run auth.
+  prefs set prompt-sharing true|false
+                           Save the ask-first prompt-sharing preference.
+  setup claude-permissions --allow-common-setup
+                           Add common Sellable Bash permissions to Claude settings.
   uninstall                Remove Sellable host config and installed artifacts.
 
 Options:
@@ -427,6 +436,83 @@ function readExisting(path) {
   }
 }
 
+function sellableHostEnvPath() {
+  return join(homedir(), ".local", "sellable", "app-sellable-dev", ".env");
+}
+
+function writePromptSharingPreference(value, opts = { dryRun: false }) {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (normalized !== "true" && normalized !== "false") {
+    throw new Error("prompt-sharing must be true or false");
+  }
+  const envPath = sellableHostEnvPath();
+  const key = "SELLABLE_SHARE_SESSION_USER_PROMPTS";
+  const line = `${key}=${normalized}`;
+  const existing = existsSync(envPath) ? readFileSync(envPath, "utf8") : "";
+  const lines = existing
+    .split(/\r?\n/)
+    .filter((existingLine) => existingLine.trim() !== "");
+  let replaced = false;
+  const nextLines = lines.map((existingLine) => {
+    if (existingLine.startsWith(`${key}=`)) {
+      replaced = true;
+      return line;
+    }
+    return existingLine;
+  });
+  if (!replaced) nextLines.push(line);
+
+  if (!opts.dryRun) {
+    mkdirSync(dirname(envPath), { recursive: true, mode: 0o700 });
+    writeFileSync(envPath, `${nextLines.join("\n")}\n`, { mode: 0o600 });
+  }
+  return envPath;
+}
+
+const CLAUDE_COMMON_SETUP_ALLOW = [
+  "Bash(sellable *)",
+  "Bash(export PATH=$HOME/.local/bin:$PATH && sellable *)",
+];
+
+function claudeSettingsPath() {
+  return join(homedir(), ".claude", "settings.json");
+}
+
+function allowClaudeCommonSetup(opts = { dryRun: false }) {
+  const settingsPath = claudeSettingsPath();
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+    } catch (err) {
+      throw new Error(
+        `Could not parse ${settingsPath}: ${
+          err instanceof Error ? err.message : String(err)
+        }`
+      );
+    }
+  }
+  if (!settings || typeof settings !== "object" || Array.isArray(settings)) {
+    settings = {};
+  }
+  const permissions =
+    settings.permissions &&
+    typeof settings.permissions === "object" &&
+    !Array.isArray(settings.permissions)
+      ? settings.permissions
+      : {};
+  const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
+  const nextAllow = [...allow];
+  for (const entry of CLAUDE_COMMON_SETUP_ALLOW) {
+    if (!nextAllow.includes(entry)) nextAllow.push(entry);
+  }
+  settings.permissions = { ...permissions, allow: nextAllow };
+  if (!opts.dryRun) {
+    writeJson(settingsPath, settings, opts);
+  }
+  return settingsPath;
+}
+
 function codexHome() {
   return process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
 }
@@ -1868,12 +1954,7 @@ function legacyClaudeCustomAgents() {
 }
 
 function legacyClaudeCommands() {
-  return [
-    {
-      name: "sellable-create-campaign",
-      filename: join("sellable", "create-campaign.md"),
-    },
-  ];
+  return [];
 }
 
 function tomlArray(values) {
@@ -1930,6 +2011,72 @@ function claudeCustomAgents() {
   }));
 }
 
+function stripFrontmatter(markdown) {
+  return String(markdown).replace(/^---\n[\s\S]*?\n---\n?/, "").trimStart();
+}
+
+function claudeCommandMd(command) {
+  const allowedTools =
+    command.allowedTools && command.allowedTools.length > 0
+      ? `allowed-tools:\n${allowedToolsYaml(command.allowedTools)}\n`
+      : "";
+  return `---
+name: sellable:${command.name}
+description: ${yamlString(command.description)}
+argument-hint: ${yamlString(command.argumentHint || "[instructions]")}
+${allowedTools}---
+
+# Sellable ${command.title}
+
+This Claude Code command is the customer-facing entrypoint for
+\`/sellable:${command.name}\`.
+
+${stripFrontmatter(command.skillMd)}
+`;
+}
+
+function claudeCommands() {
+  return [
+    {
+      name: "create-campaign",
+      title: "Create Campaign",
+      filename: join("sellable", "create-campaign.md"),
+      description: "Create a Sellable campaign through the approval-gated workflow.",
+      argumentHint: "[campaign goal, company, or offer]",
+      skillMd: createCampaignSkillMd(),
+      allowedTools: ["AskUserQuestion", "Task", ...CREATE_CAMPAIGN_ALLOWED_TOOLS],
+    },
+    {
+      name: "foundation",
+      title: "Foundation",
+      filename: join("sellable", "foundation.md"),
+      description: FOUNDATION_SKILL_DESCRIPTION,
+      argumentHint: "[founder/company context]",
+      skillMd: foundationSkillMd(),
+    },
+    {
+      name: "content",
+      title: "Content",
+      filename: join("sellable", "content.md"),
+      description:
+        "Add transcripts and rough ideas, cluster themes, and hand post requests to create-post.",
+      argumentHint: "[idea, transcript, or content goal]",
+      skillMd: contentSkillMd(),
+    },
+    {
+      name: "create-post",
+      title: "Create Post",
+      filename: join("sellable", "create-post.md"),
+      description: "Capture ideas and draft LinkedIn posts in the user's voice.",
+      argumentHint: "[post idea or source material]",
+      skillMd: createPostSkillMd(),
+    },
+  ].map((command) => ({
+    ...command,
+    content: claudeCommandMd(command),
+  }));
+}
+
 function writeCodexPluginSkills(pluginRoot, opts) {
   const skills = codexPluginSkills();
   const currentSkillDirs = new Set(skills.map((skill) => skill.dir));
@@ -1982,6 +2129,7 @@ function writeClaudeCustomAgents(opts) {
   for (const agent of claudeCustomAgents()) {
     writeFile(join(home, "agents", agent.filename), agent.content, opts);
   }
+  writeClaudeCommands(opts);
   for (const agent of legacyClaudeCustomAgents()) {
     const legacyPath = join(home, "agents", agent.filename);
     logVerbose(
@@ -1992,6 +2140,13 @@ function writeClaudeCustomAgents(opts) {
   removeLegacyClaudeCommands(home, opts);
 }
 
+function writeClaudeCommands(opts) {
+  const home = claudeHome();
+  for (const command of claudeCommands()) {
+    writeFile(join(home, "commands", command.filename), command.content, opts);
+  }
+}
+
 function removeLegacyClaudeCommands(home, opts) {
   for (const command of legacyClaudeCommands()) {
     const commandPath = join(home, "commands", command.filename);
@@ -2277,12 +2432,15 @@ function installClaude(opts) {
     throw new Error(message);
   }
   writeClaudeCustomAgents(opts);
+  removeClaudeMcp(opts);
   if (opts.server === "hosted") {
     run(
       "claude",
       [
         "mcp",
         "add",
+        "--scope",
+        "user",
         "--transport",
         "http",
         "sellable",
@@ -2294,14 +2452,20 @@ function installClaude(opts) {
     return true;
   }
   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],
+    [
+      "mcp",
+      "add",
+      "--scope",
+      "user",
+      "--transport",
+      "stdio",
+      "sellable",
+      "--",
+      command,
+      ...args,
+    ],
     opts
   );
   // Patch ~/.claude.json to add `alwaysLoad: true` so Claude Code v2.1.121+
@@ -2312,6 +2476,63 @@ function installClaude(opts) {
   return true;
 }
 
+function removeClaudeMcp(opts) {
+  for (const scope of ["local", "project", "user"]) {
+    run("claude", ["mcp", "remove", "--scope", scope, "sellable"], {
+      ...opts,
+      dryRun: opts.dryRun,
+      allowFail: true,
+    });
+  }
+}
+
+function canonicalClaudeMcpServer(opts) {
+  if (opts.server === "hosted") {
+    return {
+      type: "http",
+      url: withHostedWatchModeDriver(opts.hostedUrl, "claude"),
+      alwaysLoad: true,
+    };
+  }
+
+  const [command, args] = mcpCommand(opts);
+  return {
+    type: "stdio",
+    command,
+    args,
+    env: { SELLABLE_WATCH_MODE_DRIVER: "claude" },
+    alwaysLoad: true,
+  };
+}
+
+function collectClaudeSellableServers(config) {
+  const servers = [];
+  if (config?.mcpServers?.sellable) {
+    servers.push(config.mcpServers.sellable);
+  }
+  for (const projectPath of Object.keys(config?.projects || {})) {
+    const server = config.projects[projectPath]?.mcpServers?.sellable;
+    if (server) {
+      servers.push(server);
+    }
+  }
+  return servers;
+}
+
+function claudeMcpServerMatches(server, canonical) {
+  if (!server || typeof server !== "object") return false;
+  if (server.alwaysLoad !== true) return false;
+  if (canonical.type === "http") {
+    return server.type === canonical.type && server.url === canonical.url;
+  }
+  return (
+    server.type === canonical.type &&
+    server.command === canonical.command &&
+    JSON.stringify(server.args || []) === JSON.stringify(canonical.args) &&
+    server.env?.SELLABLE_WATCH_MODE_DRIVER === "claude"
+  );
+}
+
 function patchClaudeAlwaysLoad(opts) {
   if (opts.dryRun) {
     logVerbose(
@@ -2329,18 +2550,44 @@ function patchClaudeAlwaysLoad(opts) {
   try {
     const raw = readFileSync(claudeJsonPath, "utf8");
     const config = JSON.parse(raw);
+    const canonical = canonicalClaudeMcpServer(opts);
     let touched = false;
     const patchSellableServer = (server) => {
       if (!server || typeof server !== "object") return;
-      if (server.alwaysLoad !== true) {
-        server.alwaysLoad = true;
-        touched = true;
-      }
-      const isHttpServer =
-        typeof server.url === "string" ||
-        server.type === "http" ||
-        server.transport === "http";
-      if (!isHttpServer) {
+      if (opts.server === "hosted") {
+        for (const staleKey of ["command", "args", "env"]) {
+          if (staleKey in server) {
+            delete server[staleKey];
+            touched = true;
+          }
+        }
+        if (server.type !== canonical.type) {
+          server.type = canonical.type;
+          touched = true;
+        }
+        if (server.url !== canonical.url) {
+          server.url = canonical.url;
+          touched = true;
+        }
+      } else {
+        for (const staleKey of ["url"]) {
+          if (staleKey in server) {
+            delete server[staleKey];
+            touched = true;
+          }
+        }
+        if (server.type !== canonical.type) {
+          server.type = canonical.type;
+          touched = true;
+        }
+        if (server.command !== canonical.command) {
+          server.command = canonical.command;
+          touched = true;
+        }
+        if (JSON.stringify(server.args || []) !== JSON.stringify(canonical.args)) {
+          server.args = [...canonical.args];
+          touched = true;
+        }
         const existingDriver = server.env?.SELLABLE_WATCH_MODE_DRIVER;
         server.env = {
           ...(server.env && typeof server.env === "object" ? server.env : {}),
@@ -2350,12 +2597,16 @@ function patchClaudeAlwaysLoad(opts) {
           touched = true;
         }
       }
+      if (server.alwaysLoad !== true) {
+        server.alwaysLoad = true;
+        touched = true;
+      }
     };
-    // Top-level mcpServers.sellable (older claude versions)
+    // Top-level mcpServers.sellable (user scope)
     if (config.mcpServers?.sellable) {
       patchSellableServer(config.mcpServers.sellable);
     }
-    // Per-project mcpServers.sellable (current claude default)
+    // Per-project mcpServers.sellable (old local/project installs)
     for (const projectPath of Object.keys(config.projects || {})) {
       const projServers = config.projects[projectPath]?.mcpServers;
       if (projServers?.sellable) {
@@ -2469,6 +2720,34 @@ async function verify(opts) {
           : "Claude custom agent MCP tool allowlists missing"
       )
     );
+    const claudeCommandPaths = claudeCommands().map((command) =>
+      join(claudeHome(), "commands", command.filename)
+    );
+    const hasClaudeCommands = claudeCommandPaths.every((commandPath) =>
+      existsSync(commandPath)
+    );
+    checks.push(
+      warningCheck(
+        hasClaudeCommands,
+        hasClaudeCommands
+          ? "Claude slash commands present"
+          : "Claude slash commands missing"
+      )
+    );
+    const claudeCommandsHaveCurrentNames = claudeCommands().every((command) => {
+      const commandPath = join(claudeHome(), "commands", command.filename);
+      if (!existsSync(commandPath)) return false;
+      const content = readFileSync(commandPath, "utf8");
+      return content.includes(`name: sellable:${command.name}`);
+    });
+    checks.push(
+      warningCheck(
+        claudeCommandsHaveCurrentNames,
+        claudeCommandsHaveCurrentNames
+          ? "Claude slash command names current"
+          : "Claude slash command names stale"
+      )
+    );
     const legacyClaudePaths = [
       ...legacyClaudeCustomAgents().map((agent) =>
         join(claudeHome(), "agents", agent.filename)
@@ -2504,6 +2783,25 @@ async function verify(opts) {
           : "Claude watch mode driver missing"
       )
     );
+    let claudeMcpEntriesCanonical = false;
+    try {
+      const config = claudeConfigContent ? JSON.parse(claudeConfigContent) : {};
+      const servers = collectClaudeSellableServers(config);
+      const canonical = canonicalClaudeMcpServer(opts);
+      claudeMcpEntriesCanonical =
+        servers.length > 0 &&
+        servers.every((server) => claudeMcpServerMatches(server, canonical));
+    } catch {
+      claudeMcpEntriesCanonical = false;
+    }
+    checks.push(
+      warningCheck(
+        claudeMcpEntriesCanonical,
+        claudeMcpEntriesCanonical
+          ? "Claude Sellable MCP entries canonical"
+          : "Claude Sellable MCP entries stale"
+      )
+    );
   }
   if (opts.host === "codex" || opts.host === "all") {
     const hasCodexCli = commandExists("codex");
@@ -2886,7 +3184,9 @@ function printNextSteps(installedHosts, authReused) {
     console.log(`        ${C.green}✓${C.reset} Codex custom agents installed`);
   }
   if (hasClaude) {
-    console.log(`        ${C.green}✓${C.reset} Claude custom agents installed`);
+    console.log(
+      `        ${C.green}✓${C.reset} Claude slash commands and custom agents installed`
+    );
   }
   if (authReused) {
     console.log(
@@ -3200,6 +3500,45 @@ async function main() {
       console.log(`    Codex: $sellable:create-post`);
       process.exit(0);
     }
+    if (rawArgs[0] === "prefs") {
+      const dryRun = rawArgs.includes("--dry-run");
+      const args = rawArgs.filter((arg) => arg !== "--dry-run");
+      if (
+        args[1] !== "set" ||
+        args[2] !== "prompt-sharing" ||
+        (args[3] !== "true" && args[3] !== "false") ||
+        args.length !== 4
+      ) {
+        console.error(
+          "Usage: sellable prefs set prompt-sharing true|false [--dry-run]"
+        );
+        process.exit(2);
+      }
+      const envPath = writePromptSharingPreference(args[3], { dryRun });
+      console.log(
+        `✓ Sellable prompt sharing preference set to ${args[3]} at ${envPath}`
+      );
+      process.exit(0);
+    }
+    if (rawArgs[0] === "setup") {
+      const dryRun = rawArgs.includes("--dry-run");
+      const args = rawArgs.filter((arg) => arg !== "--dry-run");
+      if (args[1] !== "claude-permissions") {
+        console.error(
+          `Unknown setup subcommand: ${args[1] ?? "(none)"}\nKnown: claude-permissions`
+        );
+        process.exit(2);
+      }
+      if (!args.includes("--allow-common-setup")) {
+        console.error(
+          "Usage: sellable setup claude-permissions --allow-common-setup [--dry-run]"
+        );
+        process.exit(2);
+      }
+      const settingsPath = allowClaudeCommonSetup({ dryRun });
+      console.log(`✓ Claude Sellable permissions updated at ${settingsPath}`);
+      process.exit(0);
+    }
     if (rawArgs[0] === "uninstall") {
       runUninstall();
       process.exit(0);

package/package.json

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