@fileverse/api 0.0.2 → 0.0.4

package/dist/commands/index.js

@@ -1,31 +1,58 @@
 #!/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 });
+};
 
-// src/commands/index.ts
-import { Command as Command9 } from "commander";
-
-// src/config/index.ts
-import dotenv from "dotenv";
+// node_modules/tsup/assets/esm_shims.js
 import path from "path";
-import fs from "fs";
-import os from "os";
+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 = {
-  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"
-};
+var STATIC_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"
+    };
+  }
+});
+
+// src/cli/constants.ts
+var init_constants = __esm({
+  "src/cli/constants.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants_generated();
+  }
+});
 
 // src/config/index.ts
-var projectEnvPath = path.join(process.cwd(), "config", ".env");
-var userEnvPath = path.join(os.homedir(), ".fileverse", ".env");
+import dotenv from "dotenv";
+import path2 from "path";
+import fs from "fs";
+import os from "os";
 function getEnvPath() {
   if (fs.existsSync(projectEnvPath)) {
     return projectEnvPath;
@@ -36,7 +63,6 @@ function loadConfig(override = true) {
   const envPath = getEnvPath();
   dotenv.config({ path: envPath, override });
 }
-loadConfig(false);
 function getRuntimeConfig() {
   return {
     get API_KEY() {
@@ -62,435 +88,538 @@ function getRuntimeConfig() {
     }
   };
 }
-var 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 DATABASE_URL() {
-    return process.env.DATABASE_URL;
-  },
-  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;
+var projectEnvPath, userEnvPath, config;
+var init_config = __esm({
+  "src/config/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    projectEnvPath = path2.join(process.cwd(), "config", ".env");
+    userEnvPath = path2.join(os.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 DATABASE_URL() {
+        return process.env.DATABASE_URL;
+      },
+      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 = config.NODE_ENV === "production";
-var 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
+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);
       };
-    }
-  },
-  transport: config.NODE_ENV !== "production" ? {
-    target: "pino-pretty",
-    options: {
-      colorize: true,
-      translateTime: "SYS:standard",
-      ignore: "pid,hostname",
-      errorProps: "*",
-      errorLikeObjectKeys: ["err", "error"]
-    }
-  } : void 0
+    };
+    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)
+    };
+  }
 });
