@lacrous/omnicloud 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,1008 @@
+// src/client.ts
+var OmniCloudError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "OmniCloudError";
+  }
+  status;
+  code;
+};
+var OmniCloudClient = class {
+  baseUrl;
+  fetchImpl;
+  constructor(options = {}) {
+    this.baseUrl = (options.baseUrl ?? "").replace(/\/$/, "");
+    this.fetchImpl = options.fetchImpl ?? fetch.bind(globalThis);
+  }
+  // ── Authentication ───────────────────────────────────────────────────────
+  async me() {
+    return this.request("GET", "/api/auth/me");
+  }
+  async startTelegramLogin(phone) {
+    await this.request("POST", "/api/auth/telegram/start", { phone });
+  }
+  async verifyTelegramCode(phone, code) {
+    return this.request("POST", "/api/auth/telegram/verify", { phone, code });
+  }
+  async submitTelegramPassword(phone, password) {
+    return this.request("POST", "/api/auth/telegram/password", { phone, password });
+  }
+  async ensureStorage() {
+    const { storage } = await this.request("POST", "/api/storage/ensure");
+    return storage;
+  }
+  async logout() {
+    await this.request("POST", "/api/auth/logout");
+  }
+  // ── Folders ──────────────────────────────────────────────────────────────
+  async listFolders(parentId) {
+    const { folders } = await this.request(
+      "GET",
+      `/api/folders${parentId ? `?parentId=${encodeURIComponent(parentId)}` : ""}`
+    );
+    return folders;
+  }
+  async folderTree() {
+    const { folders } = await this.request("GET", "/api/folders/tree");
+    return folders;
+  }
+  async createFolder(name, parentId = null) {
+    const { folder } = await this.request("POST", "/api/folders", {
+      name,
+      parentId
+    });
+    return folder;
+  }
+  async renameFolder(id, name) {
+    const { folder } = await this.request("PATCH", `/api/folders/${id}`, {
+      name
+    });
+    return folder;
+  }
+  async moveFolder(id, parentId) {
+    const { folder } = await this.request(
+      "POST",
+      `/api/folders/${id}/move`,
+      { parentId }
+    );
+    return folder;
+  }
+  async deleteFolder(id) {
+    return this.request("DELETE", `/api/folders/${id}`);
+  }
+  // ── Files ────────────────────────────────────────────────────────────────
+  async listFiles(folderId) {
+    const { files } = await this.request(
+      "GET",
+      `/api/files${folderId ? `?folderId=${encodeURIComponent(folderId)}` : ""}`
+    );
+    return files;
+  }
+  async getFile(id) {
+    const { file } = await this.request("GET", `/api/files/${id}`);
+    return file;
+  }
+  async renameFile(id, name) {
+    const { file } = await this.request("PATCH", `/api/files/${id}`, { name });
+    return file;
+  }
+  async moveFile(id, folderId) {
+    const { file } = await this.request("POST", `/api/files/${id}/move`, {
+      folderId
+    });
+    return file;
+  }
+  async deleteFile(id) {
+    await this.request("DELETE", `/api/files/${id}`);
+  }
+  /** URL of the download endpoint (usable as href for direct downloads). */
+  fileDownloadUrl(id) {
+    return `${this.baseUrl}/api/files/${id}/download`;
+  }
+  /**
+   * Uploads a file. Uses XMLHttpRequest when available so `onProgress`
+   * works (browsers); falls back to fetch without progress in Node.
+   */
+  async uploadFile(input, options = {}) {
+    const form = new FormData();
+    const blob = input.data instanceof Blob ? input.data : new Blob([new Uint8Array(input.data)]);
+    form.append("file", blob, input.name);
+    if (options.folderId) form.append("folderId", options.folderId);
+    if (typeof XMLHttpRequest === "function") {
+      return this.uploadViaXhr(form, options.onProgress);
+    }
+    return this.request("POST", "/api/files", form);
+  }
+  async search(query) {
+    return this.request("GET", `/api/search?q=${encodeURIComponent(query)}`);
+  }
+  // ── internals ────────────────────────────────────────────────────────────
+  uploadViaXhr(form, onProgress) {
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      xhr.open("POST", `${this.baseUrl}/api/files`);
+      xhr.responseType = "json";
+      xhr.withCredentials = true;
+      xhr.upload.onprogress = (event) => {
+        if (!onProgress) return;
+        onProgress({
+          loaded: event.loaded,
+          total: event.total,
+          percent: event.total > 0 ? Math.round(event.loaded / event.total * 100) : 0
+        });
+      };
+      xhr.onload = () => {
+        const body = xhr.response;
+        if (xhr.status >= 200 && xhr.status < 300 && body?.file) {
+          resolve(body.file);
+          return;
+        }
+        reject(
+          new OmniCloudError(
+            xhr.status,
+            body?.error?.code ?? "INTERNAL_ERROR",
+            body?.error?.message ?? `Upload failed (${xhr.status})`
+          )
+        );
+      };
+      xhr.onerror = () => reject(new OmniCloudError(0, "NETWORK_ERROR", "Network error during upload"));
+      xhr.send(form);
+    });
+  }
+  async request(method, path, body) {
+    const isJsonBody = body !== void 0 && !(body instanceof FormData);
+    const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+      method,
+      headers: isJsonBody ? { "Content-Type": "application/json" } : void 0,
+      body: body === void 0 ? void 0 : isJsonBody ? JSON.stringify(body) : body,
+      credentials: "include"
+    });
+    if (response.status === 204) return void 0;
+    const data = await response.json().catch(() => null);
+    if (!response.ok) {
+      const error = data?.error;
+      throw new OmniCloudError(
+        response.status,
+        error?.code ?? "INTERNAL_ERROR",
+        error?.message ?? `Request failed (${response.status})`
+      );
+    }
+    return data;
+  }
+};
+
+// ../shared/src/mime.ts
+var MIME_BY_EXTENSION = {
+  // Documents
+  pdf: "application/pdf",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  odt: "application/vnd.oasis.opendocument.text",
+  ods: "application/vnd.oasis.opendocument.spreadsheet",
+  txt: "text/plain",
+  md: "text/markdown",
+  csv: "text/csv",
+  rtf: "application/rtf",
+  html: "text/html",
+  htm: "text/html",
+  css: "text/css",
+  xml: "application/xml",
+  yaml: "application/yaml",
+  yml: "application/yaml",
+  json: "application/json",
+  epub: "application/epub+zip",
+  // Images
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  bmp: "image/bmp",
+  ico: "image/x-icon",
+  tiff: "image/tiff",
+  tif: "image/tiff",
+  avif: "image/avif",
+  heic: "image/heic",
+  // Audio
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  flac: "audio/flac",
+  m4a: "audio/mp4",
+  aac: "audio/aac",
+  opus: "audio/opus",
+  // Video
+  mp4: "video/mp4",
+  mkv: "video/x-matroska",
+  webm: "video/webm",
+  avi: "video/x-msvideo",
+  mov: "video/quicktime",
+  wmv: "video/x-ms-wmv",
+  flv: "video/x-flv",
+  // Archives
+  zip: "application/zip",
+  rar: "application/vnd.rar",
+  "7z": "application/x-7z-compressed",
+  tar: "application/x-tar",
+  gz: "application/gzip",
+  bz2: "application/x-bzip2",
+  xz: "application/x-xz",
+  // Other
+  apk: "application/vnd.android.package-archive",
+  exe: "application/x-msdownload",
+  dmg: "application/x-apple-diskimage",
+  iso: "application/x-iso9660-image",
+  bin: "application/octet-stream"
+};
+var DEFAULT_MIME_TYPE = "application/octet-stream";
+function fileExtension(filename) {
+  const base = filename.split(/[/\\]/).pop() ?? "";
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0 || dot === base.length - 1) return "";
+  return base.slice(dot + 1).toLowerCase();
+}
+function mimeFromFilename(filename) {
+  return MIME_BY_EXTENSION[fileExtension(filename)] ?? DEFAULT_MIME_TYPE;
+}
+var PREFIXED_CATEGORIES = [
+  ["image/", "image"],
+  ["video/", "video"],
+  ["audio/", "audio"],
+  ["application/pdf", "pdf"],
+  ["application/zip", "archive"],
+  ["application/x-tar", "archive"],
+  ["application/gzip", "archive"],
+  ["application/x-7z-compressed", "archive"],
+  ["application/vnd.rar", "archive"],
+  ["application/x-bzip2", "archive"],
+  ["application/x-xz", "archive"],
+  ["text/", "text"],
+  ["application/json", "text"],
+  ["application/xml", "text"],
+  ["application/yaml", "text"],
+  ["application/javascript", "text"],
+  ["text/markdown", "text"]
+];
+var OFFICE_MIMES = /* @__PURE__ */ new Set([
+  "application/msword",
+  "application/vnd.ms-excel",
+  "application/vnd.ms-powerpoint",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  "application/vnd.oasis.opendocument.text",
+  "application/vnd.oasis.opendocument.spreadsheet",
+  "application/rtf",
+  "application/epub+zip"
+]);
+function fileCategory(mimeType) {
+  for (const [prefix, category] of PREFIXED_CATEGORIES) {
+    if (mimeType.startsWith(prefix)) return category;
+  }
+  if (OFFICE_MIMES.has(mimeType)) return "document";
+  return "other";
+}
+
+// ../shared/src/index.ts
+var ERROR_CODES = {
+  VALIDATION: "VALIDATION_ERROR",
+  UNAUTHENTICATED: "UNAUTHENTICATED",
+  FORBIDDEN: "FORBIDDEN",
+  NOT_FOUND: "NOT_FOUND",
+  CONFLICT: "CONFLICT",
+  PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE",
+  RATE_LIMITED: "RATE_LIMITED",
+  STORAGE_NOT_INITIALIZED: "STORAGE_NOT_INITIALIZED",
+  TELEGRAM_ERROR: "TELEGRAM_ERROR",
+  INTERNAL: "INTERNAL_ERROR"
+};
+
+// ../core/src/errors.ts
+var DomainError = class extends Error {
+  code;
+  status;
+  details;
+  constructor(code, status, message, details) {
+    super(message);
+    this.name = new.target.name;
+    this.code = code;
+    this.status = status;
+    this.details = details;
+  }
+};
+var ValidationError = class extends DomainError {
+  constructor(message, details) {
+    super(ERROR_CODES.VALIDATION, 400, message, details);
+  }
+};
+var UnauthorizedError = class extends DomainError {
+  constructor(message = "Authentication required") {
+    super(ERROR_CODES.UNAUTHENTICATED, 401, message);
+  }
+};
+var ForbiddenError = class extends DomainError {
+  constructor(message = "You do not have access to this resource") {
+    super(ERROR_CODES.FORBIDDEN, 403, message);
+  }
+};
+var NotFoundError = class extends DomainError {
+  constructor(message = "Resource not found") {
+    super(ERROR_CODES.NOT_FOUND, 404, message);
+  }
+};
+var RateLimitedError = class extends DomainError {
+  constructor(message = "Too many requests, please retry later") {
+    super(ERROR_CODES.RATE_LIMITED, 429, message);
+  }
+};
+var StorageNotInitializedError = class extends DomainError {
+  constructor() {
+    super(ERROR_CODES.STORAGE_NOT_INITIALIZED, 409, "Storage is not initialized for this account");
+  }
+};
+var StorageProviderError = class extends DomainError {
+  constructor(message, details) {
+    super(ERROR_CODES.TELEGRAM_ERROR, 502, message, details);
+  }
+};
+
+// ../core/src/utils/hash.ts
+import { createHash } from "crypto";
+function sha256Hex(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+
+// ../core/src/storage/engine.ts
+var StorageEngine = class {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  provider;
+  get providerName() {
+    return this.provider.name;
+  }
+  /** Uploads an object and computes its checksum in one step. */
+  async upload(input) {
+    const sha256 = sha256Hex(input.data);
+    let stored;
+    try {
+      stored = await this.provider.put(input);
+    } catch (error) {
+      throw mapProviderError("Upload failed", error);
+    }
+    return { stored, sha256, size: input.data.byteLength };
+  }
+  async download(ref) {
+    try {
+      return await this.provider.get(ref);
+    } catch (error) {
+      throw mapProviderError("Download failed", error);
+    }
+  }
+  async remove(ref) {
+    try {
+      await this.provider.delete(ref);
+    } catch (error) {
+      throw mapProviderError("Delete failed", error);
+    }
+  }
+  async verifyIntegrity(data, expectedSha256) {
+    return sha256Hex(data) === expectedSha256;
+  }
+};
+function mapProviderError(message, error) {
+  if (error instanceof StorageProviderError) return error;
+  const detail = error instanceof Error ? error.message : String(error);
+  return new StorageProviderError(detail ? `${message}: ${detail}` : message, error);
+}
+
+// ../core/src/utils/filename.ts
+function sanitizeFileName(name) {
+  const base = name.split(/[/\\]/).pop() ?? name;
+  const cleaned = base.replace(/[\u0000-\u001f\u007f]/g, "").replace(/[<>:"|?*]/g, "_").trim();
+  if (!cleaned || cleaned === "." || cleaned === "..") return "";
+  return cleaned.slice(0, 255);
+}
+
+// ../core/src/services/file-service.ts
+var FileService = class {
+  constructor(files, folders, engineFor) {
+    this.files = files;
+    this.folders = folders;
+    this.engineFor = engineFor;
+  }
+  files;
+  folders;
+  engineFor;
+  async upload(userId, input) {
+    const name = sanitizeFileName(input.name);
+    if (!name) throw new ValidationError("Invalid file name");
+    if (input.folderId !== null) {
+      const folder = await this.folders.findById(input.folderId);
+      if (!folder || folder.userId !== userId) throw new NotFoundError("Folder not found");
+    }
+    const mimeType = mimeFromFilename(name);
+    const engine = await this.engineFor(userId);
+    const { stored, sha256, size } = await engine.upload({ name, mimeType, data: input.data });
+    return this.files.create({
+      userId,
+      folderId: input.folderId,
+      name,
+      size,
+      mimeType,
+      sha256,
+      telegramMessageId: Number(stored.messageId)
+    });
+  }
+  async list(userId, folderId) {
+    if (folderId !== null) {
+      const folder = await this.folders.findById(folderId);
+      if (!folder || folder.userId !== userId) throw new NotFoundError("Folder not found");
+    }
+    return this.files.listByFolder(userId, folderId);
+  }
+  async get(userId, id) {
+    const record = await this.files.findById(id);
+    if (!record || record.userId !== userId) throw new NotFoundError("File not found");
+    return record;
+  }
+  async rename(userId, id, name) {
+    await this.get(userId, id);
+    const clean = sanitizeFileName(name);
+    if (!clean) throw new ValidationError("Invalid file name");
+    return this.files.update(id, { name: clean });
+  }
+  async move(userId, id, folderId) {
+    await this.get(userId, id);
+    if (folderId !== null) {
+      const folder = await this.folders.findById(folderId);
+      if (!folder || folder.userId !== userId) throw new NotFoundError("Folder not found");
+    }
+    return this.files.update(id, { folderId });
+  }
+  async delete(userId, id) {
+    const record = await this.get(userId, id);
+    const engine = await this.engineFor(userId);
+    try {
+      await engine.remove({ messageId: String(record.telegramMessageId) });
+    } catch {
+    }
+    await this.files.deleteMany([record.id]);
+  }
+  async download(userId, id) {
+    const record = await this.get(userId, id);
+    const engine = await this.engineFor(userId);
+    const data = await engine.download({ messageId: String(record.telegramMessageId) });
+    const integrityVerified = await engine.verifyIntegrity(data, record.sha256);
+    return { record, data, integrityVerified };
+  }
+};
+
+// ../core/src/services/folder-service.ts
+var FolderService = class {
+  constructor(folders, files, engineFor) {
+    this.folders = folders;
+    this.files = files;
+    this.engineFor = engineFor;
+  }
+  folders;
+  files;
+  engineFor;
+  async create(userId, input) {
+    const name = sanitizeFileName(input.name);
+    if (!name) throw new ValidationError("Invalid folder name");
+    if (input.parentId !== null) {
+      const parent = await this.folders.findById(input.parentId);
+      if (!parent || parent.userId !== userId) throw new NotFoundError("Folder not found");
+    }
+    return this.folders.create({ userId, parentId: input.parentId, name });
+  }
+  async listChildren(userId, parentId) {
+    if (parentId !== null) {
+      const parent = await this.folders.findById(parentId);
+      if (!parent || parent.userId !== userId) throw new NotFoundError("Folder not found");
+    }
+    return this.folders.listChildren(userId, parentId);
+  }
+  async tree(userId) {
+    return this.folders.listByUser(userId);
+  }
+  async get(userId, id) {
+    const record = await this.folders.findById(id);
+    if (!record || record.userId !== userId) throw new NotFoundError("Folder not found");
+    return record;
+  }
+  async rename(userId, id, name) {
+    await this.get(userId, id);
+    const clean = sanitizeFileName(name);
+    if (!clean) throw new ValidationError("Invalid folder name");
+    return this.folders.update(id, { name: clean });
+  }
+  async move(userId, id, newParentId) {
+    await this.get(userId, id);
+    if (newParentId === id) throw new ValidationError("Cannot move a folder into itself");
+    if (newParentId !== null) {
+      let cursor = newParentId;
+      while (cursor !== null) {
+        if (cursor === id) {
+          throw new ValidationError("Cannot move a folder into one of its subfolders");
+        }
+        const parent = await this.folders.findById(cursor);
+        if (!parent || parent.userId !== userId) throw new NotFoundError("Folder not found");
+        cursor = parent.parentId;
+      }
+    }
+    return this.folders.update(id, { parentId: newParentId });
+  }
+  async delete(userId, id) {
+    await this.get(userId, id);
+    const all = await this.folders.listByUser(userId);
+    const childrenOf = /* @__PURE__ */ new Map();
+    for (const folder of all) {
+      const list = childrenOf.get(folder.parentId) ?? [];
+      list.push(folder.id);
+      childrenOf.set(folder.parentId, list);
+    }
+    const doomed = [id];
+    const queue = [id];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      for (const child of childrenOf.get(current) ?? []) {
+        doomed.push(child);
+        queue.push(child);
+      }
+    }
+    const doomedSet = new Set(doomed);
+    const userFiles = await this.files.listByUser(userId);
+    const affectedFiles = userFiles.filter((f) => f.folderId !== null && doomedSet.has(f.folderId));
+    const engine = await this.engineFor(userId);
+    for (const file of affectedFiles) {
+      try {
+        await engine.remove({ messageId: String(file.telegramMessageId) });
+      } catch {
+      }
+    }
+    await this.files.deleteMany(affectedFiles.map((f) => f.id));
+    await this.folders.deleteMany(doomed);
+    return { deletedFolders: doomed.length, deletedFiles: affectedFiles.length };
+  }
+};
+
+// ../core/src/services/search-service.ts
+var MAX_QUERY_LENGTH = 100;
+var SearchService = class {
+  constructor(files, folders) {
+    this.files = files;
+    this.folders = folders;
+  }
+  files;
+  folders;
+  async search(userId, query, limit = 25) {
+    const q = query.trim();
+    if (!q) throw new ValidationError("Search query must not be empty");
+    if (q.length > MAX_QUERY_LENGTH) {
+      throw new ValidationError(`Search query must be at most ${MAX_QUERY_LENGTH} characters`);
+    }
+    const [fileResults, folderResults] = await Promise.all([
+      this.files.searchByName(userId, q, limit),
+      this.folders.searchByName(userId, q, limit)
+    ]);
+    return { files: fileResults, folders: folderResults };
+  }
+};
+
+// ../telegram/src/client.ts
+import { Api, TelegramClient } from "telegram";
+import { StringSession } from "telegram/sessions/index.js";
+
+// ../telegram/src/errors.ts
+import { RPCError } from "telegram/errors/index.js";
+function isTelegramRpcError(error) {
+  return error instanceof RPCError;
+}
+function isPasswordRequiredError(error) {
+  return isTelegramRpcError(error) && error.errorMessage === "SESSION_PASSWORD_NEEDED";
+}
+function mapTelegramError(error, fallbackMessage) {
+  if (error instanceof DomainError) return error;
+  if (isTelegramRpcError(error)) {
+    const msg = error.errorMessage ?? "";
+    if (msg.startsWith("FLOOD_WAIT_")) {
+      const seconds = Number(msg.slice("FLOOD_WAIT_".length)) || 60;
+      return new RateLimitedError(`Telegram rate limit reached \u2014 retry in ${seconds} seconds`);
+    }
+    switch (msg) {
+      case "PHONE_NUMBER_INVALID":
+        return new ValidationError("This phone number is not valid");
+      case "PHONE_NUMBER_UNOCCUPIED":
+        return new ValidationError("No Telegram account exists for this phone number");
+      case "PHONE_CODE_INVALID":
+        return new ValidationError("Invalid confirmation code");
+      case "PHONE_CODE_EXPIRED":
+        return new ValidationError("The confirmation code has expired \u2014 request a new one");
+      case "PHONE_CODE_EMPTY":
+        return new ValidationError("Please enter the confirmation code");
+      case "SESSION_PASSWORD_NEEDED":
+        return new UnauthorizedError("Two-factor authentication is enabled on this account");
+      case "PASSWORD_HASH_INVALID":
+        return new ValidationError("Incorrect two-factor password");
+      case "PHONE_NUMBER_BANNED":
+        return new ForbiddenError("This phone number is banned from Telegram");
+      case "AUTH_KEY_UNREGISTERED":
+      case "SESSION_REVOKED":
+      case "USER_DEACTIVATED":
+        return new UnauthorizedError("The Telegram session is no longer valid \u2014 please reconnect");
+      case "CHANNEL_PRIVATE":
+      case "CHAT_ID_INVALID":
+        return new StorageNotInitializedError();
+      default:
+        return new StorageProviderError(fallbackMessage, {
+          code: error.code,
+          telegramError: msg
+        });
+    }
+  }
+  return new StorageProviderError(
+    error instanceof Error ? `${fallbackMessage}: ${error.message}` : fallbackMessage,
+    error
+  );
+}
+
+// ../telegram/src/client.ts
+var TelegramClientManager = class {
+  constructor(credentials, sessions) {
+    this.credentials = credentials;
+    this.sessions = sessions;
+  }
+  credentials;
+  sessions;
+  clients = /* @__PURE__ */ new Map();
+  async getForUser(userId) {
+    const cached = this.clients.get(userId);
+    if (cached) {
+      try {
+        return await cached;
+      } catch {
+        this.clients.delete(userId);
+      }
+    }
+    const session = await this.sessions.get(userId);
+    if (!session) {
+      throw new UnauthorizedError("Telegram account is not connected");
+    }
+    const promise = this.connect(session.stringSession);
+    this.clients.set(userId, promise);
+    try {
+      return await promise;
+    } catch (error) {
+      this.clients.delete(userId);
+      throw mapTelegramError(error, "Could not connect to Telegram");
+    }
+  }
+  /** Registers an already-authenticated client (e.g. from the login flow). */
+  cacheClient(userId, client) {
+    this.clients.set(userId, Promise.resolve(client));
+  }
+  async disconnectAll() {
+    for (const [userId, promise] of this.clients) {
+      this.clients.delete(userId);
+      try {
+        const client = await promise;
+        await client.disconnect();
+      } catch {
+      }
+    }
+  }
+  async connect(sessionString) {
+    const client = new TelegramClient(
+      new StringSession(sessionString),
+      this.credentials.apiId,
+      this.credentials.apiHash,
+      { connectionRetries: 3 }
+    );
+    await client.connect();
+    return client;
+  }
+};
+function newTelegramClient(credentials) {
+  return new TelegramClient(new StringSession(""), credentials.apiId, credentials.apiHash, {
+    connectionRetries: 3
+  });
+}
+function extractCreatedChannel(result) {
+  const chats = result instanceof Api.Updates || result instanceof Api.UpdatesCombined ? result.chats : [];
+  for (const chat of chats) {
+    if (chat instanceof Api.Channel) return chat;
+  }
+  throw new StorageProviderError("Telegram did not return the created storage channel");
+}
+
+// ../telegram/src/provider.ts
+import { Api as Api2 } from "telegram";
+import bigInt from "big-integer";
+import { CustomFile } from "telegram/client/uploads.js";
+var TelegramStorageProvider = class {
+  constructor(client, options) {
+    this.client = client;
+    this.peer = new Api2.InputPeerChannel({
+      channelId: bigInt(options.chatId),
+      accessHash: bigInt(options.accessHash)
+    });
+  }
+  client;
+  name = "telegram";
+  peer;
+  async put(input) {
+    try {
+      const file = new CustomFile(input.name, input.data.byteLength, "", input.data);
+      const message = await this.client.sendFile(this.peer, {
+        file,
+        forceDocument: true,
+        workers: 1
+      });
+      if (!(message instanceof Api2.Message)) {
+        throw new StorageProviderError("Telegram returned an unexpected upload response");
+      }
+      return {
+        messageId: message.id.toString(),
+        name: input.name,
+        size: input.data.byteLength,
+        mimeType: input.mimeType
+      };
+    } catch (error) {
+      throw mapTelegramError(error, "Telegram upload failed");
+    }
+  }
+  async get(ref) {
+    let data;
+    try {
+      const message = await this.getMessage(ref.messageId);
+      if (!message?.media) {
+        throw new StorageProviderError("The stored file is missing from Telegram");
+      }
+      data = await this.client.downloadMedia(message, {});
+    } catch (error) {
+      if (error instanceof StorageProviderError) throw error;
+      throw mapTelegramError(error, "Telegram download failed");
+    }
+    if (!data || typeof data === "string") {
+      throw new StorageProviderError("Telegram did not return file content");
+    }
+    return Buffer.from(data);
+  }
+  async delete(ref) {
+    try {
+      await this.client.deleteMessages(this.peer, [Number(ref.messageId)], { revoke: true });
+    } catch (error) {
+      throw mapTelegramError(error, "Telegram delete failed");
+    }
+  }
+  async exists(ref) {
+    try {
+      return await this.stat(ref) !== null;
+    } catch (error) {
+      throw mapTelegramError(error, "Telegram lookup failed");
+    }
+  }
+  async stat(ref) {
+    let message;
+    try {
+      message = await this.getMessage(ref.messageId);
+    } catch (error) {
+      throw mapTelegramError(error, "Telegram lookup failed");
+    }
+    if (!message?.media) return null;
+    const document = message.document;
+    if (!(document instanceof Api2.Document)) return null;
+    let fileName;
+    for (const attr of document.attributes) {
+      if (attr instanceof Api2.DocumentAttributeFilename) {
+        fileName = attr.fileName;
+        break;
+      }
+    }
+    return {
+      messageId: ref.messageId,
+      name: fileName ?? "file",
+      size: Number(document.size.toString()),
+      mimeType: document.mimeType
+    };
+  }
+  async getMessage(id) {
+    const messages = await this.client.getMessages(this.peer, { ids: [Number(id)] });
+    const first = messages[0];
+    return first instanceof Api2.Message ? first : void 0;
+  }
+};
+
+// ../telegram/src/connection.ts
+import { Api as Api3 } from "telegram";
+import { computeCheck } from "telegram/Password.js";
+var TELEGRAM_PROVIDER = "telegram";
+var LOGIN_FLOW_TTL_MS = 5 * 60 * 1e3;
+var TelegramConnectionService = class {
+  constructor(repos, clientManager, credentials) {
+    this.repos = repos;
+    this.clientManager = clientManager;
+    this.credentials = credentials;
+  }
+  repos;
+  clientManager;
+  credentials;
+  flows = /* @__PURE__ */ new Map();
+  /** Sends the Telegram confirmation code for the phone number. */
+  async startLogin(phone) {
+    this.sweepExpiredFlows();
+    await this.cancelLogin(phone);
+    const client = newTelegramClient(this.credentials);
+    try {
+      await client.connect();
+      const { phoneCodeHash } = await client.sendCode(
+        { apiId: this.credentials.apiId, apiHash: this.credentials.apiHash },
+        phone
+      );
+      this.flows.set(phone, { phone, client, phoneCodeHash, createdAt: Date.now() });
+    } catch (error) {
+      await this.disconnectQuietly(client);
+      throw mapTelegramError(error, "Could not send the Telegram confirmation code");
+    }
+  }
+  /** Verifies the confirmation code. Returns `password_required` for 2FA accounts. */
+  async verifyCode(phone, code) {
+    const flow = this.requireFlow(phone);
+    try {
+      await flow.client.invoke(
+        new Api3.auth.SignIn({
+          phoneNumber: flow.phone,
+          phoneCodeHash: flow.phoneCodeHash,
+          phoneCode: code
+        })
+      );
+    } catch (error) {
+      if (isPasswordRequiredError(error)) {
+        return { status: "password_required" };
+      }
+      throw mapTelegramError(error, "Telegram sign-in failed");
+    }
+    return this.finalizeLogin(flow);
+  }
+  /** Completes sign-in for accounts with two-factor authentication enabled. */
+  async verifyPassword(phone, password) {
+    const flow = this.requireFlow(phone);
+    try {
+      const passwordInfo = await flow.client.invoke(new Api3.account.GetPassword());
+      const check = await computeCheck(passwordInfo, password);
+      await flow.client.invoke(new Api3.auth.CheckPassword({ password: check }));
+    } catch (error) {
+      throw mapTelegramError(error, "Telegram sign-in failed");
+    }
+    return this.finalizeLogin(flow);
+  }
+  /** Aborts a pending login flow (disconnects the client). */
+  async cancelLogin(phone) {
+    const flow = this.flows.get(phone);
+    if (flow) {
+      this.flows.delete(phone);
+      await this.disconnectQuietly(flow.client);
+    }
+  }
+  /**
+   * Ensures the user has a registered private storage channel, creating it
+   * on first use. Idempotent.
+   */
+  async ensureStorage(userId) {
+    const existing = await this.repos.storages.findByUserAndProvider(userId, TELEGRAM_PROVIDER);
+    if (existing) return existing;
+    const client = await this.clientManager.getForUser(userId);
+    return this.ensureStorageForClient(userId, client);
+  }
+  async ensureStorageForClient(userId, client) {
+    const existing = await this.repos.storages.findByUserAndProvider(userId, TELEGRAM_PROVIDER);
+    if (existing) return existing;
+    let channel;
+    try {
+      const result = await client.invoke(
+        new Api3.channels.CreateChannel({
+          title: "OmniCloud Storage",
+          about: "Private storage channel created by OmniCloud (https://github.com/Lacrous/OmniCloud)",
+          megagroup: false
+        })
+      );
+      channel = extractCreatedChannel(result);
+    } catch (error) {
+      throw mapTelegramError(error, "Could not create the private storage channel");
+    }
+    const accessHash = channel.accessHash?.toString();
+    if (!accessHash) {
+      throw new StorageProviderError("Telegram did not provide the channel access hash");
+    }
+    return this.repos.storages.create({
+      userId,
+      provider: TELEGRAM_PROVIDER,
+      title: channel.title ?? "OmniCloud Storage",
+      telegramChatId: channel.id.toString(),
+      telegramAccessHash: accessHash
+    });
+  }
+  // ── internals ────────────────────────────────────────────────────────────
+  requireFlow(phone) {
+    const flow = this.flows.get(phone);
+    if (!flow) {
+      throw new NotFoundError("No pending Telegram login for this phone number");
+    }
+    if (Date.now() - flow.createdAt > LOGIN_FLOW_TTL_MS) {
+      this.flows.delete(phone);
+      void this.disconnectQuietly(flow.client);
+      throw new ValidationError("The login session expired \u2014 please start again");
+    }
+    return flow;
+  }
+  async finalizeLogin(flow) {
+    this.flows.delete(flow.phone);
+    let stringSession;
+    let user;
+    try {
+      stringSession = flow.client.session.save();
+      const me = await flow.client.getMe();
+      if (!(me instanceof Api3.User)) {
+        throw new Error("Telegram did not return the authenticated user");
+      }
+      user = await this.repos.users.upsertFromTelegram({
+        telegramUserId: me.id.toString(),
+        username: me.username ?? null,
+        firstName: me.firstName ?? null,
+        lastName: me.lastName ?? null,
+        phone: me.phone ?? flow.phone
+      });
+    } catch (error) {
+      await this.disconnectQuietly(flow.client);
+      throw mapTelegramError(error, "Could not complete the Telegram connection");
+    }
+    await this.repos.sessions.save(user.id, stringSession);
+    await this.ensureStorageForClient(user.id, flow.client);
+    this.clientManager.cacheClient(user.id, flow.client);
+    return { status: "ok", user };
+  }
+  sweepExpiredFlows() {
+    const now = Date.now();
+    for (const [phone, flow] of this.flows) {
+      if (now - flow.createdAt > LOGIN_FLOW_TTL_MS) {
+        this.flows.delete(phone);
+        void this.disconnectQuietly(flow.client);
+      }
+    }
+  }
+  async disconnectQuietly(client) {
+    try {
+      await client.disconnect();
+    } catch {
+    }
+  }
+};
+export {
+  ERROR_CODES,
+  FileService,
+  FolderService,
+  OmniCloudClient,
+  OmniCloudError,
+  SearchService,
+  StorageEngine,
+  TELEGRAM_PROVIDER,
+  TelegramClientManager,
+  TelegramConnectionService,
+  TelegramStorageProvider,
+  fileCategory,
+  mapProviderError,
+  mapTelegramError,
+  mimeFromFilename,
+  sanitizeFileName,
+  sha256Hex
+};
+//# sourceMappingURL=index.js.map