@agent-inspect/studio 6.17.5 → 6.17.6

package/dist/index.mjs

@@ -1,8 +1,8 @@
-import { readFile, access, readdir, stat, mkdir, writeFile, copyFile, rename } from 'fs/promises';
-import path8 from 'path';
+import { readFile, access, readdir, writeFile, rm, copyFile, mkdir, rename, mkdtemp, lstat, stat } from 'fs/promises';
+import path10 from 'path';
 import { loadSessionRunRecords, buildSessionIndex, runSuite, buildRunTimeline, extractOutcomesFromTraceEvents, resolveTraceDir, searchTraces, TraceDirectory, loadTraceMetadataList } from 'agent-inspect/advanced';
 import { resolveWorkspaceLocation, readWorkspaceManifestFile } from 'agent-inspect/workspace';
-import { mkdirSync } from 'fs';
+import { mkdirSync, createReadStream } from 'fs';
 import { createRequire } from 'module';
 import { timingSafeEqual, createHash } from 'crypto';
 import { createServer } from 'http';
@@ -19,14 +19,14 @@ function isSafeRelativePath(p) {
   return !trimmed.split(/[/\\]+/).some((seg) => seg === "..");
 }
 function resolveUnderRoot(root, ...segments) {
-  const resolvedRoot = path8.resolve(root);
-  const resolved = path8.resolve(resolvedRoot, ...segments);
+  const resolvedRoot = path10.resolve(root);
+  const resolved = path10.resolve(resolvedRoot, ...segments);
   assertPathUnderRoot(resolved, resolvedRoot);
   return resolved;
 }
 function assertPathUnderRoot(resolved, root) {
-  const rel = path8.relative(path8.resolve(root), path8.resolve(resolved));
-  if (rel.startsWith("..") || path8.isAbsolute(rel)) {
+  const rel = path10.relative(path10.resolve(root), path10.resolve(resolved));
+  if (rel.startsWith("..") || path10.isAbsolute(rel)) {
     throw new Error("path escapes allowed registry root");
   }
 }
@@ -207,7 +207,23 @@ function parseStudioRegistry(input) {
           ingestConfig.bundleUpload = bundleUpload;
         }
       }