-var 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);
-  };
-};
-var 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/database/adapters/sqlite-adapter.ts
-import Database from "better-sqlite3";
+// src/infra/asyncHandler.ts
+var init_asyncHandler = __esm({
+  "src/infra/asyncHandler.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
 
 // src/domain/file/constants.ts
-var DEFAULT_LIST_LIMIT = 10;
+var DEFAULT_LIST_LIMIT;
+var init_constants2 = __esm({
+  "src/domain/file/constants.ts"() {
+    "use strict";
+    init_esm_shims();
+    DEFAULT_LIST_LIMIT = 10;
+  }
+});
 
 // src/infra/database/query-builder.ts
-var QueryBuilder = class {
-  static async select(sql, params = []) {
-    return getAdapterSync().select(sql, params);
-  }
-  static async selectOne(sql, params = []) {
-    return getAdapterSync().selectOne(sql, params);
-  }
-  static async execute(sql, params = []) {
-    return getAdapterSync().execute(sql, params);
-  }
-  static async transaction(callback) {
-    return getAdapterSync().transaction(callback);
+var QueryBuilder;
+var init_query_builder = __esm({
+  "src/infra/database/query-builder.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_connection();
+    init_constants2();
+    QueryBuilder = class {
+      static async select(sql, params = []) {
+        const adapter2 = await getAdapter();
+        return adapter2.select(sql, params);
+      }
+      static async selectOne(sql, params = []) {
+        const adapter2 = await getAdapter();
+        return adapter2.selectOne(sql, params);
+      }
+      static async execute(sql, params = []) {
+        const adapter2 = await getAdapter();
+        return adapter2.execute(sql, params);
+      }
+      static async transaction(callback) {
+        const adapter2 = await getAdapter();
+        return adapter2.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;
+      }
+    };
   }
-  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
+var closeDatabase;
+var init_database = __esm({
+  "src/infra/database/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_connection();
+    init_query_builder();
+    closeDatabase = async () => {
+      await closeAdapter();
+    };
   }
-};
+});
 
 // src/infra/database/models/files.model.ts
 import { uuidv7 } from "uuidv7";
-var FilesModel = class {
-  static TABLE = "files";
-  static parseFile(fileRaw) {
-    let metadata = {};
-    try {
-      if (fileRaw.metadata) {
-        metadata = typeof fileRaw.metadata === "string" ? JSON.parse(fileRaw.metadata) : fileRaw.metadata;
+var FilesModel;
+var init_files_model = __esm({
+  "src/infra/database/models/files.model.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_database();
+    FilesModel = class {
+      static TABLE = "files";
+      static parseFile(fileRaw) {
+        let metadata = {};
+        try {
+          if (fileRaw.metadata) {
+            metadata = typeof fileRaw.metadata === "string" ? JSON.parse(fileRaw.metadata) : fileRaw.metadata;
+          }
+        } catch (e) {
+          metadata = {};
+        }
+        return {
+          _id: fileRaw._id,
+          ddocId: fileRaw.ddocId,
+          title: fileRaw.title,
+          content: fileRaw.content,
+          localVersion: fileRaw.localVersion,
+          onchainVersion: fileRaw.onchainVersion,
+          syncStatus: fileRaw.syncStatus,
+          isDeleted: fileRaw.isDeleted,
+          onChainFileId: fileRaw.onChainFileId ?? null,
+          portalAddress: fileRaw.portalAddress,
+          metadata: metadata || {},
+          createdAt: fileRaw.createdAt,
+          updatedAt: fileRaw.updatedAt,
+          linkKey: fileRaw.linkKey,
+          linkKeyNonce: fileRaw.linkKeyNonce,
+          commentKey: fileRaw.commentKey,
+          link: fileRaw.link
+        };
       }
-    } catch (e) {
-      metadata = {};
-    }
-    return {
-      _id: fileRaw._id,
-      ddocId: fileRaw.ddocId,
-      title: fileRaw.title,
-      content: fileRaw.content,
-      localVersion: fileRaw.localVersion,
-      onchainVersion: fileRaw.onchainVersion,
-      syncStatus: fileRaw.syncStatus,
-      isDeleted: fileRaw.isDeleted,
-      onChainFileId: fileRaw.onChainFileId ?? null,
-      portalAddress: fileRaw.portalAddress,
-      metadata: metadata || {},
-      createdAt: fileRaw.createdAt,
-      updatedAt: fileRaw.updatedAt,
-      linkKey: fileRaw.linkKey,
-      linkKeyNonce: fileRaw.linkKeyNonce,
-      commentKey: fileRaw.commentKey,
-      link: fileRaw.link
-    };
-  }
-  static async findAll(portalAddress, limit, skip) {
-    const whereClause = "isDeleted = 0 AND portalAddress = ?";
-    const params = [portalAddress];
-    const countSql = `
+      static async findAll(portalAddress, limit, skip) {
+        const whereClause = "isDeleted = 0 AND portalAddress = ?";
+        const params = [portalAddress];
+        const countSql = `
       SELECT COUNT(*) as count
       FROM ${this.TABLE}
       WHERE ${whereClause}
     `;
-    const totalResult = await QueryBuilder.selectOne(countSql, params);
-    const total = totalResult?.count || 0;
-    const sql = `
+        const totalResult = await QueryBuilder.selectOne(countSql, params);
+        const total = totalResult?.count || 0;
+        const sql = `
       SELECT *
       FROM ${this.TABLE}
       WHERE ${whereClause}
     `;
-    const completeSql = QueryBuilder.paginate(sql, {
-      limit,
-      offset: skip,
-      orderBy: "createdAt",
-      orderDirection: "DESC"
-    });
-    const filesRaw = await QueryBuilder.select(completeSql, params);
-    const files = filesRaw.map(this.parseFile);
-    const hasNext = skip !== void 0 && limit !== void 0 ? skip + limit < total : false;
-    return { files, total, hasNext };
-  }
-  static async findById(_id, portalAddress) {
-    const sql = `
+        const completeSql = QueryBuilder.paginate(sql, {
+          limit,
+          offset: skip,
+          orderBy: "createdAt",
+          orderDirection: "DESC"
+        });
+        const filesRaw = await QueryBuilder.select(completeSql, params);
+        const files = filesRaw.map(this.parseFile);
+        const hasNext = skip !== void 0 && limit !== void 0 ? skip + limit < total : false;
+        return { files, total, hasNext };
+      }
+      static async findById(_id, portalAddress) {
+        const sql = `
       SELECT *
       FROM ${this.TABLE}
       WHERE _id = ? AND isDeleted = 0 AND portalAddress = ?
     `;
-    const result = await QueryBuilder.selectOne(sql, [_id, portalAddress]);
-    return result ? this.parseFile(result) : void 0;
-  }
-  static async findByIdIncludingDeleted(_id) {
-    const sql = `
+        const result = await QueryBuilder.selectOne(sql, [_id, portalAddress]);
+        return result ? this.parseFile(result) : void 0;
+      }
+      static async findByIdIncludingDeleted(_id) {
+        const sql = `
       SELECT *
       FROM ${this.TABLE}
       WHERE _id = ?
     `;
-    const result = await QueryBuilder.selectOne(sql, [_id]);
-    return result ? this.parseFile(result) : void 0;
-  }
-  static async findByIdExcludingDeleted(_id) {
-    const sql = `
+        const result = await QueryBuilder.selectOne(sql, [_id]);
+        return result ? this.parseFile(result) : void 0;
+      }
+      static async findByIdExcludingDeleted(_id) {
+        const sql = `
       SELECT *
       FROM ${this.TABLE}
       WHERE _id = ? AND isDeleted = 0
     `;
-    const result = await QueryBuilder.selectOne(sql, [_id]);
-    return result ? this.parseFile(result) : void 0;
-  }
-  static async findByDDocId(ddocId, portalAddress) {
-    const sql = `
+        const result = await QueryBuilder.selectOne(sql, [_id]);
+        return result ? this.parseFile(result) : void 0;
+      }
+      static async findByDDocId(ddocId, portalAddress) {
+        const sql = `
       SELECT *
       FROM ${this.TABLE}
       WHERE ddocId = ? AND isDeleted = 0 AND portalAddress = ?
     `;
-    const result = await QueryBuilder.selectOne(sql, [ddocId, portalAddress]);
-    return result ? this.parseFile(result) : void 0;
-  }
-  static async searchByTitle(searchTerm, portalAddress, limit, skip) {
-    const sql = `
+        const result = await QueryBuilder.selectOne(sql, [ddocId, portalAddress]);
+        return result ? this.parseFile(result) : void 0;
+      }
+      static async searchByTitle(searchTerm, portalAddress, limit, skip) {
+        const sql = `
       SELECT *
       FROM ${this.TABLE}
       WHERE LOWER(title) LIKE LOWER(?) AND isDeleted = 0 AND portalAddress = ?
     `;
-    const completeSql = QueryBuilder.paginate(sql, {
-      limit,
-      offset: skip,
-      orderBy: "createdAt",
-      orderDirection: "DESC"
-    });
-    const filesRaw = await QueryBuilder.select(completeSql, [`%${searchTerm}%`, portalAddress]);
-    return filesRaw.map(this.parseFile);
-  }
-  static async create(input) {
-    const _id = uuidv7();
-    const sql = `
+        const completeSql = QueryBuilder.paginate(sql, {
+          limit,
+          offset: skip,
+          orderBy: "createdAt",
+          orderDirection: "DESC"
+        });
+        const filesRaw = await QueryBuilder.select(completeSql, [`%${searchTerm}%`, portalAddress]);
+        return filesRaw.map(this.parseFile);
+      }
+      static async create(input) {
+        const _id = uuidv7();
+        const sql = `
       INSERT INTO ${this.TABLE}
       (_id, title, content, ddocId, portalAddress)
       VALUES (?, ?, ?, ?, ?)
     `;
-    await QueryBuilder.execute(sql, [_id, input.title, input.content, input.ddocId, input.portalAddress]);
-    const created = await this.findById(_id, input.portalAddress);
-    if (!created) {
-      throw new Error("Failed to create file");
-    }
-    return created;
-  }
-  static async update(_id, payload, portalAddress) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const keys = [];
-    const values = [];
-    for (const [k, v] of Object.entries(payload)) {
-      if (v !== void 0) {
-        if (k === "metadata" && typeof v === "object") {
-          keys.push(`${k} = ?`);
-          values.push(JSON.stringify(v));
-        } else {
-          keys.push(`${k} = ?`);
-          values.push(v);
+        await QueryBuilder.execute(sql, [_id, input.title, input.content, input.ddocId, input.portalAddress]);
+        const created = await this.findById(_id, input.portalAddress);
+        if (!created) {
+          throw new Error("Failed to create file");
         }
+        return created;
       }
-    }
-    keys.push("updatedAt = ?");
-    values.push(now, _id, portalAddress);
-    const updateChain = keys.join(", ");
-    const sql = `UPDATE ${this.TABLE} SET ${updateChain} WHERE _id = ? AND portalAddress = ?`;
-    await QueryBuilder.execute(sql, values);
-    const updated = await this.findById(_id, portalAddress);
-    if (!updated) {
-      throw new Error("Failed to update file");
-    }
-    return updated;
-  }
-  static async softDelete(_id) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const sql = `
+      static async update(_id, payload, portalAddress) {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const keys = [];
+        const values = [];
+        for (const [k, v] of Object.entries(payload)) {
+          if (v !== void 0) {
+            if (k === "metadata" && typeof v === "object") {
+              keys.push(`${k} = ?`);
+              values.push(JSON.stringify(v));
+            } else {
+              keys.push(`${k} = ?`);
+              values.push(v);
+            }
+          }
+        }
+        keys.push("updatedAt = ?");
+        values.push(now, _id, portalAddress);
+        const updateChain = keys.join(", ");
+        const sql = `UPDATE ${this.TABLE} SET ${updateChain} WHERE _id = ? AND portalAddress = ?`;
+        await QueryBuilder.execute(sql, values);
+        const updated = await this.findById(_id, portalAddress);
+        if (!updated) {
+          throw new Error("Failed to update file");
+        }
+        return updated;
+      }
+      static async softDelete(_id) {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const sql = `
       UPDATE ${this.TABLE}
       SET isDeleted = 1, syncStatus = 'pending', updatedAt = ?
       WHERE _id = ?
     `;
-    await QueryBuilder.execute(sql, [now, _id]);
-    const deleted = await this.findByIdIncludingDeleted(_id);
-    if (!deleted) {
-      throw new Error("Failed to delete file");
-    }
-    return deleted;
+        await QueryBuilder.execute(sql, [now, _id]);
+        const deleted = await this.findByIdIncludingDeleted(_id);
+        if (!deleted) {
+          throw new Error("Failed to delete file");
+        }
+        return deleted;
+      }
+    };
   }
-};
+});
 
 // src/infra/database/models/portals.model.ts
 import { uuidv7 as uuidv72 } from "uuidv7";
+var init_portals_model = __esm({
+  "src/infra/database/models/portals.model.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_database();
+  }
+});
 
 // src/infra/database/models/apikeys.model.ts
 import { uuidv7 as uuidv73 } from "uuidv7";
-var ApiKeysModel = class {
-  static TABLE = "api_keys";
-  static async create(input) {
-    const _id = uuidv73();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const sql = `INSERT INTO ${this.TABLE} (_id, apiKeySeed, name, collaboratorAddress, portalAddress, createdAt)
+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 async 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 = await 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 = await this.findById(_id);
-    if (!created) {
-      throw new Error("Failed to create API key");
-    }
-    return created;
-  }
-  static async 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 async 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 async delete(_id) {
-    const sql = `UPDATE ${this.TABLE} SET isDeleted = 1 WHERE _id = ?`;
-    await QueryBuilder.execute(sql, [_id]);
-  }
-  static async 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 async 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]);
+        const result = await 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 = await this.findById(_id);
+        if (!created) {
+          throw new Error("Failed to create API key");
+        }
+        return created;
+      }
+      static async 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 async 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 async delete(_id) {
+        const sql = `UPDATE ${this.TABLE} SET isDeleted = 1 WHERE _id = ?`;
+        await QueryBuilder.execute(sql, [_id]);
+      }
+      static async 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 async 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/events.model.ts
-import { uuidv7 as uuidv74 } from "uuidv7";
+// 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/worker/workerSignal.ts
 import { EventEmitter } from "events";
-var WorkerSignal = class extends EventEmitter {
-};
-var workerSignal = new WorkerSignal();
-workerSignal.setMaxListeners(20);
 function notifyNewEvent() {
   workerSignal.emit("newEvent");
 }
+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/database/models/events.model.ts
-var RETRY_DELAYS_MS = [5e3, 3e4, 12e4];
-var EventsModel = class {
-  static TABLE = "events";
-  static async create(input) {
-    const _id = uuidv74();
-    const timestamp = Date.now();
-    const status = "pending";
-    const sql = `
+import { uuidv7 as uuidv74 } from "uuidv7";
+var RETRY_DELAYS_MS, EventsModel;
+var init_events_model = __esm({
+  "src/infra/database/models/events.model.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_database();
+    init_workerSignal();
+    RETRY_DELAYS_MS = [5e3, 3e4, 12e4];
+    EventsModel = class {
+      static TABLE = "events";
+      static async create(input) {
+        const _id = uuidv74();
+        const timestamp = Date.now();
+        const status = "pending";
+        const sql = `
       INSERT INTO ${this.TABLE}
       (_id, type, timestamp, fileId, portalAddress, status, retryCount, lastError, lockedAt, nextRetryAt)
       VALUES (?, ?, ?, ?, ?, ?, 0, NULL, NULL, NULL)
     `;
-    await QueryBuilder.execute(sql, [_id, input.type, timestamp, input.fileId, input.portalAddress, status]);
-    notifyNewEvent();
-    return {
-      _id,
-      type: input.type,
-      timestamp,
-      fileId: input.fileId,
-      portalAddress: input.portalAddress,
-      status,
-      retryCount: 0,
-      lastError: null,
-      lockedAt: null,
-      nextRetryAt: null
-    };
-  }
-  static async findById(_id) {
-    const sql = `SELECT * FROM ${this.TABLE} WHERE _id = ?`;
-    const row = await QueryBuilder.selectOne(sql, [_id]);
-    return row ? this.parseEvent(row) : void 0;
-  }
-  static async findNextPending() {
-    const sql = `
+        await QueryBuilder.execute(sql, [_id, input.type, timestamp, input.fileId, input.portalAddress, status]);
+        notifyNewEvent();
+        return {
+          _id,
+          type: input.type,
+          timestamp,
+          fileId: input.fileId,
+          portalAddress: input.portalAddress,
+          status,
+          retryCount: 0,
+          lastError: null,
+          lockedAt: null,
+          nextRetryAt: null
+        };
+      }
+      static async findById(_id) {
+        const sql = `SELECT * FROM ${this.TABLE} WHERE _id = ?`;
+        const row = await QueryBuilder.selectOne(sql, [_id]);
+        return row ? this.parseEvent(row) : void 0;
+      }
+      static async findNextPending() {
+        const sql = `
       SELECT * FROM ${this.TABLE}
       WHERE status = 'pending'
       ORDER BY timestamp ASC
       LIMIT 1
     `;
-    const row = await QueryBuilder.selectOne(sql, []);
-    return row ? this.parseEvent(row) : void 0;
-  }
-  static async findNextEligible(lockedFileIds) {
-    const now = Date.now();
-    const exclusionClause = lockedFileIds.length > 0 ? `AND e1.fileId NOT IN (${lockedFileIds.map(() => "?").join(", ")})` : "";
-    const sql = `
+        const row = await QueryBuilder.selectOne(sql, []);
+        return row ? this.parseEvent(row) : void 0;
+      }
+      static async findNextEligible(lockedFileIds) {
+        const now = Date.now();
+        const exclusionClause = lockedFileIds.length > 0 ? `AND e1.fileId NOT IN (${lockedFileIds.map(() => "?").join(", ")})` : "";
+        const sql = `
       SELECT e1.* FROM ${this.TABLE} e1
       WHERE e1.status = 'pending'
       AND (e1.nextRetryAt IS NULL OR e1.nextRetryAt <= ?)
@@ -504,34 +633,34 @@ var EventsModel = class {
       ORDER BY e1.timestamp ASC
       LIMIT 1
     `;
-    const params = [now, ...lockedFileIds];
-    const row = await QueryBuilder.selectOne(sql, params);
-    return row ? this.parseEvent(row) : void 0;
-  }
-  static async markProcessing(_id) {
-    const sql = `
+        const params = [now, ...lockedFileIds];
+        const row = await QueryBuilder.selectOne(sql, params);
+        return row ? this.parseEvent(row) : void 0;
+      }
+      static async markProcessing(_id) {
+        const sql = `
       UPDATE ${this.TABLE}
       SET status = 'processing',
           lockedAt = ?
       WHERE _id = ?
     `;
-    await QueryBuilder.execute(sql, [Date.now(), _id]);
-  }
-  static async markProcessed(_id) {
-    const sql = `
+        await QueryBuilder.execute(sql, [Date.now(), _id]);
+      }
+      static async markProcessed(_id) {
+        const sql = `
       UPDATE ${this.TABLE}
       SET status = 'processed',
           lockedAt = NULL
       WHERE _id = ?
     `;
-    await QueryBuilder.execute(sql, [_id]);
-  }
-  static async scheduleRetry(_id, errorMsg) {
-    const event = await this.findById(_id);
-    if (!event) return;
-    const delay = RETRY_DELAYS_MS[Math.min(event.retryCount, RETRY_DELAYS_MS.length - 1)];
-    const nextRetryAt = Date.now() + delay;
-    const sql = `
+        await QueryBuilder.execute(sql, [_id]);
+      }
+      static async scheduleRetry(_id, errorMsg) {
+        const event = await this.findById(_id);
+        if (!event) return;
+        const delay = RETRY_DELAYS_MS[Math.min(event.retryCount, RETRY_DELAYS_MS.length - 1)];
+        const nextRetryAt = Date.now() + delay;
+        const sql = `
       UPDATE ${this.TABLE}
       SET status = 'pending',
           retryCount = retryCount + 1,
@@ -540,11 +669,11 @@ var EventsModel = class {
           lockedAt = NULL
       WHERE _id = ?
     `;
-    await QueryBuilder.execute(sql, [errorMsg, nextRetryAt, _id]);
-  }
-  static async scheduleRetryAfter(_id, errorMsg, retryAfterMs) {
-    const nextRetryAt = Date.now() + retryAfterMs;
-    const sql = `
+        await QueryBuilder.execute(sql, [errorMsg, nextRetryAt, _id]);
+      }
+      static async scheduleRetryAfter(_id, errorMsg, retryAfterMs) {
+        const nextRetryAt = Date.now() + retryAfterMs;
+        const sql = `
       UPDATE ${this.TABLE}
       SET status = 'pending',
           lastError = ?,
@@ -552,33 +681,33 @@ var EventsModel = class {
           lockedAt = NULL
       WHERE _id = ?
     `;
-    await QueryBuilder.execute(sql, [errorMsg, nextRetryAt, _id]);
-  }
-  static async markFailed(_id, errorMsg) {
-    const sql = `
+        await QueryBuilder.execute(sql, [errorMsg, nextRetryAt, _id]);
+      }
+      static async markFailed(_id, errorMsg) {
+        const sql = `
       UPDATE ${this.TABLE}
       SET status = 'failed',
           lastError = ?,
           lockedAt = NULL
       WHERE _id = ?
     `;
-    await QueryBuilder.execute(sql, [errorMsg, _id]);
-  }
-  static async listFailed(portalAddress) {
-    const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
-    const sql = `
+        await QueryBuilder.execute(sql, [errorMsg, _id]);
+      }
+      static async listFailed(portalAddress) {
+        const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
+        const sql = `
       SELECT * FROM ${this.TABLE}
       WHERE status = 'failed'
       ${portalClause}
       ORDER BY timestamp ASC
     `;
-    const params = portalAddress != null ? [portalAddress] : [];
-    const rows = await QueryBuilder.select(sql, params);
-    return rows.map((row) => this.parseEvent(row));
-  }
-  static async resetFailedToPending(_id, portalAddress) {
-    const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
-    const sql = `
+        const params = portalAddress != null ? [portalAddress] : [];
+        const rows = await QueryBuilder.select(sql, params);
+        return rows.map((row) => this.parseEvent(row));
+      }
+      static async resetFailedToPending(_id, portalAddress) {
+        const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
+        const sql = `
       UPDATE ${this.TABLE}
       SET status = 'pending',
           retryCount = 0,
@@ -589,16 +718,16 @@ var EventsModel = class {
       AND status = 'failed'
       ${portalClause}
     `;
-    const params = portalAddress != null ? [_id, portalAddress] : [_id];
-    const result = await QueryBuilder.execute(sql, params);
-    if (result.changes > 0) {
-      notifyNewEvent();
-    }
-    return result.changes > 0;
-  }
-  static async resetAllFailedToPending(portalAddress) {
-    const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
-    const sql = `
+        const params = portalAddress != null ? [_id, portalAddress] : [_id];
+        const result = await QueryBuilder.execute(sql, params);
+        if (result.changes > 0) {
+          notifyNewEvent();
+        }
+        return result.changes > 0;
+      }
+      static async resetAllFailedToPending(portalAddress) {
+        const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
+        const sql = `
       UPDATE ${this.TABLE}
       SET status = 'pending',
           retryCount = 0,
@@ -608,15 +737,15 @@ var EventsModel = class {
       WHERE status = 'failed'
       ${portalClause}
     `;
-    const params = portalAddress != null ? [portalAddress] : [];
-    const result = await QueryBuilder.execute(sql, params);
-    if (result.changes > 0) {
-      notifyNewEvent();
-    }
-    return result.changes;
-  }
-  static async resetStaleEvents(staleThreshold) {
-    const sql = `
+        const params = portalAddress != null ? [portalAddress] : [];
+        const result = await QueryBuilder.execute(sql, params);
+        if (result.changes > 0) {
+          notifyNewEvent();
+        }
+        return result.changes;
+      }
+      static async resetStaleEvents(staleThreshold) {
+        const sql = `
       UPDATE ${this.TABLE}
       SET status = 'pending',
           lockedAt = NULL,
@@ -626,51 +755,113 @@ var EventsModel = class {
       AND lockedAt IS NOT NULL
       AND lockedAt < ?
     `;
-    const result = await QueryBuilder.execute(sql, [staleThreshold]);
-    return result.changes;
-  }
-  static async setEventPendingOp(_id, userOpHash, payload) {
-    const sql = `UPDATE ${this.TABLE} SET userOpHash = ?, pendingPayload = ? WHERE _id = ?`;
-    await QueryBuilder.execute(sql, [userOpHash, JSON.stringify(payload), _id]);
-  }
-  static async clearEventPendingOp(_id) {
-    const sql = `UPDATE ${this.TABLE} SET userOpHash = NULL, pendingPayload = NULL WHERE _id = ?`;
-    await QueryBuilder.execute(sql, [_id]);
-  }
-  static parseEvent(row) {
-    return {
-      _id: row._id,
-      type: row.type,
-      timestamp: row.timestamp,
-      fileId: row.fileId,
-      portalAddress: row.portalAddress ?? "",
-      status: row.status,
-      retryCount: row.retryCount,
-      lastError: row.lastError,
-      lockedAt: row.lockedAt,
-      nextRetryAt: row.nextRetryAt,
-      userOpHash: row.userOpHash ?? null,
-      pendingPayload: row.pendingPayload ?? null
+        const result = await QueryBuilder.execute(sql, [staleThreshold]);
+        return result.changes;
+      }
+      static async setEventPendingOp(_id, userOpHash, payload) {
+        const sql = `UPDATE ${this.TABLE} SET userOpHash = ?, pendingPayload = ? WHERE _id = ?`;
+        await QueryBuilder.execute(sql, [userOpHash, JSON.stringify(payload), _id]);
+      }
+      static async clearEventPendingOp(_id) {
+        const sql = `UPDATE ${this.TABLE} SET userOpHash = NULL, pendingPayload = NULL WHERE _id = ?`;
+        await QueryBuilder.execute(sql, [_id]);
+      }
+      static parseEvent(row) {
+        return {
+          _id: row._id,
+          type: row.type,
+          timestamp: row.timestamp,
+          fileId: row.fileId,
+          portalAddress: row.portalAddress ?? "",
+          status: row.status,
+          retryCount: row.retryCount,
+          lastError: row.lastError,
+          lockedAt: row.lockedAt,
+          nextRetryAt: row.nextRetryAt,
+          userOpHash: row.userOpHash ?? null,
+          pendingPayload: row.pendingPayload ?? null
+        };
+      }
     };
   }
-};
+});
+
+// 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/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/domain/portal/publish.ts
-import { fromUint8Array as fromUint8Array3, toUint8Array as toUint8Array3 } from "js-base64";
-import { stringToBytes } from "viem";
-import { deriveHKDFKey } from "@fileverse/crypto/kdf";
-import { generateKeyPairFromSeed } from "@stablelib/ed25519";
-import * as ucans2 from "@ucans/ucans";
+// src/constants/chains.ts
+import { sepolia, gnosis } from "viem/chains";
+var init_chains = __esm({
+  "src/constants/chains.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
 
-// src/sdk/smart-agent.ts
-import { toHex as toHex2 } from "viem";
-import { privateKeyToAccount } from "viem/accounts";
+// 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_constants3 = __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";
@@ -678,24 +869,35 @@ import { createPimlicoClient } from "permissionless/clients/pimlico";
 import { createSmartAccountClient } from "permissionless";
 import { toSafeSmartAccount } from "permissionless/accounts";
 import { entryPoint07Address } from "viem/account-abstraction";
-
-// src/constants/chains.ts
-import { sepolia, gnosis } from "viem/chains";
-
-// src/constants/index.ts
-var NETWORK_NAME = STATIC_CONFIG.NETWORK_NAME;
-var UPLOAD_SERVER_URL = STATIC_CONFIG.API_URL;
-var CHAIN_MAP = {
-  gnosis,
-  sepolia
-};
-var CHAIN = CHAIN_MAP[NETWORK_NAME];
-
-// src/sdk/pimlico-utils.ts
 import { generatePrivateKey } from "viem/accounts";
+var init_pimlico_utils = __esm({
+  "src/sdk/pimlico-utils.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants3();
+  }
+});
 
-// src/sdk/file-manager.ts
-import { fromUint8Array as fromUint8Array2, toUint8Array as toUint8Array2 } from "js-base64";
+// 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";
@@ -705,246 +907,419 @@ import { secretBoxEncrypt } from "@fileverse/crypto/nacl";
 import hkdf from "futoin-hkdf";
 import tweetnacl from "tweetnacl";
 import { fromUint8Array, toUint8Array } from "js-base64";
-
-// src/sdk/file-encryption.ts
-import { generateRandomBytes } from "@fileverse/crypto/utils";
-
-// src/sdk/file-utils.ts
 import { toAESKey, aesEncrypt } from "@fileverse/crypto/webcrypto";
 import axios 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_constants3();
+  }
+});
 
 // src/sdk/file-manager.ts
+import { fromUint8Array as fromUint8Array2, toUint8Array as toUint8Array2 } 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_constants3();
+    init_infra();
+  }
+});
+
+// src/domain/portal/publish.ts
+import { fromUint8Array as fromUint8Array3, toUint8Array as toUint8Array3 } 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/savePortal.ts
+var init_savePortal = __esm({
+  "src/domain/portal/savePortal.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_models();
+  }
+});
+
+// src/domain/portal/saveApiKey.ts
+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_constants3();
+    init_rate_limit();
+  }
+});
 
 // src/infra/worker/worker.ts
