@skaile/workspaces 4.38.0 → 4.39.0

package/dist/{chunk-R5ARWJGE.js → chunk-P7BU6DAC.js}

@@ -1,25 +1,25 @@
-import { WorkspacePlugin } from './chunk-BQ3HXZNT.js';
-import { buildWorkspaceToolDefs } from './chunk-YCJ3PJNB.js';
+import { WorkspacePlugin } from './chunk-FTPKMJFD.js';
+import { buildWorkspaceToolDefs } from './chunk-X4DKUGV4.js';
 import { findAiAssetsRoot } from './chunk-EOKAFBJ7.js';
 import { WebSocketServerTransport } from './chunk-5LKOAX7I.js';
 import { assembleSystemPrompt, buildCapabilitiesPromptSection } from './chunk-W3UDISS2.js';
 import { prepareNativePolicy, codexInstanceEnvironment, parseCodexCredential, parseCodexRefreshInput, parseCodexRefreshResult } from './chunk-HCYS7GFP.js';
-import { resolveFlowPath } from './chunk-27DN4DZD.js';
+import { resolveFlowPath } from './chunk-252TK4RU.js';
 import { findAiAssetsRoot as findAiAssetsRoot$1, deployCatalogEntry, undeployCatalogEntry } from './chunk-DOVURNRK.js';
-import { ConnectFailureCarryOver, registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, buildSdkConnectorTools, buildLazySdkFlowTools, describeFlowOperations, buildConnectorToolDefs, buildFlowToolDefs, SessionNodeExecutor, SessionSubpromptRunner, ClassifierSubpromptRunner, SessionInlineSubFlowRunner, driveOrchestratorTurn, buildSdkFlowTools } from './chunk-J5UF3OOS.js';
+import { ConnectFailureCarryOver, registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, buildSdkConnectorTools, buildLazySdkFlowTools, describeFlowOperations, buildConnectorToolDefs, buildFlowToolDefs, SessionNodeExecutor, SessionSubpromptRunner, ClassifierSubpromptRunner, SessionInlineSubFlowRunner, driveOrchestratorTurn, buildSdkFlowTools } from './chunk-5RWL4L3X.js';
 import { loadYamlConnectorDeclarations, withMaterializedConnectorDeclarations, SecretProviderChain, ConnectorStartupError, isKnownSecretRef, EnvSecretProvider, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, deriveSingleMaterializedConnectorDeclaration } from './chunk-YQEF36D5.js';
-import { EventNormalizer } from './chunk-7UL2SQQH.js';
+import { EventNormalizer } from './chunk-M7GPCWEV.js';
 import { probeResumeTranscript, transcriptStoreForRuntime } from './chunk-5NYBY6ZE.js';
 import { scopeReconfigureModel } from './chunk-EINLFFP6.js';
 import { CodexNativeStateUnavailable } from './chunk-LOO5CB5M.js';
-import { dispatchCapability } from './chunk-PRCUGFXV.js';
+import { dispatchCapability } from './chunk-RDYI4MML.js';
 import { classifyClaudeSdkError } from './chunk-XBSQ4KMC.js';
 import { agentExecRequested } from './chunk-YROR332M.js';
-import { toAgentEffort, createDriver, catalogLayer, providerCredentialEnvName, toMergedRegistry, registryCredentialEnv, AI_PROVIDER_PRESETS, AgentDriver } from './chunk-6KPQDP7P.js';
+import { toAgentEffort, createDriver, catalogLayer, providerCredentialEnvName, toMergedRegistry, registryCredentialEnv, AI_PROVIDER_PRESETS, AgentDriver } from './chunk-TSVRKUGV.js';
 import { loadFlow } from './chunk-7RC37XFW.js';
 import { parseFlowDefinition } from './chunk-DIQDYNXZ.js';
 import { renderStimulusPrompt } from './chunk-K3IBZ2UZ.js';
