hazo_files 3.0.0 → 3.1.0

package/dist/server/index.mjs

@@ -20847,14 +20847,17 @@ var HAZO_FILE_QUOTAS_TABLE_SCHEMA = {
 // src/providers/app-file-server.ts
 import { createHmac } from "crypto";
 import {
+  copyFileSync,
   existsSync as existsSync2,
   mkdirSync,
+  readdirSync,
   readFileSync as readFileSync2,
+  renameSync,
   rmSync,
   statSync,
   writeFileSync
 } from "fs";
-import { dirname as dirname2, join as join4, normalize, sep } from "path";
+import { basename as basename2, dirname as dirname2, join as join4, normalize, sep } from "path";
 var AppFileServerProvider = class {
   constructor(opts) {
     this.provider_tag = "app_file_server";
@@ -20917,6 +20920,51 @@ var AppFileServerProvider = class {
       return { ok: false, error: "write_denied", message: String(err) };
     }
   }
+  async list(prefix) {
+    const abs = this.resolve(prefix);
+    if (!existsSync2(abs)) return [];
+    const stat = statSync(abs);
+    if (!stat.isDirectory()) {
+      return [{ path: prefix, name: basename2(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 readdirSync(absDir, { withFileTypes: true })) {
+      const logicalPath = `${base}${item.name}`;
+      const absPath = join4(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 = 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 (!existsSync2(absFrom)) throw new Error(`Not found: ${from}`);
+    mkdirSync(dirname2(absTo), { recursive: true });
+    try {
+      renameSync(absFrom, absTo);
+    } catch (err) {
+      const e = err;
+      if (e.code === "EXDEV") {
+        copyFileSync(absFrom, absTo);
+        rmSync(absFrom, { force: true });
+      } else {
+        throw err;
+      }
+    }
+  }
+  async rename(from, to) {
+    return this.move(from, to);
+  }
 };
 async function streamToBuffer(s) {
   const chunks = [];
@@ -20955,6 +21003,39 @@ var InMemoryProvider = class {
   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);
@@ -21050,6 +21131,60 @@ var GoogleDriveProvider = class {
     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 = [];
@@ -21167,6 +21302,132 @@ async function migrateToV3(executor, dbType, tableName) {
   }
 }
 
+// src/server/external-file-link.ts
+function assert_absolute_http(base) {
+  if (!/^https?:\/\//i.test(base)) {
+    throw new Error(`external_file_link: serve_base must be an absolute http(s) URL, got "${base}"`);
+  }
+}
+async function external_file_link(file_id, deps, opts = {}) {
+  const record2 = opts.metadata ?? await deps.metadataService.findById(file_id);
+  if (!record2) throw new Error(`external_file_link: file not found (${file_id})`);
+  const storage_type = record2.storage_type;
+  if (storage_type === "local" || storage_type === "app_file_server") {
+    const base = opts.serve_base;
+    if (!base) {
+      throw new Error(`external_file_link: serve_base is required for ${storage_type} storage (file ${file_id})`);
+    }
+    assert_absolute_http(base);
+    const path4 = opts.serve_path ?? "/api/files/serve";
+    const url2 = `${base.replace(/\/$/, "")}${path4}?file_id=${encodeURIComponent(file_id)}`;
+    return { url: url2, link_type: "app_gated", storage_type };
+  }
+  if (storage_type === "google_drive") {
+    const url2 = read_drive_link(record2);
+    if (!url2) throw new Error(`external_file_link: no Google Drive link for file ${file_id}`);
+    return { url: url2, link_type: "provider_managed", storage_type };
+  }
+  if (storage_type === "dropbox") {
+    throw new Error("external_file_link: Dropbox storage is not yet supported");
+  }
+  throw new Error(`external_file_link: Unsupported storage_type "${storage_type}" (file ${file_id})`);
+}
+function read_drive_link(record2) {
+  let data = {};
+  try {
+    data = JSON.parse(record2.file_data || "{}");
+  } catch {
+    data = {};
+  }
+  const nested = data.metadata ?? {};
+  const webViewLink = data.webViewLink ?? nested.webViewLink;
+  if (typeof webViewLink === "string" && webViewLink) return webViewLink;
+  const driveId = data.driveId ?? nested.driveId;
+  if (typeof driveId === "string" && driveId) return `https://drive.google.com/file/d/${driveId}/view`;
+  return null;
+}
+async function external_file_links(file_ids, deps, opts = {}) {
+  const out = {};
+  await Promise.all(
+    file_ids.map(async (id) => {
+      try {
+        out[id] = await external_file_link(id, deps, opts);
+      } catch (err) {
+        out[id] = { error: err instanceof Error ? err.message : String(err) };
+      }
+    })
+  );
+  return out;
+}
+
+// src/server/file-serve-handler.ts
+import { Readable as Readable3 } from "stream";
+function default_get_file_id(request) {
+  return new URL(request.url).searchParams.get("file_id");
+}
+function to_body(data) {
+  if (Buffer.isBuffer(data)) return data;
+  return Readable3.toWeb(data);
+}
+var INLINE_SAFE_TYPES = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/jpg",
+  "image/gif",
+  "image/webp",
+  "image/avif",
+  "application/pdf",
+  "text/plain"
+]);
+function safe_content_headers(mime, filename) {
+  const safe_name = filename.replace(/"/g, "");
+  const inline_safe = INLINE_SAFE_TYPES.has(mime) || mime.startsWith("video/") || mime.startsWith("audio/");
+  return {
+    "Content-Type": inline_safe ? mime : "application/octet-stream",
+    "Content-Disposition": `${inline_safe ? "inline" : "attachment"}; filename="${safe_name}"`,
+    "X-Content-Type-Options": "nosniff",
+    "Content-Security-Policy": "sandbox"
+  };
+}
+function createFileServeHandler(opts) {
+  const get_file_id = opts.get_file_id ?? default_get_file_id;
+  return async function handle(request) {
+    const file_id = get_file_id(request);
+    if (!file_id) return new Response("Missing file_id", { status: 400 });
+    if (opts.authenticate) {
+      let user = null;
+      try {
+        user = await opts.authenticate({ request, file_id });
+      } catch {
+        user = null;
+      }
+      if (!user) return new Response("Unauthorized", { status: 401 });
+      const metadata2 = await opts.metadataService.findById(file_id);
+      if (!metadata2) return new Response("Not found", { status: 404 });
+      if (opts.authorize) {
+        const allowed = await opts.authorize({ request, file_id, user, metadata: metadata2 });
+        if (!allowed) return new Response("Forbidden", { status: 403 });
+      }
+      return serve(opts.provider, metadata2);
+    }
+    const metadata = await opts.metadataService.findById(file_id);
+    if (!metadata) return new Response("Not found", { status: 404 });
+    return serve(opts.provider, metadata);
+  };
+}
+async function serve(provider, metadata) {
+  try {
+    const data = await provider.get(metadata.file_path);
+    const name = metadata.original_filename || metadata.filename || getBaseName(metadata.file_path);
+    return new Response(to_body(data), {
+      status: 200,
+      headers: safe_content_headers(getMimeType(name), name)
+    });
+  } catch {
+    return new Response("Internal error", { status: 500 });
+  }
+}
+
 // src/server/index.ts
 var log6 = createLogger6("hazo_files");
 try {
@@ -21243,6 +21504,7 @@ export {
   createFileManager,
   createFileMetadataService,
   createFileRef,
+  createFileServeHandler,
   createFolderItem,
   createGoogleDriveAuth,
   createGoogleDriveModule,
@@ -21261,6 +21523,8 @@ export {
   createVariableSegment,
   deepMerge,
   errorResult,
+  external_file_link,
+  external_file_links,
   filterItems,
   formatBytes,
   formatCounter,

package/dist/testing/index.d.mts

@@ -30,6 +30,22 @@ interface ProbeResult {
     /** Free-form detail for logging. */
     message?: string;
 }
+/**
+ * A single entry returned by `FileStorageProvider.list()`.
+ *
+ * `path` is the same logical namespace used by `put`/`get` — callers can pass
+ * it directly back to those methods without any transformation.
+ */
+interface FileEntry {
+    /** Logical path within the provider (same namespace as put/get). */
+    path: StoragePath;
+    /** Bare filename or directory name (the last segment of `path`). */
+    name: string;
+    /** Size in bytes. 0 for directories. */
+    size: number;
+    /** True when this entry represents a directory. */
+    isDirectory: boolean;
+}
 /**
  * Storage provider abstraction. Every method MUST be idempotent at the
  * data-content level — re-invoking put with identical body is allowed.
@@ -44,6 +60,24 @@ interface FileStorageProvider {
     getSignedUrl(path: StoragePath, opts?: SignedUrlOpts): Promise<string>;
     /** Used by validation cron + onboarding step 2. */
     probe(): Promise<ProbeResult>;
+    /**
+     * List all entries (files and sub-directories) under a logical path prefix.
+     * Results are recursive — all descendants are included.
+     * Returns an empty array when the prefix does not exist.
+     */
+    list(prefix: StoragePath): Promise<FileEntry[]>;
+    /**
+     * Move bytes from `from` to `to`, creating any intermediate directories.
+     * The source is removed on success.
+     * Throws with a message containing "Not found" when `from` does not exist.
+     */
+    move(from: StoragePath, to: StoragePath): Promise<void>;
+    /**
+     * Rename a file or directory.  `to` is the full new logical path.
+     * Implementations may delegate to `move`.
+     * Throws with a message containing "Not found" when `from` does not exist.
+     */
+    rename(from: StoragePath, to: StoragePath): Promise<void>;
 }
 
 declare class InMemoryProvider implements FileStorageProvider {
@@ -55,6 +89,9 @@ declare class InMemoryProvider implements FileStorageProvider {
     exists(path: string): Promise<boolean>;
     getSignedUrl(path: string, _opts?: SignedUrlOpts): Promise<string>;
     probe(): Promise<ProbeResult>;
+    list(prefix: string): Promise<FileEntry[]>;
+    move(from: string, to: string): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
     /** Test-only escape hatch — exposes the internal store for assertions. */
     snapshot(): Map<string, Buffer>;
 }

package/dist/testing/index.d.ts

@@ -30,6 +30,22 @@ interface ProbeResult {
     /** Free-form detail for logging. */
     message?: string;
 }
+/**
+ * A single entry returned by `FileStorageProvider.list()`.
+ *
+ * `path` is the same logical namespace used by `put`/`get` — callers can pass
+ * it directly back to those methods without any transformation.
+ */
+interface FileEntry {
+    /** Logical path within the provider (same namespace as put/get). */
+    path: StoragePath;
+    /** Bare filename or directory name (the last segment of `path`). */
+    name: string;
+    /** Size in bytes. 0 for directories. */
+    size: number;
+    /** True when this entry represents a directory. */
+    isDirectory: boolean;
+}
 /**
  * Storage provider abstraction. Every method MUST be idempotent at the
  * data-content level — re-invoking put with identical body is allowed.
@@ -44,6 +60,24 @@ interface FileStorageProvider {
     getSignedUrl(path: StoragePath, opts?: SignedUrlOpts): Promise<string>;
     /** Used by validation cron + onboarding step 2. */
     probe(): Promise<ProbeResult>;
+    /**
+     * List all entries (files and sub-directories) under a logical path prefix.
+     * Results are recursive — all descendants are included.
+     * Returns an empty array when the prefix does not exist.
+     */
+    list(prefix: StoragePath): Promise<FileEntry[]>;
+    /**
+     * Move bytes from `from` to `to`, creating any intermediate directories.
+     * The source is removed on success.
+     * Throws with a message containing "Not found" when `from` does not exist.
+     */
+    move(from: StoragePath, to: StoragePath): Promise<void>;
+    /**
+     * Rename a file or directory.  `to` is the full new logical path.
+     * Implementations may delegate to `move`.
+     * Throws with a message containing "Not found" when `from` does not exist.
+     */
+    rename(from: StoragePath, to: StoragePath): Promise<void>;
 }
 
 declare class InMemoryProvider implements FileStorageProvider {
@@ -55,6 +89,9 @@ declare class InMemoryProvider implements FileStorageProvider {
     exists(path: string): Promise<boolean>;
     getSignedUrl(path: string, _opts?: SignedUrlOpts): Promise<string>;
     probe(): Promise<ProbeResult>;
+    list(prefix: string): Promise<FileEntry[]>;
+    move(from: string, to: string): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
     /** Test-only escape hatch — exposes the internal store for assertions. */
     snapshot(): Map<string, Buffer>;
 }

package/dist/testing/index.js

@@ -55,6 +55,39 @@ var InMemoryProvider = class {
   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);

package/dist/testing/index.mjs

@@ -29,6 +29,39 @@ var InMemoryProvider = class {
   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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hazo_files",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "File management including integration to cloud files",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -102,9 +102,9 @@
     "@types/react": "^18.3.3",
     "@types/react-dom": "^18.3.0",
     "dropbox": "^10.34.0",
-    "hazo_core": "^1.0.0",
+    "hazo_core": "^1.1.0",
     "hazo_jobs": "^0.12.0",
-    "hazo_llm_api": "^2.0.0",
+    "hazo_llm_api": "^2.1.0",
     "jsdom": "^28.1.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
@@ -120,14 +120,14 @@
     "@dnd-kit/utilities": "^3.0.0",
     "dropbox": "^10.0.0",
     "googleapis": "^140.0.0",
-    "hazo_connect": "^3.0.0",
-    "hazo_core": "^1.0.0",
-    "hazo_debug": "^3.1.0",
+    "hazo_connect": "^3.4.1",
+    "hazo_core": "^1.1.0",
+    "hazo_debug": "^3.1.1",
     "hazo_jobs": "^0.12.0",
-    "hazo_llm_api": "^2.0.0",
-    "hazo_logs": "^2.0.0",
-    "hazo_secure": "^1.0.1",
-    "hazo_ui": "^3.0.1",
+    "hazo_llm_api": "^2.1.0",
+    "hazo_logs": "^2.0.3",
+    "hazo_secure": "^1.2.0",
+    "hazo_ui": "^3.2.1",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
     "server-only": "^0.0.1",