-var STALE_THRESHOLD_MS = 5 * 60 * 1e3;
+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 worker = null;
 async function closeWorker() {
   if (worker) {
     await worker.close();
     worker = null;
   }
 }
+var worker;
+var init_appWorker = __esm({
+  "src/appWorker.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_worker2();
+    worker = null;
+  }
+});
 
 // src/infra/reporter.ts
-var Reporter = class {
-  async reportError(message) {
-    console.error("Error reported:", message);
+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();
   }
-};
-var reporter_default = new Reporter();
+});
 
-// src/infra/database/adapters/sqlite-adapter.ts
-var SqliteAdapter = class {
-  db;
-  constructor(dbPath) {
-    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}`);
-  }
-  async select(sql, params = []) {
-    const stmt = this.db.prepare(sql);
-    return stmt.all(params);
-  }
-  async selectOne(sql, params = []) {
-    const stmt = this.db.prepare(sql);
-    return stmt.get(params);
-  }
-  async execute(sql, params = []) {
-    const stmt = this.db.prepare(sql);
-    const result = stmt.run(params);
-    return {
-      changes: result.changes,
-      lastInsertRowid: result.lastInsertRowid
-    };
+// 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();
   }
-  async transaction(callback) {
-    this.db.exec("SAVEPOINT txn");
-    try {
-      const result = await callback(this);
-      this.db.exec("RELEASE txn");
-      return result;
-    } catch (err) {
-      this.db.exec("ROLLBACK TO txn");
-      throw err;
+});
+
+// src/infra/database/adapters/sql-compat.ts
+function sqliteToPostgres(sql) {
+  let result = "";
+  let paramIndex = 0;
+  let inString = false;
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i];
+    if (ch === "'") {
+      if (inString && i + 1 < sql.length && sql[i + 1] === "'") {
+        result += "''";
+        i++;
+        continue;
+      }
+      inString = !inString;
+      result += ch;
+    } else if (ch === "?" && !inString) {
+      paramIndex++;
+      result += `$${paramIndex}`;
+    } else {
+      result += ch;
     }
   }
-  async exec(sql) {
-    this.db.exec(sql);
-  }
-  async close() {
-    this.db.close();
-    logger.info("Database connection closed");
+  return result;
+}
+var init_sql_compat = __esm({
+  "src/infra/database/adapters/sql-compat.ts"() {
+    "use strict";
+    init_esm_shims();
   }
-};
+});
 
-// src/infra/database/adapters/pg-adapter.ts
-import pg from "pg";
-var { Pool } = pg;
-var COLUMN_NAME_MAP = {
-  ddocid: "ddocId",
-  localversion: "localVersion",
-  onchainversion: "onchainVersion",
-  syncstatus: "syncStatus",
-  isdeleted: "isDeleted",
-  onchainfileid: "onChainFileId",
-  portaladdress: "portalAddress",
-  createdat: "createdAt",
-  updatedat: "updatedAt",
-  linkkey: "linkKey",
-  linkkeynonce: "linkKeyNonce",
-  commentkey: "commentKey",
-  portalseed: "portalSeed",
-  owneraddress: "ownerAddress",
-  apikeyseed: "apiKeySeed",
-  collaboratoraddress: "collaboratorAddress",
-  fileid: "fileId",
-  retrycount: "retryCount",
-  lasterror: "lastError",
-  lockedat: "lockedAt",
-  nextretryat: "nextRetryAt",
-  userophash: "userOpHash",
-  pendingpayload: "pendingPayload",
-  folderid: "folderId",
-  folderref: "folderRef",
-  foldername: "folderName",
-  metadataipfshash: "metadataIPFSHash",
-  contentipfshash: "contentIPFSHash",
-  lasttransactionhash: "lastTransactionHash",
-  lasttransactionblocknumber: "lastTransactionBlockNumber",
-  lasttransactionblocktimestamp: "lastTransactionBlockTimestamp",
-  created_at: "created_at",
-  updated_at: "updated_at"
-};
-function translateParams(sql) {
-  let idx = 0;
-  return sql.replace(/\?/g, () => `$${++idx}`);
-}
-function mapRow(row) {
-  const mapped = {};
-  for (const [key, value] of Object.entries(row)) {
-    const mappedKey = COLUMN_NAME_MAP[key] ?? key;
-    mapped[mappedKey] = value instanceof Date ? value.toISOString() : value;
+// src/infra/database/adapters/postgres-adapter.ts
+var postgres_adapter_exports = {};
+__export(postgres_adapter_exports, {
+  PostgresAdapter: () => PostgresAdapter
+});
+async function getPg() {
+  if (!pgModule) {
+    pgModule = await import("pg");
   }
-  return mapped;
+  return pgModule;
 }
-var PgClientAdapter = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async select(sql, params = []) {
-    const result = await this.client.query(translateParams(sql), params);
-    return result.rows.map((row) => mapRow(row));
-  }
-  async selectOne(sql, params = []) {
-    const result = await this.client.query(translateParams(sql), params);
-    return result.rows[0] ? mapRow(result.rows[0]) : void 0;
-  }
-  async execute(sql, params = []) {
-    const result = await this.client.query(translateParams(sql), params);
-    return { changes: result.rowCount ?? 0, lastInsertRowid: 0 };
-  }
-  async transaction(callback) {
-    await this.client.query("SAVEPOINT nested_txn");
-    try {
-      const result = await callback(this);
-      await this.client.query("RELEASE SAVEPOINT nested_txn");
-      return result;
-    } catch (err) {
-      await this.client.query("ROLLBACK TO SAVEPOINT nested_txn");
-      throw err;
-    }
-  }
-  async exec(sql) {
-    await this.client.query(sql);
-  }
-  async close() {
-  }
-};
-var PgAdapter = class {
-  pool;
-  constructor(connectionString) {
-    const url = new URL(connectionString);
-    const isLocal = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1";
-    const sslDisabled = connectionString.includes("sslmode=disable");
-    const needsSsl = !isLocal && !sslDisabled;
-    this.pool = new Pool({
-      connectionString,
-      // pg requires password to be a string; local trust/peer auth uses empty string
-      password: url.password || "",
-      max: 20,
-      idleTimeoutMillis: 3e4,
-      ssl: needsSsl ? { rejectUnauthorized: false } : void 0
-    });
-    logger.info(`PostgreSQL pool created (ssl: ${needsSsl ? "on" : "off"})`);
-  }
-  async select(sql, params = []) {
-    const result = await this.pool.query(translateParams(sql), params);
-    return result.rows.map((row) => mapRow(row));
-  }
-  async selectOne(sql, params = []) {
-    const result = await this.pool.query(translateParams(sql), params);
-    return result.rows[0] ? mapRow(result.rows[0]) : void 0;
-  }
-  async execute(sql, params = []) {
-    const result = await this.pool.query(translateParams(sql), params);
-    return { changes: result.rowCount ?? 0, lastInsertRowid: 0 };
-  }
-  async transaction(callback) {
-    const client = await this.pool.connect();
-    try {
-      await client.query("BEGIN");
-      const clientAdapter = new PgClientAdapter(client);
-      const result = await callback(clientAdapter);
-      await client.query("COMMIT");
-      return result;
-    } catch (err) {
-      await client.query("ROLLBACK");
-      throw err;
-    } finally {
-      client.release();
-    }
-  }
-  async exec(sql) {
-    await this.pool.query(sql);
+var pgModule, PostgresAdapter;
+var init_postgres_adapter = __esm({
+  "src/infra/database/adapters/postgres-adapter.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sql_compat();
+    init_infra();
+    pgModule = null;
+    PostgresAdapter = class {
+      pool = null;
+      connectionUrl;
+      connected = false;
+      dialect = "postgres";
+      constructor(connectionUrl) {
+        this.connectionUrl = connectionUrl;
+      }
+      async getPool() {
+        if (!this.pool) {
+          const pg = await getPg();
+          this.pool = new pg.default.Pool({
+            connectionString: this.connectionUrl,
+            max: 10,
+            ssl: this.connectionUrl.includes("sslmode=require") || this.connectionUrl.includes("amazonaws.com") || this.connectionUrl.includes("heroku") ? { rejectUnauthorized: false } : void 0
+          });
+          const client = await this.pool.connect();
+          client.release();
+          this.connected = true;
+          logger.info("PostgreSQL database connected");
+        }
+        return this.pool;
+      }
+      async select(sql, params = []) {
+        const pool = await this.getPool();
+        const pgSql = sqliteToPostgres(sql);
+        const result = await pool.query(pgSql, params);
+        return result.rows;
+      }
+      async selectOne(sql, params = []) {
+        const pool = await this.getPool();
+        const pgSql = sqliteToPostgres(sql);
+        const result = await pool.query(pgSql, params);
+        return result.rows[0] ?? void 0;
+      }
+      async execute(sql, params = []) {
+        const pool = await this.getPool();
+        const pgSql = sqliteToPostgres(sql);
+        const result = await pool.query(pgSql, params);
+        return {
+          changes: result.rowCount ?? 0,
+          lastInsertRowid: 0
+        };
+      }
+      async transaction(callback) {
+        const pool = await this.getPool();
+        const client = await pool.connect();
+        try {
+          await client.query("BEGIN");
+          const result = await callback();
+          await client.query("COMMIT");
+          return result;
+        } catch (error) {
+          await client.query("ROLLBACK");
+          throw error;
+        } finally {
+          client.release();
+        }
+      }
+      async exec(sql) {
+        const pool = await this.getPool();
+        await pool.query(sql);
+      }
+      async close() {
+        if (this.pool) {
+          await this.pool.end();
+          this.pool = null;
+          this.connected = false;
+          logger.info("Database connection closed");
+        }
+      }
+      isConnected() {
+        return this.connected;
+      }
+    };
   }
-  async close() {
-    await this.pool.end();
-    logger.info("PostgreSQL pool closed");
+});
+
+// src/infra/database/adapters/sqlite-adapter.ts
+var sqlite_adapter_exports = {};
+__export(sqlite_adapter_exports, {
+  SqliteAdapter: () => SqliteAdapter
+});
+import Database from "better-sqlite3";
+var SqliteAdapter;
+var init_sqlite_adapter = __esm({
+  "src/infra/database/adapters/sqlite-adapter.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_infra();
+    SqliteAdapter = class {
+      constructor(dbPath) {
+        this.dbPath = dbPath;
+      }
+      db = null;
+      dialect = "sqlite";
+      getDb() {
+        if (!this.db) {
+          this.db = new Database(this.dbPath);
+          this.db.pragma("journal_mode = WAL");
+          this.db.pragma("foreign_keys = ON");
+          this.db.prepare("SELECT 1").get();
+          logger.info(`SQLite database connected: ${this.dbPath}`);
+        }
+        return this.db;
+      }
+      async select(sql, params = []) {
+        const stmt = this.getDb().prepare(sql);
+        return stmt.all(params);
+      }
+      async selectOne(sql, params = []) {
+        const stmt = this.getDb().prepare(sql);
+        return stmt.get(params);
+      }
+      async execute(sql, params = []) {
+        const stmt = this.getDb().prepare(sql);
+        const result = stmt.run(params);
+        return {
+          changes: result.changes,
+          lastInsertRowid: result.lastInsertRowid
+        };
+      }
+      async transaction(callback) {
+        const db = this.getDb();
+        const savepointName = `sp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        db.exec(`SAVEPOINT ${savepointName}`);
+        try {
+          const result = await callback();
+          db.exec(`RELEASE ${savepointName}`);
+          return result;
+        } catch (error) {
+          db.exec(`ROLLBACK TO ${savepointName}`);
+          db.exec(`RELEASE ${savepointName}`);
+          throw error;
+        }
+      }
+      async exec(sql) {
+        this.getDb().exec(sql);
+      }
+      async close() {
+        if (this.db) {
+          this.db.close();
+          this.db = null;
+          logger.info("Database connection closed");
+        }
+      }
+      isConnected() {
+        return this.db !== null && this.db.open;
+      }
+    };
   }
