@adhdev/daemon-core 0.9.76-rc.36 → 0.9.76-rc.38

package/dist/commands/router.d.ts

@@ -21,6 +21,9 @@ export interface SessionHostControlPlane {
     }): Promise<any>;
     listSessions(): Promise<any[]>;
     stopSession(sessionId: string): Promise<any>;
+    deleteSession(sessionId: string, opts?: {
+        force?: boolean;
+    }): Promise<any>;
     resumeSession(sessionId: string): Promise<any>;
     restartSession(sessionId: string): Promise<any>;
     sendSignal(sessionId: string, signal: string): Promise<any>;
@@ -85,6 +88,10 @@ export declare class DaemonCommandRouter {
     private getMeshForCommand;
     private updateInlineMeshNode;
     private removeInlineMeshNode;
+    private normalizeMeshSessionCleanupMode;
+    private sessionMatchesMeshNode;
+    private isCompletedHostedSession;
+    private cleanupMeshSessions;
     private traceSessionHostAction;
     /**
      * Unified command routing.

package/dist/index.js

@@ -41,7 +41,8 @@ var init_repo_mesh_types = __esm({
       requireApprovalForPush: true,
       requireApprovalForDestructiveGit: true,
       dirtyWorkspaceBehavior: "warn",
-      maxParallelTasks: 2
+      maxParallelTasks: 2,
+      sessionCleanupOnNodeRemove: "preserve"
     };
   }
 });
@@ -460,6 +461,18 @@ function normalizeRepoIdentity(remoteUrl) {
   if (sshMatch) return `${sshMatch[1]}/${sshMatch[2]}`;
   return identity;
 }
+function mergeMeshPolicy(base, patch) {
+  const policy = { ...DEFAULT_MESH_POLICY, ...base || {}, ...patch || {} };
+  if (!["block", "warn", "checkpoint_then_continue"].includes(policy.dirtyWorkspaceBehavior)) {
+    policy.dirtyWorkspaceBehavior = "warn";
+  }
+  const maxParallelTasks = Number(policy.maxParallelTasks);
+  policy.maxParallelTasks = Number.isFinite(maxParallelTasks) ? Math.max(1, Math.min(8, Math.floor(maxParallelTasks))) : 2;
+  if (!SESSION_CLEANUP_MODES.has(String(policy.sessionCleanupOnNodeRemove))) {
+    policy.sessionCleanupOnNodeRemove = "preserve";
+  }
+  return policy;
+}
 function listMeshes() {
   return loadMeshConfig().meshes;
 }
@@ -483,7 +496,7 @@ function createMesh(opts) {
     repoIdentity,
     repoRemoteUrl: opts.repoRemoteUrl,
     defaultBranch: opts.defaultBranch,
-    policy: { ...DEFAULT_MESH_POLICY, ...opts.policy },
+    policy: mergeMeshPolicy(void 0, opts.policy),
     coordinator: opts.coordinator || {},
     nodes: [],
     createdAt: now,
@@ -499,7 +512,7 @@ function updateMesh(meshId, opts) {
   if (!mesh) return void 0;
   if (opts.name !== void 0) mesh.name = opts.name.trim().slice(0, 100);
   if (opts.defaultBranch !== void 0) mesh.defaultBranch = opts.defaultBranch;
-  if (opts.policy) mesh.policy = { ...mesh.policy, ...opts.policy };
+  if (opts.policy) mesh.policy = mergeMeshPolicy(mesh.policy, opts.policy);
   if (opts.coordinator) mesh.coordinator = opts.coordinator;
   mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   saveMeshConfig(config);
@@ -562,7 +575,7 @@ function updateNode(meshId, nodeId, opts) {
   saveMeshConfig(config);
   return node;
 }
-var import_fs2, import_path2, import_crypto3;
+var import_fs2, import_path2, import_crypto3, SESSION_CLEANUP_MODES;
 var init_mesh_config = __esm({
   "src/config/mesh-config.ts"() {
     "use strict";
@@ -571,6 +584,7 @@ var init_mesh_config = __esm({
     import_crypto3 = require("crypto");
     init_config();
     init_repo_mesh_types();
+    SESSION_CLEANUP_MODES = /* @__PURE__ */ new Set(["preserve", "stop", "delete_stopped", "stop_and_delete"]);
   }
 });
 
