@abelxiaoxing/cadence 1.0.0 → 1.0.2

package/src/scheduler.ts

@@ -43,6 +43,7 @@ interface Entry<T> {
   state: EntryState;
   attempts: number;
   cancelRequested: boolean;
+  cancelReason: unknown;
   controller: AbortController | null;
   resolve(outcome: ScheduledOutcome<T>): void;
   promise: Promise<ScheduledOutcome<T>>;
@@ -58,6 +59,7 @@ function conflictEdgeMatches(
 ): boolean {
   return conflicts.some(
     (edge) =>
+      edge === other.taskId ||
       edge === other.id ||
       other.declared.read.includes(edge) ||
       other.declared.write.includes(edge),
@@ -106,6 +108,7 @@ class Batch<T> {
         state: "queued",
         attempts: 0,
         cancelRequested: false,
+        cancelReason: undefined,
         controller: null,
         resolve,
         promise,
@@ -150,6 +153,8 @@ export class Scheduler<T> {
       }
     }
     this.pump();
+    const done = Promise.all(batch.entries.map((entry) => entry.promise));
+    void done.then(() => this.removeBatch(batch));
     return {
       batchId,
       result: (id: string) => {
@@ -157,22 +162,54 @@ export class Scheduler<T> {
         if (!entry) throw new Error(`unknown scheduled request: ${id}`);
         return entry.promise;
       },
-      done: Promise.all(batch.entries.map((entry) => entry.promise)),
+      done,
     };
   }
 
-  cancel(batchId: string): void {
+  private removeBatch(batch: Batch<T>): void {
+    const index = this.batches.indexOf(batch);
+    if (index >= 0) this.batches.splice(index, 1);
+  }
+
+  cancel(
+    batchId: string,
+    reason: unknown = new Error("batch cancelled"),
+  ): void {
     const batch = this.batches.find(
       (candidate) => candidate.batchId === batchId,
     );
-    if (!batch) return;
+    if (batch) this.cancelBatch(batch, reason);
+  }
+
+  async cancelAll(
+    reason: unknown = new Error("batch cancelled"),
+  ): Promise<void> {
+    const batches = [...this.batches];
+    for (const batch of batches) this.requestCancellation(batch, reason);
+    for (const batch of batches) this.settleQueuedCancellation(batch);
+    await Promise.all(
+      batches.flatMap((batch) => batch.entries.map((entry) => entry.promise)),
+    );
+  }
+
+  private cancelBatch(batch: Batch<T>, reason: unknown): void {
+    this.requestCancellation(batch, reason);
+    this.settleQueuedCancellation(batch);
+  }
+
+  private requestCancellation(batch: Batch<T>, reason: unknown): void {
+    for (const entry of batch.entries) {
+      if (entry.state !== "queued" && entry.state !== "running") continue;
+      if (!entry.cancelRequested) entry.cancelReason = reason;
+      entry.cancelRequested = true;
+      if (entry.state === "running") entry.controller?.abort(reason);
+    }
+  }
+
+  private settleQueuedCancellation(batch: Batch<T>): void {
     for (const entry of batch.entries) {
       if (entry.state === "queued") {
-        entry.cancelRequested = true;
         this.settle(batch, entry, this.cancelOutcome(entry));
-      } else if (entry.state === "running") {
-        entry.cancelRequested = true;
-        entry.controller?.abort();
       }
     }
     this.pump();
@@ -182,7 +219,7 @@ export class Scheduler<T> {
     for (const batch of this.batches) {
       for (const entry of batch.entries) {
         if (this.active.size >= this.limit) return;
-        if (entry.state !== "queued") continue;
+        if (entry.state !== "queued" || entry.cancelRequested) continue;
         if (!this.prerequisitesSucceeded(batch, entry)) continue;
         if (this.hasActiveConflict(entry)) continue;
         this.start(batch, entry);
@@ -207,7 +244,7 @@ export class Scheduler<T> {
 
   private start(batch: Batch<T>, entry: Entry<T>): void {
     // Guarded start: a cancelled or settled queued closure never runs later.
-    if (entry.state !== "queued") return;
+    if (entry.state !== "queued" || entry.cancelRequested) return;
     entry.state = "running";
     entry.attempts += 1;
     entry.controller = new AbortController();
@@ -262,7 +299,7 @@ export class Scheduler<T> {
       id: entry.request.id,
       status: "cancelled",
       attempts: entry.attempts,
-      error: "batch cancelled",
+      error: errorMessage(entry.cancelReason ?? new Error("batch cancelled")),
     };
   }
 

package/src/scoped-tools.ts

@@ -31,6 +31,7 @@ export interface ScopedToolDef {
 
 interface Options {
   roots: string[];
+  allowedPaths?: string[];
   observer?: (obs: Observation) => void;
 }
 
@@ -38,7 +39,11 @@ type PathResult =
   | { ok: true; abs: string; rel: string }
   | { ok: false; error: string };
 
-function resolveScoped(roots: string[], input: unknown): PathResult {
+function resolveScoped(
+  roots: string[],
+  input: unknown,
+  allowedPaths?: string[],
+): PathResult {
   if (typeof input !== "string" || input.length === 0) {
     return { ok: false, error: "missing path" };
   }
@@ -54,11 +59,21 @@ function resolveScoped(roots: string[], input: unknown): PathResult {
   if (input.startsWith("./") || input.includes("//") || input.endsWith("/.")) {
     return { ok: false, error: "noncanonical path rejected" };
   }
+  let insideRoot = false;
   for (const root of roots) {
     const abs = resolve(root, input);
     const inside =
       abs === root || abs.startsWith(root.endsWith("/") ? root : `${root}/`);
     if (!inside) continue;
+    insideRoot = true;
+    if (
+      allowedPaths &&
+      !allowedPaths.some(
+        (allowed) => abs === allowed || abs.startsWith(`${allowed}/`),
+      )
+    ) {
+      continue;
+    }
     // Hidden directories are rejected unless the root itself is the hidden scope.
     const hiddenRoot =
       basename(realpathSync(root)) === ".git" ||
@@ -89,7 +104,12 @@ function resolveScoped(roots: string[], input: unknown): PathResult {
     }
     return { ok: true, abs: abs, rel: relative(root, abs) || "." };
   }
-  return { ok: false, error: "path is outside every approved root" };
+  return {
+    ok: false,
+    error: insideRoot
+      ? "path is outside the declared read/write scope"
+      : "path is outside every approved root",
+  };
 }
 
 function existsSync(p: string): boolean {
@@ -113,6 +133,7 @@ function utf8Text(abs: string): string | null {
 
 export function createScopedTools(opts: Options): ScopedToolDef[] {
   const roots = opts.roots.map((r) => resolve(r));
+  const allowedPaths = opts.allowedPaths?.map((p) => resolve(p));
   const observe = opts.observer ?? (() => {});
 
   const readTool: ScopedToolDef = {
@@ -120,7 +141,7 @@ export function createScopedTools(opts: Options): ScopedToolDef[] {
     description:
       "Read a regular UTF-8 text file within the approved scope (max 2,000 lines / 50 KiB).",
     async execute(params) {
-      const resolved = resolveScoped(roots, params.path);
+      const resolved = resolveScoped(roots, params.path, allowedPaths);
       if (!resolved.ok) return { ok: false, error: resolved.error };
       let st: Stats | undefined;
       try {
@@ -167,7 +188,7 @@ export function createScopedTools(opts: Options): ScopedToolDef[] {
           error: `pattern exceeds ${TOOL_LIMITS.maxGrepPattern} characters`,
         };
       }
-      const resolved = resolveScoped(roots, params.path ?? ".");
+      const resolved = resolveScoped(roots, params.path ?? ".", allowedPaths);
       if (!resolved.ok) return { ok: false, error: resolved.error };
       let regex: RegExp;
       try {
@@ -207,7 +228,7 @@ export function createScopedTools(opts: Options): ScopedToolDef[] {
     description:
       "List a directory within the approved scope (max 20,000 entries, stable code-unit order).",
     async execute(params) {
-      const resolved = resolveScoped(roots, params.path ?? ".");
+      const resolved = resolveScoped(roots, params.path ?? ".", allowedPaths);
       if (!resolved.ok) return { ok: false, error: resolved.error };
       let st: Stats | undefined;
       try {
@@ -236,7 +257,7 @@ export function createScopedTools(opts: Options): ScopedToolDef[] {
     description:
       "Recursively list paths within the approved scope (max 20,000 entries, stable code-unit order).",
     async execute(params) {
-      const resolved = resolveScoped(roots, params.path ?? ".");
+      const resolved = resolveScoped(roots, params.path ?? ".", allowedPaths);
       if (!resolved.ok) return { ok: false, error: resolved.error };
       let st: Stats | undefined;
       try {