@ordewell/web 0.10.4 → 0.10.6

package/dist/server/main.js

@@ -244,8 +244,8 @@ var PoolFileSystem = class extends core.BaseFileSystem {
   }
   async globImpl(pattern, absRoot, headLimit) {
     if (await this.hasRg()) {
-      const anchor = await this.searchAnchor(absRoot);
-      const result2 = await run("rg", core.buildGlobArgs(pattern, absRoot), { timeout: SEARCH_TIMEOUT_MS, cwd: anchor, env: this.searchEnv() });
+      const { root, anchor } = await this.searchTarget(absRoot);
+      const result2 = await run("rg", core.buildGlobArgs(pattern, root), { timeout: SEARCH_TIMEOUT_MS, cwd: anchor, env: this.searchEnv() });
       if (result2.code !== 0 && result2.code !== 1 && !result2.stdout) {
         return { success: false, output: `Glob failed: ${result2.stderr.trim() || "ripgrep error"}`, truncated: false };
       }
@@ -258,41 +258,50 @@ var PoolFileSystem = class extends core.BaseFileSystem {
     }
     const basename = pattern.split("/").pop() || pattern;
     const excludeArgs = core.SEARCH_EXCLUSIONS.flatMap((dir) => ["-not", "-path", `*/${dir}/*`]);
-    const result = await run("find", [absRoot, "-type", "f", "-name", basename, ...excludeArgs], { timeout: SEARCH_TIMEOUT_MS, env: this.searchEnv() });
+    const { root: findRoot } = await this.searchTarget(absRoot);
+    const result = await run("find", [findRoot, "-type", "f", "-name", basename, ...excludeArgs], { timeout: SEARCH_TIMEOUT_MS, env: this.searchEnv() });
     if (result.code !== 0 && !result.stdout) {
       return { success: false, output: `Glob failed: ${result.stderr.trim() || "find error"}`, truncated: false };
     }
     const capped = core.applyHeadLimit(result.stdout, headLimit);
     return {
       success: true,
-      output: core.formatSearchOutput(capped, absRoot, { emptyMessage: "No files matched." }),
+      output: core.formatSearchOutput(capped, findRoot, { emptyMessage: "No files matched." }),
       truncated: capped.truncated
     };
   }
   /**
-   * A directory to anchor a search in. `cwd` exists only so anchored
-   * `--glob`/`--include` patterns resolve against the search root (see
-   * globImpl), and spawn(2) rejects a `cwd` that is a file with ENOTDIR.
+   * The search path and a directory to anchor it in. `cwd` exists only so
+   * anchored `--glob`/`--include` patterns resolve against the search root, and
+   * spawn(2) rejects a `cwd` that is a file with ENOTDIR.
    *
    * `grep`'s `path` is documented as a directory, but the tool description
    * tells the model to survey with output_mode="files" and then re-run "on a
    * narrower path" — and what that survey hands back are files. rg and grep
    * both search a single file happily, so anchor at the parent rather than
    * failing a legitimately file-scoped search.
+   *
+   * The root is resolved through symlinks because the OS reports a child's cwd
+   * as the resolved path (macOS tmpdir is `/var/...` -> `/private/var/...`),
+   * and ripgrep matches an anchored glob against the search path as written: a
+   * root that goes through a link never matches and yields a false empty
+   * result. Result rows then carry the resolved prefix, which is why callers
+   * strip `anchor` rather than the path they were handed.
    */
-  async searchAnchor(absRoot) {
+  async searchTarget(absRoot) {
     try {
-      return (await fs.promises.stat(absRoot)).isDirectory() ? absRoot : path__namespace.dirname(absRoot);
+      const root = await fs.promises.realpath(absRoot);
+      return { root, anchor: (await fs.promises.stat(root)).isDirectory() ? root : path__namespace.dirname(root) };
     } catch {
-      return absRoot;
+      return { root: absRoot, anchor: absRoot };
     }
   }
   async grepImpl(pattern, absRoot, opts) {
     const headLimit = opts.headLimit ?? 100;
     const useRg = await this.hasRg();
-    const anchor = await this.searchAnchor(absRoot);
+    const { root, anchor } = await this.searchTarget(absRoot);
     const anchoredInclude = !useRg && opts.include?.includes("/") ? opts.include : void 0;
-    const result = useRg ? await run("rg", core.buildGrepArgs(pattern, opts, absRoot).args, { timeout: SEARCH_TIMEOUT_MS, cwd: anchor, env: this.searchEnv() }) : await run("grep", core.buildFallbackGrepArgs(pattern, anchoredInclude ? { ...opts, include: void 0 } : opts, absRoot, await this.fallbackGrepRegex()), { timeout: SEARCH_TIMEOUT_MS, cwd: anchor, env: this.searchEnv() });
+    const result = useRg ? await run("rg", core.buildGrepArgs(pattern, opts, root).args, { timeout: SEARCH_TIMEOUT_MS, cwd: anchor, env: this.searchEnv() }) : await run("grep", core.buildFallbackGrepArgs(pattern, anchoredInclude ? { ...opts, include: void 0 } : opts, root, await this.fallbackGrepRegex()), { timeout: SEARCH_TIMEOUT_MS, cwd: anchor, env: this.searchEnv() });
     if (result.code !== 0 && result.code !== 1 && !result.stdout) {
       return { success: false, output: `Search failed: ${result.stderr.trim() || "search error"}`, truncated: false };
     }
@@ -561,9 +570,10 @@ var OrchestratorPool = class {
    * environment's defaults over what the user had chosen.
    */
   setRunnerEnabled(id, enabled) {
-    const current = this.enabledRunnerOverride() ?? new WebConfig().enabledRunners;
-    const next = enabled ? current.includes(id) ? current : [...current, id] : current.filter((r) => r !== id);
-    this.settingsService.setEnabledRunners(next);
+    this.settingsService.updateEnabledRunners((saved) => {
+      const current = saved ?? new WebConfig().enabledRunners;
+      return enabled ? current.includes(id) ? current : [...current, id] : current.filter((r) => r !== id);
+    });
   }
   getSettings() {
     const config = this.plannerConfig();
@@ -912,27 +922,29 @@ function sessionsRoute(pool2) {
     const id = c.req.param("id");
     const saved = core.loadSessionPlanState(id, ws);
     if (!saved) return refuse(c, 404, "Session not found", "session_not_found");
-    return c.json({ meta: saved.meta, plan: core.surfacePlanState(pool2.getPlanState(id) ?? saved.plan) });
+    const run2 = pool2.runSnapshot(id);
+    return c.json({ meta: saved.meta, plan: core.surfacePlanState(pool2.getPlanState(id) ?? saved.plan), ...run2 ? { run: run2 } : {} });
   });
   router.post("/:id/load", (c) => {
     const ws = c.req.query("workspace") || process.cwd();
     try {
       const id = c.req.param("id");
       const plan = pool2.adoptSavedSession(id, ws);
-      return c.json({ ok: true, plan: core.surfacePlan(plan), goal: pool2.getGoal(id) });
+      const run2 = pool2.runSnapshot(id);
+      return c.json({ ok: true, plan: core.surfacePlan(plan), goal: pool2.getGoal(id), ...run2 ? { run: run2 } : {} });
     } catch (err) {
       return failure(c, err, "load session", { message: "Failed to load session" });
     }
   });
   router.get("/:id/tasks/:taskId/log", (c) => {
     const ws = c.req.query("workspace") || process.cwd();
-    return c.json({ attempts: core.listTaskLogAttempts({ baseDir: ws, sessionId: c.req.param("id") }, c.req.param("taskId")) });
+    return c.json({ attempts: core.listTaskLogAttempts({ baseDir: ws, sessionId: c.req.param("id") }, c.req.param("taskId")), position: pool2.streamPosition(c.req.param("id")) });
   });
   router.get("/:id/tasks/:taskId/log/:attempt", (c) => {
     const ws = c.req.query("workspace") || process.cwd();
     const attempt = Number(c.req.param("attempt"));
     if (!Number.isInteger(attempt) || attempt < 1) return refuse(c, 400, "attempt must be a positive integer");
-    return c.json({ attempt, events: core.taskLogForSurface(core.readTaskLog({ baseDir: ws, sessionId: c.req.param("id") }, c.req.param("taskId"), attempt)) });
+    return c.json({ attempt, events: core.taskLogForSurface(core.readTaskLog({ baseDir: ws, sessionId: c.req.param("id") }, c.req.param("taskId"), attempt)), position: pool2.streamPosition(c.req.param("id")) });
   });
   router.delete("/:id", (c) => {
     const ws = c.req.query("workspace") || process.cwd();
@@ -948,6 +960,9 @@ function sessionsRoute(pool2) {
   return router;
 }
 var NO_CHECKPOINT = "The task is not waiting at a checkpoint: it was answered already, withdrawn, or has no runner left to hear it.";
+function idOfRef(session, ref) {
+  return core.resolveUserTaskRef(session.planState?.tasks ?? [], ref)?.id ?? ref;
+}
 async function runUserCommand(session, command) {
   const outcome = await session.execute(command, { kind: "user" });
   if (!outcome.ok) throw new core.TaskControlError(outcome.message);
@@ -974,9 +989,8 @@ function plansRoute(pool2) {
     try {
       const session = pool2.session(c.req.param("sessionId"));
       if (!session.planState || session.planTasks.length === 0) throw new core.NoPlanError("execute");
-      if (session.isExecuting) throw new core.AlreadyExecutingError();
-      await runUserCommand(session, { command: "run_plan" });
-      return c.json({ status: "running" });
+      const { message } = await runUserCommand(session, { command: "run_plan" });
+      return c.json({ status: "running", message });
     } catch (err) {
       return failure(c, err, "execute");
     }
@@ -987,6 +1001,7 @@ function plansRoute(pool2) {
         const session = pool2.session(c.req.param("sessionId"));
         const outcome = await session.execute({ command: "stop_run" }, { kind: "user" });
         if (!outcome.ok && (session.isExecuting || session.startsPending)) throw new core.TaskControlError(outcome.message);
+        return c.json({ status: "stopped", message: outcome.message });
       }
       return c.json({ status: "stopped" });
     } catch (err) {
@@ -997,47 +1012,28 @@ function plansRoute(pool2) {
     const cancelled = pool2.cancelPlanning(c.req.param("sessionId"));
     return c.json({ cancelled });
   });
-  router.post("/:sessionId/tasks/:taskId/complete", async (c) => {
-    try {
-      await pool2.session(c.req.param("sessionId")).markTaskComplete(c.req.param("taskId"));
-      return c.json({ ok: true });
-    } catch (err) {
-      return failure(c, err, "mark complete", { fallback: 404, message: "Not found" });
-    }
-  });
-  router.post("/:sessionId/tasks/:taskId/uncomplete", async (c) => {
+  router.post("/:sessionId/tasks/:taskId/resume/cancel", async (c) => {
     try {
-      await pool2.session(c.req.param("sessionId")).markTaskIncomplete(c.req.param("taskId"));
-      return c.json({ ok: true });
-    } catch (err) {
-      return failure(c, err, "mark incomplete", { fallback: 404, message: "Not found" });
-    }
-  });
-  router.post("/:sessionId/tasks/:taskId/resume/cancel", (c) => {
-    try {
-      const cancelled = pool2.session(c.req.param("sessionId")).cancelScheduledResume(c.req.param("taskId"));
-      return c.json({ cancelled });
+      const { message } = await runUserCommand(pool2.session(c.req.param("sessionId")), { command: "cancel_resume", task: c.req.param("taskId") });
+      return c.json({ cancelled: true, message });
     } catch (err) {
-      return failure(c, err, "cancel resume", { fallback: 404, message: "Not found" });
-    }
-  });
-  router.post("/:sessionId/tasks/:taskId/resume/now", async (c) => {
-    try {
-      await pool2.session(c.req.param("sessionId")).resumeNow(c.req.param("taskId"));
-      return c.json({ ok: true });
-    } catch (err) {
-      return failure(c, err, "resume now", { fallback: 404, message: "Not found" });
+      return failure(c, err, "cancel resume");
     }
   });
   for (const [segment, command] of [
     ["run", (id) => ({ command: "run_task", task: id })],
     ["retry", (id) => ({ command: "retry_task", task: id, from: "fresh" })],
-    ["cancel", (id) => ({ command: "stop_task", task: id })]
+    ["cancel", (id) => ({ command: "stop_task", task: id })],
+    ["complete", (id) => ({ command: "mark_complete", task: id })],
+    ["uncomplete", (id) => ({ command: "mark_not_done", task: id })],
+    // The user says the limit has reset early: the task, and every other one waiting on its runner's reset, resumes in its saved session now.
+    ["resume/now", (id) => ({ command: "retry_task", task: id, from: "session" })],
+    ["interrupt", (id) => ({ command: "interrupt_task", task: id })]
   ]) {
     router.post(`/:sessionId/tasks/:taskId/${segment}`, async (c) => {
       try {
-        await runUserCommand(pool2.session(c.req.param("sessionId")), command(c.req.param("taskId")));
-        return c.json({ ok: true });
+        const { message } = await runUserCommand(pool2.session(c.req.param("sessionId")), command(c.req.param("taskId")));
+        return c.json({ ok: true, message });
       } catch (err) {
         return failure(c, err, segment);
       }
@@ -1047,16 +1043,16 @@ function plansRoute(pool2) {
     try {
       const body = await c.req.json().catch(() => ({}));
       const reason = typeof body === "object" && body !== null && "reason" in body && typeof body.reason === "string" ? body.reason : void 0;
-      await runUserCommand(pool2.session(c.req.param("sessionId")), { command: "skip_task", task: c.req.param("taskId"), ...reason ? { reason } : {} });
-      return c.json({ ok: true });
+      const { message } = await runUserCommand(pool2.session(c.req.param("sessionId")), { command: "skip_task", task: c.req.param("taskId"), ...reason ? { reason } : {} });
+      return c.json({ ok: true, message });
     } catch (err) {
       return failure(c, err, "skip");
     }
   });
   router.post("/:sessionId/tasks/:taskId/force-start", async (c) => {
     try {
-      await pool2.session(c.req.param("sessionId")).forceStartTask(c.req.param("taskId"));
-      return c.json({ ok: true });
+      const { message, payload } = await runUserCommand(pool2.session(c.req.param("sessionId")), { command: "force_start", task: c.req.param("taskId") });
+      return c.json({ ok: true, ...payload?.kind === "queued" ? { queued: payload.line } : {}, message });
     } catch (err) {
       return failure(c, err, "force-start");
     }
@@ -1072,8 +1068,12 @@ function plansRoute(pool2) {
       return failure(c, err, "task edit");
     }
   };
-  router.post("/:sessionId/tasks/:taskId/messages", messageHandler(async (session, taskId, text) => (await runUserCommand(session, { command: "message_task", task: taskId, text })).id ?? ""));
-  router.post("/:sessionId/tasks/:taskId/messages/now", messageHandler((session, taskId, text) => session.forceSendTaskMessage(taskId, text)));
+  const sendMessage = (force) => messageHandler(async (session, taskId, text) => {
+    const { payload } = await runUserCommand(session, { command: "message_task", task: taskId, text, ...force ? { force } : {} });
+    return payload?.kind === "message" ? payload.id : "";
+  });
+  router.post("/:sessionId/tasks/:taskId/messages", sendMessage(false));
+  router.post("/:sessionId/tasks/:taskId/messages/now", sendMessage(true));
   router.post("/:sessionId/tasks/:taskId/commands", async (c) => {
     try {
       const body = await c.req.json().catch(() => ({}));
@@ -1086,10 +1086,10 @@ function plansRoute(pool2) {
       return failure(c, err, "task edit");
     }
   });
-  router.post("/:sessionId/tasks/:taskId/messages/:messageId/now", (c) => {
+  router.post("/:sessionId/tasks/:taskId/messages/:messageId/now", async (c) => {
     try {
-      const sent = pool2.session(c.req.param("sessionId")).forceSendQueuedTaskMessage(c.req.param("taskId"), c.req.param("messageId"));
-      return c.json({ sent });
+      const { message } = await runUserCommand(pool2.session(c.req.param("sessionId")), { command: "force_send_queued", task: c.req.param("taskId"), id: c.req.param("messageId") });
+      return c.json({ sent: true, message });
     } catch (err) {
       return failure(c, err, "task edit");
     }
@@ -1099,57 +1099,40 @@ function plansRoute(pool2) {
       const body = await c.req.json().catch(() => ({}));
       const text = typeof body === "object" && body !== null && "text" in body ? body.text : void 0;
       if (typeof text !== "string" || !text.trim()) return c.json({ error: "text is required" }, 400);
-      await runUserCommand(pool2.session(c.req.param("sessionId")), { command: "retry_task", task: c.req.param("taskId"), from: "session", message: text });
-      return c.json({ ok: true });
-    } catch (err) {
-      return failure(c, err, "task edit");
-    }
-  });
-  router.delete("/:sessionId/tasks/:taskId/messages/:messageId", (c) => {
-    try {
-      const removed = pool2.session(c.req.param("sessionId")).removeQueuedTaskMessage(c.req.param("taskId"), c.req.param("messageId"));
-      return c.json({ removed });
-    } catch (err) {
-      return failure(c, err, "task edit");
-    }
-  });
-  router.post("/:sessionId/tasks/:taskId/interrupt", async (c) => {
-    try {
-      await pool2.session(c.req.param("sessionId")).interruptTask(c.req.param("taskId"));
-      return c.json({ ok: true });
-    } catch (err) {
-      return failure(c, err, "task edit");
-    }
-  });
-  router.post("/:sessionId/tasks/:taskId/checkpoint/approve", (c) => {
-    try {
-      const session = pool2.session(c.req.param("sessionId"));
-      const taskId = c.req.param("taskId");
-      if (!session.awaitsCheckpoint(taskId)) return refuse(c, 409, NO_CHECKPOINT, "checkpoint_not_waiting");
-      session.approveCheckpoint(taskId);
-      return c.json({ ok: true });
+      const { message } = await runUserCommand(pool2.session(c.req.param("sessionId")), { command: "retry_task", task: c.req.param("taskId"), from: "session", message: text });
+      return c.json({ ok: true, message });
     } catch (err) {
       return failure(c, err, "task edit");
     }
   });
-  router.post("/:sessionId/tasks/:taskId/checkpoint/reject", async (c) => {
+  router.delete("/:sessionId/tasks/:taskId/messages/:messageId", async (c) => {
     try {
-      const body = await c.req.json().catch(() => ({}));
-      const reason = typeof body === "object" && body !== null && "reason" in body && typeof body.reason === "string" ? body.reason.trim() : "";
-      const session = pool2.session(c.req.param("sessionId"));
-      const taskId = c.req.param("taskId");
-      if (!session.awaitsCheckpoint(taskId)) return refuse(c, 409, NO_CHECKPOINT, "checkpoint_not_waiting");
-      session.rejectCheckpoint(taskId, reason || void 0);
-      return c.json({ ok: true });
+      const { message } = await runUserCommand(pool2.session(c.req.param("sessionId")), { command: "remove_queued", task: c.req.param("taskId"), id: c.req.param("messageId") });
+      return c.json({ removed: true, message });
     } catch (err) {
       return failure(c, err, "task edit");
     }
   });
+  for (const answer of ["approve", "reject"]) {
+    router.post(`/:sessionId/tasks/:taskId/checkpoint/${answer}`, async (c) => {
+      try {
+        const body = answer === "reject" ? await c.req.json().catch(() => ({})) : {};
+        const reason = typeof body === "object" && body !== null && "reason" in body && typeof body.reason === "string" ? body.reason.trim() : "";
+        const session = pool2.session(c.req.param("sessionId"));
+        const taskId = idOfRef(session, c.req.param("taskId"));
+        if (!session.awaitsCheckpoint(taskId)) return refuse(c, 409, NO_CHECKPOINT, "checkpoint_not_waiting");
+        const { message } = await runUserCommand(session, { command: "answer_checkpoint", task: taskId, answer, ...reason ? { reason } : {} });
+        return c.json({ ok: true, message });
+      } catch (err) {
+        return failure(c, err, "task edit");
+      }
+    });
+  }
   router.get("/:sessionId/tasks/:taskId/merge-gate", (c) => {
     try {
       const session = pool2.session(c.req.param("sessionId"));
       const tasks = core.flattenTasks(session.planState?.tasks ?? []);
-      const mergeGate = session.mergeGate(c.req.param("taskId")).map((id) => {
+      const mergeGate = session.mergeGate(idOfRef(session, c.req.param("taskId"))).map((id) => {
         const dep = tasks.find((t) => t.id === id);
         return { id, order: dep?.order ?? 0, title: dep?.title ?? id };
       });
@@ -1167,7 +1150,10 @@ function plansRoute(pool2) {
   });
   router.post("/:sessionId/isolation/merge", async (c) => {
     try {
-      return c.json(await pool2.session(c.req.param("sessionId")).mergeRun());
+      const outcome = await pool2.session(c.req.param("sessionId")).execute({ command: "merge_all" }, { kind: "user" });
+      if (outcome.payload?.kind === "merge") return c.json(outcome.payload.result);
+      if (!outcome.ok) throw new core.TaskControlError(outcome.message);
+      throw new Error("Merge all answered without its result.");
     } catch (err) {
       return failure(c, err, "task edit");
     }
@@ -1197,21 +1183,9 @@ function plansRoute(pool2) {
   });
   router.put("/:sessionId/tasks/:taskId", async (c) => {
     try {
-      const { assignedRunner, dependencies, ...rest } = await c.req.json();
-      const session = pool2.session(c.req.param("sessionId"));
-      const taskId = c.req.param("taskId");
-      const hasRunner = typeof assignedRunner === "string";
-      const hasDeps = Array.isArray(dependencies);
-      let result = null;
-      if (hasRunner) result = await session.setTaskRunner(taskId, assignedRunner);
-      if (hasDeps) {
-        try {
-          result = await session.setTaskDependencies(taskId, dependencies.map(String));
-        } catch (err) {
-          return failure(c, err, "task dependencies", { fallback: 400 });
-        }
-      }
-      if (Object.keys(rest).length > 0 || !hasRunner && !hasDeps) result = await session.updateTask(taskId, rest);
+      const changes = await c.req.json();
+      if (changes.assignedModel === null) changes.assignedModel = void 0;
+      const result = await pool2.session(c.req.param("sessionId")).updateTask(c.req.param("taskId"), changes);
       if (!result) return refuse(c, 404, "Task not found", "task_not_found");
       return c.json({ ok: true });
     } catch (err) {
@@ -1239,8 +1213,11 @@ function plansRoute(pool2) {
   });
   router.post("/:sessionId/review/approve", async (c) => {
     try {
-      const plan = await pool2.session(c.req.param("sessionId")).approveReview();
-      return c.json({ plan: core.surfacePlan(plan) });
+      const session = pool2.session(c.req.param("sessionId"));
+      const plan = session.planState;
+      if (!plan) throw new core.NoPlanError("review");
+      const { message } = await runUserCommand(session, { command: "approve_review" });
+      return c.json({ plan: core.surfacePlan(plan), message });
     } catch (err) {
       return failure(c, err, "review approve");
     }
@@ -1297,6 +1274,14 @@ function plansRoute(pool2) {
       return failure(c, err, "conversation message");
     }
   });
+  router.post("/:sessionId/converse/resend/cancel", (c) => {
+    try {
+      const cancelled = pool2.session(c.req.param("sessionId")).cancelPlannerResend();
+      return c.json({ cancelled });
+    } catch (err) {
+      return failure(c, err, "cancel resend", { fallback: 404, message: "Not found" });
+    }
+  });
   router.post("/:sessionId/conversation/fork", (c) => {
     try {
       const fork = pool2.forkConversation(c.req.param("sessionId"));
@@ -1397,9 +1382,9 @@ function approvalsRoute(pool2) {
     const answer = answerOf(await c.req.json().catch(() => null));
     const decided = core.toApprovalDecision(answer);
     const request = pool2.outstandingApprovals(sessionId).find((pending) => pending.id === approvalId)?.request;
-    if (decided.decision === "deny" && request?.taskId) {
+    if (request?.taskId) {
       const outcome = await pool2.session(sessionId).execute(
-        { command: "answer_approval", task: request.taskId, approval: approvalId, answer: "deny", ...decided.note ? { note: decided.note } : {} },
+        { command: "answer_approval", task: request.taskId, approval: approvalId, answer: decided.decision, ...decided.decision === "deny" && decided.note ? { note: decided.note } : {} },
         { kind: "user" }
       );
       if (!outcome.ok) return refuse(c, 400, outcome.message, "refused");