claude-ide-bridge 2.26.7 → 2.30.1

package/dist/automation.d.ts

@@ -13,15 +13,40 @@ import type { ExtensionClient } from "./extensionClient.js";
  *   primary event value (file path, branch name, tool name, etc.) matches.
  *   Prefix with `!` to negate: `"!**\/*.test.ts"` fires for all non-test files.
  */
+/**
+ * Optional runtime condition checked before a hook fires.
+ * All specified fields must pass for the hook to trigger.
+ */
+export interface AutomationCondition {
+    /** Only fire if the active file's diagnostic count meets this threshold. */
+    minDiagnosticCount?: number;
+    /** Only fire if the active file has a diagnostic of at least this severity. */
+    diagnosticsMinSeverity?: "error" | "warning";
+    /** Only fire if the last test run for any runner had this outcome. */
+    testRunnerLastStatus?: "passed" | "failed";
+}
 export interface PromptSource {
     prompt?: string;
     promptName?: string;
     promptArgs?: Record<string, string>;
     condition?: string;
+    /** Optional runtime condition evaluated before the hook fires. */
+    when?: AutomationCondition;
     /** Per-hook model override. Falls back to policy.defaultModel (Haiku). */
     model?: string;
     /** Per-hook effort override. Falls back to policy.defaultEffort ("low"). */
     effort?: "low" | "medium" | "high" | "max";
+    /**
+     * Number of times to re-enqueue on task error. Default: 0 (no retry).
+     * Retries only fire when the task reaches status "error" — cancellations
+     * and timeouts do not trigger a retry.
+     */
+    retryCount?: number;
+    /**
+     * Milliseconds to wait between retries. Default: 30_000.
+     * Enforced minimum: 5_000.
+     */
+    retryDelayMs?: number;
 }
 export interface OnDiagnosticsErrorPolicy extends PromptSource {
     enabled: boolean;
@@ -136,6 +161,18 @@ export interface TestRunResult {
         message: string;
     }>;
 }
