@shipers-dev/multi 0.23.0 → 0.23.2

package/dist/index.js

@@ -15000,7 +15000,7 @@ import { parseArgs as parseArgs2 } from "util";
 // package.json
 var package_default = {
   name: "@shipers-dev/multi",
-  version: "0.23.0",
+  version: "0.23.2",
   type: "module",
   bin: {
     "multi-agent": "./dist/index.js"
@@ -31195,6 +31195,41 @@ class RequestError extends Error {
 // src/_impl/acp-runner.ts
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, existsSync as existsSync4 } from "fs";
 import { dirname as dirname5, join as join6 } from "path";
+
+// src/_impl/workspace-mutex.ts
+var tails = new Map;
+var WRITE_TOOLS = new Set([
+  "Edit",
+  "Write",
+  "Bash",
+  "NotebookEdit",
+  "mcp__acp__Edit",
+  "mcp__acp__Write"
+]);
+function isWriteTool(name) {
+  if (!name)
+    return false;
+  return WRITE_TOOLS.has(name);
+}
+async function withWorkspaceWrite(workspaceId, fn2) {
+  const prev = tails.get(workspaceId) ?? Promise.resolve();
+  let release;
+  const next = new Promise((res) => {
+    release = res;
+  });
+  tails.set(workspaceId, prev.then(() => next));
+  try {
+    await prev;
+    return await fn2();
+  } finally {
+    release();
+    if (tails.get(workspaceId) === prev.then(() => next)) {
+      tails.delete(workspaceId);
+    }
+  }
+}
+
+// src/_impl/acp-runner.ts
 function ensureBypassPermissions(cwd) {
   try {
     const dir = join6(cwd, ".claude");
@@ -31429,8 +31464,13 @@ ${entries2}` } });
       const alwaysOpt = opts2.find((op) => /always/i.test(op.name || "") || /allow_always/i.test(op.kind || ""));
       const allowOpt = opts2.find((op) => /allow/i.test(op.kind || "") || /allow/i.test(op.name || ""));
       const chosen = alwaysOpt || allowOpt;
-      if (chosen)
+      if (chosen) {
+        const toolName = tc.title || tc.toolName || "";
+        if (o.workspaceId && isWriteTool(toolName)) {
+          return await withWorkspaceWrite(o.workspaceId, async () => ({ outcome: { outcome: "selected", optionId: chosen.optionId } }));
+        }
         return { outcome: { outcome: "selected", optionId: chosen.optionId } };
+      }
     }
     if (toolKey && allowCache.has(toolKey)) {
       const allowOpt = params.options.find((op) => /allow/i.test(op.kind || "") || /allow/i.test(op.name || ""));
@@ -32137,6 +32177,39 @@ var ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 var ID_LENGTH = 21;
 var generate = customAlphabet(ALPHABET, ID_LENGTH);
 var ID_REGEX = new RegExp(`^[${ALPHABET}]+$`);
+// ../lib/agent-workspaces.ts
+var AGENT_WORKSPACE_STATUSES = [
+  "initializing",
+  "setup_pending",
+  "ready",
+  "archived"
+];
+var AgentWorkspaceStatusSchema = exports_external.enum(AGENT_WORKSPACE_STATUSES);
+var AgentWorkspaceSchema = exports_external.object({
+  id: exports_external.string(),
+  project_id: exports_external.string(),
+  issue_id: exports_external.string().nullable(),
+  branch: exports_external.string(),
+  worktree_path: exports_external.string().nullable(),
+  device_id: exports_external.string().nullable(),
+  status: AgentWorkspaceStatusSchema,
+  agent_session_id: exports_external.string().nullable(),
+  runtime: exports_external.string().nullable(),
+  created_at: exports_external.number(),
+  archived_at: exports_external.number().nullable()
+}).meta({ id: "AgentWorkspace" });
+var CreateAgentWorkspaceSchema = exports_external.object({
+  project_id: exports_external.string(),
+  issue_id: exports_external.string().nullable().optional(),
+  branch: exports_external.string().min(1),
+  device_id: exports_external.string().nullable().optional(),
+  runtime: exports_external.string().nullable().optional()
+}).meta({ id: "CreateAgentWorkspace" });
+var TransitionAgentWorkspaceSchema = exports_external.object({
+  status: AgentWorkspaceStatusSchema,
+  worktree_path: exports_external.string().nullable().optional(),
+  agent_session_id: exports_external.string().nullable().optional()
+}).meta({ id: "TransitionAgentWorkspace" });
 // src/_impl/legacy-main.ts
 import { parseArgs } from "util";
 import { mkdirSync as mkdirSync5, existsSync as existsSync7, writeFileSync as writeFileSync5, readFileSync as readFileSync7, appendFileSync as appendFileSync3, unlinkSync as unlinkSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
@@ -32423,17 +32496,12 @@ async function cmdConnect(apiUrl, config2) {
   }
   function pickNext() {
     const busyAgents = Array.from(running3.values()).map((e) => e.agentId).filter((v) => !!v);
-    const busyIssues = Array.from(running3.values()).map((e) => e.issueId).filter((v) => !!v);
     const clauses = [];
     const binds = [];
     if (busyAgents.length) {
       clauses.push(`(agent_id IS NULL OR agent_id NOT IN (${busyAgents.map(() => "?").join(",")}))`);
       binds.push(...busyAgents);
     }
-    if (busyIssues.length) {
-      clauses.push(`(issue_id IS NULL OR issue_id NOT IN (${busyIssues.map(() => "?").join(",")}))`);
-      binds.push(...busyIssues);
-    }
     const where = clauses.length ? `AND ${clauses.join(" AND ")}` : "";
     const sql = `SELECT id, payload, agent_id, issue_id FROM tasks WHERE status = 'queued' ${where} ORDER BY created_at ASC LIMIT 1`;
     return db.query(sql).get(...binds);
@@ -32446,8 +32514,6 @@ async function cmdConnect(apiUrl, config2) {
       const ids4 = resolvePayloadIds(row);
       if (ids4.agent_id && Array.from(running3.values()).some((e) => e.agentId === ids4.agent_id))
         return;
-      if (ids4.issue_id && Array.from(running3.values()).some((e) => e.issueId === ids4.issue_id))
-        return;
       db.run("UPDATE tasks SET status = 'running', started_at = unixepoch(), attempts = attempts + 1 WHERE id = ?", [row.id]);
       const entry = { agentId: ids4.agent_id || "", issueId: ids4.issue_id, startedAt: Date.now(), child: null, worktreePath: "" };
       running3.set(row.id, entry);
@@ -32632,9 +32698,9 @@ async function cmdConnect(apiUrl, config2) {
   {
     const pending3 = await heartbeat();
     if (pending3 > 0)
-      drainOfflineDispatches(apiUrl, config2.deviceId, config2.token, db, () => schedule2());
+      drainOfflineDispatches(apiUrl, config2.deviceId, config2.token, db, () => schedule2(), () => alive);
   }
-  drainOfflineDispatches(apiUrl, config2.deviceId, config2.token, db, () => schedule2());
+  drainOfflineDispatches(apiUrl, config2.deviceId, config2.token, db, () => schedule2(), () => alive);
   let alive = true;
   const shutdown = async (reason) => {
     if (!alive)
@@ -32683,7 +32749,7 @@ async function cmdConnect(apiUrl, config2) {
           try {
             const pending3 = await heartbeat();
             if (pending3 > 0)
-              drainOfflineDispatches(apiUrl, config2.deviceId, config2.token, db, () => schedule2());
+              drainOfflineDispatches(apiUrl, config2.deviceId, config2.token, db, () => schedule2(), () => alive);
           } catch (e) {
             log3(`heartbeat error after tunnel restart: ${String(e)}`);
           }
@@ -32740,7 +32806,7 @@ async function cmdConnect(apiUrl, config2) {
     try {
       const pending3 = await heartbeat();
       if (pending3 > 0)
-        drainOfflineDispatches(apiUrl, config2.deviceId, config2.token, db, () => schedule2());
+        drainOfflineDispatches(apiUrl, config2.deviceId, config2.token, db, () => schedule2(), () => alive);
     } catch (e) {
       log3(`heartbeat error: ${String(e)}`);
     }
@@ -32935,6 +33001,13 @@ async function handleRunTask(apiUrl, deviceId, task, detected, ctx) {
       workingDir = wt.path;
       worktreeBranch = wt.branch;
       await postStream(apiUrl, issueId, "worktree_created", { path: wt.path, branch: wt.branch, reused: !wt.created });
+      if (task.workspace_id && task.project_id) {
+        try {
+          await apiClient.post(`${apiUrl}/api/agent-workspaces/${task.workspace_id}/ready?project_id=${encodeURIComponent(task.project_id)}`, { status: "ready", worktree_path: wt.path });
+        } catch (e) {
+          await postStream(apiUrl, issueId, "worktree_error", { message: `agent-workspace ack failed: ${fmtError(e)}` });
+        }
+      }
     } catch (e) {
       await postStream(apiUrl, issueId, "worktree_error", { message: fmtError(e) });
     }
@@ -33262,6 +33335,8 @@ ${userPart}` : userPart;
         issueId,
         deviceId,
         prompt,
+        workspaceId: task.workspace_id || issueId,
+        workspaceSessionId: task.workspace_session_id || null,
         sessionId: task.session_id || null,
         adapterBin,
         autonomy: task.autonomy_level,
@@ -33271,6 +33346,11 @@ ${userPart}` : userPart;
           try {
             await apiClient.post(`${apiUrl}/api/issues/${issueId}/session`, { session_id: sid });
           } catch {}
+          if (task.workspace_session_id) {
+            try {
+              await apiClient.patch(`${apiUrl}/api/sessions/${task.workspace_session_id}?workspace_id=${encodeURIComponent(task.workspace_id || issueId)}`, { provider_session_id: sid, status: "running" });
+            } catch {}
+          }
         },
         onSpawn: (child) => {
           if (ctx?.runEntry) {
@@ -33569,7 +33649,7 @@ async function executePlanActions(apiUrl, parentTask, actions, ctx) {
     if (blocked3)
       lines.push(`- \u26A0 ${blocked3} non-update action(s) blocked (planning depth limit ${PLANNING_DEPTH_LIMIT})`);
   }
-  const SUBCAPS = { "agent.create": 2, "skill.create": 3, "skill.attach": 5, "skill.detach": 5, "agent.update": 5 };
+  const SUBCAPS = { "agent.create": 2, "skill.create": 3, "skill.attach": 5, "skill.detach": 5, "agent.update": 5, "session.create": 3 };
   const counts = {};
   actions = actions.filter((a) => {
     const cap = SUBCAPS[a.type];
@@ -33660,6 +33740,15 @@ async function executePlanActions(apiUrl, parentTask, actions, ctx) {
           continue;
         }
         lines.push(`- \u23F3 skill.create "${a.name}" queued for human review (op ${res.data?.pending_op_id})`);
+      } else if (a.type === "session.create") {
+        const res = await apiClient.post(`${apiUrl}/api/sessions`, { workspace_id: a.workspace_id, agent_id: a.agent_id, role: a.role, device_id: a.device_id }, { headers });
+        if (!res.success) {
+          lines.push(`- \u274C session.create role=${a.role}: ${res.error || res.status}`);
+          continue;
+        }
+        const sess = res.data?.session;
+        const reused = res.data?.reused;
+        lines.push(`- ${reused ? "\u21BA" : "\u2713"} session.${reused ? "reuse" : "create"} ${sess?.id?.slice(0, 8) || "?"} (role=${a.role})`);
       } else if (a.type === "skill.attach" || a.type === "skill.detach") {
         const action = a.type === "skill.attach" ? "attach_skill" : "detach_skill";
         const res = await apiClient.post(`${apiUrl}/api/agent_ops/agents/mutate`, { action, agent_id: a.agent_id, skill_id: a.skill_id }, { headers });
@@ -33759,7 +33848,9 @@ async function ackDispatch(apiUrl, dispatchId, secret) {
     log3(`ack dispatch ${dispatchId} failed: ${String(e)}`);
   }
 }
-async function drainOfflineDispatches(apiUrl, deviceId, secret, db, onEnqueued) {
+async function drainOfflineDispatches(apiUrl, deviceId, secret, db, onEnqueued, isAlive) {
+  if (!isAlive())
+    return;
   let list;
   try {
     list = await apiClient.get(`${apiUrl}/api/devices/${deviceId}/dispatches/pending`);
@@ -33772,6 +33863,10 @@ async function drainOfflineDispatches(apiUrl, deviceId, secret, db, onEnqueued)
     return;
   log3(`\uD83E\uDEA3 draining ${rows.length} offline dispatch(es)`);
   for (const r of rows) {
+    if (!isAlive()) {
+      log3("drain aborted: shutting down");
+      return;
+    }
     try {
       const res = await fetch(`${apiUrl}/api/issues/dispatches/${r.id}/claim`, {
         method: "POST",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shipers-dev/multi",
-  "version": "0.23.0",
+  "version": "0.23.2",
   "type": "module",
   "bin": {
     "multi-agent": "./dist/index.js"