@@ -21491,6 +21505,75 @@ var DaemonCommandRouter = class {
     this.inlineMeshCache.set(meshId, mesh);
     return true;
   }
+  normalizeMeshSessionCleanupMode(value) {
+    return value === "stop" || value === "delete_stopped" || value === "stop_and_delete" || value === "preserve" ? value : "preserve";
+  }
+  sessionMatchesMeshNode(record, node, nodeId, sessionIds) {
+    const sessionId = typeof record?.sessionId === "string" ? record.sessionId : "";
+    if (!sessionId) return false;
+    if (sessionIds?.size) return sessionIds.has(sessionId);
+    const workspace = typeof node?.workspace === "string" ? node.workspace : "";
+    if (workspace && record?.workspace === workspace) return true;
+    if (record?.meta?.meshNodeId === nodeId) return true;
+    return false;
+  }
+  isCompletedHostedSession(record) {
+    return record?.lifecycle === "stopped" || record?.lifecycle === "failed" || record?.lifecycle === "interrupted";
+  }
+  async cleanupMeshSessions(args) {
+    if (args.mode === "preserve") {
+      return { success: true, mode: "preserve", matchedCount: 0, stoppedSessionIds: [], deletedSessionIds: [], skippedSessionIds: [] };
+    }
+    if (!this.deps.sessionHostControl) return { success: false, error: "Session host control unavailable" };
+    const requestedSessionIds = Array.isArray(args.sessionIds) ? new Set(args.sessionIds.map((id) => typeof id === "string" ? id.trim() : "").filter(Boolean)) : void 0;
+    const sessions = await this.deps.sessionHostControl.listSessions();
+    const matched = sessions.filter((record) => this.sessionMatchesMeshNode(record, args.node, args.nodeId, requestedSessionIds));
+    const stoppedSessionIds = [];
+    const deletedSessionIds = [];
+    const skippedSessionIds = [];
+    const errors = [];
+    for (const record of matched) {
+      const sessionId = String(record.sessionId);
+      const completed = this.isCompletedHostedSession(record);
+      try {
+        if (args.mode === "stop") {
+          if (!completed) {
+            if (!args.dryRun) await this.deps.sessionHostControl.stopSession(sessionId);
+            stoppedSessionIds.push(sessionId);
+          } else {
+            skippedSessionIds.push(sessionId);
+          }
+          continue;
+        }
+        if (args.mode === "delete_stopped") {
+          if (completed) {
+            if (!args.dryRun) await this.deps.sessionHostControl.deleteSession(sessionId, { force: false });
+            deletedSessionIds.push(sessionId);
+          } else {
+            skippedSessionIds.push(sessionId);
+          }
+          continue;
+        }
+        if (args.mode === "stop_and_delete") {
+          if (!args.dryRun) await this.deps.sessionHostControl.deleteSession(sessionId, { force: true });
+          deletedSessionIds.push(sessionId);
+          continue;
+        }
+      } catch (e) {
+        errors.push({ sessionId, error: e?.message || String(e) });
+      }
+    }
+    return {
+      success: errors.length === 0,
+      mode: args.mode,
+      dryRun: args.dryRun === true,
+      matchedCount: matched.length,
+      stoppedSessionIds,
+      deletedSessionIds,
+      skippedSessionIds,
+      ...errors.length ? { errors } : {}
+    };
+  }
   async traceSessionHostAction(action, args, run, summarizeResult) {
     const interactionId = typeof args?._interactionId === "string" ? args._interactionId : void 0;
     const sessionId = typeof args?.sessionId === "string" ? args.sessionId : void 0;
@@ -22157,7 +22240,26 @@ var DaemonCommandRouter = class {
         if (!name) return { success: false, error: "name required" };
         try {
           const { createMesh: createMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-          const mesh = createMesh2({ name, repoIdentity, repoRemoteUrl, defaultBranch });
+          const mesh = createMesh2({ name, repoIdentity, repoRemoteUrl, defaultBranch, policy: args?.policy });
+          return { success: true, mesh };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      }
+      case "update_mesh": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        try {
+          const { updateMesh: updateMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const patch = {};
+          if (typeof args?.name === "string") patch.name = args.name;
+          if (typeof args?.defaultBranch === "string") patch.defaultBranch = args.defaultBranch;
+          if (args?.policy && typeof args.policy === "object" && !Array.isArray(args.policy)) patch.policy = args.policy;
+          if (args?.coordinator && typeof args.coordinator === "object" && !Array.isArray(args.coordinator)) patch.coordinator = args.coordinator;
+          if (!Object.keys(patch).length) return { success: false, error: "No updates provided" };
+          const mesh = updateMesh2(meshId, patch);
+          if (!mesh) return { success: false, error: "Mesh not found" };
+          this.inlineMeshCache.set(meshId, mesh);
           return { success: true, mesh };
         } catch (e) {
           return { success: false, error: e.message };
@@ -22194,6 +22296,54 @@ var DaemonCommandRouter = class {
           return { success: false, error: e.message };
         }
       }
+      case "update_mesh_node": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+        if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+        try {
+          const { updateNode: updateNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const policy = args?.policy && typeof args.policy === "object" && !Array.isArray(args.policy) ? { ...args.policy } : {};
+          if (Array.isArray(args?.providerPriority)) {
+            const providerPriority = args.providerPriority.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean);
+            delete policy.provider_priority;
+            if (providerPriority.length) {
+              policy.providerPriority = providerPriority;
+            } else {
+              delete policy.providerPriority;
+            }
+          }
+          const node = updateNode2(meshId, nodeId, { policy });
+          if (!node) return { success: false, error: "Mesh node not found" };
+          return { success: true, node };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      }
+      case "cleanup_mesh_sessions": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+        if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+        try {
+          const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+          const mesh = meshRecord?.mesh;
+          if (!mesh) return { success: false, error: "Mesh not found" };
+          const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
+          if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
+          const mode = this.normalizeMeshSessionCleanupMode(args?.mode ?? mesh?.policy?.sessionCleanupOnNodeRemove);
+          const sessionIds = Array.isArray(args?.sessionIds) ? args.sessionIds.map((id) => typeof id === "string" ? id.trim() : "").filter(Boolean) : void 0;
+          const result = await this.cleanupMeshSessions({
+            meshId,
+            nodeId,
+            node,
+            mode,
+            sessionIds,
+            dryRun: args?.dryRun === true
+          });
+          return result;
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      }
       case "remove_mesh_node": {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
@@ -22202,6 +22352,14 @@ var DaemonCommandRouter = class {
           const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
           const mesh = meshRecord?.mesh;
           const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
+          const sessionCleanupMode = this.normalizeMeshSessionCleanupMode(
+            args?.sessionCleanupMode ?? args?.session_cleanup_mode ?? mesh?.policy?.sessionCleanupOnNodeRemove
+          );
+          let sessionCleanup;
+          if (node && sessionCleanupMode !== "preserve") {
+            sessionCleanup = await this.cleanupMeshSessions({ meshId, nodeId, node, mode: sessionCleanupMode });
+            if (sessionCleanup.success === false) return { success: false, removed: false, sessionCleanup };
+          }
           if (node?.isLocalWorktree && node.workspace) {
             try {
               const sourceNode = node.clonedFromNodeId ? mesh?.nodes.find((n) => n.id === node.clonedFromNodeId || n.nodeId === node.clonedFromNodeId) : mesh?.nodes.find((n) => !n.isLocalWorktree);
@@ -22221,7 +22379,7 @@ var DaemonCommandRouter = class {
             const { removeNode: removeNode3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
             removed = removeNode3(meshId, nodeId);
           }
-          return { success: true, removed };
+          return { success: true, removed, ...sessionCleanup ? { sessionCleanup } : {} };
         } catch (e) {
           return { success: false, error: e.message };
         }