@sellable/install 0.1.302 → 0.1.304

package/README.md

@@ -16,7 +16,7 @@ Windows users can use PowerShell or Windows Terminal:
 iwr "https://app.sellable.dev/api/v2/cli/install.ps1" | iex
 ```
 
-After install, restart Claude Code, Codex Desktop, or Hermes so Sellable MCP
+After install, restart Codex Desktop, Claude Code, or Hermes so Sellable MCP
 tools and skills reload. In an active Hermes session, `/reload-mcp` and
 `/reload-skills` can reload the new config.
 
@@ -83,6 +83,80 @@ Auth is stored once at:
 ~/.sellable/config.json
 ```
 
+## Hermes Profile-Scoped Installs
+
+For a single local Hermes profile, point Sellable auth and memory at the profile
+instead of the global `~/.sellable/config.json`:
+
+```bash
+profile="$HOME/.hermes/profiles/acme"
+sellable --host hermes \
+  --sellable-config-path "$profile/sellable/config.json" \
+  --sellable-configs-dir "$profile/sellable/configs"
+```
+
+That writes `SELLABLE_CONFIG_PATH` and `SELLABLE_CONFIGS_DIR` into
+`mcp_servers.sellable.env`, so first-run login, `get_auth_status`, workspace
+switches, and Sellable memory all use the same profile-local files. Hosted MCP
+mode does not receive local filesystem paths.
+
+For zero-shot local or Hostinger/Linux VPS bootstrap, use the profile command:
+
+```bash
+sellable hermes profile bootstrap \
+  --profile acme \
+  --profiles-root /srv/hermes/profiles \
+  --workspace-id ws_acme \
+  --workspace-name Acme \
+  --token-file /run/secrets/sellable-acme-token \
+  --json
+```
+
+It creates:
+
+```text
+/srv/hermes/profiles/acme/config.yaml
+/srv/hermes/profiles/acme/sellable/config.json
+/srv/hermes/profiles/acme/sellable/configs/
+/srv/hermes/profiles/acme/skills/sellable/
+/srv/hermes/profiles/acme/.env        # only when Slack token inputs are supplied
+```
+
+If no token is supplied, bootstrap still creates a pending
+`sellable/config.json` so the profile path is concrete from the first MCP
+launch. Finish auth with:
+
+```bash
+sellable auth set <token> --workspace-id <workspace_id> \
+  --sellable-config-path /srv/hermes/profiles/acme/sellable/config.json
+```
+
+Slack Socket Mode tokens can be written profile-locally:
+
+```bash
+sellable hermes profile bootstrap \
+  --profile acme \
+  --profiles-root /srv/hermes/profiles \
+  --workspace-id ws_acme \
+  --slack-bot-token "$SLACK_BOT_TOKEN" \
+  --slack-app-token "$SLACK_APP_TOKEN"
+```
+
+Customer profiles should use customer-scoped Sellable credentials. A shared
+Sellable admin token can work for internal admin automation, but it is weaker
+isolation and should not be the default for customer profiles. After changing
+Hermes profile config, restart the gateway/session or run `/reload-mcp` and
+`/reload-skills`.
+
+Validate the active profile with the same path inputs:
+
+```bash
+SELLABLE_CONFIG_PATH=/srv/hermes/profiles/acme/sellable/config.json \
+SELLABLE_CONFIGS_DIR=/srv/hermes/profiles/acme/sellable/configs \
+sellable --verify-only --host hermes --json \
+  --artifact /srv/hermes/profiles/acme/sellable/verify-runtime.json
+```
+
 Claude Code, Codex, and Hermes are configured to launch the same packaged MCP server. The
 installer also writes Sellable agent definitions from the packaged `agents/`
 registry, but normal create-campaign runs use only the Message Drafting

package/bin/sellable-install.mjs

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
+import { createHash } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import {
+  chmodSync,
   cpSync,
   existsSync,
   mkdirSync,
@@ -11,7 +13,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join, relative } from "node:path";
+import { dirname, join, relative, resolve } from "node:path";
 import { stdout as output } from "node:process";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
@@ -168,6 +170,8 @@ Commands:
                            Save the ask-first prompt-sharing preference.
   setup claude-permissions --allow-common-setup
                            Add common Sellable Bash permissions to Claude settings.
+  hermes profile bootstrap  Create a profile-local Hermes config, Sellable auth config,
+                           configs dir, skills, and optional Slack .env.
   uninstall                Remove Sellable host config and installed artifacts.
 
 Options:
@@ -176,6 +180,10 @@ Options:
   --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}
+  --sellable-config-path <path>
+                            Profile-scoped Sellable config path. Also reads SELLABLE_CONFIG_PATH.
+  --sellable-configs-dir <path>
+                            Profile-scoped Sellable configs/memory dir. Also reads SELLABLE_CONFIGS_DIR.
   --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.
