@sellable/mcp 0.1.511 → 0.1.513

package/dist/api.js

@@ -1,9 +1,9 @@
-import { getConfig, getConfigPath } from "./auth.js";
 import { createWriteStream } from "node:fs";
 import { mkdir, rename, rm, stat } from "node:fs/promises";
 import path from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
+import { getConfig, getConfigPath } from "./auth.js";
 export class SellableApiError extends Error {
     status;
     body;
@@ -21,18 +21,21 @@ export class SellableApiError extends Error {
 export class SellableApi {
     buildError(status, errorText) {
         const isAuthError = status === 401 || status === 403;
+        const isWorkspaceMembershipError = status === 403 && errorText.includes("No access to workspace");
         const missingWorkspace = status === 400 && errorText.includes("Workspace");
-        const guidance = isAuthError
-            ? "Sellable authentication failed.\n\n" +
-                "Run the first-run Sellable login flow from a Sellable workflow, then retry.\n\n" +
-                "If the browser login page shows a manual fallback command, use:\n" +
-                "sellable auth set <token> --workspace-id <workspace_id>\n\n" +
-                `Current config path: ${getConfigPath()}\n\n` +
-                "Older copied Settings tokens can be stale, restricted, or missing write/credit permissions. Sign in again so Sellable mints the current agent token."
-            : missingWorkspace
-                ? "No active workspace selected.\n\n" +
-                    "Run list_workspaces then set_active_workspace to choose a workspace."
-                : undefined;
+        const guidance = isWorkspaceMembershipError
+            ? "The authenticated user is not a member of this workspace. Confirm the workspaceId or ask a workspace admin to add the user; re-login will not help."
+            : isAuthError
+                ? "Sellable authentication failed.\n\n" +
+                    "Run the first-run Sellable login flow from a Sellable workflow, then retry.\n\n" +
+                    "If the browser login page shows a manual fallback command, use:\n" +
+                    "sellable auth set <token> --workspace-id <workspace_id>\n\n" +
+                    `Current config path: ${getConfigPath()}\n\n` +
+                    "Older copied Settings tokens can be stale, restricted, or missing write/credit permissions. Sign in again so Sellable mints the current agent token."
+                : missingWorkspace
+                    ? "No active workspace selected.\n\n" +
+                        "Run list_workspaces then set_active_workspace to choose a workspace."
+                    : undefined;
         return new SellableApiError(status, errorText, guidance);
     }
     async requestResponse(method, path, body, options) {

package/dist/refill-journal.d.ts

@@ -0,0 +1,49 @@
+export declare const DRY_RUN_MARKER = "**DRY RUN \u2014 no mutations performed**";
+export declare const JOURNAL_SECTION_HEADINGS: {
+    readonly bootstrap: "## Bootstrap";
+    readonly plan: "## Plan";
+    readonly terminal: "## Terminal";
+};
+export declare function resolveRefillRunsRoot(): string;
+/**
+ * Throws on path-safety and permission failures. Callers must wrap the entire
+ * journal block and degrade to journalPath: null; journal failure must never
+ * abort a plan response.
+ */
+export declare function createRunJournal(params: {
+    workspaceId: string;
+    runId?: string;
+    dryRun: boolean;
+    now?: Date;
+}): {
+    filePath: string;
+    runId: string;
+};
+export declare function appendJournalEvent(filePath: string, block: string): void;
+/**
+ * The index is a rebuildable cache. Directory listing is the source of truth;
+ * Phase 85 appends dry-run lines, Phase 86 maintains real-run entries.
+ */
+export declare function appendIndexLine(entry: {
+    runId: string;
+    fileName: string;
+    workspaceId: string;
+    dryRun: boolean;
+    summary: string;
+}): void;
+export declare function renderBootstrapSection(params: {
+    summary: string;
+    senderSummary?: string;
+    laneSummary?: string;
+    targetSummary?: string;
+    creditSummary?: string;
+}): string;
+export declare function renderPlanSection(params: {
+    chosenSummary: string;
+    itinerarySummaries?: string[];
+    fallbackSummary?: string;
+}): string;
+export declare function renderTerminalSection(params: {
+    summary: string;
+    finalNumbers?: string;
+}): string;

package/dist/refill-journal.js

@@ -0,0 +1,134 @@
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const REFILL_RUNS_ROOT_ENV = "SELLABLE_REFILL_RUNS_DIR";
+export const DRY_RUN_MARKER = "**DRY RUN — no mutations performed**";
+export const JOURNAL_SECTION_HEADINGS = {
+    bootstrap: "## Bootstrap",
+    plan: "## Plan",
+    terminal: "## Terminal",
+};
+function expandLeadingTilde(value) {
+    if (value === "~")
+        return os.homedir();
+    if (value.startsWith("~/") || value.startsWith("~\\")) {
+        return path.join(os.homedir(), value.slice(2));
+    }
+    return value;
+}
+function normalizeConfiguredRoot(value, label) {
+    const expanded = expandLeadingTilde(value);
+    if (!path.isAbsolute(expanded)) {
+        throw new Error(`${label} must be an absolute path.`);
+    }
+    return path.resolve(expanded);
+}
+export function resolveRefillRunsRoot() {
+    const envValue = process.env[REFILL_RUNS_ROOT_ENV]?.trim();
+    if (envValue) {
+        return normalizeConfiguredRoot(envValue, REFILL_RUNS_ROOT_ENV);
+    }
+    const home = os.homedir();
+    if (!home || !path.isAbsolute(home)) {
+        throw new Error(`Unable to resolve Sellable refill runs root: ${REFILL_RUNS_ROOT_ENV} is unset and home directory is unavailable.`);
+    }
+    return path.resolve(home, ".sellable/refill/runs");
+}
+function isPathInside(candidate, root) {
+    const relative = path.relative(root, candidate);
+    return (Boolean(relative) &&
+        !relative.startsWith("..") &&
+        !path.isAbsolute(relative));
+}
+function assertSafeRunId(runId) {
+    if (!/^[A-Za-z0-9_-]+$/.test(runId) ||
+        runId.includes("..") ||
+        runId.includes("/") ||
+        runId.includes("\\") ||
+        runId.includes("\0")) {
+        throw new Error("runId must be a safe filename segment.");
+    }
+}
+function utcBasicTimestamp(now) {
+    return `${now.toISOString().slice(0, 19).replace(/[-:]/g, "")}Z`;
+}
+function normalizeBlock(block) {
+    return block.endsWith("\n") ? block : `${block}\n`;
+}
+/**
+ * Throws on path-safety and permission failures. Callers must wrap the entire
+ * journal block and degrade to journalPath: null; journal failure must never
+ * abort a plan response.
+ */
+export function createRunJournal(params) {
+    const runId = params.runId ?? randomBytes(4).toString("hex");
+    assertSafeRunId(runId);
+    const root = resolveRefillRunsRoot();
+    fs.mkdirSync(root, { recursive: true });
+    const normalizedRoot = path.resolve(root);
+    const fileName = `${utcBasicTimestamp(params.now ?? new Date())}-${runId}${params.dryRun ? "-dry" : ""}.md`;
+    const filePath = path.resolve(normalizedRoot, fileName);
+    if (!isPathInside(filePath, normalizedRoot)) {
+        throw new Error("Resolved journal path escapes refill runs root.");
+    }
+    const startedAt = (params.now ?? new Date()).toISOString();
+    const header = [
+        `# Refill Sends V2 Run ${runId}`,
+        "",
+        `- Run ID: ${runId}`,
+        `- Workspace ID: ${params.workspaceId}`,
+        `- Started at: ${startedAt}`,
+        params.dryRun ? `- ${DRY_RUN_MARKER}` : null,
+        "",
+    ]
+        .filter((line) => line !== null)
+        .join("\n");
+    fs.appendFileSync(filePath, normalizeBlock(header), "utf8");
+    return { filePath, runId };
+}
+export function appendJournalEvent(filePath, block) {
+    try {
+        fs.appendFileSync(filePath, normalizeBlock(block), "utf8");
+    }
+    catch {
+        // Best effort by design.
+    }
+}
+/**
+ * The index is a rebuildable cache. Directory listing is the source of truth;
+ * Phase 85 appends dry-run lines, Phase 86 maintains real-run entries.
+ */
+export function appendIndexLine(entry) {
+    try {
+        const root = resolveRefillRunsRoot();
+        fs.mkdirSync(root, { recursive: true });
+        const marker = entry.dryRun ? " (dry)" : "";
+        fs.appendFileSync(path.join(root, "index.md"), `- ${entry.runId}${marker} [${entry.workspaceId}] ${entry.fileName} — ${entry.summary}\n`, "utf8");
+    }
+    catch {
+        // Best effort by design.
+    }
+}
+function renderLines(heading, lines) {
+    return normalizeBlock([heading, "", ...lines, ""].join("\n"));
+}
+export function renderBootstrapSection(params) {
+    return renderLines(JOURNAL_SECTION_HEADINGS.bootstrap, [
+        params.summary,
+        params.senderSummary,
+        params.laneSummary,
+        params.targetSummary,
+        params.creditSummary,
+    ].filter((line) => Boolean(line)));
+}
+export function renderPlanSection(params) {
+    return renderLines(JOURNAL_SECTION_HEADINGS.plan, [
+        `Chosen: ${params.chosenSummary}`,
+        ...(params.itinerarySummaries ?? []).map((summary) => `Next: ${summary}`),
+        params.fallbackSummary ? `Fallback: ${params.fallbackSummary}` : null,
+    ].filter((line) => Boolean(line)));
+}
+export function renderTerminalSection(params) {
+    return renderLines(JOURNAL_SECTION_HEADINGS.terminal, [params.summary, params.finalNumbers].filter((line) => Boolean(line)));
+}

package/dist/refill-local-state.d.ts

@@ -0,0 +1,31 @@
+export interface RefillLaneMemoryEntry {
+    senderId: string;
+    laneKey: string;
+    outcome: string;
+    cooldownUntil: string;
+    reason: string;
+}
+export interface RefillPassRateObservation {
+    campaignId: string;
+    enrichedCount: number;
+    passedCount: number;
+    observedAt: string;
+}
+export interface RefillRunSummaryEntry {
+    runId: string;
+    endedAt: string;
+    terminalState: string;
+    sendsLoaded: number;
+    lanesTouched: string[];
+}
+export interface RefillWorkspaceState {
+    laneMemory: RefillLaneMemoryEntry[];
+    passRates: RefillPassRateObservation[];
+    recentRuns: RefillRunSummaryEntry[];
+}
+/**
+ * Advisory hints only. A missing, stale, corrupt, or malformed file means no
+ * hints; live planner reads remain the source of correctness. Phase 85 reads
+ * this section only. Phase 86 adds the writer plus writeJsonAtomic.
+ */
+export declare function readRefillWorkspaceState(workspaceId: string): RefillWorkspaceState | null;

package/dist/refill-local-state.js

@@ -0,0 +1,96 @@
+import { getConfig } from "./auth.js";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return (Array.isArray(value) && value.every((entry) => typeof entry === "string"));
+}
+function readString(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? value : null;
+}
+function readNumber(record, key) {
+    const value = record[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function parseLaneMemoryEntry(value) {
+    if (!isRecord(value))
+        return null;
+    const senderId = readString(value, "senderId");
+    const laneKey = readString(value, "laneKey");
+    const outcome = readString(value, "outcome");
+    const cooldownUntil = readString(value, "cooldownUntil");
+    const reason = readString(value, "reason");
+    if (!senderId || !laneKey || !outcome || !cooldownUntil || !reason) {
+        return null;
+    }
+    return { senderId, laneKey, outcome, cooldownUntil, reason };
+}
+function parsePassRateObservation(value) {
+    if (!isRecord(value))
+        return null;
+    const campaignId = readString(value, "campaignId");
+    const enrichedCount = readNumber(value, "enrichedCount");
+    const passedCount = readNumber(value, "passedCount");
+    const observedAt = readString(value, "observedAt");
+    if (!campaignId ||
+        enrichedCount === null ||
+        passedCount === null ||
+        !observedAt) {
+        return null;
+    }
+    return { campaignId, enrichedCount, passedCount, observedAt };
+}
+function parseRunSummaryEntry(value) {
+    if (!isRecord(value))
+        return null;
+    const runId = readString(value, "runId");
+    const endedAt = readString(value, "endedAt");
+    const terminalState = readString(value, "terminalState");
+    const sendsLoaded = readNumber(value, "sendsLoaded");
+    const lanesTouched = value.lanesTouched;
+    if (!runId ||
+        !endedAt ||
+        !terminalState ||
+        sendsLoaded === null ||
+        !isStringArray(lanesTouched)) {
+        return null;
+    }
+    return { runId, endedAt, terminalState, sendsLoaded, lanesTouched };
+}
+function parseArray(value, parser) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        const parsed = parser(entry);
+        return parsed ? [parsed] : [];
+    });
+}
+/**
+ * Advisory hints only. A missing, stale, corrupt, or malformed file means no
+ * hints; live planner reads remain the source of correctness. Phase 85 reads
+ * this section only. Phase 86 adds the writer plus writeJsonAtomic.
+ */
+export function readRefillWorkspaceState(workspaceId) {
+    try {
+        const config = getConfig();
+        const refill = config.skillState
+            ?.refill;
+        if (!isRecord(refill) || refill.version !== 1)
+            return null;
+        const byWorkspace = refill.byWorkspace;
+        if (!isRecord(byWorkspace))
+            return null;
+        const workspaceState = byWorkspace[workspaceId];
+        if (!isRecord(workspaceState))
+            return null;
+        return {
+            laneMemory: parseArray(workspaceState.laneMemory, parseLaneMemoryEntry),
+            passRates: parseArray(workspaceState.passRates, parsePassRateObservation),
+            recentRuns: parseArray(workspaceState.recentRuns, parseRunSummaryEntry),
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/server.js

@@ -9,10 +9,8 @@ import { prepareCampaignAbTest } from "./tools/campaign-ab-test.js";
 import { resolveCampaignFillRoute } from "./tools/campaign-fill-routing.js";
 import { fillCampaignHorizon } from "./tools/campaign-horizon-fill.js";
 import { cancelPrepareCampaignMessages, getPrepareCampaignMessagesStatus, startPrepareCampaignMessages, } from "./tools/campaign-message-preparation.js";
-import { getCampaignRefillState } from "./tools/campaign-refill-state.js";
-import { getRefillTargetPlan } from "./tools/refill-target-plan.js";
-import { getSchedulerFillCapacity } from "./tools/scheduler-fill-capacity.js";
 import { getCampaignTableSchema, queueCampaignCells, recordCampaignReviewBatch, reviseMessageTemplateAndRerun, selectCampaignCells, waitForCampaignProcessing, } from "./tools/campaign-processing.js";
+import { getCampaignRefillState } from "./tools/campaign-refill-state.js";
 import { archiveCampaign, createCampaign, duplicateCampaign, getCampaign, getCampaignMessagesPreview, getCampaigns, pauseCampaign, startCampaign, updateCampaign, updateCampaignBrief, } from "./tools/campaigns.js";
 import { queueCells, updateCell } from "./tools/cells.js";
 import { handleStartCliLogin, handleWaitForCliLogin, } from "./tools/cli-login.js";
@@ -29,6 +27,7 @@ import { searchEngagementPosts } from "./tools/engage-discovery.js";
 import { copySenderConfigTool, getEngageMemoryTool, migrateFlatConfigsTool, recordEngageProvenSearchTool, setEngageStyleGuideTool, upsertEngageTrackedPersonTool, } from "./tools/engage-memory.js";
 import { getEngageStateTool, setEngageStateTool, } from "./tools/engage-state.js";
 import { bulkEnrichWithProspeo, enrichWithProspeo, getProspeoCredits, } from "./tools/enrichment.js";
+import { getRefillPlanV2 } from "./tools/evergreen-refill-plan.js";
 import { getCampaignFramework } from "./tools/framework.js";
 import { confirmHarvestJobCompanies, searchHarvestJobs, } from "./tools/harvest-jobs.js";
 import { checkInboxReplyEligibility, getInboxThread, searchInboxThreads, sendInboxDraft, sendInboxManualReply, updateInboxDraft, } from "./tools/inbox.js";
@@ -39,10 +38,13 @@ import { addOnDemandLeads, createOnDemandCampaign, createOnDemandTable, initOnDe
 import { upsertRubric } from "./tools/processing.js";
 import { completeSenderResearch, getPostFindLeadsScoutRegistry, getSourceScoutRegistry, getSubskillAsset, getSubskillPrompt, listSubskillPrompts, searchSubskillPrompts, } from "./tools/prompts.js";
 import { waitForCampaignTableReady, waitForLeadListReady, } from "./tools/readiness.js";
+import { refillSendsV2Command } from "./tools/refill-sends-v2.js";
 import { executeRefillSendsCommand } from "./tools/refill-sends.js";
+import { getRefillTargetPlan } from "./tools/refill-target-plan.js";
 import { allTools } from "./tools/registry.js";
 import { getRows, getTableRows, getTableRowsMinimal } from "./tools/rows.js";
 import { addRubricItem, checkRubric, deleteRubricItem, draftRubrics, saveRubrics, selectNecessaryRubrics, updateRubricItem, waitForRubricResults, } from "./tools/rubrics.js";
+import { getSchedulerFillCapacity } from "./tools/scheduler-fill-capacity.js";
 import { getSenderRoutingTool, setSenderRoutingTool, } from "./tools/sender-routing.js";
 import { getSender, listSenders, refreshPaidInmailCredits, } from "./tools/senders.js";
 import { attachRecommendedSequence, attachSequence, createWorkflowTable, } from "./tools/sequencer.js";
@@ -223,6 +225,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_campaign_refill_state":
                 result = await getCampaignRefillState(args);
                 break;
+            case "get_refill_plan_v2":
+            case "get_evergreen_refill_plan":
+                result = await getRefillPlanV2(args);
+                break;
             case "get_refill_target_plan":
                 result = await getRefillTargetPlan(args);
                 break;
@@ -232,6 +238,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "refill_sends":
                 result = await executeRefillSendsCommand(args);
                 break;
+            case "refill_sends_v2":
+            case "refill_sends_evergreen":
+                result = refillSendsV2Command(args);
+                break;
             case "setup_evergreen_campaigns":
                 result = await setupEvergreenCampaigns(args);
                 markEvergreenSetupCampaignsDirty(args);

package/dist/tools/evergreen-refill-plan.d.ts

@@ -0,0 +1,69 @@
+type GetRefillPlanV2Input = {
+    workspaceId?: string;
+    intent?: "auto" | "evergreen" | "plain" | "active";
+    senderIds?: string[];
+    runState?: Record<string, unknown>;
+    journal?: boolean;
+    journalNote?: string;
+};
+export declare function sanitizeEvergreenRefillPlanResult(value: unknown): Record<string, unknown>;
+export declare const refillPlanV2ToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            workspaceId: {
+                type: string;
+                description: string;
+            };
+            senderIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+            runState: {
+                type: string;
+                description: string;
+            };
+            intent: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            journal: {
+                type: string;
+                description: string;
+            };
+            journalNote: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function getRefillPlanV2(input: GetRefillPlanV2Input): Promise<{
+    readOnly: boolean;
+    blocker: string;
+    workspaceId: string;
+    guidance: string;
+    warnings: string[];
+    journalPath: string | null;
+    text: string;
+    workspaceResolution: string;
+} | {
+    warnings: any[];
+    journalPath: string | null;
+    text: string;
+    workspaceId: string;
+    workspaceResolution: string;
+    readOnly?: undefined;
+    blocker?: undefined;
+    guidance?: undefined;
+}>;
+/** @deprecated Use getRefillPlanV2. */
+export declare const getEvergreenRefillPlan: typeof getRefillPlanV2;
+export {};