hazo_files 3.0.0 → 3.1.0

package/dist/index.js

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ALL_SYSTEM_VARIABLES: () => ALL_SYSTEM_VARIABLES,
+  AppFileServerProvider: () => AppFileServerProvider,
   AuthenticationError: () => AuthenticationError,
   ConfigurationError: () => ConfigurationError,
   DEFAULT_DATE_FORMATS: () => DEFAULT_DATE_FORMATS,
@@ -46,6 +47,7 @@ __export(index_exports, {
   FileTooLargeError: () => FileTooLargeError,
   GoogleDriveAuth: () => GoogleDriveAuth,
   GoogleDriveModule: () => GoogleDriveModule,
+  GoogleDriveProvider: () => GoogleDriveProvider,
   HAZO_FILES_DEFAULT_TABLE_NAME: () => HAZO_FILES_DEFAULT_TABLE_NAME,
   HAZO_FILES_MIGRATION_V2: () => HAZO_FILES_MIGRATION_V2,
   HAZO_FILES_MIGRATION_V3: () => HAZO_FILES_MIGRATION_V3,
@@ -53,6 +55,7 @@ __export(index_exports, {
   HAZO_FILES_NAMING_TABLE_SCHEMA: () => HAZO_FILES_NAMING_TABLE_SCHEMA,
   HAZO_FILES_TABLE_SCHEMA: () => HAZO_FILES_TABLE_SCHEMA,
   HazoFilesError: () => import_hazo_core2.HazoError,
+  InMemoryProvider: () => InMemoryProvider,
   InvalidExtensionError: () => InvalidExtensionError,
   InvalidPathError: () => InvalidPathError,
   LLMExtractionService: () => LLMExtractionService,
@@ -64,6 +67,9 @@ __export(index_exports, {
   SYSTEM_COUNTER_VARIABLES: () => SYSTEM_COUNTER_VARIABLES,
   SYSTEM_DATE_VARIABLES: () => SYSTEM_DATE_VARIABLES,
   SYSTEM_FILE_VARIABLES: () => SYSTEM_FILE_VARIABLES,
+  StorageCollisionExhausted: () => StorageCollisionExhausted,
+  StorageNotConfigured: () => StorageNotConfigured,
+  StorageUnavailable: () => StorageUnavailable,
   TrackedFileManager: () => TrackedFileManager,
   UploadExtractService: () => UploadExtractService,
   addExtractionToFileData: () => addExtractionToFileData,
@@ -20613,6 +20619,19 @@ var StorageCollisionExhausted = class extends Error {
     this.name = "StorageCollisionExhausted";
   }
 };
+var StorageNotConfigured = class extends Error {
+  constructor() {
+    super("Storage provider is not configured for this scope");
+    this.name = "StorageNotConfigured";
+  }
+};
+var StorageUnavailable = class extends Error {
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+    this.name = "StorageUnavailable";
+  }
+};
 
 // src/naming/collision.ts
 async function writeWithCollisionRetry(opts) {
@@ -20646,9 +20665,403 @@ function removeRef(file2, ref_id, removed_at) {
 function countRefs(file2) {
   return file2.file_refs.filter((r) => !r.removed_at).length;
 }
+
+// src/providers/app-file-server.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var AppFileServerProvider = class {
+  constructor(opts) {
+    this.provider_tag = "app_file_server";
+    this.root = (0, import_node_path.normalize)(opts.root);
+    this.secret = opts.hmac_secret;
+    this.default_ttl = opts.default_ttl_seconds ?? 300;
+  }
+  resolve(path4) {
+    const safe = (0, import_node_path.normalize)(path4).replace(/^([./\\])+/, "");
+    if (safe.includes(`..${import_node_path.sep}`) || safe.startsWith("..")) {
+      throw new Error(`Path escapes root: ${path4}`);
+    }
+    return (0, import_node_path.join)(this.root, safe);
+  }
+  async put(path4, body, opts) {
+    const abs = this.resolve(path4);
+    if (opts?.ifNotExists && (0, import_node_fs.existsSync)(abs)) {
+      throw new Error(`File exists: ${path4}`);
+    }
+    (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(abs), { recursive: true });
+    const buf = Buffer.isBuffer(body) ? body : await streamToBuffer(body);
+    (0, import_node_fs.writeFileSync)(abs, buf);
+    return { provider: this.provider_tag, native_id: path4, size: buf.length };
+  }
+  async get(path4) {
+    return (0, import_node_fs.readFileSync)(this.resolve(path4));
+  }
+  async delete(path4) {
+    const abs = this.resolve(path4);
+    if ((0, import_node_fs.existsSync)(abs)) (0, import_node_fs.rmSync)(abs, { force: true });
+  }
+  async exists(path4) {
+    return (0, import_node_fs.existsSync)(this.resolve(path4));
+  }
+  async getSignedUrl(path4, opts) {
+    const ttl = opts?.ttl_seconds ?? this.default_ttl;
+    const exp = Math.floor(Date.now() / 1e3) + ttl;
+    const payload = `${path4}:${exp}`;
+    const sig = (0, import_node_crypto.createHmac)("sha256", this.secret).update(payload).digest("base64url");
+    const token = `${exp}.${sig}`;
+    return `/api/files/serve/${token}/${path4}`;
+  }
+  /** Verify a token produced by `getSignedUrl`. Used by the `/api/files/serve` route. */
+  verifySignedUrl(token, path4) {
+    const [expStr, sig] = token.split(".");
+    const exp = Number(expStr);
+    if (!Number.isFinite(exp) || exp * 1e3 < Date.now()) return false;
+    const expected = (0, import_node_crypto.createHmac)("sha256", this.secret).update(`${path4}:${exp}`).digest("base64url");
+    return sig === expected;
+  }
+  async probe() {
+    try {
+      const test = (0, import_node_path.join)(this.root, ".hazo_probe");
+      (0, import_node_fs.mkdirSync)(this.root, { recursive: true });
+      (0, import_node_fs.writeFileSync)(test, "probe");
+      (0, import_node_fs.statSync)(test);
+      (0, import_node_fs.rmSync)(test, { force: true });
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, error: "write_denied", message: String(err) };
+    }
+  }
+  async list(prefix) {
+    const abs = this.resolve(prefix);
+    if (!(0, import_node_fs.existsSync)(abs)) return [];
+    const stat = (0, import_node_fs.statSync)(abs);
+    if (!stat.isDirectory()) {
+      return [{ path: prefix, name: (0, import_node_path.basename)(prefix), size: stat.size, isDirectory: false }];
+    }
+    const entries = [];
+    this.walkDir(abs, prefix, entries);
+    return entries;
+  }
+  walkDir(absDir, logicalDir, out) {
+    const base = logicalDir.endsWith("/") ? logicalDir : `${logicalDir}/`;
+    for (const item of (0, import_node_fs.readdirSync)(absDir, { withFileTypes: true })) {
+      const logicalPath = `${base}${item.name}`;
+      const absPath = (0, import_node_path.join)(absDir, item.name);
+      if (item.isDirectory()) {
+        out.push({ path: logicalPath, name: item.name, size: 0, isDirectory: true });
+        this.walkDir(absPath, logicalPath, out);
+      } else {
+        const st = (0, import_node_fs.statSync)(absPath);
+        out.push({ path: logicalPath, name: item.name, size: st.size, isDirectory: false });
+      }
+    }
+  }
+  async move(from, to) {
+    const absFrom = this.resolve(from);
+    const absTo = this.resolve(to);
+    if (!(0, import_node_fs.existsSync)(absFrom)) throw new Error(`Not found: ${from}`);
+    (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(absTo), { recursive: true });
+    try {
+      (0, import_node_fs.renameSync)(absFrom, absTo);
+    } catch (err) {
+      const e = err;
+      if (e.code === "EXDEV") {
+        (0, import_node_fs.copyFileSync)(absFrom, absTo);
+        (0, import_node_fs.rmSync)(absFrom, { force: true });
+      } else {
+        throw err;
+      }
+    }
+  }
+  async rename(from, to) {
+    return this.move(from, to);
+  }
+};
+async function streamToBuffer(s) {
+  const chunks = [];
+  for await (const c of s) chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(c));
+  return Buffer.concat(chunks);
+}
+
+// src/providers/in-memory.ts
+var InMemoryProvider = class {
+  constructor() {
+    this.provider_tag = "in_memory";
+    this.store = /* @__PURE__ */ new Map();
+  }
+  async put(path4, body, opts) {
+    if (opts?.ifNotExists && this.store.has(path4)) throw new Error(`File exists: ${path4}`);
+    const buf = Buffer.isBuffer(body) ? body : await streamToBuffer2(body);
+    this.store.set(path4, buf);
+    return { provider: this.provider_tag, native_id: path4, size: buf.length };
+  }
+  async get(path4) {
+    const buf = this.store.get(path4);
+    if (!buf) throw new Error(`Not found: ${path4}`);
+    return buf;
+  }
+  async delete(path4) {
+    this.store.delete(path4);
+  }
+  async exists(path4) {
+    return this.store.has(path4);
+  }
+  async getSignedUrl(path4, _opts) {
+    const buf = this.store.get(path4);
+    if (!buf) throw new Error(`Not found: ${path4}`);
+    return `data:application/octet-stream;base64,${buf.toString("base64")}`;
+  }
+  async probe() {
+    return { ok: true };
+  }
+  async list(prefix) {
+    const base = prefix.replace(/\/$/, "");
+    const matchPrefix = `${base}/`;
+    const entries = [];
+    const seenDirs = /* @__PURE__ */ new Set();
+    for (const [key, buf] of this.store.entries()) {
+      if (key !== base && !key.startsWith(matchPrefix)) continue;
+      const rel = key.startsWith(matchPrefix) ? key.slice(matchPrefix.length) : "";
+      if (!rel) {
+        entries.push({ path: key, name: key.split("/").pop(), size: buf.length, isDirectory: false });
+        continue;
+      }
+      const parts = rel.split("/");
+      for (let i = 1; i < parts.length; i++) {
+        const dirPath = matchPrefix + parts.slice(0, i).join("/");
+        if (!seenDirs.has(dirPath)) {
+          seenDirs.add(dirPath);
+          entries.push({ path: dirPath, name: parts[i - 1], size: 0, isDirectory: true });
+        }
+      }
+      entries.push({ path: key, name: parts[parts.length - 1], size: buf.length, isDirectory: false });
+    }
+    return entries;
+  }
+  async move(from, to) {
+    const buf = this.store.get(from);
+    if (!buf) throw new Error(`Not found: ${from}`);
+    this.store.set(to, buf);
+    this.store.delete(from);
+  }
+  async rename(from, to) {
+    return this.move(from, to);
+  }
+  /** Test-only escape hatch — exposes the internal store for assertions. */
+  snapshot() {
+    return new Map(this.store);
+  }
+};
+async function streamToBuffer2(s) {
+  const chunks = [];
+  for await (const c of s) chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(c));
+  return Buffer.concat(chunks);
+}
+
+// src/providers/google-drive.ts
+var import_googleapis3 = require("googleapis");
+var GoogleDriveProvider = class {
+  constructor(opts) {
+    this.provider_tag = "gdrive";
+    let credentials = {};
+    try {
+      credentials = JSON.parse(opts.service_account_json);
+    } catch {
+    }
+    const auth = new import_googleapis3.google.auth.GoogleAuth({
+      credentials,
+      scopes: ["https://www.googleapis.com/auth/drive"]
+    });
+    this.drive = import_googleapis3.google.drive({ version: "v3", auth });
+    this.driveId = opts.shared_drive_id;
+    this.cache = opts.path_cache;
+  }
+  async probe() {
+    try {
+      await this.drive.drives.get({
+        driveId: this.driveId,
+        supportsAllDrives: true
+      });
+      return { ok: true };
+    } catch (err) {
+      const e = err;
+      if (e?.code === 404) return { ok: false, error: "drive_not_shared", message: "SA cannot see Shared Drive" };
+      if (e?.code === 403) return { ok: false, error: "write_denied", message: "SA lacks permission" };
+      return { ok: false, error: "transient", message: String(err) };
+    }
+  }
+  async put(path4, body, opts) {
+    const segments = path4.split("/").filter(Boolean);
+    const filename = segments.pop();
+    const parentId = await this.resolvePath(segments, { create: true });
+    if (opts?.ifNotExists) {
+      const existing = await this.findChild(filename, parentId);
+      if (existing) throw new Error(`File exists: ${path4}`);
+    }
+    const buf = Buffer.isBuffer(body) ? body : await streamToBuffer3(body);
+    const res = await this.drive.files.create({
+      requestBody: {
+        name: filename,
+        parents: [parentId],
+        mimeType: opts?.contentType ?? "application/octet-stream"
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      media: { body: buf },
+      fields: "id, name"
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+    return { provider: this.provider_tag, native_id: res.data.id, size: buf.length };
+  }
+  async get(path4) {
+    const id = await this.lookupFileId(path4);
+    const res = await this.drive.files.get(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      { fileId: id, alt: "media", supportsAllDrives: true },
+      { responseType: "arraybuffer" }
+    );
+    return Buffer.from(res.data);
+  }
+  async delete(path4) {
+    try {
+      const id = await this.lookupFileId(path4);
+      await this.drive.files.delete({ fileId: id, supportsAllDrives: true });
+    } catch (err) {
+      const e = err;
+      if (e?.code !== 404) throw err;
+    }
+  }
+  async exists(path4) {
+    try {
+      await this.lookupFileId(path4);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getSignedUrl(path4, _opts) {
+    const id = await this.lookupFileId(path4);
+    return `https://drive.google.com/uc?id=${id}&export=download`;
+  }
+  async list(prefix) {
+    const segments = prefix.split("/").filter(Boolean);
+    let parentId;
+    try {
+      parentId = await this.resolvePath(segments, { create: false });
+    } catch {
+      return [];
+    }
+    const res = await this.drive.files.list({
+      q: `'${parentId}' in parents and trashed=false`,
+      driveId: this.driveId,
+      corpora: "drive",
+      includeItemsFromAllDrives: true,
+      fields: "files(id, name, mimeType, size)"
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+    const files = res.data.files ?? [];
+    const base = prefix.endsWith("/") ? prefix : `${prefix}/`;
+    return files.map((f) => ({
+      path: `${base}${f.name}`,
+      name: f.name,
+      size: Number(f.size ?? 0),
+      isDirectory: f.mimeType === "application/vnd.google-apps.folder"
+    }));
+  }
+  async move(from, to) {
+    const id = await this.lookupFileId(from);
+    const fromSegs = from.split("/").filter(Boolean);
+    fromSegs.pop();
+    const toSegs = to.split("/").filter(Boolean);
+    const newName = toSegs.pop();
+    const oldParentId = await this.resolvePath(fromSegs, { create: false });
+    const newParentId = await this.resolvePath(toSegs, { create: true });
+    await this.drive.files.update({
+      fileId: id,
+      addParents: newParentId,
+      removeParents: oldParentId,
+      requestBody: { name: newName },
+      supportsAllDrives: true,
+      fields: "id, parents"
+    });
+    await this.cache.invalidate(from);
+  }
+  async rename(from, to) {
+    const id = await this.lookupFileId(from);
+    const segs = to.split("/").filter(Boolean);
+    const newName = segs[segs.length - 1];
+    await this.drive.files.update({
+      fileId: id,
+      requestBody: { name: newName },
+      supportsAllDrives: true,
+      fields: "id, name"
+    });
+  }
+  async resolvePath(segments, opts) {
+    let parentId = this.driveId;
+    const accumulated = [];
+    for (const segment of segments) {
+      accumulated.push(segment);
+      const cacheKey = accumulated.join("/");
+      const cached2 = await this.cache.lookup(cacheKey);
+      if (cached2) {
+        parentId = cached2;
+        continue;
+      }
+      let found = await this.findChild(segment, parentId, "application/vnd.google-apps.folder");
+      if (!found && opts.create) {
+        const created = await this.drive.files.create({
+          requestBody: {
+            name: segment,
+            parents: [parentId],
+            mimeType: "application/vnd.google-apps.folder"
+          },
+          fields: "id"
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        });
+        found = created.data.id;
+      }
+      if (!found) throw new Error(`Folder not found and create=false: ${cacheKey}`);
+      await this.cache.write(cacheKey, found);
+      parentId = found;
+    }
+    return parentId;
+  }
+  async findChild(name, parentId, mimeType) {
+    const q = [
+      `name='${name.replace(/'/g, "\\'")}'`,
+      `'${parentId}' in parents`,
+      `trashed=false`
+    ];
+    if (mimeType) q.push(`mimeType='${mimeType}'`);
+    const res = await this.drive.files.list({
+      q: q.join(" and "),
+      driveId: this.driveId,
+      corpora: "drive",
+      includeItemsFromAllDrives: true,
+      fields: "files(id, name)"
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+    return res.data.files?.[0]?.id ?? null;
+  }
+  async lookupFileId(path4) {
+    const segments = path4.split("/").filter(Boolean);
+    const filename = segments.pop();
+    const parentId = await this.resolvePath(segments, { create: false });
+    const id = await this.findChild(filename, parentId);
+    if (!id) throw Object.assign(new Error(`Not found: ${path4}`), { code: 404 });
+    return id;
+  }
+};
+async function streamToBuffer3(s) {
+  const chunks = [];
+  for await (const c of s) chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(c));
+  return Buffer.concat(chunks);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALL_SYSTEM_VARIABLES,
+  AppFileServerProvider,
   AuthenticationError,
   ConfigurationError,
   DEFAULT_DATE_FORMATS,
@@ -20664,6 +21077,7 @@ function countRefs(file2) {
   FileTooLargeError,
   GoogleDriveAuth,
   GoogleDriveModule,
+  GoogleDriveProvider,
   HAZO_FILES_DEFAULT_TABLE_NAME,
   HAZO_FILES_MIGRATION_V2,
   HAZO_FILES_MIGRATION_V3,
@@ -20671,6 +21085,7 @@ function countRefs(file2) {
   HAZO_FILES_NAMING_TABLE_SCHEMA,
   HAZO_FILES_TABLE_SCHEMA,
   HazoFilesError,
+  InMemoryProvider,
   InvalidExtensionError,
   InvalidPathError,
   LLMExtractionService,
@@ -20682,6 +21097,9 @@ function countRefs(file2) {
   SYSTEM_COUNTER_VARIABLES,
   SYSTEM_DATE_VARIABLES,
   SYSTEM_FILE_VARIABLES,
+  StorageCollisionExhausted,
+  StorageNotConfigured,
+  StorageUnavailable,
   TrackedFileManager,
   UploadExtractService,
   addExtractionToFileData,