@@ -199,7 +207,19 @@ Auth:
 
   For CI/scripted installs, pass --token + --workspace-id or set
   SELLABLE_TOKEN + SELLABLE_WORKSPACE_ID and the installer will write the
-  config file directly without prompting.
+  config file directly without prompting. For Hermes customer/admin profiles,
+  also pass --sellable-config-path or set SELLABLE_CONFIG_PATH so auth and MCP
+  runtime use the same profile-local config file.
+
+Hermes profile bootstrap:
+  sellable hermes profile bootstrap --profile acme --profiles-root /srv/hermes/profiles --workspace-id ws_acme --token-file /run/secrets/sellable-token --json
+  sellable hermes profile bootstrap --profile-root "$HOME/.hermes/profiles/acme" --workspace-id ws_acme --json
+
+  Bootstrap writes <profileRoot>/config.yaml, <profileRoot>/sellable/config.json,
+  <profileRoot>/sellable/configs, Sellable Hermes skills, and optional
+  <profileRoot>/.env Slack token keys. Use customer-scoped Sellable credentials
+  for customer profiles; a shared admin token is weaker isolation and should
+  remain internal-only.
 `;
 }
 
@@ -271,6 +291,8 @@ function parseArgs(argv) {
     token: process.env.SELLABLE_TOKEN || "",
     workspaceId: process.env.SELLABLE_WORKSPACE_ID || "",
     apiUrl: process.env.SELLABLE_API_URL || DEFAULT_API_URL,
+    sellableConfigPath: process.env.SELLABLE_CONFIG_PATH || "",
+    sellableConfigsDir: process.env.SELLABLE_CONFIGS_DIR || "",
     mcpPackage: DEFAULT_SERVER_PACKAGE,
     localCommand: process.env.SELLABLE_MCP_LOCAL_COMMAND || "",
     hostedUrl: process.env.SELLABLE_MCP_HOSTED_URL || "",
@@ -305,6 +327,10 @@ function parseArgs(argv) {
       opts.workspaceId = next();
     } else if (arg === "--api-url") {
       opts.apiUrl = next();
+    } else if (arg === "--sellable-config-path") {
+      opts.sellableConfigPath = next();
+    } else if (arg === "--sellable-configs-dir") {
+      opts.sellableConfigsDir = next();
     } else if (arg === "--mcp-package") {
       opts.mcpPackage = normalizeWindowsPackageSpec(next());
     } else if (arg === "--local-command") {
@@ -336,6 +362,11 @@ function parseArgs(argv) {
   if (!["package", "local", "hosted"].includes(opts.server)) {
     throw new Error("--server must be package, local, or hosted");
   }
+  opts.sellableConfigPath = normalizeOptionalPath(opts.sellableConfigPath);
+  opts.sellableConfigsDir = normalizeOptionalPath(opts.sellableConfigsDir);
+  if (opts.sellableConfigPath && !opts.sellableConfigsDir) {
+    opts.sellableConfigsDir = join(dirname(opts.sellableConfigPath), "configs");
+  }
 
   return opts;
 }
@@ -593,8 +624,17 @@ function getMcpVersion() {
   return "latest";
 }
 
-function authPath() {
-  return join(homedir(), ".sellable", "config.json");
+function normalizeOptionalPath(value) {
+  const trimmed = String(value || "").trim();
+  return trimmed ? resolve(trimmed) : "";
+}
+
+function authPath(opts = {}) {
+  return (
+    normalizeOptionalPath(opts.sellableConfigPath) ||
+    normalizeOptionalPath(process.env.SELLABLE_CONFIG_PATH) ||
+    join(homedir(), ".sellable", "config.json")
+  );
 }
 
 function normalizeStoredAuth(raw) {
@@ -615,15 +655,15 @@ function normalizeStoredAuth(raw) {
   };
 }
 
-function readStoredAuth() {
-  const raw = readExisting(authPath());
+function readStoredAuth(opts = {}) {
+  const raw = readExisting(authPath(opts));
   return raw ? normalizeStoredAuth(raw) : null;
 }
 
 async function loadAuthIfPresent(opts) {
   if (opts.token && opts.workspaceId) return opts;
 
-  const stored = readStoredAuth();
+  const stored = readStoredAuth(opts);
   if (stored?.token && stored?.workspaceId) {
     opts.token ||= stored.token;
     opts.workspaceId ||= stored.workspaceId;
@@ -687,7 +727,7 @@ function mergeAuthConfig(raw, auth) {
       Array.isArray(envConfig)
     ) {
       throw new Error(
-        `Unknown active environment '${activeEnv}' in ${authPath()}`
+        `Unknown active environment '${activeEnv}' in configured Sellable auth path`
       );
     }
     return {
@@ -708,8 +748,14 @@ function mergeAuthConfig(raw, auth) {
   };
 }
 
-function writeAuthSetConfig({ token, workspaceId, apiUrl, dryRun }) {
-  const configPath = authPath();
+function writeAuthSetConfig({
+  token,
+  workspaceId,
+  apiUrl,
+  dryRun,
+  sellableConfigPath,
+}) {
+  const configPath = authPath({ sellableConfigPath });
   const raw = readExisting(configPath) || {};
   const config = mergeAuthConfig(raw, {
     token,
@@ -860,6 +906,7 @@ function writeFile(path, content, opts, mode = 0o644) {
   if (opts.dryRun) return;
   mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
   writeFileSync(path, content, { mode });
+  chmodSync(path, mode);
 }
 
 function ensureSymlink(target, linkPath, opts) {
@@ -952,9 +999,7 @@ function codexPluginMcp(opts) {
           type: "stdio",
           command,
           args,
-          env: {
-            SELLABLE_WATCH_MODE_DRIVER: "codex",
-          },
+          env: mcpEnvForHost("codex", opts),
         },
       },
     };
@@ -967,9 +1012,7 @@ function codexPluginMcp(opts) {
         type: "stdio",
         command,
         args,
-        env: {
-          SELLABLE_WATCH_MODE_DRIVER: "codex",
-        },
+        env: mcpEnvForHost("codex", opts),
       },
     },
   };
@@ -3385,7 +3428,7 @@ function writeAuth(opts) {
     activeWorkspaceId: opts.workspaceId,
     apiUrl: opts.apiUrl,
   };
-  writeJson(authPath(), config, opts);
+  writeJson(authPath(opts), config, opts);
   return { written: true, reused: false };
 }
 
@@ -3445,6 +3488,40 @@ const WATCH_MODE_DRIVER_ENV = {
   hermes: "SELLABLE_WATCH_MODE_DRIVER=hermes",
 };
 
+function mcpEnvForHost(host, opts) {
+  const env = {
+    SELLABLE_WATCH_MODE_DRIVER: host,
+  };
+  if (opts.server === "hosted") return env;
+  if (opts.sellableConfigPath) {
+    env.SELLABLE_CONFIG_PATH = opts.sellableConfigPath;
+  }
+  if (opts.sellableConfigsDir) {
+    env.SELLABLE_CONFIGS_DIR = opts.sellableConfigsDir;
+  }
+  return env;
+}
+
+function mcpEnvVarArgs(host, opts) {
+  return Object.entries(mcpEnvForHost(host, opts)).map(
+    ([key, value]) => `${key}=${value}`
+  );
+}
+
+function tomlEnvTable(host, opts) {
+  return Object.entries(mcpEnvForHost(host, opts))
+    .map(([key, value]) => `${key} = ${quoteToml(value)}`)
+    .join("\n");
+}
+
+function runtimeMcpEnvForVerify(opts) {
+  const host =
+    opts.host === "claude" || opts.host === "codex" || opts.host === "hermes"
+      ? opts.host
+      : "codex";
+  return mcpEnvForHost(host, opts);
+}
+
 function withHostedWatchModeDriver(rawUrl, driver) {
   if (!WATCH_MODE_DRIVER_ENV[driver]) {
     throw new Error(`Unknown watch mode driver: ${driver}`);
@@ -3498,8 +3575,7 @@ function codexMcpAddArgs(opts) {
     "mcp",
     "add",
     "sellable",
-    "--env",
-    WATCH_MODE_DRIVER_ENV.codex,
+    ...mcpEnvVarArgs("codex", opts).flatMap((entry) => ["--env", entry]),
     "--",
     command,
     ...args,
@@ -3530,7 +3606,7 @@ args = ${tomlArray(args)}`
     content,
     "mcp_servers.sellable.env",
     `[mcp_servers.sellable.env]
-SELLABLE_WATCH_MODE_DRIVER = "codex"`
+${tomlEnvTable("codex", opts)}`
   );
   return content;
 }
@@ -3553,7 +3629,9 @@ function codexMcpServerMatches(content, opts) {
   return (
     server.includes(`command = ${quoteToml(command)}`) &&
     server.includes(`args = ${tomlArray(args)}`) &&
-    env.includes('SELLABLE_WATCH_MODE_DRIVER = "codex"')
+    Object.entries(mcpEnvForHost("codex", opts)).every(([key, value]) =>
+      env.includes(`${key} = ${quoteToml(value)}`)
+    )
   );
 }
 
@@ -3568,16 +3646,20 @@ function codexPluginMcpServerMatches(content, opts) {
   }
 }
 
-function hermesHome() {
-  return process.env.HERMES_HOME?.trim() || join(homedir(), ".hermes");
+function hermesHome(opts = {}) {
+  return (
+    opts.hermesHome ||
+    process.env.HERMES_HOME?.trim() ||
+    join(homedir(), ".hermes")
+  );
 }
 
-function hermesConfigPath() {
-  return join(hermesHome(), "config.yaml");
+function hermesConfigPath(opts = {}) {
+  return join(hermesHome(opts), "config.yaml");
 }
 
-function hermesSkillsRoot() {
-  return join(hermesHome(), "skills", "sellable");
+function hermesSkillsRoot(opts = {}) {
+  return join(hermesHome(opts), "skills", "sellable");
 }
 
 function hermesLikelyInstalled() {
@@ -3606,8 +3688,8 @@ function parseHermesConfig(raw, configPath = hermesConfigPath()) {
   return value;
 }
 
-function readHermesConfig() {
-  const configPath = hermesConfigPath();
+function readHermesConfig(opts = {}) {
+  const configPath = hermesConfigPath(opts);
   const raw = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
   return { raw, config: parseHermesConfig(raw, configPath), configPath };
 }
@@ -3628,9 +3710,7 @@ function hermesMcpServer(opts) {
     command,
     args,
     enabled: true,
-    env: {
-      SELLABLE_WATCH_MODE_DRIVER: "hermes",
-    },
+    env: mcpEnvForHost("hermes", opts),
   };
 }
 
@@ -3643,7 +3723,7 @@ function writeHermesConfig(configPath, config, opts) {
 }
 
 function writeHermesMcpServer(opts) {
-  const { config, configPath } = readHermesConfig();
+  const { config, configPath } = readHermesConfig(opts);
   const existingMcpServers =
     config.mcp_servers &&
     typeof config.mcp_servers === "object" &&
@@ -3662,7 +3742,7 @@ function writeHermesMcpServer(opts) {
 }
 
 function installHermesSkills(opts) {
-  const root = hermesSkillsRoot();
+  const root = hermesSkillsRoot(opts);
   for (const skill of hermesSkillDefinitions()) {
     const skillRoot = join(root, skill.dir);
     writeFile(join(skillRoot, "SKILL.md"), skill.skillMd, opts);
@@ -3676,7 +3756,7 @@ function installHermesSkills(opts) {
 function installHermes(opts) {
   // Parse config before writing skills so invalid user YAML cannot leave a
   // half-installed Hermes skill tree behind.
-  readHermesConfig();
+  readHermesConfig(opts);
   let skillsRoot = null;
   try {
     skillsRoot = installHermesSkills(opts);
@@ -3691,6 +3771,403 @@ function installHermes(opts) {
   }
 }
 
+function parseHermesProfileBootstrapArgs(argv) {
+  const opts = {
+    profile: "",
+    profileRoot: "",
+    profilesRoot: "",
+    workspaceId: "",
+    workspaceName: "",
+    token: "",
+    tokenFile: "",
+    apiUrl: process.env.SELLABLE_API_URL || DEFAULT_API_URL,
+    slackBotToken: process.env.SLACK_BOT_TOKEN || "",
+    slackAppToken: process.env.SLACK_APP_TOKEN || "",
+    server: process.env.SELLABLE_INSTALL_SERVER || "package",
+    mcpPackage: DEFAULT_SERVER_PACKAGE,
+    localCommand: process.env.SELLABLE_MCP_LOCAL_COMMAND || "",
+    dryRun: false,
+    json: false,
+    force: false,
+    overwriteEnv: false,
+    allowDuplicateSlackTokens: false,
+    verbose: 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 === "--profile") opts.profile = next();
+    else if (arg === "--profile-root") opts.profileRoot = next();
+    else if (arg === "--profiles-root") opts.profilesRoot = next();
+    else if (arg === "--workspace-id") opts.workspaceId = next();
+    else if (arg === "--workspace-name") opts.workspaceName = next();
+    else if (arg === "--token") opts.token = next();
+    else if (arg === "--token-file") opts.tokenFile = next();
+    else if (arg === "--api-url") opts.apiUrl = next();
+    else if (arg === "--slack-bot-token") opts.slackBotToken = next();
+    else if (arg === "--slack-app-token") opts.slackAppToken = next();
+    else if (arg === "--server") opts.server = next();
+    else if (arg === "--mcp-package") {
+      opts.mcpPackage = normalizeWindowsPackageSpec(next());
+    } else if (arg === "--local-command") opts.localCommand = next();
+    else if (arg === "--dry-run") opts.dryRun = true;
+    else if (arg === "--json") opts.json = true;
+    else if (arg === "--force") opts.force = true;
+    else if (arg === "--overwrite-env") opts.overwriteEnv = true;
+    else if (arg === "--allow-duplicate-slack-tokens") {
+      opts.allowDuplicateSlackTokens = true;
+    } else if (arg === "--verbose") opts.verbose = true;
+    else {
+      throw new Error(`Unknown hermes profile bootstrap option: ${arg}`);
+    }
+  }
+
+  if (!["package", "local"].includes(opts.server)) {
+    throw new Error("hermes profile bootstrap supports --server package or local");
+  }
+  return opts;
+}
+
+function assertSafeProfileName(profile) {
+  if (!profile) return;
+  if (profile.includes("/") || profile.includes("\\") || profile === "." || profile === "..") {
+    throw new Error("--profile must be a profile name, not a path");
+  }
+}
+
+function resolveHermesProfileRoot(opts) {
+  if (opts.profileRoot) {
+    return normalizeOptionalPath(opts.profileRoot);
+  }
+
+  if (opts.profilesRoot || opts.profile) {
+    if (!opts.profilesRoot || !opts.profile) {
+      throw new Error("--profiles-root requires --profile for Hermes bootstrap");
+    }
+    assertSafeProfileName(opts.profile);
+    return join(normalizeOptionalPath(opts.profilesRoot), opts.profile);
+  }
+
+  const envHermesHome = process.env.HERMES_HOME?.trim();
+  if (envHermesHome) {
+    return resolve(envHermesHome);
+  }
+
+  throw new Error(
+    "Missing Hermes profile root. Pass --profile-root, or --profiles-root with --profile, or set HERMES_HOME."
+  );
+}
+
+function readBootstrapToken(opts) {
+  if (opts.tokenFile) {
+    const tokenPath = normalizeOptionalPath(opts.tokenFile);
+    if (!existsSync(tokenPath)) {
+      throw new Error(`Token file not found: ${tokenPath}`);
+    }
+    return {
+      token: readFileSync(tokenPath, "utf8").trim(),
+      source: "token-file",
+    };
+  }
+
+  const envToken = process.env.SELLABLE_API_TOKEN || process.env.SELLABLE_TOKEN || "";
+  if (envToken) return { token: envToken.trim(), source: "env" };
+  if (opts.token) return { token: opts.token.trim(), source: "flag" };
+  return { token: "", source: "none" };
+}
+
+function tokenFingerprint(value) {
+  if (!value) return null;
+  return createHash("sha256").update(value).digest("hex").slice(0, 16);
+}
+
+function parseEnvLines(raw) {
+  const entries = new Map();
+  const passthrough = [];
+  for (const line of String(raw || "").split(/\r?\n/)) {
+    if (!line) continue;
+    const match = line.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (!match) {
+      passthrough.push(line);
+      continue;
+    }
+    entries.set(match[1], match[2]);
+  }
+  return { entries, passthrough };
+}
+
+function renderEnvFile({ entries, passthrough }) {
+  const lines = [...passthrough];
+  for (const [key, value] of entries.entries()) {
+    if (String(value).includes("\n")) {
+      throw new Error(`Invalid newline in ${key}`);
+    }
+    lines.push(`${key}=${value}`);
+  }
+  return `${lines.join("\n")}${lines.length ? "\n" : ""}`;
+}
+
+function findDuplicateSlackTokenProfiles(profileRoot, slackTokens) {
+  const duplicates = [];
+  const profilesRoot = dirname(profileRoot);
+  if (!existsSync(profilesRoot)) return duplicates;
+
+  const requested = Object.entries(slackTokens)
+    .filter(([, value]) => value)
+    .map(([key, value]) => [key, tokenFingerprint(value), value]);
+  if (requested.length === 0) return duplicates;
+
+  for (const name of readdirSync(profilesRoot)) {
+    const siblingRoot = join(profilesRoot, name);
+    if (resolve(siblingRoot) === resolve(profileRoot)) continue;
+    const envPath = join(siblingRoot, ".env");
+    if (!existsSync(envPath)) continue;
+    const existing = parseEnvLines(readFileSync(envPath, "utf8")).entries;
+    for (const [key, fingerprint, rawValue] of requested) {
+      if (existing.get(key) === rawValue) {
+        duplicates.push({ key, fingerprint, profileRoot: siblingRoot });
+      }
+    }
+  }
+  return duplicates;
+}
+
+function readJsonFile(path) {
+  if (!existsSync(path)) return {};
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  } catch (err) {
+    throw new Error(
+      `Invalid JSON in ${path}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+
+function writeHermesProfileSellableConfig(configPath, raw, opts) {
+  writeJson(configPath, raw, opts);
+}
+
+function runHermesProfileBootstrap(argv) {
+  const parsed = parseHermesProfileBootstrapArgs(argv);
+  const previousVerbose = VERBOSE;
+  VERBOSE = Boolean(parsed.verbose);
+  try {
+    const profileRoot = resolveHermesProfileRoot(parsed);
+    const profile = parsed.profile || basenameSafe(profileRoot);
+    const sellableConfigPath = join(profileRoot, "sellable", "config.json");
+    const sellableConfigsDir = join(profileRoot, "sellable", "configs");
+    const envPath = join(profileRoot, ".env");
+    const { token, source: tokenSource } = readBootstrapToken(parsed);
+    const slackTokens = {
+      SLACK_BOT_TOKEN: parsed.slackBotToken.trim(),
+      SLACK_APP_TOKEN: parsed.slackAppToken.trim(),
+    };
+    const opts = {
+      ...parsed,
+      host: "hermes",
+      hermesHome: profileRoot,
+      sellableConfigPath,
+      sellableConfigsDir,
+      token,
+      tokenSource,
+      workspaceId: parsed.workspaceId,
+      apiUrl: parsed.apiUrl,
+    };
+
+    if (token && !parsed.workspaceId) {
+      throw new Error("--workspace-id is required when a Sellable token is supplied");
+    }
+
+    const summary = {
+      ok: true,
+      command: "hermes profile bootstrap",
+      profile,
+      dryRun: opts.dryRun,
+      paths: {
+        profileRoot,
+        hermesConfigPath: hermesConfigPath(opts),
+        envPath,
+        sellableConfigPath,
+        sellableConfigsDir,
+        skillsRoot: hermesSkillsRoot(opts),
+      },
+      auth: {
+        apiUrl: opts.apiUrl,
+        activeWorkspaceId: parsed.workspaceId || null,
+        activeWorkspaceName: parsed.workspaceName || null,
+        tokenPresent: Boolean(token),
+        tokenSource,
+        tokenFingerprint: tokenFingerprint(token),
+      },
+      slack: {
+        keys: Object.entries(slackTokens)
+          .filter(([, value]) => value)
+          .map(([key]) => key),
+        fingerprints: Object.fromEntries(
+          Object.entries(slackTokens)
+            .filter(([, value]) => value)
+            .map(([key, value]) => [key, tokenFingerprint(value)])
+        ),
+      },
+      created: [],
+      updated: [],
+      preserved: [],
+      skipped: [],
+      warnings: [],
+    };
+
+    let hermesConfig = {};
+    try {
+      hermesConfig = readHermesConfig(opts).config;
+    } catch (err) {
+      throw err;
+    }
+    const existingSellablePath =
+      hermesConfig?.mcp_servers?.sellable?.env?.SELLABLE_CONFIG_PATH || "";
+    if (
+      existingSellablePath &&
+      resolve(existingSellablePath) !== sellableConfigPath &&
+      !opts.force
+    ) {
+      throw new Error(
+        `Existing Hermes sellable MCP points at ${existingSellablePath}; pass --force to replace it with ${sellableConfigPath}.`
+      );
+    }
+
+    const existingAuth = readJsonFile(sellableConfigPath);
+    const existingWorkspaceId =
+      existingAuth.activeWorkspaceId || existingAuth.workspaceId || "";
+    if (
+      existingWorkspaceId &&
+      parsed.workspaceId &&
+      existingWorkspaceId !== parsed.workspaceId &&
+      !opts.force
+    ) {
+      throw new Error(
+        `Existing Sellable profile config uses workspace ${existingWorkspaceId}; pass --force to replace it with ${parsed.workspaceId}.`
+      );
+    }
+
+    let envState = { entries: new Map(), passthrough: [] };
+    if (existsSync(envPath)) {
+      envState = parseEnvLines(readFileSync(envPath, "utf8"));
+    }
+    for (const [key, value] of Object.entries(slackTokens)) {
+      if (!value) continue;
+      const existing = envState.entries.get(key);
+      if (existing && existing !== value && !opts.overwriteEnv) {
+        throw new Error(
+          `${envPath} already has ${key}; pass --overwrite-env to replace it.`
+        );
+      }
+    }
+    if (!opts.allowDuplicateSlackTokens) {
+      const duplicates = findDuplicateSlackTokenProfiles(profileRoot, slackTokens);
+      if (duplicates.length > 0) {
+        const rendered = duplicates
+          .map((dup) => `${dup.key} fingerprint ${dup.fingerprint} in ${dup.profileRoot}`)
+          .join("; ");
+        throw new Error(
+          `Duplicate Slack token detected across Hermes profiles: ${rendered}. Pass --allow-duplicate-slack-tokens to allow this.`
+        );
+      }
+    }
+
+    const hermesConfigExisted = existsSync(hermesConfigPath(opts));
+    const skillsExisted = existsSync(hermesSkillsRoot(opts));
+    const authExisted = existsSync(sellableConfigPath);
+    const configsDirExisted = existsSync(sellableConfigsDir);
+    const envExisted = existsSync(envPath);
+
+    const nextAuth = {
+      ...existingAuth,
+      apiUrl: opts.apiUrl,
+      bootstrap: {
+        ...(existingAuth.bootstrap &&
+        typeof existingAuth.bootstrap === "object" &&
+        !Array.isArray(existingAuth.bootstrap)
+          ? existingAuth.bootstrap
+          : {}),
+        profile,
+        status: token ? "ready" : "pending_auth",
+        updatedAt: new Date().toISOString(),
+      },
+    };
+    if (parsed.workspaceId) {
+      nextAuth.activeWorkspaceId = parsed.workspaceId;
+      nextAuth.workspaceId = parsed.workspaceId;
+    }
+    if (parsed.workspaceName) {
+      nextAuth.activeWorkspaceName = parsed.workspaceName;
+      nextAuth.workspaceName = parsed.workspaceName;
+    }
+    if (token) {
+      nextAuth.token = token;
+    } else if (!existingAuth.token) {
+      delete nextAuth.token;
+    }
+
+    if (!opts.dryRun) {
+      mkdirSync(profileRoot, { recursive: true, mode: 0o700 });
+      mkdirSync(sellableConfigsDir, { recursive: true, mode: 0o700 });
+      writeHermesProfileSellableConfig(sellableConfigPath, nextAuth, opts);
+      installHermes(opts);
+      if (Object.values(slackTokens).some(Boolean)) {
+        for (const [key, value] of Object.entries(slackTokens)) {
+          if (value) envState.entries.set(key, value);
+        }
+        writeFile(envPath, renderEnvFile(envState), opts, 0o600);
+      }
+    }
+
+    (configsDirExisted ? summary.preserved : summary.created).push(
+      sellableConfigsDir
+    );
+    (authExisted ? summary.updated : summary.created).push(sellableConfigPath);
+    (hermesConfigExisted ? summary.updated : summary.created).push(
+      hermesConfigPath(opts)
+    );
+    (skillsExisted ? summary.updated : summary.created).push(hermesSkillsRoot(opts));
+    if (Object.values(slackTokens).some(Boolean)) {
+      (envExisted ? summary.updated : summary.created).push(envPath);
+    } else {
+      summary.skipped.push("Slack env: no Slack tokens supplied");
+    }
+    if (!token) {
+      summary.warnings.push(
+        `Manual auth pending. Run: sellable auth set <token> --workspace-id <workspace_id> --sellable-config-path ${sellableConfigPath}`
+      );
+    }
+
+    if (opts.json) {
+      console.log(JSON.stringify(summary, null, 2));
+    } else {
+      logMilestone(`Hermes profile bootstrapped at ${profileRoot}`);
+      logStep(`Sellable config: ${sellableConfigPath}`);
+      logStep(`Sellable configs dir: ${sellableConfigsDir}`);
+      if (!token) logWarn(summary.warnings[0]);
+    }
+    return summary;
+  } finally {
+    VERBOSE = previousVerbose;
+  }
+}
+
+function basenameSafe(pathValue) {
+  const normalized = resolve(pathValue);
+  return normalized.split(/[\\/]/).filter(Boolean).pop() || "hermes-profile";
+}
+
 function hermesMcpServerMatches(config, opts) {
   const server = config?.mcp_servers?.sellable;
   if (!server || typeof server !== "object") return false;
@@ -3810,7 +4287,7 @@ function canonicalClaudeMcpServer(opts) {
     type: "stdio",
     command,
     args,
-    env: { SELLABLE_WATCH_MODE_DRIVER: "claude" },
+    env: mcpEnvForHost("claude", opts),
     alwaysLoad: true,
   };
 }
