@wfm-cn/dsh-storage 0.0.0-stage → 0.3.0

package/lib/types/generated/sqlserver/models.d.ts

@@ -0,0 +1,3 @@
+export type * from './models/AiMessage.js';
+export type * from './models/AiChatHistory.js';
+export type * from './commonInputTypes.js';

package/lib/types/health.d.ts

@@ -0,0 +1,52 @@
+import { type SyncConfig } from './config.js';
+export type HealthStatus = {
+    state: 'ok' | 'down' | 'disabled' | 'config-error';
+    lastOkAt?: number;
+    lastError?: string;
+    retryCount: number;
+    mirroredTotal?: number;
+};
+/** Thrown by the probe when the sync config itself is unusable — no retries until it is fixed. */
+export declare class ConfigError extends Error {
+}
+type TransitionCallback = (to: HealthStatus['state'], from: HealthStatus['state'], status: HealthStatus) => void;
+export interface HealthMonitorOptions {
+    /** Re-probe interval while healthy (default 30s). */
+    intervalMs?: number;
+}
+/**
+ * States: 'disabled' (not started) → 'ok'/'down' on probe results, or
+ * 'config-error' when the probe reports a ConfigError (retries suspended
+ * until an explicit `recheck()`). Same-state results never re-fire
+ * transition callbacks.
+ */
+export declare class HealthMonitor {
+    private readonly probe;
+    private readonly options;
+    private state;
+    private lastOkAt;
+    private lastError;
+    private retryCount;
+    private running;
+    private timer;
+    private readonly listeners;
+    constructor(probe: () => Promise<void>, options?: HealthMonitorOptions);
+    start(): void;
+    stop(): void;
+    snapshot(): HealthStatus;
+    onTransition(cb: TransitionCallback): () => void;
+    /** Run one probe cycle immediately (re-arms after a config error). */
+    recheck(): Promise<void>;
+    private clearTimer;
+    private runProbe;
+    private onSuccess;
+    private onFailure;
+    private scheduleRetry;
+    private transition;
+}
+/** Probe for HealthMonitor: resolves when the database is live and migrated. */
+export declare function probeDatabase(cfg: SyncConfig): Promise<void>;
+export type ConnectionTestResult = 'ok' | 'no-tables' | `fail:${string}`;
+/** One-shot panel test: never throws — every failure maps to 'fail:<reason>'. */
+export declare function testConnection(cfg: SyncConfig): Promise<ConnectionTestResult>;
+export {};

package/lib/types/index.d.ts

