@zktx.io/sui-mcp 0.5.0 → 0.6.1

package/dist/mcp-ui/contracts.js

@@ -7,11 +7,13 @@ export const CARD_RESOURCE_URIS = {
     receipt: "ui://sui-mcp/receipt.html",
     chart: "ui://sui-mcp/chart.html",
     connect: "ui://sui-mcp/connect.html",
-    review: "ui://sui-mcp/review.html"
+    review: "ui://sui-mcp/review.html",
+    settings: "ui://sui-mcp/settings.html"
 };
 export const CARD_METADATA_KEY = "sui-mcp/card";
 export const CARD_DISPLAY_METADATA_KEY = "sui-mcp/receipt-display";
 export const WALLET_DISPLAY_METADATA_KEY = "sui-mcp/wallet-display";
+export const SETTINGS_FILE_METADATA_KEY = "sui-mcp/settings-file";
 export const CARD_RESOURCE_PREFIX = "suimcp://cards/";
 export const cardInputRequiredSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("account"), status: z.literal("input_required"), field: z.literal("account"), message: z.string().min(1) }).strict(),
@@ -25,7 +27,11 @@ export const cardReceiptDisplaySchema = receiptDisplaySchema.extend({
     cardId: z.string().min(1), revision: z.number().int().nonnegative(), attemptId: z.string().min(1).optional()
 });
 export const cardWalletDisplaySchema = walletDisplaySchema.extend({ cardId: z.string().min(1), revision: z.number().int().nonnegative() });
+export const settingsFileDisplaySchema = z.object({ attemptId: z.string().uuid().optional(), cardId: z.string().min(1), operationId: z.string().uuid(), fileId: z.string().uuid(),
+    offset: z.number().int().nonnegative().safe(), totalSize: z.number().int().nonnegative().safe(), sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    chunkBase64: z.string() }).strict();
 export const CARD_TOOLS = {
     account: TOOL_NAMES.uiOpenAccount, receipt: TOOL_NAMES.uiOpenReceipt, chart: TOOL_NAMES.uiOpenChart,
-    read: TOOL_NAMES.uiReadCard, submit: TOOL_NAMES.uiSubmitCard, act: TOOL_NAMES.uiActCard
+    read: TOOL_NAMES.uiReadCard, submit: TOOL_NAMES.uiSubmitCard, act: TOOL_NAMES.uiActCard,
+    readSettingsFile: TOOL_NAMES.uiReadSettingsFile
 };

package/dist/mcp-ui/readCards.js