@@ -3839,7 +4316,7 @@ function claudeMcpServerMatches(server, canonical) {
     server.type === canonical.type &&
     server.command === canonical.command &&
     JSON.stringify(server.args || []) === JSON.stringify(canonical.args) &&
-    server.env?.SELLABLE_WATCH_MODE_DRIVER === "claude"
+    JSON.stringify(server.env || {}) === JSON.stringify(canonical.env)
   );
 }
 
@@ -3898,12 +4375,10 @@ function patchClaudeAlwaysLoad(opts) {
           server.args = [...canonical.args];
           touched = true;
         }
-        const existingDriver = server.env?.SELLABLE_WATCH_MODE_DRIVER;
-        server.env = {
-          ...(server.env && typeof server.env === "object" ? server.env : {}),
-          SELLABLE_WATCH_MODE_DRIVER: "claude",
-        };
-        if (existingDriver !== "claude") {
+        const existingEnv =
+          server.env && typeof server.env === "object" ? server.env : {};
+        server.env = { ...canonical.env };
+        if (JSON.stringify(existingEnv) !== JSON.stringify(server.env)) {
           touched = true;
         }
       }
@@ -4021,7 +4496,7 @@ function firstRunCommandForHost(host) {
 
 async function verify(opts) {
   const startedAt = new Date().toISOString();
-  const stored = readStoredAuth();
+  const stored = readStoredAuth(opts);
   const checks = [];
   const hasWatchModeDriverMarker = (content, driver) =>
     new RegExp(`SELLABLE_WATCH_MODE_DRIVER[\\s\\S]{0,80}${driver}`).test(
@@ -4029,7 +4504,7 @@ async function verify(opts) {
     ) || new RegExp(`[?&]driver=${driver}(?:\\b|&)`).test(content);
 
   if (stored?.token && stored?.workspaceId) {
-    checks.push(warningCheck(true, `Auth config: ${authPath()}`));
+    checks.push(warningCheck(true, `Auth config: ${authPath(opts)}`));
   } else {
     checks.push(
       warningCheck(
@@ -4413,6 +4888,7 @@ async function verify(opts) {
       cwd: process.cwd(),
       env: {
         ...process.env,
+        ...runtimeMcpEnvForVerify(opts),
         SELLABLE_API_URL: opts.apiUrl,
         SELLABLE_TOKEN: opts.token || process.env.SELLABLE_TOKEN || "",
         SELLABLE_WORKSPACE_ID:
@@ -4468,6 +4944,11 @@ async function verify(opts) {
       install: INSTALL_PACKAGE_SPEC,
       mcp: opts.mcpPackage,
     },
+    sellableConfig: {
+      path: authPath(opts),
+      explicitPath: opts.sellableConfigPath || null,
+      configsDir: opts.sellableConfigsDir || null,
+    },
     checks,
     runtimeMcp,
     threadExposureNotice:
@@ -4996,6 +5477,7 @@ async function main() {
       const authSetFlags = rawArgs.slice(3);
       let dryRun = false;
       let workspaceId = "";
+      let sellableConfigPath = process.env.SELLABLE_CONFIG_PATH || "";
       for (let i = 0; i < authSetFlags.length; i += 1) {
         const flag = authSetFlags[i];
         if (flag === "--dry-run") {
@@ -5012,6 +5494,16 @@ async function main() {
           i += 1;
           continue;
         }
+        if (flag === "--sellable-config-path") {
+          const value = authSetFlags[i + 1];
+          if (!value || value.startsWith("--")) {
+            console.error("Missing value for --sellable-config-path");
+            process.exit(2);
+          }
+          sellableConfigPath = value;
+          i += 1;
+          continue;
+        }
         console.error(`Unknown auth set option: ${flag}`);
         process.exit(2);
       }
@@ -5036,11 +5528,18 @@ async function main() {
       // Skip installSelfShim() — by definition the user has the shim already
       // (they invoked `sellable auth set` from it).
       const apiUrl = process.env.SELLABLE_API_URL || DEFAULT_API_URL;
-      writeAuthSetConfig({ token, workspaceId, apiUrl, dryRun });
+      writeAuthSetConfig({
+        token,
+        workspaceId,
+        apiUrl,
+        dryRun,
+        sellableConfigPath,
+      });
+      const configPath = authPath({ sellableConfigPath });
       if (dryRun) {
-        console.log(`Dry run: token would be saved to ${authPath()}`);
+        console.log(`Dry run: token would be saved to ${configPath}`);
       } else {
-        console.log(`✓ Token saved to ${authPath()}`);
+        console.log(`✓ Token saved to ${configPath}`);
       }
       console.log(`  apiUrl: ${apiUrl}`);
       if (workspaceId) {
@@ -5118,6 +5617,14 @@ async function main() {
       printCreateCommandHint();
       process.exit(0);
     }
+    if (
+      rawArgs[0] === "hermes" &&
+      rawArgs[1] === "profile" &&
+      rawArgs[2] === "bootstrap"
+    ) {
+      runHermesProfileBootstrap(rawArgs.slice(3));
+      process.exit(0);
+    }
     const opts = parseArgs(process.argv.slice(2));
     if (opts.help) {
       console.log(usage());

package/lib/runtime-verify.mjs

@@ -188,6 +188,10 @@ function summarizeToolResult(name, result) {
     return {
       ...summary,
       authOk: parsed.ok === true,
+      configPath: parsed.configPath || null,
+      configExists: parsed.configExists === true,
+      configsDir: parsed.configsDir || null,
+      tokenPresent: parsed.tokenPresent === true,
       errorType: parsed.error?.type || null,
       activeWorkspaceId: parsed.activeWorkspaceId || null,
       activeWorkspaceName: parsed.activeWorkspaceName || null,

package/package.json

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