@@ -0,0 +1,91 @@
+/**
+ * dsh-storage — mirrors the dsh session event stream into the ai_messages /
+ * ai_chat_histories tables (MySQL/PostgreSQL/SQLite/SQL Server).
+ *
+ * Design: dsh's own session persistence (JSONL/SQLite) stays authoritative.
+ * This plugin taps `session/event` (the same seam the built-in persistence
+ * coordinator uses) and projects events into MessageRow / SessionRow shaped
+ * after the source project's ai_messages / ai_chat_histories tables.
+ *
+ * A2A task state (task metadata in Redis, workspace archives in GCS) is NOT
+ * here — that belongs to the A2A layer, see dsh-a2a's TaskStore backends.
+ *
+ * Resume caveat (docs/subsystems/persistence.md): constructor seeds do not
+ * emit events. On agent resume, only events >= `session.firstLiveSeq` fire
+ * on this stream — historical rows must come from the database itself, not
+ * from replaying the tap.
+ *
+ * @module dsh-storage
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import Schema from '@deepseek-ai/schemastery';
+import { type DatabaseProvider } from './backends/database.js';
+import { type BackfillSummary } from './backfill.js';
+import { type SyncConfig } from './config.js';
+import { type CreateTableResult } from './ddl.js';
+import { type ConnectionTestResult, type HealthStatus } from './health.js';
+import { type StorageToast } from './notify.js';
+export declare const name = "dsh-storage";
+export declare const inject: string[];
+export declare const Config: Schema<Schemastery.ObjectS<NoInfer<{
+    enabled: Schema<boolean, boolean, "defined">;
+    database: Schema<Schemastery.ObjectS<NoInfer<{
+        enabled: Schema<boolean, boolean, "defined">;
+        provider: Schema<"mysql" | "postgresql" | "sqlite" | "sqlserver", "mysql" | "postgresql" | "sqlite" | "sqlserver", "defined">;
+        url: Schema<string, string, "defined">;
+        timezone: Schema<string, string, "defined">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        enabled: Schema<boolean, boolean, "defined">;
+        provider: Schema<"mysql" | "postgresql" | "sqlite" | "sqlserver", "mysql" | "postgresql" | "sqlite" | "sqlserver", "defined">;
+        url: Schema<string, string, "defined">;
+        timezone: Schema<string, string, "defined">;
+    }>>, "plain">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    enabled: Schema<boolean, boolean, "defined">;
+    database: Schema<Schemastery.ObjectS<NoInfer<{
+        enabled: Schema<boolean, boolean, "defined">;
+        provider: Schema<"mysql" | "postgresql" | "sqlite" | "sqlserver", "mysql" | "postgresql" | "sqlite" | "sqlserver", "defined">;
+        url: Schema<string, string, "defined">;
+        timezone: Schema<string, string, "defined">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        enabled: Schema<boolean, boolean, "defined">;
+        provider: Schema<"mysql" | "postgresql" | "sqlite" | "sqlserver", "mysql" | "postgresql" | "sqlite" | "sqlserver", "defined">;
+        url: Schema<string, string, "defined">;
+        timezone: Schema<string, string, "defined">;
+    }>>, "plain">;
+}>>, "plain">;
+export interface StoragePluginConfig {
+    enabled: boolean;
+    database: {
+        enabled: boolean;
+        provider: DatabaseProvider;
+        url: string;
+        timezone?: string;
+    };
+}
+/** Explicit write API for a consumer's session-clear flow. */
+export interface DshStorageService {
+    archiveSession(sessionId: string): Promise<string | null>;
+}
+/** Status/health RPC for the settings panel (Task 5) and notifications (Task 6). */
+export interface DshStorageStatusService {
+    snapshot(): HealthStatus;
+    testConnection(cfg: SyncConfig): Promise<ConnectionTestResult>;
+    /** Panel 「建表」: provider-appropriate DDL via packaged prisma schemas. */
+    createTables(cfg: SyncConfig): Promise<CreateTableResult>;
+    /** Panel form load/persist — the file the backend watches (T3). */
+    getConfig(): {
+        config: SyncConfig;
+        error?: 'parse' | 'missing-field';
+    };
+    saveConfig(cfg: SyncConfig): {
+        config: SyncConfig;
+    };
+    /** Panel 「补传」 (T6): replay gap events from local session logs. */
+    backfill(): Promise<BackfillSummary>;
+    /** Toast notifications newer than the cursor (client polling, T6). */
+    toasts(payload: {
+        sinceId?: number;
+    }): StorageToast[];
+}
+export declare function apply(ctx: Context, config: StoragePluginConfig): void;

package/lib/types/memory-tools.d.ts