-import { withActivityLabelJsonSchema, TOOL_ACTIVITY_PROMPT_SECTION, SESSION_ROOT_CONNECTOR_ID, PROTOCOL_VERSION } from './chunk-YNUBJY3L.js';
+import { withActivityLabelJsonSchema, TOOL_ACTIVITY_PROMPT_SECTION, SESSION_ROOT_CONNECTOR_ID, PROTOCOL_VERSION } from './chunk-IDEA6CYI.js';
 import { resolveLibraryDir, resolveSettings, loadProviderRegistry } from './chunk-YV3YI3TA.js';
 import { resolveRuntimeAssets } from './chunk-36ML6SFP.js';
 import { resolveDriverPaths } from './chunk-K5GBV4SA.js';
@@ -32,7 +32,7 @@ import { pickRegistryEntries, registryEntries, resolveEntryBaseUrl, parseModelRe
 import { getLogStore, registerLogStore, createLogger, resetLogStore, isUnwritableStreamError, markStreamBroken, isBrokenPipeError, redactCredentials } from './chunk-BOFL7GIF.js';
 import { __require } from './chunk-NSBPE2FW.js';
 import pc from 'picocolors';
-import path5, { join, resolve, relative, sep, isAbsolute, basename, dirname } from 'path';
+import path5, { join, resolve, basename, dirname, relative, sep, isAbsolute } from 'path';
 import { Marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
 import fs4, { readFile, readdir, lstat, stat, rm, unlink, mkdir, writeFile, realpath, rename, open, readlink, mkdtemp } from 'fs/promises';
@@ -3864,6 +3864,176 @@ async function readMountRange(targetPath, range, authoritativeSize) {
     });
   }
 }