-};
+});
 
 // src/infra/database/connection.ts
-var adapter = null;
-async function getAdapter() {
+import path3 from "path";
+import fs2 from "fs";
+async function initializeAdapter() {
   if (adapter) return adapter;
-  const databaseUrl = config.DATABASE_URL;
-  const dbPath = config.DB_PATH;
+  const databaseUrl = process.env.DATABASE_URL;
+  const dbPath = process.env.DB_PATH;
   if (databaseUrl) {
-    adapter = new PgAdapter(databaseUrl);
+    const { PostgresAdapter: PostgresAdapter2 } = await Promise.resolve().then(() => (init_postgres_adapter(), postgres_adapter_exports));
+    adapter = new PostgresAdapter2(databaseUrl);
+    logger.info("Using PostgreSQL adapter");
   } else if (dbPath) {
-    adapter = new SqliteAdapter(dbPath);
+    const dbDir = path3.dirname(dbPath.trim());
+    if (!fs2.existsSync(dbDir)) {
+      fs2.mkdirSync(dbDir, { recursive: true });
+    }
+    const { SqliteAdapter: SqliteAdapter2 } = await Promise.resolve().then(() => (init_sqlite_adapter(), sqlite_adapter_exports));
+    adapter = new SqliteAdapter2(dbPath);
+    logger.info("Using SQLite adapter");
   } else {
-    throw new Error("Either DATABASE_URL or DB_PATH must be set");
+    throw new Error(
+      "No database configured. Set DATABASE_URL (PostgreSQL) or DB_PATH (SQLite)."
+    );
   }
   return adapter;
 }
-function getAdapterSync() {
+async function getAdapter() {
   if (!adapter) {
-    throw new Error(
-      "Database adapter not initialized. Call getAdapter() at startup first."
-    );
+    return initializeAdapter();
   }
   return adapter;
 }
@@ -954,8 +1329,26 @@ async function closeAdapter() {
     adapter = null;
   }
 }
+var adapter;
+var init_connection = __esm({
+  "src/infra/database/connection.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_infra();
+    adapter = null;
+  }
+});
+
+// src/commands/index.ts
+init_esm_shims();
+init_config();
+init_logger();
+import { Command as Command9 } from "commander";
 
 // src/infra/database/migrations/index.ts
