@skaile/workspaces 4.27.2 → 4.28.0

package/dist/{chunk-7JC4ZIXJ.js → chunk-G3VT2BCY.js}

@@ -1,17 +1,17 @@
-import { declaredConnectErrorKind, ClassifiedConnectError, withConnectErrorKind } from './chunk-KVWSBQNP.js';
-import { OAuthRequiredError, ConnectorFieldMissingError, LegacyAuthGrammarError, resolveAuthRef, readUnavailableMarker, ConnectorStartupError } from './chunk-YOPE344M.js';
-import { EventNormalizer } from './chunk-BADVX5LG.js';
-import { resolveModelTier } from './chunk-NLUW3IJL.js';
-import { createDriver } from './chunk-IQID7X6P.js';
+import { declaredConnectErrorKind, ClassifiedConnectError, withConnectErrorKind } from './chunk-5UQNCPIP.js';
+import { OAuthRequiredError, ConnectorFieldMissingError, LegacyAuthGrammarError, resolveAuthRef, readUnavailableMarker, ConnectorStartupError } from './chunk-2JANXYTJ.js';
+import { EventNormalizer } from './chunk-Q2AOHZFF.js';
+import { resolveModelTier } from './chunk-X5CW2HDM.js';
+import { createDriver } from './chunk-H5EGBMZ5.js';
 import { pluginRegistry } from './chunk-6E6PKKAD.js';
 import { computeStimulus } from './chunk-IFGTRL2I.js';
 import { interpolateNodeInstruction, resolveNodeBindings, getConsumedOutputSchema, validateConsumedNodeOutput, appendAttempt, resolveTerminalFailureStatus, remainingActiveExecutionMs, deriveCheckEvidence, computeFlowStateFromSnapshots, availableRouterFrontier, evaluateRouterSelection, routerSelectionOutput, planRouterSkips, unsettledRouterBranchIds, countFailedAttempts, hasAutomaticRetryBudget, persistedRouterSelection } from './chunk-KTCMBEEB.js';
 import { INPUT_SCHEMA_SHAPES_HINT, coerceInputSchema } from './chunk-XPDB4O4H.js';
 import { parseFlowDefinition } from './chunk-ALLCAFHQ.js';
 import { describeStimulus, buildOrchestratorPrompt, renderSubpromptPrompt, renderStimulusPrompt } from './chunk-D6YOE2DB.js';
-import { deterministicNodeKindLabel, nodeInstruction, flowDefaults, isAgentNode, isGateNode, isCheckNode, nodeRequiresApproval, isSubFlowNode, isFunctionNode, isSubpromptNode, isRouterNode, isActiveRuntimeNode, nodeIsOptional, nodeLabel, nodeAssets } from './chunk-V4RGCKYC.js';
+import { deterministicNodeKindLabel, nodeInstruction, flowDefaults, isAgentNode, isGateNode, isCheckNode, nodeRequiresApproval, isSubFlowNode, isActiveRuntimeNode, isFunctionNode, isSubpromptNode, isRouterNode, nodeIsOptional, nodeLabel, nodeAssets } from './chunk-V4RGCKYC.js';
 import { classifierDecision, withoutReservedClassifierFields } from './chunk-DHMBE5J7.js';
-import { withActivityLabelDefs } from './chunk-GRBB4CQL.js';
+import { withActivityLabelDefs } from './chunk-DJZRPPFJ.js';
 import { processAlive } from './chunk-4GY63JU6.js';
 import { withFsDeadline, tryWithFsDeadline, FsDeadlineError, fsDeadlineMs } from './chunk-2FBPAR2V.js';
 import { portableSpawn } from './chunk-DPLIN2RA.js';
