@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.1

package/src/filtered-task-limits.js

@@ -0,0 +1,93 @@
+import { lstat, opendir } from "node:fs/promises";
+import { join } from "node:path";
+const FILTERED_WORKSPACE_LIMITS = { entries: 2e3, depth: 32, logicalBytes: 32 * 1024 * 1024, allocatedBytes: 64 * 1024 * 1024, scanMs: 5e3 };
+class FilteredWorkspaceLimitError extends Error {
+}
+async function inspectFilteredWorkspace(root, stopped = () => false) {
+  const stats = { entries: 0, logicalBytes: 0, allocatedBytes: 0 }, started = Date.now();
+  const fail = (reason) => {
+    throw new FilteredWorkspaceLimitError(`Filtered workspace ${reason}; stop the task and inspect its bounded output`);
+  };
+  const walk = async (directory, depth) => {
+    if (stopped()) return;
+    if (depth > FILTERED_WORKSPACE_LIMITS.depth) fail("directory depth exceeds its live limit");
+    const before = await lstat(directory);
+    if (!before.isDirectory() || before.isSymbolicLink()) fail("contains a symbolic or non-directory ancestor");
+    const handle = await opendir(directory, { bufferSize: 32 });
+    try {
+      const current = await lstat(directory);
+      if (current.isSymbolicLink() || current.dev !== before.dev || current.ino !== before.ino) fail("directory changed during inspection");
+      for await (const entry of handle) {
+        if (stopped()) return;
+        if (depth === 0 && entry.name === ".git") continue;
+        if (++stats.entries > FILTERED_WORKSPACE_LIMITS.entries) fail("entry count exceeds its live limit");
+        if (Date.now() - started > FILTERED_WORKSPACE_LIMITS.scanMs) fail("inspection exceeded its deadline");
+        if (!entry.name || entry.name === "." || entry.name === ".." || /[\\/\x00-\x1f\x7f]/.test(entry.name)) fail("contains an unsupported entry name");
+        const path = join(directory, entry.name);
+        let info;
+        try {
+          info = await lstat(path);
+        } catch (error) {
+          if (error.code === "ENOENT") continue;
+          throw error;
+        }
+        if (info.isSymbolicLink()) fail("contains a symbolic link");
+        if (!info.isDirectory() && !info.isFile() || info.isFile() && info.nlink !== 1) fail("contains a special or hard-linked file");
+        stats.logicalBytes += info.isFile() ? info.size : 0;
+        stats.allocatedBytes += typeof info.blocks === "number" ? info.blocks * 512 : Math.ceil(info.size / 4096) * 4096;
+        if (stats.logicalBytes > FILTERED_WORKSPACE_LIMITS.logicalBytes || stats.allocatedBytes > FILTERED_WORKSPACE_LIMITS.allocatedBytes) fail("bytes exceed its live limit");
+        if (info.isDirectory()) await walk(path, depth + 1);
+      }
+    } finally {
+      await handle.close().catch((error) => {
+        if (error.code !== "ERR_DIR_CLOSED") throw error;
+      });
+    }
+  };
+  try {
+    await walk(root, 0);
+  } catch (error) {
+    if (stopped()) return stats;
+    if (error instanceof FilteredWorkspaceLimitError) throw error;
+    throw new FilteredWorkspaceLimitError("Filtered workspace could not be safely inspected; stop the task and inspect its output");
+  }
+  return stats;
+}
+function monitorFilteredWorkspace(root, options) {
+  const interval = Number.isFinite(options.intervalMs) ? Math.max(20, Math.min(5e3, options.intervalMs)) : 250;
+  let stopped = options.signal.aborted, timer, pending = Promise.resolve();
+  const abort = () => {
+    stopped = true;
+    clearTimeout(timer);
+  };
+  options.signal.addEventListener("abort", abort, { once: true });
+  const scan = () => {
+    if (stopped) return;
+    pending = inspectFilteredWorkspace(root, () => stopped).then(() => {
+      if (!stopped) {
+        timer = setTimeout(scan, interval);
+        timer.unref();
+      }
+    }, (error) => {
+      if (!stopped) {
+        stopped = true;
+        try {
+          options.onExceeded(error);
+        } catch {
+        }
+      }
+    });
+  };
+  scan();
+  return { async stop() {
+    abort();
+    options.signal.removeEventListener("abort", abort);
+    await pending;
+  } };
+}
+export {
+  FILTERED_WORKSPACE_LIMITS,
+  FilteredWorkspaceLimitError,
+  inspectFilteredWorkspace,
+  monitorFilteredWorkspace
+};

package/src/filtered-tasks-api.js

@@ -0,0 +1,53 @@
+import { HttpError, readJson, send } from "./http.js";
+import { FilteredTaskError } from "./filtered-tasks.js";
+async function handleFilteredTasksApi(req, res, url, parts, service) {
+  if (parts[0] !== "filtered-tasks") return false;
+  try {
+    const id = parts[1];
+    if (!id && parts.length === 1 && req.method === "GET") {
+      send(res, 200, service.summaries(url.searchParams.get("project") ?? void 0));
+      return true;
+    }
+    if (!id && parts.length === 1 && req.method === "POST") {
+      send(res, 202, await service.create(await readJson(req, 64 * 1024)));
+      return true;
+    }
+    if (id && parts.length === 2 && req.method === "GET") {
+      send(res, 200, await service.read(id));
+      return true;
+    }
+    if (id && parts.length === 2 && req.method === "DELETE") {
+      const body = await readJson(req, 16 * 1024);
+      send(res, 200, await service.delete(id, body.revision));
+      return true;
+    }
+    if (id && parts.length === 3 && req.method === "POST") {
+      const body = await readJson(req, 16 * 1024);
+      if (parts[2] === "preview-import") {
+        send(res, 200, await service.preview(id));
+        return true;
+      }
+      if (parts[2] === "import") {
+        send(res, 200, await service.import(id, body));
+        return true;
+      }
+      if (parts[2] === "cancel") {
+        await service.cancel(id, body.revision);
+        send(res, 200, service.summaries().find((job) => job.id === id));
+        return true;
+      }
+      if (parts[2] === "receipt") {
+        await service.reconcile(id, body.revision);
+        send(res, 200, service.summaries().find((job) => job.id === id));
+        return true;
+      }
+    }
+    throw new HttpError(404, "Unknown filtered task operation");
+  } catch (error) {
+    if (error instanceof FilteredTaskError) throw new HttpError(error.status, error.message);
+    throw error;
+  }
+}
+export {
+  handleFilteredTasksApi
+};