@@ -2,7 +2,7 @@ import { CardStore } from "../core/session/cardSessionStore.js";
 import { accountInputSchema, receiptInputSchema, chartInputSchema } from "../core/read/readCardInputs.js";
 export function createReadCardStore(options) {
     return new CardStore({
-        records: options.records, ownerId: options.ownerId, assertCurrent: options.assertCurrent, now: options.now, logger: options.logger, workflow: options.workflow,
+        records: options.records, ownerId: options.ownerId, assertCurrent: options.assertCurrent, now: options.now, logger: options.logger, workflow: options.workflow, settings: options.settings,
         prepare: async (kind) => {
             if (kind !== "chart")
                 return { status: "ready" };

package/dist/mcp-ui/tools.js

@@ -1,4 +1,6 @@
 import { workflowActionSchema } from "../core/session/workflowView.js";
+import { settingsActionSchema } from "../core/session/settingsOperation.js";
+import { MAX_JSON_BODY_BYTES, settingsJsonSize, settingsRawChunkBudget } from "../core/session/settingsFileProtocol.js";
 import { sessionDomainToolError } from "../mcp/toolErrors.js";
 import { accountInputSchema, receiptInputSchema, chartOpenInputSchema } from "../core/read/readCardInputs.js";
 import { readFile } from "node:fs/promises";
@@ -8,8 +10,8 @@ import { z } from "zod";
 import { okToolResult, errorToolResult } from "../mcp/result.js";
 import { CardError } from "../core/session/cardSessionStore.js";
 import { resolveExplicitOrActiveAccount } from "../mcp/tools/read/readToolHelpers.js";
-import { CARD_METADATA_KEY, CARD_DISPLAY_METADATA_KEY, WALLET_DISPLAY_METADATA_KEY, CARD_RESOURCE_PREFIX, CARD_RESOURCE_URIS, CARD_TOOLS, cardReceiptDisplaySchema, cardWalletDisplaySchema, cardReferenceSchema, cardSubmissionSchema, cardInputRequiredSchema } from "./contracts.js";
-const cardActionSchema = cardReferenceSchema.extend({ revision: z.number().int().nonnegative(), input: workflowActionSchema }).strict();
+import { CARD_METADATA_KEY, CARD_DISPLAY_METADATA_KEY, WALLET_DISPLAY_METADATA_KEY, SETTINGS_FILE_METADATA_KEY, CARD_RESOURCE_PREFIX, CARD_RESOURCE_URIS, CARD_TOOLS, cardReceiptDisplaySchema, cardWalletDisplaySchema, cardReferenceSchema, cardSubmissionSchema, cardInputRequiredSchema } from "./contracts.js";
+const cardActionSchema = cardReferenceSchema.extend({ revision: z.number().int().nonnegative().safe(), input: z.union([workflowActionSchema, settingsActionSchema]) }).strict();
 export const cardMetadata = (kind) => ({
     ui: { resourceUri: CARD_RESOURCE_URIS[kind], visibility: ["model"] },
     "openai/outputTemplate": CARD_RESOURCE_URIS[kind]
@@ -19,8 +21,9 @@ export function supportsCards(server) {
     const capabilities = server.server.getClientCapabilities();
     const { extensions, ...standard } = capabilities ?? {};
     const current = capabilities === undefined ? undefined : { ...standard, ...(extensions === undefined ? {} : { extensions }) };
-    return getUiCapability(current)?.mimeTypes?.includes(RESOURCE_MIME_TYPE) === true ||
-        server.server.getClientVersion()?.name === "codex-mcp-client";
+    const ui = getUiCapability(current);
+    return ui !== null && typeof ui === "object" && !Array.isArray(ui) && Array.isArray(ui.mimeTypes) &&
+        ui.mimeTypes.every((mimeType) => typeof mimeType === "string") && ui.mimeTypes.includes(RESOURCE_MIME_TYPE);
 }
 export function cardToolResult(response, savedLink = false) {
     const snapshot = response.snapshot;
@@ -131,4 +134,31 @@ export function registerReadCards(server, deps) {
             }
         });
     }
+    const fileInput = cardReferenceSchema.extend({ attemptId: z.string().uuid().optional(), operationId: z.string().uuid(), fileId: z.string().uuid(), offset: z.number().int().nonnegative().safe(),
+        limit: z.number().int().positive().safe().optional() }).strict();
+    registerAppTool(server, CARD_TOOLS.readSettingsFile, { description: "Read a verified backup file for its current download attempt.", inputSchema: fileInput,
+        _meta: { ui: { visibility: ["app"] } }, annotations: { readOnlyHint: true, openWorldHint: false }
+    }, async (input, extra) => {
+        try {
+            if (!deps.cards)
+                throw new CardError("Card service is unavailable.");
+            const base = okToolResult({ status: "read", fileId: input.fileId, offset: input.offset, rangeSize: Number.MAX_SAFE_INTEGER });
+            const metadata = { ...(input.attemptId ? { attemptId: input.attemptId } : {}), cardId: input.cardId, operationId: input.operationId, fileId: input.fileId, offset: input.offset, totalSize: Number.MAX_SAFE_INTEGER,
+                sha256: "0".repeat(64), chunkBase64: "" };
+            base._meta = { [SETTINGS_FILE_METADATA_KEY]: metadata };
+            const budget = settingsRawChunkBudget({ jsonrpc: "2.0", id: extra.requestId, result: base });
+            if (!budget)
+                throw new CardError("The backup response cannot fit the app's message envelope.");
+            const read = await deps.cards.store.readSettingsFile(input, Math.min(input.limit ?? budget, budget));
+            const rangeSize = Buffer.from(read.chunkBase64, "base64").length;
+            const result = okToolResult({ status: "read", fileId: input.fileId, offset: input.offset, rangeSize });
+            result._meta = { [SETTINGS_FILE_METADATA_KEY]: { ...metadata, totalSize: read.file.totalSize, sha256: read.file.sha256, chunkBase64: read.chunkBase64 } };
+            if (settingsJsonSize({ jsonrpc: "2.0", id: extra.requestId, result }) > MAX_JSON_BODY_BYTES)
+                throw new CardError("The backup response exceeds its message limit.");
+            return result;
+        }
+        catch {
+            return errorToolResult({ kind: "input_invalid", details: { reason: "This backup file could not be read or verified." } });
+        }
+    });
 }

package/dist/review-server/server.js

@@ -1,10 +1,6 @@
-import { createServer } from "node:http";
 import { validateHostOrigin } from "./middleware/hostOrigin.js";
-import { defaultReviewAssetsDir, serveReviewAsset } from "./assets.js";
-import { settingsHtml } from "./html.js";
-import { HttpError, sendHtml, sendJson } from "./http.js";
+import { sendJson } from "../runtime/shared/http.js";
 import { ALLOWED_HOSTNAMES } from "./reviewServerPolicy.js";
-import { routeSettingsApi } from "./settingsApi.js";
 export function createReviewRequestHandler(options) {
     return async (request, response) => {
         try {
@@ -18,55 +14,11 @@ export function createReviewRequestHandler(options) {
                 sendJson(response, 400, { error: "token_query_not_supported" });
                 return;
             }
-            const settings = /^\/settings\/([^/]+)$/.exec(url.pathname);
-            if (request.method === "GET" && settings?.[1]) {
-                sendHtml(response, settingsHtml(settings[1]), { "content-security-policy": [
-                        "default-src 'none'", "base-uri 'none'", "connect-src 'self'", "script-src 'self'",
-                        "style-src 'self'", "img-src 'self' data:", "form-action 'none'"
-                    ].join("; ") });
-                return;
-            }
-            const asset = /^\/review-assets\/(.+)$/.exec(url.pathname);
-            if (request.method === "GET" && asset?.[1]) {
-                await serveReviewAsset(response, options.reviewAssetsDir ?? defaultReviewAssetsDir(), asset[1]);
-                return;
-            }
-            const route = /^\/api\/settings\/([^/]+)(?:\/(.*))?$/.exec(url.pathname);
-            if (route?.[1]) {
-                const routes = {
-                    "": "status", "clear-active-account": "clearActiveAccount", "sui-grpc-url": "setSuiGrpcUrl",
-                    "sui-grpc-url/restore-default": "restoreDefaultSuiGrpcUrl", "sui-graphql-url": "setSuiGraphqlUrl",
-                    "sui-graphql-url/restore-default": "restoreDefaultSuiGraphqlUrl", "local-data/export": "exportLocalData",
-                    "local-data/import/preview": "previewImport", "local-data/import": "importLocalData", "local-data/reset": "resetLocalData"
-                };
-                const match = routes[route[2] ?? ""];
-                if (match) {
-                    await routeSettingsApi(request, response, options, url, { [match]: route[1] });
-                    return;
-                }
-            }
             sendJson(response, 404, { error: "not_found" });
         }
-        catch (error) {
-            if (error instanceof HttpError) {
-                sendJson(response, error.status, { error: error.code });
-                return;
-            }
-            options.logger.error("settings request failed", { stage: "settings_http" });
+        catch {
+            options.logger.error("HTTP routing failed", { stage: "http_routing" });
             sendJson(response, 500, { error: "internal_error" });
         }
     };
 }
-export function createReviewHttpServer(options) {
-    const handler = createReviewRequestHandler(options);
-    const server = createServer((request, response) => { void handler(request, response); });
-    return {
-        start(port) {
-            return new Promise((resolve, reject) => {
-                server.once("error", reject);
-                server.listen(port, options.host, () => resolve({ host: options.host, port: server.address().port,
-                    close: () => new Promise((done, failed) => { server.close((error) => error ? failed(error) : done()); }) }));
-            });
-        }
-    };
-}

package/dist/runtime/application.js

@@ -5,6 +5,8 @@ import { dirname } from "node:path";
 import { WalletSdkProcess } from "./walletSdkProcess.js";
 import { WALLETCONNECT_PROJECT_ID } from "./walletConnectConfig.js";
 import { WalletWorkflow } from "../core/session/walletWorkflow.js";
+import { SettingsWorkflow } from "../core/session/settingsWorkflow.js";
+import { SettingsFileStore } from "../core/session/settingsFileStore.js";
 import { randomUUID } from "node:crypto";
 import { SqliteActivityStore } from "../core/activity/sqliteActivityStore.js";
 import { validateSupportedAdapterLifecycle } from "../adapters/adapterLifecycleValidators.js";
@@ -33,6 +35,7 @@ export async function createRuntimeApplication(bootConfig, logger, ownerId = ran
     let activityStore;
     let cards;
     let workflow;
+    let settings;
     let chart;
     try {
         const store = new SqliteActivityStore({
@@ -68,10 +71,10 @@ export async function createRuntimeApplication(bootConfig, logger, ownerId = ran
             bootSuiGrpcUrl: config.suiGrpcUrl,
             bootSuiGraphqlUrl: config.suiGraphqlUrl
         });
-        const workflowRecords = store.createWalletWorkflowStore(ownerId);
+        const workflowRecords = store.createWalletWorkflowStore(ownerId, () => new Date(), () => walletRuntime?.snapshot());
         const localData = store.createLocalDataService({
             advanceRequestDeadlines: (now) => workflowRecords.advanceRequestDeadlines(now),
-            onDataReplaced: () => { access.dataReplaced(); workflow?.dataReplaced(); chart?.clearCache(); },
+            onDataReplaced: () => { access.dataReplaced(); workflow?.dataReplaced(); settings?.dataReplaced(); chart?.clearCache(); },
             suiGrpcUrl: DEFAULT_SUI_GRPC_URL,
             suiGraphqlUrl: DEFAULT_SUI_GRAPHQL_URL,
             verifySuiGrpcUrl: async (url) => {
@@ -95,8 +98,7 @@ export async function createRuntimeApplication(bootConfig, logger, ownerId = ran
             validateAdapterLifecycle: validateSupportedAdapterLifecycle,
             sessions: store.createSessionRecordStore(),
             artifacts: store.createPrivateReviewArtifactStore(),
-            ownerId,
-            settingsStore: store.createSettingsRecordStore()
+            ownerId
         });
         const readService = createSuiReadService({
             client: suiClient,
@@ -118,9 +120,7 @@ export async function createRuntimeApplication(bootConfig, logger, ownerId = ran
         }, input);
         const reviewComputationDeps = createRuntimeReviewDependencies({ client: suiClient, chainIdentifier,
             expectedChainIdentifier: config.expectedChainIdentifier, materialStore: transactionMaterialStore, readService });
-        const httpHandler = createReviewRequestHandler({ host: config.reviewHost, store: sessions, logger,
-            activityStore: store, localSettings, localData,
-            serverInfo: { name: SERVER_NAME, version: SERVER_VERSION, network: SERVER_NETWORK } });
+        const httpHandler = createReviewRequestHandler({ logger });
         const cardRecords = store.createCardRecordStore();
         let metadata;
         try {
@@ -141,9 +141,26 @@ export async function createRuntimeApplication(bootConfig, logger, ownerId = ran
             },
             submitTransaction: (transaction, signature) => suiClient.core.executeTransaction({ transaction, signatures: [signature] })
         });
+        const settingsRecords = store.createSettingsWorkflowStore(ownerId);
+        settings = new SettingsWorkflow({ records: settingsRecords, files: new SettingsFileStore(dirname(bootConfig.activityDatabasePath)),
+            activity: store, localData, preferences: preferencesRepository, wallet: workflow, assertCurrent: access.assertCurrent, runMaintenance: (work) => access.run(work),
+            resolveEndpoint: (input) => localSettings.resolveEndpointChange(input),
+            verifyEndpoint: (input) => localSettings.prepareEndpointChange(input),
+            interruptRun: (runId) => workflowRecords.invalidateWalletRun("wallet_service_restarted", new Date(), runId),
+            readFacts: async () => settingsRecords.transaction(() => {
+                const context = workflow.currentConnectionContext(), account = store.getActiveAccountSync();
+                const observedAt = context.walletObservation?.observedAt;
+                return { server: { name: SERVER_NAME, version: SERVER_VERSION, network: SERVER_NETWORK },
+                    localSettings: localSettings.getLocalSettingsSync((key) => preferencesRepository.getLocalSettingSync(key)),
+                    ...(account ? { readAddress: account.address } : {}),
+                    assetReadAccount: context.assetReadAccount, walletAvailability: context.walletAvailability,
+                    ...(context.connectionReconciliationRequired ? { connectionReconciliationRequired: true } : {}),
+                    ...(observedAt ? { observedAt } : {}), counts: localData.getDataCountsSync() };
+            }) });
+        settings.recoverOwner();
         await workflow.start();
         chart = createDeepbookUsdcChartService({ assertCurrent: access.assertCurrent });
-        cards = createReadCardStore({ readService, publicChainReceiptReader, chart, records: cardRecords, ownerId, assertCurrent: access.assertCurrent, logger, workflow });
+        cards = createReadCardStore({ readService, publicChainReceiptReader, chart, records: cardRecords, ownerId, assertCurrent: access.assertCurrent, logger, workflow, settings });
         const transactionActivityService = new TransactionActivityService({
             activityStore: store,
             source: new GraphqlSuiTransactionActivitySource({
@@ -157,31 +174,41 @@ export async function createRuntimeApplication(bootConfig, logger, ownerId = ran
             promptSurfaces: ADAPTER_PROMPT_SURFACES,
             sessions,
             activityStore: store,
-            reviewBaseUrl: `http://${config.reviewHost}:${config.reviewPort}`,
             readService,
             transactionActivityService,
             localSettings,
             logger
         }));
         access.ready();
+        void access.run(() => settings.cleanupAfterOwnerChange()).catch(() => {
+            try {
+                logger.error("Temporary settings file cleanup is incomplete", { stage: "settings_file_cleanup" });
+            }
+            catch { }
+        });
         return {
             handleMcp: (request, response) => access.run(() => mcp.handle(request, response)),
             handleHttp: (request, response) => access.run(() => httpHandler(request, response)),
             async close() {
                 workflow?.stop();
-                access.close();
                 cards?.stop();
                 chart?.clearCache();
                 try {
-                    await walletRuntime.close();
+                    await settings.close();
                 }
                 finally {
+                    access.close();
                     try {
-                        await mcp.close();
+                        await walletRuntime.close();
                     }
                     finally {
-                        store.close();
-                        ownership.close();
+                        try {
+                            await mcp.close();
+                        }
+                        finally {
+                            store.close();
+                            ownership.close();
+                        }
                     }
                 }
             }

package/dist/runtime/config.js

@@ -17,8 +17,6 @@ export function loadBootConfig(env = process.env) {
         activityDatabasePath: resolveActivityDatabasePath(env)
     };
 }
-// Existing shared-backend port: clients using the same data directory must
-// agree on this port and configuration. It is not browser-wallet authority.
 export const DEFAULT_REVIEW_PORT = 8765;
 function parseReviewPort(value) {
     if (value === undefined || value === "") {

package/dist/runtime/localSettingsService.js

@@ -33,14 +33,23 @@ export class RuntimeLocalSettingsService {
     async getLocalSettings() {
         const stored = await this.options.preferencesRepository.getSuiGrpcUrl();
         const storedGraphql = await this.options.preferencesRepository.getSuiGraphqlUrl();
+        return this.settingsFromStored(stored?.value, storedGraphql?.value);
+    }
+    getLocalSettingsSync(read) {
+        const grpc = read("suiGrpcUrl"), graphql = read("suiGraphqlUrl");
+        if (grpc && typeof grpc.value !== "string" || graphql && typeof graphql.value !== "string")
+            throw new LocalSettingsError("internal_error", "Stored endpoints are invalid.");
+        return this.settingsFromStored(grpc?.value, graphql?.value);
+    }
+    settingsFromStored(stored, storedGraphql) {
         const currentStoredView = resolveSuiGrpcUrlView({
             defaultSuiGrpcUrl: this.defaultSuiGrpcUrl,
-            storedValue: stored?.value,
+            storedValue: stored,
             envValue: this.env.SUI_GRPC_URL
         });
         const currentStoredGraphqlView = resolveSuiGraphqlUrlView({
             defaultSuiGraphqlUrl: this.defaultSuiGraphqlUrl,
-            storedValue: storedGraphql?.value,
+            storedValue: storedGraphql,
             envValue: this.env.SUI_GRAPHQL_URL
         });
         return {
@@ -48,6 +57,18 @@ export class RuntimeLocalSettingsService {
             suiGraphqlUrl: withBootEffectiveEndpoint(currentStoredGraphqlView, this.bootSuiGraphqlUrl)
         };
     }
+    resolveEndpointChange(input) {
+        const value = input.kind === "restore_endpoint"
+            ? input.endpoint === "grpc" ? this.defaultSuiGrpcUrl : this.defaultSuiGraphqlUrl
+            : input.endpoint === "grpc" ? parseEndpointForTool(input.value ?? "") : parseGraphqlEndpointForTool(input.value ?? "");
+        return { key: input.endpoint === "grpc" ? "suiGrpcUrl" : "suiGraphqlUrl", value,
+            status: input.kind === "restore_endpoint" ? "reset" : "saved" };
+    }
+    async prepareEndpointChange(input) {
+        const target = this.resolveEndpointChange(input);
+        await this.verifyEndpointForTool(target.value, input.endpoint);
+        return target;
+    }
     async setSuiGrpcUrl(url) {
         const normalized = parseEndpointForTool(url);
         await this.verifyEndpointForTool(normalized, "grpc");

package/dist/runtime/logger.js

@@ -3,8 +3,6 @@ export function flushStderr() {
         const failed = (error) => { process.stderr.off("error", failed); reject(error); };
         process.stderr.once("error", failed);
         process.stderr.write("", (error) => {
-            // A failed stream write also emits error; keep its handler through that
-            // event instead of allowing EPIPE to replace the intended exit code.
             if (error) {
                 reject(error);
                 return;

package/dist/runtime/reviewServerAcquire.js

@@ -4,8 +4,6 @@ function errorCode(error) {
         ? error.code
         : undefined;
 }
-// Bind the port: returns the server on success, undefined when the port is already
-// in use, and rethrows any other (non-EADDRINUSE) startup error.
 async function tryStart(start, port) {
     try {
         return await start(port);
@@ -17,17 +15,6 @@ async function tryStart(start, port) {
         throw error;
     }
 }
-/**
- * Bind the review server to its fixed port, or defer to a healthy peer already
- * serving it.
- *
- * - Port free → bind and own the single review origin.
- * - Port held by a separate healthy instance of our review server → defer (run no
- *   local server; the peer serves the shared database for every client) and watch for
- *   the owner to exit, then take the origin over. No peer process is signalled.
- * - Port held by anything else (foreign, no identity answer, or our own pid) → clear
- *   error; the origin is never silently reassigned.
- */
 export async function startOrDeferReviewServer(start, port, deps) {
     const owned = await tryStart(start, port);
     if (owned) {
@@ -58,14 +45,12 @@ export async function startOrDeferReviewServer(start, port, deps) {
                 next = await tryStart(start, port);
             }
             catch (error) {
-                // An authenticated prior owner may have closed its port while its SDK
-                // still owns private storage. Reuse the existing takeover observation.
                 if (typeof error === "object" && error !== null && "code" in error && error.code === "DATA_DIRECTORY_OWNED")
                     continue;
                 throw error;
             }
             if (!next) {
-                continue; // a peer still owns the port; keep deferring
+                continue;
             }
             if (stopped) {
                 await next.close();
@@ -82,8 +67,6 @@ export async function startOrDeferReviewServer(start, port, deps) {
     return {
         deferred: true,
         close: async () => {
-            // Stop watching; the loop's stopped-check closes any bind that lands in-flight,
-            // so we never await the (possibly mid-delay) watch loop here.
             stopped = true;
             if (acquired) {
                 await acquired.close();

package/dist/runtime/runtimeTermination.js

@@ -1,5 +1,4 @@
 import { SuiEndpointError } from "../core/suiEndpoint.js";
-// Keep arbitrary SDK/server exception text, endpoint values and stacks private.
 export function runtimeFailureReason(error, stage) {
     if (error instanceof SuiEndpointError)
         return `Sui mainnet endpoint verification failed (${error.kind}). Check the configured endpoint.`;
@@ -16,8 +15,6 @@ export function runtimeFailureReason(error, stage) {
         return "The private runtime control identity could not be loaded. Check data directory ownership and permissions.";
     return "The local runtime could not complete this stage. Check local data permissions and runtime configuration.";
 }
-// Bootstrap alone decides exit intent. Cleanup-induced onclose notifications
-// join the same promise; they cannot replace a fatal or signal exit with EOF.
 export class RuntimeTermination {
     options;
     closing;
@@ -34,7 +31,7 @@ export class RuntimeTermination {
                 try {
                     this.options.logger.error(message, { stage, reason: runtimeFailureReason(error, stage) });
                 }
-                catch { /* Preserve failure intent even if stderr is unavailable. */ }
+                catch { }
             };
             if (cause.kind === "failure")
                 report("fatal runtime error", cause.stage, cause.error);

package/dist/runtime/shared/authenticatedFetch.js

@@ -2,10 +2,8 @@ import { Agent, request as httpRequest } from "node:http";
 import { connect } from "node:net";
 import { randomBytes } from "node:crypto";
 import { Readable } from "node:stream";
-import { MAX_JSON_BODY_BYTES } from "../../review-server/http.js";
+import { MAX_JSON_BODY_BYTES } from "./http.js";
 import { IDENTITY_CHALLENGE_HEADER, IDENTITY_PATH, IDENTITY_TIMEOUT_MS, INTERNAL_MCP_PATH, SERVER_INSTANCE_HEADER, verifyServerIdentity } from "./control.js";
-// Proof and authenticated request use the same TCP socket. A closed socket is never
-// transparently replaced: no credential or UI permission can reach a new listener.
 async function authenticatedChannel(port, control, signal) {
     signal?.throwIfAborted();
     const socket = connect({ host: "127.0.0.1", port });
@@ -86,7 +84,7 @@ export function createAuthenticatedFetch(port, control, expectedInstanceId) {
         headers.set("host", url.host);
         headers.set("authorization", `Bearer ${control.key}`);
         headers.set(SERVER_INSTANCE_HEADER, channel.identity.instanceId);
-        headers.set("connection", "close");
+        headers.set("connection", "keep-alive");
         const body = init?.body;
         if (body !== undefined && body !== null && typeof body !== "string") {
             channel.close();

package/dist/runtime/shared/control.js

@@ -2,20 +2,17 @@ import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from
 import { link, lstat, mkdir, readFile, realpath, unlink, writeFile } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
 import { z } from "zod";
-// Version 7 uses the Sui MCP resource, metadata and response-field identities.
-// Clients must not attach to an owner that serves the previous package contract.
-export const INTERNAL_API_VERSION = 7;
+import { SERVER_VERSION } from "../../mcp/serverInfo.js";
 export const IDENTITY_PATH = "/__runtime/identity";
 export const INTERNAL_MCP_PATH = "/__runtime/mcp";
 export const IDENTITY_CHALLENGE_HEADER = "x-sui-mcp-identity-challenge";
 export const SERVER_INSTANCE_HEADER = "x-sui-mcp-server-instance";
-// The existing review-server identity probe allows one second for a local response.
 export const IDENTITY_TIMEOUT_MS = 1000;
 const secretSchema = z.string().regex(/^[A-Za-z0-9_-]{43}$/);
 export const serverIdentitySchema = z.object({
     service: z.literal("sui-mcp"),
     role: z.literal("shared-server"),
-    apiVersion: z.literal(INTERNAL_API_VERSION),
+    packageVersion: z.literal(SERVER_VERSION),
     databaseId: z.string().regex(/^[0-9a-f]{64}$/),
     configurationId: z.string().regex(/^[0-9a-f]{64}$/),
     instanceId: z.string().uuid(),
@@ -53,12 +50,12 @@ export async function loadControlIdentity(databasePath, configuration) {
     };
 }
 function identityPayload(identity) {
-    return JSON.stringify([identity.service, identity.role, identity.apiVersion, identity.databaseId,
+    return JSON.stringify([identity.service, identity.role, identity.packageVersion, identity.databaseId,
         identity.configurationId, identity.instanceId, identity.pid, identity.challenge]);
 }
 export function createServerIdentity(control, instanceId, challenge) {
     secretSchema.parse(challenge);
-    const identity = { service: "sui-mcp", role: "shared-server", apiVersion: INTERNAL_API_VERSION,
+    const identity = { service: "sui-mcp", role: "shared-server", packageVersion: SERVER_VERSION,
         databaseId: control.databaseId, configurationId: control.configurationId,
         instanceId, pid: process.pid, challenge };
     return { ...identity, proof: createHmac("sha256", control.key).update(identityPayload(identity)).digest("base64url") };

package/dist/runtime/shared/dataAccess.js

@@ -1,6 +1,4 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-// An asynchronous read may finish after import/reset. Its original generation
-// remains attached to the continuation and cannot read or write the replacement DB.
 export class RuntimeDataAccess {
     context = new AsyncLocalStorage();
     generation = 0;

package/dist/runtime/shared/http.js

@@ -0,0 +1,14 @@
+export { MAX_JSON_BODY_BYTES } from "../../core/session/settingsFileProtocol.js";
+export class HttpError extends Error {
+    status;
+    code;
+    constructor(status, code) {
+        super(code);
+        this.status = status;
+        this.code = code;
+    }
+}
+export function sendJson(response, status, body) {
+    response.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+    response.end(JSON.stringify(body));
+}

package/dist/runtime/shared/mcpHttp.js

@@ -2,14 +2,13 @@ import { CARD_TOOLS } from "../../mcp-ui/contracts.js";
 import { randomUUID } from "node:crypto";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isJSONRPCRequest } from "@modelcontextprotocol/sdk/types.js";
-import { MAX_JSON_BODY_BYTES, sendJson } from "../../review-server/http.js";
+import { MAX_JSON_BODY_BYTES, sendJson } from "./http.js";
+import { settingsUploadMessageBudget } from "../../core/session/settingsFileProtocol.js";
 export function createInternalMcpHandler(createServer) {
     const sessions = new Map();
     const connections = new Set();
     return {
         async handle(request, response) {
-            // This product has no unsolicited server requests. POST returns JSON, and
-            // clients do not create a reconnecting SSE channel or replay requests.
             if (request.method === "GET") {
                 response.setHeader("Allow", "POST, DELETE");
                 sendJson(response, 405, { error: "method_not_allowed" });
@@ -48,12 +47,13 @@ export function createInternalMcpHandler(createServer) {
                     close: () => transport.close()
                 };
                 transport.onmessage = (message, extra) => {
-                    // Preserve ordinary stdio MCP input contracts. The existing HTTP/UI
-                    // body limit applies to card calls, including their JSON-RPC envelope.
                     if (isJSONRPCRequest(message) && message.method === "tools/call" &&
                         Object.values(CARD_TOOLS).some((name) => name === message.params?.name) &&
                         Buffer.byteLength(JSON.stringify(message)) > MAX_JSON_BODY_BYTES) {
-                        void transport.send({ jsonrpc: "2.0", id: message.id, error: { code: -32600, message: "Card request exceeds the JSON body limit." } });
+                        const budget = settingsUploadMessageBudget(message);
+                        void transport.send({ jsonrpc: "2.0", id: message.id, error: { code: -32600,
+                                message: budget === undefined ? "Card request exceeds the JSON body limit." : "settings_payload_too_large",
+                                ...(budget === undefined ? {} : { data: { code: "settings_payload_too_large", maximumMessageSize: MAX_JSON_BODY_BYTES, rawChunkLimit: budget } }) } });
                         return;
                     }
                     connection.onmessage?.(message, extra);

package/dist/runtime/shared/ownerLease.js

@@ -4,8 +4,6 @@ import { dirname, join } from "node:path";
 export class DataDirectoryOwnedError extends Error {
     code = "DATA_DIRECTORY_OWNED";
 }
-/** An OS-released ownership lock, separate from the product database. No
- * business transaction is held while waiting for a wallet or network reply. */
 export function acquireDataDirectoryOwner(databasePath) {
     const directory = dirname(databasePath);
     mkdirSync(directory, { recursive: true, mode: 0o700 });
@@ -31,8 +29,6 @@ export function acquireDataDirectoryOwner(databasePath) {
         process.umask(mask);
     }
     try {
-        // A second owner is refused immediately, including one using another port.
-        // SQLite retains the EXCLUSIVE lock after commit until this handle closes.
         lock.pragma("locking_mode=EXCLUSIVE");
         lock.exec("BEGIN EXCLUSIVE");
         lock.exec("CREATE TABLE IF NOT EXISTS owner_lock (singleton INTEGER PRIMARY KEY CHECK (singleton=1))");

package/dist/runtime/shared/server.js

@@ -1,6 +1,6 @@
 import { createServer } from "node:http";
 import { randomUUID } from "node:crypto";
-import { HttpError, sendJson } from "../../review-server/http.js";
+import { HttpError, sendJson } from "./http.js";
 import { createServerIdentity, IDENTITY_CHALLENGE_HEADER, IDENTITY_PATH, INTERNAL_MCP_PATH, singleHeader, validControlAuthorization, validInternalRequest } from "./control.js";
 export async function startSharedServer(input) {
     const instanceId = randomUUID();
@@ -64,7 +64,6 @@ export async function startSharedServer(input) {
         server.listen(port, "127.0.0.1");
     });
     port = server.address().port;
-    // Only the process that owns the port opens SQLite or initializes services.
     application = Promise.resolve().then(() => input.createApplication(instanceId));
     const closeListener = async () => {
         if (!server.listening)

package/dist/runtime/shared/stdio.js

@@ -5,9 +5,6 @@ import { CallToolRequestSchema, CallToolResultSchema, CompleteRequestSchema, Get
 import { SERVER_INSTRUCTIONS, SERVER_NAME, SERVER_VERSION } from "../../mcp/serverInfo.js";
 import { createAuthenticatedFetch, probeAuthenticatedServer } from "./authenticatedFetch.js";
 import { INTERNAL_MCP_PATH } from "./control.js";
-// The SDK owns request IDs, initialization, cancellation and response parsing.
-// This proxy has no domain services or writable stores. A new request may open a
-// new MCP session after ownership changes; an already dispatched call is never replayed.
 export async function startSharedStdio(input) {
     const server = new Server({ name: SERVER_NAME, version: SERVER_VERSION }, {
         capabilities: { tools: {}, resources: {}, prompts: {}, completions: {} }, instructions: SERVER_INSTRUCTIONS
@@ -56,7 +53,7 @@ export async function startSharedStdio(input) {
                 close: async () => { try {
                     await http.terminateSession();
                 }
-                catch { /* The prior owner may already be gone. */ } await http.close(); }
+                catch { } await http.close(); }
             };
             http.onmessage = (message) => { if (http.sessionId !== undefined)
                 transport.sessionId = http.sessionId; transport.onmessage?.(message); };
@@ -105,7 +102,7 @@ export async function startSharedStdio(input) {
             try {
                 await connecting;
             }
-            catch { /* Initialization was cancelled with the stdio connection. */ }
+            catch { }
             await connection?.client.close();
             connection = undefined;
         }

package/dist/runtime/smokeMainnetRead.js

@@ -122,12 +122,9 @@ async function main() {
             validateAdapterLifecycle: validateSupportedAdapterLifecycle,
             sessions: activityStore.createSessionRecordStore(),
             artifacts: activityStore.createPrivateReviewArtifactStore(),
-            settingsStore: activityStore.createSettingsRecordStore()
         });
         const reviewDependencies = createRuntimeReviewDependencies({ client: suiClient, chainIdentifier,
             expectedChainIdentifier: config.expectedChainIdentifier, materialStore: transactionMaterialStore, readService });
-        // Utility-only read context in this script's temporary DB. This does not
-        // create a live wallet session or prove address ownership.
         await activityStore.setActiveAccount(smokeAddress, "wallet_connection", new Date(), { name: "Explicit smoke read fixture" });
         server = createMcpServer({
             sessions,