@pruddiman/dispatch 1.5.0-beta.30f06ab → 1.5.0-beta.c0bcc82

package/dist/cli.js

@@ -11920,9 +11920,18 @@ var init_database = __esm({
 // src/mcp/state/manager.ts
 import { randomUUID as randomUUID6 } from "crypto";
 function registerLiveRun(runId) {
-  liveRuns.set(runId, { runId, callbacks: [] });
+  liveRuns.set(runId, { runId, callbacks: [], completionCallbacks: [] });
 }
 function unregisterLiveRun(runId) {
+  const run = liveRuns.get(runId);
+  if (run) {
+    for (const cb of run.completionCallbacks) {
+      try {
+        cb();
+      } catch {
+      }
+    }
+  }
   liveRuns.delete(runId);
 }
 function addLogCallback(runId, cb) {
@@ -11943,6 +11952,48 @@ function emitLog(runId, message, level = "info") {
     }
   }
 }
+function isLiveRun(runId) {
+  return liveRuns.has(runId);
+}
+function addCompletionCallback(runId, cb) {
+  const run = liveRuns.get(runId);
+  if (run) {
+    run.completionCallbacks.push(cb);
+  }
+}
+function waitForRunCompletion(runId, waitMs, getStatus) {
+  const effectiveWait = Math.min(Math.max(waitMs, 0), 12e4);
+  if (effectiveWait <= 0) return Promise.resolve(false);
+  const currentStatus = getStatus();
+  if (currentStatus !== null && currentStatus !== "running") {
+    return Promise.resolve(true);
+  }
+  return new Promise((resolve6) => {
+    let settled = false;
+    let pollTimer;
+    let timeoutTimer;
+    const cleanup = () => {
+      if (pollTimer) clearInterval(pollTimer);
+      if (timeoutTimer) clearTimeout(timeoutTimer);
+    };
+    const settle = (completed) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve6(completed);
+    };
+    if (isLiveRun(runId)) {
+      addCompletionCallback(runId, () => settle(true));
+    }
+    pollTimer = setInterval(() => {
+      const s = getStatus();
+      if (s !== null && s !== "running") {
+        settle(true);
+      }
+    }, 2e3);
+    timeoutTimer = setTimeout(() => settle(false), effectiveWait);
+  });
+}
 function assertRunStatus(value) {
   if (RUN_STATUSES.includes(value)) return value;
   throw new Error(`Invalid RunStatus from database: "${value}"`);
@@ -12210,9 +12261,36 @@ var init_fork_run = __esm({
   }
 });
 
+// src/mcp/tools/_resolve-config.ts
+import { join as join17 } from "path";
+async function loadMcpConfig(cwd, overrides) {
+  const config = await loadConfig(join17(cwd, ".dispatch"));
+  const provider = overrides?.provider ?? config.provider;
+  if (!provider) {
+    throw new Error(
+      "Missing required configuration: provider. Run 'dispatch config' to set up defaults."
+    );
+  }
+  let source = overrides?.source ?? config.source;
+  if (!source) {
+    const detected = await detectDatasource(cwd);
+    if (detected) {
+      source = detected;
+    }
+  }
+  return { ...config, provider, source };
+}
+var init_resolve_config = __esm({
+  "src/mcp/tools/_resolve-config.ts"() {
+    "use strict";
+    init_config();
+    init_datasources();
+  }
+});
+
 // src/mcp/tools/spec.ts
 import { z as z2 } from "zod";
