@sellable/mcp 0.1.0

package/dist/auth.js

@@ -0,0 +1,246 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+const DEFAULT_API_URL = "https://app.sellable.dev";
+// No caching — re-read config on every call so token/workspace changes
+// made by the LLM (editing sellable.json) take effect immediately
+// without requiring an MCP server restart.
+let cachedConfig = null;
+const DISABLE_CONFIG_CACHE = true;
+let configFileName = "sellable.json";
+/**
+ * Set which config file to use. Call before getConfig().
+ * - "sellable.json" (default) - production
+ * - "sellable-dev.json" - local development
+ */
+export function setConfigFile(fileName) {
+    configFileName = fileName;
+    cachedConfig = null; // Reset cache when switching
+}
+function getConfigPathCandidates() {
+    const candidates = [];
+    const explicitConfigPath = process.env.SELLABLE_CONFIG_PATH?.trim();
+    if (explicitConfigPath) {
+        candidates.push(path.resolve(explicitConfigPath));
+    }
+    const codexHome = process.env.CODEX_HOME?.trim();
+    if (codexHome) {
+        candidates.push(path.resolve(codexHome, configFileName));
+    }
+    candidates.push(path.join(os.homedir(), ".codex", configFileName));
+    candidates.push(path.join(os.homedir(), ".claude", configFileName));
+    return Array.from(new Set(candidates));
+}
+function renderConfigPathOrder(candidates) {
+    return candidates
+        .map((candidate, idx) => `${idx + 1}. ${candidate}`)
+        .join("\n");
+}
+export function getConfigPath() {
+    const candidates = getConfigPathCandidates();
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return candidates[0];
+}
+function normalizeConfig(raw) {
+    return {
+        ...raw,
+        activeWorkspaceId: raw.activeWorkspaceId || raw.workspaceId,
+        activeWorkspaceName: raw.activeWorkspaceName || raw.workspaceName,
+        apiUrl: raw.apiUrl || DEFAULT_API_URL,
+    };
+}
+export function getConfig() {
+    if (cachedConfig && !DISABLE_CONFIG_CACHE) {
+        return cachedConfig;
+    }
+    const configPathCandidates = getConfigPathCandidates();
+    const configPath = getConfigPath();
+    if (!fs.existsSync(configPath)) {
+        throw new Error("Sellable not configured.\n\n" +
+            `Create ${configPath} with your token:\n` +
+            "{\n" +
+            '  "token": "skt_live_..."\n' +
+            "}\n\n" +
+            "Config path resolution order:\n" +
+            `${renderConfigPathOrder(configPathCandidates)}\n\n` +
+            "Get your token at: https://app.sellable.dev/settings/integrations\n" +
+            "Then run list_workspaces + set_active_workspace to select a workspace.");
+    }
+    try {
+        const content = fs.readFileSync(configPath, "utf-8");
+        const raw = JSON.parse(content);
+        // Resolve config: support multi-env format or legacy flat format
+        let config;
+        if (raw.activeEnv && raw.environments) {
+            const envName = raw.activeEnv;
+            const envConfig = raw.environments[envName];
+            if (!envConfig) {
+                const available = Object.keys(raw.environments).join(", ");
+                throw new Error(`Unknown environment '${envName}' in ${configFileName}. Available: ${available}`);
+            }
+            config = {
+                ...normalizeConfig(envConfig),
+                activeEnvName: envName,
+            };
+        }
+        else {
+            // Legacy flat format: { token, workspaceId?, apiUrl? }
+            config = normalizeConfig(raw);
+        }
+        if (!config.token) {
+            throw new Error(`Missing 'token' in ${configFileName}`);
+        }
+        if (!config.token.startsWith("skt_")) {
+            throw new Error("Invalid token format - must start with 'skt_'");
+        }
+        cachedConfig = config;
+        return config;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON in ${configPath}: ${error.message}`);
+        }
+        throw error;
+    }
+}
+export function updateActiveWorkspace(params) {
+    const configPath = getConfigPath();
+    const configDir = path.dirname(configPath);
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Sellable not configured. Create ${configPath} with your token first.`);
+    }
+    const content = fs.readFileSync(configPath, "utf-8");
+    let raw;
+    try {
+        raw = JSON.parse(content);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON in ${configPath}: ${error.message}`);
+        }
+        throw error;
+    }
+    if (raw.activeEnv && raw.environments) {
+        const envName = raw.activeEnv;
+        const envConfig = raw.environments[envName];
+        if (!envConfig) {
+            const available = Object.keys(raw.environments).join(", ");
+            throw new Error(`Unknown environment '${envName}' in ${configFileName}. Available: ${available}`);
+        }
+        raw.environments[envName] = {
+            ...envConfig,
+            activeWorkspaceId: params.workspaceId,
+            activeWorkspaceName: params.workspaceName ?? envConfig.activeWorkspaceName,
+            workspaceId: params.workspaceId,
+            workspaceName: params.workspaceName ?? envConfig.workspaceName,
+        };
+    }
+    else {
+        raw.activeWorkspaceId = params.workspaceId;
+        raw.activeWorkspaceName = params.workspaceName ?? raw.activeWorkspaceName;
+        raw.workspaceId = params.workspaceId;
+        raw.workspaceName = params.workspaceName ?? raw.workspaceName;
+    }
+    fs.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
+    cachedConfig = null;
+}
+function readRawConfigFile() {
+    const configPath = getConfigPath();
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Sellable not configured. Create ${configPath} with your token first.`);
+    }
+    const content = fs.readFileSync(configPath, "utf-8");
+    try {
+        return { configPath, raw: JSON.parse(content) };
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON in ${configPath}: ${error.message}`);
+        }
+        throw error;
+    }
+}
+function writeRawConfigFile(configPath, raw) {
+    const configDir = path.dirname(configPath);
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
+    cachedConfig = null;
+}
+function getActiveEnvConfigRef(raw) {
+    if (raw?.activeEnv && raw?.environments) {
+        const envName = raw.activeEnv;
+        const envConfig = raw.environments?.[envName];
+        if (!envConfig) {
+            const available = Object.keys(raw.environments || {}).join(", ");
+            throw new Error(`Unknown environment '${envName}' in ${configFileName}. Available: ${available}`);
+        }
+        return {
+            envConfig,
+            set: (v) => {
+                raw.environments[envName] = v;
+            },
+        };
+    }
+    return {
+        envConfig: raw,
+        set: (v) => {
+            Object.assign(raw, v);
+        },
+    };
+}
+export function getEngageState() {
+    const config = getConfig();
+    const workspaceId = config.activeWorkspaceId || config.workspaceId || null;
+    if (!workspaceId) {
+        return { activeWorkspaceId: null, state: null };
+    }
+    const state = config.skillState?.engage?.byWorkspace?.[workspaceId] ?? null;
+    return { activeWorkspaceId: workspaceId, state };
+}
+export function updateEngageState(patch) {
+    const { configPath, raw } = readRawConfigFile();
+    const { envConfig, set } = getActiveEnvConfigRef(raw);
+    const normalized = normalizeConfig(envConfig);
+    const workspaceId = normalized.activeWorkspaceId || normalized.workspaceId || null;
+    if (!workspaceId) {
+        throw new Error("No active workspace selected. Run list_workspaces then set_active_workspace.");
+    }
+    const now = new Date().toISOString();
+    const skillState = (envConfig.skillState || {});
+    const engageState = (skillState.engage || {});
+    const byWorkspace = (engageState.byWorkspace || {});
+    const existing = byWorkspace[workspaceId] || {};
+    const next = {
+        ...existing,
+        ...(patch.lastSenderId ? { lastSenderId: patch.lastSenderId } : {}),
+        ...(typeof patch.lastCommentCampaignTableId === "string"
+            ? { lastCommentCampaignTableId: patch.lastCommentCampaignTableId }
+            : patch.lastCommentCampaignTableId === null
+                ? { lastCommentCampaignTableId: undefined }
+                : {}),
+        ...(patch.lastSenderIds ? { lastSenderIds: patch.lastSenderIds } : {}),
+        ...(patch.lastCommentCampaignTableIds
+            ? { lastCommentCampaignTableIds: patch.lastCommentCampaignTableIds }
+            : {}),
+        ...(patch.lastMode ? { lastMode: patch.lastMode } : {}),
+        updatedAt: now,
+    };
+    byWorkspace[workspaceId] = next;
+    engageState.byWorkspace = byWorkspace;
+    skillState.engage = engageState;
+    set({
+        ...envConfig,
+        skillState,
+    });
+    writeRawConfigFile(configPath, raw);
+    return { activeWorkspaceId: workspaceId, state: next };
+}

package/dist/engage-memory.d.ts

@@ -0,0 +1,63 @@
+export interface EngageStyleGuide {
+    markdown: string;
+    updatedAt: string;
+}
+export interface ProvenSearch {
+    keyword: string;
+    lastUsed: string;
+    totalSearches: number;
+    totalReturned: number;
+    totalYielded: number;
+    avgHitRate: number;
+}
+export interface TrackedPerson {
+    name: string;
+    linkedinUrl: string;
+    reason: string;
+    includeInDiscovery: boolean;
+}
+export interface EngageMemory {
+    styleGuide?: EngageStyleGuide;
+    provenSearches: ProvenSearch[];
+    trackedPeople: TrackedPerson[];
+}
+/** Check if a sender has per-sender config directory. */
+export declare function senderHasConfig(senderId: string): boolean;
+export declare function getEngageMemory(senderId?: string): {
+    memory: EngageMemory;
+};
+export declare function setStyleGuide(markdown: string, senderId?: string): {
+    styleGuide: EngageStyleGuide;
+};
+export declare function recordProvenSearch(input: {
+    keyword: string;
+    totalReturned: number;
+    postsYielded: number;
+    senderId?: string;
+}): {
+    search: ProvenSearch;
+};
+export declare function upsertTrackedPerson(input: {
+    name: string;
+    linkedinUrl: string;
+    reason: string;
+    senderId?: string;
+}): {
+    person: TrackedPerson;
+    created: boolean;
+};
+/** Copy all per-sender config files from one sender to another. */
+export declare function copySenderConfig(input: {
+    fromSenderId: string;
+    toSenderId: string;
+}): {
+    copied: string[];
+    skipped: string[];
+};
+/** Migrate existing flat configs into a sender's directory (one-time migration). */
+export declare function migrateFlatConfigs(input: {
+    senderId: string;
+}): {
+    migrated: string[];
+    skipped: string[];
+};

package/dist/engage-memory.js

@@ -0,0 +1,354 @@
+import * as fs from "fs";
+import * as path from "path";
+// ── Config directory resolution ────────────────────────────────────────────
+function resolveConfigsDir() {
+    const candidates = [];
+    if (process.env.SELLABLE_CONFIGS_DIR) {
+        candidates.push(path.resolve(process.env.SELLABLE_CONFIGS_DIR));
+    }
+    // Same resolution strategy as skills.ts
+    if (process.argv[1]) {
+        candidates.push(path.resolve(path.dirname(process.argv[1]), "../../.sellable/configs"));
+    }
+    candidates.push(path.resolve(process.cwd(), ".sellable/configs"));
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    // Default — create on first write
+    return candidates[candidates.length - 1];
+}
+let configsDir = null;
+function getConfigsDir() {
+    if (!configsDir) {
+        configsDir = resolveConfigsDir();
+    }
+    return configsDir;
+}
+function ensureDir(filePath) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function readFile(relPath) {
+    const fullPath = path.join(getConfigsDir(), relPath);
+    if (!fs.existsSync(fullPath))
+        return null;
+    return fs.readFileSync(fullPath, "utf-8");
+}
+function writeFile(relPath, content) {
+    const fullPath = path.join(getConfigsDir(), relPath);
+    ensureDir(fullPath);
+    fs.writeFileSync(fullPath, content);
+}
+// ── Sender-scoped path resolution ─────────────────────────────────────────
+/** Per-sender file paths. When senderId is given, resolves to senders/{id}/file.
+ *  Falls back to legacy flat path when senderId is omitted or sender dir doesn't exist. */
+function senderPath(senderId, fileName, flatFallback) {
+    if (senderId) {
+        const senderDir = `senders/${senderId}`;
+        const senderFile = `${senderDir}/${fileName}`;
+        // If sender dir exists, always use it (even if file doesn't exist yet — it'll be created)
+        if (fs.existsSync(path.join(getConfigsDir(), senderDir))) {
+            return senderFile;
+        }
+        // If the file exists in sender dir (dir just created), use it
+        if (fs.existsSync(path.join(getConfigsDir(), senderFile))) {
+            return senderFile;
+        }
+    }
+    // Fallback to flat path
+    return flatFallback;
+}
+/** Check if a sender has per-sender config directory. */
+export function senderHasConfig(senderId) {
+    const senderDir = path.join(getConfigsDir(), `senders/${senderId}`);
+    return fs.existsSync(senderDir);
+}
+// ── Markdown table parsing/writing ─────────────────────────────────────────
+function parseMarkdownTable(content) {
+    const lines = content.split("\n");
+    let headerIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith("|") && line.endsWith("|")) {
+            const next = lines[i + 1]?.trim() || "";
+            if (next.match(/^\|[\s\-:|]+\|$/)) {
+                headerIdx = i;
+                break;
+            }
+        }
+    }
+    if (headerIdx === -1)
+        return { headers: [], rows: [] };
+    const headers = lines[headerIdx]
+        .split("|")
+        .map((h) => h.trim())
+        .filter(Boolean);
+    const rows = [];
+    for (let i = headerIdx + 2; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line.startsWith("|"))
+            break;
+        if (line.startsWith("<!--"))
+            continue;
+        const cells = line
+            .split("|")
+            .map((c) => c.trim())
+            .filter((_, idx, arr) => idx > 0 && idx < arr.length);
+        if (cells.length === 0 || cells.every((c) => !c))
+            continue;
+        const row = {};
+        headers.forEach((h, idx) => {
+            row[h] = cells[idx] || "";
+        });
+        rows.push(row);
+    }
+    return { headers, rows };
+}
+function buildMarkdownTable(headers, rows) {
+    if (headers.length === 0)
+        return "";
+    const headerLine = "| " + headers.join(" | ") + " |";
+    const sepLine = "| " + headers.map(() => "---").join(" | ") + " |";
+    const dataLines = rows.map((row) => "| " + headers.map((h) => row[h] || "").join(" | ") + " |");
+    return [headerLine, sepLine, ...dataLines].join("\n");
+}
+// ── Style guide ────────────────────────────────────────────────────────────
+const FLAT_STYLE_CORE_PATH = "writing/styleguide-core.md";
+const STYLE_COMMENTS_PATH = "writing/comments.md";
+function readStyleGuide(senderId) {
+    const corePath = senderPath(senderId, "styleguide-core.md", FLAT_STYLE_CORE_PATH);
+    const core = readFile(corePath);
+    // comments.md is always shared
+    const comments = readFile(STYLE_COMMENTS_PATH);
+    if (!core && !comments)
+        return undefined;
+    const parts = [];
+    if (core)
+        parts.push(core.trim());
+    if (comments)
+        parts.push(comments.trim());
+    const markdown = parts.join("\n\n");
+    // Use file mtime as updatedAt
+    const coreFullPath = path.join(getConfigsDir(), corePath);
+    const commentsFullPath = path.join(getConfigsDir(), STYLE_COMMENTS_PATH);
+    const coreMtime = fs.existsSync(coreFullPath)
+        ? fs.statSync(coreFullPath).mtime
+        : new Date(0);
+    const commentsMtime = fs.existsSync(commentsFullPath)
+        ? fs.statSync(commentsFullPath).mtime
+        : new Date(0);
+    const updatedAt = new Date(Math.max(coreMtime.getTime(), commentsMtime.getTime())).toISOString();
+    return { markdown, updatedAt };
+}
+export function getEngageMemory(senderId) {
+    const styleGuide = readStyleGuide(senderId);
+    const provenSearches = readProvenSearches(senderId);
+    const trackedPeople = readTrackedPeople(senderId);
+    return { memory: { styleGuide, provenSearches, trackedPeople } };
+}
+export function setStyleGuide(markdown, senderId) {
+    const corePath = senderPath(senderId, "styleguide-core.md", FLAT_STYLE_CORE_PATH);
+    writeFile(corePath, markdown + "\n");
+    const updatedAt = new Date().toISOString();
+    return { styleGuide: { markdown, updatedAt } };
+}
+// ── Proven searches ────────────────────────────────────────────────────────
+const FLAT_PROVEN_SEARCHES_PATH = "discovery/proven-searches.md";
+const PROVEN_SEARCHES_HEADER = `# Proven Searches
+
+Keywords discovered during Engage sessions, ranked by performance.
+Updated automatically after each session — high hit-rate terms are prioritized in future discovery.
+
+`;
+const PROVEN_HEADERS = [
+    "Keyword",
+    "Last Used",
+    "Searches",
+    "Returned",
+    "Yielded",
+    "Hit Rate",
+];
+function readProvenSearches(senderId) {
+    const filePath = senderPath(senderId, "proven-searches.md", FLAT_PROVEN_SEARCHES_PATH);
+    const content = readFile(filePath);
+    if (!content)
+        return [];
+    const { rows } = parseMarkdownTable(content);
+    return rows.map((row) => ({
+        keyword: row["Keyword"] || "",
+        lastUsed: row["Last Used"] || "",
+        totalSearches: parseInt(row["Searches"] || "0", 10) || 0,
+        totalReturned: parseInt(row["Returned"] || "0", 10) || 0,
+        totalYielded: parseInt(row["Yielded"] || "0", 10) || 0,
+        avgHitRate: parseFloat(row["Hit Rate"] || "0") || 0,
+    }));
+}
+function writeProvenSearches(searches, senderId) {
+    // Sort by avgHitRate desc, then by lastUsed desc
+    const sorted = [...searches].sort((a, b) => {
+        if (b.avgHitRate !== a.avgHitRate)
+            return b.avgHitRate - a.avgHitRate;
+        return b.lastUsed.localeCompare(a.lastUsed);
+    });
+    const rows = sorted.map((s) => ({
+        Keyword: s.keyword,
+        "Last Used": s.lastUsed.split("T")[0],
+        Searches: String(s.totalSearches),
+        Returned: String(s.totalReturned),
+        Yielded: String(s.totalYielded),
+        "Hit Rate": s.avgHitRate.toFixed(2),
+    }));
+    const filePath = senderPath(senderId, "proven-searches.md", FLAT_PROVEN_SEARCHES_PATH);
+    const table = buildMarkdownTable(PROVEN_HEADERS, rows);
+    writeFile(filePath, PROVEN_SEARCHES_HEADER + table + "\n");
+}
+export function recordProvenSearch(input) {
+    const searches = readProvenSearches(input.senderId);
+    const existing = searches.find((s) => s.keyword.toLowerCase() === input.keyword.toLowerCase());
+    const hitRate = input.totalReturned > 0 ? input.postsYielded / input.totalReturned : 0;
+    if (existing) {
+        existing.totalSearches += 1;
+        existing.totalReturned += input.totalReturned;
+        existing.totalYielded += input.postsYielded;
+        existing.avgHitRate =
+            existing.totalReturned > 0
+                ? existing.totalYielded / existing.totalReturned
+                : 0;
+        existing.lastUsed = new Date().toISOString();
+        writeProvenSearches(searches, input.senderId);
+        return { search: existing };
+    }
+    const search = {
+        keyword: input.keyword,
+        lastUsed: new Date().toISOString(),
+        totalSearches: 1,
+        totalReturned: input.totalReturned,
+        totalYielded: input.postsYielded,
+        avgHitRate: hitRate,
+    };
+    searches.push(search);
+    writeProvenSearches(searches, input.senderId);
+    return { search };
+}
+// ── Tracked people ─────────────────────────────────────────────────────────
+const FLAT_INFLUENCERS_PATH = "discovery/influencers.md";
+const INFLUENCERS_HEADER = `# Influencers & Tracked People
+
+People whose posts are fetched during Engage discovery sessions.
+Add rows to the table below to track new people.
+
+## People
+
+`;
+const INFLUENCER_HEADERS = [
+    "Name",
+    "LinkedIn URL",
+    "Reason",
+    "Include in Discovery",
+];
+function readTrackedPeople(senderId) {
+    const filePath = senderPath(senderId, "influencers.md", FLAT_INFLUENCERS_PATH);
+    const content = readFile(filePath);
+    if (!content)
+        return [];
+    const { rows } = parseMarkdownTable(content);
+    return rows.map((row) => ({
+        name: row["Name"] || "",
+        linkedinUrl: row["LinkedIn URL"] || "",
+        reason: row["Reason"] || "",
+        includeInDiscovery: (row["Include in Discovery"] || "true").toLowerCase() !== "false",
+    }));
+}
+function writeTrackedPeople(people, senderId) {
+    const filePath = senderPath(senderId, "influencers.md", FLAT_INFLUENCERS_PATH);
+    const rows = people.map((p) => ({
+        Name: p.name,
+        "LinkedIn URL": p.linkedinUrl,
+        Reason: p.reason,
+        "Include in Discovery": p.includeInDiscovery ? "true" : "false",
+    }));
+    const table = buildMarkdownTable(INFLUENCER_HEADERS, rows);
+    // Preserve notes section
+    const existing = readFile(filePath);
+    let notes = "";
+    if (existing) {
+        const notesIdx = existing.indexOf("## Notes");
+        if (notesIdx !== -1) {
+            notes = "\n" + existing.slice(notesIdx);
+        }
+    }
+    writeFile(filePath, INFLUENCERS_HEADER + table + "\n" + notes);
+}
+export function upsertTrackedPerson(input) {
+    const people = readTrackedPeople(input.senderId);
+    const normalizedUrl = input.linkedinUrl
+        .toLowerCase()
+        .replace(/\/+$/, "")
+        .trim();
+    const existing = people.find((p) => p.linkedinUrl.toLowerCase().replace(/\/+$/, "").trim() === normalizedUrl);
+    if (existing) {
+        existing.name = input.name || existing.name;
+        existing.reason = input.reason || existing.reason;
+        writeTrackedPeople(people, input.senderId);
+        return { person: existing, created: false };
+    }
+    const person = {
+        name: input.name,
+        linkedinUrl: input.linkedinUrl,
+        reason: input.reason,
+        includeInDiscovery: true,
+    };
+    people.push(person);
+    writeTrackedPeople(people, input.senderId);
+    return { person, created: true };
+}
+// ── Copy + migrate sender configs ─────────────────────────────────────────
+const SENDER_CONFIG_FILES = [
+    "styleguide-core.md",
+    "proven-searches.md",
+    "influencers.md",
+];
+/** Copy all per-sender config files from one sender to another. */
+export function copySenderConfig(input) {
+    const copied = [];
+    const skipped = [];
+    for (const fileName of SENDER_CONFIG_FILES) {
+        const fromPath = `senders/${input.fromSenderId}/${fileName}`;
+        const toPath = `senders/${input.toSenderId}/${fileName}`;
+        const content = readFile(fromPath);
+        if (content) {
+            writeFile(toPath, content);
+            copied.push(fileName);
+        }
+        else {
+            skipped.push(fileName);
+        }
+    }
+    return { copied, skipped };
+}
+/** Migrate existing flat configs into a sender's directory (one-time migration). */
+export function migrateFlatConfigs(input) {
+    const migrated = [];
+    const skipped = [];
+    const migrations = [
+        { flat: FLAT_STYLE_CORE_PATH, fileName: "styleguide-core.md" },
+        { flat: FLAT_PROVEN_SEARCHES_PATH, fileName: "proven-searches.md" },
+        { flat: FLAT_INFLUENCERS_PATH, fileName: "influencers.md" },
+    ];
+    for (const { flat, fileName } of migrations) {
+        const content = readFile(flat);
+        const targetPath = `senders/${input.senderId}/${fileName}`;
+        if (content) {
+            writeFile(targetPath, content);
+            migrated.push(`${flat} → ${targetPath}`);
+        }
+        else {
+            skipped.push(flat);
+        }
+    }
+    return { migrated, skipped };
+}

package/dist/index-dev.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./server.js";

package/dist/index-dev.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * Sellable MCP Server - Development
+ *
+ * Uses ~/.claude/sellable-dev.json config with local API URL.
+ * Config should have:
+ * {
+ *   "token": "skt_...",
+ *   "activeWorkspaceId": "ws_...",
+ *   "apiUrl": "http://localhost:3000"
+ * }
+ */
+import { setConfigFile } from "./auth.js";
+// Set dev config BEFORE any other imports that might call getConfig()
+setConfigFile("sellable-dev.json");
+// Now import the main server logic
+import "./server.js";

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * Sellable MCP Server - Production
+ *
+ * Uses ~/.claude/sellable.json config (default prod URL: https://app.sellable.dev)
+ */
+import "./server.js";