@@ -21,6 +21,7 @@ import { mkdir, rename, writeFile, readFile, stat, cp, rmdir, chmod, rm, readdir
 import * as z4 from 'zod';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
+import { tmpdir } from 'os';
 import { createReadStream, existsSync, mkdirSync, openSync, closeSync, chmodSync, utimesSync, readFileSync, writeSync, renameSync } from 'fs';
 import { createServer } from 'http';
 import mime from 'mime';
@@ -1549,6 +1550,10 @@ function gitPrefix(cwd) {
   return ["-c", `safe.directory=${cwd}`];
 }
 var SKAILE_INTERNAL_DIR = ".skaile";
+function isSkaileInternalPath(statusPath) {
+  const p = statusPath.startsWith('"') ? statusPath.slice(1) : statusPath;
+  return p === SKAILE_INTERNAL_DIR || p.startsWith(`${SKAILE_INTERNAL_DIR}/`);
+}
 var SKAILE_EXCLUDE_MARKER = "# skaile: platform-internal session state (git connector)";
 var UNSTAGE_BATCH = 500;
 async function commitIdentityArgs(cwd) {
@@ -1689,13 +1694,20 @@ async function ensureSkaileExcluded(cwd, log) {
   }
 }
 async function runGit(args, options) {
-  const { stdout } = await execFileAsync2("git", args, {
+  const pending = execFileAsync2("git", args, {
     encoding: "utf-8",
     timeout: options.timeout,
     killSignal: "SIGKILL",
     ...options.cwd === void 0 ? {} : { cwd: options.cwd },
-    ...options.env === void 0 ? {} : { env: options.env }
+    ...options.env === void 0 ? {} : { env: options.env },
+    ...options.maxBuffer === void 0 ? {} : { maxBuffer: options.maxBuffer }
   });
+  if (options.input !== void 0) {
+    pending.child.stdin?.on("error", () => {
+    });
+    pending.child.stdin?.end(options.input);
+  }
+  const { stdout } = await pending;
   return stdout.trim();
 }
 function git(args, cwd, timeout = 3e4) {
@@ -1753,8 +1765,9 @@ async function runRemoteGit(args, auth, options) {
     );
   }
   const recursion = RECURSING_SUBCOMMANDS.has(subcommandOf(args)) ? NO_SUBMODULE_RECURSION : [];
+  const cwd = options.cwd ?? options.neutralCwd;
   return runGit([...gitPrefix(options.safeDir), ...NETWORK_GIT_ARGS, ...recursion, ...args], {
-    ...options.cwd === void 0 ? {} : { cwd: options.cwd },
+    ...cwd === void 0 ? {} : { cwd },
     timeout: options.timeout,
     env: networkGitEnv(withheld === null ? auth : void 0, options.env)
   });
@@ -1987,6 +2000,41 @@ async function gitOrNull(args, cwd) {
     return null;
   }
 }
+var PUSH_STATE_REMOTE_TIMEOUT_MS = 1e4;
+var PUSH_STATE_LOCAL_TIMEOUT_MS = 1e4;
+var PROBE_GIT_ARGS = [
+  "-c",
+  "core.fsmonitor=false",
+  "-c",
+  "status.showUntrackedFiles=all",
+  "-c",
+  "core.untrackedCache=false",
+  "-c",
+  "core.excludesFile=/dev/null"
+];
+async function probeGitOrNull(args, cwd, input) {
+  try {
+    return await runGit([...gitPrefix(cwd), ...PROBE_GIT_ARGS, ...args], {
+      cwd,
+      timeout: PUSH_STATE_LOCAL_TIMEOUT_MS,
+      env: { ...process.env, GIT_NO_REPLACE_OBJECTS: "1", GIT_WORK_TREE: cwd },
+      maxBuffer: 64 * 1024 * 1024,
+      ...input === void 0 ? {} : { input }
+    });
+  } catch {
+    return null;
+  }
+}
+async function hasInitialisedSubmodule(cwd) {
+  const staged = await probeGitOrNull(["ls-files", "--stage", "-z"], cwd);
+  if (staged === null) return true;
+  for (const entry of staged.split("\0")) {
+    if (!entry.startsWith("160000 ")) continue;
+    const path = entry.slice(entry.indexOf("	") + 1);
+    if (await pathExists(join(cwd, path, ".git"))) return true;
+  }
+  return false;
+}
 async function countAheadBehind(cwd, remoteRef) {
   const out = await gitOrNull(["rev-list", "--left-right", "--count", `${remoteRef}...HEAD`], cwd);
   if (!out) {
@@ -2995,30 +3043,135 @@ var GitConnector = class extends AbstractConnector {
     };
   }
   // ── Session lifecycle ──────────────────────────────────────────────────────
+  /**
+   * Commit and push per the lifecycle config, then report what the checkout
+   * can prove afterwards (`pushState`) so the host can tell whether anything
+   * exists only on local disk. A push that throws still throws (no report).
+   */
   async onHibernate(handle) {
     this.log.info("hibernate");
     const s = handle.state;
     if (s.fleetManaged) {
       return "fleet-managed";
     }
-    const lc = s.lifecycle;
-    if (!lc.commitOnHibernate) return;
+    const cwd = handle.mountPath;
     return this.withMountLock(s, async () => {
-      const result = await commitAll(handle.mountPath, `skaile: hibernate snapshot`, this.log);
-      if (!result) return this.pushUnpushedOnHibernate(s, handle.mountPath);
-      const sha = await git(["rev-parse", "--short", "HEAD"], handle.mountPath);
-      if (lc.pushOnHibernate) {
-        try {
-          await this.pushActiveBranch(s, handle.mountPath);
-          this.log.info("push ok", { branch: s.activeBranch });
-        } catch (err) {
-          this.log.error("push failed", err, { branch: s.activeBranch });
-          throw err;
-        }
-      }
-      return `Committed ${sha} on ${s.activeBranch}${lc.pushOnHibernate ? " (pushed)" : ""}`;
+      const detail = await this.hibernateSave(s, cwd);
+      const pushState = await this.readPushState(s, cwd);
+      return detail === void 0 ? { pushState } : { detail, pushState };
     });
   }
+  /** The commit/push half of {@link onHibernate}; returns its detail line. Runs under the mount lock. */
+  async hibernateSave(s, cwd) {
+    const lc = s.lifecycle;
+    if (!lc.commitOnHibernate) return void 0;
+    const result = await commitAll(cwd, `skaile: hibernate snapshot`, this.log);
+    if (!result) return this.pushUnpushedOnHibernate(s, cwd);
+    const sha = await git(["rev-parse", "--short", "HEAD"], cwd);
+    if (lc.pushOnHibernate) {
+      try {
+        await this.pushActiveBranch(s, cwd);
+        this.log.info("push ok", { branch: s.activeBranch });
+      } catch (err) {
+        this.log.error("push failed", err, { branch: s.activeBranch });
+        throw err;
+      }
+    }
+    return `Committed ${sha} on ${s.activeBranch}${lc.pushOnHibernate ? " (pushed)" : ""}`;
+  }
+  /**
+   * What this checkout can prove after a hibernate save, for a host deciding
+   * whether deleting the workspace loses anything. Read-only: never fetches,
+   * pushes, or writes the repo. Every doubt answers in the "keep it" direction.
+   */
+  async readPushState(s, cwd) {
+    const status = await probeGitOrNull(
+      ["status", "--porcelain", "--untracked-files=all", "--ignore-submodules=none"],
+      cwd
+    );
+    const ignored = await probeGitOrNull(
+      ["status", "--porcelain", "--ignored=matching", "--untracked-files=normal"],
+      cwd
+    );
+    const head = await probeGitOrNull(["rev-parse", "--verify", "--quiet", "HEAD^{commit}"], cwd) || null;
+    const abbrev = head === null ? null : await probeGitOrNull(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+    return {
+      clean: status === "",
+      onRemote: await this.isWorkspaceOnRemote(s, cwd, head),
+      ignoredFiles: ignored === null ? null : ignored.split("\n").some((line) => line.startsWith("!! ") && !isSkaileInternalPath(line.slice(3))),
+      head,
+      branch: abbrev === null || abbrev === "" || abbrev === "HEAD" ? null : abbrev
+    };
+  }
+  /**
+   * Whether every commit reachable from a local ref (`refs/heads/*`, `HEAD`
+   * even when detached, `refs/stash`) is reachable from some remote branch
+   * head. The remote heads come from `ls-remote`, because local `origin/*`
+   * refs go stale (a push by URL does not move them); only the ones whose
+   * commit this checkout already holds can be walked, so a head we lack
+   * proves nothing and the answer leans to `false`.
+   *
+   * `false` for any initialised submodule, checked first: a commit pinned only
+   * in its local clone is out of this walk's reach. `null` when the remote
+   * cannot be asked within {@link PUSH_STATE_REMOTE_TIMEOUT_MS}, which includes
+   * a remote the mount reaches only through ambient config (a credential helper,
+   * ssh or CA settings in global/system gitconfig): that config is switched off
+   * here, so such a workspace always reads "cannot tell" and is kept.
+   */
+  async isWorkspaceOnRemote(s, cwd, head) {
+    if (await hasInitialisedSubmodule(cwd)) return false;
+    let out;
+    try {
+      out = await runRemoteGit(["ls-remote", "--heads", plainRemoteUrl(s)], s, {
+        neutralCwd: tmpdir(),
+        safeDir: cwd,
+        timeout: PUSH_STATE_REMOTE_TIMEOUT_MS,
+        env: {
+          ...process.env,
+          GIT_CONFIG_GLOBAL: "/dev/null",
+          GIT_CONFIG_NOSYSTEM: "1",
+          GIT_NO_REPLACE_OBJECTS: "1"
+        }
+      });
+    } catch (err) {
+      this.log.warn("ls-remote for hibernate push state failed \u2014 cannot tell what is pushed", {
+        error: redactCredentials(err instanceof Error ? err.message : String(err))
+      });
+      return null;
+    }
+    const refs = await probeGitOrNull(
+      ["for-each-ref", "--format=%(objectname)", "refs/heads", "refs/tags", "refs/stash"],
+      cwd
+    );
+    if (refs === null) return false;
+    const local = new Set(refs.split("\n").filter((l) => l !== ""));
+    if (head !== null) local.add(head);
+    if (local.size === 0) return true;
+    const remote = /* @__PURE__ */ new Set();
+    for (const line of out.split("\n")) {
+      const sha = line.split("	")[0];
+      if (sha) remote.add(sha);
+    }
+    let present = [];
+    if (remote.size > 0) {
+      const batch = await probeGitOrNull(
+        ["cat-file", "--batch-check=%(objectname) %(objecttype)"],
+        cwd,
+        `${[...remote].join("\n")}
+`
+      );
+      if (batch === null) return false;
+      present = batch.split("\n").map((line) => line.split(" ")).filter(([, type]) => type === "commit").map(([sha]) => sha);
+    }
+    const count = await probeGitOrNull(
+      ["rev-list", "--count", "--stdin"],
+      cwd,
+      // `^<sha>` per line: older git does not honour `--not` on stdin.
+      `${[...local, ...present.map((sha) => `^${sha}`)].join("\n")}
+`
+    );
+    return count === "0";
+  }
   /**
    * Hibernate with nothing new to commit: push commits that are still only
    * local (the agent committed its own work, or an earlier push failed).
@@ -8424,8 +8577,17 @@ var ConnectorManager = class {
         continue;
       }
       try {
-        const detail = await fn.call(entry.connector, entry.handle);
-        results.push({ id, ok: true, detail: detail ?? void 0 });
+        const outcome = await fn.call(entry.connector, entry.handle);
+        if (outcome !== null && typeof outcome === "object") {
+          results.push({
+            id,
+            ok: true,
+            ...outcome.detail === void 0 ? {} : { detail: outcome.detail },
+            ...outcome.pushState === void 0 ? {} : { pushState: outcome.pushState }
+          });
+        } else {
+          results.push({ id, ok: true, detail: outcome ?? void 0 });
+        }
       } catch (err) {
         results.push({
           id,
@@ -10169,7 +10331,8 @@ function prepareExecutionSnapshot(flowDef, execution) {
   const nodes = nodeExecutionRecord(Object.entries(snapshot.nodes ?? {}));
   for (const node of flowDef.nodes) {
     const existing = nodes[node.id];
-    if ((isSubFlowNode(node) || isSubpromptNode(node)) && existing && ["running", "awaiting_approval", "awaiting_input"].includes(existing.status)) {
+    const interrupted = (isSubFlowNode(node) || isSubpromptNode(node)) && ["running", "awaiting_approval", "awaiting_input"].includes(existing?.status ?? "") || (isFunctionNode(node) || isCheckNode(node)) && existing?.status === "running";
+    if (existing && interrupted) {
       nodes[node.id] = {
         ...existing,
         status: "not_started",
@@ -10240,6 +10403,7 @@ var FlowAdapter = class extends AbstractConnector {
       inlineSubFlowRunner: options.inlineSubFlowRunner,
       inlineOperationTargets: /* @__PURE__ */ new Map(),
       subpromptOperations: /* @__PURE__ */ new Map(),
+      deterministicOperations: /* @__PURE__ */ new Map(),
       subpromptCleanup: /* @__PURE__ */ new Set(),
       flowInputOrigins: options.flowInputOrigins,
       inlineSubFlowAncestry: options.inlineSubFlowAncestry ?? [flowDef.id],
@@ -10254,7 +10418,7 @@ var FlowAdapter = class extends AbstractConnector {
   async disconnect(handle) {
     const state = this.s(handle);
     state.executionGeneration += 1;
-    await this.cancelSubprompts(state);
+    await this.cancelRuntimeWork(state);
     this.clearWakeTimer(state);
     await this.cancelInlineTargets(state);
     handle.status = "disconnected";
@@ -10264,16 +10428,31 @@ var FlowAdapter = class extends AbstractConnector {
     s.inlineOperationTargets.clear();
     for (const target of targets) await target.cancel();
   }
-  async cancelSubprompts(s) {
-    for (const operation of s.subpromptOperations.values()) {
-      operation.controller.abort();
-      s.subpromptCleanup.add(operation.promise);
-      void operation.promise.then(
-        () => s.subpromptCleanup.delete(operation.promise),
-        () => s.subpromptCleanup.delete(operation.promise)
+  /**
+   * Abort in-flight subprompt and function/check work and join it, so a restored
+   * run that re-runs the node never races the attempt it replaced. A
+   * deterministic join is bounded: an executor may ignore its abort signal.
+   */
+  async cancelRuntimeWork(s) {
+    const joins = [
+      ...[...s.subpromptOperations.values()].map((operation) => {
+        operation.controller.abort();
+        return operation.promise;
+      }),
+      ...[...s.deterministicOperations.values()].map((operation) => {
+        operation.controller.abort();
+        return settleWithin(operation.promise, ABORTED_ATTEMPT_SETTLE_MS);
+      })
+    ];
+    for (const join6 of joins) {
+      s.subpromptCleanup.add(join6);
+      void join6.then(
+        () => s.subpromptCleanup.delete(join6),
+        () => s.subpromptCleanup.delete(join6)
       );
     }
     s.subpromptOperations.clear();
+    s.deterministicOperations.clear();
     await Promise.allSettled([...s.subpromptCleanup]);
   }
   projectInlineInteraction(handle, parentNodeId, projection2) {
@@ -10306,7 +10485,7 @@ var FlowAdapter = class extends AbstractConnector {
    */
   hydrate(handle, execution) {
     const s = this.s(handle);
-    void this.cancelSubprompts(s);
+    void this.cancelRuntimeWork(s);
     assertLegal(
       s.inlineOperationTargets.size === 0,
       "hydrate requires live inline children to be cancelled first"
@@ -10814,7 +10993,7 @@ var FlowAdapter = class extends AbstractConnector {
       throw new Error("FlowAdapter: start requires args.seed.runId + args.seed.startedBy");
     }
     s.flowDef = flow;
-    void this.cancelSubprompts(s);
+    void this.cancelRuntimeWork(s);
     s.executionGeneration += 1;
     s.execution = buildInitialExecution(flow, {
       runId: seed.runId,
@@ -11244,7 +11423,7 @@ var FlowAdapter = class extends AbstractConnector {
    */
   cancel(handle) {
     this.mutate(handle, (s) => {
-      void this.cancelSubprompts(s);
+      void this.cancelRuntimeWork(s);
       s.execution = { ...s.execution, status: "cancelled" };
       s.executionGeneration += 1;
       return void 0;
@@ -11307,6 +11486,20 @@ var FlowAdapter = class extends AbstractConnector {
     }
     return false;
   }
+  /**
+   * Whether {@link drainRuntimeNodes} has a node to start: an `available` runtime-owned
+   * node, or an inline sub-flow it would re-enter. A run restored from a snapshot is only
+   * moved on by a turn kick, so the runner kicks one when this holds.
+   */
+  hasRuntimeWork(handle) {
+    const { flowDef, execution } = this.s(handle);
+    if (execution.status === "cancelled" || execution.status === "failed") return false;
+    return flowDef.nodes.some((node) => {
+      const status = execution.nodes[node.id]?.status;
+      if (isSubFlowNode(node)) return status === "available" || status === "running";
+      return !isAgentNode(node) && isActiveRuntimeNode(node) && status === "available";
+    });
+  }
   /**
    * Drain runtime-owned nodes in definition order until only agent work or a human decision
    * remains. Routers select branches, function nodes use NodeExecutor, gates park, and sub-flows
@@ -11703,6 +11896,10 @@ var FlowAdapter = class extends AbstractConnector {
           { node, inputs: resolved.values, inputOrigins: resolved.origins },
           { signal: deterministicAbort.signal }
         );
+        state.deterministicOperations.set(node.id, {
+          controller: deterministicAbort,
+          promise: runPromise
+        });
         const result = deterministicRemainingMs !== void 0 ? await raceWithTimeout(
           runPromise,
           Math.max(0, deterministicRemainingMs),
@@ -11762,6 +11959,9 @@ var FlowAdapter = class extends AbstractConnector {
           };
         }
       }
+      if (state.deterministicOperations.get(node.id)?.controller === deterministicAbort) {
+        state.deterministicOperations.delete(node.id);
+      }
       if (this.s(handle).executionGeneration !== deterministicExecutionGeneration) {
         deterministicAbort.abort();
         break;
@@ -12580,5 +12780,5 @@ function describeFlowOperations() {
 }
 
 export { AbstractConnector, BUILTIN_CONNECTOR_CATALOG, BoxConnector, ClassifierSubpromptRunner, ConnectorManager, DeployConnector, DevServerConnector, FlowAdapter, GitConnector, GmailConnector, GoogleDriveConnector, LocalConnector, LogBuffer, MAX_REARM_MS, MIN_REFRESH_DELAY_MS, ManagedGitconfigCollisionError, MattermostConnector, MemoryConnector, MinIOConnector, NO_ACTIVE_FLOW_ERROR, PortPool, PostgresConnector, REFRESH_LEAD_MS, S3Connector, S3FetchStoppedError, S3PresignedRequestError, S3_PRESIGN_BATCH, SQLiteConnector, SessionInlineSubFlowRunner, SessionNodeExecutor, SessionSubpromptRunner, SharePointConnector, StaticServerConnector, TunnelConnector, WebDAVConnector, XStateConnector, XStateStoreConnector, __test, atomicReplaceCredential, buildConnectorPromptSection, buildConnectorToolDefs, buildFlowPromptEvent, buildFlowToolDefs, buildLazyFlowToolDefs, buildLazySdkFlowTools, buildSdkConnectorTools, buildSdkFlowTools, checkFleetMountLiveness, classifierQuestion, classifyConnectError, createConnector, createConnector10, createConnector11, createConnector12, createConnector13, createConnector14, createConnector15, createConnector16, createConnector17, createConnector18, createConnector19, createConnector2, createConnector20, createConnector3, createConnector4, createConnector5, createConnector6, createConnector7, createConnector8, createConnector9, createFsWatcher, createWorktree, defaultSpawn, describeFlowOperations, driveOrchestratorTurn, ensureDirMode, ensureFleetMounted, ensureRefreshAttemptStamp, findGitRoot, findMissingPackages, getConnector, installNpmPackages, isFleetManaged, isPackageResolvable, listConnectors, listWorktrees, missingTokenMediatorMessage, parseListObjectsV2, presignScopePrefix, presignableKey, readGitSyncStatus, registerBuiltinConnectors, removeMountBlock, removeUnavailableMountBlock, renderCredentialHelperScript, tryGetConnector, worktreeRegistry, writeHelperScript, writeMountBlock, writeUnavailableMountBlock };
-//# sourceMappingURL=chunk-7JC4ZIXJ.js.map
-//# sourceMappingURL=chunk-7JC4ZIXJ.js.map
+//# sourceMappingURL=chunk-G3VT2BCY.js.map
+//# sourceMappingURL=chunk-G3VT2BCY.js.map