+init_esm_shims();
+init_connection();
+init_infra();
 var STABLE_SCHEMA = `
 CREATE TABLE IF NOT EXISTS files (
   _id TEXT PRIMARY KEY,
@@ -1040,16 +1433,20 @@ CREATE INDEX IF NOT EXISTS idx_folders_folderRef ON folders(folderRef);
 CREATE INDEX IF NOT EXISTS idx_folders_created_at ON folders(created_at);
 `;
 async function runMigrations() {
-  const adapter2 = getAdapterSync();
+  const adapter2 = await getAdapter();
   await adapter2.exec(STABLE_SCHEMA);
   logger.debug("Database schema ready");
 }
 
 // src/commands/listCommand.ts
+init_esm_shims();
 import { Command } from "commander";
 import Table from "cli-table3";
 
 // src/domain/file/index.ts
+init_esm_shims();
+init_models();
+init_constants2();
 import { generate } from "short-uuid";
 async function listFiles(params) {
   const { limit, skip, portalAddress } = params;
@@ -1160,6 +1557,7 @@ var deleteFile = async (ddocId, portalAddress) => {
 };
 
 // src/commands/utils/util.ts
+init_esm_shims();
 var columnNames = {
   index: "#",
   ddocId: "DDoc ID",
@@ -1236,12 +1634,15 @@ After setup, you can use ddctl commands.
 }
 
 // src/commands/listCommand.ts
+init_config();
+init_models();
 var listCommand = new Command().name("list").description("List all ddocs").option("-l, --limit <number>", "Limit the number of results", parseInt).option("-s, --skip <number>", "Skip the first N results", parseInt).action(async (options) => {
   try {
     const runtimeConfig = getRuntimeConfig();
     const apiKey = runtimeConfig.API_KEY;
     validateApiKey(apiKey);
-    const portalAddress = (await ApiKeysModel.findByApiKey(apiKey))?.portalAddress;
+    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+    const portalAddress = apiKeyInfo?.portalAddress;
     if (!portalAddress) throw new Error("Portal address is required");
     const params = {
       limit: options.limit,
@@ -1303,14 +1704,18 @@ Found ${result.total} ddoc(s):
 });
 
 // src/commands/getCommand.ts
+init_esm_shims();
 import { Command as Command2 } from "commander";
 import Table2 from "cli-table3";
+init_config();
+init_models();
 var getCommand = new Command2().name("get").description("Get a ddoc by its ID").argument("<ddocId>", "The ddoc ID to retrieve").action(async (ddocId) => {
   try {
     const runtimeConfig = getRuntimeConfig();
     const apiKey = runtimeConfig.API_KEY;
     validateApiKey(apiKey);
-    const portalAddress = (await ApiKeysModel.findByApiKey(apiKey))?.portalAddress;
+    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+    const portalAddress = apiKeyInfo?.portalAddress;
     if (!portalAddress) throw new Error("Portal address is required");
     const file = await getFile(ddocId, portalAddress);
     if (!file) {
@@ -1365,26 +1770,30 @@ Link: ${file.link}
 });
 
 // src/commands/createCommand.ts
+init_esm_shims();
 import { Command as Command3 } from "commander";
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path4 from "path";
 import Table3 from "cli-table3";
+init_config();
+init_models();
 var createCommand = new Command3().name("create").description("Create a new ddoc from a file").argument("<filepath>", "Path to the file to create ddoc from").action(async (filepath) => {
   try {
-    if (!fs2.existsSync(filepath)) {
+    if (!fs3.existsSync(filepath)) {
       throw new Error(`File not found: ${filepath}`);
     }
     const runtimeConfig = getRuntimeConfig();
     const apiKey = runtimeConfig.API_KEY;
     validateApiKey(apiKey);
-    const portalAddress = (await ApiKeysModel.findByApiKey(apiKey))?.portalAddress;
+    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+    const portalAddress = apiKeyInfo?.portalAddress;
     if (!portalAddress) throw new Error("Portal address is required");
-    const content = fs2.readFileSync(filepath, "utf-8");
+    const content = fs3.readFileSync(filepath, "utf-8");
     if (!content || content.trim().length === 0) {
       console.error("Error creating ddoc: File content cannot be empty. Add some content to the file and try again.");
       process.exit(1);
     }
-    const basename3 = path2.basename(filepath);
+    const basename3 = path4.basename(filepath);
     const lastDotIndex = basename3.lastIndexOf(".");
     const title = lastDotIndex > 0 ? basename3.substring(0, lastDotIndex) : basename3;
     const file = await createFile({ title, content, portalAddress });
@@ -1428,12 +1837,15 @@ var createCommand = new Command3().name("create").description("Create a new ddoc
 });
 
 // src/commands/updateCommand.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+init_esm_shims();
+import * as fs4 from "fs";
+import * as path5 from "path";
 import * as os2 from "os";
 import { Command as Command4 } from "commander";
 import { spawnSync } from "child_process";
 import Table4 from "cli-table3";
+init_models();
+init_config();
 function showTable(updatedFile) {
   const table = new Table4({
     head: [
@@ -1473,7 +1885,8 @@ var updateCommand = new Command4().name("update").description("Update an existin
     const runtimeConfig = getRuntimeConfig();
     const apiKey = runtimeConfig.API_KEY;
     validateApiKey(apiKey);
-    const portalAddress = (await ApiKeysModel.findByApiKey(apiKey))?.portalAddress;
+    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+    const portalAddress = apiKeyInfo?.portalAddress;
     if (!portalAddress) throw new Error("Portal address is required");
     const file = await getFile(ddocId, portalAddress);
     if (!file) {
@@ -1481,11 +1894,13 @@ var updateCommand = new Command4().name("update").description("Update an existin
     }
     const filePath = options?.file ?? "";
     if (filePath) {
-      const content = fs3.readFileSync(filePath, "utf-8");
+      const content = fs4.readFileSync(filePath, "utf-8");
       if (!content || content.trim().length === 0) {
         throw new Error(`file content cannot be empty`);
       }
-      const title = path3.basename(filePath);
+      const basename3 = path5.basename(filePath);
+      const lastDotIndex = basename3.lastIndexOf(".");
+      const title = lastDotIndex > 0 ? basename3.substring(0, lastDotIndex) : basename3;
       const payload = {
         title,
         content
@@ -1495,15 +1910,15 @@ var updateCommand = new Command4().name("update").description("Update an existin
       showTable(updatedFile);
       return;
     }
-    const tmpFilePath = path3.join(os2.tmpdir(), `tmp-${ddocId}-${Date.now()}.txt`);
-    fs3.writeFileSync(tmpFilePath, file.content);
+    const tmpFilePath = path5.join(os2.tmpdir(), `tmp-${ddocId}-${Date.now()}.txt`);
+    fs4.writeFileSync(tmpFilePath, file.content);
     const editor = process.env.EDITOR || "vi";
     const result = spawnSync(editor, [tmpFilePath], { stdio: "inherit" });
     if (result.status === 0) {
-      const newContent = fs3.readFileSync(tmpFilePath, "utf-8");
+      const newContent = fs4.readFileSync(tmpFilePath, "utf-8");
       if (newContent === file.content) {
         console.log(`No changes made. Update cancelled.`);
-        fs3.unlinkSync(tmpFilePath);
+        fs4.unlinkSync(tmpFilePath);
         return;
       }
       const payload = {
@@ -1515,7 +1930,7 @@ var updateCommand = new Command4().name("update").description("Update an existin
       console.log("\n\u2713 Ddoc updated successfully!\n");
       showTable(updatedFile);
     }
-    fs3.unlinkSync(tmpFilePath);
+    fs4.unlinkSync(tmpFilePath);
   } catch (error) {
     console.error("Error updating ddoc:", error.message);
     throw error;
@@ -1523,13 +1938,17 @@ var updateCommand = new Command4().name("update").description("Update an existin
 });
 
 // src/commands/deleteCommand.ts
+init_esm_shims();
 import { Command as Command5 } from "commander";
+init_config();
+init_models();
 var deleteCommand = new Command5().name("delete").description("Delete one or more ddocs by their IDs").argument("<ddocIds...>", "One or more ddoc IDs to delete (space-separated)").action(async (ddocIds) => {
   try {
     const runtimeConfig = getRuntimeConfig();
     const apiKey = runtimeConfig.API_KEY;
     validateApiKey(apiKey);
-    const portalAddress = (await ApiKeysModel.findByApiKey(apiKey))?.portalAddress;
+    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+    const portalAddress = apiKeyInfo?.portalAddress;
     if (!portalAddress) throw new Error("Portal address is required");
     for (const ddocId of ddocIds) {
       try {
@@ -1546,14 +1965,18 @@ var deleteCommand = new Command5().name("delete").description("Delete one or mor
 });
 
 // src/commands/downloadCommand.ts
+init_esm_shims();
 import { Command as Command6 } from "commander";
-import * as fs4 from "fs";
+import * as fs5 from "fs";
+init_config();
+init_models();
 var downloadCommand = new Command6().name("download").description("Download a ddoc to a local file").argument("<ddocId>", "The ddoc ID to download").option("-o, --output <filename>", "Output filename (only supports markdown)").action(async (ddocId, options) => {
   try {
     const runtimeConfig = getRuntimeConfig();
     const apiKey = runtimeConfig.API_KEY;
     validateApiKey(apiKey);
-    const portalAddress = (await ApiKeysModel.findByApiKey(apiKey))?.portalAddress;
+    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+    const portalAddress = apiKeyInfo?.portalAddress;
     if (!portalAddress) throw new Error("Portal address is required");
     const file = await getFile(ddocId, portalAddress);
     if (!file) {
@@ -1564,7 +1987,7 @@ var downloadCommand = new Command6().name("download").description("Download a dd
     if (options.output) {
       outputFilename = options.output.endsWith(".md") ? options.output : `${options.output}.md`;
     }
-    fs4.writeFileSync(outputFilename, file.content, "utf-8");
+    fs5.writeFileSync(outputFilename, file.content, "utf-8");
     console.log(`
 \u2713 Ddoc downloaded successfully to: ${outputFilename}
 `);
@@ -1575,13 +1998,17 @@ var downloadCommand = new Command6().name("download").description("Download a dd
 });
 
 // src/commands/viewCommand.ts
+init_esm_shims();
 import { Command as Command7 } from "commander";
+init_config();
+init_models();
 var viewCommand = new Command7().name("view").description("View content preview of a ddoc").argument("<ddocId>", "The ddoc ID to view").option("-n, --lines <number>", "Number of lines to preview (default: 10)", "10").action(async (ddocId, options) => {
   try {
     const runtimeConfig = getRuntimeConfig();
     const apiKey = runtimeConfig.API_KEY;
     validateApiKey(apiKey);
-    const portalAddress = (await ApiKeysModel.findByApiKey(apiKey))?.portalAddress;
+    const apiKeyInfo = await ApiKeysModel.findByApiKey(apiKey);
+    const portalAddress = apiKeyInfo?.portalAddress;
     if (!portalAddress) throw new Error("Portal address is required");
     const file = await getFile(ddocId, portalAddress);
     if (!file) {
@@ -1619,6 +2046,8 @@ Showing ${linesToShow} of ${totalLines} line${totalLines === 1 ? "" : "s"}
 });
 
 // src/commands/eventsCommand.ts
+init_esm_shims();
+init_models();
 import { Command as Command8 } from "commander";
 import Table5 from "cli-table3";
 var MAX_ERROR_LEN = 60;
@@ -1683,8 +2112,10 @@ eventsCommand.command("retry-all").description("Retry all failed events").action
 });
 
 // src/commands/index.ts
+init_infra();
 logger.level = "error";
-var program = new Command9().name("ddctl").description("CLI tool to manage your ddocs").version("0.0.2").addHelpText("beforeAll", "\n").addHelpText("afterAll", "\n");
+await runMigrations();
+var program = new Command9().name("ddctl").description("CLI tool to manage your ddocs").version("0.0.3").addHelpText("beforeAll", "\n").addHelpText("afterAll", "\n");
 program.addCommand(listCommand);
 program.addCommand(getCommand);
 program.addCommand(createCommand);
@@ -1693,14 +2124,10 @@ program.addCommand(deleteCommand);
 program.addCommand(downloadCommand);
 program.addCommand(viewCommand);
 program.addCommand(eventsCommand);
-(async () => {
-  await getAdapter();
-  await runMigrations();
-  await program.parseAsync();
-})().then(async () => {
+program.parseAsync().then(async () => {
   try {
     await closeWorker();
-    await closeAdapter();
+    await closeDatabase();
   } catch (error) {
   }
   process.exit(0);