@tangle-network/agent-app 0.44.26 → 0.44.27

package/dist/sandbox/index.js

@@ -63,7 +63,7 @@ import {
   verifySandboxTerminalToken,
   verifyTerminalProxyToken,
   writeProfileFilesToBox
-} from "../chunk-Q74BS43G.js";
+} from "../chunk-7775L5NN.js";
 import "../chunk-LWSJK546.js";
 import "../chunk-CQZSAR77.js";
 import "../chunk-ICOHEZK6.js";

package/dist/store/index.d.ts

@@ -32,6 +32,14 @@ interface DatabaseProviderOptions {
      *  existing wording so callers see a familiar message. */
     notReadyMessage?: string;
 }
+/** A database driver that can execute related SQLite statements as one batch.
+ * Cloudflare D1 and libsql expose this method; portable local drivers may not. */
+interface SqliteBatchDatabase {
+    batch?: (statements: [unknown, ...unknown[]]) => Promise<unknown[]>;
+}
+/** Execute related SQLite statements in one transactional driver batch when
+ * supported, or sequentially in the same order for portable local drivers. */
+declare function runSqliteStatements(db: SqliteBatchDatabase, statements: [unknown, ...unknown[]]): Promise<unknown[]>;
 /**
  * Create a swappable database provider. `DB` is the injected instance's type
  * (e.g. a drizzle `Database`); the proxy is typed as `DB` so callers keep full
@@ -77,4 +85,4 @@ interface KVStore {
  */
 declare function createInMemoryKV(initial?: Record<string, string>): KVStore;
 
-export { type DatabaseProvider, type DatabaseProviderOptions, type KVGetWithMetadataResult, type KVListResult, type KVPutOptions, type KVStore, createDatabaseProvider, createInMemoryKV };
+export { type DatabaseProvider, type DatabaseProviderOptions, type KVGetWithMetadataResult, type KVListResult, type KVPutOptions, type KVStore, type SqliteBatchDatabase, createDatabaseProvider, createInMemoryKV, runSqliteStatements };

package/dist/store/index.js

@@ -1,57 +1,11 @@
-// src/store/index.ts
-function createDatabaseProvider(options = {}) {
-  const message = options.notReadyMessage ?? "Database not initialized \u2014 call setDatabase() first.";
-  let current = null;
-  const db = new Proxy({}, {
-    get(_target, prop) {
-      if (!current) throw new Error(message);
-      const value = current[prop];
-      return typeof value === "function" ? value.bind(current) : value;
-    },
-    has(_target, prop) {
-      return current !== null && prop in current;
-    }
-  });
-  return {
-    db,
-    setDatabase(database) {
-      current = database;
-    },
-    isReady() {
-      return current !== null;
-    },
-    reset() {
-      current = null;
-    }
-  };
-}
-function createInMemoryKV(initial) {
-  const store = new Map(
-    initial ? Object.entries(initial).map(([k, v]) => [k, { value: v, metadata: null }]) : []
-  );
-  return {
-    async get(key) {
-      return store.get(key)?.value ?? null;
-    },
-    async getWithMetadata(key) {
-      const entry = store.get(key);
-      return { value: entry?.value ?? null, metadata: entry?.metadata ?? null };
-    },
-    async put(key, value, options) {
-      store.set(key, { value, metadata: options?.metadata ?? null });
-    },
-    async delete(key) {
-      store.delete(key);
-    },
-    async list(options) {
-      const prefix = options?.prefix ?? "";
-      const keys = [...store.keys()].filter((k) => k.startsWith(prefix)).sort().map((name) => ({ name }));
-      return { keys, list_complete: true };
-    }
-  };
-}
+import {
+  createDatabaseProvider,
+  createInMemoryKV,
+  runSqliteStatements
+} from "../chunk-LRHVCVEW.js";
 export {
   createDatabaseProvider,
-  createInMemoryKV
+  createInMemoryKV,
+  runSqliteStatements
 };
 //# sourceMappingURL=index.js.map

