@xnetjs/cli 0.2.1 → 0.3.0

package/dist/agent-local-XRQV3OKU.js

@@ -0,0 +1,6 @@
+import {
+  createLocalAgentBackend
+} from "./chunk-NOYKKZDQ.js";
+export {
+  createLocalAgentBackend
+};

package/dist/chunk-NOYKKZDQ.js

@@ -0,0 +1,90 @@
+// src/utils/agent-local.ts
+import { getSigningPublicKeyFromPrivate } from "@xnetjs/crypto";
+import { SQLiteNodeStorageAdapter, builtInSchemas } from "@xnetjs/data";
+import { createDID } from "@xnetjs/identity";
+import { createXNetClient } from "@xnetjs/runtime";
+var toNodeData = (node) => ({
+  id: node.id,
+  schemaId: node.schemaId,
+  properties: node.properties,
+  deleted: node.deleted ?? false,
+  createdAt: node.createdAt ?? 0,
+  updatedAt: node.updatedAt ?? 0
+});
+async function resolveStorage(db) {
+  if (db) {
+    const { createElectronSQLiteAdapter } = await import("@xnetjs/sqlite/electron");
+    const adapter2 = await createElectronSQLiteAdapter({
+      path: db,
+      busyTimeout: 5e3,
+      foreignKeys: true,
+      walMode: true
+    });
+    return new SQLiteNodeStorageAdapter(adapter2);
+  }
+  const { createMemorySQLiteAdapter } = await import("@xnetjs/sqlite/memory");
+  const adapter = await createMemorySQLiteAdapter();
+  return new SQLiteNodeStorageAdapter(adapter);
+}
+function builtInSchemaRegistry() {
+  const iris = Object.keys(builtInSchemas).filter((iri) => iri.includes("@"));
+  return {
+    getAllIRIs: () => iris,
+    get: async (iri) => {
+      const loader = builtInSchemas[iri];
+      if (!loader) return null;
+      const schema = await loader();
+      return {
+        iri,
+        name: schema.schema.name,
+        properties: schema.schema.properties
+      };
+    }
+  };
+}
+async function createLocalAgentBackend(options) {
+  const agentDID = createDID(getSigningPublicKeyFromPrivate(options.agentKey));
+  const nodeStorage = await resolveStorage(options.db);
+  const client = await createXNetClient({
+    nodeStorage,
+    authorDID: agentDID,
+    signingKey: options.agentKey
+  });
+  const store = {
+    get: async (id) => {
+      const node = await client.store.get(id);
+      return node ? toNodeData(node) : null;
+    },
+    list: async (opts) => {
+      const nodes = await client.store.list({
+        ...opts?.schemaId ? { schemaId: opts.schemaId } : {},
+        ...opts?.limit !== void 0 ? { limit: opts.limit } : {},
+        ...opts?.offset !== void 0 ? { offset: opts.offset } : {}
+      });
+      return nodes.map(toNodeData);
+    },
+    create: async (opts) => {
+      const node = await client.store.create({
+        ...opts.id ? { id: opts.id } : {},
+        schemaId: opts.schemaId,
+        properties: opts.properties
+      });
+      return toNodeData(node);
+    },
+    update: async (id, opts) => {
+      const node = await client.store.update(id, { properties: opts.properties });
+      return toNodeData(node);
+    },
+    delete: async (id) => {
+      await client.store.delete(id);
+    },
+    subscribe: (listener) => client.store.subscribe((event) => {
+      listener({ change: { type: event.change.type }, node: null, isRemote: false });
+    })
+  };
+  return { store, schemas: builtInSchemaRegistry(), client, agentDID };
+}
+
+export {
+  createLocalAgentBackend
+};

package/dist/cli.js

@@ -4,6 +4,9 @@ import {
   generateLensCode,
   generateLensSnippet
 } from "./chunk-IUOECMVU.js";
+import {
+  createLocalAgentBackend
+} from "./chunk-NOYKKZDQ.js";
 
 // src/cli.ts
 import { program } from "commander";
@@ -724,11 +727,82 @@ function registerConnectorCommand(program2) {
 }
 
 // src/commands/data.ts
