@stelis/say-ur-intent 0.0.0 → 0.0.2

package/dist/core/activity/localDataService.js

@@ -0,0 +1,258 @@
+import { SuiEndpointError, parseGraphqlUrl, parseGrpcUrl } from "../suiEndpoint.js";
+import { LOCAL_DATA_EXPORT_FORMAT, LOCAL_DATA_NETWORK, LocalDataError } from "./localDataTypes.js";
+import { activeAccountChange, countsForPayload, defaultsInjectedForImport, invalidBackup, maxNumber, parseLocalDataEnvelope, suiGraphqlUrlFromPayload, suiGrpcUrlFromPayload } from "./localDataValidation.js";
+export * from "./localDataTypes.js";
+export class SqliteLocalDataService {
+    db;
+    options;
+    validateAdapterLifecycle;
+    constructor(db, options, validateAdapterLifecycle) {
+        this.db = db;
+        this.options = options;
+        this.validateAdapterLifecycle = validateAdapterLifecycle;
+    }
+    async getDataCounts() {
+        return this.getDataCountsSync();
+    }
+    async exportLocalData(now = new Date()) {
+        return this.db.transaction(() => {
+            const envelope = {
+                format: LOCAL_DATA_EXPORT_FORMAT,
+                network: LOCAL_DATA_NETWORK,
+                exportedAt: now.toISOString(),
+                data: {
+                    accounts: this.selectAll("accounts"),
+                    activeAccountContext: this.selectAll("active_account_context"),
+                    reviewSessions: this.selectAll("review_sessions"),
+                    reviewStateSnapshots: this.selectAll("review_state_snapshots"),
+                    reviewStatusTransitions: this.selectAll("review_status_transitions"),
+                    reviewExecutions: this.selectAll("review_executions"),
+                    externalActivityScans: this.selectAll("external_activity_scans"),
+                    externalActivityTransactions: this.selectAll("external_activity_transactions"),
+                    localSettings: this.selectAll("local_settings")
+                }
+            };
+            return parseLocalDataEnvelope(envelope, {
+                defaultSuiGraphqlUrl: this.options.suiGraphqlUrl,
+                validateAdapterLifecycle: this.validateAdapterLifecycle
+            });
+        })();
+    }
+    async previewImportLocalData(input) {
+        const defaultsInjected = defaultsInjectedForImport(input);
+        const envelope = parseLocalDataEnvelope(input, {
+            defaultSuiGraphqlUrl: this.options.suiGraphqlUrl,
+            validateAdapterLifecycle: this.validateAdapterLifecycle
+        });
+        return {
+            status: "valid",
+            format: envelope.format,
+            network: envelope.network,
+            exportedAt: envelope.exportedAt,
+            currentCounts: this.getDataCountsSync(),
+            incomingCounts: countsForPayload(envelope.data),
+            willReplace: true,
+            activeAccountChange: activeAccountChange(this.selectAll("accounts"), this.selectAll("active_account_context"), envelope.data.accounts, envelope.data.activeAccountContext),
+            restartRequiredAfterImport: true,
+            defaultsInjected
+        };
+    }
+    async importLocalDataReplace(input, _now = new Date()) {
+        const envelope = await this.parseAndVerifyImportEnvelope(input);
+        this.db.transaction(() => {
+            this.resetLocalDataTables();
+            this.insertAccounts(envelope.data.accounts);
+            this.insertActiveAccountContext(envelope.data.activeAccountContext);
+            this.insertReviewSessions(envelope.data.reviewSessions);
+            this.insertReviewStateSnapshots(envelope.data.reviewStateSnapshots);
+            this.insertReviewStatusTransitions(envelope.data.reviewStatusTransitions);
+            this.insertReviewExecutions(envelope.data.reviewExecutions);
+            this.insertExternalActivityScans(envelope.data.externalActivityScans);
+            this.insertExternalActivityTransactions(envelope.data.externalActivityTransactions);
+            this.insertLocalSettings(envelope.data.localSettings);
+            this.syncSqliteSequences(envelope.data);
+        })();
+        return {
+            status: "imported",
+            dataCounts: this.getDataCountsSync(),
+            sessionsInvalidated: true
+        };
+    }
+    async resetLocalData(now = new Date()) {
+        this.db.transaction(() => {
+            this.resetLocalDataTables();
+            this.insertDefaultSuiGrpcUrl(now);
+        })();
+        return {
+            status: "reset",
+            dataCounts: this.getDataCountsSync(),
+            sessionsInvalidated: true
+        };
+    }
+    resetLocalDataTables() {
+        for (const table of [
+            "external_activity_transactions",
+            "external_activity_scans",
+            "review_state_snapshots",
+            "review_status_transitions",
+            "review_executions",
+            "review_sessions",
+            "coin_metadata_cache",
+            "active_account_context",
+            "accounts",
+            "local_settings"
+        ]) {
+            this.db.prepare(`DELETE FROM ${table}`).run();
+        }
+        this.db.prepare("DELETE FROM sqlite_sequence WHERE name IN ('accounts', 'review_state_snapshots', 'review_status_transitions')").run();
+    }
+    insertDefaultSuiGrpcUrl(now) {
+        const statement = this.db.prepare(`INSERT INTO local_settings (key, value_json, updated_at)
+       VALUES (?, ?, ?)`);
+        statement.run("suiGrpcUrl", JSON.stringify(parseGrpcUrl(this.options.suiGrpcUrl)), now.toISOString());
+        statement.run("suiGraphqlUrl", JSON.stringify(parseGraphqlUrl(this.options.suiGraphqlUrl)), now.toISOString());
+    }
+    getDataCountsSync() {
+        return {
+            accounts: this.count("accounts"),
+            reviewSessions: this.count("review_sessions"),
+            reviewStateSnapshots: this.count("review_state_snapshots"),
+            reviewStatusTransitions: this.count("review_status_transitions"),
+            reviewExecutions: this.count("review_executions"),
+            externalActivityScans: this.count("external_activity_scans"),
+            externalActivityTransactions: this.count("external_activity_transactions"),
+            localSettings: this.count("local_settings")
+        };
+    }
+    count(table) {
+        return this.db.prepare(`SELECT COUNT(*) AS count FROM ${table}`).get().count;
+    }
+    selectAll(table) {
+        return this.db.prepare(`SELECT * FROM ${table} ORDER BY rowid ASC`).all();
+    }
+    insertAccounts(rows) {
+        const statement = this.db.prepare(`INSERT INTO accounts (id, sui_address, first_seen_at, last_used_at, first_source, last_source)
+       VALUES (?, ?, ?, ?, ?, ?)`);
+        for (const row of rows) {
+            statement.run(row.id, row.sui_address, row.first_seen_at, row.last_used_at, row.first_source, row.last_source);
+        }
+    }
+    insertActiveAccountContext(rows) {
+        const statement = this.db.prepare(`INSERT INTO active_account_context (id, account_id, source, set_at, wallet_name, wallet_id)
+       VALUES (?, ?, ?, ?, ?, ?)`);
+        for (const row of rows) {
+            statement.run(row.id, row.account_id, row.source, row.set_at, row.wallet_name ?? null, row.wallet_id ?? null);
+        }
+    }
+    insertReviewSessions(rows) {
+        const statement = this.db.prepare(`INSERT INTO review_sessions
+        (id, plan_id, action_kind, adapter_id, protocol, account_id, current_status, plan_json, intent_json, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        for (const row of rows) {
+            statement.run(row.id, row.plan_id, row.action_kind, row.adapter_id, row.protocol, row.account_id, row.current_status, row.plan_json, row.intent_json, row.created_at, row.updated_at);
+        }
+    }
+    insertReviewStateSnapshots(rows) {
+        const statement = this.db.prepare(`INSERT INTO review_state_snapshots
+        (id, review_session_id, plan_id, account_id, status, blocked_reason, refresh_reason, state_json, updated_at, recorded_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        for (const row of rows) {
+            statement.run(row.id, row.review_session_id, row.plan_id, row.account_id, row.status, row.blocked_reason, row.refresh_reason, row.state_json, row.updated_at, row.recorded_at);
+        }
+    }
+    insertReviewStatusTransitions(rows) {
+        const statement = this.db.prepare(`INSERT INTO review_status_transitions
+        (id, review_session_id, event, from_status, to_status, account_id, reason, transitioned_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
+        for (const row of rows) {
+            statement.run(row.id, row.review_session_id, row.event, row.from_status, row.to_status, row.account_id, row.reason, row.transitioned_at);
+        }
+    }
+    insertReviewExecutions(rows) {
+        const statement = this.db.prepare(`INSERT INTO review_executions
+        (review_session_id, plan_id, account_id, status, tx_digest, explorer_url, failure_reason, result_json, recorded_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        for (const row of rows) {
+            statement.run(row.review_session_id, row.plan_id, row.account_id, row.status, row.tx_digest, row.explorer_url, row.failure_reason, row.result_json, row.recorded_at, row.updated_at);
+        }
+    }
+    insertExternalActivityScans(rows) {
+        const statement = this.db.prepare(`INSERT INTO external_activity_scans
+        (scan_id, kind, account_id, relationship, input_digest, from_checkpoint, to_checkpoint,
+         from_timestamp, to_timestamp, limit_count, request_cursor, response_cursor, endpoint_host,
+         chain_identifier, fetched_at, stored_count, skipped_count, has_more, window_complete,
+         incomplete_reason)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        for (const row of rows) {
+            statement.run(row.scan_id, row.kind, row.account_id, row.relationship, row.input_digest, row.from_checkpoint, row.to_checkpoint, row.from_timestamp, row.to_timestamp, row.limit_count, row.request_cursor, row.response_cursor, row.endpoint_host, row.chain_identifier, row.fetched_at, row.stored_count, row.skipped_count, row.has_more, row.window_complete, row.incomplete_reason);
+        }
+    }
+    insertExternalActivityTransactions(rows) {
+        const statement = this.db.prepare(`INSERT INTO external_activity_transactions
+        (account_id, digest, relationship, checkpoint, timestamp, status, known_sender_account_id,
+         first_scan_id, last_scan_id, first_fetched_at, last_fetched_at, detail_json)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        for (const row of rows) {
+            statement.run(row.account_id, row.digest, row.relationship, row.checkpoint, row.timestamp, row.status, row.known_sender_account_id, row.first_scan_id, row.last_scan_id, row.first_fetched_at, row.last_fetched_at, row.detail_json);
+        }
+    }
+    insertLocalSettings(rows) {
+        const statement = this.db.prepare(`INSERT INTO local_settings (key, value_json, updated_at)
+       VALUES (?, ?, ?)`);
+        for (const row of rows) {
+            statement.run(row.key, row.value_json, row.updated_at);
+        }
+    }
+    syncSqliteSequences(data) {
+        const sequenceRows = [
+            ["accounts", maxNumber(data.accounts.map((row) => row.id))],
+            ["review_state_snapshots", maxNumber(data.reviewStateSnapshots.map((row) => row.id))],
+            ["review_status_transitions", maxNumber(data.reviewStatusTransitions.map((row) => row.id))]
+        ];
+        const update = this.db.prepare("UPDATE sqlite_sequence SET seq = ? WHERE name = ?");
+        const insert = this.db.prepare("INSERT INTO sqlite_sequence (name, seq) VALUES (?, ?)");
+        for (const [name, seq] of sequenceRows) {
+            if (seq > 0) {
+                const result = update.run(seq, name);
+                if (result.changes === 0) {
+                    insert.run(name, seq);
+                }
+            }
+        }
+    }
+    async parseAndVerifyImportEnvelope(input) {
+        const envelope = parseLocalDataEnvelope(input, {
+            defaultSuiGraphqlUrl: this.options.suiGraphqlUrl,
+            validateAdapterLifecycle: this.validateAdapterLifecycle
+        });
+        await this.verifyImportedSuiGrpcUrl(suiGrpcUrlFromPayload(envelope.data));
+        await this.verifyImportedSuiGraphqlUrl(suiGraphqlUrlFromPayload(envelope.data));
+        return envelope;
+    }
+    async verifyImportedSuiGrpcUrl(url) {
+        try {
+            await this.options.verifySuiGrpcUrl(url);
+        }
+        catch (error) {
+            if (error instanceof SuiEndpointError) {
+                throw invalidBackup("invalid_sui_grpc_url_endpoint", { endpointReason: error.kind });
+            }
+            throw new LocalDataError("internal_error", "Could not verify imported Sui gRPC endpoint", {
+                message: "Could not verify imported Sui gRPC endpoint"
+            });
+        }
+    }
+    async verifyImportedSuiGraphqlUrl(url) {
+        try {
+            await this.options.verifySuiGraphqlUrl(url);
+        }
+        catch (error) {
+            if (error instanceof SuiEndpointError) {
+                throw invalidBackup("invalid_sui_graphql_url_endpoint", { endpointReason: error.kind });
+            }
+            throw new LocalDataError("internal_error", "Could not verify imported Sui GraphQL endpoint", {
+                message: "Could not verify imported Sui GraphQL endpoint"
+            });
+        }
+    }
+}

package/dist/core/activity/localDataTypes.js

@@ -0,0 +1,11 @@
+export const LOCAL_DATA_EXPORT_FORMAT = "say-ur-intent.local-data";
+export const LOCAL_DATA_NETWORK = "mainnet";
+export class LocalDataError extends Error {
+    kind;
+    details;
+    constructor(kind, message, details = {}) {
+        super(message);
+        this.kind = kind;
+        this.details = details;
+    }
+}

package/dist/core/activity/localDataValidation.js

@@ -0,0 +1,396 @@
+import { z } from "zod";
+import { assertNoForbiddenMcpFields } from "../action/forbiddenFields.js";
+import { parseLifecycleValidatedReviewState } from "../action/reviewStateValidation.js";
+import { actionPlanSchema, executionResultSchema, internalSessionStatusSchema } from "../action/schemas.js";
+import { parseSuiAddress } from "../suiAddress.js";
+import { parseGraphqlUrl, parseGrpcUrl } from "../suiEndpoint.js";
+import { EXTERNAL_ACTIVITY_TRANSACTION_DETAIL_JSON_MAX_BYTES, externalActivityTransactionDetailJsonByteLength, externalActivityTransactionDetailSchema, externalActivityTransactionDetailsReferenceOnlyAccount } from "./transactionActivityDetails.js";
+import { LOCAL_DATA_EXPORT_FORMAT, LOCAL_DATA_NETWORK, LocalDataError } from "./localDataTypes.js";
+const isoTimestamp = z.string().refine((value) => {
+    const parsed = new Date(value);
+    return !Number.isNaN(parsed.getTime()) && parsed.toISOString() === value;
+}, "must be an ISO 8601 UTC timestamp");
+const nullableString = z.string().nullable();
+const accountRowSchema = z.object({
+    id: z.number().int().positive(),
+    sui_address: z.string().refine((value) => parseSuiAddress(value) === value, "must be a normalized Sui address"),
+    first_seen_at: isoTimestamp,
+    last_used_at: isoTimestamp,
+    first_source: z.enum(["wallet_identity", "review_execution"]),
+    last_source: z.enum(["wallet_identity", "review_execution"])
+}).strict();
+const activeAccountContextRowSchema = z.object({
+    id: z.literal(1),
+    account_id: z.number().int().positive().nullable(),
+    source: z.enum(["wallet_identity", "cleared"]),
+    set_at: isoTimestamp,
+    wallet_name: z.string().min(1).max(200).nullish(),
+    wallet_id: z.string().min(1).max(200).nullish()
+}).strict();
+const reviewSessionRowSchema = z.object({
+    id: z.string().min(1),
+    plan_id: z.string().min(1),
+    action_kind: z.string().min(1),
+    adapter_id: z.string().min(1),
+    protocol: z.string().min(1),
+    account_id: z.number().int().positive().nullable(),
+    current_status: internalSessionStatusSchema,
+    plan_json: z.string(),
+    intent_json: z.string().nullable(),
+    created_at: isoTimestamp,
+    updated_at: isoTimestamp
+}).strict();
+const reviewStateSnapshotRowSchema = z.object({
+    id: z.number().int().positive(),
+    review_session_id: z.string().min(1),
+    plan_id: z.string().min(1),
+    account_id: z.number().int().positive(),
+    status: z.enum(["ready_for_wallet_review", "refresh_required", "blocked"]),
+    blocked_reason: nullableString,
+    refresh_reason: nullableString,
+    state_json: z.string(),
+    updated_at: isoTimestamp,
+    recorded_at: isoTimestamp
+}).strict();
+const reviewStatusTransitionRowSchema = z.object({
+    id: z.number().int().positive(),
+    review_session_id: z.string().min(1),
+    event: z.enum(["created", "opened", "wallet_connected", "state_computed", "result_recorded", "expired"]),
+    from_status: internalSessionStatusSchema.nullable(),
+    to_status: internalSessionStatusSchema,
+    account_id: z.number().int().positive().nullable(),
+    reason: nullableString,
+    transitioned_at: isoTimestamp
+}).strict();
+const reviewExecutionRowSchema = z.object({
+    review_session_id: z.string().min(1),
+    plan_id: z.string().min(1),
+    account_id: z.number().int().positive(),
+    status: z.enum(["signed_pending_result", "success", "failure"]),
+    tx_digest: nullableString,
+    explorer_url: nullableString,
+    failure_reason: nullableString,
+    result_json: z.string(),
+    recorded_at: isoTimestamp,
+    updated_at: isoTimestamp
+}).strict();
+const externalActivityScanRowSchema = z.object({
+    scan_id: z.string().min(1),
+    kind: z.enum(["digest_lookup", "account_scan", "function_scan"]),
+    account_id: z.number().int().positive(),
+    relationship: z.enum(["affected", "sent"]),
+    input_digest: nullableString,
+    from_checkpoint: nullableString,
+    to_checkpoint: nullableString,
+    from_timestamp: isoTimestamp.nullable(),
+    to_timestamp: isoTimestamp.nullable(),
+    limit_count: z.number().int().min(1).max(100),
+    request_cursor: nullableString,
+    response_cursor: nullableString,
+    endpoint_host: z.string().min(1),
+    chain_identifier: z.string().min(1),
+    fetched_at: isoTimestamp,
+    stored_count: z.number().int().nonnegative(),
+    skipped_count: z.number().int().nonnegative(),
+    has_more: z.union([z.literal(0), z.literal(1)]),
+    window_complete: z.union([z.literal(0), z.literal(1)]).nullable(),
+    incomplete_reason: z.enum(["limit_reached", "ordering_unverified", "cursor_invalid", "provider_error"]).nullable()
+}).strict();
+const externalActivityTransactionRowSchema = z.object({
+    account_id: z.number().int().positive(),
+    digest: z.string().min(1),
+    relationship: z.enum(["affected", "sent"]),
+    checkpoint: nullableString,
+    timestamp: isoTimestamp.nullable(),
+    status: z.enum(["success", "failure", "unknown"]),
+    known_sender_account_id: z.number().int().positive().nullable(),
+    first_scan_id: z.string().min(1),
+    last_scan_id: z.string().min(1),
+    first_fetched_at: isoTimestamp,
+    last_fetched_at: isoTimestamp,
+    detail_json: z.string().nullable().default(null)
+}).strict();
+const localSettingRowSchema = z.object({
+    key: z.enum(["suiGrpcUrl", "suiGraphqlUrl"]),
+    value_json: z.string(),
+    updated_at: isoTimestamp
+}).strict();
+const payloadSchema = z.object({
+    accounts: z.array(accountRowSchema),
+    activeAccountContext: z.array(activeAccountContextRowSchema).max(1),
+    reviewSessions: z.array(reviewSessionRowSchema),
+    reviewStateSnapshots: z.array(reviewStateSnapshotRowSchema),
+    reviewStatusTransitions: z.array(reviewStatusTransitionRowSchema),
+    reviewExecutions: z.array(reviewExecutionRowSchema),
+    externalActivityScans: z.array(externalActivityScanRowSchema).default([]),
+    externalActivityTransactions: z.array(externalActivityTransactionRowSchema).default([]),
+    localSettings: z.array(localSettingRowSchema).min(1).max(2)
+}).strict();
+const envelopeSchema = z.object({
+    format: z.literal(LOCAL_DATA_EXPORT_FORMAT),
+    network: z.literal(LOCAL_DATA_NETWORK),
+    exportedAt: isoTimestamp,
+    data: payloadSchema
+}).strict();
+export function parseLocalDataEnvelope(input, options) {
+    const parsed = envelopeSchema.safeParse(input);
+    if (!parsed.success) {
+        throw new LocalDataError("input_invalid", "Invalid local data backup", {
+            reason: "invalid_backup_shape"
+        });
+    }
+    const normalized = withDefaultSuiGraphqlSetting(parsed.data, options.defaultSuiGraphqlUrl);
+    validatePayloadSemantics(normalized.data, options.validateAdapterLifecycle);
+    return normalized;
+}
+export function defaultsInjectedForImport(input) {
+    const parsed = envelopeSchema.safeParse(input);
+    if (!parsed.success) {
+        return [];
+    }
+    return parsed.data.data.localSettings.some((row) => row.key === "suiGraphqlUrl") ? [] : ["suiGraphqlUrl"];
+}
+function validatePayloadSemantics(data, validateAdapterLifecycle) {
+    ensureUnique(data.accounts.map((row) => row.id), "duplicate_account_id");
+    ensureUnique(data.accounts.map((row) => row.sui_address), "duplicate_account_address");
+    ensureUnique(data.reviewSessions.map((row) => row.id), "duplicate_review_session_id");
+    ensureUnique(data.reviewStateSnapshots.map((row) => row.id), "duplicate_review_state_snapshot_id");
+    ensureUnique(data.reviewStatusTransitions.map((row) => row.id), "duplicate_review_transition_id");
+    ensureUnique(data.reviewExecutions.map((row) => row.review_session_id), "duplicate_review_execution_id");
+    ensureUnique(data.externalActivityScans.map((row) => row.scan_id), "duplicate_external_activity_scan_id");
+    ensureUnique(data.externalActivityTransactions.map((row) => `${row.account_id}:${row.digest}:${row.relationship}`), "duplicate_external_activity_transaction");
+    ensureUnique(data.localSettings.map((row) => row.key), "duplicate_local_setting_key");
+    const accountIds = new Set(data.accounts.map((row) => row.id));
+    const accountAddressesById = new Map(data.accounts.map((row) => [row.id, row.sui_address]));
+    for (const row of data.activeAccountContext) {
+        if (row.source === "cleared" && row.account_id !== null) {
+            throw invalidBackup("invalid_active_account_context");
+        }
+        if (row.source === "wallet_identity" && (row.account_id === null || !accountIds.has(row.account_id))) {
+            throw invalidBackup("invalid_active_account_context");
+        }
+    }
+    for (const row of data.reviewSessions) {
+        validateJsonColumn(row.plan_json, "plan_json", actionPlanSchema);
+        validateOptionalJsonColumn(row.intent_json, "intent_json");
+        if (row.account_id !== null && !accountIds.has(row.account_id)) {
+            throw invalidBackup("invalid_review_session_account");
+        }
+    }
+    const reviewSessionIds = new Set(data.reviewSessions.map((row) => row.id));
+    for (const row of data.reviewStateSnapshots) {
+        if (!reviewSessionIds.has(row.review_session_id) || !accountIds.has(row.account_id)) {
+            throw invalidBackup("invalid_review_state_snapshot_reference");
+        }
+        if (row.status === "blocked" && (row.blocked_reason === null || row.refresh_reason !== null)) {
+            throw invalidBackup("invalid_review_state_snapshot_status");
+        }
+        if (row.status === "refresh_required" && (row.refresh_reason === null || row.blocked_reason !== null)) {
+            throw invalidBackup("invalid_review_state_snapshot_status");
+        }
+        if (row.status === "ready_for_wallet_review" && (row.blocked_reason !== null || row.refresh_reason !== null)) {
+            throw invalidBackup("invalid_review_state_snapshot_status");
+        }
+        validateReviewStateJsonColumn(row.state_json, "state_json", validateAdapterLifecycle);
+    }
+    for (const row of data.reviewStatusTransitions) {
+        if (!reviewSessionIds.has(row.review_session_id) || (row.account_id !== null && !accountIds.has(row.account_id))) {
+            throw invalidBackup("invalid_review_transition_reference");
+        }
+    }
+    for (const row of data.reviewExecutions) {
+        if (!reviewSessionIds.has(row.review_session_id) || !accountIds.has(row.account_id)) {
+            throw invalidBackup("invalid_review_execution_reference");
+        }
+        if (row.status === "failure" && row.failure_reason === null) {
+            throw invalidBackup("invalid_review_execution_status");
+        }
+        if (row.status !== "failure" && row.failure_reason !== null) {
+            throw invalidBackup("invalid_review_execution_status");
+        }
+        validateJsonColumn(row.result_json, "result_json", executionResultSchema);
+    }
+    const scanIds = new Set(data.externalActivityScans.map((row) => row.scan_id));
+    for (const row of data.externalActivityScans) {
+        if (!accountIds.has(row.account_id)) {
+            throw invalidBackup("invalid_external_activity_scan_account");
+        }
+        if (row.from_timestamp !== null && row.to_timestamp !== null && row.from_timestamp > row.to_timestamp) {
+            throw invalidBackup("invalid_external_activity_scan_window");
+        }
+        if (row.window_complete !== null && row.window_complete !== 0 && row.window_complete !== 1) {
+            throw invalidBackup("invalid_external_activity_scan_window_complete");
+        }
+    }
+    for (const row of data.externalActivityTransactions) {
+        if (!accountIds.has(row.account_id) || !scanIds.has(row.first_scan_id) || !scanIds.has(row.last_scan_id)) {
+            throw invalidBackup("invalid_external_activity_transaction_reference");
+        }
+        if (row.known_sender_account_id !== null && !accountIds.has(row.known_sender_account_id)) {
+            throw invalidBackup("invalid_external_activity_sender_reference");
+        }
+        if (row.detail_json !== null) {
+            if (externalActivityTransactionDetailJsonByteLength(row.detail_json) > EXTERNAL_ACTIVITY_TRANSACTION_DETAIL_JSON_MAX_BYTES) {
+                throw invalidBackup("external_activity_detail_too_large", {
+                    maxBytes: EXTERNAL_ACTIVITY_TRANSACTION_DETAIL_JSON_MAX_BYTES
+                });
+            }
+            const detail = validateJsonColumn(row.detail_json, "external_activity_transactions.detail_json");
+            const parsedDetail = externalActivityTransactionDetailSchema.safeParse(detail);
+            if (!parsedDetail.success) {
+                throw invalidBackup("invalid_external_activity_detail_json");
+            }
+            const account = accountAddressesById.get(row.account_id);
+            if (account === undefined || !externalActivityTransactionDetailsReferenceOnlyAccount(parsedDetail.data, account)) {
+                throw invalidBackup("invalid_external_activity_detail_json");
+            }
+        }
+    }
+    const localSettingKeys = new Set(data.localSettings.map((row) => row.key));
+    if (!localSettingKeys.has("suiGrpcUrl")) {
+        throw invalidBackup("missing_sui_grpc_url");
+    }
+    for (const row of data.localSettings) {
+        const value = validateJsonColumn(row.value_json, "local_settings.value_json");
+        if (typeof value !== "string") {
+            throw invalidBackup(row.key === "suiGrpcUrl" ? "invalid_sui_grpc_url" : "invalid_sui_graphql_url");
+        }
+        try {
+            if (row.key === "suiGrpcUrl") {
+                parseGrpcUrl(value);
+            }
+            else {
+                parseGraphqlUrl(value);
+            }
+        }
+        catch {
+            throw invalidBackup(row.key === "suiGrpcUrl" ? "invalid_sui_grpc_url" : "invalid_sui_graphql_url");
+        }
+    }
+}
+function validateReviewStateJsonColumn(value, field, validateAdapterLifecycle) {
+    const parsed = validateJsonColumn(value, field);
+    try {
+        parseLifecycleValidatedReviewState(parsed, validateAdapterLifecycle);
+    }
+    catch {
+        throw invalidBackup("invalid_json_shape", { field });
+    }
+}
+function withDefaultSuiGraphqlSetting(envelope, defaultSuiGraphqlUrl) {
+    if (envelope.data.localSettings.some((row) => row.key === "suiGraphqlUrl")) {
+        return envelope;
+    }
+    return {
+        ...envelope,
+        data: {
+            ...envelope.data,
+            localSettings: [
+                ...envelope.data.localSettings,
+                {
+                    key: "suiGraphqlUrl",
+                    value_json: JSON.stringify(parseGraphqlUrl(defaultSuiGraphqlUrl)),
+                    updated_at: envelope.exportedAt
+                }
+            ]
+        }
+    };
+}
+export function suiGrpcUrlFromPayload(data) {
+    const row = data.localSettings.find((setting) => setting.key === "suiGrpcUrl");
+    if (!row) {
+        throw invalidBackup("missing_sui_grpc_url");
+    }
+    const value = validateJsonColumn(row.value_json, "local_settings.value_json");
+    if (typeof value !== "string") {
+        throw invalidBackup("invalid_sui_grpc_url");
+    }
+    try {
+        return parseGrpcUrl(value);
+    }
+    catch {
+        throw invalidBackup("invalid_sui_grpc_url");
+    }
+}
+export function suiGraphqlUrlFromPayload(data) {
+    const row = data.localSettings.find((setting) => setting.key === "suiGraphqlUrl");
+    if (!row) {
+        throw invalidBackup("missing_sui_graphql_url");
+    }
+    const value = validateJsonColumn(row.value_json, "local_settings.value_json");
+    if (typeof value !== "string") {
+        throw invalidBackup("invalid_sui_graphql_url");
+    }
+    try {
+        return parseGraphqlUrl(value);
+    }
+    catch {
+        throw invalidBackup("invalid_sui_graphql_url");
+    }
+}
+function ensureUnique(values, reason) {
+    if (new Set(values).size !== values.length) {
+        throw invalidBackup(reason);
+    }
+}
+function validateJsonColumn(value, field, schema) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw invalidBackup("malformed_json", { field });
+    }
+    try {
+        assertNoForbiddenMcpFields(parsed);
+    }
+    catch {
+        throw invalidBackup("forbidden_field", { field });
+    }
+    if (schema) {
+        const result = schema.safeParse(parsed);
+        if (!result.success) {
+            throw invalidBackup("invalid_json_shape", { field });
+        }
+        return result.data;
+    }
+    return parsed;
+}
+function validateOptionalJsonColumn(value, field) {
+    if (value !== null) {
+        validateJsonColumn(value, field);
+    }
+}
+export function invalidBackup(reason, details = {}) {
+    return new LocalDataError("input_invalid", "Invalid local data backup", { reason, ...details });
+}
+export function countsForPayload(data) {
+    return {
+        accounts: data.accounts.length,
+        reviewSessions: data.reviewSessions.length,
+        reviewStateSnapshots: data.reviewStateSnapshots.length,
+        reviewStatusTransitions: data.reviewStatusTransitions.length,
+        reviewExecutions: data.reviewExecutions.length,
+        externalActivityScans: data.externalActivityScans.length,
+        externalActivityTransactions: data.externalActivityTransactions.length,
+        localSettings: data.localSettings.length
+    };
+}
+export function activeAccountChange(currentAccounts, current, incomingAccounts, incoming) {
+    const currentAccount = activeAccountAddress(currentAccounts, current);
+    const incomingAccount = activeAccountAddress(incomingAccounts, incoming);
+    if (currentAccount === incomingAccount) {
+        return "unchanged";
+    }
+    return incomingAccount === null ? "cleared" : "set";
+}
+function activeAccountAddress(accounts, context) {
+    const accountId = context[0]?.account_id ?? null;
+    if (accountId === null) {
+        return null;
+    }
+    return accounts.find((account) => account.id === accountId)?.sui_address ?? null;
+}
+export function maxNumber(values) {
+    return values.reduce((max, value) => Math.max(max, value), 0);
+}

package/dist/core/activity/schemaVersion.js

@@ -0,0 +1 @@
+export const DB_USER_VERSION = 5;