@skaile/workspaces 0.10.1 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## 0.11.0
+
+### Minor Changes
+
+- c0f3b15: Two-part hardening of the AI-credential 401 path:
+
+  **Bridge: defer the auth-error event when self-heal is pending.** The
+  `claude-sdk` driver used to emit a `{ type: "error" }` agent-event from
+  `failTurn()` _before_ its `onAuthError` self-heal callback decided
+  whether the credential could be refreshed. The runner forwarded every
+  such event to the platform, so users saw a flash of `Failed to
+authenticate. API Error: 401` even on every successful self-heal.
+  `failTurn()` now suppresses the downstream emission when the failure
+  is an `AuthError` on the first attempt AND an `onAuthError` callback is
+  configured; the event is emitted only if the self-heal callback returns
+  failure (or throws), or if the retry's own `failTurn` runs. Every auth
+  failure still produces exactly one downstream `error` event — none on
+  silent recovery, one on terminal failure.
+
+  **Runner: proactive AI-credential refresh.** New
+  `createAiCredentialRefreshScheduler` factory in
+  `runner/src/ai-credential-refresh.ts`. After the initial Claude Code
+  credentials blob lands at `session_init`, the runner parses
+  `claudeAiOauth.expiresAt`, schedules a single `setTimeout` to fire 5
+  minutes before expiry, and on fire calls
+  `host.refresh_credential { reason: 'refresh' }` via the existing
+  mediator path. Successful mints (proactive or reactive retry-401) chain
+  the next fire. Static tokens (`expiresAt: null`) and standalone CLI
+  sessions short-circuit to no-op. The reactive retry-401 path stays as
+  the safety net. Cancelled in `cleanup()` so SIGTERM / hibernate does
+  not leak the timer.
+
+  The new helper `extractClaudeAiOauthExpiresAt(json)` is exported from
+  the runner for callers that need to inspect the credentials blob
+  without persisting it.
+
+  Pair with the platform-side enablement of `SKAILE_AIP_AUTO_REFRESH` to
+  also pre-warm the platform's credential cache every 15 minutes; the
+  runner's proactive timer is the primary defence against in-container
+  401s and is independent of that flag.
+
 ## 0.10.1
 
 ### Patch Changes

package/dist/base-assets/connectors/flow/run-flow.js

@@ -1,4 +1,4 @@
-export { resumeFlow, runFlow } from '../../../chunk-IFRUVHOQ.js';
+export { resumeFlow, runFlow } from '../../../chunk-ZLLUIIZR.js';
 import '../../../chunk-GCJXPUHG.js';
 import '../../../chunk-IPUYL6TD.js';
 import '../../../chunk-UHSC75L7.js';

package/dist/bridge/drivers/claude-sdk.js

@@ -1,7 +1,7 @@
 import { classifyClaudeSdkError, AuthError } from '../../chunk-EWP5HZBV.js';
 import { fetchProviderModels } from '../../chunk-KOVLSBXK.js';
 import { dispatchCapability } from '../../chunk-RRVQAE5D.js';
-import { registerDriver, DRIVER_CATALOG, AgentDriver, getBridgeLogger } from '../../chunk-S7RACIZI.js';
+import { registerDriver, DRIVER_CATALOG, AgentDriver, getBridgeLogger } from '../../chunk-YOFKTALB.js';
 import '../../chunk-24UIWON4.js';
 import '../../chunk-NSBPE2FW.js';
 import { spawnSync } from 'child_process';
@@ -237,6 +237,17 @@ var ClaudeSdkDriver = class extends AgentDriver {
   turnReject = null;
   /** Guards against duplicate agent_end emissions per turn. */
   turnCompleted = false;
+  /**
+   * Mirror of the `_retryCount` argument of the in-flight {@link prompt} call.
+   * Read by {@link failTurn} to decide whether to defer the `agent-event:
+   * error` emission for a self-healable auth error. `0` means "first
+   * attempt"; `prompt()` increments to `1` before recursing on its
+   * `onAuthError` self-heal branch.
+   *
+   * Set unconditionally at the top of every {@link prompt} invocation; never
+   * reset elsewhere — the next call's set is the only legitimate transition.
+   */
+  currentRetryCount = 0;
   /** Tracks whether a session has been started (for continue: true). */
   hasSession = false;
   /** Session ID from the SDK — used for streamInput messages. */
@@ -313,6 +324,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
    * occurs after a container crash that prevented the SDK from flushing its session file.
    */
   async prompt(message, _retryCount = 0) {
+    this.currentRetryCount = _retryCount;
     if (!this.sdk) await this.start();
     let retrying = false;
     if (_retryCount === 0) this._lastTokens = null;
@@ -439,6 +451,18 @@ var ClaudeSdkDriver = class extends AgentDriver {
           retrying = true;
           return this.prompt(message, _retryCount + 1);
         }
+        try {
+          this.emit("agent-event", {
+            type: "error",
+            error: err.message,
+            detail: err.detail
+          });
+        } catch (emitErr) {
+          this.log.warn(
+            "agent-event listener threw during deferred auth-error surfacing; suppressing",
+            { error: emitErr instanceof Error ? emitErr.message : String(emitErr) }
+          );
+        }
       }
       throw err;
     } finally {
@@ -761,6 +785,17 @@ var ClaudeSdkDriver = class extends AgentDriver {
    * caller transitions even if the listener chain misbehaves; the emit is
    * wrapped in try/catch so a listener failure cannot leak out.
    *
+   * Self-heal deferral: when the failure is an {@link AuthError} on the
+   * first attempt (`currentRetryCount === 0`) AND the caller wired an
+   * `onAuthError` callback, the downstream `agent-event: error` emission
+   * is deferred. The rejected turn promise still travels to {@link prompt}'s
+   * catch block where the self-heal runs; if the retry succeeds the user
+   * never sees a 401, if the retry fails the second `failTurn` call (now
+   * with `currentRetryCount === 1`) emits the error normally. This stops
+   * the historical "401 flashes in the UI even though self-heal worked"
+   * misbehaviour where the bridge emitted the error event before the
+   * retry decision was known.
+   *
    * Spec: `_devlog/specs/2026-05-07-unified-credential-mediation.md`
    * § "Runner-side handling on 401" (the AI 401 mediation path that
    * exposed this hang).
@@ -771,6 +806,12 @@ var ClaudeSdkDriver = class extends AgentDriver {
       this.turnResolve = null;
       this.turnReject = null;
     }
+    this.turnCompleted = true;
+    const willSelfHeal = err instanceof AuthError && this.currentRetryCount === 0 && this.config.onAuthError != null;
+    if (willSelfHeal) {
+      this.log.info("deferring auth-error event; self-heal will attempt refresh");
+      return;
+    }
     try {
       this.emit("agent-event", {
         type: "error",