@skaile/workspaces 3.2.1 → 3.4.0

package/dist/{chunk-BEA7RXI3.js → chunk-P6V5GORE.js}

@@ -1,16 +1,16 @@
-import { resolveAuthRef } from './chunk-ZNIHTT22.js';
-import { EventNormalizer } from './chunk-KPZZI2KG.js';
+import { resolveAuthRef } from './chunk-AXFOJ2UG.js';
+import { EventNormalizer } from './chunk-ZCIK44M7.js';
 import { resolveModelTier } from './chunk-V34ZEXSE.js';
-import { createDriver } from './chunk-VT6HDD2L.js';
+import { createDriver } from './chunk-SUGDZOYZ.js';
 import { pluginRegistry } from './chunk-6E6PKKAD.js';
 import { computeStimulus } from './chunk-IFGTRL2I.js';
-import { resolveNodeBindings, getConsumedOutputSchema, validateConsumedNodeOutput, appendAttempt, resolveTerminalFailureStatus, remainingActiveExecutionMs, interpolateNodeInstruction, deriveCheckEvidence, computeFlowStateFromSnapshots, availableRouterFrontier, evaluateRouterSelection, routerSelectionOutput, planRouterSkips, unsettledRouterBranchIds, countFailedAttempts, hasAutomaticRetryBudget, persistedRouterSelection } from './chunk-I7S6DFRU.js';
+import { resolveNodeBindings, getConsumedOutputSchema, validateConsumedNodeOutput, appendAttempt, resolveTerminalFailureStatus, remainingActiveExecutionMs, interpolateNodeInstruction, deriveCheckEvidence, computeFlowStateFromSnapshots, availableRouterFrontier, evaluateRouterSelection, routerSelectionOutput, planRouterSkips, unsettledRouterBranchIds, countFailedAttempts, hasAutomaticRetryBudget, persistedRouterSelection } from './chunk-3Q7JDLLH.js';
 import { parseFlowDefinition } from './chunk-B4J6TV4G.js';
-import { renderSubpromptPrompt, renderStimulusPrompt } from './chunk-FLBDLF3I.js';
-import { deterministicNodeKindLabel, flowDefaults, isAgentNode, isGateNode, isCheckNode, nodeRequiresApproval, isSubFlowNode, isFunctionNode, isSubpromptNode, nodeInstruction, isRouterNode, isActiveRuntimeNode, nodeIsOptional, nodeLabel, nodeAssets } from './chunk-F5VREBV2.js';
-import { portableSpawn } from './chunk-P43HBWKK.js';
-import { withFsDeadline, tryWithFsDeadline, FsDeadlineError, fsDeadlineMs } from './chunk-DYMWJAL4.js';
-import { createLogger } from './chunk-7GOCNYUV.js';
+import { renderSubpromptPrompt, renderStimulusPrompt } from './chunk-HGFKNJA5.js';
+import { deterministicNodeKindLabel, flowDefaults, isAgentNode, isGateNode, isCheckNode, nodeRequiresApproval, isSubFlowNode, isFunctionNode, isSubpromptNode, nodeInstruction, isRouterNode, isActiveRuntimeNode, nodeIsOptional, nodeLabel, nodeAssets } from './chunk-ELPR5XBG.js';
+import { portableSpawn } from './chunk-6BV24JPZ.js';
+import { withFsDeadline, tryWithFsDeadline, FsDeadlineError, fsDeadlineMs } from './chunk-VQ4P7UYE.js';
+import { createLogger } from './chunk-3A5IKBHQ.js';
 import { resolve, relative, sep, isAbsolute, join, dirname } from 'path';
 import { mkdir, rename, writeFile, readFile, stat, cp, readdir, chmod, realpath } from 'fs/promises';
 import * as z4 from 'zod';
@@ -346,6 +346,28 @@ function commandFor(node) {
       return ["python3", "-c", node.run.command];
   }
 }