+export interface OnDebugSessionEndPolicy extends PromptSource {
+    enabled: boolean;
+    /**
+     * Placeholders (inline prompt only): {{sessionName}}, {{sessionType}}
+     */
+    cooldownMs: number;
+}
+/** Minimal debug session result passed to handleDebugSessionEnd. */
+export interface DebugSessionEndResult {
+    sessionName: string;
+    sessionType: string;
+}
 export interface OnGitCommitPolicy extends PromptSource {
     enabled: boolean;
     /**
@@ -309,6 +346,8 @@ export interface AutomationPolicy {
     onDiagnosticsCleared?: OnDiagnosticsClearedPolicy;
     /** Fired when a Claude orchestrator task completes with status done. */
     onTaskSuccess?: OnTaskSuccessPolicy;
+    /** Fired when a VS Code debug session terminates (hasActiveSession transitions true→false). */
+    onDebugSessionEnd?: OnDebugSessionEndPolicy;
 }
 export interface Diagnostic {
     message: string;
@@ -378,8 +417,14 @@ export declare class AutomationHooks {
     private activeDiagnosticsClearedTasks;
     /** Tracks previous error count per normalized file path for zero-transition detection. */
     private prevDiagnosticErrors;
+    /** Latest diagnostics by file — used by _evaluateWhen() for conditional hooks. */
+    private latestDiagnosticsByFile;
+    /** Last test runner outcome per runner name — used by _evaluateWhen(). */
+    private lastTestRunnerStatusByRunner;
     /** Active task ID for the task-success handler (workspace-global). */
     private activeTaskSuccessTaskId;
+    /** Active task ID for the debug-session-end handler (workspace-global). */
+    private activeDebugSessionEndTaskId;
     /** Active task ID for the post-compact handler (workspace-global). */
     private activePostCompactTaskId;
     /** Active task ID for the instructions-loaded handler (workspace-global). */
@@ -397,6 +442,11 @@ export declare class AutomationHooks {
      * callers can handle it identically.
      */
     private _enqueueAutomationTask;
+    /**
+     * Poll a task until it reaches a terminal state. If the task ends with
+     * status "error" and retries remain, re-enqueue after `retryDelayMs`.
+     */
+    private _watchForRetry;
     /**
      * Resolve a named prompt, substituting any `{{placeholder}}` tokens in
      * `promptArgs` values with sanitized event data before calling `getPrompt()`.
@@ -405,6 +455,12 @@ export declare class AutomationHooks {
      * or has missing required arguments.
      */
     private _resolveNamedPrompt;
+    /**
+     * Evaluate the optional `when` condition block on a hook.
+     * Called after _matchesCondition() succeeds and before cooldown checks.
+     * Returns true if all specified conditions pass (or no `when` block present).
+     */
+    private _evaluateWhen;
     private _matchesCondition;
     handleDiagnosticsChanged(file: string, diagnostics: Diagnostic[]): void;
     /** Prune lastTrigger entries older than LAST_TRIGGER_MAX_AGE_MS to prevent unbounded growth. */
@@ -476,6 +532,11 @@ export declare class AutomationHooks {
      * Call from bridge.ts when a task transitions to done.
      */
     handleTaskSuccess(result: TaskSuccessResult): void;
+    /**
+     * Called when a VS Code debug session ends (hasActiveSession transitions true→false).
+     * Fires the onDebugSessionEnd automation hook if configured.
+     */
+    handleDebugSessionEnd(result: DebugSessionEndResult): Promise<void>;
     /** Summary of automation policy for getBridgeStatus. */
     getStatus(): {
         onPostCompact: {
@@ -546,6 +607,10 @@ export declare class AutomationHooks {
             enabled: boolean;
             cooldownMs: number;
         } | null;
+        onDebugSessionEnd: {
+            enabled: boolean;
+            cooldownMs: number;
+        } | null;
         unwiredEnabledHooks: string[];
         defaultModel: string;
         maxTasksPerHour: number;

package/dist/automation.js

@@ -498,6 +498,24 @@ export function loadPolicy(filePath) {
             ts.cooldownMs = MIN_COOLDOWN_MS;
         }
     }
+    // Validate onDebugSessionEnd
+    if (policy.onDebugSessionEnd !== undefined) {
+        const dse = policy.onDebugSessionEnd;
+        if (typeof dse !== "object" || dse === null) {
+            throw new Error(`"onDebugSessionEnd" must be an object`);
+        }
+        if (typeof dse.enabled !== "boolean") {
+            throw new Error(`"onDebugSessionEnd.enabled" must be a boolean`);
+        }
+        validatePromptSource("onDebugSessionEnd", dse);
+        if (typeof dse.cooldownMs !== "number" ||
+            !Number.isFinite(dse.cooldownMs)) {
+            throw new Error(`"onDebugSessionEnd.cooldownMs" must be a number`);
+        }
+        if (dse.cooldownMs < MIN_COOLDOWN_MS) {
+            dse.cooldownMs = MIN_COOLDOWN_MS;
+        }
+    }
     return policy;
 }
 /**
@@ -543,7 +561,7 @@ export function checkCcHookWiring() {
             result[ccEvent] = entries.some((e) => {
                 // New format: { matcher, hooks: [{ type, command }] }
                 if (e && Array.isArray(e.hooks)) {
-                    return e.hooks.some((h) => commandMatches(h.command, ccEvent, toolName));
+                    return e.hooks?.some((h) => commandMatches(h.command, ccEvent, toolName));
                 }
                 // Legacy flat format: { type, command }
                 return commandMatches(e.command, ccEvent, toolName);
@@ -603,8 +621,14 @@ export class AutomationHooks {
     activeDiagnosticsClearedTasks = new Map();
     /** Tracks previous error count per normalized file path for zero-transition detection. */
     prevDiagnosticErrors = new Map();
+    /** Latest diagnostics by file — used by _evaluateWhen() for conditional hooks. */
+    latestDiagnosticsByFile = new Map();
+    /** Last test runner outcome per runner name — used by _evaluateWhen(). */
+    lastTestRunnerStatusByRunner = new Map();
     /** Active task ID for the task-success handler (workspace-global). */
     activeTaskSuccessTaskId = null;
+    /** Active task ID for the debug-session-end handler (workspace-global). */
+    activeDebugSessionEndTaskId = null;
     /** Active task ID for the post-compact handler (workspace-global). */
     activePostCompactTaskId = null;
     /** Active task ID for the instructions-loaded handler (workspace-global). */
@@ -661,8 +685,50 @@ export class AutomationHooks {
         if (maxPerHour > 0) {
             this.taskTimestamps.push(Date.now());
         }
+        // Schedule retry watcher if retryCount > 0.
+        const retryCount = opts.hookCfg?.retryCount ?? 0;
+        const retryAttempt = opts._retryAttempt ?? 0;
+        if (retryCount > 0) {
+            const retryDelayMs = Math.max(5_000, opts.hookCfg?.retryDelayMs ?? 30_000);
+            this._watchForRetry(taskId, opts, retryAttempt, retryCount, retryDelayMs);
+        }
         return taskId;
     }
+    /**
+     * Poll a task until it reaches a terminal state. If the task ends with
+     * status "error" and retries remain, re-enqueue after `retryDelayMs`.
+     */
+    _watchForRetry(taskId, opts, retryAttempt, retryCount, retryDelayMs) {
+        const interval = setInterval(() => {
+            const task = this.orchestrator.getTask(taskId);
+            if (!task) {
+                clearInterval(interval);
+                return;
+            }
+            if (task.status === "pending" || task.status === "running")
+                return;
+            clearInterval(interval);
+            if (task.status !== "error")
+                return; // cancelled/done → no retry
+            const nextAttempt = retryAttempt + 1;
+            if (nextAttempt > retryCount) {
+                this.log(`[automation] ${opts.triggerSource}: max retries (${retryCount}) reached, dropping`);
+                return;
+            }
+            this.log(`[automation] ${opts.triggerSource}: retry ${nextAttempt}/${retryCount} in ${retryDelayMs}ms`);
+            setTimeout(() => {
+                try {
+                    this._enqueueAutomationTask({
+                        ...opts,
+                        _retryAttempt: nextAttempt,
+                    });
+                }
+                catch (e) {
+                    this.log(`[automation] ${opts.triggerSource}: retry enqueue failed: ${e}`);
+                }
+            }, retryDelayMs);
+        }, 2_000);
+    }
     /**
      * Resolve a named prompt, substituting any `{{placeholder}}` tokens in
      * `promptArgs` values with sanitized event data before calling `getPrompt()`.
@@ -693,6 +759,47 @@ export class AutomationHooks {
             .map((m) => m.content.text)
             .join("\n\n");
     }
+    /**
+     * Evaluate the optional `when` condition block on a hook.
+     * Called after _matchesCondition() succeeds and before cooldown checks.
+     * Returns true if all specified conditions pass (or no `when` block present).
+     */
+    _evaluateWhen(cfg, file) {
+        const when = cfg.when;
+        if (!when)
+            return true;
+        if (when.minDiagnosticCount !== undefined ||
+            when.diagnosticsMinSeverity !== undefined) {
+            const diags = (file ? this.latestDiagnosticsByFile.get(file) : undefined) ?? [];
+            if (when.minDiagnosticCount !== undefined &&
+                diags.length < when.minDiagnosticCount) {
+                return false;
+            }
+            if (when.diagnosticsMinSeverity !== undefined) {
+                const targetRank = when.diagnosticsMinSeverity === "error" ? 2 : 1;
+                const severityRank = {
+                    error: 2,
+                    warning: 1,
+                    info: 0,
+                    information: 0,
+                    hint: 0,
+                };
+                const hasMatchingSeverity = diags.some((d) => (severityRank[d.severity] ?? 0) >= targetRank);
+                if (!hasMatchingSeverity)
+                    return false;
+            }
+        }
+        if (when.testRunnerLastStatus !== undefined) {
+            // Check any runner's last status (wildcard: first match wins)
+            const statuses = Array.from(this.lastTestRunnerStatusByRunner.values());
+            if (statuses.length === 0)
+                return false;
+            const hasMatch = statuses.some((s) => s === when.testRunnerLastStatus);
+            if (!hasMatch)
+                return false;
+        }
+        return true;
+    }
     _matchesCondition(cfg, primaryValue) {
         if (!cfg.condition)
             return true;
@@ -717,6 +824,8 @@ export class AutomationHooks {
         const currentErrorCount = diagnostics.filter((d) => (severityRankForClear[d.severity] ?? 0) >= 1).length;
         const prevErrorCount = this.prevDiagnosticErrors.get(normalizedFile) ?? 0;
         this.prevDiagnosticErrors.set(normalizedFile, currentErrorCount);
+        // Keep latest diagnostics for _evaluateWhen() condition checks
+        this.latestDiagnosticsByFile.set(normalizedFile, diagnostics);
         // Fire onDiagnosticsCleared if transitioning from non-zero → zero
         if (prevErrorCount > 0 && currentErrorCount === 0) {
             this.handleDiagnosticsCleared(normalizedFile);
@@ -727,6 +836,8 @@ export class AutomationHooks {
         // Condition filter
         if (!this._matchesCondition(cfg, normalizedFile))
             return;
+        if (!this._evaluateWhen(cfg, normalizedFile))
+            return;
         // Skip onDiagnosticsError if there are no errors to report
         if (currentErrorCount === 0)
             return;
@@ -1011,6 +1122,8 @@ export class AutomationHooks {
         // Condition filter
         if (!this._matchesCondition(cfg, normalizedFile))
             return;
+        if (!this._evaluateWhen(cfg, normalizedFile))
+            return;
         // Pattern matching — also try workspace-relative path so patterns like
         // "src/**/*.ts" work when VS Code sends absolute paths.
         const relFile = this.workspace && path.isAbsolute(normalizedFile)
@@ -1151,10 +1264,13 @@ export class AutomationHooks {
         const failureCount = result.summary.failed + result.summary.errored;
         // Update per-runner outcome state unconditionally so onTestPassAfterFailure
         // can detect fail→pass transitions even when onTestRun is disabled/absent.
+        const testStatus = failureCount === 0 ? "passed" : "failed";
         for (const runner of result.runners) {
             const prev = this.lastTestOutcomeByRunner.get(runner);
             const current = failureCount === 0 ? "pass" : "fail";
             this.lastTestOutcomeByRunner.set(runner, current);
+            // Update lastTestRunnerStatusByRunner for _evaluateWhen() condition checks
+            this.lastTestRunnerStatusByRunner.set(runner, testStatus);
             if (prev === "fail" && current === "pass") {
                 this._handleTestPassAfterFailure(result, runner);
             }
@@ -1175,6 +1291,9 @@ export class AutomationHooks {
             this.log(`[automation] skipping test-run trigger — duration ${result.summary.durationMs}ms < minDuration ${cfg.minDuration}ms`);
             return;
         }
+        // Evaluate optional when condition
+        if (!this._evaluateWhen(cfg))
+            return;
         // Loop guard: skip if a task is still pending/running
         if (this.activeTestRunTaskId) {
             const existing = this.orchestrator.getTask(this.activeTestRunTaskId);
@@ -1882,6 +2001,67 @@ export class AutomationHooks {
             this.log(`[automation] failed to enqueue task-success task: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
+    /**
+     * Called when a VS Code debug session ends (hasActiveSession transitions true→false).
+     * Fires the onDebugSessionEnd automation hook if configured.
+     */
+    async handleDebugSessionEnd(result) {
+        const cfg = this.policy.onDebugSessionEnd;
+        if (!cfg?.enabled)
+            return;
+        // Loop guard: skip if a task is still pending/running
+        if (this.activeDebugSessionEndTaskId) {
+            const existing = this.orchestrator.getTask(this.activeDebugSessionEndTaskId);
+            if (existing &&
+                (existing.status === "pending" || existing.status === "running")) {
+                this.log(`[automation] skipping debug-session-end trigger — task ${this.activeDebugSessionEndTaskId.slice(0, 8)} still active`);
+                return;
+            }
+            this.activeDebugSessionEndTaskId = null;
+        }
+        // Cooldown check (workspace-global)
+        const key = "debugSessionEnd:global";
+        const now = Date.now();
+        const last = this.lastTrigger.get(key) ?? 0;
+        if (now - last < cfg.cooldownMs) {
+            this.log(`[automation] cooldown active for debug-session-end (${cfg.cooldownMs - (now - last)}ms remaining)`);
+            return;
+        }
+        this._pruneLastTrigger(now);
+        const safeSessionName = result.sessionName.slice(0, MAX_FILE_PATH_CHARS);
+        const safeSessionType = result.sessionType.slice(0, MAX_FILE_PATH_CHARS);
+        let prompt;
+        if (cfg.promptName) {
+            const resolved = this._resolveNamedPrompt(cfg.promptName, cfg.promptArgs ?? {}, {
+                sessionName: safeSessionName,
+                sessionType: safeSessionType,
+            });
+            if (resolved === null)
+                return;
+            prompt = resolved;
+        }
+        else {
+            const nonce = crypto.randomBytes(6).toString("hex");
+            prompt =
+                (cfg.prompt ?? "")
+                    .replace(/\{\{sessionName\}\}/g, untrustedBlock("SESSION NAME", safeSessionName, nonce))
+                    .replace(/\{\{sessionType\}\}/g, untrustedBlock("SESSION TYPE", safeSessionType, nonce)) ?? "";
+        }
+        prompt = truncatePrompt(buildHookMetadata("onDebugSessionEnd") + prompt);
+        try {
+            const taskId = this._enqueueAutomationTask({
+                prompt,
+                triggerSource: "onDebugSessionEnd",
+                hookCfg: cfg,
+            });
+            this.lastTrigger.set(key, now);
+            this.activeDebugSessionEndTaskId = taskId;
+            this.log(`[automation] triggered debug-session-end task ${taskId.slice(0, 8)} (session: ${result.sessionName}, type: ${result.sessionType})`);
+        }
+        catch (err) {
+            this.log(`[automation] failed to enqueue debug-session-end task: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     /** Summary of automation policy for getBridgeStatus. */
     getStatus() {
         const p = this.policy;
@@ -1993,6 +2173,12 @@ export class AutomationHooks {
                     cooldownMs: p.onGitPull.cooldownMs,
                 }
                 : null,
+            onDebugSessionEnd: p.onDebugSessionEnd
+                ? {
+                    enabled: p.onDebugSessionEnd.enabled,
+                    cooldownMs: p.onDebugSessionEnd.cooldownMs,
+                }
+                : null,
             unwiredEnabledHooks,
             defaultModel: p.defaultModel ?? "claude-haiku-4-5-20251001",
             maxTasksPerHour: p.maxTasksPerHour ?? 20,