@skaile/workspaces 1.14.1 → 1.15.1

package/dist/{chunk-ZWPXSHMW.js → chunk-EKGB4ZWR.js}

@@ -1,20 +1,20 @@
-import { WorkspacePlugin } from './chunk-CS6NFRNQ.js';
-import { WebSocketServerTransport } from './chunk-WQ7DE5UC.js';
+import { WorkspacePlugin } from './chunk-MJEUK6VJ.js';
 import { assembleSystemPrompt, buildCapabilitiesPromptSection } from './chunk-W3UDISS2.js';
-import { EventNormalizer } from './chunk-G73FOLLO.js';
+import { WebSocketServerTransport } from './chunk-WQ7DE5UC.js';
+import { EventNormalizer } from './chunk-M5GJT3D7.js';
 import { SUPPORTED_CLOUDS, CLOUD_SECRET_ENV_KEYS } from './chunk-ISQWMBKD.js';
 import { classifyClaudeSdkError } from './chunk-GAH4YRCI.js';
-import { createDriver } from './chunk-HLIN4HRK.js';
+import { createDriver } from './chunk-ACWCVB5Q.js';
 import { deployCatalogEntry, undeployCatalogEntry } from './chunk-LV2HPH3C.js';
 import { registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, ConnectorStartupError, buildSdkConnectorTools, buildSdkFlowTools } from './chunk-MTM6C7IS.js';
 import { loadConnectorDeclarations, SecretProviderChain, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, isKnownSecretRef, deriveSingleMaterializedConnectorDeclaration } from './chunk-2TSSCHCQ.js';
 import { renderStimulusPrompt, buildOrchestratorPrompt } from './chunk-3EBFDMZC.js';
-import { PROTOCOL_VERSION } from './chunk-TSB46BHR.js';
+import { PROTOCOL_VERSION } from './chunk-RDE43ORT.js';
 import { resolveSettings, resolveApiKey, providerEnvKey } from './chunk-5NZ56R63.js';
+import { resolveDriverPaths } from './chunk-K5GBV4SA.js';
 import { resolveRuntimeAssets } from './chunk-7J7LQP6T.js';
 import { resolveSkWorkspaceConfig, resolveAgentDir, cloudConfigFromProfile, stageMaterializedSkills, loadMcpServerDeclarations, COMPACTION_DEFAULTS, validateAssetRecipeAttr, deriveSingleMaterializedMcpDeclaration } from './chunk-ISA7R7PK.js';
 import { parseAssetRef } from './chunk-GEEW6SY2.js';
-import { resolveDriverPaths } from './chunk-K5GBV4SA.js';
 import { getLogStore, resolveLogStoreConfig, createLogStoreFromConfig, OnLogBridgeSink, WsLogSink, registerLogStore, resetLogStore, createLogger } from './chunk-JB35MVBN.js';
 import { __require } from './chunk-NSBPE2FW.js';
 import pc from 'picocolors';
@@ -4392,6 +4392,155 @@ function planFlowMutate(cmd, ctx) {
   }
   return { kind: "dispatch", dispatchId };
 }