+var ABORT_SIGKILL_GRACE_MS = 2e3;
+function abortError(nodeLabel2) {
+  const error = new Error(`${nodeLabel2} was aborted`);
+  error.name = "AbortError";
+  return error;
+}
+var liveDetachedChildren = /* @__PURE__ */ new Set();
+var shutdownSweepInstalled = false;
+function sweepOnShutdown(child) {
+  liveDetachedChildren.add(child);
+  void child.exited.then(() => liveDetachedChildren.delete(child));
+  if (shutdownSweepInstalled) return;
+  shutdownSweepInstalled = true;
+  globalThis.process.once("exit", () => {
+    for (const live of liveDetachedChildren) {
+      try {
+        live.kill("SIGKILL");
+      } catch {
+      }
+    }
+  });
+}
 var SessionNodeExecutor = class {
   workspaceDir;
   /** Creates an executor scoped to one already-materialized session workspace. */
@@ -353,7 +375,7 @@ var SessionNodeExecutor = class {
     this.workspaceDir = resolve(options.workspaceDir);
   }
   /** Runs one function or check node process with session environment and binding overrides. */
-  async execute(request) {
+  async execute(request, options) {
     const nodeLabel2 = `${deterministicNodeKindLabel(request.node.run.kind)} node ${request.node.id}`;
     const cwd = resolve(this.workspaceDir, request.node.run.cwd ?? ".");
     const workspaceRelative = relative(this.workspaceDir, cwd);
@@ -366,16 +388,35 @@ var SessionNodeExecutor = class {
         serializeEnvironmentInput(name, value, nodeLabel2)
       ])
     );
+    const signal = options?.signal;
+    if (signal?.aborted) throw abortError(nodeLabel2);
     const process2 = portableSpawn(commandFor(request.node), {
       cwd,
-      env: { ...globalThis.process.env, ...boundEnvironment }
+      env: { ...globalThis.process.env, ...boundEnvironment },
+      detached: true
     });
-    const [stdout, stderr, exitStatus] = await Promise.all([
-      new Response(process2.stdout).text(),
-      new Response(process2.stderr).text(),
-      process2.exited
-    ]);
-    return { exitStatus, stdout, stderr };
+    sweepOnShutdown(process2);
+    let aborted = false;
+    let escalation;
+    const onAbort = () => {
+      aborted = true;
+      process2.kill("SIGTERM");
+      escalation = setTimeout(() => process2.kill("SIGKILL"), ABORT_SIGKILL_GRACE_MS);
+      escalation.unref?.();
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      const [stdout, stderr, exitStatus] = await Promise.all([
+        new Response(process2.stdout).text(),
+        new Response(process2.stderr).text(),
+        process2.exited
+      ]);
+      if (aborted) throw abortError(nodeLabel2);
+      return { exitStatus, stdout, stderr };
+    } finally {
+      if (escalation) clearTimeout(escalation);
+      signal?.removeEventListener("abort", onAbort);
+    }
   }
 };
 
@@ -7584,6 +7625,18 @@ function raceWithTimeout(promise, ms, timeoutMessage) {
     );
   });
 }