-      const knownIngestKeys = /* @__PURE__ */ new Set(["github", "http", "bundleUpload"]);
+      if (input.ingest.fileDrop !== void 0) {
+        if (!isPlainObject(input.ingest.fileDrop)) {
+          errors.push("ingest.fileDrop must be an object");
+        } else {
+          const fileDrop = {};
+          if (input.ingest.fileDrop.maxBytes !== void 0) {
+            const maxBytes = Number(input.ingest.fileDrop.maxBytes);
+            if (!Number.isInteger(maxBytes) || maxBytes <= 0) {
+              errors.push("ingest.fileDrop.maxBytes must be a positive integer");
+            } else {
+              fileDrop.maxBytes = maxBytes;
+            }
+          }
+          ingestConfig.fileDrop = fileDrop;
+        }
+      }
+      const knownIngestKeys = /* @__PURE__ */ new Set(["github", "http", "bundleUpload", "fileDrop"]);
       for (const key of Object.keys(input.ingest)) {
         if (!knownIngestKeys.has(key)) {
           ingestWarnings.push(`ignored unknown ingest key: ${key}`);
@@ -248,7 +264,7 @@ async function readStudioRegistryFile(filePath) {
   }
 }
 function resolveRegistryProjectPath(registryDir, projectPath) {
-  return path8.isAbsolute(projectPath) ? path8.resolve(projectPath) : path8.resolve(registryDir, projectPath);
+  return path10.isAbsolute(projectPath) ? path10.resolve(projectPath) : path10.resolve(registryDir, projectPath);
 }
 var cached;
 function loadBetterSqlite3() {
@@ -313,9 +329,9 @@ function resolveStudioDbPath(options) {
     if (raw.startsWith("postgres://") || raw.startsWith("postgresql://")) {
       return raw;
     }
-    return path8.resolve(options.cwd ?? process.cwd(), raw);
+    return path10.resolve(options.cwd ?? process.cwd(), raw);
   }
-  return path8.resolve(
+  return path10.resolve(
     options.cwd ?? process.cwd(),
     ".agent-inspect",
     DEFAULT_STUDIO_DB_FILENAME
@@ -330,7 +346,7 @@ function openStudioDb(dbPath) {
       "Postgres studio databases are not supported; use a SQLite file path (preview only)."
     );
   }
-  const dir = path8.dirname(dbPath);
+  const dir = path10.dirname(dbPath);
   try {
     mkdirSync(dir, { recursive: true });
   } catch (error) {
@@ -443,14 +459,14 @@ function insertIngestFile(db, row) {
 // packages/studio/src/import.ts
 async function discoverSuiteConfigs(projectRoot, configured) {
   if (configured && configured.length > 0) {
-    return configured.map((rel) => path8.resolve(projectRoot, rel));
+    return configured.map((rel) => path10.resolve(projectRoot, rel));
   }
   const found = [];
   try {
     const entries = await readdir(projectRoot);
     for (const entry of entries) {
       if (entry.endsWith(".suite.json")) {
-        found.push(path8.join(projectRoot, entry));
+        found.push(path10.join(projectRoot, entry));
       }
     }
   } catch {
@@ -460,7 +476,7 @@ async function discoverSuiteConfigs(projectRoot, configured) {
 async function loadProjectRuns(workspaceDir, traceDirs) {
   const runs = [];
   for (const rel of traceDirs) {
-    const traceDir = resolveTraceDir({ dir: path8.join(workspaceDir, rel) });
+    const traceDir = resolveTraceDir({ dir: path10.join(workspaceDir, rel) });
     const td = new TraceDirectory({ dir: traceDir });
     const files = await td.list();
     const metas = await loadTraceMetadataList(
@@ -474,7 +490,7 @@ async function loadProjectRuns(workspaceDir, traceDirs) {
         runId: meta.runId,
         ...meta.name !== void 0 ? { name: meta.name } : {},
         status: meta.status,
-        file: path8.basename(meta.filePath),
+        file: path10.basename(meta.filePath),
         ...meta.startedAt !== void 0 ? { startedAt: meta.startedAt } : {},
         ...meta.durationMs !== void 0 ? { durationMs: meta.durationMs } : {}
       });
@@ -483,7 +499,7 @@ async function loadProjectRuns(workspaceDir, traceDirs) {
   return runs.sort((a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0));
 }
 async function importStudioRegistry(options) {
-  const registryDir = path8.dirname(options.registryPath);
+  const registryDir = path10.dirname(options.registryPath);
   const warnings = [];
   const projects = [];
   const importedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -544,21 +560,21 @@ async function importStudioProject(options) {
 }
 async function resolveStudioRegistryPath(options) {
   if (options.workspacePath && options.workspacePath.trim() !== "") {
-    return path8.resolve(options.cwd ?? process.cwd(), options.workspacePath);
+    return path10.resolve(options.cwd ?? process.cwd(), options.workspacePath);
   }
-  const cwd = path8.resolve(options.cwd ?? process.cwd());
+  const cwd = path10.resolve(options.cwd ?? process.cwd());
   for (const rel of STUDIO_REGISTRY_FILENAMES) {
-    const candidate = path8.join(cwd, rel);
+    const candidate = path10.join(cwd, rel);
     try {
       await access(candidate);
       return candidate;
     } catch {
     }
   }
-  return path8.join(cwd, STUDIO_REGISTRY_FILENAMES[0]);
+  return path10.join(cwd, STUDIO_REGISTRY_FILENAMES[0]);
 }
 function resolveImportDirs(registryPath, registry) {
-  const registryDir = path8.dirname(registryPath);
+  const registryDir = path10.dirname(registryPath);
   const importConfig = registry.import ?? {};
   const fileDropDir = importConfig.fileDropDir ?? "imports/drop";
   const ciArtifactsDir = importConfig.ciArtifactsDir ?? "imports/ci";
@@ -571,10 +587,10 @@ function resolveImportDirs(registryPath, registry) {
   };
 }
 function uniqueDestPath(destDir, fileName, contentHash) {
-  const ext = path8.extname(fileName);
-  const base = path8.basename(fileName, ext);
+  const ext = path10.extname(fileName);
+  const base = path10.basename(fileName, ext);
   const shortHash = contentHash.slice(0, 8);
-  return path8.join(destDir, `${base}-${shortHash}${ext}`);
+  return path10.join(destDir, `${base}-${shortHash}${ext}`);
 }
 function sanitizeSafeErrorMessage(message, secret) {
   if (!secret || secret.length < 4) return message;
@@ -591,6 +607,136 @@ function parseGitHubRepo(repo) {
 function buildGitHubArtifactSourceKey(options) {
   return `github:${options.owner}/${options.repo}/runs/${options.runId}/${options.artifactName}`;
 }
+var DEFAULT_MAX_INGEST_BYTES = 52428800;
+var IngestLimitError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "IngestLimitError";
+    this.code = code;
+  }
+};
+function resolveIngestMaxBytes(configured) {
+  if (configured === void 0) return DEFAULT_MAX_INGEST_BYTES;
+  if (!Number.isInteger(configured) || configured <= 0) {
+    throw new IngestLimitError(
+      "INGEST_SIZE_LIMIT",
+      "maxBytes must be a positive integer"
+    );
+  }
+  return configured;
+}
+async function lstatRegularFile(filePath) {
+  const info = await lstat(filePath);
+  if (info.isSymbolicLink()) {
+    throw new IngestLimitError(
+      "INGEST_SYMLINK_REJECTED",
+      "symbolic links are not allowed for ingest"
+    );
+  }
+  if (!info.isFile()) {
+    throw new IngestLimitError("INGEST_NOT_A_FILE", "ingest path must be a regular file");
+  }
+  return info;
+}
+async function lstatRegularDirectory(dirPath) {
+  const info = await lstat(dirPath);
+  if (info.isSymbolicLink()) {
+    throw new IngestLimitError(
+      "INGEST_SYMLINK_REJECTED",
+      "symbolic links are not allowed for ingest"
+    );
+  }
+  if (!info.isDirectory()) {
+    throw new IngestLimitError(
+      "INGEST_NOT_A_DIRECTORY",
+      "ingest path must be a directory"
+    );
+  }
+  return info;
+}
+async function assertFileWithinByteLimit(filePath, maxBytes) {
+  const info = await lstatRegularFile(filePath);
+  if (info.size > maxBytes) {
+    throw new IngestLimitError("INGEST_SIZE_LIMIT", "file exceeds size limit");
+  }
+  return info;
+}
+async function measureDirectoryBytes(dirPath, maxBytes) {
+  await lstatRegularDirectory(dirPath);
+  let total = 0;
+  const walk = async (current) => {
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const abs = path10.join(current, entry.name);
+      const info = await lstat(abs);
+      if (info.isSymbolicLink()) {
+        throw new IngestLimitError(
+          "INGEST_SYMLINK_REJECTED",
+          "symbolic links are not allowed for ingest"
+        );
+      }
+      if (info.isDirectory()) {
+        await walk(abs);
+        continue;
+      }
+      if (!info.isFile()) continue;
+      total += info.size;
+      if (total > maxBytes) {
+        throw new IngestLimitError("INGEST_SIZE_LIMIT", "directory exceeds size limit");
+      }
+    }
+  };
+  await walk(dirPath);
+  return total;
+}
+async function readBoundedResponseBody(response, maxBytes) {
+  const lengthHeader = response.headers.get("content-length");
+  if (lengthHeader) {
+    const length = Number(lengthHeader);
+    if (Number.isFinite(length) && length > maxBytes) {
+      throw new IngestLimitError("INGEST_SIZE_LIMIT", "response exceeds size limit");
+    }
+  }
+  if (!response.body) {
+    const arrayBuffer = await response.arrayBuffer();
+    if (arrayBuffer.byteLength > maxBytes) {
+      throw new IngestLimitError("INGEST_SIZE_LIMIT", "response exceeds size limit");
+    }
+    return Buffer.from(arrayBuffer);
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (!value || value.byteLength === 0) continue;
+    total += value.byteLength;
+    if (total > maxBytes) {
+      try {
+        await reader.cancel();
+      } catch {
+      }
+      throw new IngestLimitError("INGEST_SIZE_LIMIT", "response exceeds size limit");
+    }
+    chunks.push(Buffer.from(value));
+  }
+  return Buffer.concat(chunks);
+}
+async function withAtomicStagingDir(parentDir, work) {
+  await mkdir(parentDir, { recursive: true });
+  const stagingDir = await mkdtemp(path10.join(parentDir, ".ingest-staging-"));
+  try {
+    return await work(stagingDir);
+  } finally {
+    await rm(stagingDir, { recursive: true, force: true });
+  }
+}
+async function promoteStagingPath(stagingPath, finalPath) {
+  await mkdir(path10.dirname(finalPath), { recursive: true });
+  await rename(stagingPath, finalPath);
+}
 
 // packages/studio/src/ingest/file-drop.ts
 var FILE_DROP_ARCHIVE_DIR = ".imported";
@@ -603,26 +749,38 @@ function classifyFile(fileName) {
   return void 0;
 }
 async function hashFile(filePath) {
-  const data = await readFile(filePath);
-  return createHash("sha256").update(data).digest("hex");
+  const hash = createHash("sha256");
+  const stream = createReadStream(filePath);
+  for await (const chunk of stream) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
 }
 async function importOneFile(options) {
   const destPath = uniqueDestPath(options.destDir, options.fileName, options.contentHash);
-  assertPathUnderRoot(destPath, path8.dirname(options.destDir));
-  await mkdir(options.destDir, { recursive: true });
-  await copyFile(options.sourcePath, destPath);
-  insertIngestFile(options.db, {
-    sourceKey: options.sourceKey,
-    sourceName: options.fileName,
-    destPath,
-    kind: options.kind,
-    contentHash: options.contentHash,
-    importedAt: options.importedAt
-  });
+  assertPathUnderRoot(destPath, path10.dirname(options.destDir));
+  try {
+    await withAtomicStagingDir(options.destDir, async (stagingDir) => {
+      const stagedPath = path10.join(stagingDir, options.fileName);
+      await copyFile(options.sourcePath, stagedPath);
+      await promoteStagingPath(stagedPath, destPath);
+    });
+    insertIngestFile(options.db, {
+      sourceKey: options.sourceKey,
+      sourceName: options.fileName,
+      destPath,
+      kind: options.kind,
+      contentHash: options.contentHash,
+      importedAt: options.importedAt
+    });
+  } catch (error) {
+    await rm(destPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
   let archived = false;
   if (options.archiveAfterImport) {
     await mkdir(options.archiveDir, { recursive: true });
-    const archiveTarget = path8.join(options.archiveDir, options.fileName);
+    const archiveTarget = path10.join(options.archiveDir, options.fileName);
     await rename(options.sourcePath, archiveTarget);
     archived = true;
   }
@@ -651,10 +809,27 @@ async function importFileDrop(options) {
       files
     };
   }
+  let maxBytes;
+  try {
+    maxBytes = resolveIngestMaxBytes(
+      options.maxBytes ?? options.registry.ingest?.fileDrop?.maxBytes
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      skipped: false,
+      scanned: 0,
+      imported: 0,
+      skippedFiles: 0,
+      errors: [message],
+      warnings,
+      files
+    };
+  }
   const dirs = resolveImportDirs(options.registryPath, options.registry);
   let dropDir;
   try {
-    dropDir = options.dropDir ? path8.isAbsolute(options.dropDir) ? (assertPathUnderRoot(options.dropDir, dirs.registryDir), options.dropDir) : resolveUnderRoot(dirs.registryDir, options.dropDir) : dirs.fileDropDir;
+    dropDir = options.dropDir ? path10.isAbsolute(options.dropDir) ? (assertPathUnderRoot(options.dropDir, dirs.registryDir), options.dropDir) : resolveUnderRoot(dirs.registryDir, options.dropDir) : dirs.fileDropDir;
     assertPathUnderRoot(dropDir, dirs.registryDir);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -684,24 +859,35 @@ async function importFileDrop(options) {
     };
   }
   const importedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const archiveDir = path8.join(dropDir, FILE_DROP_ARCHIVE_DIR);
+  const archiveDir = path10.join(dropDir, FILE_DROP_ARCHIVE_DIR);
   let scanned = 0;
   let imported = 0;
   let skippedFiles = 0;
   for (const entry of entries.sort()) {
     if (entry === FILE_DROP_ARCHIVE_DIR || entry.startsWith(".")) continue;
-    const sourcePath = path8.join(dropDir, entry);
-    let fileStat;
+    const sourcePath = path10.join(dropDir, entry);
+    const kind = classifyFile(entry);
+    if (!kind) continue;
+    scanned += 1;
     try {
-      fileStat = await stat(sourcePath);
-    } catch {
+      await assertFileWithinByteLimit(sourcePath, maxBytes);
+    } catch (error) {
+      if (error instanceof IngestLimitError && error.code === "INGEST_NOT_A_FILE") {
+        scanned -= 1;
+        continue;
+      }
+      if (error instanceof IngestLimitError && error.code === "INGEST_SYMLINK_REJECTED") {
+        errors.push(`failed to import ${entry}: ${error.message}`);
+        continue;
+      }
+      if (error instanceof IngestLimitError && error.code === "INGEST_SIZE_LIMIT") {
+        errors.push(`failed to import ${entry}: ${error.message}`);
+        continue;
+      }
       warnings.push(`skipped unreadable entry: ${entry}`);
+      scanned -= 1;
       continue;
     }
-    if (!fileStat.isFile()) continue;
-    const kind = classifyFile(entry);
-    if (!kind) continue;
-    scanned += 1;
     const sourceKey = entry;
     let contentHash;
     try {
@@ -754,7 +940,8 @@ async function importFileDropFromRegistry(options) {
     registry: options.registry,
     enabled: options.enabled,
     ...options.dropDir !== void 0 ? { dropDir: options.dropDir } : {},
-    ...options.archiveAfterImport !== void 0 ? { archiveAfterImport: options.archiveAfterImport } : {}
+    ...options.archiveAfterImport !== void 0 ? { archiveAfterImport: options.archiveAfterImport } : {},
+    ...options.maxBytes !== void 0 ? { maxBytes: options.maxBytes } : {}
   });
 }
 async function runStudioFileDropImport(options) {
@@ -871,7 +1058,6 @@ function isIngestTokenValid(provided, expected) {
 var DEFAULT_HTTP_INGEST_BASE_PATH = "/api/ingest";
 var HTTP_INGEST_BUNDLE_PATH = "/api/ingest/bundle";
 var HTTP_INGEST_ARTIFACT_PATH = "/api/ingest/artifact";
-var DEFAULT_MAX_INGEST_BYTES = 52428800;
 function resolveHttpIngestConfig(options, registryHttp) {
   const http = registryHttp ?? options.context?.registry.ingest?.http;
   const enabled = options.ingestHttp === true || http?.enabled === true;
@@ -880,7 +1066,7 @@ function resolveHttpIngestConfig(options, registryHttp) {
     ...options.ingestTokenEnv !== void 0 ? { tokenEnv: options.ingestTokenEnv } : {},
     ...http?.tokenEnv !== void 0 ? { registryTokenEnv: http.tokenEnv } : {}
   });
-  const maxBytes = http?.maxBytes ?? DEFAULT_MAX_INGEST_BYTES;
+  const maxBytes = resolveIngestMaxBytes(http?.maxBytes);
   return { enabled, basePath, tokenEnv, maxBytes };
 }
 function sendJson(res, status, body) {
@@ -950,22 +1136,30 @@ async function handleHttpIngestRequest(req, res, ctx, options, pathname) {
     const destDir = isBundle ? dirs.bundlesDir : dirs.ciArtifactsDir;
     const destPath = uniqueDestPath(destDir, fileName, contentHash);
     assertPathUnderRoot(destPath, dirs.registryDir);
-    await mkdir(destDir, { recursive: true });
-    await writeFile(destPath, body);
-    const sourceKey = isBundle ? `http:bundle:${contentHash}` : buildGitHubArtifactSourceKey({
-      owner: "http",
-      repo: "ingest",
-      runId: importedAt,
-      artifactName: fileName
-    });
-    insertIngestFile(ctx.db, {
-      sourceKey,
-      sourceName: fileName,
-      destPath,
-      kind: isBundle ? "bundle" : "ci",
-      contentHash,
-      importedAt
-    });
+    try {
+      await withAtomicStagingDir(destDir, async (stagingDir) => {
+        const stagedPath = path10.join(stagingDir, fileName);
+        await writeFile(stagedPath, body);
+        await promoteStagingPath(stagedPath, destPath);
+      });
+      const sourceKey = isBundle ? `http:bundle:${contentHash}` : buildGitHubArtifactSourceKey({
+        owner: "http",
+        repo: "ingest",
+        runId: importedAt,
+        artifactName: fileName
+      });
+      insertIngestFile(ctx.db, {
+        sourceKey,
+        sourceName: fileName,
+        destPath,
+        kind: isBundle ? "bundle" : "ci",
+        contentHash,
+        importedAt
+      });
+    } catch (error) {
+      await rm(destPath, { force: true }).catch(() => void 0);
+      throw error;
+    }
     const registryImport = await importStudioRegistry({
       db: ctx.db,
       registry: ctx.registry,
@@ -1150,7 +1344,7 @@ function getImportedProject(db, projects, projectId) {
 async function loadTraceDirMetas(workspaceDir, traceDirs) {
   const metas = [];
   for (const rel of traceDirs) {
-    const traceDir = resolveTraceDir({ dir: path8.join(workspaceDir, rel) });
+    const traceDir = resolveTraceDir({ dir: path10.join(workspaceDir, rel) });
     const td = new TraceDirectory({ dir: traceDir });
     const files = await td.list();
     const listed = await loadTraceMetadataList(
@@ -1179,7 +1373,7 @@ async function loadProjectSuitesView(ctx) {
     try {
       const result = await runSuite({
         configPath,
-        cwd: path8.dirname(configPath)
+        cwd: path10.dirname(configPath)
       });
       suites.push({
         suiteName: result.suiteName,
@@ -1197,7 +1391,7 @@ async function loadProjectSuitesView(ctx) {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       suites.push({
-        suiteName: path8.basename(configPath),
+        suiteName: path10.basename(configPath),
         configPath,
         ok: false,
         status: "error",
@@ -1246,7 +1440,7 @@ async function loadProjectSearchView(ctx, db, params) {
   }
   const metas = await loadTraceDirMetas(ctx.project.workspaceDir, ["runs"]);
   const traceDir = resolveTraceDir({
-    dir: path8.join(ctx.project.workspaceDir, "runs")
+    dir: path10.join(ctx.project.workspaceDir, "runs")
   });
   const results = await searchTraces(metas, {
     traceDir,
@@ -1290,12 +1484,12 @@ async function loadProjectDiffView(ctx, params) {
   };
 }
 async function loadProjectReportsView(ctx) {
-  const reportsDir = path8.join(ctx.project.workspaceDir, "reports");
+  const reportsDir = path10.join(ctx.project.workspaceDir, "reports");
   const reports = [];
   try {
     const files = await readdir(reportsDir);
     for (const file of files) {
-      const filePath = path8.join(reportsDir, file);
+      const filePath = path10.join(reportsDir, file);
       const info = await stat(filePath);
       if (!info.isFile()) continue;
       reports.push({ name: file, path: filePath, sizeBytes: info.size });
@@ -1350,7 +1544,7 @@ async function loadBundleExportView(ctx, params) {
     runId,
     readOnly: true,
     redactionProfile: ctx.project.redactionProfile ?? "share",
-    cliHint: `npx agent-inspect bundle ${runId} --profile ${ctx.project.redactionProfile ?? "share"} --dir ${path8.join(ctx.project.workspaceDir, "runs")}`,
+    cliHint: `npx agent-inspect bundle ${runId} --profile ${ctx.project.redactionProfile ?? "share"} --dir ${path10.join(ctx.project.workspaceDir, "runs")}`,
     note: "Studio does not mutate traces or upload bundles. Run the CLI locally to assemble a share-safe bundle."
   };
 }
@@ -1692,7 +1886,6 @@ async function startStudioServer(options = {}) {
 }
 var DEFAULT_GITHUB_TOKEN_ENV = "GITHUB_TOKEN";
 var GITHUB_API_BASE = "https://api.github.com";
-var MAX_ARTIFACT_BYTES = 52428800;
 function resolveTokenEnv(registry, override) {
   const fromRegistry = registry.ingest?.github?.tokenEnv?.trim();
   const envName = override?.trim() || fromRegistry || DEFAULT_GITHUB_TOKEN_ENV;
@@ -1717,20 +1910,17 @@ function githubHeaders(token) {
   };
 }
 async function readResponseBody(response, maxBytes) {
-  const lengthHeader = response.headers.get("content-length");
-  if (lengthHeader) {
-    const length = Number(lengthHeader);
-    if (Number.isFinite(length) && length > maxBytes) {
+  try {
+    return await readBoundedResponseBody(response, maxBytes);
+  } catch (error) {
+    if (error instanceof IngestLimitError && error.code === "INGEST_SIZE_LIMIT") {
       throw new Error("artifact exceeds size limit");
     }
+    throw error;
   }
-  const arrayBuffer = await response.arrayBuffer();
-  if (arrayBuffer.byteLength > maxBytes) {
-    throw new Error("artifact exceeds size limit");
-  }
-  return Buffer.from(arrayBuffer);
 }
 async function downloadGitHubArtifactArchive(options) {
+  const maxBytes = resolveIngestMaxBytes(options.maxBytes);
   const fetchFn = options.fetchImpl ?? fetch;
   const { owner, name } = parseGitHubRepo(options.repo);
   const runId = options.runId.trim();
@@ -1756,7 +1946,7 @@ async function downloadGitHubArtifactArchive(options) {
   if (artifact.expired === true) {
     throw new Error(`artifact expired for run ${runId}: ${artifactName}`);
   }
-  if (typeof artifact.size_in_bytes === "number" && artifact.size_in_bytes > MAX_ARTIFACT_BYTES) {
+  if (typeof artifact.size_in_bytes === "number" && artifact.size_in_bytes > maxBytes) {
     throw new Error("artifact exceeds size limit");
   }
   const downloadResponse = await fetchFn(artifact.archive_download_url, {
@@ -1766,7 +1956,7 @@ async function downloadGitHubArtifactArchive(options) {
   if (!downloadResponse.ok) {
     throw new Error(`GitHub artifact download failed (${downloadResponse.status})`);
   }
-  return readResponseBody(downloadResponse, MAX_ARTIFACT_BYTES);
+  return readResponseBody(downloadResponse, maxBytes);
 }
 async function importGitHubArtifact(options) {
   const registryImportWarnings = [];
@@ -1816,17 +2006,25 @@ async function importGitHubArtifact(options) {
     const fileName = `${options.artifactName}.zip`;
     const destPath = uniqueDestPath(dirs.bundlesDir, fileName, contentHash);
     assertPathUnderRoot(destPath, dirs.registryDir);
-    await mkdir(dirs.bundlesDir, { recursive: true });
-    await writeFile(destPath, archive);
-    const importedAt = (/* @__PURE__ */ new Date()).toISOString();
-    insertIngestFile(options.db, {
-      sourceKey,
-      sourceName: fileName,
-      destPath,
-      kind: "bundle",
-      contentHash,
-      importedAt
-    });
+    try {
+      await withAtomicStagingDir(dirs.bundlesDir, async (stagingDir) => {
+        const stagedPath = path10.join(stagingDir, fileName);
+        await writeFile(stagedPath, archive);
+        await promoteStagingPath(stagedPath, destPath);
+      });
+      const importedAt = (/* @__PURE__ */ new Date()).toISOString();
+      insertIngestFile(options.db, {
+        sourceKey,
+        sourceName: fileName,
+        destPath,
+        kind: "bundle",
+        contentHash,
+        importedAt
+      });
+    } catch (error) {
+      await rm(destPath, { force: true }).catch(() => void 0);
+      throw error;
+    }
     const registryImport = await importStudioRegistry({
       db: options.db,
       registry: options.registry,
@@ -1890,7 +2088,7 @@ async function pathExists(filePath) {
 }
 async function validateBundleDirectory(bundleDir) {
   const errors = [];
-  const metadataPath = path8.join(bundleDir, "metadata.json");
+  const metadataPath = path10.join(bundleDir, "metadata.json");
   if (!await pathExists(metadataPath)) {
     errors.push("bundle missing metadata.json");
     return errors;
@@ -1916,11 +2114,18 @@ async function hashBundleContents(bundleDir) {
       (a, b) => a.name.localeCompare(b.name)
     );
     for (const entry of entries) {
-      const abs = path8.join(dir, entry.name);
+      const abs = path10.join(dir, entry.name);
       const rel = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
-      if (entry.isDirectory()) {
+      const info = await lstat(abs);
+      if (info.isSymbolicLink()) {
+        throw new IngestLimitError(
+          "INGEST_SYMLINK_REJECTED",
+          "symbolic links are not allowed for ingest"
+        );
+      }
+      if (info.isDirectory()) {
         await walk(abs, rel);
-      } else if (entry.isFile()) {
+      } else if (info.isFile()) {
         hash.update(rel);
         hash.update("\0");
         hash.update(await readFile(abs));
@@ -1935,11 +2140,18 @@ async function copyDirectoryRecursive(sourceDir, destDir) {
   await mkdir(destDir, { recursive: true });
   const entries = await readdir(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
-    const from = path8.join(sourceDir, entry.name);
-    const to = path8.join(destDir, entry.name);
-    if (entry.isDirectory()) {
+    const from = path10.join(sourceDir, entry.name);
+    const to = path10.join(destDir, entry.name);
+    const info = await lstat(from);
+    if (info.isSymbolicLink()) {
+      throw new IngestLimitError(
+        "INGEST_SYMLINK_REJECTED",
+        "symbolic links are not allowed for ingest"
+      );
+    }
+    if (info.isDirectory()) {
       await copyDirectoryRecursive(from, to);
-    } else if (entry.isFile()) {
+    } else if (info.isFile()) {
       await copyFile(from, to);
     }
   }
@@ -1956,11 +2168,18 @@ async function importBundleUpload(options) {
       registryImportWarnings
     };
   }
-  const bundlePath = path8.resolve(options.bundlePath);
-  let bundleStat;
+  const bundlePath = path10.resolve(options.bundlePath);
   try {
-    bundleStat = await stat(bundlePath);
-  } catch {
+    await lstatRegularDirectory(bundlePath);
+  } catch (error) {
+    if (error instanceof IngestLimitError) {
+      return {
+        skipped: false,
+        imported: false,
+        errors: [error.message],
+        registryImportWarnings
+      };
+    }
     return {
       skipped: false,
       imported: false,
@@ -1968,24 +2187,42 @@ async function importBundleUpload(options) {
       registryImportWarnings
     };
   }
-  if (!bundleStat.isDirectory()) {
+  const validationErrors = await validateBundleDirectory(bundlePath);
+  if (validationErrors.length > 0) {
     return {
       skipped: false,
       imported: false,
-      errors: ["bundle path must be a directory produced by agent-inspect bundle"],
+      errors: validationErrors,
       registryImportWarnings
     };
   }
-  const validationErrors = await validateBundleDirectory(bundlePath);
-  if (validationErrors.length > 0) {
+  let maxBytes;
+  try {
+    maxBytes = resolveIngestMaxBytes(
+      options.maxBytes ?? options.registry.ingest?.bundleUpload?.maxBytes
+    );
+    await measureDirectoryBytes(bundlePath, maxBytes);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
     return {
       skipped: false,
       imported: false,
-      errors: validationErrors,
+      errors: [message],
+      registryImportWarnings
+    };
+  }
+  let contentHash;
+  try {
+    contentHash = await hashBundleContents(bundlePath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      skipped: false,
+      imported: false,
+      errors: [message],
       registryImportWarnings
     };
   }
-  const contentHash = await hashBundleContents(bundlePath);
   const sourceKey = `bundle:${bundlePath}`;
   const existing = findIngestFileBySourceKey(options.db, sourceKey);
   if (existing && existing.contentHash === contentHash) {
@@ -1999,11 +2236,15 @@ async function importBundleUpload(options) {
     };
   }
   const dirs = resolveImportDirs(options.registryPath, options.registry);
-  const folderName = path8.basename(bundlePath);
+  const folderName = path10.basename(bundlePath);
   const destPath = uniqueDestPath(dirs.bundlesDir, folderName, contentHash);
   assertPathUnderRoot(destPath, dirs.registryDir);
   try {
-    await copyDirectoryRecursive(bundlePath, destPath);
+    await withAtomicStagingDir(dirs.bundlesDir, async (stagingDir) => {
+      const stagedDest = path10.join(stagingDir, folderName);
+      await copyDirectoryRecursive(bundlePath, stagedDest);
+      await promoteStagingPath(stagedDest, destPath);
+    });
     insertIngestFile(options.db, {
       sourceKey,
       sourceName: folderName,
@@ -2027,6 +2268,7 @@ async function importBundleUpload(options) {
       registryImportWarnings
     };
   } catch (error) {
+    await rm(destPath, { recursive: true, force: true }).catch(() => void 0);
     const message = error instanceof Error ? error.message : String(error);
     return {
       skipped: false,