@@ -0,0 +1,168 @@
+/**
+ * AI-accessible memory query tools (Phase 2): `memory_search` / `memory_read`.
+ *
+ * Registration contract (verified against the running DSH runtime):
+ * - `@deepseek-ai/dsh-tools` exposes a cordis `tools` service whose
+ *   `register(definition)` inserts into the scoped tool layer; the definition
+ *   is `{ name, description, parameters (plain JSON Schema), output: { schema,
+ *   render(args, value) }, execute(args, exec), timeoutMs? }` (ToolsService
+ *   inside the app bundle; working plugin idiom: ds-harness-remote
+ *   `dist/remote-tools.js` → `ctx.inject(['tools'], (toolCtx) =>
+ *   toolCtx.effect(() => tools.register(definition)))`).
+ * - Tool names are flat global strings (`remote_list_hosts` style), so these
+ *   tools are `memory_search` / `memory_read`.
+ *
+ * Read-only SELECTs over the same connection config the mirror uses
+ * (createAdapter / configToUrl / loadConfig). Connections are disposed after
+ * every call. All user input is parameter-bound; LIKE wildcards in user
+ * keywords are escaped with an explicit `ESCAPE '~'` clause (works on all
+ * four providers — avoids backslash, which MySQL also treats as a string
+ * literal escape).
+ *
+ * Raw adapter binding detail (verified in @prisma/adapter-{mariadb,pg,mssql,libsql}
+ * 7.9.1 sources): each adapter maps `query.args[i]` through
+ * `mapArg(arg, query.argTypes[i])`, and the mssql adapter dereferences
+ * `argType.scalarType` unconditionally — binding any argument without
+ * argTypes throws (the ddl.ts comment describes this). The argType shape is
+ * the client runtime's `{ scalarType, arity }` record ('string' | 'int' |
+ * …, 'scalar' | 'list'), not the numeric ColumnTypeEnum. We therefore always
+ * pass argTypes and never bind Date objects (ISO strings compare correctly
+ * against DATETIME/TIMESTAMP/TEXT created_at on every provider).
+ *
+ * @module dsh-storage/memory-tools
+ */
+import { type DatabaseProvider } from './backends/database.js';
+import { type SyncConfig } from './config.js';
+/** Minimal cordis/tool surface we rely on — the package does not depend on dsh-tools types. */
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    output: {
+        schema: Record<string, unknown>;
+        render(args: unknown, value: unknown): Array<{
+            type: string;
+            text: string;
+        }>;
+    };
+    execute(args: any, exec: {
+        signal?: AbortSignal;
+    }): Promise<unknown>;
+}
+export interface ToolRegistrarContext {
+    inject(services: string[], callback: (ctx: ToolContext) => void): unknown;
+}
+export interface ToolContext {
+    get(service: string): unknown;
+    effect(factory: () => unknown): unknown;
+}
+/** One raw adapter query: `?` placeholders + positionally aligned args/argTypes. */
+export interface RawQuery {
+    sql: string;
+    args: unknown[];
+    argTypes: Array<{
+        scalarType: string;
+        arity: 'scalar';
+    }>;
+}
+/**
+ * Adapter connection from `createAdapter(...).connect()` (ddl.ts seam).
+ * All four adapters' `queryRaw` return `{ columnNames, rows: unknown[][] }`.
+ */
+export interface RawConnection {
+    queryRaw?(query: RawQuery): Promise<unknown>;
+    executeRaw(query: RawQuery): Promise<unknown>;
+    dispose?(): Promise<void>;
+}
+/**
+ * Escape LIKE wildcards in user input for use with `ESCAPE '~'`:
+ * `~` (the escape character itself), `%` and `_`. Everything else stays
+ * literal, so keywords match plain substrings.
+ */
+export declare function escapeLike(value: string): string;
+/** Split a free-text query into non-empty keyword terms. */
+export declare function splitKeywords(query: string): string[];
+export interface SearchPlanOptions {
+    query: string;
+    device?: 'all' | 'current';
+    limit?: number;
+    since?: string;
+}
+export interface SearchPlan {
+    sql: string;
+    args: unknown[];
+    argTypes: Array<{
+        scalarType: string;
+        arity: 'scalar';
+    }>;
+}
+/**
+ * Build the memory_search SELECT. Keywords OR across user+model rows
+ * (no type filter); `device:'current'` binds the configured device id;
+ * `since` (YYYY-MM-DD) filters `created_at >=` with an ISO 'T' delimiter so
+ * the string comparison also matches sqlite's TEXT timestamps.
+ */
+export declare function buildSearchSql(provider: DatabaseProvider, opts: SearchPlanOptions, deviceId?: string): SearchPlan;
+export interface ReadPlanOptions {
+    sessionId: string;
+    around?: string;
+    limit?: number;
+}
+/**
+ * Build the memory_read SELECT. Both cases fetch the newest-first (DESC)
+ * `limit`-row window — with `around`, at-or-before the instant; without it,
+ * the most recent `limit` rows of the session. The executor always reverses
+ * the rows to chronological order before handing them to the model.
+ */
+export declare function buildReadSql(provider: DatabaseProvider, opts: ReadPlanOptions): SearchPlan;
+/**
+ * Normalize adapter query results to row objects. The 7.9.1 adapters return
+ * `{ columnNames, rows: value[][] }`; tests and older shapes may already
+ * produce arrays of objects.
+ */
+export declare function normalizeRows(result: unknown): Array<Record<string, unknown>>;
+/** First-index snippet ≤ max chars centered on the earliest keyword hit. */
+export declare function snippetOf(content: string, keywords: string[], max?: number): string;
+export interface SearchHit {
+    session_id: string;
+    device: string | null;
+    type: string;
+    created_at: string;
+    snippet: string;
+}
+export interface ReadMessage {
+    role: string;
+    type: string;
+    created_at: string;
+    content: string;
+}
+/** Shape the memory_search result list. */
+export declare function toSearchHits(rows: Array<Record<string, unknown>>, keywords: string[]): SearchHit[];
+/** Shape the memory_read conversation window. */
+export declare function toReadMessages(rows: Array<Record<string, unknown>>, max?: number): ReadMessage[];
+/** Friendly unconfigured-config error (shown to the model). */
+export declare function notConfiguredError(reason?: string): Error;
+/** Load the sync config and reject unless sync is enabled and complete. */
+export declare function requireConfig(configPath?: string): SyncConfig;
+/** Open a one-shot read-only adapter connection; caller disposes. */
+export declare function connectReadOnly(config: SyncConfig): Promise<RawConnection>;
+/** Run one SELECT over the connection and return row objects. */
+export declare function runSelect(connection: RawConnection, query: RawQuery): Promise<Array<Record<string, unknown>>>;
+export interface MemoryToolsDeps {
+    /** Config path override (tests); defaults to $DSH_HOME/dsh-storage.json. */
+    configPath?: string;
+    /** Connection factory override (tests): receives the resolved sync config. */
+    connect?: (config: SyncConfig) => Promise<RawConnection>;
+}
+/**
+ * Build the two tool definitions. `deps.connect` defaults to a real
+ * read-only adapter connection created from the sync config and disposed
+ * after each execution.
+ */
+export declare function createMemoryTools(deps?: MemoryToolsDeps): ToolDefinition[];
+/**
+ * Register the memory tools on the host `tools` service (dsh-tools):
+ * `ctx.inject(['tools'], (toolCtx) => toolCtx.effect(() => tools.register(def)))`
+ * — the ds-harness-remote idiom. Tools are host-side only; nothing client-side.
+ */
+export declare function registerMemoryTools(ctx: ToolRegistrarContext, deps?: MemoryToolsDeps): void;

