@supercuts-walrus/backend 0.1.1 → 0.1.3

package/dist/seller-provision.js

@@ -48,6 +48,8 @@ async function main() {
                         catch (error) {
                             return fail("BRIEF_INVALID", "market brief must be JSON", error);
                         }
+                        if (report.reviewStatus !== "approved")
+                            fail("ARTIFACT_REVIEW_REQUIRED", "market brief must be owner-reviewed before provisioning");
                         if (typeof report.title !== "string" || typeof report.body !== "string" || !Array.isArray(report.citations) || report.citations.length < 2 || report.citations.some((value) => typeof value !== "string" || !/^https:\/\//.test(value)))
                             fail("BRIEF_INVALID", "market brief needs a title, body, and at least two HTTPS citations");
                     }
@@ -56,7 +58,19 @@ async function main() {
                 for (const [briefHash, artifactPath] of Object.entries(capability.variants ?? {})) {
                     if (!/^[0-9a-f]{64}$/.test(briefHash))
                         fail("SELLER_CONFIG_INVALID", "variant brief hash is invalid");
-                    artifacts[`${manifest.capabilityId}:${briefHash}`] = readFileSync(resolve(artifactPath)).toString("base64url");
+                    const body = readFileSync(resolve(artifactPath));
+                    if (manifest.capability === "sui.competitor-analysis") {
+                        let report;
+                        try {
+                            report = JSON.parse(body.toString());
+                        }
+                        catch (error) {
+                            return fail("ANALYSIS_INVALID", "competitor analysis must be JSON", error);
+                        }
+                        if (report.reviewStatus !== "approved")
+                            fail("ARTIFACT_REVIEW_REQUIRED", "competitor analysis must be owner-reviewed before provisioning");
+                    }
+                    artifacts[`${manifest.capabilityId}:${briefHash}`] = body.toString("base64url");
                 }
                 if (!capability.artifact && !Object.keys(capability.variants ?? {}).length)
                     fail("SELLER_ARTIFACT_MISSING", "capability needs a prepared artifact or brief variants");

package/dist/seller-research.d.ts

@@ -0,0 +1,50 @@
+export type SellerResearchKind = "market-brief" | "competitor-analysis";
+export interface SellerResearchDraft {
+    title: string;
+    body: string;
+    citations: string[];
+    preview: {
+        summary: string;
+        relevance: number;
+        sourceQuality: number;
+        freshnessDays: number;
+    };
+    reviewStatus: "draft-needs-owner-review";
+    research: {
+        model: string;
+        generatedAt: string;
+        sourceCount: number;
+        topic: string;
+        kind: SellerResearchKind;
+    };
+}
+export interface SellerResearchOptions {
+    apiKey?: string;
+    model?: string;
+    fetch?: typeof globalThis.fetch;
+    maxSearches?: number;
+    maxTokens?: number;
+    allowedDomains?: string[];
+    now?: Date;
+}
+/** Generates an owner-review draft. It never publishes or mutates a live seller. */
+export declare class ClaudeSellerResearcher {
+    #private;
+    readonly model: string;
+    constructor(options?: SellerResearchOptions);
+    research(input: {
+        kind: SellerResearchKind;
+        topic: string;
+        context?: Record<string, unknown>;
+    }): Promise<SellerResearchDraft>;
+}
+export declare function generateSellerResearch(input: {
+    kind: string;
+    topic: string;
+    output: string;
+    contextFile?: string;
+    allowedDomains?: string;
+    apiKey?: string;
+    model?: string;
+    fetch?: typeof globalThis.fetch;
+}): Promise<Record<string, unknown>>;

package/dist/seller-research.js

@@ -0,0 +1,210 @@
+import { readFileSync, statSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fail } from "./errors.js";
+const asObject = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : fail("SELLER_RESEARCH_INVALID", "Claude research output must be an object");
+const submittedTool = (blocks) => {
+    for (const block of blocks)
+        if (block?.type === "tool_use" && block.name === "submit_research") {
+            if (block.input && typeof block.input === "object" && !Array.isArray(block.input))
+                return block;
+            if (typeof block.input === "string")
+                try {
+                    const input = JSON.parse(block.input);
+                    if (input && typeof input === "object" && !Array.isArray(input))
+                        return { ...block, input };
+                }
+                catch { }
+        }
+    return undefined;
+};
+const normalizedUrl = (value) => { const url = new URL(value); url.hash = ""; if (url.pathname !== "/")
+    url.pathname = url.pathname.replace(/\/$/, ""); return url.toString(); };
+function sourceUrls(value, found = new Set()) {
+    if (Array.isArray(value))
+        for (const item of value)
+            sourceUrls(item, found);
+    else if (value && typeof value === "object")
+        for (const [key, item] of Object.entries(value)) {
+            if (key === "url" && typeof item === "string") {
+                try {
+                    if (new URL(item).protocol === "https:")
+                        found.add(normalizedUrl(item));
+                }
+                catch { }
+            }
+            sourceUrls(item, found);
+        }
+    return found;
+}
+function validateDraft(value, evidence, allowedDomains) {
+    const draft = asObject(value), preview = asObject(draft.preview);
+    if (typeof draft.title !== "string" || draft.title.trim().length < 8 || draft.title.length > 180)
+        fail("SELLER_RESEARCH_INVALID", "research title must contain 8 to 180 characters");
+    if (typeof draft.body !== "string" || draft.body.trim().length < 800 || draft.body.length > 16_000)
+        fail("SELLER_RESEARCH_INVALID", "research body must contain 800 to 16,000 characters");
+    if (!Array.isArray(draft.citations))
+        fail("SELLER_RESEARCH_INVALID", "research citations must be an array");
+    if (draft.citations.length < 3 || draft.citations.length > 32)
+        fail("SELLER_RESEARCH_INVALID", `research must contain 3 to 32 citations; received ${draft.citations.length}`);
+    let citations = draft.citations.map((item) => {
+        if (typeof item !== "string")
+            return fail("SELLER_RESEARCH_INVALID", "every citation must be an HTTPS URL");
+        let url;
+        try {
+            url = new URL(item);
+        }
+        catch (error) {
+            return fail("SELLER_RESEARCH_INVALID", "every citation must be a valid URL", error);
+        }
+        if (url.protocol !== "https:" || url.username || url.password)
+            fail("SELLER_RESEARCH_INVALID", "every citation must be a public HTTPS URL without credentials");
+        if (allowedDomains.length && !allowedDomains.some((domain) => url.hostname === domain || url.hostname.endsWith(`.${domain}`)))
+            fail("SELLER_RESEARCH_SOURCE_UNAPPROVED", `citation host ${url.hostname} is outside --allowed-domains`);
+        const normalized = normalizedUrl(item);
+        if (!evidence.has(normalized))
+            fail("SELLER_RESEARCH_SOURCE_UNVERIFIED", "Claude cited a URL that was not returned by web search");
+        return normalized;
+    });
+    if (new Set(citations).size !== citations.length)
+        fail("SELLER_RESEARCH_INVALID", "research citations must be unique");
+    let reportBody = draft.body.trim();
+    const markers = [...reportBody.matchAll(/\[([1-9][0-9]*)\]/g)].map((match) => Number(match[1]));
+    if (markers.some((index) => index > citations.length))
+        fail("SELLER_RESEARCH_INVALID", "research body contains an out-of-range citation marker");
+    const used = [...new Set(markers)].sort((a, b) => a - b);
+    if (used.length < 3)
+        fail("SELLER_RESEARCH_INVALID", "research body must reference at least three listed sources inline");
+    if (used.length !== citations.length) {
+        const remap = new Map(used.map((oldIndex, newIndex) => [oldIndex, newIndex + 1]));
+        reportBody = reportBody.replace(/\[([1-9][0-9]*)\]/g, (_marker, raw) => `[${remap.get(Number(raw))}]`);
+        citations = used.map((index) => citations[index - 1]);
+    }
+    if (typeof preview.summary !== "string" || preview.summary.trim().length < 30 || preview.summary.length > 400)
+        fail("SELLER_RESEARCH_INVALID", "preview summary must contain 30 to 400 characters");
+    for (const key of ["relevance", "sourceQuality"])
+        if (typeof preview[key] !== "number" || !Number.isFinite(preview[key]) || preview[key] < 0 || preview[key] > 1)
+            fail("SELLER_RESEARCH_INVALID", `preview ${key} must be in [0,1]`);
+    if (!Number.isInteger(preview.freshnessDays) || preview.freshnessDays < 0 || preview.freshnessDays > 365)
+        fail("SELLER_RESEARCH_INVALID", "preview freshnessDays must be an integer in [0,365]");
+    return { title: draft.title.trim(), body: reportBody, citations, preview: { summary: preview.summary.trim(), relevance: preview.relevance, sourceQuality: preview.sourceQuality, freshnessDays: preview.freshnessDays } };
+}
+/** Generates an owner-review draft. It never publishes or mutates a live seller. */
+export class ClaudeSellerResearcher {
+    model;
+    #apiKey;
+    #fetch;
+    #maxSearches;
+    #maxTokens;
+    #allowedDomains;
+    #now;
+    constructor(options = {}) {
+        this.#apiKey = options.apiKey ?? process.env.CLAUDE_API_KEY ?? "";
+        if (!this.#apiKey)
+            fail("CLAUDE_CREDENTIAL_MISSING", "CLAUDE_API_KEY is required to generate a seller research draft");
+        this.model = options.model ?? process.env.CLAUDE_RESEARCH_MODEL ?? process.env.CLAUDE_MODEL ?? "claude-haiku-5-5";
+        this.#fetch = options.fetch ?? fetch;
+        this.#maxSearches = options.maxSearches ?? 8;
+        this.#maxTokens = options.maxTokens ?? 5_000;
+        this.#allowedDomains = (options.allowedDomains ?? []).map((item) => item.trim().toLowerCase()).filter(Boolean);
+        this.#now = options.now ?? new Date();
+        if (!Number.isInteger(this.#maxSearches) || this.#maxSearches < 3 || this.#maxSearches > 12 || !Number.isInteger(this.#maxTokens) || this.#maxTokens < 1_500 || this.#maxTokens > 8_192)
+            fail("CLAUDE_LIMIT_INVALID", "seller research bounds are invalid");
+        if (this.#allowedDomains.some((item) => !/^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)*[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(item)))
+            fail("SELLER_RESEARCH_INVALID", "allowed domains must be bare DNS names");
+    }
+    async research(input) {
+        if (!["market-brief", "competitor-analysis"].includes(input.kind) || !input.topic.trim() || input.topic.length > 500)
+            fail("SELLER_RESEARCH_INVALID", "research needs a valid kind and a topic of at most 500 characters");
+        const context = input.context ? JSON.stringify(input.context) : "none";
+        if (context.length > 40_000)
+            fail("SELLER_RESEARCH_INVALID", "matching brief context is too large");
+        const schema = {
+            type: "object", additionalProperties: false,
+            properties: {
+                title: { type: "string", maxLength: 180 }, body: { type: "string", maxLength: 16000 }, citations: { type: "array", minItems: 3, maxItems: 32, items: { type: "string" } },
+                preview: { type: "object", additionalProperties: false, properties: { summary: { type: "string", maxLength: 400 }, relevance: { type: "number", minimum: 0, maximum: 1 }, sourceQuality: { type: "number", minimum: 0, maximum: 1 }, freshnessDays: { type: "integer", minimum: 0, maximum: 365 } }, required: ["summary", "relevance", "sourceQuality", "freshnessDays"] },
+            }, required: ["title", "body", "citations", "preview"],
+        };
+        const webSearch = { type: "web_search_20250305", name: "web_search", max_uses: this.#maxSearches, allowed_callers: ["direct"] };
+        if (this.#allowedDomains.length)
+            webSearch.allowed_domains = this.#allowedDomains;
+        const system = `<role>You are the research desk for a paid Sui ecosystem intelligence seller.</role>
+<quality_bar>Use web search before writing. Prefer primary sources, official documentation, project announcements, repositories, and dated first-party metrics. Cross-check material claims across independent sources. Separate observed facts from analysis, name dates and measurement windows, surface uncertainty and counter-evidence, and never invent a fact, quotation, number, or URL. The report must be useful to a technically sophisticated buyer, not promotional copy.</quality_bar>
+<format>After research and a final self-check, call submit_research exactly once. Write a cohesive 800-16000 character report. Include inline source markers such as [1] that correspond in order to the citations array. Use only HTTPS URLs actually returned by web_search. Provide at least 3 unique sources and include additional material sources when useful. Preview scores are seller estimates, not independent guarantees.</format>`;
+        const prompt = `<today>${this.#now.toISOString().slice(0, 10)}</today><kind>${input.kind}</kind><topic>${input.topic.trim()}</topic><matching_brief_context>${context}</matching_brief_context><instructions>Research the topic broadly enough to identify market structure, concrete evidence, important competitors or alternatives, risks, and what would change the conclusion. For competitor analysis, directly compare the purchased brief's thesis with named competing projects or approaches. Before submission, verify every citation was observed in search results and every quantitative claim is qualified by date and source.</instructions>`;
+        const request = async (payload) => {
+            let response;
+            try {
+                response = await this.#fetch("https://api.anthropic.com/v1/messages", { method: "POST", headers: { "content-type": "application/json", "anthropic-version": "2023-06-01", "x-api-key": this.#apiKey }, body: JSON.stringify(payload), signal: AbortSignal.timeout(90_000) });
+            }
+            catch (error) {
+                return fail("CLAUDE_UNAVAILABLE", "Claude research request failed closed", error);
+            }
+            if (!response.ok) {
+                await response.arrayBuffer();
+                return fail("CLAUDE_UNAVAILABLE", `Claude research returned status ${response.status}`);
+            }
+            try {
+                return await response.json();
+            }
+            catch (error) {
+                return fail("CLAUDE_OUTPUT_INVALID", "Claude research returned invalid JSON", error);
+            }
+        };
+        const submitTool = { name: "submit_research", description: "Submit the source-checked seller research draft for owner review.", input_schema: schema };
+        let messages = [{ role: "user", content: prompt }], selected;
+        const blocks = [];
+        for (let turn = 0; turn < 3; turn++) {
+            const body = await request({ model: this.model, max_tokens: this.#maxTokens, system, messages, tools: [webSearch, submitTool] });
+            const current = Array.isArray(body.content) ? body.content : [];
+            blocks.push(...current);
+            selected = submittedTool(current);
+            if (selected || current.some((block) => block?.type === "text" && typeof block.text === "string" && block.text.trim()))
+                break;
+            if (!current.length || turn === 2)
+                break;
+            // Anthropic can pause a server-side search turn. Replay its opaque content
+            // unchanged so the model can synthesize the already-returned evidence.
+            messages = [...messages, { role: "assistant", content: current }, { role: "user", content: "Continue the paused research turn using the returned search evidence, then submit the structured draft." }];
+        }
+        const searchFailure = blocks.some((block) => block?.type === "web_search_tool_result" && (block.is_error === true || block.content?.type === "web_search_tool_result_error"));
+        if (searchFailure)
+            fail("SELLER_RESEARCH_SEARCH_FAILED", "Claude web search failed; no draft was written");
+        const evidence = sourceUrls(blocks);
+        if (evidence.size < 3)
+            fail("SELLER_RESEARCH_SOURCE_UNVERIFIED", "Claude returned fewer than three verifiable web-search sources");
+        if (selected)
+            try {
+                const draft = validateDraft(selected.input, evidence, this.#allowedDomains);
+                return { ...draft, reviewStatus: "draft-needs-owner-review", research: { model: this.model, generatedAt: this.#now.toISOString(), sourceCount: evidence.size, topic: input.topic.trim(), kind: input.kind } };
+            }
+            catch { }
+        const researchedText = blocks.filter((block) => block?.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n").slice(0, 30_000) || (selected ? JSON.stringify(selected.input).slice(0, 30_000) : "");
+        if (!researchedText)
+            fail("CLAUDE_OUTPUT_INVALID", "Claude returned search evidence without a research answer");
+        const editorSystem = `<role>You are a strict research editor.</role><instructions>Convert or repair the supplied web-researched answer into the submit_research schema. Preserve material uncertainty, dates, comparisons, and counter-evidence. Use only URLs in verified_sources, include at least 3 unique citations and all additional material sources, and do not add facts or sources. The body must be 800-16000 characters and use [1], [2], and subsequent inline markers corresponding to citation order. Ensure preview is an object with summary, relevance, sourceQuality, and integer freshnessDays. Call submit_research exactly once.</instructions>`;
+        const edited = await request({ model: this.model, max_tokens: this.#maxTokens, system: editorSystem, messages: [{ role: "user", content: JSON.stringify({ kind: input.kind, topic: input.topic.trim(), researchedAnswer: researchedText, verifiedSources: [...evidence].slice(0, 32) }) }], tools: [submitTool], tool_choice: { type: "tool", name: "submit_research" } });
+        const editedBlocks = Array.isArray(edited.content) ? edited.content : [];
+        selected = submittedTool(editedBlocks);
+        if (!selected)
+            fail("CLAUDE_OUTPUT_INVALID", "Claude did not submit a structured research draft");
+        const draft = validateDraft(selected.input, evidence, this.#allowedDomains);
+        return { ...draft, reviewStatus: "draft-needs-owner-review", research: { model: this.model, generatedAt: this.#now.toISOString(), sourceCount: evidence.size, topic: input.topic.trim(), kind: input.kind } };
+    }
+}
+export async function generateSellerResearch(input) {
+    const kind = input.kind;
+    const output = resolve(input.output || fail("ARGUMENT_REQUIRED", "seller research requires --output"));
+    let context;
+    if (input.contextFile) {
+        const path = resolve(input.contextFile);
+        if ((statSync(path).mode & 0o077) !== 0)
+            fail("SELLER_CONFIG_PERMISSIONS", "research context file must be owner-only");
+        context = asObject(JSON.parse(readFileSync(path, "utf8")));
+    }
+    const allowedDomains = input.allowedDomains?.split(",").map((item) => item.trim()).filter(Boolean);
+    const researcher = new ClaudeSellerResearcher({ ...(input.apiKey ? { apiKey: input.apiKey } : {}), ...(input.model ? { model: input.model } : {}), ...(input.fetch ? { fetch: input.fetch } : {}), ...(allowedDomains?.length ? { allowedDomains } : {}) });
+    const draft = await researcher.research({ kind, topic: input.topic, ...(context ? { context } : {}) });
+    writeFileSync(output, `${JSON.stringify(draft, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+    return { output, kind, topic: input.topic, model: researcher.model, citations: draft.citations.length, reviewStatus: draft.reviewStatus, nextStep: "Review every claim and citation, then set reviewStatus to approved before catalog generation or seller packaging." };
+}

package/dist/seller-scaffold.d.ts

@@ -0,0 +1 @@
+export declare function scaffoldSeller(input: Record<string, string | boolean>): Record<string, unknown>;

package/dist/seller-scaffold.js

@@ -0,0 +1,35 @@
+import { chmodSync, mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fail } from "./errors.js";
+const idPattern = /^[a-z0-9][a-z0-9._-]{1,127}$/;
+export function scaffoldSeller(input) {
+    const home = typeof input.home === "string" ? resolve(input.home) : fail("ARGUMENT_REQUIRED", "seller scaffold requires --home");
+    const output = typeof input.output === "string" ? resolve(input.output) : fail("ARGUMENT_REQUIRED", "seller scaffold requires --output");
+    const capabilityId = String(input["capability-id"] ?? ""), capability = String(input.capability ?? ""), description = String(input.description ?? ""), origin = String(input.origin ?? ""), price = String(input.price ?? "");
+    if (!idPattern.test(capabilityId) || !idPattern.test(capability))
+        fail("SELLER_SCAFFOLD_INVALID", "capability identifiers must use 2..128 lowercase letters, digits, dot, underscore, or dash");
+    if (!description || description.length > 512 || !/^[1-9][0-9]*$/.test(price))
+        fail("SELLER_SCAFFOLD_INVALID", "description and positive MIST --price are required");
+    const url = new URL(origin);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "::1"].includes(url.hostname)) || url.username || url.password || url.pathname !== "/" || url.search || url.hash)
+        fail("SELLER_SCAFFOLD_INVALID", "origin must be an HTTPS or loopback HTTP origin without path or credentials");
+    const rails = String(input.rails ?? "x402").split(",").map((rail) => rail.trim()).filter(Boolean);
+    if (!rails.length || rails.some((rail) => rail !== "x402" && rail !== "shielded") || new Set(rails).size !== rails.length)
+        fail("SELLER_SCAFFOLD_INVALID", "--rails must be x402, shielded, or x402,shielded");
+    const days = Number(input["expires-in-days"] ?? "30");
+    if (!Number.isSafeInteger(days) || days < 1 || days > 365)
+        fail("SELLER_SCAFFOLD_INVALID", "--expires-in-days must be 1..365");
+    const listenPort = Number(input["listen-port"] ?? (url.protocol === "http:" && url.port ? url.port : "8788"));
+    if (!Number.isSafeInteger(listenPort) || listenPort < 1 || listenPort > 65535)
+        fail("SELLER_SCAFFOLD_INVALID", "--listen-port must be 1..65535");
+    mkdirSync(output, { recursive: false, mode: 0o700 });
+    chmodSync(output, 0o700);
+    const specPath = resolve(output, "capability.json"), handlerPath = resolve(output, "handler.mjs"), registrationPath = resolve(output, "registration.json"), servicePath = resolve(output, "seller-service.json");
+    const spec = { capabilityId, capability, description, inputSchema: { type: "object", required: ["task"], properties: { task: { type: "string", minLength: 1, maxLength: 4096 } }, additionalProperties: false }, outputSchema: { type: "object", required: ["kind"], properties: { kind: { const: capability } }, additionalProperties: false }, supportedRails: rails, priceBand: { minimum: price, maximum: price }, asset: "0x2::sui::SUI", endpoint: `${url.origin}/v2/resource/${capabilityId}`, expiresAt: Date.now() + days * 86_400_000 };
+    const handler = `export async function handle(request) {\n  const result = { kind: ${JSON.stringify(capability)}, task: request.input.task, message: "Replace this template with your seller implementation." };\n  return { artifact: Buffer.from(JSON.stringify(result)), contentType: "application/json", metadata: { kind: ${JSON.stringify(capability)} } };\n}\n`;
+    const service = { origin: url.origin, listenHost: "127.0.0.1", listenPort, ...(rails.includes("x402") ? { facilitatorUrlEnv: "X402_FACILITATOR_URL", facilitatorKeyEnv: "FACILITATOR_SHARED_KEY" } : {}), capabilities: [{ registrationFile: registrationPath, handler: handlerPath }] };
+    writeFileSync(specPath, `${JSON.stringify(spec, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+    writeFileSync(handlerPath, handler, { mode: 0o600, flag: "wx" });
+    writeFileSync(servicePath, `${JSON.stringify(service, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+    return { home, output, specFile: specPath, handlerFile: handlerPath, registrationFile: registrationPath, serviceFile: servicePath, expiresAt: spec.expiresAt, nextCommands: [`supercuts-seller-register ${JSON.stringify(home)} ${JSON.stringify(specPath)} ${JSON.stringify(registrationPath)}`, `supercuts-seller-live ${JSON.stringify(home)} ${JSON.stringify(servicePath)}`], note: "Review and replace the generated handler before serving production work." };
+}

package/dist/seller-service.d.ts

@@ -18,7 +18,7 @@ export declare class SellerService {
         facilitatorUrl: string;
         facilitatorKey: string;
         allowedBuyers: ReadonlySet<string>;
-        claudeKey: string;
+        claudeKey?: string;
         directoryAggregator?: string;
     }): Promise<SellerService>;
     private artifact;

package/dist/seller-service.js

@@ -4,7 +4,6 @@ import { createServer } from "node:http";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { BoundedClaude } from "./claude.js";
 import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
 import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
 import { isValidPersonalMessageSignature } from "@mysten/sui/verify";
@@ -18,6 +17,7 @@ import { captureSellerHome, decryptSellerSnapshot, encryptSellerSnapshot, restor
 import { X402ResourceService } from "./x402-resource-service.js";
 import { LiveSellerTransport } from "./live-seller-transport.js";
 import { registerDirectoryCapability } from "./seller-directory.js";
+import { isMainModule } from "./main-module.js";
 const isV2 = (row) => row.preview.genericV2 === true;
 const sha256 = (value) => createHash("sha256").update(value).digest("hex");
 const validId = (value, name) => typeof value === "string" && /^[a-zA-Z0-9._:-]{1,128}$/.test(value) ? value : fail("SELLER_REQUEST_INVALID", `${name} is invalid`);
@@ -35,10 +35,9 @@ export class SellerService {
     #v2 = new Map();
     #v2BySeller = new Map();
     #root = mkdtempSync(join(tmpdir(), "supercuts-sellers-"));
-    #claude;
     #queue = Promise.resolve();
     #healthy = true;
-    constructor(db, snapshotKey, origin, facilitatorUrl, facilitatorKey, allowedBuyers, claudeKey, directoryAggregator) {
+    constructor(db, snapshotKey, origin, facilitatorUrl, facilitatorKey, allowedBuyers, directoryAggregator) {
         this.db = db;
         this.snapshotKey = snapshotKey;
         this.origin = origin;
@@ -46,10 +45,9 @@ export class SellerService {
         this.facilitatorKey = facilitatorKey;
         this.allowedBuyers = allowedBuyers;
         this.directoryAggregator = directoryAggregator;
-        this.#claude = new BoundedClaude({ apiKey: claudeKey });
     }
     static async create(config) {
-        const service = new SellerService(config.db, config.snapshotKey, config.origin, config.facilitatorUrl, config.facilitatorKey, config.allowedBuyers, config.claudeKey, config.directoryAggregator);
+        const service = new SellerService(config.db, config.snapshotKey, config.origin, config.facilitatorUrl, config.facilitatorKey, config.allowedBuyers, config.directoryAggregator);
         const rows = (await config.db.listCatalog()).filter((row) => !(isV2(row) && row.manifest.expiresAt <= Date.now()));
         for (const row of rows) {
             validateCapabilityManifest(row.manifest);
@@ -271,10 +269,6 @@ export class SellerService {
                     const opening = BigInt(String(offer.opening ?? "0")), maximum = BigInt(String(offer.maximum ?? "0")), minimum = BigInt(row.manifest.priceBand.minimum), briefHash = typeof offer.briefHash === "string" ? offer.briefHash : undefined;
                     if (opening <= 0n || opening > maximum || maximum < minimum || maximum > BigInt(row.manifest.priceBand.maximum) || briefHash !== undefined && !/^[0-9a-f]{64}$/.test(briefHash))
                         fail("NEGOTIATION_BOUNDS_INVALID", "buyer offer exceeds approved price bounds");
-                    const task = String(offer.task ?? "").slice(0, 512);
-                    const decision = await this.#claude.decide({ system: "You are a bounded research seller. Present only the fixed price and service terms approved by Supercuts.", task, candidates: [{ action: "counteroffer", capabilityId, amount: minimum.toString() }], schema: { name: "respond_to_private_offer", description: "Present the approved exact price.", properties: { action: { type: "string", enum: ["counteroffer"] } }, required: ["action"] } });
-                    if (decision.action.action !== "counteroffer")
-                        fail("SELLER_DECISION_INVALID", "seller did not choose the approved response");
                     const reply = { capabilityId, amount: minimum.toString(), asset: row.manifest.asset, railOptions: row.manifest.supportedRails, accepted: true };
                     const replyCiphertext = encryptSessionMessage(key, sessionId, `${sessionId}:seller:2`, Buffer.from(JSON.stringify(reply)));
                     const requestBlobId = await this.publishCiphertext(slot, ciphertext), replyBlobId = await this.publishCiphertext(slot, replyCiphertext);
@@ -291,7 +285,7 @@ export class SellerService {
                         this.#healthy = false;
                         throw error;
                     }
-                    await this.db.addEvent({ run_id: runId, seller_id: slot.sellerId, stage: "negotiation", status: "complete", details: { capabilityId, sessionId, requestBlobId, replyBlobId, transcriptHash, model: decision.model } });
+                    await this.db.addEvent({ run_id: runId, seller_id: slot.sellerId, stage: "negotiation", status: "complete", details: { capabilityId, sessionId, requestBlobId, replyBlobId, transcriptHash, decision: "policy-validated-fixed-price" } });
                     return this.reply(response, 200, { sessionId, capabilityId, ciphertext: replyCiphertext, signature, requestBlobId, replyBlobId, transcriptHash });
                 });
             }
@@ -316,9 +310,6 @@ export class SellerService {
                     const prior = slot.app.store.db.prepare("SELECT operation_id AS operationId,capability_id AS capabilityId,amount,artifact_key AS artifactKey,run_id AS runId FROM remote_quotes WHERE request_id=?").get(requestId);
                     if (prior && JSON.stringify(prior) !== JSON.stringify({ operationId, capabilityId, amount: quote.amount, artifactKey: quote.artifactKey, runId }))
                         fail("SELLER_QUOTE_CONFLICT", "request ID identifies another quote");
-                    const decision = await this.#claude.decide({ system: "You are a bounded seller agent. You may present only the fixed approved quote.", task: String(input.task ?? "Sui market brief").slice(0, 512), candidates: [{ action: "present_quote", capabilityId, amount: quote.amount }], schema: { name: "respond_to_buyer", description: "Present the approved exact price.", properties: { action: { type: "string", enum: ["present_quote"] } }, required: ["action"] } });
-                    if (decision.action.action !== "present_quote")
-                        fail("SELLER_DECISION_INVALID", "seller did not choose the approved quote");
                     slot.app.store.db.prepare("INSERT OR IGNORE INTO remote_quotes(request_id,operation_id,capability_id,amount,artifact_key,run_id) VALUES(?,?,?,?,?,?)").run(requestId, operationId, capabilityId, quote.amount, quote.artifactKey, runId);
                     const artifact = this.artifact(slot, quote.artifactKey), registration = this.resource(slot, row).register(requestId, operationId, artifact);
                     try {
@@ -328,7 +319,7 @@ export class SellerService {
                         this.#healthy = false;
                         throw error;
                     }
-                    await this.db.addEvent({ run_id: runId, seller_id: slot.sellerId, stage: "quote", status: "complete", details: { capabilityId, amount: quote.amount, model: decision.model } });
+                    await this.db.addEvent({ run_id: runId, seller_id: slot.sellerId, stage: "quote", status: "complete", details: { capabilityId, amount: quote.amount, decision: "manifest-fixed-price" } });
                     return this.reply(response, 200, { capabilityId, sellerId: slot.sellerId, amount: quote.amount, asset: row.manifest.asset, requestId, operationId, resourceUrl: registration.url, artifactSha256: registration.artifactSha256 });
                 });
             }
@@ -356,9 +347,6 @@ export class SellerService {
                     const prior = slot.app.store.db.prepare("SELECT capability_id AS capabilityId,artifact_key AS artifactKey,delivery_public_key AS deliveryPublicKey,run_id AS runId FROM remote_deliveries WHERE session_id=?").get(sessionId);
                     if (prior && JSON.stringify(prior) !== JSON.stringify({ capabilityId, artifactKey, deliveryPublicKey, runId }))
                         fail("AGREEMENT_SESSION_CONFLICT", "session identifies another delivery");
-                    const decision = await this.#claude.decide({ system: "You are a bounded seller agent. Sign only the backend-verified agreement.", task: `Respond to accepted competitor analysis request for ${capabilityId}.`, candidates: [{ action: "sign_approved_agreement", capabilityId }], schema: { name: "respond_to_private_offer", description: "Approve the backend-verified agreement.", properties: { action: { type: "string", enum: ["sign_approved_agreement"] } }, required: ["action"] } });
-                    if (decision.action.action !== "sign_approved_agreement")
-                        fail("SELLER_DECISION_INVALID", "seller did not choose the approved agreement");
                     const signed = await executeMandated(slot.app, loadMandate(slot.home), "offer.counter", { "operation-id": `remote-counter-${sessionId}`, session: sessionId, agreement: encoded });
                     slot.app.store.db.prepare("INSERT OR IGNORE INTO remote_deliveries(session_id,capability_id,artifact_key,delivery_public_key,run_id) VALUES(?,?,?,?,?)").run(sessionId, capabilityId, artifactKey, deliveryPublicKey, runId);
                     try {
@@ -368,7 +356,7 @@ export class SellerService {
                         this.#healthy = false;
                         throw error;
                     }
-                    await this.db.addEvent({ run_id: runId, seller_id: slot.sellerId, stage: "agreement", status: "complete", details: { capabilityId, sessionId, model: decision.model, dealCommitment: signed.dealCommitment } });
+                    await this.db.addEvent({ run_id: runId, seller_id: slot.sellerId, stage: "agreement", status: "complete", details: { capabilityId, sessionId, decision: "backend-verified-agreement", dealCommitment: signed.dealCommitment } });
                     return this.reply(response, 200, { sessionId, capabilityId, agreement: signed.agreement, dealCommitment: signed.dealCommitment, artifactSha256 });
                 });
             }
@@ -412,11 +400,11 @@ export class SellerService {
     close() { for (const slot of this.#slots.values())
         slot.app.close(); rmSync(this.#root, { recursive: true, force: true }); }
 }
-if (process.argv[1] && import.meta.url.endsWith(process.argv[1])) {
+if (isMainModule(import.meta.url)) {
     const required = (key) => process.env[key] ?? fail("SELLER_CONFIG_MISSING", `${key} is required`);
     const port = Number(process.env.PORT ?? "3000");
     const origin = required("SELLER_ORIGIN");
-    SellerService.create({ db: new SellerDatabase(required("SUPABASE_URL"), required("SUPABASE_SERVICE_ROLE_KEY")), snapshotKey: required("SELLER_STATE_KEY"), origin, facilitatorUrl: required("FACILITATOR_URL"), facilitatorKey: required("FACILITATOR_SHARED_KEY"), allowedBuyers: new Set((process.env.SELLER_ALLOWED_BUYERS ?? "").split(",").map((item) => item.trim().toLowerCase()).filter(Boolean)), claudeKey: required("CLAUDE_API_KEY"), ...(process.env.DIRECTORY_WALRUS_AGGREGATOR ? { directoryAggregator: process.env.DIRECTORY_WALRUS_AGGREGATOR } : {}) })
+    SellerService.create({ db: new SellerDatabase(required("SUPABASE_URL"), required("SUPABASE_SERVICE_ROLE_KEY")), snapshotKey: required("SELLER_STATE_KEY"), origin, facilitatorUrl: required("FACILITATOR_URL"), facilitatorKey: required("FACILITATOR_SHARED_KEY"), allowedBuyers: new Set((process.env.SELLER_ALLOWED_BUYERS ?? "").split(",").map((item) => item.trim().toLowerCase()).filter(Boolean)), ...(process.env.DIRECTORY_WALRUS_AGGREGATOR ? { directoryAggregator: process.env.DIRECTORY_WALRUS_AGGREGATOR } : {}) })
         .then((service) => { const server = service.createServer(); server.listen(port, "0.0.0.0"); const close = () => server.close(() => { service.close(); process.exit(0); }); process.on("SIGINT", close); process.on("SIGTERM", close); })
         .catch((error) => { process.stderr.write(`${error instanceof Error ? error.message : "seller service failed"}\n`); process.exitCode = 1; });
 }

package/dist/seller-setup.d.ts

@@ -0,0 +1,3 @@
+export declare function createSellerSession(home: string): Record<string, unknown>;
+export declare function setupSeller(home: string, configPath: string): Record<string, unknown>;
+export declare function promptSellerSetup(home: string): Promise<Record<string, unknown>>;

package/dist/seller-setup.js

@@ -0,0 +1,109 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline/promises";
+import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+import { fail } from "./errors.js";
+import { TESTNET_DEFAULTS, withTestnetDefaults } from "./testnet-defaults.js";
+import { initialize } from "./phase3.js";
+function ownerFile(path) {
+    if ((statSync(path).mode & 0o077) !== 0)
+        fail("SETUP_PERMISSIONS", `${path} must be owner-only`);
+}
+function validateConfig(config) {
+    withTestnetDefaults(config);
+    for (const key of ["deploymentConfig", "tatumKeyFile", "writeGrpc", "tatumGrpc", "walrusPublisher", "walrusAggregator"]) {
+        if (typeof config[key] !== "string" || !config[key])
+            fail("SETUP_INVALID", `${key} is required`);
+    }
+    ownerFile(resolve(config.tatumKeyFile));
+    if (config.suiKeyFile)
+        ownerFile(resolve(config.suiKeyFile));
+    const deployment = JSON.parse(readFileSync(resolve(config.deploymentConfig), "utf8"));
+    if (deployment.network !== "testnet" || deployment.testOnly !== true || deployment.verifierVersion !== 2)
+        fail("SETUP_INVALID", "seller setup requires the pinned experimental v2 Testnet deployment");
+    return config;
+}
+function readConfig(path) {
+    ownerFile(path);
+    return validateConfig(JSON.parse(readFileSync(path, "utf8")));
+}
+export function createSellerSession(home) {
+    if (!existsSync(join(home, "profile.json")))
+        fail("SETUP_REQUIRED", "initialize the seller before creating an agent session");
+    const mcpScript = join(dirname(fileURLToPath(import.meta.url)), "mcp-bootstrap.js");
+    const mcp = `[mcp_servers.supercuts-seller]\ncommand = ${JSON.stringify(process.execPath)}\nargs = ${JSON.stringify([mcpScript])}\n[mcp_servers.supercuts-seller.env]\nSUPERCUTS_HOME = ${JSON.stringify(home)}\n`;
+    const mcpConfig = join(home, "seller-codex.toml");
+    writeFileSync(mcpConfig, mcp, { mode: 0o600 });
+    chmodSync(mcpConfig, 0o600);
+    return { mcpConfig };
+}
+function setupSellerConfig(home, config) {
+    if (existsSync(join(home, "profile.json")))
+        fail("PROFILE_EXISTS", "seller home already exists; create a separate home for another seller identity");
+    mkdirSync(home, { recursive: true, mode: 0o700 });
+    chmodSync(home, 0o700);
+    const keyPath = config.suiKeyFile ? resolve(config.suiKeyFile) : join(home, "seller.sui.key");
+    if (!config.suiKeyFile)
+        writeFileSync(keyPath, Ed25519Keypair.generate().getSecretKey(), { mode: 0o600, flag: "wx" });
+    ownerFile(keyPath);
+    initialize(home, {
+        role: "seller",
+        "deployment-config": resolve(config.deploymentConfig),
+        "sui-key-file": keyPath,
+        "tatum-key-file": resolve(config.tatumKeyFile),
+        "write-grpc": config.writeGrpc,
+        "tatum-grpc": config.tatumGrpc,
+        "walrus-publisher": config.walrusPublisher,
+        "walrus-aggregator": config.walrusAggregator,
+        ...(config.snarkjs ? { snarkjs: resolve(config.snarkjs) } : {}),
+        ...(config.converter ? { converter: resolve(config.converter) } : {}),
+        ...(config.rapidsnark ? { rapidsnark: resolve(config.rapidsnark) } : {}),
+    });
+    const decoded = decodeSuiPrivateKey(readFileSync(keyPath, "utf8").trim());
+    if (decoded.scheme !== "ED25519")
+        fail("SETUP_INVALID", "seller key must use ED25519");
+    const address = Ed25519Keypair.fromSecretKey(decoded.secretKey).toSuiAddress();
+    return {
+        home,
+        address,
+        fundingRequired: false,
+        warning: "Do not faucet-fund the seller. Only a generated buyer address is funded for live purchases.",
+        ...createSellerSession(home),
+        nextStep: `Run supercuts seller scaffold --home ${JSON.stringify(home)} --output <offer-dir> with the capability, origin, price, rails, and expiry options. Review the handler, then run the printed registration and service commands.`,
+    };
+}
+export function setupSeller(home, configPath) {
+    return setupSellerConfig(home, readConfig(resolve(configPath)));
+}
+export async function promptSellerSetup(home) {
+    if (!process.stdin.isTTY)
+        fail("SETUP_INPUT_REQUIRED", "interactive seller setup requires a terminal; use --config with an owner-only JSON file");
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        const ask = async (label, fallback) => (await rl.question(fallback ? `${label} [${fallback}]: ` : `${label}: `)).trim() || fallback || "";
+        process.stderr.write("Press Enter to accept a bracketed default. Credentials are read from owner-only files, never typed here.\n");
+        const config = {
+            deploymentConfig: await ask("Pinned v2 Testnet deployment config path (blank for bundled config)"),
+            tatumKeyFile: await ask("Owner-only Tatum API key file path"),
+            writeGrpc: await ask("Sui write gRPC URL", TESTNET_DEFAULTS.writeGrpc),
+            tatumGrpc: await ask("Tatum read gRPC URL", TESTNET_DEFAULTS.tatumGrpc),
+            walrusPublisher: await ask("Walrus publisher URL", TESTNET_DEFAULTS.walrusPublisher),
+            walrusAggregator: await ask("Walrus aggregator URL", TESTNET_DEFAULTS.walrusAggregator),
+        };
+        const snarkjs = await ask("SnarkJS executable path (blank for deployment-relative default)");
+        const converter = await ask("Groth16 converter path (blank for deployment-relative default)");
+        const rapidsnark = await ask("RapidSnark executable path (blank to use SnarkJS)");
+        if (snarkjs)
+            config.snarkjs = snarkjs;
+        if (converter)
+            config.converter = converter;
+        if (rapidsnark)
+            config.rapidsnark = rapidsnark;
+        return setupSellerConfig(home, validateConfig(config));
+    }
+    finally {
+        rl.close();
+    }
+}