+var DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS = 8e3;
+function resolveFlowMutateConnectorWaitMs(env = process.env) {
+  const parsed = Number.parseInt(env.SKAILE_FLOW_MUTATE_CONNECTOR_WAIT_MS ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS;
+}
+function createFlowConnectorReadiness(isReady) {
+  const waiters = [];
+  return {
+    wait(timeoutMs, isSatisfied) {
+      const satisfied = isSatisfied ?? isReady;
+      if (satisfied()) return Promise.resolve(true);
+      return new Promise((resolve4) => {
+        let timer;
+        const waiter = {
+          satisfied,
+          release: () => {
+            clearTimeout(timer);
+            resolve4(true);
+          }
+        };
+        timer = setTimeout(() => {
+          const idx = waiters.indexOf(waiter);
+          if (idx >= 0) waiters.splice(idx, 1);
+          resolve4(false);
+        }, timeoutMs);
+        timer.unref?.();
+        waiters.push(waiter);
+      });
+    },
+    drain() {
+      for (const waiter of waiters.splice(0)) {
+        if (waiter.satisfied()) waiter.release();
+        else waiters.push(waiter);
+      }
+    },
+    pending: () => waiters.length
+  };
+}
+function validateInputResponse(schema, response) {
+  if (!schema || typeof schema !== "object") return true;
+  switch (schema.kind) {
+    case "text":
+      return typeof response === "string";
+    case "choice": {
+      const ids = new Set((Array.isArray(schema.options) ? schema.options : []).map((o) => o?.id));
+      if (schema.multiple) {
+        return Array.isArray(response) && response.every((v) => typeof v === "string" && ids.has(v));
+      }
+      return typeof response === "string" && ids.has(response);
+    }
+    case "form": {
+      if (!response || typeof response !== "object" || Array.isArray(response)) return false;
+      const value = response;
+      for (const field of Array.isArray(schema.fields) ? schema.fields : []) {
+        if (!field?.id) continue;
+        const v = value[field.id];
+        if (field.required && (v === void 0 || v === null || v === "")) return false;
+        if (v === void 0 || v === null) continue;
+        if (field.type === "number" && typeof v !== "number") return false;
+        if (field.type === "boolean" && typeof v !== "boolean") return false;
+        if (field.type === "choice" && Array.isArray(field.options) && field.options.length > 0) {
+          if (!field.options.some((o) => o?.id === v)) return false;
+        }
+      }
+      return true;
+    }
+    case "file":
+      return Array.isArray(response) || typeof response === "object" && response !== null;
+    default:
+      return true;
+  }
+}
+function reconcilePendingDecisions(execution, pending) {
+  const toApply = [];
+  const reconciled = { applied: [], skipped: [] };
+  if (!Array.isArray(pending)) return { toApply, reconciled };
+  const nodes = execution?.nodes ?? {};
+  for (const raw of pending) {
+    if (!raw || typeof raw !== "object") continue;
+    const entry = raw;
+    const nodeId = typeof entry.nodeId === "string" && entry.nodeId ? entry.nodeId : null;
+    const kind = entry.kind;
+    if (kind !== "approval" && kind !== "input") {
+      if (nodeId) reconciled.skipped.push({ nodeId, reason: "payload_invalid" });
+      continue;
+    }
+    if (!nodeId) continue;
+    const node = nodes[nodeId];
+    if (!node) {
+      reconciled.skipped.push({ nodeId, reason: "unknown_node" });
+      continue;
+    }
+    const wantStatus = kind === "approval" ? "awaiting_approval" : "awaiting_input";
+    if (node.status !== wantStatus) {
+      reconciled.skipped.push({ nodeId, reason: "not_parked" });
+      continue;
+    }
+    const decidedAt = kind === "approval" ? node.approval?.decidedAt : node.input?.providedAt;
+    if (decidedAt != null) {
+      reconciled.skipped.push({ nodeId, reason: "already_decided" });
+      continue;
+    }
+    if (kind === "approval") {
+      const decision = entry.decision;
+      if (decision !== "approved" && decision !== "rejected") {
+        reconciled.skipped.push({ nodeId, reason: "payload_invalid" });
+        continue;
+      }
+      toApply.push({
+        kind: "approval",
+        nodeId,
+        decision,
+        decidedBy: typeof entry.decidedBy === "string" ? entry.decidedBy : "user",
+        ...typeof entry.feedback === "string" ? { feedback: entry.feedback } : {}
+      });
+    } else {
+      if (!validateInputResponse(node.input?.schema, entry.response)) {
+        reconciled.skipped.push({ nodeId, reason: "payload_invalid" });
+        continue;
+      }
+      toApply.push({
+        kind: "input",
+        nodeId,
+        response: entry.response,
+        providedBy: typeof entry.providedBy === "string" ? entry.providedBy : "user"
+      });
+    }
+    reconciled.applied.push(nodeId);
+  }
+  return { toApply, reconciled };
+}
+function pendingDecisionOp(decision) {
+  return decision.kind === "approval" ? {
+    op: "applyApproval",
+    payload: {
+      nodeId: decision.nodeId,
+      decision: decision.decision,
+      decidedBy: decision.decidedBy,
+      ...decision.feedback !== void 0 ? { feedback: decision.feedback } : {}
+    }
+  } : {
+    op: "applyInput",
+    payload: {
+      nodeId: decision.nodeId,
+      response: decision.response,
+      providedBy: decision.providedBy
+    }
+  };
+}
 function hostOpResumeStimulus(op, payload) {
   switch (op) {
     case "applyApproval":
@@ -4419,6 +4568,142 @@ function hostOpResumeStimulus(op, payload) {
       return null;
   }
 }
+async function executeConnectorMutate(cmd, deps) {
+  let acked = false;
+  const respond = (r) => {
+    if (!cmd.requestId || acked) return;
+    acked = true;
+    deps.sendEvent({ type: "connector_mutate_response", requestId: cmd.requestId, ...r });
+  };
+  try {
+    await deps.sessionReady;
+  } catch (err) {
+    const message = `Session not available: ${err.message}`;
+    deps.sendEvent({ type: "error", message, fatal: true });
+    respond({ ok: false, code: "session_unavailable", error: message });
+    return;
+  }
+  const payload = cmd.payload ?? {};
+  const planContext = () => {
+    const targetExists = deps.hasConnector(cmd.id);
+    const state = deps.flowState();
+    return {
+      targetExists,
+      isExistingFlow: targetExists && deps.isFlowConnector(cmd.id),
+      hasActiveFlow: state.hasActiveFlow,
+      hasRunningFlow: state.hasRunningFlow,
+      onlyActiveConnectorId: state.activeFlow?.connectorId ?? null
+    };
+  };
+  try {
+    deps.assertResourcesReady();
+    let plan = planFlowMutate(cmd, planContext());
+    const flowTargeted = cmd.id === "flow" || cmd.id.startsWith("flow:");
+    if (plan.kind === "dispatch" && flowTargeted && !deps.hasConnector(plan.dispatchId)) {
+      const ready = await deps.waitForFlowConnector(
+        deps.connectorWaitMs,
+        cmd.id === "flow" ? void 0 : () => deps.hasConnector(cmd.id)
+      );
+      if (!ready) {
+        deps.log.warn("connector_mutate timed out waiting for the flow connector", {
+          id: cmd.id,
+          op: cmd.op,
+          waitedMs: deps.connectorWaitMs
+        });
+        respond({
+          ok: false,
+          code: "connector_unavailable",
+          error: `Connector not found: "${cmd.id}" (waited ${deps.connectorWaitMs}ms)`
+        });
+        return;
+      }
+      plan = planFlowMutate(cmd, planContext());
+    }
+    switch (plan.kind) {
+      case "create-start": {
+        const entry = await deps.createActiveFlow(plan.flowDef, { seed: plan.seed });
+        deps.log.info("connector_mutate flow.start", {
+          runId: entry.runId,
+          flowId: plan.flowDef.id
+        });
+        respond({ ok: true });
+        deps.signalStimulus(entry, { kind: "flow_started" });
+        return;
+      }
+      case "create-hydrate": {
+        const entry = await deps.createActiveFlow(plan.flowDef, { execution: plan.execution });
+        deps.log.info("connector_mutate flow.hydrate (bootstrap)", {
+          runId: entry.runId,
+          flowId: plan.flowDef.id
+        });
+        if (payload.pendingDecisions === void 0) {
+          respond({ ok: true });
+          return;
+        }
+        const { toApply, reconciled } = reconcilePendingDecisions(
+          plan.execution,
+          payload.pendingDecisions
+        );
+        let lastApplied = null;
+        const applied = [];
+        for (const decision of toApply) {
+          const { op, payload: opPayload } = pendingDecisionOp(decision);
+          try {
+            await deps.executeOp(entry.connectorId, op, opPayload);
+            applied.push(decision.nodeId);
+            const stimulus = hostOpResumeStimulus(op, opPayload);
+            if (stimulus) lastApplied = { target: entry, stimulus };
+          } catch (err) {
+            reconciled.skipped.push({ nodeId: decision.nodeId, reason: "not_parked" });
+            deps.log.warn("flow hydrate reconciliation refused", {
+              nodeId: decision.nodeId,
+              op,
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }
+        }
+        reconciled.applied = applied;
+        respond({ ok: true, reconciled });
+        if (lastApplied) deps.signalStimulus(lastApplied.target, lastApplied.stimulus);
+        return;
+      }
+      case "reject": {
+        deps.log.warn("connector_mutate rejected", {
+          id: cmd.id,
+          op: cmd.op,
+          reason: plan.reason
+        });
+        deps.sendEvent({
+          type: "error",
+          message: `connector_mutate rejected (id=${cmd.id}, op=${cmd.op}): ${plan.reason}`,
+          fatal: false,
+          category: "validation"
+        });
+        respond({ ok: false, code: "rejected", error: plan.reason });
+        return;
+      }
+      case "dispatch": {
+        const result = await deps.executeOp(plan.dispatchId, cmd.op, payload);
+        const ignoredReplay = cmd.op === "hydrate" && payload.pendingDecisions !== void 0;
+        respond({
+          ok: true,
+          ...result !== void 0 && result !== null ? { result } : {},
+          ...ignoredReplay ? { reconciled: { applied: [], skipped: [] } } : {}
+        });
+        const resumeStimulus = hostOpResumeStimulus(cmd.op, payload);
+        if (resumeStimulus) {
+          const active = deps.flowState().activeFlow;
+          if (active) deps.signalStimulus(active, resumeStimulus);
+        }
+        return;
+      }
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    deps.log.warn("connector_mutate failed", { id: cmd.id, op: cmd.op, error: message });
+    respond({ ok: false, code: "op_failed", error: message });
+  }
+}
 function reconstructTypedStimulus(meta) {
   switch (meta.kind) {
     case "flow_started":
@@ -4983,6 +5268,8 @@ async function startAgentServer(opts) {
     const iter = activeFlows.values().next();
     return iter.done ? null : iter.value;
   }
+  const flowConnectorReadiness = createFlowConnectorReadiness(() => getOnlyActiveFlow() !== null);
+  const flowMutateConnectorWaitMs = resolveFlowMutateConnectorWaitMs();
   function getOrCreateStimulusBus() {
     if (stimulusBus) return stimulusBus;
     stimulusBus = createSessionStimulusBus({
@@ -5118,6 +5405,7 @@ async function startAgentServer(opts) {
     const entry = { runId, flowDef, adapter, handle, connectorId };
     const pruned = registerActiveFlow(activeFlows, runId, entry);
     if (pruned.length > 0) serverLog.debug("pruned terminal flow runs", { runIds: pruned });
+    flowConnectorReadiness.drain();
     return entry;
   }
   const refreshFlagPath = join(opts.projectDir, ".skaile", "refresh-request");
@@ -5787,98 +6075,46 @@ async function startAgentServer(opts) {
     void handleResourceRequest(cmd, resourceManager, sendEvent);
   }
   async function handleConnectorMutate(cmd) {
-    try {
-      await sessionReady;
-    } catch (err) {
-      sendEvent({
-        type: "error",
-        message: `Session not available: ${err.message}`,
-        fatal: true
-      });
-      return;
-    }
-    try {
-      if (!resourceManager) throw new Error("connector_mutate before resources ready");
-      const targetEntry = resourceManager.has?.(cmd.id) ? resourceManager.get(cmd.id) : null;
-      const isExistingFlow = targetEntry?.connector?.name === "flow";
-      const plan = planFlowMutate(cmd, {
-        targetExists: !!targetEntry,
-        isExistingFlow,
-        hasActiveFlow: activeFlows.size > 0,
-        hasRunningFlow: hasNonTerminalFlow(activeFlows.values()),
-        onlyActiveConnectorId: getOnlyActiveFlow()?.connectorId ?? null
-      });
-      switch (plan.kind) {
-        case "create-start": {
-          const entry = await createActiveFlow(plan.flowDef, { seed: plan.seed });
-          serverLog.info("connector_mutate flow.start", {
-            runId: entry.runId,
-            flowId: plan.flowDef.id
-          });
-          const startStimulus = { kind: "flow_started" };
-          void getOrCreateStimulusBus().signal(entry.connectorId, {
-            promptFragment: renderStimulusPrompt(startStimulus),
-            meta: { kind: startStimulus.kind, runId: entry.runId }
-          }).catch((err) => {
-            serverLog.warn("flow_started turn failed", {
-              runId: entry.runId,
-              error: err instanceof Error ? err.message : String(err)
-            });
-          });
-          return;
-        }
-        case "create-hydrate": {
-          const entry = await createActiveFlow(plan.flowDef, { execution: plan.execution });
-          serverLog.info("connector_mutate flow.hydrate (bootstrap)", {
-            runId: entry.runId,
-            flowId: plan.flowDef.id
-          });
-          return;
-        }
-        case "reject": {
-          serverLog.warn("connector_mutate rejected", {
-            id: cmd.id,
-            op: cmd.op,
-            reason: plan.reason
-          });
-          sendEvent({
-            type: "error",
-            message: `connector_mutate rejected (id=${cmd.id}, op=${cmd.op}): ${plan.reason}`,
-            fatal: false,
-            category: "validation"
+    await executeConnectorMutate(cmd, {
+      sessionReady,
+      sendEvent,
+      assertResourcesReady: () => {
+        if (!resourceManager) throw new Error("connector_mutate before resources ready");
+      },
+      hasConnector: (id) => resourceManager?.has?.(id) ?? false,
+      isFlowConnector: (id) => resourceManager?.has?.(id) === true && resourceManager.get(id).connector?.name === "flow",
+      executeOp: (id, op, args) => {
+        if (!resourceManager) throw new Error("connector_mutate before resources ready");
+        return resourceManager.executeOp(id, op, args);
+      },
+      flowState: () => {
+        const active = getOnlyActiveFlow();
+        return {
+          hasActiveFlow: activeFlows.size > 0,
+          hasRunningFlow: hasNonTerminalFlow(activeFlows.values()),
+          activeFlow: active ? { runId: active.runId, connectorId: active.connectorId } : null
+        };
+      },
+      createActiveFlow: async (flowDef, seedOrExecution) => {
+        const entry = await createActiveFlow(flowDef, seedOrExecution);
+        return { runId: entry.runId, connectorId: entry.connectorId };
+      },
+      waitForFlowConnector: (timeoutMs, isSatisfied) => flowConnectorReadiness.wait(timeoutMs, isSatisfied),
+      connectorWaitMs: flowMutateConnectorWaitMs,
+      signalStimulus: (target, stimulus) => {
+        void getOrCreateStimulusBus().signal(target.connectorId, {
+          promptFragment: renderStimulusPrompt(stimulus),
+          meta: { ...stimulus, runId: target.runId }
+        }).catch((err) => {
+          serverLog.warn("flow turn kick failed", {
+            kind: stimulus.kind,
+            runId: target.runId,
+            error: err instanceof Error ? err.message : String(err)
           });
-          return;
-        }
-        case "dispatch": {
-          await resourceManager.executeOp(plan.dispatchId, cmd.op, cmd.payload ?? {});
-          const resumeStimulus = hostOpResumeStimulus(cmd.op, cmd.payload ?? {});
-          if (resumeStimulus) {
-            const entry = getOnlyActiveFlow();
-            if (entry) {
-              void getOrCreateStimulusBus().signal(entry.connectorId, {
-                promptFragment: renderStimulusPrompt(resumeStimulus),
-                meta: {
-                  ...resumeStimulus,
-                  runId: entry.runId
-                }
-              }).catch((err) => {
-                serverLog.warn("host-op resume turn failed", {
-                  op: cmd.op,
-                  error: err instanceof Error ? err.message : String(err)
-                });
-              });
-            }
-          }
-          return;
-        }
-      }
-    } catch (err) {
-      serverLog.warn("connector_mutate failed", {
-        id: cmd.id,
-        op: cmd.op,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
+        });
+      },
+      log: serverLog
+    });
   }
   async function handleConnectorQuery(cmd) {
     try {
@@ -6330,6 +6566,6 @@ function touchSession(state) {
   return { ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
 }
 
-export { CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, MarkdownStreamer, PreInitRingSink, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, capabilityLogInstance, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, connectorRefreshKind, createAgentSession, createSessionStimulusBus, defineCapability, deleteSession, dispatchRunnerCapabilityInvocation, emitSystemPromptComposed, ensureGitConfigInclude, extractClaudeAiOauthExpiresAt, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isTerminalFlowStatus, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadSession, loadSessionById, mcpAuthSecretKey, newSession, pickRepointedManager, planFlowMutate, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveMixin, runAgentChat, saveSession, setCurrentSession, startAgentServer, stimulusFromMetas, touchSession, writeClaudeCodeCredentialsFile };
-//# sourceMappingURL=chunk-ZWPXSHMW.js.map
-//# sourceMappingURL=chunk-ZWPXSHMW.js.map
+export { CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS, MarkdownStreamer, PreInitRingSink, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, capabilityLogInstance, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, connectorRefreshKind, createAgentSession, createFlowConnectorReadiness, createSessionStimulusBus, defineCapability, deleteSession, dispatchRunnerCapabilityInvocation, emitSystemPromptComposed, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isTerminalFlowStatus, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadSession, loadSessionById, mcpAuthSecretKey, newSession, pickRepointedManager, planFlowMutate, reconcilePendingDecisions, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveMixin, runAgentChat, saveSession, setCurrentSession, startAgentServer, stimulusFromMetas, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile };
+//# sourceMappingURL=chunk-EKGB4ZWR.js.map
+//# sourceMappingURL=chunk-EKGB4ZWR.js.map