package/lib/types/notify.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 同步中断/恢复通知 (Task 6): the host side records toast notifications on
+ * HealthMonitor transitions; the browser client (src/client/toast.tsx) polls
+ * them through the status bridge and renders a React portal independent of
+ * the settings panel. The monitor already guarantees transitions only
+ * (same-state results never re-fire), so each record is a real state change.
+ */
+export interface StorageToast {
+    id: number;
+    kind: 'interrupted' | 'recovered';
+    text: string;
+    /** Secondary line (recovery backfill hint). */
+    hint?: string;
+    createdAt: number;
+}
+/** Minimal monitor surface wireNotifications needs (satisfied by HealthMonitor). */
+export interface ToastCapableMonitor {
+    onTransition(cb: (to: string, from: string, status: {
+        lastError?: string;
+    }) => void): () => void;
+}
+/** 中断 toast: good → bad. */
+export declare function notifyGoodToBad(lastError?: string): StorageToast;
+/** 恢复 toast: bad → good, with a backfill hint for the gap. */
+export declare function notifyBadToGood(): StorageToast;
+/** Records newer than `sinceId` (polling cursor for the client). */
+export declare function drainToasts(sinceId?: number): StorageToast[];
+/** Test/reset hook: drop all history. */
+export declare function clearToasts(): void;
+/**
+ * Wire the toast records onto a monitor's transitions. Good→bad strictly
+ * means ok → down (a config error was never "good"); bad→good covers
+ * down → ok and config-error → ok.
+ */
+export declare function wireNotifications(monitor: ToastCapableMonitor): () => void;

