@schoolai/shipyard 0.6.0 → 0.7.0-rc.20260221

package/dist/index.js

@@ -12,7 +12,7 @@ import {
   PersonalRoomConnection,
   ROUTES,
   ValidationErrorResponseSchema
-} from "./chunk-CQBP5B4G.js";
+} from "./chunk-OTIQVES4.js";
 import {
   __export,
   getShipyardHome,
@@ -11331,6 +11331,7 @@ var TaskDocumentSchema = Shape.doc({
     updatedAt: Shape.plain.number()
   }),
   conversation: Shape.list(MessageShape),
+  pendingFollowUps: Shape.list(MessageShape),
   sessions: Shape.list(SessionEntryShape),
   diffState: DiffStateShape,
   plans: Shape.list(PlanVersionShape),
@@ -11338,6 +11339,7 @@ var TaskDocumentSchema = Shape.doc({
   diffComments: Shape.record(DiffCommentShape),
   planComments: Shape.record(PlanCommentShape)
 });
+var TERMINAL_TASK_STATES = ["completed", "failed", "canceled"];
 var TOOL_RISK_LEVELS = ["low", "medium", "high"];
 var PERMISSION_DECISIONS = ["approved", "denied"];
 var PermissionRequestEphemeral = Shape.plain.struct({
@@ -41672,7 +41674,8 @@ var SessionManager = class {
    * Determine whether to resume an existing session or start fresh.
    *
    * Walks backwards through sessions to find the most recent one with a
-   * non-empty agentSessionId that has not failed. If found, returns
+   * non-empty agentSessionId that has not genuinely failed. Interrupted
+   * (user-cancelled) sessions are resumable. If found, returns
    * { resume: true, sessionId } so the caller can pass it to resumeSession().
    */
   shouldResume() {
@@ -41743,7 +41746,7 @@ var SessionManager = class {
     });
     this.#inputController = controller;
     this.#activeQuery = response;
-    return this.#processMessages(response, sessionId);
+    return this.#processMessages(response, sessionId, opts.abortController);
   }
   /**
    * Send a follow-up message to the active streaming session.
@@ -41839,9 +41842,9 @@ var SessionManager = class {
     });
     this.#inputController = controller;
     this.#activeQuery = response;
-    return this.#processMessages(response, newSessionId);
+    return this.#processMessages(response, newSessionId, opts?.abortController);
   }
-  async #processMessages(response, sessionId) {
+  async #processMessages(response, sessionId, abortController) {
     let agentSessionId = "";
     let lastMessageAt = Date.now();
     let idleTimedOut = false;
@@ -41868,14 +41871,13 @@ var SessionManager = class {
         }
       }
     } catch (error2) {
-      const errorMsg2 = idleTimedOut ? "Session idle timeout exceeded" : error2 instanceof Error ? error2.message : String(error2);
-      this.#markFailed(sessionId, errorMsg2);
-      return {
+      return this.#handleProcessError(
+        error2,
         sessionId,
         agentSessionId,
-        status: "failed",
-        error: errorMsg2
-      };
+        idleTimedOut,
+        abortController
+      );
     } finally {
       clearInterval(idleTimer);
       this.#inputController = null;
@@ -42113,6 +42115,28 @@ var SessionManager = class {
       error: !isSuccess ? errorText ?? message.subtype : void 0
     };
   }
+  #handleProcessError(error2, sessionId, agentSessionId, idleTimedOut, abortController) {
+    if (abortController?.signal.aborted) {
+      this.#markInterrupted(sessionId);
+      return { sessionId, agentSessionId, status: "interrupted" };
+    }
+    const errorMsg = idleTimedOut ? "Session idle timeout exceeded" : error2 instanceof Error ? error2.message : String(error2);
+    this.#markFailed(sessionId, errorMsg);
+    return { sessionId, agentSessionId, status: "failed", error: errorMsg };
+  }
+  #markInterrupted(sessionId) {
+    const idx = this.#findSessionIndex(sessionId);
+    change(this.#taskDoc, (draft) => {
+      const session = idx >= 0 ? draft.sessions.get(idx) : void 0;
+      if (session) {
+        session.status = "interrupted";
+        session.completedAt = Date.now();
+      }
+      draft.meta.status = "canceled";
+      draft.meta.updatedAt = Date.now();
+    });
+    this.#notifyStatusChange("canceled");
+  }
   #markFailed(sessionId, errorMsg) {
     const idx = this.#findSessionIndex(sessionId);
     change(this.#taskDoc, (draft) => {
@@ -42488,6 +42512,34 @@ var TaskEphemeralDeclarations = {
   permReqs: PermissionRequestEphemeral,
   permResps: PermissionResponseEphemeral
 };
+var TERMINAL_STATUSES = new Set(TERMINAL_TASK_STATES);
+async function rehydrateTaskDocuments(roomHandle, roomDoc, repo, log) {
+  try {
+    await roomHandle.waitForSync({ kind: "storage", timeout: 5e3 });
+  } catch {
+    log.warn(
+      "Room doc storage sync timed out during rehydration \u2014 task rehydration may be incomplete"
+    );
+  }
+  const roomJson = roomDoc.toJSON();
+  const taskEntries = Object.entries(roomJson.taskIndex ?? {});
+  log.info({ count: taskEntries.length }, "Rehydrating task documents from storage");
+  for (const [taskId, entry] of taskEntries) {
+    if (TERMINAL_STATUSES.has(entry.status)) continue;
+    try {
+      const taskDocId = buildDocumentId("task", taskId, DEFAULT_EPOCH);
+      const taskHandle = repo.get(taskDocId, TaskDocumentSchema, TaskEphemeralDeclarations);
+      await taskHandle.waitForSync({ kind: "storage", timeout: 5e3 });
+      if (recoverOrphanedTask(taskHandle.doc, createChildLogger({ mode: "rehydrate", taskId }))) {
+        updateTaskInIndex(roomDoc, taskId, { status: "failed", updatedAt: Date.now() });
+      }
+      log.debug({ taskId, taskDocId }, "Task document rehydrated");
+    } catch (err) {
+      log.warn({ taskId, err }, "Failed to rehydrate task document");
+    }
+  }
+  log.info("Task document rehydration complete");
+}
 async function serve(env) {
   if (!env.SHIPYARD_SIGNALING_URL) {
     logger.error("SHIPYARD_SIGNALING_URL is required for serve mode");
@@ -42520,6 +42572,7 @@ async function serve(env) {
   const activeTasks = /* @__PURE__ */ new Map();
   const watchedTasks = /* @__PURE__ */ new Map();
   const taskHandles = /* @__PURE__ */ new Map();
+  const lastProcessedConvLen = /* @__PURE__ */ new Map();
   const devSuffix = env.SHIPYARD_DEV ? "-dev" : "";
   const machineId = env.SHIPYARD_MACHINE_ID ?? `${hostname2()}${devSuffix}`;
   const dataDir = resolve(env.SHIPYARD_DATA_DIR.replace("~", homedir2()));
@@ -42733,6 +42786,7 @@ async function serve(env) {
   const typedRoomHandle = roomHandle;
   const typedRoomDoc = roomHandle.doc;
   cleanupStaleSetupEntries(typedRoomDoc, machineId, log);
+  await rehydrateTaskDocuments(roomHandle, typedRoomDoc, repo, log);
   typedRoomHandle.enhancePromptReqs.subscribe(({ key: requestId, value, source }) => {
     if (source !== "remote") return;
     if (!value) return;
@@ -42904,6 +42958,7 @@ async function serve(env) {
       activeTasks,
       watchedTasks,
       taskHandles,
+      lastProcessedConvLen,
       peerManager,
       env,
       machineId,
@@ -42935,6 +42990,7 @@ async function serve(env) {
     }
     watchedTasks.clear();
     taskHandles.clear();
+    lastProcessedConvLen.clear();
     for (const timer of pendingCleanupTimers) clearTimeout(timer);
     pendingCleanupTimers.clear();
     for (const [id, ptyMgr] of terminalPtys) {
@@ -43109,6 +43165,12 @@ function handleMessage(msg, ctx) {
     case "worktree-create-error":
       ctx.log.debug({ type: msg.type }, "Worktree create echo");
       break;
+    case "cancel-task":
+      handleCancelTask(msg, ctx);
+      break;
+    case "control-ack":
+      ctx.log.debug({ type: msg.type }, "Control ack echo");
+      break;
     case "authenticated":
     case "agent-joined":
     case "agent-left":
@@ -43160,6 +43222,32 @@ function handleNotifyTask(msg, ctx) {
     taskLog.error({ err: errMsg }, "Failed to start watching task document");
   });
 }
+function handleCancelTask(msg, ctx) {
+  const { taskId, requestId } = msg;
+  const taskLog = createChildLogger({ mode: "serve", taskId });
+  const activeTask = ctx.activeTasks.get(taskId);
+  if (!activeTask) {
+    taskLog.warn("Cancel requested but no active task found");
+    ctx.connection.send({
+      type: "control-ack",
+      requestId,
+      taskId,
+      action: "cancel",
+      accepted: false,
+      error: "No active agent running for this task"
+    });
+    return;
+  }
+  taskLog.info("Canceling active task");
+  activeTask.abortController.abort();
+  ctx.connection.send({
+    type: "control-ack",
+    requestId,
+    taskId,
+    action: "cancel",
+    accepted: true
+  });
+}
 var ENHANCE_PROMPT_TIMEOUT_MS = 3e4;
 var ENHANCE_SYSTEM_PROMPT = `You are a prompt rewriter that transforms rough user requests into clear, specific instructions for an AI coding assistant (Claude Code). The enhanced prompt will be sent AS the user's message to that assistant.
 
@@ -43586,12 +43674,15 @@ async function watchTaskDocument(taskId, taskLog, ctx) {
   try {
     await taskHandle.waitForSync({ kind: "storage", timeout: 5e3 });
   } catch {
-    taskLog.debug({ taskDocId }, "No existing task data in storage");
+    taskLog.info({ taskDocId }, "No existing task data in storage");
   }
   try {
     await taskHandle.waitForSync({ kind: "network", timeout: 3e3 });
   } catch {
-    taskLog.debug({ taskDocId }, "Network sync timed out (browser may not be connected yet)");
+    taskLog.warn(
+      { taskDocId, timeoutMs: 3e3 },
+      "Network sync timed out (browser may not be connected yet)"
+    );
   }
   if (recoverOrphanedTask(taskHandle.doc, taskLog)) {
     updateTaskInIndex(ctx.roomDoc, taskId, { status: "failed", updatedAt: Date.now() });
@@ -43622,27 +43713,38 @@ async function watchTaskDocument(taskId, taskLog, ctx) {
     onTaskDocChanged(taskId, taskHandle, taskLog, ctx);
   }
 }
-function handleFollowUp(activeTask, conversationLen, taskLog) {
+function promotePendingFollowUps(taskHandle, activeTask, taskLog) {
   if (!activeTask) return;
-  if (conversationLen <= activeTask.lastDispatchedConvLen) {
-    taskLog.debug(
-      { conversationLen, lastDispatched: activeTask.lastDispatchedConvLen },
-      "Conversation unchanged since last dispatch, skipping duplicate"
-    );
+  if (activeTask.abortController.signal.aborted) {
+    taskLog.debug("Task is being aborted, skipping pending follow-up promotion");
     return;
   }
   if (!activeTask.sessionManager.isStreaming) {
-    taskLog.debug("Task already running but not streaming, skipping");
+    taskLog.debug("Task not streaming, skipping pending follow-up promotion");
     return;
   }
-  const contentBlocks = activeTask.sessionManager.getLatestUserContentBlocks();
-  if (contentBlocks && contentBlocks.length > 0) {
+  const json = taskHandle.doc.toJSON();
+  const pending = json.pendingFollowUps ?? [];
+  if (pending.length === 0) return;
+  change(taskHandle.doc, (draft) => {
+    const items = draft.pendingFollowUps.toArray();
+    for (const msg of items) {
+      draft.conversation.push(msg);
+    }
+    if (draft.pendingFollowUps.length > 0) {
+      draft.pendingFollowUps.delete(0, draft.pendingFollowUps.length);
+    }
+  });
+  const allContentBlocks = pending.flatMap(
+    (msg) => msg.content.filter((block2) => block2.type === "text" || block2.type === "image")
+  );
+  if (allContentBlocks.length > 0) {
     try {
-      taskLog.info("Sending follow-up to active streaming session");
-      activeTask.lastDispatchedConvLen = conversationLen;
-      activeTask.sessionManager.sendFollowUp(contentBlocks);
+      taskLog.info({ pendingCount: pending.length }, "Promoted pending follow-ups to conversation");
+      activeTask.lastDispatchedConvLen = json.conversation.length + pending.length;
+      activeTask.sessionManager.sendFollowUp(allContentBlocks);
     } catch (err) {
-      taskLog.warn({ err }, "Failed to send follow-up to streaming session");
+      taskLog.warn({ err }, "Failed to send promoted follow-up");
     }
   }
 }
@@ -43659,22 +43761,35 @@ function onTaskDocChanged(taskId, taskHandle, taskLog, ctx) {
     "onTaskDocChanged evaluation"
   );
   if (ctx.activeTasks.has(taskId)) {
-    const conversation2 = json.conversation;
-    const lastMessage2 = conversation2[conversation2.length - 1];
-    if (lastMessage2?.role === "user") {
-      handleFollowUp(ctx.activeTasks.get(taskId), conversation2.length, taskLog);
+    const pendingFollowUps2 = json.pendingFollowUps ?? [];
+    if (pendingFollowUps2.length > 0) {
+      promotePendingFollowUps(taskHandle, ctx.activeTasks.get(taskId), taskLog);
     }
+    const conversation2 = json.conversation;
     const activeLastUserMsg = [...conversation2].reverse().find((m) => m.role === "user");
     const activeCwd = activeLastUserMsg?.cwd ?? process.cwd();
     debouncedDiffCapture(taskId, activeCwd, taskHandle, taskLog);
     debouncedBranchDiffCapture(taskId, activeCwd, taskHandle, taskLog);
     return;
   }
-  if (json.meta.status === "working" || json.meta.status === "input-required" || json.meta.status === "starting") {
-    taskLog.debug({ status: json.meta.status }, "Status blocks new work, skipping");
-    return;
+  const pendingFollowUps = json.pendingFollowUps ?? [];
+  if (pendingFollowUps.length > 0) {
+    taskLog.info(
+      { pendingCount: pendingFollowUps.length },
+      "Promoting orphaned pending follow-ups"
+    );
+    change(taskHandle.doc, (draft) => {
+      const items = draft.pendingFollowUps.toArray();
+      for (const msg of items) {
+        draft.conversation.push(msg);
+      }
+      if (draft.pendingFollowUps.length > 0) {
+        draft.pendingFollowUps.delete(0, draft.pendingFollowUps.length);
+      }
+    });
   }
-  const conversation = json.conversation;
+  const freshJson = taskHandle.doc.toJSON();
+  const conversation = freshJson.conversation;
   if (conversation.length === 0) {
     taskLog.debug("No conversation messages, skipping");
     return;
@@ -43683,7 +43798,18 @@ function onTaskDocChanged(taskId, taskHandle, taskLog, ctx) {
   if (!lastMessage || lastMessage.role !== "user") {
     return;
   }
-  taskLog.info("New user message detected, starting agent");
+  const prevLen = ctx.lastProcessedConvLen.get(taskId) ?? 0;
+  if (conversation.length <= prevLen) {
+    taskLog.debug(
+      { conversationLen: conversation.length, lastProcessed: prevLen },
+      "No new messages since last run, skipping"
+    );
+    return;
+  }
+  taskLog.info(
+    { prevLen, newLen: conversation.length },
+    "New user message detected, starting agent"
+  );
   const cwd = lastMessage.cwd ?? process.cwd();
   const model = lastMessage.model ?? void 0;
   const permissionMode = mapPermissionMode(lastMessage.permissionMode);
@@ -43700,6 +43826,7 @@ function onTaskDocChanged(taskId, taskHandle, taskLog, ctx) {
     lastDispatchedConvLen: conversation.length
   };
   ctx.activeTasks.set(taskId, activeTask);
+  ctx.lastProcessedConvLen.set(taskId, conversation.length);
   ctx.signaling.updateStatus("running", taskId);
   const turnStartRefPromise = captureTreeSnapshot(cwd);
   turnStartRefPromise.then((ref) => taskLog.debug({ turnStartRef: ref }, "Captured turn start snapshot")).catch((err) => taskLog.warn({ err }, "Failed to capture turn start snapshot"));
@@ -43746,6 +43873,7 @@ async function cleanupTaskRun(opts) {
   const { taskId, cwd, taskHandle, taskLog, turnStartRefPromise, abortController, ctx } = opts;
   const activeTask = ctx.activeTasks.get(taskId);
   activeTask?.sessionManager.closeSession();
+  abortController.abort();
   clearDebouncedTimer(diffDebounceTimers, taskId);
   clearDebouncedTimer(branchDiffTimers, taskId);
   try {
@@ -43764,7 +43892,6 @@ async function cleanupTaskRun(opts) {
   } catch (err) {
     taskLog.warn({ err }, "Failed to capture turn diff");
   }
-  abortController.abort();
   for (const [key] of taskHandle.permReqs.getAll()) {
     taskHandle.permReqs.delete(key);
   }
@@ -43773,6 +43900,7 @@ async function cleanupTaskRun(opts) {
   }
   ctx.activeTasks.delete(taskId);
   ctx.signaling.updateStatus("idle");
+  onTaskDocChanged(taskId, taskHandle, taskLog, ctx);
 }
 function clearDebouncedTimer(timers, taskId) {
   const timer = timers.get(taskId);
@@ -44154,7 +44282,7 @@ function handleResult(log, result, startTime) {
 async function handleSubcommand() {
   const subcommand = process.argv[2];
   if (subcommand === "login") {
-    const { loginCommand } = await import("./login-625HP2EN.js");
+    const { loginCommand } = await import("./login-6TA7RIBE.js");
     const hasCheck = process.argv.includes("--check");
     await loginCommand({ check: hasCheck });
     return true;