package/dist/store/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/store/index.ts"],"sourcesContent":["/**\n * Swappable database provider — the seam that decouples the agent's persistence\n * from any one driver.\n *\n * The agent core (and the app's server modules) import a single `db` and use it\n * directly. That `db` is a lazy proxy: it forwards to whatever database instance\n * the runtime injects via {@link DatabaseProvider.setDatabase}. So the SAME core\n * runs on:\n *   - Cloudflare D1            (`setDatabase(drizzle(d1, schema))`)        — prod\n *   - SQLite / miniflare       (`setDatabase(drizzle(betterSqlite, schema))`) — eval / the portable inner shell\n *   - libsql / Turso, Postgres (`setDatabase(drizzle(client, schema))`)    — a future hosted DB\n *\n * Adding a new database is one adapter (a drizzle instance over a new driver) +\n * a `setDatabase` call. None of the modules importing `db` change. Substrate-\n * free and driver-agnostic: this module knows nothing about D1, drizzle, or any\n * schema — it only forwards property access to the injected instance.\n */\n\nexport interface DatabaseProvider<DB> {\n  /** The injected database, as a lazy proxy. Throws (with `notReadyMessage`)\n   *  on any access before {@link setDatabase} is called. */\n  readonly db: DB\n  /** Inject the active database instance (any driver's client). */\n  setDatabase(database: DB): void\n  /** True once a database has been injected. */\n  isReady(): boolean\n  /** Clear the injected database (next access throws again). Mainly for tests. */\n  reset(): void\n}\n\n/** Define options for configuring database provider behavior including error messaging */\nexport interface DatabaseProviderOptions {\n  /** Error thrown when `db` is accessed before injection. Keep the product's\n   *  existing wording so callers see a familiar message. */\n  notReadyMessage?: string\n}\n\n/**\n * Create a swappable database provider. `DB` is the injected instance's type\n * (e.g. a drizzle `Database`); the proxy is typed as `DB` so callers keep full\n * typing and their existing query syntax.\n */\nexport function createDatabaseProvider<DB extends object>(\n  options: DatabaseProviderOptions = {},\n): DatabaseProvider<DB> {\n  const message = options.notReadyMessage ?? 'Database not initialized — call setDatabase() first.'\n  let current: DB | null = null\n\n  const db = new Proxy({} as DB, {\n    get(_target, prop) {\n      if (!current) throw new Error(message)\n      const value = (current as Record<string | symbol, unknown>)[prop]\n      // Bind methods to the real instance so `this` resolves correctly through\n      // the proxy (works for drizzle's query builders and class-based stores).\n      return typeof value === 'function' ? (value as (...args: unknown[]) => unknown).bind(current) : value\n    },\n    has(_target, prop) {\n      return current !== null && prop in (current as object)\n    },\n  })\n\n  return {\n    db,\n    setDatabase(database: DB) {\n      current = database\n    },\n    isReady() {\n      return current !== null\n    },\n    reset() {\n      current = null\n    },\n  }\n}\n\n// ── KV store port (the vault backend) ───────────────────────────────────────\n//\n// The vault (workspace files) is a key/value store. In production it's a\n// Cloudflare `KVNamespace`; the portable inner shell injects an in-memory (or\n// other) implementation. This is the subset of the KV API the vault uses —\n// `KVNamespace` satisfies it structurally, so prod passes the binding unchanged,\n// and `createInMemoryKV()` supplies the portable adapter for sandbox/eval.\n\n/** Describe the result of listing keys with completion status and optional pagination cursor */\nexport interface KVListResult {\n  keys: { name: string }[]\n  list_complete: boolean\n  cursor?: string\n}\n\n/** Define options for storing a key-value pair with expiration and metadata settings */\nexport interface KVPutOptions {\n  expiration?: number\n  expirationTtl?: number\n  metadata?: unknown\n}\n\n/** Resolve a key-value pair retrieval including its associated metadata and value */\nexport interface KVGetWithMetadataResult {\n  value: string | null\n  metadata: unknown | null\n}\n\n/** Define a key-value store interface for asynchronous data retrieval, storage, deletion, and listing */\nexport interface KVStore {\n  get(key: string): Promise<string | null>\n  /** Read a value with its stored metadata (e.g. the vault's encrypted/hasPII flags). */\n  getWithMetadata(key: string): Promise<KVGetWithMetadataResult>\n  put(key: string, value: string, options?: KVPutOptions): Promise<void>\n  delete(key: string): Promise<void>\n  list(options?: { prefix?: string; cursor?: string; limit?: number }): Promise<KVListResult>\n}\n\n/**\n * In-memory {@link KVStore} — the portable vault backend for sandbox/eval runs.\n * Backed by a Map; `list` returns all prefix-matched keys in one complete page\n * (no real pagination needed in-process). Seed with `initial` entries if useful.\n */\nexport function createInMemoryKV(initial?: Record<string, string>): KVStore {\n  const store = new Map<string, { value: string; metadata: unknown }>(\n    initial ? Object.entries(initial).map(([k, v]) => [k, { value: v, metadata: null }]) : [],\n  )\n  return {\n    async get(key) {\n      return store.get(key)?.value ?? null\n    },\n    async getWithMetadata(key) {\n      const entry = store.get(key)\n      return { value: entry?.value ?? null, metadata: entry?.metadata ?? null }\n    },\n    async put(key, value, options) {\n      store.set(key, { value, metadata: options?.metadata ?? null })\n    },\n    async delete(key) {\n      store.delete(key)\n    },\n    async list(options) {\n      const prefix = options?.prefix ?? ''\n      const keys = [...store.keys()]\n        .filter((k) => k.startsWith(prefix))\n        .sort()\n        .map((name) => ({ name }))\n      return { keys, list_complete: true }\n    },\n  }\n}\n"],"mappings":";AA0CO,SAAS,uBACd,UAAmC,CAAC,GACd;AACtB,QAAM,UAAU,QAAQ,mBAAmB;AAC3C,MAAI,UAAqB;AAEzB,QAAM,KAAK,IAAI,MAAM,CAAC,GAAS;AAAA,IAC7B,IAAI,SAAS,MAAM;AACjB,UAAI,CAAC,QAAS,OAAM,IAAI,MAAM,OAAO;AACrC,YAAM,QAAS,QAA6C,IAAI;AAGhE,aAAO,OAAO,UAAU,aAAc,MAA0C,KAAK,OAAO,IAAI;AAAA,IAClG;AAAA,IACA,IAAI,SAAS,MAAM;AACjB,aAAO,YAAY,QAAQ,QAAS;AAAA,IACtC;AAAA,EACF,CAAC;AAED,SAAO;AAAA,IACL;AAAA,IACA,YAAY,UAAc;AACxB,gBAAU;AAAA,IACZ;AAAA,IACA,UAAU;AACR,aAAO,YAAY;AAAA,IACrB;AAAA,IACA,QAAQ;AACN,gBAAU;AAAA,IACZ;AAAA,EACF;AACF;AA6CO,SAAS,iBAAiB,SAA2C;AAC1E,QAAM,QAAQ,IAAI;AAAA,IAChB,UAAU,OAAO,QAAQ,OAAO,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,UAAU,KAAK,CAAC,CAAC,IAAI,CAAC;AAAA,EAC1F;AACA,SAAO;AAAA,IACL,MAAM,IAAI,KAAK;AACb,aAAO,MAAM,IAAI,GAAG,GAAG,SAAS;AAAA,IAClC;AAAA,IACA,MAAM,gBAAgB,KAAK;AACzB,YAAM,QAAQ,MAAM,IAAI,GAAG;AAC3B,aAAO,EAAE,OAAO,OAAO,SAAS,MAAM,UAAU,OAAO,YAAY,KAAK;AAAA,IAC1E;AAAA,IACA,MAAM,IAAI,KAAK,OAAO,SAAS;AAC7B,YAAM,IAAI,KAAK,EAAE,OAAO,UAAU,SAAS,YAAY,KAAK,CAAC;AAAA,IAC/D;AAAA,IACA,MAAM,OAAO,KAAK;AAChB,YAAM,OAAO,GAAG;AAAA,IAClB;AAAA,IACA,MAAM,KAAK,SAAS;AAClB,YAAM,SAAS,SAAS,UAAU;AAClC,YAAM,OAAO,CAAC,GAAG,MAAM,KAAK,CAAC,EAC1B,OAAO,CAAC,MAAM,EAAE,WAAW,MAAM,CAAC,EAClC,KAAK,EACL,IAAI,CAAC,UAAU,EAAE,KAAK,EAAE;AAC3B,aAAO,EAAE,MAAM,eAAe,KAAK;AAAA,IACrC;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-app",
-  "version": "0.44.26",
+  "version": "0.44.27",
   "packageManager": "pnpm@10.33.4",
   "description": "Application-shell framework for Tangle agent products: a bounded tool loop, the structured agent→app tool side channel, integration-hub client, per-workspace billing, and crypto — composed over the Tangle agent substrate through typed seams.",
   "keywords": [