@vibedeckx/linux-x64 0.2.4 → 0.2.5

package/dist/bin.js

@@ -224066,6 +224066,7 @@ var AgentSessionManager = class {
   capacityQueue = Promise.resolve();
   /** Grace window before committing a held completion (injectable for tests). */
   completionGraceMs;
+  workflowSuppressionCheck = null;
   constructor(storage, opts) {
     this.storage = storage;
     this.completionGraceMs = opts?.completionGraceMs ?? COMPLETION_GRACE_MS;
@@ -224073,6 +224074,15 @@ var AgentSessionManager = class {
   setEventBus(eventBus) {
     this.eventBus = eventBus;
   }
+  /**
+   * Injected by shared-services: lets commitCompletion mark taskCompleted WS
+   * frames whose completion the local WorkflowEngine claims (reviewer
+   * sessions of active runs). A front server bridging this frame must not
+   * wake its commander for it (spec §Phase 1.5 抑制协调).
+   */
+  setWorkflowSuppressionCheck(check2) {
+    this.workflowSuppressionCheck = check2;
+  }
   /**
    * Broadcast a freshly-generated title on the global event bus so the sidebar
    * (`useResidentSessions`) updates regardless of which workspace is currently
@@ -224576,7 +224586,9 @@ var AgentSessionManager = class {
         cost_usd: payload.cost_usd,
         input_tokens: payload.input_tokens,
         output_tokens: payload.output_tokens,
-        summaryText
+        summaryText,
+        turnEndEntryIndex: turnEndEntryIndex ?? void 0,
+        workflowSuppressed: this.workflowSuppressionCheck?.(sessionId) || void 0
       }
     });
     this.eventBus?.emit({
@@ -225067,6 +225079,14 @@ ${details}`;
   getRawMessages(sessionId) {
     return this.sessions.get(sessionId)?.store.entries ?? [];
   }
+  /**
+   * Public wrapper over broadcastRaw for the WorkflowEngine: mirror a raw WS
+   * frame to a session's stream subscribers (a front server subscribed to
+   * this stream relies on it for run-transition delivery — spec §Phase 1.5).
+   */
+  broadcastRawToSession(sessionId, payload) {
+    this.broadcastRaw(sessionId, payload);
+  }
   /**
    * Get session info
    */
@@ -225966,6 +225986,40 @@ function statusEventFromRemotePatch(parsed, sessionId, remoteInfo) {
     status: content
   };
 }
+function taskCompletedEventFromRemoteFrame(parsed, sessionId, remoteInfo) {
+  if (!("taskCompleted" in parsed)) return null;
+  const tc = parsed.taskCompleted;
+  return {
+    type: "session:taskCompleted",
+    projectId: projectIdFromRemoteSessionId(sessionId, remoteInfo),
+    branch: remoteInfo.branch ?? null,
+    sessionId,
+    duration_ms: tc?.duration_ms,
+    cost_usd: tc?.cost_usd,
+    input_tokens: tc?.input_tokens,
+    output_tokens: tc?.output_tokens,
+    summaryText: tc?.summaryText,
+    turnEndEntryIndex: tc?.turnEndEntryIndex,
+    workflowSuppressed: tc?.workflowSuppressed === true ? true : void 0
+  };
+}
+function mapRemoteRun(run2, remoteServerId, projectId) {
+  const prefix = `remote-${remoteServerId}-${projectId}-`;
+  return {
+    ...run2,
+    id: `${prefix}${run2.id}`,
+    project_id: projectId,
+    source_session_id: `${prefix}${run2.source_session_id}`,
+    reviewer_session_id: run2.reviewer_session_id ? `${prefix}${run2.reviewer_session_id}` : null
+  };
+}
+function runUpdatedEventFromRemoteFrame(parsed, sessionId, remoteInfo) {
+  if (!("workflowRunUpdated" in parsed)) return null;
+  const bare = parsed.workflowRunUpdated;
+  const projectId = projectIdFromRemoteSessionId(sessionId, remoteInfo);
+  const run2 = mapRemoteRun(bare, remoteInfo.remoteServerId, projectId);
+  return { type: "workflow:run-updated", projectId, branch: run2.branch, run: run2 };
+}
 
 // src/remote-agent-sessions.ts
 async function createRemoteAgentSession(deps, params) {
@@ -226079,7 +226133,7 @@ function connectPersistentRemoteWs(sessionId, remoteInfo, cache2, wsOptions, rev
     const raw = data.toString();
     const parsed = tryParseWsMessage(raw);
     if (!parsed) return;
-    const kind = "JsonPatch" in parsed ? "JsonPatch" : "finished" in parsed ? "finished" : "taskCompleted" in parsed ? "taskCompleted" : "processAlive" in parsed ? "processAlive" : "branchActivity" in parsed ? "branchActivity" : "Ready" in parsed ? "Ready" : "error" in parsed ? "error" : "other";
+    const kind = "JsonPatch" in parsed ? "JsonPatch" : "finished" in parsed ? "finished" : "taskCompleted" in parsed ? "taskCompleted" : "workflowRunUpdated" in parsed ? "workflowRunUpdated" : "processAlive" in parsed ? "processAlive" : "branchActivity" in parsed ? "branchActivity" : "Ready" in parsed ? "Ready" : "error" in parsed ? "error" : "other";
     if (kind === "JsonPatch") {
       const ops = parsed.JsonPatch;
       const statusOp = ops.find((o) => o.path === "/status");
@@ -226108,25 +226162,20 @@ function connectPersistentRemoteWs(sessionId, remoteInfo, cache2, wsOptions, rev
       cache2.appendMessage(sessionId, raw, false);
       cache2.broadcast(sessionId, raw);
       if (eventBus) {
-        const tc = parsed.taskCompleted;
-        const projectId = projectIdFromRemoteSessionId(sessionId, remoteInfo);
-        const branch = remoteInfo.branch ?? null;
-        eventBus.emit({
-          type: "session:taskCompleted",
-          projectId,
-          branch,
-          sessionId,
-          duration_ms: tc?.duration_ms,
-          cost_usd: tc?.cost_usd,
-          input_tokens: tc?.input_tokens,
-          output_tokens: tc?.output_tokens,
-          summaryText: tc?.summaryText
-        });
-        agentSessionManager?.emitBranchActivityIfChanged(
-          projectId,
-          branch,
-          { activity: "completed", since: Date.now(), sessionId }
-        );
+        const evt = taskCompletedEventFromRemoteFrame(parsed, sessionId, remoteInfo);
+        if (evt) {
+          eventBus.emit(evt);
+          agentSessionManager?.emitBranchActivityIfChanged(evt.projectId, evt.branch, {
+            activity: "completed",
+            since: Date.now(),
+            sessionId
+          });
+        }
+      }
+    } else if ("workflowRunUpdated" in parsed) {
+      if (eventBus) {
+        const evt = runUpdatedEventFromRemoteFrame(parsed, sessionId, remoteInfo);
+        if (evt) eventBus.emit(evt);
       }
     } else if ("processAlive" in parsed) {
       cache2.broadcast(sessionId, raw);
@@ -226497,7 +226546,7 @@ var ChatSessionManager = class {
   }
   handleSessionTaskCompleted(event) {
     try {
-      if (this.workflowEngine?.shouldSuppressAgentEvent(event.sessionId)) return;
+      if (event.workflowSuppressed || this.workflowEngine?.shouldSuppressAgentEvent(event.sessionId)) return;
       const key = `${event.projectId}:${event.branch ?? ""}`;
       console.log(`[ChatSession] handleSessionTaskCompleted: key=${key}, sessionIndex keys=[${[...this.sessionIndex.keys()].join(", ")}]`);
       const sessionId = this.sessionIndex.get(key);
@@ -228930,6 +228979,9 @@ var WorkflowEngine = class {
   }
   emitRunUpdated(run2) {
     this.eventBus?.emit({ type: "workflow:run-updated", projectId: run2.project_id, branch: run2.branch, run: run2 });
+    for (const sid of [run2.source_session_id, run2.reviewer_session_id]) {
+      if (sid) this.agentOps.broadcastRawToSession?.(sid, { workflowRunUpdated: run2 });
+    }
   }
 };
 
@@ -230833,6 +230885,7 @@ var sharedServices = async (fastify2, opts) => {
   await workflowEngine.init();
   fastify2.decorate("workflowEngine", workflowEngine);
   chatSessionManager.setWorkflowEngine(workflowEngine);
+  agentSessionManager.setWorkflowSuppressionCheck((sessionId) => workflowEngine.shouldSuppressAgentEvent(sessionId));
   chatSessionManager.setEventBus(eventBus);
   chatSessionManager.setRemoteExecutorMonitor(remoteExecutorMonitor);
   processManager.setEventBus(eventBus);
@@ -235857,12 +235910,78 @@ function errStatus(err) {
   }
 }
 async function routes18(fastify2) {
+  const remoteRunMap = /* @__PURE__ */ new Map();
+  const TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set(["completed", "cancelled", "failed"]);
+  const trackRemoteRun = (localRun, info) => {
+    if (TERMINAL_RUN_STATUSES.has(localRun.status)) remoteRunMap.delete(localRun.id);
+    else remoteRunMap.set(localRun.id, info);
+  };
+  const proxyAuto = (info, method, apiPath, body) => proxyToRemoteAuto(info.remoteServerId, info.remoteUrl, info.remoteApiKey, method, apiPath, body, {
+    reverseConnectManager: fastify2.reverseConnectManager
+  });
+  const sendProxyFailure = (reply, result) => reply.code(proxyStatus(result)).send(
+    result.status === 0 ? { error: `Remote proxy failed: ${result.errorCode || "unknown"}` } : result.data
+  );
+  const resolveRemoteRun = async (runId, userId) => {
+    const info = remoteRunMap.get(runId);
+    if (!info) return null;
+    const project = await fastify2.storage.projects.getById(info.projectId, userId);
+    if (!project) return null;
+    return info;
+  };
   fastify2.post("/api/workflow-runs", async (req, reply) => {
     const userId = requireAuth(req, reply);
     if (userId === null) return;
     const { projectId, branch, sourceSessionId, reviewFocus, sourceTurnEndIndex } = req.body ?? {};
     if (!projectId || !sourceSessionId) return reply.code(400).send({ error: "projectId and sourceSessionId are required" });
-    if (sourceSessionId.startsWith("remote-")) return reply.code(400).send({ error: "Remote sessions are not supported in ad-hoc review yet" });
+    if (sourceSessionId.startsWith("remote-")) {
+      const remoteInfo = fastify2.remoteSessionMap.get(sourceSessionId);
+      if (!remoteInfo) return reply.code(404).send({ error: "Session not found" });
+      const derivedProjectId = projectIdFromRemoteSessionId(sourceSessionId, remoteInfo);
+      if (derivedProjectId !== projectId) return reply.code(404).send({ error: "Session not found" });
+      const remoteProject = await fastify2.storage.projects.getById(projectId, userId);
+      if (!remoteProject) return reply.code(404).send({ error: "Project not found" });
+      const result = await proxyAuto(remoteInfo, "POST", "/api/path/workflow-runs", {
+        sourceSessionId: remoteInfo.remoteSessionId,
+        reviewFocus,
+        sourceTurnEndIndex
+      });
+      if (!result.ok) return sendProxyFailure(reply, result);
+      const bareRun = result.data.run;
+      const localRun = mapRemoteRun(bareRun, remoteInfo.remoteServerId, projectId);
+      trackRemoteRun(localRun, {
+        remoteServerId: remoteInfo.remoteServerId,
+        remoteUrl: remoteInfo.remoteUrl,
+        remoteApiKey: remoteInfo.remoteApiKey,
+        bareRunId: bareRun.id,
+        projectId
+      });
+      if (bareRun.reviewer_session_id && localRun.reviewer_session_id) {
+        fastify2.remoteSessionMap.set(localRun.reviewer_session_id, {
+          remoteServerId: remoteInfo.remoteServerId,
+          remoteUrl: remoteInfo.remoteUrl,
+          remoteApiKey: remoteInfo.remoteApiKey,
+          remoteSessionId: bareRun.reviewer_session_id,
+          branch: bareRun.branch
+        });
+        await fastify2.storage.remoteSessionMappings.upsert(
+          localRun.reviewer_session_id,
+          projectId,
+          remoteInfo.remoteServerId,
+          bareRun.reviewer_session_id,
+          bareRun.branch
+        );
+        ensureRemoteAgentStream(localRun.reviewer_session_id, {
+          remoteSessionMap: fastify2.remoteSessionMap,
+          remotePatchCache: fastify2.remotePatchCache,
+          reverseConnectManager: fastify2.reverseConnectManager,
+          eventBus: fastify2.eventBus,
+          agentSessionManager: fastify2.agentSessionManager
+        });
+      }
+      fastify2.eventBus.emit({ type: "workflow:run-updated", projectId, branch: bareRun.branch, run: localRun });
+      return reply.code(201).send({ run: localRun });
+    }
     const project = await fastify2.storage.projects.getById(projectId, userId);
     if (!project) return reply.code(404).send({ error: "Project not found" });
     if (!project.path) return reply.code(400).send({ error: "Project has no local path (remote-only projects are not supported yet)" });
@@ -235898,6 +236017,27 @@ async function routes18(fastify2) {
       if (!projectId) return reply.code(400).send({ error: "projectId is required" });
       const project = await fastify2.storage.projects.getById(projectId, userId);
       if (!project) return reply.code(404).send({ error: "Project not found" });
+      if (project.agent_mode && project.agent_mode !== "local") {
+        const remoteConfig = await fastify2.storage.projectRemotes.getByProjectAndServer(projectId, project.agent_mode);
+        if (remoteConfig) {
+          const q = new URLSearchParams({ path: remoteConfig.remote_path ?? "" });
+          if (branch) q.set("branch", branch);
+          const info = {
+            remoteServerId: project.agent_mode,
+            remoteUrl: remoteConfig.server_url ?? "",
+            remoteApiKey: remoteConfig.server_api_key || ""
+          };
+          const result = await proxyAuto(info, "GET", `/api/path/workflow-runs?${q}`);
+          if (!result.ok) return sendProxyFailure(reply, result);
+          const bareRuns = result.data.runs ?? [];
+          const runs2 = bareRuns.map((r) => {
+            const mapped = mapRemoteRun(r, info.remoteServerId, projectId);
+            trackRemoteRun(mapped, { ...info, bareRunId: r.id, projectId });
+            return mapped;
+          });
+          return reply.send({ runs: runs2 });
+        }
+      }
       const runs = await fastify2.storage.workflowRuns.getActive(projectId, branch ?? null);
       return reply.send({ runs });
     }
@@ -235905,6 +236045,15 @@ async function routes18(fastify2) {
   fastify2.get("/api/workflow-runs/:id", async (req, reply) => {
     const userId = requireAuth(req, reply);
     if (userId === null) return;
+    if (req.params.id.startsWith("remote-")) {
+      const info = await resolveRemoteRun(req.params.id, userId);
+      if (!info) return reply.code(404).send({ error: "Run not found" });
+      const result = await proxyAuto(info, "GET", `/api/workflow-runs/${info.bareRunId}`);
+      if (!result.ok) return sendProxyFailure(reply, result);
+      const localRun = mapRemoteRun(result.data.run, info.remoteServerId, info.projectId);
+      trackRemoteRun(localRun, info);
+      return reply.send({ run: localRun });
+    }
     const run2 = await fastify2.storage.workflowRuns.getById(req.params.id);
     if (!run2) return reply.code(404).send({ error: "Run not found" });
     const project = await fastify2.storage.projects.getById(run2.project_id, userId);
@@ -235916,6 +236065,16 @@ async function routes18(fastify2) {
     async (req, reply) => {
       const userId = requireAuth(req, reply);
       if (userId === null) return;
+      if (req.params.id.startsWith("remote-")) {
+        const info = await resolveRemoteRun(req.params.id, userId);
+        if (!info) return reply.code(404).send({ error: "Run not found" });
+        const result = await proxyAuto(info, "POST", `/api/workflow-runs/${info.bareRunId}/gate`, req.body ?? {});
+        if (!result.ok) return sendProxyFailure(reply, result);
+        const localRun = mapRemoteRun(result.data.run, info.remoteServerId, info.projectId);
+        trackRemoteRun(localRun, info);
+        fastify2.eventBus.emit({ type: "workflow:run-updated", projectId: info.projectId, branch: localRun.branch, run: localRun });
+        return reply.send({ run: localRun });
+      }
       const existing = await fastify2.storage.workflowRuns.getById(req.params.id);
       if (!existing) return reply.code(404).send({ error: "Run not found" });
       const project = await fastify2.storage.projects.getById(existing.project_id, userId);
@@ -235941,6 +236100,16 @@ async function routes18(fastify2) {
   fastify2.post("/api/workflow-runs/:id/cancel", async (req, reply) => {
     const userId = requireAuth(req, reply);
     if (userId === null) return;
+    if (req.params.id.startsWith("remote-")) {
+      const info = await resolveRemoteRun(req.params.id, userId);
+      if (!info) return reply.code(404).send({ error: "Run not found" });
+      const result = await proxyAuto(info, "POST", `/api/workflow-runs/${info.bareRunId}/cancel`);
+      if (!result.ok) return sendProxyFailure(reply, result);
+      const localRun = mapRemoteRun(result.data.run, info.remoteServerId, info.projectId);
+      trackRemoteRun(localRun, info);
+      fastify2.eventBus.emit({ type: "workflow:run-updated", projectId: info.projectId, branch: localRun.branch, run: localRun });
+      return reply.send({ run: localRun });
+    }
     const existing = await fastify2.storage.workflowRuns.getById(req.params.id);
     if (!existing) return reply.code(404).send({ error: "Run not found" });
     const project = await fastify2.storage.projects.getById(existing.project_id, userId);
@@ -235954,6 +236123,41 @@ async function routes18(fastify2) {
       throw err;
     }
   });
+  fastify2.post("/api/path/workflow-runs", async (req, reply) => {
+    const userId = requireAuth(req, reply);
+    if (userId === null) return;
+    const { sourceSessionId, reviewFocus, sourceTurnEndIndex } = req.body ?? {};
+    if (!sourceSessionId) return reply.code(400).send({ error: "sourceSessionId is required" });
+    const sourceSession = await fastify2.storage.agentSessions.getById(sourceSessionId);
+    if (!sourceSession) return reply.code(404).send({ error: "Session not found" });
+    const project = await fastify2.storage.projects.getById(sourceSession.project_id);
+    if (!project) return reply.code(404).send({ error: "Session not found" });
+    if (!project.path) return reply.code(400).send({ error: "Project has no local path" });
+    try {
+      const run2 = await fastify2.workflowEngine.startAdhocReview({
+        project: { id: project.id, path: project.path },
+        branch: sourceSession.branch || null,
+        sourceSessionId,
+        reviewFocus,
+        sourceTurnEndIndex
+      });
+      return reply.code(201).send({ run: run2 });
+    } catch (err) {
+      const status = errStatus(err);
+      if (status) return reply.code(status).send({ error: err.message });
+      throw err;
+    }
+  });
+  fastify2.get("/api/path/workflow-runs", async (req, reply) => {
+    const userId = requireAuth(req, reply);
+    if (userId === null) return;
+    const { path: projectPath, branch } = req.query;
+    if (!projectPath) return reply.code(400).send({ error: "path is required" });
+    const project = await fastify2.storage.projects.getByPath(projectPath) ?? await fastify2.storage.projects.getById(`path:${projectPath}`);
+    if (!project) return reply.send({ runs: [] });
+    const runs = await fastify2.storage.workflowRuns.getActive(project.id, branch || null);
+    return reply.send({ runs });
+  });
 }
 var workflow_run_routes_default = (0, import_fastify_plugin19.default)(routes18, { name: "workflow-run-routes" });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibedeckx/linux-x64",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "Vibedeckx platform binaries for Linux x64",
   "os": [
     "linux"