@goodandready/dsh-cron 0.2.4 → 0.2.6

package/lib/runner.js

@@ -208,190 +208,229 @@ export class SessionRunner {
       return this._runExternal(task, runtime === 'llm' ? 'script' : runtime, signal);
     }
 
-    // 2. If ctx.agents is available, run through agent session (LLM)
+    // 2. Agent session, when the harness exposes one
     if (this.ctx && this.ctx.agents && typeof this.ctx.agents.create === 'function') {
-      try {
-        const { randomUUID } = await import('node:crypto');
-        let createUserMessage = (m) => m;
-        try {
-          const llmModule = await import('@deepseek-ai/dsh-llm');
-          if (llmModule && typeof llmModule.createUserMessage === 'function') {
-            createUserMessage = llmModule.createUserMessage;
-          }
-        } catch {}
+      return this._runAgentSession(task, runtime, signal);
+    }
 
-        let sessionModule = null;
-        try {
-          sessionModule = await import('@deepseek-ai/dsh-session');
-        } catch {}
+    // 3. Legacy session service
+    if (this.ctx && this.ctx.session && typeof this.ctx.session.create === 'function') {
+      return this._runLegacySession(task);
+    }
 
-        const mintSessionId = () => {
-          const sid = `cron-exec-${task.id}-${randomUUID()}`;
-          if (sessionModule && typeof sessionModule.SessionId === 'function') {
-            return sessionModule.SessionId(sid);
-          }
-          return sid;
-        };
-
-        const defaultSel = this.ctx.get?.('agentDefaultModel')?.currentSelection?.();
-        const provider = task.provider || defaultSel?.provider;
-        const model = task.model || defaultSel?.model || undefined;
-
-        // The agent session cannot take the AbortSignal natively, so any abort
-        // (timeout, overlap replace, pause, scheduler stop) races against the
-        // session awaits and forces an immediate dispose (#88).
-        const abortError = () => (signal && signal.reason) || new Error('Task aborted');
-        const raceAbort = (promise) => {
-          if (!signal) return promise;
-          return Promise.race([
-            promise,
-            new Promise((_, reject) => {
-              if (signal.aborted) {
-                reject(abortError());
-                return;
-              }
-              signal.addEventListener('abort', () => reject(abortError()), { once: true });
-            }),
-          ]);
-        };
-
-        const baseCwd = this.resolveCwd(task);
-        // #29: code-modifying tasks may run in an isolated git worktree.
-        let cwd = baseCwd;
-        let taskWorktree = null;
-        if (task.worktree) {
-          try {
-            taskWorktree = await this.createTaskWorktree(baseCwd, task);
-            cwd = taskWorktree;
-          } catch (wtErr) {
-            console.warn('[dsh-cron] task worktree not created, running in the workspace:', wtErr.message);
-          }
-        }
-        // #6/#10: skill- and workflow-driven tasks are agent-mediated with a
-        // shaped prompt naming the skill/workflow.
-        let agentPrompt = String(task.prompt || '');
-        if (runtime === 'skill' && task.skillName) {
-          agentPrompt = `Use the DSH skill "${task.skillName}" for this task:\n${agentPrompt}`;
-        } else if (runtime === 'workflow' && task.workflowName) {
-          agentPrompt = `Execute this through the DSH workflow "${task.workflowName}" step by step:\n${agentPrompt}`;
-        }
-        let handle = null;
-        try {
-          handle = await this.ctx.agents.create({
-            sessionId: mintSessionId(),
-            meta: { cwd, ephemeral: true, internal: true },
-            agentOptions: provider && model ? { provider, model } : undefined,
-          });
-
-          // Per-job permission preset (#32): read-only | workspace-write | full.
-          if (task.permissionPreset && task.permissionPreset !== 'default') {
-            try {
-              const presets = this.ctx.get && this.ctx.get('permissionPresets');
-              if (presets && typeof presets.set === 'function') {
-                presets.set(handle.agent.session, task.permissionPreset);
-              }
-            } catch (ppErr) {
-              console.warn('[dsh-cron] permission preset not applied:', ppErr.message);
-            }
-          }
+    // 4. Nothing to run through: report the prompt as triggered
+    return this._runBare(task);
+  }
 
-          await raceAbort(handle.agent.whenIdle());
-          handle.agent.followup(createUserMessage({
-            content: [{ type: 'text', text: agentPrompt }],
-            source: { kind: 'plugin', plugin: 'dsh-cron', form: 'cron-execute' },
-          }));
+  /** Legacy session service path; falls back to the bare report. */
+  async _runLegacySession(task) {
+    try {
+      const session = await this.ctx.session.create({
+        title: `[Cron] ${task.title}`,
+        ephemeral: task.delivery === 'isolated',
+      });
+      if (session && typeof session.send === 'function') {
+        const result = await session.send(task.prompt);
+        const out = typeof result === 'string' ? result : JSON.stringify(result);
+        const usage = session.usage || { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
+        return { output: out, usage, costUsd: estimateTokenCost(task.model, usage) };
+      }
+    } catch (err) {
+      console.error(`[dsh-cron] session execution failed:`, err.message);
+      throw err;
+    }
+    return this._runBare(task);
+  }
 
-          // Await agent turn completion (#67), abortable on timeout/overlap (#88)
-          if (typeof handle.agent.whenIdle === 'function') {
-            await raceAbort(handle.agent.whenIdle());
-          }
+  _runBare(task) {
+    return {
+      output: `[dsh-cron] Prompt triggered: "${task.prompt.slice(0, 100)}..."`,
+      usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
+      costUsd: 0,
+    };
+  }
 
-          // Try extracting token usage from session history if available
-          let usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
-          try {
-            const sessionUsage = handle.agent.session?.usage || handle.agent.usage;
-            if (sessionUsage) {
-              usage = {
-                inputTokens: sessionUsage.inputTokens || sessionUsage.promptTokens || 0,
-                outputTokens: sessionUsage.outputTokens || sessionUsage.completionTokens || 0,
-                cacheReadTokens: sessionUsage.cacheReadTokens || sessionUsage.cachedTokens || 0,
-              };
-            }
-          } catch {}
-
-          const costUsd = estimateTokenCost(model, usage);
-
-          return {
-            output: `[dsh-cron] Agent finished turn for task "${task.title}" (session: ${handle.agent.session?.id || 'cron'})`,
-            usage,
-            costUsd,
-            sessionId: handle.agent.session?.id || null
-          };
-        } finally {
-          let archivedSessionId = null;
-          try {
-            archivedSessionId = (handle && handle.agent && handle.agent.session && handle.agent.session.id) || null;
-          } catch {}
-          try {
-            if (handle && typeof handle.dispose === 'function') {
-              await handle.dispose();
-            } else if (handle && handle.agent && typeof handle.agent.destroy === 'function') {
-              await handle.agent.destroy();
-            }
-          } catch (disposeErr) {
-            console.warn('[dsh-cron] session dispose notice:', disposeErr.message);
-          }
-          // Best-effort: keep ephemeral cron sessions out of the main chat
-          // list (#30). The archive call degrades silently when the core
-          // does not expose it.
-          if (archivedSessionId && this.ctx && this.ctx.get) {
-            try {
-              const sessions = this.ctx.get('sessions');
-              if (sessions && typeof sessions.archive === 'function') {
-                sessions.archive(archivedSessionId);
-              }
-            } catch {}
-          }
-          // #29: dispose the isolated worktree (kept when keepWorktree is set).
-          if (taskWorktree && !task.keepWorktree) {
-            await this.removeTaskWorktree(baseCwd, taskWorktree);
+  async _runAgentSession(task, runtime, signal) {
+    try {
+      const prep = await this._prepareAgentRun(task, runtime, signal);
+      return await this._executeAgentTurn(task, prep);
+    } catch (err) {
+      console.error(`[dsh-cron] agent execution failed:`, err.message);
+      throw err;
+    }
+  }
+  /** Everything an agent run needs before the session is created. */
+  async _prepareAgentRun(task, runtime, signal) {
+    const { randomUUID } = await import('node:crypto');
+    let createUserMessage = (m) => m;
+    try {
+      const llmModule = await import('@deepseek-ai/dsh-llm');
+      if (llmModule && typeof llmModule.createUserMessage === 'function') {
+        createUserMessage = llmModule.createUserMessage;
+      }
+    } catch {}
+    let sessionModule = null;
+    try {
+      sessionModule = await import('@deepseek-ai/dsh-session');
+    } catch {}
+
+    const mintSessionId = () => {
+      const sid = `cron-exec-${task.id}-${randomUUID()}`;
+      if (sessionModule && typeof sessionModule.SessionId === 'function') {
+        return sessionModule.SessionId(sid);
+      }
+      return sid;
+    };
+
+    const defaultSel = this.ctx.get?.('agentDefaultModel')?.currentSelection?.();
+    return {
+      createUserMessage,
+      mintSessionId,
+      provider: task.provider || defaultSel?.provider,
+      model: task.model || defaultSel?.model || undefined,
+      ...(await this._resolveRunContext(task)),
+      agentPrompt: this._shapeAgentPrompt(task, runtime),
+      raceAbort: this._makeAbortRacer(signal),
+    };
+  }
+
+  /**
+   * The agent session cannot take the AbortSignal natively, so any abort
+   * (timeout, overlap replace, pause, scheduler stop) races against the session
+   * awaits and forces an immediate dispose (#88).
+   */
+  _makeAbortRacer(signal) {
+    const abortError = () => (signal && signal.reason) || new Error('Task aborted');
+    return (promise) => {
+      if (!signal) return promise;
+      return Promise.race([
+        promise,
+        new Promise((_, reject) => {
+          if (signal.aborted) {
+            reject(abortError());
+            return;
           }
-        }
-      } catch (err) {
-        console.error(`[dsh-cron] agent execution failed:`, err.message);
-        throw err;
+          signal.addEventListener('abort', () => reject(abortError()), { once: true });
+        }),
+      ]);
+    };
+  }
+
+  /** Working directory for the run, in an isolated worktree when requested (#29). */
+  async _resolveRunContext(task) {
+    const baseCwd = this.resolveCwd(task);
+    let cwd = baseCwd;
+    let taskWorktree = null;
+    if (task.worktree) {
+      try {
+        taskWorktree = await this.createTaskWorktree(baseCwd, task);
+        cwd = taskWorktree;
+      } catch (wtErr) {
+        console.warn('[dsh-cron] task worktree not created, running in the workspace:', wtErr.message);
       }
     }
+    return { baseCwd, cwd, taskWorktree };
+  }
 
-    // 3. Check if legacy session service is present
-    if (this.ctx && this.ctx.session && typeof this.ctx.session.create === 'function') {
-      try {
-        const session = await this.ctx.session.create({
-          title: `[Cron] ${task.title}`,
-          ephemeral: task.delivery === 'isolated',
-        });
+  /** #6/#10: skill- and workflow-driven tasks name the skill/workflow. */
+  _shapeAgentPrompt(task, runtime) {
+    const prompt = String(task.prompt || '');
+    if (runtime === 'skill' && task.skillName) {
+      return `Use the DSH skill "${task.skillName}" for this task:
+${prompt}`;
+    }
+    if (runtime === 'workflow' && task.workflowName) {
+      return `Execute this through the DSH workflow "${task.workflowName}" step by step:
+${prompt}`;
+    }
+    return prompt;
+  }
 
-        if (session && typeof session.send === 'function') {
-          const result = await session.send(task.prompt);
-          const out = typeof result === 'string' ? result : JSON.stringify(result);
-          const usage = session.usage || { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
-          const costUsd = estimateTokenCost(task.model, usage);
-          return {
-            output: out,
-            usage,
-            costUsd
-          };
-        }
-      } catch (err) {
-        console.error(`[dsh-cron] session execution failed:`, err.message);
-        throw err;
+  /** Create the session, drive one turn, and always clean up. */
+  async _executeAgentTurn(task, prep) {
+    let handle = null;
+    try {
+      handle = await this.ctx.agents.create({
+        sessionId: prep.mintSessionId(),
+        meta: { cwd: prep.cwd, ephemeral: true, internal: true },
+        agentOptions: prep.provider && prep.model ? { provider: prep.provider, model: prep.model } : undefined,
+      });
+      this._applyPermissionPreset(task, handle);
+      await prep.raceAbort(handle.agent.whenIdle());
+      handle.agent.followup(prep.createUserMessage({
+        content: [{ type: 'text', text: prep.agentPrompt }],
+        source: { kind: 'plugin', plugin: 'dsh-cron', form: 'cron-execute' },
+      }));
+      // Await agent turn completion (#67), abortable on timeout/overlap (#88)
+      if (typeof handle.agent.whenIdle === 'function') {
+        await prep.raceAbort(handle.agent.whenIdle());
       }
+      const usage = this._extractUsage(handle);
+      return {
+        output: `[dsh-cron] Agent finished turn for task "${task.title}" (session: ${handle.agent.session?.id || 'cron'})`,
+        usage,
+        costUsd: estimateTokenCost(prep.model, usage),
+        sessionId: handle.agent.session?.id || null,
+      };
+    } finally {
+      await this._disposeAgentRun(task, prep, handle);
     }
+  }
 
-    return {
-      output: `[dsh-cron] Prompt triggered: "${task.prompt.slice(0, 100)}..."`,
-      usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
-      costUsd: 0
-    };
+  /** Per-job permission preset (#32): read-only | workspace-write | full. */
+  _applyPermissionPreset(task, handle) {
+    if (!task.permissionPreset || task.permissionPreset === 'default') return;
+    try {
+      const presets = this.ctx.get && this.ctx.get('permissionPresets');
+      if (presets && typeof presets.set === 'function') {
+        presets.set(handle.agent.session, task.permissionPreset);
+      }
+    } catch (ppErr) {
+      console.warn('[dsh-cron] permission preset not applied:', ppErr.message);
+    }
+  }
+
+  /** Token usage reported by the session, when the core exposes it. */
+  _extractUsage(handle) {
+    const usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
+    try {
+      const sessionUsage = handle.agent.session?.usage || handle.agent.usage;
+      if (sessionUsage) {
+        usage.inputTokens = sessionUsage.inputTokens || sessionUsage.promptTokens || 0;
+        usage.outputTokens = sessionUsage.outputTokens || sessionUsage.completionTokens || 0;
+        usage.cacheReadTokens = sessionUsage.cacheReadTokens || sessionUsage.cachedTokens || 0;
+      }
+    } catch {}
+    return usage;
+  }
+
+  /** Dispose the session, archive it best-effort, drop the worktree (#30, #29). */
+  async _disposeAgentRun(task, prep, handle) {
+    let archivedSessionId = null;
+    try {
+      archivedSessionId = (handle && handle.agent && handle.agent.session && handle.agent.session.id) || null;
+    } catch {}
+    try {
+      if (handle && typeof handle.dispose === 'function') {
+        await handle.dispose();
+      } else if (handle && handle.agent && typeof handle.agent.destroy === 'function') {
+        await handle.agent.destroy();
+      }
+    } catch (disposeErr) {
+      console.warn('[dsh-cron] session dispose notice:', disposeErr.message);
+    }
+    // Best-effort: keep ephemeral cron sessions out of the main chat list (#30).
+    if (archivedSessionId && this.ctx && this.ctx.get) {
+      try {
+        const sessions = this.ctx.get('sessions');
+        if (sessions && typeof sessions.archive === 'function') {
+          sessions.archive(archivedSessionId);
+        }
+      } catch {}
+    }
+    // #29: dispose the isolated worktree (kept when keepWorktree is set).
+    if (prep.taskWorktree && !task.keepWorktree) {
+      await this.removeTaskWorktree(prep.baseCwd, prep.taskWorktree);
+    }
   }
 }