+var MOUNT_WRITE_MAX_CHUNK_BYTES = 8 * 1024 * 1024;
+var WRITE_RANGE_PARTIAL_TTL_MS = 60 * 60 * 1e3;
+var PARTIAL_SUFFIX = ".skaile-partial";
+var UPLOAD_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+var PARTIAL_NAME_MAX_BYTES = 120;
+function writeRangePartialPath(targetPath, uploadId) {
+  const name = basename(targetPath);
+  const stem = Buffer.byteLength(name) > PARTIAL_NAME_MAX_BYTES ? createHash("sha256").update(name).digest("hex").slice(0, 32) : name;
+  return join(dirname(targetPath), `.${stem}.${uploadId}${PARTIAL_SUFFIX}`);
+}
+var partialLocks = /* @__PURE__ */ new Map();
+var transferOutcomes = /* @__PURE__ */ new Map();
+function recordOutcome(partialPath, outcome, size) {
+  const now = Date.now();
+  for (const [key, entry] of transferOutcomes) {
+    if (now - entry.at > WRITE_RANGE_PARTIAL_TTL_MS) transferOutcomes.delete(key);
+  }
+  transferOutcomes.set(partialPath, { outcome, size, at: now });
+}
+async function withPartialLock(key, fn) {
+  const previous = partialLocks.get(key) ?? Promise.resolve();
+  const run = previous.catch(() => {
+  }).then(fn);
+  partialLocks.set(key, run);
+  try {
+    return await run;
+  } finally {
+    if (partialLocks.get(key) === run) partialLocks.delete(key);
+  }
+}
+function invalidRange(message) {
+  return new ResourceOperationError(`Invalid write range: ${message}`, "invalid_range");
+}
+function parseWriteRange(options, content) {
+  const { uploadId, offset, size, abort } = options ?? {};
+  if (typeof uploadId !== "string" || !UPLOAD_ID_PATTERN.test(uploadId)) {
+    throw invalidRange("uploadId must be 1-64 letters, digits, '-' or '_'");
+  }
+  if (abort === true) return { uploadId, offset: 0, size: 0, abort: true, chunk: Buffer.alloc(0) };
+  for (const [name, value] of [
+    ["offset", offset],
+    ["size", size]
+  ]) {
+    if (!(Number.isSafeInteger(value) && value >= 0)) {
+      throw invalidRange(`${name} must be a non-negative integer`);
+    }
+  }
+  const body = typeof content === "object" && content !== null ? content : void 0;
+  if (body?.encoding !== "binary" || typeof body.data !== "string") {
+    throw invalidRange('the chunk must be base64 content with encoding "binary"');
+  }
+  if (body.data.length > Math.ceil(MOUNT_WRITE_MAX_CHUNK_BYTES / 3) * 4) {
+    throw invalidRange(`a chunk holds at most ${MOUNT_WRITE_MAX_CHUNK_BYTES} bytes`);
+  }
+  const chunk = Buffer.from(body.data, "base64");
+  if (chunk.length > MOUNT_WRITE_MAX_CHUNK_BYTES) {
+    throw invalidRange(`a chunk holds at most ${MOUNT_WRITE_MAX_CHUNK_BYTES} bytes`);
+  }
+  if (offset + chunk.length > size) {
+    throw invalidRange(
+      `a chunk of ${chunk.length} bytes at offset ${offset} runs past the stated size of ${size}`
+    );
+  }
+  if (chunk.length === 0 && offset < size) {
+    throw invalidRange(
+      `an empty chunk at offset ${offset} cannot complete a file of ${size} bytes`
+    );
+  }
+  return { uploadId, offset, size, abort: false, chunk };
+}
+async function sweepStalePartials(targetPath, keep) {
+  const dir = dirname(targetPath);
+  try {
+    const names = await withFsDeadline(`readdir ${dir}`, () => readdir(dir));
+    const now = Date.now();
+    for (const name of names) {
+      if (!name.startsWith(".") || !name.endsWith(PARTIAL_SUFFIX)) continue;
+      const abs = join(dir, name);
+      if (abs === keep) continue;
+      const st = await withFsDeadline(`lstat ${abs}`, () => lstat(abs));
+      if (st.isFile() && now - st.mtimeMs > WRITE_RANGE_PARTIAL_TTL_MS) {
+        await withFsDeadline(`unlink ${abs}`, () => unlink(abs));
+      }
+    }
+  } catch {
+  }
+}
+async function openPartial(partialPath, start) {
+  if (start) await withFsDeadline(`rm ${partialPath}`, () => rm(partialPath, { force: true }));
+  const flags = start ? constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW : constants.O_RDWR | constants.O_NOFOLLOW;
+  const opening = open(partialPath, flags);
+  try {
+    return await withFsDeadline(`open ${partialPath}`, () => opening);
+  } catch (err) {
+    void opening.then((h) => h.close()).catch(() => {
+    });
+    throw err;
+  }
+}
+async function writeRangeChunk(targetPath, options, content) {
+  const req = parseWriteRange(options, content);
+  const partialPath = writeRangePartialPath(targetPath, req.uploadId);
+  return withPartialLock(partialPath, async () => {
+    const known = transferOutcomes.get(partialPath);
+    if (req.abort) {
+      await withFsDeadline(`rm ${partialPath}`, () => rm(partialPath, { force: true }));
+      transferOutcomes.delete(partialPath);
+      return { received: 0, size: 0, complete: false };
+    }
+    const received = req.offset + req.chunk.length;
+    if (req.offset > 0 && known?.outcome === "done") {
+      if (received === req.size && known.size === req.size) {
+        return { received, size: req.size, complete: true };
+      }
+      throw invalidRange(`transfer "${req.uploadId}" is already complete`);
+    }
+    if (req.offset > 0 && known?.outcome === "stalled") {
+      throw invalidRange(
+        `transfer "${req.uploadId}" stalled on a slow mount; start again at offset 0`
+      );
+    }
+    const parentDir = dirname(targetPath);
+    await withFsDeadline(`mkdir ${parentDir}`, () => mkdir(parentDir, { recursive: true }));
+    if (req.offset === 0) await sweepStalePartials(targetPath, partialPath);
+    let fh;
+    try {
+      fh = await openPartial(partialPath, req.offset === 0);
+      if (req.offset === 0) transferOutcomes.delete(partialPath);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ELOOP") throw invalidRange("the partial file is not a regular file");
+      if (code !== "ENOENT" || req.offset === 0) throw err;
+      throw invalidRange(`no transfer "${req.uploadId}" is in progress; start again at offset 0`);
+    }
+    try {
+      const st = await withFsDeadline(`fstat ${partialPath}`, () => fh.stat());
+      if (!st.isFile()) throw invalidRange("the partial file is not a regular file");
+      if (st.size !== req.offset) {
+        throw invalidRange(`expected offset ${st.size}, got ${req.offset}`);
+      }
+      await withFsDeadline(`write ${partialPath} @${req.offset}+${req.chunk.length}`, async () => {
+        let done = 0;
+        while (done < req.chunk.length) {
+          const { bytesWritten } = await fh.write(
+            req.chunk,
+            done,
+            req.chunk.length - done,
+            req.offset + done
+          );
+          done += bytesWritten;
+        }
+      });
+    } catch (err) {
+      if (err instanceof FsDeadlineError) {
+        void fh.close().catch(() => {
+        });
+        recordOutcome(partialPath, "stalled", req.size);
+      } else {
+        await fh.close().catch(() => {
+        });
+      }
+      throw err;
+    }
+    await withFsDeadline(`close ${partialPath}`, () => fh.close());
+    if (received < req.size) return { received, size: req.size, complete: false };
+    await withFsDeadline(`rename ${partialPath}`, () => rename(partialPath, targetPath));
+    recordOutcome(partialPath, "done", req.size);
+    return { received, size: req.size, complete: true };
+  });
+}
 var MOUNT_STAT_MAX_ENTRIES = 5e4;
 var MOUNT_STAT_BUDGET_MS = 1e4;
 var MOUNT_STAT_CONCURRENCY = 16;