+var ABORTED_ATTEMPT_SETTLE_MS = ABORT_SIGKILL_GRACE_MS + 1e3;
+function settleWithin(promise, ms) {
+  return new Promise((resolve6) => {
+    const timer = setTimeout(resolve6, ms);
+    timer.unref?.();
+    const settled = () => {
+      clearTimeout(timer);
+      resolve6();
+    };
+    promise.then(settled, settled);
+  });
+}
 function mergeInteractionHistory(history, interaction) {
   if (!interaction) return history;
   const next = [...history];
@@ -8799,6 +8852,7 @@ var FlowAdapter = class extends AbstractConnector {
   }
   async drainAvailableRuntimeNodes(handle, includeRoutersAndGates) {
     const advancedSubFlows = /* @__PURE__ */ new Set();
+    let abortedAttempt;
     while (true) {
       const state = this.s(handle);
       if (state.execution.status === "cancelled" || state.execution.status === "failed") break;
@@ -8874,7 +8928,7 @@ var FlowAdapter = class extends AbstractConnector {
             state.flowInputOrigins
           );
           subFlowInputOrigins = resolved.origins;
-          const runPromise = runner.run({
+          const runPromise2 = runner.run({
             node,
             flowId: node.run.flow,
             inputs: resolved.values,
@@ -8892,10 +8946,10 @@ var FlowAdapter = class extends AbstractConnector {
             }
           });
           result = remainingMs !== void 0 ? await raceWithTimeout(
-            runPromise,
+            runPromise2,
             Math.max(0, remainingMs),
             `Sub-flow node ${node.id} timed out after ${timeoutSec}s`
-          ) : await runPromise;
+          ) : await runPromise2;
         } catch (error) {
           if (error instanceof NodeTimeoutError) {
             const target = state.inlineOperationTargets.get(node.id);
@@ -9015,17 +9069,17 @@ var FlowAdapter = class extends AbstractConnector {
             interpolateNodeInstruction(instruction, resolved.values),
             outputSchema
           );
-          const runPromise = runner.execute({
+          const runPromise2 = runner.execute({
             node,
             prompt,
             inputs: resolved.values,
             inputOrigins: resolved.origins
           });
           const result = subpromptRemainingMs !== void 0 ? await raceWithTimeout(
-            runPromise,
+            runPromise2,
             Math.max(0, subpromptRemainingMs),
             `Subprompt node ${node.id} timed out after ${subpromptTimeoutSec}s`
-          ) : await runPromise;
+          ) : await runPromise2;
           subpromptOutput = subpromptNodeOutput(node, result.text);
           const validation = validateConsumedNodeOutput(
             state.flowDef,
@@ -9099,6 +9153,12 @@ var FlowAdapter = class extends AbstractConnector {
         continue;
       }
       if (!isFunctionNode(node) && !isCheckNode(node)) continue;
+      if (abortedAttempt) {
+        const settling = abortedAttempt;
+        abortedAttempt = void 0;
+        await settleWithin(settling, ABORTED_ATTEMPT_SETTLE_MS);
+        continue;
+      }
       this.mutate(
         handle,
         (current) => {
@@ -9129,6 +9189,8 @@ var FlowAdapter = class extends AbstractConnector {
       let capturedInputOrigins;
       let checkEvidence;
       let deterministicOutcome;
+      const deterministicAbort = new AbortController();
+      let runPromise;
       try {
         const executor = state.nodeExecutor;
         if (!executor)
@@ -9140,11 +9202,10 @@ var FlowAdapter = class extends AbstractConnector {
           state.flowInputOrigins
         );
         capturedInputOrigins = resolved.origins;
-        const runPromise = executor.execute({
-          node,
-          inputs: resolved.values,
-          inputOrigins: resolved.origins
-        });
+        runPromise = executor.execute(
+          { node, inputs: resolved.values, inputOrigins: resolved.origins },
+          { signal: deterministicAbort.signal }
+        );
         const result = deterministicRemainingMs !== void 0 ? await raceWithTimeout(
           runPromise,
           Math.max(0, deterministicRemainingMs),
@@ -9193,12 +9254,21 @@ var FlowAdapter = class extends AbstractConnector {
           deterministicOutcome = { kind: "success" };
         }
       } catch (error) {
-        deterministicOutcome = error instanceof NodeTimeoutError ? { kind: "failure", message: error.message } : {
-          kind: "failure",
-          message: `${deterministicKindLabel} node ${node.id} failed: ${error instanceof Error ? error.message : String(error)}`
-        };
+        if (error instanceof NodeTimeoutError) {
+          deterministicAbort.abort();
+          abortedAttempt = runPromise;
+          deterministicOutcome = { kind: "failure", message: error.message };
+        } else {
+          deterministicOutcome = {
+            kind: "failure",
+            message: `${deterministicKindLabel} node ${node.id} failed: ${error instanceof Error ? error.message : String(error)}`
+          };
+        }
+      }
+      if (this.s(handle).executionGeneration !== deterministicExecutionGeneration) {
+        deterministicAbort.abort();
+        break;
       }
-      if (this.s(handle).executionGeneration !== deterministicExecutionGeneration) break;
       if (deterministicOutcome.kind === "success") {
         this.mutate(
           handle,
@@ -9717,6 +9787,7 @@ ${targetExecution.outputCorrection.issues.map((issue) => `- ${issue}`).join("\n"
 ${assets.map((asset) => `- ${asset}`).join("\n")}`);
     }
     const deps = flowPredecessors(s.flowDef, nodeId);
+    const supplied = suppliedProducerFields(resolved);
     const handoff = [];
     for (const depId of deps) {
       const exec = s.execution.nodes[depId];
@@ -9729,8 +9800,9 @@ Concerns: ${output.concerns.join("; ")}` : "";
       const predecessor = s.flowDef.nodes.find((n) => n.id === depId);
       const label = predecessor ? nodeLabel(predecessor) : depId;
       const summary = predecessor && isRouterNode(predecessor) ? routerSelectionHandoffSummary(predecessor, exec) ?? output.summary : output.summary;
+      const fields = exec?.status === "complete" ? upstreamFieldsBlock(predecessor, output, supplied) : "";
       handoff.push(`### ${label} (${exec?.status})
-${summary}${artifacts}${concerns}`);
+${summary}${fields}${artifacts}${concerns}`);
     }
     sections.push(
       `## Upstream handoff
@@ -9748,6 +9820,62 @@ function routerSelectionHandoffSummary(router, execution) {
   if (!selection) return void 0;
   return selection.selectedTarget === null ? "Router completed without selecting a target." : `Router selected ${selection.selectedTarget}.`;
 }
+var HANDOFF_FIELD_VALUE_MAX_CHARS = 500;
+var HANDOFF_FIELD_MAX_COUNT = 20;
+function declaredOutputFieldNames(node) {
+  const schema = node?.contract?.output?.fields;
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return [];
+  const properties = schema.properties;
+  if (!properties || typeof properties !== "object" || Array.isArray(properties)) return [];
+  return Object.keys(properties);
+}
+function suppliedProducerFields(resolved) {
+  const supplied = /* @__PURE__ */ new Set();
+  for (const [name, originList] of Object.entries(resolved.origins)) {
+    const serialized = JSON.stringify(resolved.values[name]);
+    if (serialized === void 0) continue;
+    for (const origin of originList) {
+      if (origin.source !== "node-output") continue;
+      const root = origin.path.split(".")[4];
+      if (root) supplied.add(`${origin.nodeId} ${root} ${serialized}`);
+    }
+  }
+  return supplied;
+}
+function upstreamFieldsBlock(predecessor, output, supplied) {
+  const fields = output.fields;
+  if (!predecessor || !fields) return "";
+  const renderable = [];
+  let suppressed = 0;
+  for (const name of declaredOutputFieldNames(predecessor)) {
+    if (!Object.hasOwn(fields, name)) continue;
+    const serialized = JSON.stringify(fields[name]) ?? "null";
+    if (supplied.has(`${predecessor.id} ${name} ${serialized}`)) {
+      suppressed += 1;
+      continue;
+    }
+    renderable.push([name, serialized]);
+  }
+  if (renderable.length === 0) return "";
+  const lines = renderable.slice(0, HANDOFF_FIELD_MAX_COUNT).map(([name, serialized]) => {
+    const value = serialized.length > HANDOFF_FIELD_VALUE_MAX_CHARS ? `${serialized.slice(0, HANDOFF_FIELD_VALUE_MAX_CHARS)} \u2026 [truncated from ${serialized.length} chars]` : serialized;
+    return `- ${name}: ${value}`;
+  });
+  const overflow = renderable.length - lines.length;
+  if (overflow > 0) {
+    lines.push(
+      `- \u2026 ${overflow} more declared field(s) not shown (${HANDOFF_FIELD_MAX_COUNT}-field cap)`
+    );
+  }
+  if (suppressed > 0) {
+    lines.push(
+      `- (${suppressed} declared field(s) omitted \u2014 already shown under "Supplied bindings")`
+    );
+  }
+  return `
+Fields:
+${lines.join("\n")}`;
+}
 function deterministicNodeOutput(node, result, passed) {
   const kindLabel = deterministicNodeKindLabel(node.run.kind);
   const capturedFields = [];
@@ -9770,19 +9898,80 @@ function deterministicNodeOutput(node, result, passed) {
     ...Object.keys(fields).length > 0 ? { fields } : {}
   };
 }
+function findSoleJsonSpan(text) {
+  const spans = [];
+  const stack = [];
+  let spanStart = null;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (stack.length > 0 && char === '"') {
+      inString = true;
+    } else if (char === "{" || char === "[") {
+      if (stack.length === 0) spanStart = i;
+      stack.push(char === "{" ? "}" : "]");
+    } else if (char === "}" || char === "]") {
+      if (stack.length === 0) {
+        return { ambiguity: "a closing bracket appears outside any JSON structure" };
+      }
+      if (stack.pop() !== char) return { ambiguity: "mismatched bracket" };
+      if (stack.length === 0 && spanStart !== null) {
+        spans.push({ text: text.slice(spanStart, i + 1), end: i + 1 });
+        spanStart = null;
+      }
+    }
+  }
+  if (stack.length > 0 || inString) return { ambiguity: "unterminated JSON structure" };
+  if (spans.length > 1) {
+    return {
+      ambiguity: `found ${spans.length} candidate JSON values; refusing to guess which is the answer`
+    };
+  }
+  const sole = spans[0];
+  if (!sole) return {};
+  const afterSpan = text.slice(sole.end);
+  const lineBreak = afterSpan.indexOf("\n");
+  const restOfLine = lineBreak === -1 ? afterSpan : afterSpan.slice(0, lineBreak);
+  if (restOfLine.trim() !== "") {
+    return { ambiguity: "the candidate JSON value is embedded mid-sentence" };
+  }
+  return { span: sole.text };
+}
 function extractSubpromptJsonPayload(text) {
+  const parses = (value) => {
+    try {
+      JSON.parse(value);
+      return true;
+    } catch {
+      return false;
+    }
+  };
   const trimmed = text.trim();
   const fenceMatch = /^```(?:json)?\s*([\s\S]*?)\s*```$/.exec(trimmed);
-  return fenceMatch?.[1] ?? trimmed;
+  const direct = fenceMatch?.[1] ?? trimmed;
+  if (parses(direct)) return { payload: direct };
+  const scan = findSoleJsonSpan(direct);
+  if (scan.span !== void 0) {
+    if (parses(scan.span)) return { payload: scan.span };
+    return { payload: direct, ambiguity: "the sole candidate JSON value did not parse" };
+  }
+  return scan.ambiguity ? { payload: direct, ambiguity: scan.ambiguity } : { payload: direct };
 }
 function subpromptNodeOutput(node, text) {
   const outputSchema = node.contract?.output?.fields;
   if (!outputSchema) return { summary: text.trim(), artifacts: [] };
-  const parsed = safeParseFields(extractSubpromptJsonPayload(text));
+  const extracted = extractSubpromptJsonPayload(text);
+  const parsed = safeParseFields(extracted.payload);
   if (!parsed.fields) {
-    throw new Error(
-      `Subprompt node ${node.id} response is not valid JSON: ${parsed.issues.join("; ")}`
-    );
+    const detail = extracted.ambiguity ? `${parsed.issues.join("; ")} (${extracted.ambiguity})` : parsed.issues.join("; ");
+    throw new Error(`Subprompt node ${node.id} response is not valid JSON: ${detail}`);
   }
   return {
     summary: text.trim(),
@@ -9859,5 +10048,5 @@ function createConnector() {
 }
 
 export { AbstractConnector, BUILTIN_CONNECTOR_CATALOG, BoxConnector, ConnectorFieldMissingError, ConnectorManager, ConnectorStartupError, DeployConnector, DevServerConnector, FlowAdapter, GitConnector, GmailConnector, GoogleDriveConnector, LocalConnector, LogBuffer, ManagedGitconfigCollisionError, MattermostConnector, MemoryConnector, MinIOConnector, PortPool, PostgresConnector, S3Connector, SQLiteConnector, SessionInlineSubFlowRunner, SessionNodeExecutor, SessionSubpromptRunner, SharePointConnector, StaticServerConnector, TunnelConnector, WebDAVConnector, XStateConnector, XStateStoreConnector, __test, atomicReplaceCredential, buildConnectorPromptSection, buildSdkConnectorTools, buildSdkFlowTools, createConnector, createConnector10, createConnector11, createConnector12, createConnector13, createConnector14, createConnector15, createConnector16, createConnector17, createConnector18, createConnector19, createConnector2, createConnector20, createConnector3, createConnector4, createConnector5, createConnector6, createConnector7, createConnector8, createConnector9, createFsWatcher, createWorktree, defaultSpawn, ensureDirMode, ensureFleetMounted, findGitRoot, findMissingPackages, getConnector, installNpmPackages, isFleetManaged, isPackageResolvable, listConnectors, listWorktrees, readGitSyncStatus, registerBuiltinConnectors, removeMountBlock, renderCredentialHelperScript, tryGetConnector, worktreeRegistry, writeHelperScript, writeMountBlock };
-//# sourceMappingURL=chunk-BEA7RXI3.js.map
-//# sourceMappingURL=chunk-BEA7RXI3.js.map
+//# sourceMappingURL=chunk-P6V5GORE.js.map
+//# sourceMappingURL=chunk-P6V5GORE.js.map