@fileverse/api 0.0.1

package/dist/commands/index.js

@@ -0,0 +1,1548 @@
+#!/usr/bin/env node
+
+// src/commands/index.ts
+import { Command as Command9 } from "commander";
+
+// src/config/index.ts
+import dotenv from "dotenv";
+import path from "path";
+import fs from "fs";
+import os from "os";
+
+// 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"
+};
+
+// src/config/index.ts
+var projectEnvPath = path.join(process.cwd(), "config", ".env");
+var userEnvPath = path.join(os.homedir(), ".fileverse", ".env");
+function getEnvPath() {
+  if (fs.existsSync(projectEnvPath)) {
+    return projectEnvPath;
+  }
+  return userEnvPath;
+}
+function loadConfig(override = true) {
+  const envPath = getEnvPath();
+  dotenv.config({ path: envPath, override });
+}
+loadConfig(false);
+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 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 = 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
+      };
+    }
+  },
+  transport: config.NODE_ENV !== "production" ? {
+    target: "pino-pretty",
+    options: {
+      colorize: true,
+      translateTime: "SYS:standard",
+      ignore: "pid,hostname",
+      errorProps: "*",
+      errorLikeObjectKeys: ["err", "error"]
+    }
+  } : void 0
+});
+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/connection.ts
+import Database from "better-sqlite3";
+
+// 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;
+      }
+    } 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 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 = 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 = 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 findById(_id, portalAddress) {
+    const sql = `
+      SELECT *
+      FROM ${this.TABLE} 
+      WHERE _id = ? AND isDeleted = 0 AND portalAddress = ?
+    `;
+    const result = QueryBuilder.selectOne(sql, [_id, portalAddress]);
+    return result ? this.parseFile(result) : void 0;
+  }
+  static findByIdIncludingDeleted(_id) {
+    const sql = `
+      SELECT *
+      FROM ${this.TABLE} 
+      WHERE _id = ?
+    `;
+    const result = QueryBuilder.selectOne(sql, [_id]);
+    return result ? this.parseFile(result) : void 0;
+  }
+  static findByIdExcludingDeleted(_id) {
+    const sql = `
+      SELECT *
+      FROM ${this.TABLE} 
+      WHERE _id = ? AND isDeleted = 0
+    `;
+    const result = QueryBuilder.selectOne(sql, [_id]);
+    return result ? this.parseFile(result) : void 0;
+  }
+  static findByDDocId(ddocId, portalAddress) {
+    const sql = `
+      SELECT *
+      FROM ${this.TABLE} 
+      WHERE ddocId = ? AND isDeleted = 0 AND portalAddress = ?
+    `;
+    const result = QueryBuilder.selectOne(sql, [ddocId, portalAddress]);
+    return result ? this.parseFile(result) : void 0;
+  }
+  static 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 = QueryBuilder.select(completeSql, [`%${searchTerm}%`, portalAddress]);
+    return filesRaw.map(this.parseFile);
+  }
+  static create(input) {
+    const _id = uuidv7();
+    const sql = `
+      INSERT INTO ${this.TABLE} 
+      (_id, title, content, ddocId, portalAddress) 
+      VALUES (?, ?, ?, ?, ?)
+    `;
+    QueryBuilder.execute(sql, [_id, input.title, input.content, input.ddocId, input.portalAddress]);
+    const created = this.findById(_id, input.portalAddress);
+    if (!created) {
+      throw new Error("Failed to create file");
+    }
+    return created;
+  }
+  static 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 = ?`;
+    QueryBuilder.execute(sql, values);
+    const updated = this.findById(_id, portalAddress);
+    if (!updated) {
+      throw new Error("Failed to update file");
+    }
+    return updated;
+  }
+  static softDelete(_id) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const sql = `
+      UPDATE ${this.TABLE} 
+      SET isDeleted = 1, syncStatus = 'pending', updatedAt = ?
+      WHERE _id = ?
+    `;
+    QueryBuilder.execute(sql, [now, _id]);
+    const deleted = 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";
+
+// src/infra/database/models/apikeys.model.ts
+import { uuidv7 as uuidv73 } from "uuidv7";
+var 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/events.model.ts
+import { uuidv7 as uuidv74 } from "uuidv7";
+
+// 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");
+}
+
+// src/infra/database/models/events.model.ts
+var RETRY_DELAYS_MS = [5e3, 3e4, 12e4];
+var EventsModel = class {
+  static TABLE = "events";
+  static 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)
+    `;
+    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 findById(_id) {
+    const sql = `SELECT * FROM ${this.TABLE} WHERE _id = ?`;
+    const row = QueryBuilder.selectOne(sql, [_id]);
+    return row ? this.parseEvent(row) : void 0;
+  }
+  static findNextPending() {
+    const sql = `
+      SELECT * FROM ${this.TABLE}
+      WHERE status = 'pending'
+      ORDER BY timestamp ASC
+      LIMIT 1
+    `;
+    const row = QueryBuilder.selectOne(sql, []);
+    return row ? this.parseEvent(row) : void 0;
+  }
+  static 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 <= ?)
+      ${exclusionClause}
+      AND NOT EXISTS (
+        SELECT 1 FROM ${this.TABLE} e2
+        WHERE e2.fileId = e1.fileId
+        AND e2.status = 'pending'
+        AND e2.timestamp < e1.timestamp
+      )
+      ORDER BY e1.timestamp ASC
+      LIMIT 1
+    `;
+    const params = [now, ...lockedFileIds];
+    const row = QueryBuilder.selectOne(sql, params);
+    return row ? this.parseEvent(row) : void 0;
+  }
+  static markProcessing(_id) {
+    const sql = `
+      UPDATE ${this.TABLE}
+      SET status = 'processing',
+          lockedAt = ?
+      WHERE _id = ?
+    `;
+    QueryBuilder.execute(sql, [Date.now(), _id]);
+  }
+  static markProcessed(_id) {
+    const sql = `
+      UPDATE ${this.TABLE}
+      SET status = 'processed',
+          lockedAt = NULL
+      WHERE _id = ?
+    `;
+    QueryBuilder.execute(sql, [_id]);
+  }
+  static scheduleRetry(_id, errorMsg) {
+    const event = 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,
+          lastError = ?,
+          nextRetryAt = ?,
+          lockedAt = NULL
+      WHERE _id = ?
+    `;
+    QueryBuilder.execute(sql, [errorMsg, nextRetryAt, _id]);
+  }
+  static scheduleRetryAfter(_id, errorMsg, retryAfterMs) {
+    const nextRetryAt = Date.now() + retryAfterMs;
+    const sql = `
+      UPDATE ${this.TABLE}
+      SET status = 'pending',
+          lastError = ?,
+          nextRetryAt = ?,
+          lockedAt = NULL
+      WHERE _id = ?
+    `;
+    QueryBuilder.execute(sql, [errorMsg, nextRetryAt, _id]);
+  }
+  static markFailed(_id, errorMsg) {
+    const sql = `
+      UPDATE ${this.TABLE}
+      SET status = 'failed',
+          lastError = ?,
+          lockedAt = NULL
+      WHERE _id = ?
+    `;
+    QueryBuilder.execute(sql, [errorMsg, _id]);
+  }
+  static 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 = QueryBuilder.select(sql, params);
+    return rows.map((row) => this.parseEvent(row));
+  }
+  static resetFailedToPending(_id, portalAddress) {
+    const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
+    const sql = `
+      UPDATE ${this.TABLE}
+      SET status = 'pending',
+          retryCount = 0,
+          lastError = NULL,
+          nextRetryAt = NULL,
+          lockedAt = NULL
+      WHERE _id = ?
+      AND status = 'failed'
+      ${portalClause}
+    `;
+    const params = portalAddress != null ? [_id, portalAddress] : [_id];
+    const result = QueryBuilder.execute(sql, params);
+    if (result.changes > 0) {
+      notifyNewEvent();
+    }
+    return result.changes > 0;
+  }
+  static resetAllFailedToPending(portalAddress) {
+    const portalClause = portalAddress != null ? "AND portalAddress = ?" : "";
+    const sql = `
+      UPDATE ${this.TABLE}
+      SET status = 'pending',
+          retryCount = 0,
+          lastError = NULL,
+          nextRetryAt = NULL,
+          lockedAt = NULL
+      WHERE status = 'failed'
+      ${portalClause}
+    `;
+    const params = portalAddress != null ? [portalAddress] : [];
+    const result = QueryBuilder.execute(sql, params);
+    if (result.changes > 0) {
+      notifyNewEvent();
+    }
+    return result.changes;
+  }
+  static resetStaleEvents(staleThreshold) {
+    const sql = `
+      UPDATE ${this.TABLE}
+      SET status = 'pending',
+          lockedAt = NULL,
+          userOpHash = NULL,
+          pendingPayload = NULL
+      WHERE status = 'processing'
+      AND lockedAt IS NOT NULL
+      AND lockedAt < ?
+    `;
+    const result = QueryBuilder.execute(sql, [staleThreshold]);
+    return result.changes;
+  }
+  static setEventPendingOp(_id, userOpHash, payload) {
+    const sql = `UPDATE ${this.TABLE} SET userOpHash = ?, pendingPayload = ? WHERE _id = ?`;
+    QueryBuilder.execute(sql, [userOpHash, JSON.stringify(payload), _id]);
+  }
+  static clearEventPendingOp(_id) {
+    const sql = `UPDATE ${this.TABLE} SET userOpHash = NULL, pendingPayload = NULL WHERE _id = ?`;
+    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/sdk/key-store.ts
+import { eciesDecrypt, eciesEncrypt, generateECKeyPair } from "@fileverse/crypto/ecies";
+
+// src/sdk/auth-token-provider.ts
+import * as ucans from "@ucans/ucans";
+
+// 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/sdk/smart-agent.ts
+import { toHex as toHex2 } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+
+// 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";
+
+// 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";
+
+// src/sdk/file-manager.ts
+import { fromUint8Array as fromUint8Array2, toUint8Array as toUint8Array2 } from "js-base64";
+
+// 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 } 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";
+
+// src/sdk/file-manager.ts
+import { generateAESKey, exportAESKey } from "@fileverse/crypto/webcrypto";
+import { markdownToYjs } from "@fileverse/content-processor";
+
+// src/errors/rate-limit.ts
+import { HttpRequestError } from "viem";
+
+// src/infra/worker/worker.ts
+var STALE_THRESHOLD_MS = 5 * 60 * 1e3;
+
+// src/appWorker.ts
+var worker = null;
+async function closeWorker() {
+  if (worker) {
+    await worker.close();
+    worker = null;
+  }
+}
+
+// src/infra/reporter.ts
+var Reporter = class {
+  async reportError(message) {
+    console.error("Error reported:", message);
+  }
+};
+var reporter_default = new Reporter();
+
+// src/infra/database/connection.ts
+var 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;
+  }
+};
+var databaseConnectionManager = DatabaseConnectionManager.getInstance();
+
+// src/domain/file/constants.ts
+var DEFAULT_LIST_LIMIT = 10;
+
+// src/infra/database/query-builder.ts
+function getDb() {
+  return databaseConnectionManager.getConnection();
+}
+var 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 closeDatabase = async () => {
+  await databaseConnectionManager.close();
+};
+var database_default = getDb2;
+
+// src/infra/database/migrations/index.ts
+var 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);
+`;
+function runMigrations() {
+  const db = database_default();
+  db.exec(STABLE_SCHEMA);
+  logger.debug("Database schema ready");
+}
+
+// src/commands/listCommand.ts
+import { Command } from "commander";
+import Table from "cli-table3";
+
+// src/domain/file/index.ts
+import { generate } from "short-uuid";
+function listFiles(params) {
+  const { limit, skip, portalAddress } = params;
+  const effectiveLimit = limit || DEFAULT_LIST_LIMIT;
+  const result = FilesModel.findAll(portalAddress, effectiveLimit, skip);
+  const processedFiles = result.files.map((file) => ({
+    ddocId: file.ddocId,
+    link: file.link,
+    title: file.title,
+    content: file.content,
+    localVersion: file.localVersion,
+    onchainVersion: file.onchainVersion,
+    syncStatus: file.syncStatus,
+    isDeleted: file.isDeleted,
+    onChainFileId: file.onChainFileId,
+    portalAddress: file.portalAddress,
+    createdAt: file.createdAt,
+    updatedAt: file.updatedAt
+  }));
+  return {
+    ddocs: processedFiles,
+    total: result.total,
+    hasNext: result.hasNext
+  };
+}
+function getFile(ddocId, portalAddress) {
+  if (!ddocId) {
+    throw new Error("ddocId is required");
+  }
+  const file = FilesModel.findByDDocId(ddocId, portalAddress);
+  if (!file) {
+    return null;
+  }
+  return {
+    ddocId: file.ddocId,
+    link: file.link || "",
+    title: file.title,
+    content: file.content,
+    localVersion: file.localVersion,
+    onchainVersion: file.onchainVersion,
+    syncStatus: file.syncStatus,
+    isDeleted: file.isDeleted,
+    onChainFileId: file.onChainFileId,
+    portalAddress: file.portalAddress,
+    createdAt: file.createdAt,
+    updatedAt: file.updatedAt
+  };
+}
+var createFile = async (input) => {
+  if (!input.title || !input.content || !input.portalAddress) {
+    throw new Error("title, content, and portalAddress are required");
+  }
+  const ddocId = generate();
+  const file = FilesModel.create({
+    title: input.title,
+    content: input.content,
+    ddocId,
+    portalAddress: input.portalAddress
+  });
+  EventsModel.create({ type: "create", fileId: file._id, portalAddress: file.portalAddress });
+  return file;
+};
+var updateFile = async (ddocId, payload, portalAddress) => {
+  if (!ddocId) {
+    throw new Error("ddocId is required");
+  }
+  if (!payload.title && !payload.content) {
+    throw new Error("At least one field is required: Either provide title, content, or both");
+  }
+  const existingFile = FilesModel.findByDDocId(ddocId, portalAddress);
+  if (!existingFile) {
+    throw new Error(`File with ddocId ${ddocId} not found`);
+  }
+  const updatePayload = {
+    ...payload,
+    localVersion: existingFile.localVersion + 1,
+    syncStatus: "pending"
+    // since the update is done in local db, it's not on the chain yet. hence pending
+  };
+  const updatedFile = FilesModel.update(existingFile._id, updatePayload, portalAddress);
+  EventsModel.create({ type: "update", fileId: updatedFile._id, portalAddress: updatedFile.portalAddress });
+  return {
+    ddocId: updatedFile.ddocId,
+    link: updatedFile.link,
+    title: updatedFile.title,
+    content: updatedFile.content,
+    localVersion: updatedFile.localVersion,
+    onchainVersion: updatedFile.onchainVersion,
+    syncStatus: updatedFile.syncStatus,
+    isDeleted: updatedFile.isDeleted,
+    onChainFileId: updatedFile.onChainFileId,
+    portalAddress: updatedFile.portalAddress,
+    createdAt: updatedFile.createdAt,
+    updatedAt: updatedFile.updatedAt
+  };
+};
+var deleteFile = async (ddocId, portalAddress) => {
+  if (!ddocId) {
+    throw new Error("ddocId is required");
+  }
+  const existingFile = FilesModel.findByDDocId(ddocId, portalAddress);
+  if (!existingFile) {
+    throw new Error(`File with ddocId ${ddocId} not found`);
+  }
+  const deletedFile = FilesModel.softDelete(existingFile._id);
+  EventsModel.create({ type: "delete", fileId: deletedFile._id, portalAddress: deletedFile.portalAddress });
+  return deletedFile;
+};
+
+// src/commands/utils/util.ts
+var columnNames = {
+  index: "#",
+  ddocId: "DDoc ID",
+  title: "Title",
+  status: "Status",
+  local: "Local version",
+  onchain: "On-chain version",
+  deleted: "Deleted",
+  created: "Created",
+  lastModified: "Last modified"
+};
+var columnWidth = {
+  [columnNames.index]: 3,
+  [columnNames.ddocId]: 25,
+  [columnNames.title]: 25,
+  [columnNames.status]: 10,
+  [columnNames.local]: 16,
+  [columnNames.onchain]: 18,
+  [columnNames.deleted]: 10,
+  [columnNames.created]: 12,
+  [columnNames.lastModified]: 20
+};
+function formatDate(date) {
+  const d = typeof date === "string" ? new Date(date) : date;
+  const day = String(d.getDate()).padStart(2, "0");
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const year = d.getFullYear();
+  return `${day}-${month}-${year}`;
+}
+function getElapsedTime(date) {
+  const now = /* @__PURE__ */ new Date();
+  const past = typeof date === "string" ? new Date(date) : date;
+  const diffMs = now.getTime() - past.getTime();
+  if (diffMs < 0) {
+    return "just now";
+  }
+  const diffSeconds = Math.floor(diffMs / 1e3);
+  const diffMinutes = Math.floor(diffSeconds / 60);
+  const diffHours = Math.floor(diffMinutes / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  const diffWeeks = Math.floor(diffDays / 7);
+  const diffMonths = Math.floor(diffDays / 30);
+  const diffYears = Math.floor(diffDays / 365);
+  const units = [
+    { value: diffSeconds, max: 60, name: "second" },
+    { value: diffMinutes, max: 60, name: "minute" },
+    { value: diffHours, max: 24, name: "hour" },
+    { value: diffDays, max: 7, name: "day" },
+    { value: diffWeeks, max: 4, name: "week" },
+    { value: diffMonths, max: 12, name: "month" },
+    { value: diffYears, max: Infinity, name: "year" }
+  ];
+  const unit = units.find((u) => u.value < u.max);
+  if (unit) {
+    const label = unit.value === 1 ? unit.name : `${unit.name}s`;
+    return `${unit.value} ${label} ago`;
+  }
+  return "just now";
+}
+function validateApiKey(apiKey) {
+  if (!apiKey) {
+    const API_KEY_SETUP_MESSAGE = `
+API key is not configured.
+
+To set up your API key, run:
+  fileverse-api --apiKey <your-api-key> --rpcUrl <rpc-url>
+
+This will configure your Fileverse API instance and save your credentials.
+After setup, you can use ddctl commands.
+`;
+    console.error(API_KEY_SETUP_MESSAGE);
+    process.exit(1);
+  }
+}
+
+// src/commands/listCommand.ts
+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 = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
+    if (!portalAddress) throw new Error("Portal address is required");
+    const params = {
+      limit: options.limit,
+      skip: options.skip,
+      portalAddress
+    };
+    const result = listFiles(params);
+    if (result.ddocs.length === 0) {
+      console.log("No ddocs found.");
+      return;
+    }
+    const table = new Table({
+      head: [
+        columnNames.index,
+        columnNames.ddocId,
+        columnNames.title,
+        columnNames.status,
+        columnNames.local,
+        columnNames.onchain,
+        columnNames.created,
+        columnNames.lastModified
+      ],
+      colWidths: [
+        columnWidth[columnNames.index],
+        columnWidth[columnNames.ddocId],
+        columnWidth[columnNames.title],
+        columnWidth[columnNames.status],
+        columnWidth[columnNames.local],
+        columnWidth[columnNames.onchain],
+        columnWidth[columnNames.created],
+        columnWidth[columnNames.lastModified]
+      ],
+      style: { head: [] }
+    });
+    result.ddocs.forEach((ddoc, index) => {
+      const ddocId = ddoc.ddocId || "N/A";
+      table.push([
+        index + 1,
+        ddocId,
+        ddoc.title.length > 23 ? ddoc.title.substring(0, 20) + "..." : ddoc.title,
+        ddoc.syncStatus,
+        ddoc.localVersion,
+        ddoc.onchainVersion,
+        formatDate(ddoc.createdAt),
+        getElapsedTime(ddoc.updatedAt)
+      ]);
+    });
+    console.log(`
+Found ${result.total} ddoc(s):
+`);
+    console.log(table.toString());
+    if (result.hasNext) {
+      console.log("\n(More results available. Use --skip and --limit for pagination)");
+    }
+  } catch (error) {
+    console.error("Error listing ddocs:", error.message);
+    throw error;
+  }
+});
+
+// src/commands/getCommand.ts
+import { Command as Command2 } from "commander";
+import Table2 from "cli-table3";
+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 = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
+    if (!portalAddress) throw new Error("Portal address is required");
+    const file = getFile(ddocId, portalAddress);
+    if (!file) {
+      console.error(`Ddoc with ID "${ddocId}" not found.`);
+      return;
+    }
+    const table = new Table2({
+      head: [
+        columnNames.ddocId,
+        columnNames.title,
+        columnNames.status,
+        columnNames.local,
+        columnNames.onchain,
+        columnNames.deleted,
+        columnNames.created,
+        columnNames.lastModified
+      ],
+      colWidths: [
+        columnWidth[columnNames.ddocId],
+        columnWidth[columnNames.title],
+        columnWidth[columnNames.status],
+        columnWidth[columnNames.local],
+        columnWidth[columnNames.onchain],
+        columnWidth[columnNames.deleted],
+        columnWidth[columnNames.created],
+        columnWidth[columnNames.lastModified]
+      ],
+      style: { head: [] }
+    });
+    const fileDdocId = file.ddocId || "N/A";
+    table.push([
+      fileDdocId,
+      file.title.length > 23 ? file.title.substring(0, 20) + "..." : file.title,
+      file.syncStatus,
+      file.localVersion,
+      file.onchainVersion,
+      file.isDeleted ? "True" : "False",
+      formatDate(file.createdAt),
+      getElapsedTime(file.updatedAt)
+    ]);
+    console.log("\nDdoc details:\n");
+    console.log(table.toString());
+    if (file.link) {
+      console.log(`
+Link: ${file.link}
+`);
+    }
+  } catch (error) {
+    console.error("Error getting ddoc:", error.message);
+    throw error;
+  }
+});
+
+// src/commands/createCommand.ts
+import { Command as Command3 } from "commander";
+import * as fs2 from "fs";
+import * as path2 from "path";
+import Table3 from "cli-table3";
+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)) {
+      throw new Error(`File not found: ${filepath}`);
+    }
+    const runtimeConfig = getRuntimeConfig();
+    const apiKey = runtimeConfig.API_KEY;
+    validateApiKey(apiKey);
+    const portalAddress = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
+    if (!portalAddress) throw new Error("Portal address is required");
+    const content = fs2.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 lastDotIndex = basename3.lastIndexOf(".");
+    const title = lastDotIndex > 0 ? basename3.substring(0, lastDotIndex) : basename3;
+    const file = await createFile({ title, content, portalAddress });
+    console.log("\nDdoc created successfully!\n");
+    const table = new Table3({
+      head: [
+        columnNames.ddocId,
+        columnNames.title,
+        columnNames.status,
+        columnNames.local,
+        columnNames.onchain,
+        columnNames.created,
+        columnNames.lastModified
+      ],
+      colWidths: [
+        columnWidth[columnNames.ddocId],
+        columnWidth[columnNames.title],
+        columnWidth[columnNames.status],
+        columnWidth[columnNames.local],
+        columnWidth[columnNames.onchain],
+        columnWidth[columnNames.created],
+        columnWidth[columnNames.lastModified]
+      ],
+      style: { head: [] }
+    });
+    const ddocId = file.ddocId || "N/A";
+    table.push([
+      ddocId,
+      file.title.length > 23 ? file.title.substring(0, 20) + "..." : file.title,
+      file.syncStatus,
+      file.localVersion,
+      file.onchainVersion,
+      formatDate(file.createdAt),
+      getElapsedTime(file.updatedAt)
+    ]);
+    console.log(table.toString());
+  } catch (error) {
+    console.error("Error creating ddoc:", error.message);
+    process.exit(1);
+  }
+});
+
+// src/commands/updateCommand.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as os2 from "os";
+import { Command as Command4 } from "commander";
+import { spawnSync } from "child_process";
+import Table4 from "cli-table3";
+function showTable(updatedFile) {
+  const table = new Table4({
+    head: [
+      columnNames.ddocId,
+      columnNames.title,
+      columnNames.status,
+      columnNames.local,
+      columnNames.onchain,
+      columnNames.created,
+      columnNames.lastModified
+    ],
+    colWidths: [
+      columnWidth[columnNames.ddocId],
+      columnWidth[columnNames.title],
+      columnWidth[columnNames.status],
+      columnWidth[columnNames.local],
+      columnWidth[columnNames.onchain],
+      columnWidth[columnNames.created],
+      columnWidth[columnNames.lastModified]
+    ],
+    style: { head: [] }
+  });
+  const fileDdocId = updatedFile.ddocId || "N/A";
+  table.push([
+    fileDdocId,
+    updatedFile.title.length > 23 ? updatedFile.title.substring(0, 20) + "..." : updatedFile.title,
+    updatedFile.syncStatus,
+    updatedFile.localVersion,
+    updatedFile.onchainVersion,
+    formatDate(updatedFile.createdAt),
+    getElapsedTime(updatedFile.updatedAt)
+  ]);
+  console.log(table.toString());
+}
+var updateCommand = new Command4().name("update").description("Update an existing ddoc. Use -f to update from a file, or omit -f to edit in vi editor").argument("<ddocId>", "The ddoc ID to update").option("-f, --file <file_path>", "path to file to update ddoc from (if omitted, opens vi editor)").action(async (ddocId, options) => {
+  try {
+    const runtimeConfig = getRuntimeConfig();
+    const apiKey = runtimeConfig.API_KEY;
+    validateApiKey(apiKey);
+    const portalAddress = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
+    if (!portalAddress) throw new Error("Portal address is required");
+    const file = getFile(ddocId, portalAddress);
+    if (!file) {
+      throw new Error(`ddoc with ${ddocId} not found.`);
+    }
+    const filePath = options?.file ?? "";
+    if (filePath) {
+      const content = fs3.readFileSync(filePath, "utf-8");
+      if (!content || content.trim().length === 0) {
+        throw new Error(`file content cannot be empty`);
+      }
+      const title = path3.basename(filePath);
+      const payload = {
+        title,
+        content
+      };
+      const updatedFile = await updateFile(ddocId, payload, portalAddress);
+      console.log("\n\u2713 Ddoc updated successfully!\n");
+      showTable(updatedFile);
+      return;
+    }
+    const tmpFilePath = path3.join(os2.tmpdir(), `tmp-${ddocId}-${Date.now()}.txt`);
+    fs3.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");
+      if (newContent === file.content) {
+        console.log(`No changes made. Update cancelled.`);
+        fs3.unlinkSync(tmpFilePath);
+        return;
+      }
+      const payload = {
+        title: file.title,
+        // keeping same title as current
+        content: newContent
+      };
+      const updatedFile = await updateFile(ddocId, payload, portalAddress);
+      console.log("\n\u2713 Ddoc updated successfully!\n");
+      showTable(updatedFile);
+    }
+    fs3.unlinkSync(tmpFilePath);
+  } catch (error) {
+    console.error("Error updating ddoc:", error.message);
+    throw error;
+  }
+});
+
+// src/commands/deleteCommand.ts
+import { Command as Command5 } from "commander";
+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 = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
+    if (!portalAddress) throw new Error("Portal address is required");
+    for (const ddocId of ddocIds) {
+      try {
+        await deleteFile(ddocId, portalAddress);
+        console.log(`ddoc ${ddocId} deleted successfully`);
+      } catch (error) {
+        console.error(`Error deleting ddoc ${ddocId}:`, error.message);
+      }
+    }
+  } catch (error) {
+    console.error("Error:", error.message);
+    throw error;
+  }
+});
+
+// src/commands/downloadCommand.ts
+import { Command as Command6 } from "commander";
+import * as fs4 from "fs";
+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 = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
+    if (!portalAddress) throw new Error("Portal address is required");
+    const file = getFile(ddocId, portalAddress);
+    if (!file) {
+      console.error(`Ddoc with ID "${ddocId}" not found.`);
+      return;
+    }
+    let outputFilename = file.title;
+    if (options.output) {
+      outputFilename = options.output.endsWith(".md") ? options.output : `${options.output}.md`;
+    }
+    fs4.writeFileSync(outputFilename, file.content, "utf-8");
+    console.log(`
+\u2713 Ddoc downloaded successfully to: ${outputFilename}
+`);
+  } catch (error) {
+    console.error("Error downloading ddoc:", error.message);
+    throw error;
+  }
+});
+
+// src/commands/viewCommand.ts
+import { Command as Command7 } from "commander";
+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 = ApiKeysModel.findByApiKey(apiKey)?.portalAddress;
+    if (!portalAddress) throw new Error("Portal address is required");
+    const file = getFile(ddocId, portalAddress);
+    if (!file) {
+      console.error(`Ddoc with ID "${ddocId}" not found.`);
+      return;
+    }
+    const content = file.content || "";
+    const contentLines = content.split("\n");
+    const totalLines = contentLines.length;
+    const previewLines = Math.max(1, parseInt(options.lines || "10", 10));
+    const linesToShow = Math.min(previewLines, totalLines);
+    if (content.trim().length === 0) {
+      console.log("\nContent preview:\n");
+      console.log("=".repeat(80));
+      console.log("(empty)");
+      console.log("=".repeat(80));
+    } else {
+      const preview = contentLines.slice(0, linesToShow).join("\n");
+      console.log("\nContent preview:\n");
+      console.log("=".repeat(80));
+      console.log(preview);
+      if (totalLines > linesToShow) {
+        console.log(`
+... (${totalLines - linesToShow} more line${totalLines - linesToShow === 1 ? "" : "s"})`);
+      }
+      console.log("=".repeat(80));
+      console.log(`
+Showing ${linesToShow} of ${totalLines} line${totalLines === 1 ? "" : "s"}
+`);
+    }
+  } catch (error) {
+    console.error("Error viewing ddoc:", error.message);
+    throw error;
+  }
+});
+
+// src/commands/eventsCommand.ts
+import { Command as Command8 } from "commander";
+import Table5 from "cli-table3";
+var MAX_ERROR_LEN = 60;
+var eventsCommand = new Command8().name("events").description("Worker event operations (list failed, retry)");
+eventsCommand.command("list-failed").description("List all failed events").action(async () => {
+  try {
+    const events = EventsModel.listFailed();
+    if (events.length === 0) {
+      console.log("No failed events.");
+      return;
+    }
+    const table = new Table5({
+      head: ["ID", "File ID", "Portal", "Type", "Timestamp", "Last Error"],
+      colWidths: [28, 12, 14, 10, 12, MAX_ERROR_LEN],
+      style: { head: [] }
+    });
+    events.forEach((e) => {
+      const err = e.lastError ?? "";
+      table.push([
+        e._id,
+        e.fileId,
+        e.portalAddress || "\u2014",
+        e.type,
+        formatDate(new Date(e.timestamp)),
+        err.length > MAX_ERROR_LEN ? err.slice(0, MAX_ERROR_LEN - 3) + "..." : err
+      ]);
+    });
+    console.log(`
+Failed events (${events.length}):
+`);
+    console.log(table.toString());
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.error("Error listing failed events:", msg);
+    throw error;
+  }
+});
+eventsCommand.command("retry <eventId>").description("Retry a single failed event by ID").action(async (eventId) => {
+  try {
+    const updated = EventsModel.resetFailedToPending(eventId);
+    if (updated) {
+      console.log(`Event ${eventId} reset to pending. Worker will pick it up.`);
+    } else {
+      console.error(`Event not found or not in failed state: ${eventId}`);
+      process.exitCode = 1;
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.error("Error retrying event:", msg);
+    throw error;
+  }
+});
+eventsCommand.command("retry-all").description("Retry all failed events").action(async () => {
+  try {
+    const count = EventsModel.resetAllFailedToPending();
+    console.log(`Reset ${count} failed event(s) to pending. Worker will pick them up.`);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.error("Error retrying failed events:", msg);
+    throw error;
+  }
+});
+
+// src/commands/index.ts
+logger.level = "error";
+runMigrations();
+var program = new Command9().name("ddctl").description("CLI tool to manage your ddocs").version("0.0.1").addHelpText("beforeAll", "\n").addHelpText("afterAll", "\n");
+program.addCommand(listCommand);
+program.addCommand(getCommand);
+program.addCommand(createCommand);
+program.addCommand(updateCommand);
+program.addCommand(deleteCommand);
+program.addCommand(downloadCommand);
+program.addCommand(viewCommand);
+program.addCommand(eventsCommand);
+program.parseAsync().then(async () => {
+  try {
+    await closeWorker();
+    await closeDatabase();
+  } catch (error) {
+  }
+  process.exit(0);
+}).catch((error) => {
+  console.error("Error:", error);
+  process.exit(1);
+});
+export {
+  program
+};
+//# sourceMappingURL=index.js.map