@@ -4094,6 +4264,11 @@ async function handleMountResourceRequest(command, manager, emit) {
         data = true;
         break;
       }
+      case "write_range": {
+        if (rel === "") throw new Error("A file path is required");
+        data = await writeRangeChunk(targetPath, options, content);
+        break;
+      }
       case "mkdir": {
         if (rel === "") throw new Error("A folder path is required");
         const parentDir = dirname(targetPath);
@@ -4216,27 +4391,34 @@ async function readDanglingLink(absPath) {
 async function handleSessionRootResourceRequest(command, rootDir, emit) {
   const { requestId, connectorId, operation, path: reqPath, content } = command;
   try {
-    if (operation !== "write" && operation !== "delete") {
+    if (operation !== "write" && operation !== "write_range" && operation !== "delete") {
       throw unsupportedOperation(operation, "the session root");
     }
+    const access = operation === "delete" ? "delete" : "write";
     if (!reqPath) throw new Error("A path is required for the session root");
     if (isAbsolute(reqPath)) throw new Error("Absolute paths are not allowed for the session root");
     const root = resolve(rootDir);
     const targetPath = resolve(root, reqPath);
     if (!isWithin2(root, targetPath)) throw new Error("Path traversal outside the session root");
     const rel = relative(root, targetPath).split(sep).join("/");
-    if (!isSessionRootPathAllowed(rel, operation)) {
+    if (!isSessionRootPathAllowed(rel, access)) {
       throw new Error(
         `Path "${rel}" is not writable in the session root \u2014 allowed: ${[...SESSION_ROOT_WRITABLE_FILES, ...SESSION_ROOT_WRITABLE_DIRS.map((d) => `${d}/**`)].join(", ")}`
       );
     }
     const realRoot = await withFsDeadline(`realpath ${root}`, () => realpath(root));
-    const onDisk = operation === "write" ? await resolveOnDisk(targetPath) : join(await resolveOnDisk(dirname(targetPath)), basename(targetPath));
-    if (!isWithin2(realRoot, operation === "write" ? onDisk : dirname(onDisk))) {
+    const onDisk = access === "write" ? await resolveOnDisk(targetPath) : join(await resolveOnDisk(dirname(targetPath)), basename(targetPath));
+    if (!isWithin2(realRoot, access === "write" ? onDisk : dirname(onDisk))) {
       throw new Error("Path escapes the session root through a symlink");
     }
     let data = true;
-    if (operation === "write") {
+    if (operation === "write_range") {
+      data = await writeRangeChunk(
+        onDisk,
+        command.options,
+        content
+      );
+    } else if (operation === "write") {
       const parentDir = dirname(onDisk);
       await withFsDeadline(`mkdir ${parentDir}`, () => mkdir(parentDir, { recursive: true }));
       const writeContent = typeof content === "string" ? content : content?.data ?? "";
@@ -11710,6 +11892,6 @@ function touchSession(state) {
   return { ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
 }
 
-export { CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CONNECTOR_MUTATE_NOT_READY, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS, MOUNT_LIST_MAX_DEPTH, MOUNT_LIST_MAX_ENTRIES, MOUNT_READ_DEADLINE_FACTOR, MOUNT_READ_MAX_CHUNK_BYTES, MOUNT_STAT_BUDGET_MS, MOUNT_STAT_MAX_ENTRIES, MOUNT_TREE_OP_DEADLINE_FACTOR, MarkdownStreamer, PreInitRingSink, ResourceOperationError, SESSION_ROOT_WRITABLE_DIRS, SESSION_ROOT_WRITABLE_FILES, WS_AUTH_TOKEN_ENV, WS_AUTH_TOKEN_FILE_ENV, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, capabilityLogInstance, capabilitySignatureInputs, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, computeDirectoryTotals, connectorRefreshKind, createAgentSession, createFlowConnectorReadiness, createManagedCodexSubpromptDriver, createSessionStimulusBus, defineCapability, deleteSession, dispatchResourceRequest, dispatchRunnerCapabilityInvocation, driverActiveAfterTurnEnd, emitSystemPromptComposed, ensureClaudeSettingsDisablesConnectors, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, flowRunDrivesTurns, flowStartNeedsDriverRestart, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, handleSessionRootResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isSessionRootPathAllowed, isTerminalFlowStatus, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadManagedCodexHostConfig, loadSession, loadSessionById, mcpAuthSecretKey, newSession, nulTailPaddingLength, pickChatFlowTarget, pickFlowToolTarget, pickRepointedManager, planFlowMutate, prepareCodexTools, reconcilePendingDecisions, reconnectedRunNeedsAgentTurn, recreateKeepingLiveFlows, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, rejectPendingCapabilityCallsOnDisconnect, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveMixin, restoredRunHasWorkToResume, runAgentChat, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, supportsLiveToolUpdates, takeRunnerWsAuthToken, toActiveFlowTarget, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile };
-//# sourceMappingURL=chunk-R5ARWJGE.js.map
-//# sourceMappingURL=chunk-R5ARWJGE.js.map
+export { CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CONNECTOR_MUTATE_NOT_READY, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS, MOUNT_LIST_MAX_DEPTH, MOUNT_LIST_MAX_ENTRIES, MOUNT_READ_DEADLINE_FACTOR, MOUNT_READ_MAX_CHUNK_BYTES, MOUNT_STAT_BUDGET_MS, MOUNT_STAT_MAX_ENTRIES, MOUNT_TREE_OP_DEADLINE_FACTOR, MOUNT_WRITE_MAX_CHUNK_BYTES, MarkdownStreamer, PreInitRingSink, ResourceOperationError, SESSION_ROOT_WRITABLE_DIRS, SESSION_ROOT_WRITABLE_FILES, WRITE_RANGE_PARTIAL_TTL_MS, WS_AUTH_TOKEN_ENV, WS_AUTH_TOKEN_FILE_ENV, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, capabilityLogInstance, capabilitySignatureInputs, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, computeDirectoryTotals, connectorRefreshKind, createAgentSession, createFlowConnectorReadiness, createManagedCodexSubpromptDriver, createSessionStimulusBus, defineCapability, deleteSession, dispatchResourceRequest, dispatchRunnerCapabilityInvocation, driverActiveAfterTurnEnd, emitSystemPromptComposed, ensureClaudeSettingsDisablesConnectors, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, flowRunDrivesTurns, flowStartNeedsDriverRestart, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, handleSessionRootResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isSessionRootPathAllowed, isTerminalFlowStatus, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadManagedCodexHostConfig, loadSession, loadSessionById, mcpAuthSecretKey, newSession, nulTailPaddingLength, pickChatFlowTarget, pickFlowToolTarget, pickRepointedManager, planFlowMutate, prepareCodexTools, reconcilePendingDecisions, reconnectedRunNeedsAgentTurn, recreateKeepingLiveFlows, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, rejectPendingCapabilityCallsOnDisconnect, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveMixin, restoredRunHasWorkToResume, runAgentChat, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, supportsLiveToolUpdates, takeRunnerWsAuthToken, toActiveFlowTarget, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile, writeRangeChunk, writeRangePartialPath };
+//# sourceMappingURL=chunk-P7BU6DAC.js.map
+//# sourceMappingURL=chunk-P7BU6DAC.js.map