@blogic-cz/agent-tools 0.14.43 → 0.14.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blogic-cz/agent-tools",
-  "version": "0.14.43",
+  "version": "0.14.44",
   "description": "CLI tools for AI coding agent workflows — GitHub, database, Kubernetes, Azure DevOps, logs, sessions, and audit",
   "keywords": [
     "agent",
@@ -137,13 +137,13 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@effect/platform-bun": "4.0.0-beta.74",
+    "@effect/platform-bun": "4.0.0-beta.90",
     "@toon-format/toon": "2.1.0",
-    "effect": "4.0.0-beta.74"
+    "effect": "4.0.0-beta.90"
   },
   "devDependencies": {
     "@effect/language-service": "0.86.2",
-    "@effect/vitest": "4.0.0-beta.74",
+    "@effect/vitest": "4.0.0-beta.90",
     "@types/bun": "1.3.12",
     "oxfmt": "0.44.0",
     "oxlint": "1.59.0",
@@ -151,7 +151,7 @@
     "vitest": "^4.1.4"
   },
   "overrides": {
-    "@effect/platform-node-shared": "4.0.0-beta.74"
+    "@effect/platform-node-shared": "4.0.0-beta.90"
   },
   "engines": {
     "bun": ">=1.0.0"

package/src/gh-tool/pr/commands.ts

@@ -452,7 +452,11 @@ export const prChecksCommand = Command.make(
     repo: repoOption,
     timeout: Flag.integer("timeout").pipe(
       Flag.withDefault(CI_CHECK_WATCH_TIMEOUT_MS / 1000),
-      Flag.withDescription("Timeout in seconds for watch mode (default: 600)"),
+      Flag.withDescription("Timeout in seconds for watch mode (default: 600, minimum 1)"),
+      Flag.filter(
+        (n) => n >= 1,
+        () => "--timeout must be at least 1 second",
+      ),
     ),
     watch: Flag.boolean("watch").pipe(
       Flag.withDefault(false),

package/src/gh-tool/pr/core.ts

@@ -20,9 +20,6 @@ import { runLocalCommand } from "./helpers";
 
 const CHECK_JSON_FIELDS = "name,state,bucket,link";
 const GITHUB_ACTIONS_RUN_ID_RE = /github\.com\/[^/]+\/[^/]+\/actions\/runs\/(\d+)/;
-// A single blocking `--watch` is capped here so an agent never loses a whole turn to a 30-min
-// foreground wait. On hitting the cap we return the partial snapshot, not a failure (H1).
-const MAX_WATCH_SECONDS = 120;
 
 const validatePRTitle = Effect.fn("pr.validatePRTitle")(function* (title: string) {
   const gh = yield* GitHubService;
@@ -874,11 +871,12 @@ export const fetchChecks = Effect.fn("pr.fetchChecks")(function* (
       watchArgs.push("--fail-fast");
     }
 
-    // Cap the blocking wait; on timeout fall through to a snapshot instead of failing with no state.
-    const cappedSeconds = Math.min(timeoutSeconds, MAX_WATCH_SECONDS);
+    // Block for the caller's requested --timeout (no artificial cap — blocking isn't the problem;
+    // --timeout is validated >= 1s at the CLI boundary). On timeout return a snapshot, never
+    // nothing — that was the actual token-wasting bug.
     const watchOutcome = yield* gh.runGh(watchArgs).pipe(
       Effect.timeoutOrElse({
-        duration: cappedSeconds * 1000,
+        duration: timeoutSeconds * 1000,
         orElse: () => Effect.succeed(null),
       }),
     );
@@ -887,7 +885,7 @@ export const fetchChecks = Effect.fn("pr.fetchChecks")(function* (
     if (watchOutcome === null && results.some((c) => c.bucket === "pending")) {
       const pending = results.filter((c) => c.bucket === "pending").length;
       yield* Console.warn(
-        `ℹ️  Watch capped at ${cappedSeconds}s; ${pending} check(s) still pending (snapshot returned). ` +
+        `ℹ️  Watch timed out after ${timeoutSeconds}s; ${pending} check(s) still pending (snapshot returned). ` +
           `Re-run to keep watching:\n   ${buildChecksCommand(pr, true)}`,
       );
     }

package/src/gh-tool/workflow.ts

@@ -2,6 +2,7 @@ import { Command, Flag } from "effect/unstable/cli";
 import { Console, Effect, Option } from "effect";
 
 import { formatOption, logFormatted } from "#shared";
+import { CI_CHECK_WATCH_TIMEOUT_MS } from "#gh/config";
 import { GitHubCommandError, GitHubNotFoundError } from "./errors";
 import { GitHubService } from "./service";
 import type { CheckRunAnnotation, JobAnnotations } from "./types";
@@ -212,11 +213,15 @@ const cancelRun = Effect.fn("workflow.cancelRun")(function* (runId: number, repo
   };
 });
 
-// `gh run watch` has no native timeout and was observed hanging a turn for 36 min. Cap it and
-// fall back to a one-shot snapshot, mirroring the `pr checks --watch` cap (M1).
-const WATCH_RUN_TIMEOUT_SECONDS = 120;
+// `gh run watch` has no native timeout (observed hanging 36 min). Block for the caller's --timeout,
+// then fall back to a one-shot snapshot so a timeout never returns nothing.
+const DEFAULT_WATCH_RUN_TIMEOUT_SECONDS = CI_CHECK_WATCH_TIMEOUT_MS / 1000;
 
-const watchRun = Effect.fn("workflow.watchRun")(function* (runId: number, repo: string | null) {
+const watchRun = Effect.fn("workflow.watchRun")(function* (
+  runId: number,
+  repo: string | null,
+  timeoutSeconds: number,
+) {
   const gh = yield* GitHubService;
 
   const watchArgs = ["run", "watch", String(runId), "--exit-status"];
@@ -237,7 +242,7 @@ const watchRun = Effect.fn("workflow.watchRun")(function* (runId: number, repo:
       return Effect.fail(error);
     }),
     Effect.timeoutOrElse({
-      duration: WATCH_RUN_TIMEOUT_SECONDS * 1000,
+      duration: timeoutSeconds * 1000,
       orElse: () => Effect.succeed(null),
     }),
   );
@@ -255,7 +260,7 @@ const watchRun = Effect.fn("workflow.watchRun")(function* (runId: number, repo:
     })),
     watchOutput:
       result === null
-        ? `(watch capped at ${WATCH_RUN_TIMEOUT_SECONDS}s; status taken from snapshot — re-run to keep watching)`
+        ? `(watch timed out after ${timeoutSeconds}s; status taken from snapshot — re-run to keep watching)`
         : result.stdout,
   };
 });
@@ -650,11 +655,21 @@ export const workflowWatchCommand = Command.make(
     format: formatOption,
     repo: repoOption,
     run: Flag.integer("run").pipe(Flag.withDescription("Workflow run ID to watch")),
+    timeout: Flag.integer("timeout").pipe(
+      Flag.withDescription(
+        `Max seconds to block before returning a snapshot (default: ${DEFAULT_WATCH_RUN_TIMEOUT_SECONDS}, minimum 1)`,
+      ),
+      Flag.withDefault(DEFAULT_WATCH_RUN_TIMEOUT_SECONDS),
+      Flag.filter(
+        (n) => n >= 1,
+        () => "--timeout must be at least 1 second",
+      ),
+    ),
   },
-  ({ format, repo, run }) =>
+  ({ format, repo, run, timeout }) =>
     Effect.gen(function* () {
       const resolvedRepo = yield* resolveRepoArg(repo);
-      const result = yield* watchRun(run, resolvedRepo);
+      const result = yield* watchRun(run, resolvedRepo, timeout);
       yield* logFormatted(result, format);
     }),
 ).pipe(Command.withDescription("Watch a workflow run until it completes, then show final status"));