package/lib/types/projector.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Projects dsh session events onto MessageRow / SessionRow.
+ *
+ * Event shapes verified against the dsh persistence catalog
+ * (https://deepseek-harness.github.io/deepseek-harness/reference/persistence-catalog)
+ * and the @deepseek-ai/dsh-llm message types:
+ * - envelope: `{ type, seq, time, data }` — payload lives under `data`.
+ * - `user/message` and `assistant/message` produce rows; `tool/result` updates
+ *   the matching assistant row's toolCalls instead of producing a tool row.
+ * - token usage (V3 log): `assistant/message.data.usage` is the settled
+ *   step's accounting; a failed/cancelled attempt commits `assistant/attempt`
+ *   instead, with the adapter's usage chunk preserved as a raw record in its
+ *   embedded compact stream (recovered in usageSampleOf). `turn/end` carries
+ *   none — it only serves as a rollup checkpoint.
+ * - compaction summaries enter the surface as a `user/message` with
+ *   `surfaceOp: replace`, so they flow through the user path unchanged.
+ */
+import type { MessageRow } from './types.js';
+/**
+ * Map one session event to zero or one message row. Returns null for events
+ * that should not be persisted as standalone rows (log-only events: chunks,
+ * turn/step lifecycle, approvals, ...).
+ */
+export declare function projectEvent(_session: any, event: any, sessionId: string): MessageRow | null;
+/** Identify the assistant tool call answered by either supported result shape. */
+export declare function toolResultCallId(event: any): string | undefined;
+/** Update the persisted assistant call identified by a tool result. */
+export declare function mergeToolResult(event: any, rows: MessageRow[]): MessageRow | null;
+export interface UsageSample {
+    input: number;
+    output: number;
+}
+/**
+ * Extract one model call's usage, keyed by its durable event sequence.
+ *
+ * V3 session log (dsh-session@0.1.6-alpha.2):
+ * - `assistant/message.data.usage` — the settled call's accounting;
+ * - `assistant/attempt` — a failed/retried/cancelled call commits no surface
+ *   message; the adapter's usage chunk survives as a raw `chunk` record in the
+ *   embedded compact `stream` (deltas are packed, but usage is a raw type).
+ *
+ * Calls on one `(turn, step)` are additive: a retry is another billed model
+ * call, not a progressive snapshot. Only redelivery of the same event sequence
+ * is a duplicate. Totals include the cache buckets: cacheRead/cacheWrite are
+ * billed in their own buckets (observed cacheReadTokens ≫ inputTokens in dsh
+ * session logs — they are not subsets of inputTokens).
+ */
+export declare function usageSampleOf(event: any): {
+    key: string;
+    sample: UsageSample;
+} | null;

package/lib/types/status-route.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Host→browser bridge for the settings panel: exposes the dshStorageStatus
+ * service over the DSH connection generic-RPC channel `/dsh-storage`.
+ *
+ * Pattern verified against the installed reference plugins (ds-harness-remote
+ * `registerControlRoute`, dsh-video-skin settings.section client): the browser
+ * client calls `ctx.connection.rpc.call('/dsh-storage', endpoint, payload)`,
+ * which POSTs `{type:'client-request', rpcId, method, payload}` to
+ * `/<channel>/<endpoint>` and expects `{type:'server-response', rpcId,
+ * result:{ok:true,value}|{ok:false,error:{code,message,details}}}`. When the
+ * webServer service is available we serve that path with a prefix route
+ * (guarded by `connection.requestRejection` for authentication); otherwise we
+ * fall back to `connection.rpc.handle` for in-process carriers. Both halves
+ * stay optional (`ctx.get`), so profiles without a web carrier simply skip
+ * the bridge.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { SyncConfig } from './config.js';
+import type { CreateTableResult } from './ddl.js';
+import type { ConnectionTestResult, HealthStatus } from './health.js';
+import type { BackfillSummary } from './backfill.js';
+import type { StorageToast } from './notify.js';
+/** The surface bridged to the browser panel. */
+export interface StatusService {
+    snapshot(): HealthStatus;
+    testConnection(cfg: SyncConfig): Promise<ConnectionTestResult>;
+    createTables(cfg: SyncConfig): Promise<CreateTableResult>;
+    getConfig(): {
+        config: SyncConfig;
+        error?: 'parse' | 'missing-field';
+    };
+    saveConfig(cfg: SyncConfig): {
+        config: SyncConfig;
+    };
+    /** Panel 「补传」: replay missing events from local session logs. */
+    backfill(): Promise<BackfillSummary>;
+    /** Toast notifications newer than the cursor (client polling). */
+    toasts(payload: {
+        sinceId?: number;
+    }): StorageToast[];
+}
+export declare const STATUS_CHANNEL = "/dsh-storage";
+/**
+ * Register the /dsh-storage channel. Wire order mirrors ds-harness-remote's
+ * control route: an authenticated webServer prefix route when both services
+ * allow it, otherwise connection.rpc.handle for logical carriers.
+ */
+export declare function registerStatusRoute(ctx: Context, service: StatusService): (() => void) | undefined;

package/lib/types/types.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Shared row types and the backend contract.
+ *
+ * Row shapes mirror the `ai_messages` / `ai_chat_histories` Prisma models
+ * (see prisma/schema.{mysql,postgresql,sqlite,sqlserver}.prisma), matching
+ * the source project's tables.
+ */
+/** One row in `ai_messages`. */
+export interface MessageRow {
+    id: string;
+    sessionId: string;
+    historyId: string | null;
+    /** 'user' | 'model' | 'tool' | 'utility_compressor' | plugin-defined */
+    type: string;
+    content: string;
+    thoughts?: unknown;
+    model?: string | null;
+    tokens?: unknown;
+    toolCalls?: unknown;
+    agentId?: string | null;
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+}
+/** One row in `ai_chat_histories` — a per-session rollup. */
+export interface SessionRow {
+    sessionId: string;
+    title?: string | null;
+    messageCount: number;
+    totalTokens: number;
+    firstMessageAt?: Date | null;
+    lastMessageAt?: Date | null;
+    /** Plugin bookkeeping persisted in the row's JSON metadata column. */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * A storage backend receives already-projected rows. Backend errors reject
+ * into the plugin's per-session queue, whose catch/log boundary keeps
+ * mirroring failures out of the agent loop.
+ */
+export interface StorageBackend {
+    readonly name: string;
+    init?(): Promise<void>;
+    /** Read the stored session row, for seeding the live rollup on resume. */
+    readSession?(sessionId: string): Promise<SessionRow | null>;
+    /** Max message created_at per session across active rows (backfill gap detection). */
+    latestPerSession?(): Promise<Map<string, Date>>;
+    /** Read one persisted logical message, including archived rows for redelivery. */
+    readMessages(sessionId: string, messageId: string): Promise<MessageRow[]>;
+    /** Find the newest active model message containing this exact tool call. */
+    readToolCallMessages(sessionId: string, callId: string): Promise<MessageRow[]>;
+    upsertMessage(row: MessageRow): Promise<void>;
+    upsertSession(row: SessionRow): Promise<void>;
+    /** Atomically persist one event's optional message and its session rollup. */
+    upsertEvent(message: MessageRow | null, session: SessionRow): Promise<void>;
+    /** Move active messages into a queryable history row; null when already empty. */
+    archiveSession(sessionId: string): Promise<string | null>;
+    close?(): Promise<void>;
+}

package/lib/types.js

@@ -0,0 +1,8 @@
+/**
+ * Shared row types and the backend contract.
+ *
+ * Row shapes mirror the `ai_messages` / `ai_chat_histories` Prisma models
+ * (see prisma/schema.{mysql,postgresql,sqlite,sqlserver}.prisma), matching
+ * the source project's tables.
+ */
+export {};

package/package.json

@@ -1,6 +1,129 @@
 {
   "name": "@wfm-cn/dsh-storage",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.0",
+  "description": "Session storage mirror for DeepSeek Harness: projects the session event stream into MySQL/PostgreSQL/SQLite/SQL Server (ai_messages / ai_chat_histories) without replacing dsh's local persistence.",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json",
+    "./client": {
+      "default": "./lib/client.js"
+    }
+  },
+  "files": [
+    "lib",
+    "prisma",
+    "cordis.patch.yml",
+    "preview.png",
+    "CHANGELOG.md"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/2938236819/dsh-storage.git"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-ui-slots"
+      ],
+      "platform": "web"
+    }
+  },
+  "scripts": {
+    "build": "node scripts/prisma-generate.mjs && tsc -p tsconfig.build.json && npm run build:client",
+    "build:client": "esbuild src/client/index.ts --bundle --format=iife --outfile=lib/client.js --target=es2020 --minify --legal-comments=none",
+    "generate": "node scripts/prisma-generate.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.5",
+    "@prisma/client": "7.9.1",
+    "@prisma/adapter-mariadb": "7.9.1"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-session": ">=0.1.5-rc.1 || >=0.1.6-alpha.1 || >=0.1.7-alpha.1 || >=0.2.0-rc.1 || >=0.2.1-rc.1 || >=0.2.2-rc.1",
+    "@prisma/adapter-libsql": "^7.9.1",
+    "@prisma/adapter-mariadb": "^7.9.1",
+    "@prisma/adapter-mssql": "^7.9.1",
+    "@prisma/adapter-pg": "^7.9.1",
+    "@prisma/client": "^7.9.1",
+    "react": ">=18.2.0 <19",
+    "@deepseek-ai/dsh-client-connection": ">=0.2.0-rc.1 <0.3.0-0",
+    "@deepseek-ai/dsh-client-ui-slots": ">=0.2.0-rc.1 <0.3.0-0"
+  },
+  "peerDependenciesMeta": {
+    "@prisma/adapter-libsql": {
+      "optional": true
+    },
+    "@prisma/adapter-mariadb": {
+      "optional": true
+    },
+    "@prisma/adapter-mssql": {
+      "optional": true
+    },
+    "@prisma/adapter-pg": {
+      "optional": true
+    },
+    "@prisma/client": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-connection": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-slots": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "4.1.0",
+    "@deepseek-ai/dsh-session": "0.2.2-rc.1",
+    "@prisma/adapter-libsql": "^7.9.1",
+    "@prisma/adapter-mariadb": "^7.9.1",
+    "@prisma/adapter-mssql": "^7.9.1",
+    "@prisma/adapter-pg": "^7.9.1",
+    "@prisma/client": "^7.9.1",
+    "@testing-library/dom": "^10.4.2",
+    "@testing-library/react": "^16.3.3",
+    "@types/node": "^22.0.0",
+    "@types/react": "^18.3.31",
+    "@types/react-dom": "^18.3.7",
+    "esbuild": "^0.28.2",
+    "jsdom": "^31.0.0",
+    "prisma": "^7.9.1",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "typescript": "^5.6.3",
+    "vitest": "^4.1.11"
+  },
+  "engines": {
+    "node": "^20.19 || ^22.12 || >=24.0"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "@prisma/engines",
+      "esbuild",
+      "prisma"
+    ],
+    "patchedDependencies": {
+      "@prisma/adapter-mariadb@7.9.1": "patches/@prisma__adapter-mariadb@7.9.1.patch"
+    }
+  }
+}