@fileverse/api 0.0.1

package/dist/cli/index.js

@@ -0,0 +1,1258 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/cli/constants.generated.ts
+var STATIC_CONFIG, BASE_CONFIG;
+var init_constants_generated = __esm({
+  "src/cli/constants.generated.ts"() {
+    "use strict";
+    init_esm_shims();
+    STATIC_CONFIG = {
+      API_URL: "https://prod-apps-storage-5cdacc06ff79.herokuapp.com/",
+      SERVER_DID: "did:key:z6Mkroj9bxTin6Z5S9qwx2G2b87NPrCX7S85FhCpmBGPcDCz",
+      PROXY_SERVER_DID: "did:key:z6MkrZSmq8D6vQG87YbjUQatXeptaCCXWdTx8fYaWxWbRUHB",
+      NETWORK_NAME: "gnosis",
+      DEFAULT_PORT: "8001",
+      DEFAULT_RPC_URL: "https://rpc.gnosischain.com",
+      PIMLICO_PROXY_URL: "https://pimlico-proxy-0a326da116f8.herokuapp.com/",
+      SERVICE_NAME: "fileverse-api",
+      LOG_LEVEL: "info",
+      FRONTEND_URL: "https://docs.fileverse.io"
+    };
+    BASE_CONFIG = STATIC_CONFIG;
+  }
+});
+
+// src/cli/constants.ts
+var init_constants = __esm({
+  "src/cli/constants.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants_generated();
+  }
+});
+
+// src/config/index.ts
+import dotenv from "dotenv";
+import path4 from "path";
+import fs2 from "fs";
+import os2 from "os";
+function getEnvPath2() {
+  if (fs2.existsSync(projectEnvPath)) {
+    return projectEnvPath;
+  }
+  return userEnvPath;
+}
+function loadConfig(override = true) {
+  const envPath = getEnvPath2();
+  dotenv.config({ path: envPath, override });
+}
+function getRuntimeConfig() {
+  return {
+    get API_KEY() {
+      return process.env.API_KEY;
+    },
+    get RPC_URL() {
+      return process.env.RPC_URL || STATIC_CONFIG.DEFAULT_RPC_URL;
+    },
+    get DB_PATH() {
+      return process.env.DB_PATH;
+    },
+    get PORT() {
+      return process.env.PORT || STATIC_CONFIG.DEFAULT_PORT;
+    },
+    get NODE_ENV() {
+      return process.env.NODE_ENV || "production";
+    },
+    get FRONTEND_URL() {
+      return process.env.FRONTEND_URL || STATIC_CONFIG.FRONTEND_URL;
+    }
+  };
+}
+var projectEnvPath, userEnvPath, config;
+var init_config = __esm({
+  "src/config/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    projectEnvPath = path4.join(process.cwd(), "config", ".env");
+    userEnvPath = path4.join(os2.homedir(), ".fileverse", ".env");
+    loadConfig(false);
+    config = {
+      ...STATIC_CONFIG,
+      get SERVICE_NAME() {
+        return STATIC_CONFIG.SERVICE_NAME;
+      },
+      get LOG_LEVEL() {
+        return STATIC_CONFIG.LOG_LEVEL;
+      },
+      get NETWORK_NAME() {
+        return STATIC_CONFIG.NETWORK_NAME;
+      },
+      get UPLOAD_SERVER_URL() {
+        return STATIC_CONFIG.API_URL;
+      },
+      get UPLOAD_SERVER_DID() {
+        return STATIC_CONFIG.SERVER_DID;
+      },
+      get API_KEY() {
+        return process.env.API_KEY;
+      },
+      get RPC_URL() {
+        return process.env.RPC_URL || STATIC_CONFIG.DEFAULT_RPC_URL;
+      },
+      get DB_PATH() {
+        return process.env.DB_PATH;
+      },
+      get PORT() {
+        return process.env.PORT || STATIC_CONFIG.DEFAULT_PORT;
+      },
+      get NODE_ENV() {
+        return process.env.NODE_ENV || "production";
+      },
+      get IP() {
+        return process.env.IP || "0.0.0.0";
+      },
+      get FRONTEND_URL() {
+        return process.env.FRONTEND_URL || STATIC_CONFIG.FRONTEND_URL;
+      }
+    };
+  }
+});
+
+// src/infra/logger.ts
+import pino from "pino";
+var isProduction, pinoInstance, createLogMethod, logger;
+var init_logger = __esm({
+  "src/infra/logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_config();
+    isProduction = config.NODE_ENV === "production";
+    pinoInstance = pino({
+      name: STATIC_CONFIG.SERVICE_NAME,
+      level: STATIC_CONFIG.LOG_LEVEL,
+      formatters: {
+        bindings: (bindings) => ({ name: bindings.name }),
+        level: (label) => ({ level: label })
+      },
+      serializers: {
+        err(err) {
+          if (!err) return err;
+          if (isProduction) {
+            return { type: err.name, message: err.message };
+          }
+          return {
+            type: err.name,
+            message: err.message,
+            stack: err.stack
+          };
+        }
+      },
+      transport: config.NODE_ENV !== "production" ? {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          translateTime: "SYS:standard",
+          ignore: "pid,hostname",
+          errorProps: "*",
+          errorLikeObjectKeys: ["err", "error"]
+        }
+      } : void 0
+    });
+    createLogMethod = (level) => {
+      return (...args) => {
+        const [first, ...rest] = args;
+        const log = pinoInstance[level].bind(pinoInstance);
+        if (typeof first === "object" && first !== null && !(first instanceof Error)) {
+          log(first, ...rest);
+          return;
+        }
+        if (rest.length > 0) {
+          const last = rest[rest.length - 1];
+          if (last instanceof Error) {
+            log({ err: last }, first, ...rest.slice(0, -1));
+            return;
+          }
+        }
+        if (first instanceof Error) {
+          log({ err: first }, first.message);
+          return;
+        }
+        log(first, ...rest);
+      };
+    };
+    logger = {
+      trace: createLogMethod("trace"),
+      debug: createLogMethod("debug"),
+      info: createLogMethod("info"),
+      warn: createLogMethod("warn"),
+      error: createLogMethod("error"),
+      fatal: createLogMethod("fatal"),
+      get level() {
+        return pinoInstance.level;
+      },
+      set level(lvl) {
+        pinoInstance.level = lvl;
+      },
+      child: pinoInstance.child.bind(pinoInstance)
+    };
+  }
+});
+
+// src/infra/asyncHandler.ts
+var init_asyncHandler = __esm({
+  "src/infra/asyncHandler.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/sdk/key-store.ts
+import { eciesDecrypt, eciesEncrypt, generateECKeyPair } from "@fileverse/crypto/ecies";
+var init_key_store = __esm({
+  "src/sdk/key-store.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/sdk/auth-token-provider.ts
+import * as ucans from "@ucans/ucans";
+var init_auth_token_provider = __esm({
+  "src/sdk/auth-token-provider.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/constants/chains.ts
+import { sepolia, gnosis } from "viem/chains";
+var init_chains = __esm({
+  "src/constants/chains.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/constants/events.ts
+var init_events = __esm({
+  "src/constants/events.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/constants/methods.ts
+var init_methods = __esm({
+  "src/constants/methods.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/constants/index.ts
+var NETWORK_NAME, UPLOAD_SERVER_URL, CHAIN_MAP, CHAIN;
+var init_constants2 = __esm({
+  "src/constants/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_config();
+    init_chains();
+    init_events();
+    init_methods();
+    NETWORK_NAME = STATIC_CONFIG.NETWORK_NAME;
+    UPLOAD_SERVER_URL = STATIC_CONFIG.API_URL;
+    CHAIN_MAP = {
+      gnosis,
+      sepolia
+    };
+    CHAIN = CHAIN_MAP[NETWORK_NAME];
+  }
+});
+
+// src/sdk/pimlico-utils.ts
+import { createPublicClient, http, hexToBigInt, toHex, toBytes } from "viem";
+import { createPimlicoClient } from "permissionless/clients/pimlico";
+import { createSmartAccountClient } from "permissionless";
+import { toSafeSmartAccount } from "permissionless/accounts";
+import { entryPoint07Address } from "viem/account-abstraction";
+import { generatePrivateKey } from "viem/accounts";
+var init_pimlico_utils = __esm({
+  "src/sdk/pimlico-utils.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants2();
+  }
+});
+
+// src/sdk/smart-agent.ts
+import { toHex as toHex2 } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+var init_smart_agent = __esm({
+  "src/sdk/smart-agent.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_pimlico_utils();
+    init_constants();
+  }
+});
+
+// src/sdk/file-encryption.ts
+import { generateRandomBytes } from "@fileverse/crypto/utils";
+var init_file_encryption = __esm({
+  "src/sdk/file-encryption.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/sdk/file-utils.ts
+import { getArgon2idHash } from "@fileverse/crypto/argon";
+import { bytesToBase64, generateRandomBytes as generateRandomBytes2 } from "@fileverse/crypto/utils";
+import { derivePBKDF2Key, encryptAesCBC } from "@fileverse/crypto/kdf";
+import { secretBoxEncrypt } from "@fileverse/crypto/nacl";
+import hkdf from "futoin-hkdf";
+import tweetnacl from "tweetnacl";
+import { fromUint8Array, toUint8Array as toUint8Array2 } from "js-base64";
+import { toAESKey, aesEncrypt } from "@fileverse/crypto/webcrypto";
+import axios2 from "axios";
+import { encodeFunctionData, parseEventLogs } from "viem";
+var init_file_utils = __esm({
+  "src/sdk/file-utils.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_file_encryption();
+    init_constants2();
+  }
+});
+
+// src/sdk/file-manager.ts
+import { fromUint8Array as fromUint8Array2, toUint8Array as toUint8Array3 } from "js-base64";
+import { generateAESKey, exportAESKey } from "@fileverse/crypto/webcrypto";
+import { markdownToYjs } from "@fileverse/content-processor";
+var init_file_manager = __esm({
+  "src/sdk/file-manager.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_file_utils();
+    init_constants();
+    init_constants2();
+    init_infra();
+  }
+});
+
+// src/domain/portal/publish.ts
+import { fromUint8Array as fromUint8Array3, toUint8Array as toUint8Array4 } from "js-base64";
+import { stringToBytes } from "viem";
+import { deriveHKDFKey } from "@fileverse/crypto/kdf";
+import { generateKeyPairFromSeed } from "@stablelib/ed25519";
+import * as ucans2 from "@ucans/ucans";
+var init_publish = __esm({
+  "src/domain/portal/publish.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_models();
+    init_infra();
+    init_key_store();
+    init_auth_token_provider();
+    init_smart_agent();
+    init_file_manager();
+    init_config();
+  }
+});
+
+// src/domain/portal/saveApiKey.ts
+function addApiKey(input) {
+  if (!input.apiKeySeed || !input.name || !input.collaboratorAddress || !input.portalAddress) {
+    throw new Error("apiKeySeed, name, collaboratorAddress, and portalAddress are required");
+  }
+  const portal = PortalsModel.findByPortalAddress(input.portalAddress);
+  if (!portal) {
+    throw new Error(`Portal with address ${input.portalAddress} does not exist`);
+  }
+  return ApiKeysModel.create(input);
+}
+var init_saveApiKey = __esm({
+  "src/domain/portal/saveApiKey.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_models();
+  }
+});
+
+// src/domain/portal/removeApiKey.ts
+var init_removeApiKey = __esm({
+  "src/domain/portal/removeApiKey.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_models();
+  }
+});
+
+// src/domain/portal/index.ts
+var init_portal = __esm({
+  "src/domain/portal/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_publish();
+    init_savePortal();
+    init_saveApiKey();
+    init_removeApiKey();
+  }
+});
+
+// src/errors/rate-limit.ts
+import { HttpRequestError } from "viem";
+var init_rate_limit = __esm({
+  "src/errors/rate-limit.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/infra/worker/eventProcessor.ts
+var init_eventProcessor = __esm({
+  "src/infra/worker/eventProcessor.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_portal();
+    init_models();
+    init_infra();
+    init_pimlico_utils();
+    init_file_utils();
+    init_constants2();
+    init_rate_limit();
+  }
+});
+
+// src/infra/worker/workerSignal.ts
+import { EventEmitter } from "events";
+var WorkerSignal, workerSignal;
+var init_workerSignal = __esm({
+  "src/infra/worker/workerSignal.ts"() {
+    "use strict";
+    init_esm_shims();
+    WorkerSignal = class extends EventEmitter {
+    };
+    workerSignal = new WorkerSignal();
+    workerSignal.setMaxListeners(20);
+  }
+});
+
+// src/infra/worker/worker.ts
+var STALE_THRESHOLD_MS;
+var init_worker = __esm({
+  "src/infra/worker/worker.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_infra();
+    init_eventProcessor();
+    init_workerSignal();
+    init_models();
+    init_rate_limit();
+    STALE_THRESHOLD_MS = 5 * 60 * 1e3;
+  }
+});
+
+// src/infra/worker/index.ts
+var init_worker2 = __esm({
+  "src/infra/worker/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_worker();
+    init_workerSignal();
+  }
+});
+
+// src/appWorker.ts
+var init_appWorker = __esm({
+  "src/appWorker.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_worker2();
+  }
+});
+
+// src/infra/reporter.ts
+var Reporter, reporter_default;
+var init_reporter = __esm({
+  "src/infra/reporter.ts"() {
+    "use strict";
+    init_esm_shims();
+    Reporter = class {
+      async reportError(message) {
+        console.error("Error reported:", message);
+      }
+    };
+    reporter_default = new Reporter();
+  }
+});
+
+// src/infra/index.ts
+var init_infra = __esm({
+  "src/infra/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_asyncHandler();
+    init_appWorker();
+    init_database();
+    init_reporter();
+  }
+});
+
+// src/infra/database/connection.ts
+import Database from "better-sqlite3";
+var DatabaseConnectionManager, databaseConnectionManager;
+var init_connection = __esm({
+  "src/infra/database/connection.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_infra();
+    DatabaseConnectionManager = class _DatabaseConnectionManager {
+      static instance;
+      db = null;
+      constructor() {
+      }
+      static getInstance() {
+        if (!_DatabaseConnectionManager.instance) {
+          _DatabaseConnectionManager.instance = new _DatabaseConnectionManager();
+        }
+        return _DatabaseConnectionManager.instance;
+      }
+      getConnection() {
+        if (!this.db) {
+          const dbPath = config.DB_PATH;
+          this.db = new Database(dbPath, {
+            verbose: config.NODE_ENV === "development" ? (msg) => logger.debug(String(msg)) : void 0
+          });
+          this.db.pragma("journal_mode = WAL");
+          this.db.pragma("foreign_keys = ON");
+          this.db.prepare("SELECT 1").get();
+          logger.info(`SQLite database connected: ${dbPath}`);
+        }
+        return this.db;
+      }
+      async close() {
+        if (this.db) {
+          this.db.close();
+          this.db = null;
+          logger.info("Database connection closed");
+        }
+      }
+      isConnected() {
+        return this.db !== null && this.db.open;
+      }
+    };
+    databaseConnectionManager = DatabaseConnectionManager.getInstance();
+  }
+});
+
+// src/domain/file/constants.ts
+var DEFAULT_LIST_LIMIT;
+var init_constants3 = __esm({
+  "src/domain/file/constants.ts"() {
+    "use strict";
+    init_esm_shims();
+    DEFAULT_LIST_LIMIT = 10;
+  }
+});
+
+// src/infra/database/query-builder.ts
+function getDb() {
+  return databaseConnectionManager.getConnection();
+}
+var QueryBuilder;
+var init_query_builder = __esm({
+  "src/infra/database/query-builder.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_connection();
+    init_constants3();
+    QueryBuilder = class {
+      static select(sql, params = []) {
+        const stmt = getDb().prepare(sql);
+        return stmt.all(params);
+      }
+      static selectOne(sql, params = []) {
+        const stmt = getDb().prepare(sql);
+        return stmt.get(params);
+      }
+      static execute(sql, params = []) {
+        const stmt = getDb().prepare(sql);
+        const result = stmt.run(params);
+        return {
+          changes: result.changes,
+          lastInsertRowid: result.lastInsertRowid
+        };
+      }
+      static transaction(callback) {
+        return getDb().transaction(callback)();
+      }
+      static paginate(sql, options = {}) {
+        let query = sql;
+        if (options.orderBy) {
+          query += ` ORDER BY ${options.orderBy} ${options.orderDirection || "ASC"}`;
+        }
+        const hasOffset = (options.offset ?? 0) > 0;
+        const limit = options.limit ?? (hasOffset ? DEFAULT_LIST_LIMIT : void 0);
+        if (limit) {
+          query += ` LIMIT ${limit}`;
+        }
+        if (hasOffset) {
+          query += ` OFFSET ${options.offset}`;
+        }
+        return query;
+      }
+    };
+  }
+});
+
+// src/infra/database/index.ts
+function getDb2() {
+  return databaseConnectionManager.getConnection();
+}
+var database_default;
+var init_database = __esm({
+  "src/infra/database/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_connection();
+    init_query_builder();
+    database_default = getDb2;
+  }
+});
+
+// src/infra/database/models/files.model.ts
+import { uuidv7 } from "uuidv7";
+var init_files_model = __esm({
+  "src/infra/database/models/files.model.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_database();
+  }
+});
+
+// src/infra/database/models/portals.model.ts
+import { uuidv7 as uuidv72 } from "uuidv7";
+var PortalsModel;
+var init_portals_model = __esm({
+  "src/infra/database/models/portals.model.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_database();
+    PortalsModel = class {
+      static TABLE = "portals";
+      static findByPortalAddress(portalAddress) {
+        const sql = `SELECT _id, portalAddress, portalSeed, ownerAddress, createdAt, updatedAt FROM ${this.TABLE} WHERE portalAddress = ?`;
+        return QueryBuilder.selectOne(sql, [portalAddress]);
+      }
+      static create(input) {
+        const _id = uuidv72();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const sql = `INSERT INTO ${this.TABLE} (_id, portalAddress, portalSeed, ownerAddress, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, ?)`;
+        QueryBuilder.execute(sql, [_id, input.portalAddress, input.portalSeed, input.ownerAddress, now, now]);
+        const created = this.findByPortalAddress(input.portalAddress);
+        if (!created) {
+          throw new Error("Failed to create portal");
+        }
+        return created;
+      }
+      static update(portalAddress, input) {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const keys = [];
+        const values = [];
+        for (const [k, v] of Object.entries(input)) {
+          if (v !== void 0) {
+            keys.push(`${k} = ?`);
+            values.push(v);
+          }
+        }
+        keys.push("updatedAt = ?");
+        values.push(now);
+        const updateChain = keys.join(", ");
+        const sql = `UPDATE ${this.TABLE} SET ${updateChain} WHERE portalAddress = ?`;
+        values.push(portalAddress);
+        QueryBuilder.execute(sql, values);
+        const updated = this.findByPortalAddress(portalAddress);
+        if (!updated) {
+          throw new Error("Failed to update portal");
+        }
+        return updated;
+      }
+      static upsert(input) {
+        const existing = this.findByPortalAddress(input.portalAddress);
+        if (existing) {
+          return this.update(input.portalAddress, {
+            portalSeed: input.portalSeed,
+            ownerAddress: input.ownerAddress
+          });
+        }
+        return this.create(input);
+      }
+    };
+  }
+});
+
+// src/infra/database/models/apikeys.model.ts
+import { uuidv7 as uuidv73 } from "uuidv7";
+var ApiKeysModel;
+var init_apikeys_model = __esm({
+  "src/infra/database/models/apikeys.model.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_database();
+    ApiKeysModel = class {
+      static TABLE = "api_keys";
+      static create(input) {
+        const _id = uuidv73();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const sql = `INSERT INTO ${this.TABLE} (_id, apiKeySeed, name, collaboratorAddress, portalAddress, createdAt) 
+    VALUES (?, ?, ?, ?, ?, ?)`;
+        const result = QueryBuilder.execute(sql, [
+          _id,
+          input.apiKeySeed,
+          input.name,
+          input.collaboratorAddress,
+          input.portalAddress,
+          now
+        ]);
+        if (result.changes === 0) {
+          throw new Error("Failed to create API key");
+        }
+        const created = this.findById(_id);
+        if (!created) {
+          throw new Error("Failed to create API key");
+        }
+        return created;
+      }
+      static findById(_id) {
+        const sql = `SELECT _id, apiKeySeed, name, collaboratorAddress, portalAddress, createdAt, isDeleted FROM ${this.TABLE} WHERE _id = ? AND isDeleted = 0`;
+        return QueryBuilder.selectOne(sql, [_id]);
+      }
+      static findByCollaboratorAddress(collaboratorAddress) {
+        const sql = `SELECT _id, apiKeySeed, name, collaboratorAddress, portalAddress, createdAt, isDeleted FROM ${this.TABLE} WHERE collaboratorAddress = ? AND isDeleted = 0 LIMIT 1`;
+        return QueryBuilder.selectOne(sql, [collaboratorAddress]);
+      }
+      static delete(_id) {
+        const sql = `UPDATE ${this.TABLE} SET isDeleted = 1 WHERE _id = ?`;
+        QueryBuilder.execute(sql, [_id]);
+      }
+      static findByPortalAddress(portalAddress) {
+        const sql = `SELECT _id, apiKeySeed, name, collaboratorAddress, portalAddress, createdAt, isDeleted FROM ${this.TABLE} WHERE portalAddress = ? AND isDeleted = 0`;
+        return QueryBuilder.selectOne(sql, [portalAddress]);
+      }
+      static findByApiKey(apiKey) {
+        const sql = `SELECT _id, apiKeySeed, name, collaboratorAddress, portalAddress, createdAt, isDeleted FROM ${this.TABLE} WHERE apiKeySeed = ? AND isDeleted = 0`;
+        return QueryBuilder.selectOne(sql, [apiKey]);
+      }
+    };
+  }
+});
+
+// src/infra/database/models/folders.model.ts
+var init_folders_model = __esm({
+  "src/infra/database/models/folders.model.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_database();
+  }
+});
+
+// src/infra/database/models/events.model.ts
+import { uuidv7 as uuidv74 } from "uuidv7";
+var init_events_model = __esm({
+  "src/infra/database/models/events.model.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_database();
+    init_workerSignal();
+  }
+});
+
+// src/infra/database/models/index.ts
+var init_models = __esm({
+  "src/infra/database/models/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_files_model();
+    init_portals_model();
+    init_apikeys_model();
+    init_folders_model();
+    init_events_model();
+  }
+});
+
+// src/domain/portal/savePortal.ts
+function savePortal(input) {
+  if (!input.portalAddress || !input.portalSeed || !input.ownerAddress) {
+    throw new Error("portalAddress, portalSeed, and ownerAddress are required");
+  }
+  return PortalsModel.upsert(input);
+}
+var init_savePortal = __esm({
+  "src/domain/portal/savePortal.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_models();
+  }
+});
+
+// src/infra/database/migrations/index.ts
+var migrations_exports = {};
+__export(migrations_exports, {
+  runMigrations: () => runMigrations
+});
+function runMigrations() {
+  const db = database_default();
+  db.exec(STABLE_SCHEMA);
+  logger.debug("Database schema ready");
+}
+var STABLE_SCHEMA;
+var init_migrations = __esm({
+  "src/infra/database/migrations/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_database();
+    init_infra();
+    STABLE_SCHEMA = `
+CREATE TABLE IF NOT EXISTS files (
+  _id TEXT PRIMARY KEY,
+  ddocId TEXT NOT NULL,
+  title TEXT NOT NULL,
+  content TEXT NOT NULL,
+  localVersion INTEGER NOT NULL DEFAULT 1,
+  onchainVersion INTEGER NOT NULL DEFAULT 0,
+  syncStatus TEXT NOT NULL DEFAULT 'pending',
+  createdAt DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updatedAt DATETIME DEFAULT CURRENT_TIMESTAMP,
+  isDeleted INTEGER NOT NULL DEFAULT 0,
+  portalAddress TEXT NOT NULL,
+  metadata TEXT DEFAULT '{}',
+  onChainFileId INTEGER,
+  commentKey TEXT,
+  linkKey TEXT,
+  linkKeyNonce TEXT,
+  link TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_files_createdAt ON files(createdAt);
+CREATE INDEX IF NOT EXISTS idx_files_syncStatus ON files(syncStatus);
+CREATE INDEX IF NOT EXISTS idx_files_title ON files(title);
+CREATE INDEX IF NOT EXISTS idx_files_portalAddress ON files(portalAddress);
+
+CREATE TABLE IF NOT EXISTS portals (
+  _id TEXT PRIMARY KEY,
+  portalAddress TEXT NOT NULL UNIQUE,
+  portalSeed TEXT NOT NULL UNIQUE,
+  ownerAddress TEXT NOT NULL,
+  createdAt DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updatedAt DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS api_keys (
+  _id TEXT PRIMARY KEY,
+  apiKeySeed TEXT NOT NULL UNIQUE,
+  name TEXT NOT NULL,
+  collaboratorAddress TEXT NOT NULL UNIQUE,
+  portalAddress TEXT NOT NULL,
+  createdAt DATETIME DEFAULT CURRENT_TIMESTAMP,
+  isDeleted INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS events (
+  _id TEXT PRIMARY KEY,
+  type TEXT NOT NULL CHECK (type IN ('create', 'update', 'delete')),
+  timestamp INTEGER NOT NULL,
+  fileId TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'processing', 'processed', 'failed')),
+  retryCount INTEGER NOT NULL DEFAULT 0,
+  lastError TEXT,
+  lockedAt INTEGER,
+  nextRetryAt INTEGER,
+  userOpHash TEXT,
+  pendingPayload TEXT,
+  portalAddress TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_events_pending_eligible ON events (status, nextRetryAt, timestamp) WHERE status = 'pending';
+CREATE INDEX IF NOT EXISTS idx_events_file_pending_ts ON events (fileId, status, timestamp) WHERE status = 'pending';
+CREATE INDEX IF NOT EXISTS idx_events_processing_locked ON events (status, lockedAt) WHERE status = 'processing';
+CREATE INDEX IF NOT EXISTS idx_events_failed_portal ON events (portalAddress, status) WHERE status = 'failed';
+
+CREATE TABLE IF NOT EXISTS folders (
+  _id TEXT PRIMARY KEY,
+  onchainFileId INTEGER NOT NULL,
+  folderId TEXT NOT NULL,
+  folderRef TEXT NOT NULL,
+  folderName TEXT NOT NULL,
+  portalAddress TEXT NOT NULL,
+  metadataIPFSHash TEXT NOT NULL,
+  contentIPFSHash TEXT NOT NULL,
+  isDeleted INTEGER NOT NULL DEFAULT 0,
+  lastTransactionHash TEXT,
+  lastTransactionBlockNumber INTEGER NOT NULL,
+  lastTransactionBlockTimestamp INTEGER NOT NULL,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+CREATE INDEX IF NOT EXISTS idx_folders_folderRef_folderId ON folders(folderRef, folderId);
+CREATE INDEX IF NOT EXISTS idx_folders_folderRef ON folders(folderRef);
+CREATE INDEX IF NOT EXISTS idx_folders_created_at ON folders(created_at);
+`;
+  }
+});
+
+// src/cli/index.ts
+init_esm_shims();
+import { Command } from "commander";
+
+// src/cli/fetch-api-key.ts
+init_esm_shims();
+init_constants();
+import axios from "axios";
+import { toUint8Array } from "js-base64";
+import { sha256 } from "viem";
+var fetchApiKeyData = async (apiKey) => {
+  try {
+    const keyHash = sha256(toUint8Array(apiKey));
+    const fullUrl = BASE_CONFIG.API_URL + `api-access/${keyHash}`;
+    const response = await axios.get(fullUrl);
+    const { encryptedKeyMaterial, encryptedAppMaterial, id } = response.data;
+    return { encryptedKeyMaterial, encryptedAppMaterial, id };
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      if (error.response?.status === 401) {
+        throw new Error("Invalid API key");
+      }
+      if (error.response?.status === 404) {
+        throw new Error("API key not found");
+      }
+      if (error.code === "ECONNREFUSED") {
+        throw new Error(`Cannot connect to server at ${BASE_CONFIG.API_URL}`);
+      }
+      throw new Error(`Server error: ${error.response?.data?.message || error.message}`);
+    }
+    throw error;
+  }
+};
+
+// src/cli/scaffold-config.ts
+init_esm_shims();
+init_constants();
+import fs from "fs";
+import path2 from "path";
+import os from "os";
+function getFileverseDir() {
+  return path2.join(os.homedir(), ".fileverse");
+}
+function getDefaultDbPath() {
+  return path2.join(getFileverseDir(), "fileverse-api.db");
+}
+function getEnvPath() {
+  return path2.join(getFileverseDir(), ".env");
+}
+function scaffoldConfig(options = {}) {
+  const fileverseDir = getFileverseDir();
+  const envPath = getEnvPath();
+  if (!fs.existsSync(fileverseDir)) {
+    fs.mkdirSync(fileverseDir, { recursive: true });
+  }
+  const dbPath = options.dbPath || getDefaultDbPath();
+  const dbDir = path2.dirname(dbPath);
+  if (!fs.existsSync(dbDir)) {
+    fs.mkdirSync(dbDir, { recursive: true });
+  }
+  const envContent = `API_KEY=${options.apiKey}
+RPC_URL=${options.rpcUrl || STATIC_CONFIG.DEFAULT_RPC_URL}
+DB_PATH=${dbPath}
+PORT=${options.port || STATIC_CONFIG.DEFAULT_PORT}
+`;
+  fs.writeFileSync(envPath, envContent, "utf-8");
+  return envPath;
+}
+
+// src/cli/process-manager.ts
+init_esm_shims();
+import { spawn } from "child_process";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { existsSync } from "fs";
+var managedProcesses = [];
+function getDistDir() {
+  const __dirname2 = path3.dirname(fileURLToPath2(import.meta.url));
+  return path3.resolve(__dirname2, "..");
+}
+function isDevMode() {
+  const distDir = getDistDir();
+  return existsSync(path3.join(distDir, "index.ts"));
+}
+function prefixOutput(name, data) {
+  const lines = data.toString().split("\n").filter(Boolean);
+  for (const line of lines) {
+    console.log(`[${name}] ${line}`);
+  }
+}
+function spawnProcess(name, executable, scriptPath, extraEnv) {
+  const child = spawn(executable, [scriptPath], {
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, NODE_ENV: executable === "tsx" ? "development" : "production", ...extraEnv },
+    detached: false
+  });
+  child.stdout?.on("data", (data) => prefixOutput(name, data));
+  child.stderr?.on("data", (data) => prefixOutput(name, data));
+  child.on("error", (error) => {
+    console.error(`[${name}] Process error:`, error.message);
+  });
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      console.log(`[${name}] Process terminated by signal ${signal}`);
+    } else if (code !== 0) {
+      console.error(`[${name}] Process exited with code ${code}`);
+    }
+  });
+  managedProcesses.push({ name, process: child });
+  return child;
+}
+function startApiServer() {
+  const distDir = getDistDir();
+  const dev = isDevMode();
+  const executable = dev ? "tsx" : "node";
+  const apiPath = path3.join(distDir, dev ? "index.ts" : "index.js");
+  return spawnProcess("API", executable, apiPath, { IS_CLI: "1" });
+}
+function startWorker() {
+  const distDir = getDistDir();
+  const dev = isDevMode();
+  const executable = dev ? "tsx" : "node";
+  const workerPath = path3.join(distDir, dev ? "worker.ts" : "worker.js");
+  return spawnProcess("WORKER", executable, workerPath);
+}
+function startAll() {
+  const api = startApiServer();
+  const worker = startWorker();
+  return { api, worker };
+}
+function setupShutdownHandlers() {
+  const shutdown = (signal) => {
+    console.log(`
+Received ${signal}, shutting down...`);
+    for (const { name, process: child } of managedProcesses) {
+      if (child.pid && !child.killed) {
+        console.log(`[${name}] Stopping...`);
+        child.kill("SIGTERM");
+      }
+    }
+    setTimeout(() => {
+      for (const { name, process: child } of managedProcesses) {
+        if (child.pid && !child.killed) {
+          console.log(`[${name}] Force killing...`);
+          child.kill("SIGKILL");
+        }
+      }
+      process.exit(0);
+    }, 5e3);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+}
+function waitForProcesses() {
+  return new Promise((resolve) => {
+    const checkInterval = setInterval(() => {
+      const allExited = managedProcesses.every(({ process: child }) => child.exitCode !== null || child.killed);
+      if (allExited) {
+        clearInterval(checkInterval);
+        resolve();
+      }
+    }, 1e3);
+  });
+}
+
+// src/cli/prompts.ts
+init_esm_shims();
+init_constants();
+init_config();
+import prompts from "prompts";
+var promptForConfig = async (existingOptions = {}) => {
+  const savedConfig = getRuntimeConfig();
+  const questions = [];
+  if (!existingOptions.apiKey) {
+    questions.push({
+      type: "text",
+      name: "apiKey",
+      message: "Enter your API Key:",
+      validate: (value) => value.length > 0 || "API Key is required",
+      initial: savedConfig.API_KEY || ""
+    });
+  }
+  if (!existingOptions.rpcUrl) {
+    questions.push({
+      type: "text",
+      name: "rpcUrl",
+      message: "Enter RPC URL (press Enter for default):",
+      initial: savedConfig.RPC_URL || STATIC_CONFIG.DEFAULT_RPC_URL
+    });
+  }
+  if (questions.length === 0) {
+    return {
+      apiKey: existingOptions.apiKey,
+      rpcUrl: existingOptions.rpcUrl || STATIC_CONFIG.DEFAULT_RPC_URL
+    };
+  }
+  const response = await prompts(questions, {
+    onCancel: () => {
+      console.log("\nSetup cancelled.");
+      process.exit(1);
+    }
+  });
+  return {
+    apiKey: existingOptions.apiKey || response.apiKey,
+    rpcUrl: existingOptions.rpcUrl || response.rpcUrl || STATIC_CONFIG.DEFAULT_RPC_URL
+  };
+};
+function needsPrompting(options) {
+  return !options.apiKey;
+}
+
+// src/cli/index.ts
+init_config();
+
+// src/init/index.ts
+init_esm_shims();
+init_savePortal();
+init_saveApiKey();
+init_apikeys_model();
+init_infra();
+import { deriveHKDFKey as deriveHKDFKey2 } from "@fileverse/crypto/hkdf";
+import { toUint8Array as toUint8Array5 } from "js-base64";
+import { stringToBytes as stringToBytes2 } from "viem";
+import { toAESKey as toAESKey2, aesDecrypt } from "@fileverse/crypto/webcrypto";
+var SAVED_DATA_ENCRYPTION_KEY_INFO = "SAVED_DATA_ENCRYPTION_KEY";
+function initializeWithData(data) {
+  const { keyMaterial, appMaterial } = data;
+  savePortal({
+    portalAddress: appMaterial.portalAddress,
+    portalSeed: appMaterial.portalSeed,
+    ownerAddress: appMaterial.ownerAddress
+  });
+  const existingApiKey = ApiKeysModel.findByApiKey(keyMaterial.apiKeySeed);
+  if (!existingApiKey) {
+    addApiKey({
+      apiKeySeed: keyMaterial.apiKeySeed,
+      name: keyMaterial.name,
+      collaboratorAddress: keyMaterial.collaboratorAddress,
+      portalAddress: appMaterial.portalAddress
+    });
+    return { portalSaved: true, apiKeySaved: true };
+  }
+  return { portalSaved: true, apiKeySaved: false };
+}
+var getAesKeyFromApiKey = async (apiKey) => {
+  const rawSecret = deriveHKDFKey2(
+    toUint8Array5(apiKey),
+    new Uint8Array([0]),
+    stringToBytes2(SAVED_DATA_ENCRYPTION_KEY_INFO)
+  );
+  return await toAESKey2(rawSecret);
+};
+var bytestToJSON = (bytes) => {
+  return JSON.parse(new TextDecoder().decode(bytes));
+};
+var decryptSavedData = async (apiKey, encryptedData) => {
+  const aesKey = await getAesKeyFromApiKey(apiKey);
+  const decryptedBytes = await aesDecrypt(aesKey, toUint8Array5(encryptedData));
+  const data = bytestToJSON(decryptedBytes);
+  return data;
+};
+
+// src/cli/index.ts
+var program = new Command().name("fileverse-api").description("Run the Fileverse API server").version("0.0.1").option("--apiKey <key>", "API key for authentication").option("--rpcUrl <url>", "RPC URL for blockchain connection").option("--port <port>", "Port to run the server on", "8001").option("--db <path>", "Database path").action(async (options) => {
+  try {
+    console.log("Fileverse API - Starting initialization...\n");
+    if (needsPrompting(options)) {
+      const prompted = await promptForConfig({
+        apiKey: options.apiKey,
+        rpcUrl: options.rpcUrl
+      });
+      options.apiKey = prompted.apiKey;
+      options.rpcUrl = prompted.rpcUrl;
+    }
+    const data = await fetchApiKeyData(options.apiKey);
+    console.log("\u2713 API key data retrieved\n");
+    const keyMaterial = await decryptSavedData(options.apiKey, data.encryptedKeyMaterial);
+    const appMaterial = await decryptSavedData(options.apiKey, data.encryptedAppMaterial);
+    console.log("Setting up configuration...");
+    const envPath = scaffoldConfig({
+      dbPath: options.db,
+      port: options.port,
+      apiKey: options.apiKey,
+      rpcUrl: options.rpcUrl
+    });
+    loadConfig();
+    console.log(`\u2713 Configuration saved to ${envPath}
+`);
+    const { runMigrations: runMigrations2 } = await Promise.resolve().then(() => (init_migrations(), migrations_exports));
+    runMigrations2();
+    console.log("\u2713 Database migrations complete");
+    const result = initializeWithData({
+      keyMaterial,
+      appMaterial,
+      id: data.id
+    });
+    console.log("\u2713 Portal saved");
+    if (result.apiKeySaved) {
+      console.log("\u2713 API key saved");
+    } else {
+      console.log("\u2713 API key already exists");
+    }
+    console.log("\nStarting services...");
+    setupShutdownHandlers();
+    startAll();
+    console.log(`
+\u2713 Fileverse API is running!
+
+  API Server: http://127.0.0.1:${options.port}
+  Worker:     Active
+
+  MCP:  Add this to your AI agent's MCP config (e.g. .claude/mcp.json):
+
+        {
+          "mcpServers": {
+            "fileverse-api": {
+              "command": "fileverse-api-mcp"
+            }
+          }
+        }
+
+        Config is auto-read from ~/.fileverse/.env \u2014 no env vars needed.
+
+Press Ctrl+C to stop.
+`);
+    await waitForProcesses();
+  } catch (error) {
+    console.error("\n\u274C Error:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=index.js.map