-import { join as join17, resolve as resolve4, sep as sep2 } from "path";
+import { join as join18, resolve as resolve4, sep as sep2 } from "path";
 import { readdir as readdir2, readFile as readFile11 } from "fs/promises";
 function registerSpecTools(server, cwd) {
   server.tool(
@@ -12222,21 +12300,39 @@ function registerSpecTools(server, cwd) {
       issues: z2.string().describe(
         "Comma-separated issue IDs (e.g. '42,43'), a glob pattern (e.g. 'drafts/*.md'), or an inline description."
       ),
-      provider: z2.enum(PROVIDER_NAMES).optional().describe("Agent provider name (default: opencode)"),
-      source: z2.enum(DATASOURCE_NAMES).optional().describe("Issue datasource: github, azdevops, md"),
+      provider: z2.enum(PROVIDER_NAMES).optional().describe("Agent provider name (default: from config)"),
+      source: z2.enum(DATASOURCE_NAMES).optional().describe("Issue datasource: github, azdevops, md (default: from config)"),
       concurrency: z2.number().int().min(1).max(32).optional().describe("Max parallel spec generations"),
       dryRun: z2.boolean().optional().describe("Preview without generating")
     },
     async (args) => {
+      let config;
+      try {
+        config = await loadMcpConfig(cwd, { provider: args.provider, source: args.source });
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true
+        };
+      }
       const runId = createSpecRun({ cwd, issues: args.issues });
       forkDispatchRun(runId, server, {
         type: "spec",
         cwd,
         opts: {
           issues: args.issues,
-          provider: args.provider ?? "opencode",
-          issueSource: args.source,
-          concurrency: args.concurrency,
+          provider: config.provider,
+          model: config.model,
+          issueSource: config.source,
+          org: config.org,
+          project: config.project,
+          workItemType: config.workItemType,
+          iteration: config.iteration,
+          area: config.area,
+          concurrency: args.concurrency ?? config.concurrency,
+          specTimeout: config.specTimeout,
+          specWarnTimeout: config.specWarnTimeout,
+          specKillTimeout: config.specKillTimeout,
           dryRun: args.dryRun,
           cwd
         }
@@ -12261,7 +12357,7 @@ function registerSpecTools(server, cwd) {
     "List spec files in the .dispatch/specs directory.",
     {},
     async () => {
-      const specsDir = join17(cwd, ".dispatch", "specs");
+      const specsDir = join18(cwd, ".dispatch", "specs");
       let files = [];
       let dirError;
       try {
@@ -12291,7 +12387,7 @@ function registerSpecTools(server, cwd) {
     },
     async (args) => {
       const specsDir = resolve4(cwd, ".dispatch", "specs");
-      const candidatePath = args.file.includes("/") || args.file.includes("\\") ? resolve4(specsDir, args.file) : join17(specsDir, args.file);
+      const candidatePath = args.file.includes("/") || args.file.includes("\\") ? resolve4(specsDir, args.file) : join18(specsDir, args.file);
       if (!candidatePath.startsWith(specsDir + sep2) && candidatePath !== specsDir) {
         return {
           content: [{ type: "text", text: `Access denied: path must be inside the specs directory` }],
@@ -12335,21 +12431,36 @@ function registerSpecTools(server, cwd) {
   );
   server.tool(
     "spec_run_status",
-    "Get the status of a specific spec generation run.",
+    "Get the status of a specific spec generation run. Use waitMs to hold the response until the run completes or the timeout elapses.",
     {
-      runId: z2.string().describe("The runId returned by spec_generate")
+      runId: z2.string().describe("The runId returned by spec_generate"),
+      waitMs: z2.number().int().min(0).max(12e4).optional().default(0).describe("Hold response until run completes or timeout (ms). 0 = return immediately.")
     },
     async (args) => {
       try {
-        const run = getSpecRun(args.runId);
+        let run = getSpecRun(args.runId);
         if (!run) {
           return {
             content: [{ type: "text", text: `Run ${args.runId} not found` }],
             isError: true
           };
         }
+        if (run.status === "running" && args.waitMs > 0) {
+          const completed = await waitForRunCompletion(
+            args.runId,
+            args.waitMs,
+            () => getSpecRun(args.runId)?.status ?? null
+          );
+          if (completed) {
+            run = getSpecRun(args.runId);
+          }
+        }
+        const response = { ...run };
+        if (run.status === "running") {
+          response.retryAfterMs = 5e3;
+        }
         return {
-          content: [{ type: "text", text: JSON.stringify(run) }]
+          content: [{ type: "text", text: JSON.stringify(response) }]
         };
       } catch (err) {
         return {
@@ -12367,6 +12478,7 @@ var init_spec2 = __esm({
     init_interface2();
     init_interface();
     init_fork_run();
+    init_resolve_config();
   }
 });
 
@@ -12378,8 +12490,8 @@ function registerDispatchTools(server, cwd) {
     "Execute dispatch pipeline for one or more issue IDs. Returns a runId immediately; progress is pushed via logging notifications.",
     {
       issueIds: z3.array(z3.string()).min(1).describe("Issue IDs to dispatch (e.g. ['42', '43'])"),
-      provider: z3.enum(PROVIDER_NAMES).optional().describe("Agent provider (default: opencode)"),
-      source: z3.enum(DATASOURCE_NAMES).optional().describe("Issue datasource: github, azdevops, md"),
+      provider: z3.enum(PROVIDER_NAMES).optional().describe("Agent provider (default: from config)"),
+      source: z3.enum(DATASOURCE_NAMES).optional().describe("Issue datasource: github, azdevops, md (default: from config)"),
       concurrency: z3.number().int().min(1).max(32).optional().describe("Max parallel tasks"),
       noPlan: z3.boolean().optional().describe("Skip the planner agent"),
       noBranch: z3.boolean().optional().describe("Skip branch creation and PR lifecycle"),
@@ -12387,6 +12499,15 @@ function registerDispatchTools(server, cwd) {
       retries: z3.number().int().min(0).max(10).optional().describe("Retry attempts per task")
     },
     async (args) => {
+      let config;
+      try {
+        config = await loadMcpConfig(cwd, { provider: args.provider, source: args.source });
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true
+        };
+      }
       const runId = createRun({ cwd, issueIds: args.issueIds });
       forkDispatchRun(runId, server, {
         type: "dispatch",
@@ -12394,9 +12515,20 @@ function registerDispatchTools(server, cwd) {
         opts: {
           issueIds: args.issueIds,
           dryRun: false,
-          provider: args.provider ?? "opencode",
-          source: args.source,
-          concurrency: args.concurrency ?? 1,
+          provider: config.provider,
+          model: config.model,
+          fastProvider: config.fastProvider,
+          fastModel: config.fastModel,
+          agents: config.agents,
+          source: config.source,
+          org: config.org,
+          project: config.project,
+          workItemType: config.workItemType,
+          iteration: config.iteration,
+          area: config.area,
+          username: config.username,
+          planTimeout: config.planTimeout,
+          concurrency: args.concurrency ?? config.concurrency ?? 1,
           noPlan: args.noPlan,
           noBranch: args.noBranch,
           noWorktree: args.noWorktree,
@@ -12413,15 +12545,28 @@ function registerDispatchTools(server, cwd) {
     "Preview tasks that would be dispatched for the given issue IDs without executing anything.",
     {
       issueIds: z3.array(z3.string()).min(1).describe("Issue IDs to preview"),
-      source: z3.enum(DATASOURCE_NAMES).optional().describe("Issue datasource: github, azdevops, md")
+      source: z3.enum(DATASOURCE_NAMES).optional().describe("Issue datasource: github, azdevops, md (default: from config)")
     },
     async (args) => {
       try {
+        const config = await loadMcpConfig(cwd, { source: args.source });
         const orchestrator = await boot9({ cwd });
         const result = await orchestrator.orchestrate({
           issueIds: args.issueIds,
           dryRun: true,
-          source: args.source
+          provider: config.provider,
+          model: config.model,
+          fastProvider: config.fastProvider,
+          fastModel: config.fastModel,
+          agents: config.agents,
+          source: config.source,
+          org: config.org,
+          project: config.project,
+          workItemType: config.workItemType,
+          iteration: config.iteration,
+          area: config.area,
+          username: config.username,
+          planTimeout: config.planTimeout
         });
         return {
           content: [{ type: "text", text: JSON.stringify(result) }]
@@ -12443,31 +12588,47 @@ var init_dispatch = __esm({
     init_interface2();
     init_interface();
     init_fork_run();
+    init_resolve_config();
   }
 });
 
 // src/mcp/tools/monitor.ts
 import { z as z4 } from "zod";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 function registerMonitorTools(server, cwd) {
   server.tool(
     "status_get",
-    "Get the current status of a dispatch or spec run, including per-task details.",
+    "Get the current status of a dispatch or spec run, including per-task details. Use waitMs to hold the response until the run completes or the timeout elapses.",
     {
-      runId: z4.string().describe("The runId returned by dispatch_run or spec_generate")
+      runId: z4.string().describe("The runId returned by dispatch_run or spec_generate"),
+      waitMs: z4.number().int().min(0).max(12e4).optional().default(0).describe("Hold response until run completes or timeout (ms). 0 = return immediately.")
     },
     async (args) => {
       try {
-        const run = getRun(args.runId);
+        let run = getRun(args.runId);
         if (!run) {
           return {
             content: [{ type: "text", text: `Run ${args.runId} not found` }],
             isError: true
           };
         }
+        if (run.status === "running" && args.waitMs > 0) {
+          const completed = await waitForRunCompletion(
+            args.runId,
+            args.waitMs,
+            () => getRun(args.runId)?.status ?? null
+          );
+          if (completed) {
+            run = getRun(args.runId);
+          }
+        }
         const tasks = getTasksForRun(args.runId);
+        const response = { run, tasks };
+        if (run.status === "running") {
+          response.retryAfterMs = 5e3;
+        }
         return {
-          content: [{ type: "text", text: JSON.stringify({ run, tasks }) }]
+          content: [{ type: "text", text: JSON.stringify(response) }]
         };
       } catch (err) {
         return {
@@ -12511,7 +12672,7 @@ function registerMonitorTools(server, cwd) {
     },
     async (args) => {
       try {
-        const config = await loadConfig(join18(cwd, ".dispatch"));
+        const config = await loadConfig(join19(cwd, ".dispatch"));
         const sourceName = args.source ?? config.source;
         if (!sourceName) {
           return {
@@ -12556,7 +12717,7 @@ function registerMonitorTools(server, cwd) {
     },
     async (args) => {
       try {
-        const config = await loadConfig(join18(cwd, ".dispatch"));
+        const config = await loadConfig(join19(cwd, ".dispatch"));
         const sourceName = args.source ?? config.source;
         if (!sourceName) {
           return {
@@ -12604,7 +12765,6 @@ var init_monitor = __esm({
 
 // src/mcp/tools/recovery.ts
 import { z as z5 } from "zod";
-import { join as join19 } from "path";
 function registerRecoveryTools(server, cwd) {
   server.tool(
     "run_retry",
@@ -12629,7 +12789,15 @@ function registerRecoveryTools(server, cwd) {
           content: [{ type: "text", text: JSON.stringify({ message: "No failed tasks found", originalRunId: args.runId }) }]
         };
       }
-      const config = await loadConfig(join19(cwd, ".dispatch"));
+      let config;
+      try {
+        config = await loadMcpConfig(cwd, { provider: args.provider });
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true
+        };
+      }
       const issueIds = issueIdsSchema.parse(JSON.parse(originalRun.issueIds));
       const newRunId = createRun({ cwd, issueIds });
       forkDispatchRun(newRunId, server, {
@@ -12638,8 +12806,19 @@ function registerRecoveryTools(server, cwd) {
         opts: {
           issueIds,
           dryRun: false,
-          provider: args.provider ?? config.provider ?? "opencode",
+          provider: config.provider,
+          model: config.model,
+          fastProvider: config.fastProvider,
+          fastModel: config.fastModel,
+          agents: config.agents,
           source: config.source,
+          org: config.org,
+          project: config.project,
+          workItemType: config.workItemType,
+          iteration: config.iteration,
+          area: config.area,
+          username: config.username,
+          planTimeout: config.planTimeout,
           concurrency: args.concurrency ?? config.concurrency ?? 1,
           force: true
         }
@@ -12673,7 +12852,15 @@ function registerRecoveryTools(server, cwd) {
           isError: true
         };
       }
-      const config = await loadConfig(join19(cwd, ".dispatch"));
+      let config;
+      try {
+        config = await loadMcpConfig(cwd, { provider: args.provider });
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+          isError: true
+        };
+      }
       const issueIds = issueIdsSchema.parse(JSON.parse(originalRun.issueIds));
       const newRunId = createRun({ cwd, issueIds });
       forkDispatchRun(newRunId, server, {
@@ -12682,8 +12869,19 @@ function registerRecoveryTools(server, cwd) {
         opts: {
           issueIds,
           dryRun: false,
-          provider: args.provider ?? config.provider ?? "opencode",
+          provider: config.provider,
+          model: config.model,
+          fastProvider: config.fastProvider,
+          fastModel: config.fastModel,
+          agents: config.agents,
           source: config.source,
+          org: config.org,
+          project: config.project,
+          workItemType: config.workItemType,
+          iteration: config.iteration,
+          area: config.area,
+          username: config.username,
+          planTimeout: config.planTimeout,
           concurrency: 1,
           force: true
         }
@@ -12699,9 +12897,9 @@ var init_recovery = __esm({
   "src/mcp/tools/recovery.ts"() {
     "use strict";
     init_manager();
-    init_config();
     init_interface2();
     init_fork_run();
+    init_resolve_config();
     issueIdsSchema = z5.array(z5.string());
   }
 });
@@ -13305,7 +13503,7 @@ async function main() {
     process.exit(0);
   }
   if (args.version) {
-    console.log(`dispatch v${"1.5.0-beta.30f06ab"}`);
+    console.log(`dispatch v${"1.5.0-beta.c0bcc82"}`);
     process.exit(0);
   }
   const orchestrator = await boot9({ cwd: args.cwd });