-import { generateSigningKeyPair, getSigningPublicKeyFromPrivate } from "@xnetjs/crypto";
-import { defineSchema, SQLiteNodeStorageAdapter, text } from "@xnetjs/data";
+import { generateSigningKeyPair, getSigningPublicKeyFromPrivate, sign } from "@xnetjs/crypto";
+import {
+  applyBundle,
+  defineSchema,
+  SQLiteNodeStorageAdapter,
+  text,
+  verifyBundle,
+  writeBundle
+} from "@xnetjs/data";
 import { createDID } from "@xnetjs/identity";
 import { createXNetClient } from "@xnetjs/runtime";
 import chalk from "chalk";
+import { resolve as resolve5 } from "path";
+
+// src/utils/fs-bundle.ts
+import { createReadStream } from "fs";
+import { mkdir as mkdir2, readdir, readFile as readFile2, stat, writeFile } from "fs/promises";
+import { dirname as dirname3, join as join5, relative, sep } from "path";
+import { createInterface } from "readline";
+var FsBundleSink = class {
+  constructor(root) {
+    this.root = root;
+  }
+  async writeEntry(path, data) {
+    const target = join5(this.root, path);
+    await mkdir2(dirname3(target), { recursive: true });
+    await writeFile(target, data);
+  }
+};
+var FsBundleSource = class {
+  constructor(root) {
+    this.root = root;
+  }
+  async readEntry(path) {
+    try {
+      return new Uint8Array(await readFile2(join5(this.root, path)));
+    } catch {
+      return null;
+    }
+  }
+  async *readLines(path) {
+    const target = join5(this.root, path);
+    try {
+      await stat(target);
+    } catch {
+      return;
+    }
+    const rl = createInterface({ input: createReadStream(target), crlfDelay: Infinity });
+    for await (const line of rl) {
+      if (line.length > 0) yield line;
+    }
+  }
+  async listEntries(prefix) {
+    const results = [];
+    const walk = async (dir) => {
+      let entries;
+      try {
+        entries = await readdir(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        const full = join5(dir, entry.name);
+        if (entry.isDirectory()) await walk(full);
+        else {
+          const rel = relative(this.root, full).split(sep).join("/");
+          if (rel.startsWith(prefix)) results.push(rel);
+        }
+      }
+    };
+    await walk(this.root);
+    return results.sort();
+  }
+};
+
+// src/commands/data.ts
 var NoteSchema = defineSchema({
   name: "Note",
   namespace: "xnet://cli/",
@@ -773,6 +847,35 @@ async function runCreateNote(client, input) {
 async function runListNotes(client) {
   return client.fetch(NoteSchema);
 }
+function parseScope(opts) {
+  if (opts.space) return { kind: "space", spaceId: opts.space };
+  if (opts.schema?.length) return { kind: "schemas", schemaIds: opts.schema };
+  if (opts.node?.length) return { kind: "nodes", nodeIds: opts.node };
+  return { kind: "full" };
+}
+function printVerifyReport(report) {
+  const m = report.manifest;
+  if (m) {
+    console.log(`  format:   ${m.formatVersion} (change protocol v${m.protocolVersion.change})`);
+    console.log(`  owner:    ${m.ownerDid}`);
+    console.log(`  scope:    ${JSON.stringify(m.scope)}`);
+    console.log(
+      `  contents: ${m.counts.changes} changes, ${m.counts.blobs} blobs, ${m.counts.yjsDocs} yjs docs`
+    );
+    if (m.prerequisites) {
+      console.log(
+        `  requires: base bundle through lamport ${m.prerequisites.lamport} (incremental)`
+      );
+    }
+  }
+  for (const issue of report.issues) {
+    const paint = issue.severity === "error" ? chalk.red : chalk.yellow;
+    console.log(paint(`  ${issue.severity}: [${issue.code}] ${issue.detail}`));
+  }
+  console.log(
+    report.ok ? chalk.green("\u2713 bundle verifies clean") : chalk.red("\u2717 bundle failed verification")
+  );
+}
 function registerDataCommand(program2) {
   const data = program2.command("data").description("Read and write live nodes (runtime client)");
   data.command("add").description("Create a Note node").requiredOption("--title <title>", "Note title").option("--body <body>", "Note body", "").option("--db <path>", "SQLite file path (default: in-memory)").option("--key <hex>", "Ed25519 signing key (hex); falls back to $XNET_SIGNING_KEY").action(async (opts) => {
@@ -801,11 +904,123 @@ function registerDataCommand(program2) {
       await client.destroy();
     }
   });
+  data.command("export").description("Export the change log as an .xnetpack bundle directory (exploration 0344)").requiredOption("--out <dir>", "Bundle output directory").option("--db <path>", "SQLite file path (default: in-memory)").option("--key <hex>", "Ed25519 signing key (hex); falls back to $XNET_SIGNING_KEY").option("--space <id>", "Export one space (the space node plus its members)").option("--schema <iri...>", "Export nodes of the given schema IRI(s)").option("--node <id...>", "Export the given node id(s)").option("--since-lamport <n>", "Incremental: export changes after this lamport time").action(
+    async (opts) => {
+      const { signingKey, ephemeral } = resolveSigningKey(opts.key);
+      if (ephemeral) {
+        console.log(
+          chalk.yellow(
+            "\u26A0 no signing key provided \u2014 manifest will be signed by an ephemeral identity"
+          )
+        );
+      }
+      const client = await buildDataClient({
+        db: opts.db,
+        key: Buffer.from(signingKey).toString("hex")
+      });
+      try {
+        const scope = parseScope(opts);
+        const since = opts.sinceLamport ? { lamport: Number(opts.sinceLamport), heads: [], changeCount: 0 } : void 0;
+        const manifest = await writeBundle(client.store, scope, new FsBundleSink(opts.out), {
+          ownerDid: client.authorDID,
+          manifestSigner: (bytes) => sign(bytes, signingKey),
+          since
+        });
+        console.log(chalk.green(`\u2713 exported ${manifest.counts.changes} changes to ${opts.out}`));
+        console.log(chalk.dim(`  owner: ${manifest.ownerDid}`));
+        console.log(chalk.dim(`  frontier lamport: ${manifest.frontier.lamport}`));
+      } finally {
+        await client.destroy();
+      }
+    }
+  );
+  data.command("import").description("Verify and import an .xnetpack bundle directory").requiredOption("--in <dir>", "Bundle directory to import").option("--db <path>", "SQLite file path (default: in-memory)").option("--key <hex>", "Ed25519 signing key (hex); falls back to $XNET_SIGNING_KEY").option("--dry-run", "Verify and report only \u2014 write nothing").option("--allow-foreign-owner", "Import a bundle owned by another identity's DID").option("--allow-unsigned", "Import a bundle whose manifest is unsigned").action(
+    async (opts) => {
+      const source = new FsBundleSource(opts.in);
+      if (opts.dryRun) {
+        const report = await verifyBundle(source);
+        printVerifyReport(report);
+        if (!report.ok) process.exitCode = 1;
+        return;
+      }
+      const client = await buildDataClient({ db: opts.db, key: opts.key });
+      try {
+        const result = await applyBundle(client.store, source, {
+          importerDid: client.authorDID,
+          allowForeignOwner: opts.allowForeignOwner,
+          allowUnsigned: opts.allowUnsigned
+        });
+        console.log(
+          chalk.green(
+            `\u2713 applied ${result.applied} change(s), ${result.duplicates} duplicate(s) skipped`
+          )
+        );
+        if (result.quarantined.length > 0) {
+          console.log(chalk.yellow(`\u26A0 ${result.quarantined.length} record(s) quarantined:`));
+          for (const q of result.quarantined.slice(0, 20)) {
+            console.log(chalk.yellow(`  [${q.kind}] ${q.subject}: ${q.reason}`));
+          }
+        }
+      } finally {
+        await client.destroy();
+      }
+    }
+  );
+  data.command("export-folder").description(
+    "Export the workspace as a human-readable folder: Pages/*.md, Databases/*.rows.jsonl,\nCanvases/*.canvas (Tier 2 \u2014 a projection in xNet's markdown dialect: wikilinks and\nschema JSON travel, history/signatures/comments do not; use `export` for the lossless bundle)"
+  ).requiredOption("--out <dir>", "Folder to write the projection into").option("--db <path>", "SQLite file path (default: in-memory)").option("--key <hex>", "Ed25519 signing key (hex); falls back to $XNET_SIGNING_KEY").action(async (opts) => {
+    const { signingKey } = resolveSigningKey(opts.key);
+    const [{ createLocalAgentBackend: createLocalAgentBackend2 }, plugins] = await Promise.all([
+      import("./agent-local-XRQV3OKU.js"),
+      import("@xnetjs/plugins/node")
+    ]);
+    const backend = await createLocalAgentBackend2({ db: opts.db, agentKey: signingKey });
+    try {
+      const aiSurface = plugins.createAiSurfaceService({
+        store: backend.store,
+        schemas: backend.schemas
+      });
+      const exporter = plugins.createAiWorkspaceExporter({ ...backend, aiSurface });
+      const result = await exporter.exportWorkspace({ rootDir: resolve5(opts.out) });
+      console.log(
+        chalk.green(`\u2713 exported ${result.manifestEntries.length} file(s) to ${opts.out}`)
+      );
+      console.log(
+        chalk.dim(
+          "  note: this is a readable projection (markdown + JSONL); history, signatures,\n  and comments do not survive \u2014 use `xnet data export` for the lossless bundle"
+        )
+      );
+    } finally {
+      await backend.client.destroy();
+    }
+  });
+  data.command("snapshot").description(
+    "Write a defragmented SQLite snapshot of the database (VACUUM INTO \u2014 Tier 2:\nmaterialized state for any SQLite tool; use 'export' for the lossless bundle)"
+  ).requiredOption("--db <path>", "SQLite file path to snapshot").requiredOption("--sqlite <out>", "Output .sqlite file path").action(async (opts) => {
+    const { createElectronSQLiteAdapter } = await import("@xnetjs/sqlite/electron");
+    const adapter = await createElectronSQLiteAdapter({
+      path: opts.db,
+      busyTimeout: 5e3,
+      foreignKeys: true,
+      walMode: true
+    });
+    try {
+      await adapter.exec(`VACUUM INTO '${opts.sqlite.replace(/'/g, "''")}'`);
+      console.log(chalk.green(`\u2713 snapshot written to ${opts.sqlite}`));
+      console.log(
+        chalk.dim(
+          "  note: a snapshot is materialized state (readable by any SQLite tool); it is not\n  a signed bundle \u2014 use `xnet data export` for the lossless, verifiable artifact"
+        )
+      );
+    } finally {
+      await adapter.close();
+    }
+  });
 }
 
 // src/commands/doctor.ts
 import { writeFileSync as writeFileSync3, readFileSync, existsSync, readdirSync, statSync } from "fs";
-import { resolve as resolve5, join as join5 } from "path";
+import { resolve as resolve6, join as join6 } from "path";
 import {
   verifyIntegrity,
   quickIntegrityCheck,
@@ -835,15 +1050,15 @@ async function getChalk() {
 }
 function findDataDir(providedDir) {
   if (providedDir) {
-    const resolved = resolve5(process.cwd(), providedDir);
+    const resolved = resolve6(process.cwd(), providedDir);
     if (existsSync(resolved)) {
       return resolved;
     }
     throw new Error(`Data directory not found: ${resolved}`);
   }
-  const commonPaths = [".xnet/data", "data", ".data", resolve5(process.env.HOME ?? "", ".xnet/data")];
+  const commonPaths = [".xnet/data", "data", ".data", resolve6(process.env.HOME ?? "", ".xnet/data")];
   for (const path of commonPaths) {
-    const resolved = resolve5(process.cwd(), path);
+    const resolved = resolve6(process.cwd(), path);
     if (existsSync(resolved)) {
       return resolved;
     }
@@ -854,7 +1069,7 @@ function loadChangesFromDir(dataDir) {
   const changes = [];
   const patterns = ["changes.json", "changes/*.json", "*.changes.json"];
   for (const pattern of patterns) {
-    const changesFile = join5(dataDir, pattern.split("/")[0]);
+    const changesFile = join6(dataDir, pattern.split("/")[0]);
     if (existsSync(changesFile) && statSync(changesFile).isFile()) {
       try {
         const content = readFileSync(changesFile, "utf-8");
@@ -868,12 +1083,12 @@ function loadChangesFromDir(dataDir) {
       }
     }
   }
-  const changesDir = join5(dataDir, "changes");
+  const changesDir = join6(dataDir, "changes");
   if (existsSync(changesDir) && statSync(changesDir).isDirectory()) {
     const files = readdirSync(changesDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
       try {
-        const content = readFileSync(join5(changesDir, file), "utf-8");
+        const content = readFileSync(join6(changesDir, file), "utf-8");
         const change = JSON.parse(content);
         changes.push(change);
       } catch {
@@ -1114,7 +1329,7 @@ async function exportCommand(options) {
       dataDir = "";
       changes = generateDemoChanges();
     }
-    const outputPath = resolve5(process.cwd(), options.output);
+    const outputPath = resolve6(process.cwd(), options.output);
     console.log(chalk2.gray(`Source: ${dataDir || "demo data"}`));
     console.log(chalk2.gray(`Output: ${outputPath}`));
     console.log();
@@ -1153,7 +1368,7 @@ async function importCommand(options) {
   const chalk2 = await getChalk();
   console.log(chalk2.bold("\nxNet Data Import\n"));
   try {
-    const inputPath = resolve5(process.cwd(), options.input);
+    const inputPath = resolve6(process.cwd(), options.input);
     if (!existsSync(inputPath)) {
       console.error(chalk2.red(`Error: Input file not found: ${inputPath}`));
       process.exit(1);
@@ -1236,29 +1451,29 @@ import { agentPassportId } from "@xnetjs/data";
 import { createDID as createDID2, mintAgentPassport } from "@xnetjs/identity";
 
 // src/utils/agent-passport-file.ts
-import { mkdir as mkdir2, readFile as readFile2, writeFile, chmod, readdir } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile2, chmod, readdir as readdir2 } from "fs/promises";
 import { homedir } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 function agentPassportDir() {
-  return process.env.XNET_AGENT_DIR ?? join6(homedir(), ".xnet", "agents");
+  return process.env.XNET_AGENT_DIR ?? join7(homedir(), ".xnet", "agents");
 }
 var passportPath = (name) => {
   if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
     throw new Error(`Invalid agent name: ${name} (use letters, digits, - and _)`);
   }
-  return join6(agentPassportDir(), `${name}.json`);
+  return join7(agentPassportDir(), `${name}.json`);
 };
 async function saveAgentPassportFile(file) {
   const dir = agentPassportDir();
-  await mkdir2(dir, { recursive: true, mode: 448 });
+  await mkdir3(dir, { recursive: true, mode: 448 });
   const path = passportPath(file.name);
-  await writeFile(path, JSON.stringify(file, null, 2) + "\n", { mode: 384 });
+  await writeFile2(path, JSON.stringify(file, null, 2) + "\n", { mode: 384 });
   await chmod(path, 384);
   return path;
 }
 async function loadAgentPassportFile(name) {
   try {
-    const raw = await readFile2(passportPath(name), "utf8");
+    const raw = await readFile3(passportPath(name), "utf8");
     return JSON.parse(raw);
   } catch (err) {
     if (err.code === "ENOENT") return null;
@@ -1267,7 +1482,7 @@ async function loadAgentPassportFile(name) {
 }
 async function listAgentPassportNames() {
   try {
-    const entries = await readdir(agentPassportDir());
+    const entries = await readdir2(agentPassportDir());
     return entries.filter((e) => e.endsWith(".json")).map((e) => e.slice(0, -5));
   } catch (err) {
     if (err.code === "ENOENT") return [];
@@ -1419,95 +1634,6 @@ import {
   createMCPServer,
   createMcpHttpServer
 } from "@xnetjs/plugins/node";
-
-// src/utils/agent-local.ts
-import { getSigningPublicKeyFromPrivate as getSigningPublicKeyFromPrivate3 } from "@xnetjs/crypto";
-import { SQLiteNodeStorageAdapter as SQLiteNodeStorageAdapter2, builtInSchemas } from "@xnetjs/data";
-import { createDID as createDID3 } from "@xnetjs/identity";
-import { createXNetClient as createXNetClient2 } from "@xnetjs/runtime";
-var toNodeData = (node) => ({
-  id: node.id,
-  schemaId: node.schemaId,
-  properties: node.properties,
-  deleted: node.deleted ?? false,
-  createdAt: node.createdAt ?? 0,
-  updatedAt: node.updatedAt ?? 0
-});
-async function resolveStorage2(db) {
-  if (db) {
-    const { createElectronSQLiteAdapter } = await import("@xnetjs/sqlite/electron");
-    const adapter2 = await createElectronSQLiteAdapter({
-      path: db,
-      busyTimeout: 5e3,
-      foreignKeys: true,
-      walMode: true
-    });
-    return new SQLiteNodeStorageAdapter2(adapter2);
-  }
-  const { createMemorySQLiteAdapter } = await import("@xnetjs/sqlite/memory");
-  const adapter = await createMemorySQLiteAdapter();
-  return new SQLiteNodeStorageAdapter2(adapter);
-}
-function builtInSchemaRegistry() {
-  const iris = Object.keys(builtInSchemas).filter((iri) => iri.includes("@"));
-  return {
-    getAllIRIs: () => iris,
-    get: async (iri) => {
-      const loader = builtInSchemas[iri];
-      if (!loader) return null;
-      const schema = await loader();
-      return {
-        iri,
-        name: schema.schema.name,
-        properties: schema.schema.properties
-      };
-    }
-  };
-}
-async function createLocalAgentBackend(options) {
-  const agentDID = createDID3(getSigningPublicKeyFromPrivate3(options.agentKey));
-  const nodeStorage = await resolveStorage2(options.db);
-  const client = await createXNetClient2({
-    nodeStorage,
-    authorDID: agentDID,
-    signingKey: options.agentKey
-  });
-  const store = {
-    get: async (id) => {
-      const node = await client.store.get(id);
-      return node ? toNodeData(node) : null;
-    },
-    list: async (opts) => {
-      const nodes = await client.store.list({
-        ...opts?.schemaId ? { schemaId: opts.schemaId } : {},
-        ...opts?.limit !== void 0 ? { limit: opts.limit } : {},
-        ...opts?.offset !== void 0 ? { offset: opts.offset } : {}
-      });
-      return nodes.map(toNodeData);
-    },
-    create: async (opts) => {
-      const node = await client.store.create({
-        ...opts.id ? { id: opts.id } : {},
-        schemaId: opts.schemaId,
-        properties: opts.properties
-      });
-      return toNodeData(node);
-    },
-    update: async (id, opts) => {
-      const node = await client.store.update(id, { properties: opts.properties });
-      return toNodeData(node);
-    },
-    delete: async (id) => {
-      await client.store.delete(id);
-    },
-    subscribe: (listener) => client.store.subscribe((event) => {
-      listener({ change: { type: event.change.type }, node: null, isRemote: false });
-    })
-  };
-  return { store, schemas: builtInSchemaRegistry(), client, agentDID };
-}
-
-// src/commands/mcp.ts
 var defaultBackendFactory = (options) => createRemoteAgentBackend(options);
 function buildMcpServer(backend, agent) {
   return createMCPServer({
@@ -1626,7 +1752,7 @@ function parseIntOption3(value) {
 
 // src/commands/migrate.ts
 import { writeFileSync as writeFileSync4, readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 async function getChalk2() {
   try {
     const chalk2 = await import("chalk");
@@ -1811,7 +1937,7 @@ async function generateCommand(options) {
       includeTodos: true
     });
     if (options.output) {
-      const outputPath = resolve6(process.cwd(), options.output);
+      const outputPath = resolve7(process.cwd(), options.output);
       if (existsSync2(outputPath) && !options.force) {
         console.error(chalk2.red(`Error: File already exists: ${outputPath}`));
         console.error(chalk2.gray("Use --force to overwrite."));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xnetjs/cli",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "xNet CLI - Schema migrations, diagnostics, and development tools",
   "license": "MIT",
   "repository": {
@@ -31,15 +31,15 @@
   "dependencies": {
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
-    "@xnetjs/core": "2.2.0",
-    "@xnetjs/crypto": "2.2.0",
-    "@xnetjs/data": "2.2.0",
+    "@xnetjs/core": "2.4.0",
+    "@xnetjs/crypto": "2.4.0",
+    "@xnetjs/data": "2.4.0",
     "@xnetjs/devkit": "1.0.0",
-    "@xnetjs/identity": "2.2.0",
-    "@xnetjs/plugins": "2.2.0",
-    "@xnetjs/runtime": "0.5.2",
-    "@xnetjs/sqlite": "2.2.0",
-    "@xnetjs/sync": "2.2.0"
+    "@xnetjs/identity": "2.4.0",
+    "@xnetjs/plugins": "2.4.0",
+    "@xnetjs/runtime": "0.5.4",
+    "@xnetjs/sqlite": "2.4.0",
+    "@xnetjs/sync": "2.4.0"
   },
   "devDependencies": {
     "tsup": "^8.0.0",