@truefoundry/trueforge-core 0.1.3 → 0.1.4-rc.0

package/dist/core/sandbox/Sandbox.mjs

@@ -14,29 +14,36 @@ import {
 } from "../runtime/DeferredTool.mjs";
 import { extractErrorLogFields } from "../util/errorLogFields.mjs";
 import { CodeModeDispatcher } from "./codeMode/CodeModeDispatcher.mjs";
-import { SANDBOX_FILE_UPLOADS_DIR } from "./constants.mjs";
+import "./codeMode/CodeModeTransport.mjs";
 import { ensureExecSuccess, shellEscape } from "./provider/Provider.mjs";
-import { validateNoPathTraversal, validateSandboxOwnedByTenant } from "./SandboxErrors.mjs";
-import { sandboxScripts } from "./sandboxScripts.gen.mjs";
-import { SKILLS_DIR } from "./skills/constants.mjs";
+import { SandboxNotAvailableError, validateNoPathTraversal } from "./SandboxErrors.mjs";
+import { formatSandboxId, rawSandboxId } from "./sandboxRef.mjs";
+import { dirname, join, relative } from "path";
+function mcpClientLayout(remotePath) {
+  const pythonPath = dirname(remotePath);
+  const binDir = join(pythonPath, "bin");
+  return { pythonPath, binDir, binLink: join(binDir, "mcp-client") };
+}
 var SKILL_DOWNLOAD_TIMEOUT_SECONDS = 180;
 var NATS_REQUEST_TIMEOUT_BUFFER_SECONDS = 30;
 function buildWriteAndRunScriptCommand(params) {
   const b64 = Buffer.from(params.scriptContent, "utf-8").toString("base64");
+  const scriptPath = shellEscape(params.scriptPath);
   return [
-    `mkdir -p "$(dirname ${params.scriptPath})"`,
-    `rm -f ${params.scriptPath}`,
-    `echo ${shellEscape(b64)} | base64 -d > ${params.scriptPath}`,
-    `chmod a-w ${params.scriptPath}`,
-    `python3 ${params.scriptPath}`
+    `mkdir -p "$(dirname ${scriptPath})"`,
+    `rm -f ${scriptPath}`,
+    `echo ${shellEscape(b64)} | base64 -d > ${scriptPath}`,
+    `chmod a-w ${scriptPath}`,
+    `python3 ${scriptPath}`
   ].join(" && ");
 }
 function buildSyncGitCredentialsCommand(credentialsContent, credentialsPath) {
+  const path = shellEscape(credentialsPath);
   if (credentialsContent === null) {
-    return `rm -f ${credentialsPath}`;
+    return `rm -f ${path}`;
   }
   const b64 = Buffer.from(credentialsContent, "utf-8").toString("base64");
-  return `mkdir -p "$(dirname ${credentialsPath})" && echo '${b64}' | base64 -d > ${credentialsPath} && chmod 600 ${credentialsPath}`;
+  return `mkdir -p "$(dirname ${path})" && echo '${b64}' | base64 -d > ${path} && chmod 600 ${path}`;
 }
 function buildGitCredentialHelperEnv(credentialsPath) {
   return {
@@ -50,9 +57,6 @@ var SANDBOX_MCP_REMINDER_TAG = "sandbox-mcp-code-mode";
 var SANDBOX_FILE_OUTPUT_TAG = "sandbox-file-output";
 var SANDBOX_SCHEMA_INFER_TAG = "sandbox-schema-infer";
 var SANDBOX_FILE_UPLOADS_TAG = "sandbox-file-uploads";
-var MCP_CLIENT_DIR = "/opt/tfy/mcp-client";
-var MCP_CLIENT_PATH = `${MCP_CLIENT_DIR}/mcp_client.py`;
-var MCP_CLIENT_BIN_SYMLINK = "/usr/local/bin/mcp-client";
 function injectTraceContextEnv() {
   const carrier = {};
   propagation.inject(context.active(), carrier);
@@ -68,9 +72,13 @@ function injectTraceContextEnv() {
 function injectMCPClientEnv(params) {
   const codeModeEnv = params.codeModeEnv ?? {};
   const hasCodeModeTransport = Object.keys(codeModeEnv).length > 0;
+  const install = params.mcpClientInstall;
+  const layout = install === void 0 ? void 0 : mcpClientLayout(install.remotePath);
   return {
     ...params.env ?? {},
-    PYTHONPATH: MCP_CLIENT_DIR,
+    ...layout !== void 0 && {
+      PYTHONPATH: layout.pythonPath
+    },
     ...Object.keys(params.mcpServers).length > 0 && {
       TFY_MCP_SERVERS: Buffer.from(JSON.stringify(params.mcpServers)).toString("base64")
     },
@@ -102,14 +110,12 @@ function createSandboxLargeToolResponseGuidance() {
   return `For use cases where the Agent needs a subset of fields from the MCP response or needs deterministic processing, write code with the provided MCP client and use <${SANDBOX_MCP_REMINDER_TAG}>.`;
 }
 var SANDBOX_MCP_SERVER_ID = "sandbox";
-var Sandbox = class _Sandbox extends LocalToolMCP {
+var Sandbox = class extends LocalToolMCP {
   name = SANDBOX_MCP_SERVER_ID;
   displayName = "Sandbox";
   description = "Persistent sandbox environment for code execution";
-  static FILE_UPLOADS_DIR = SANDBOX_FILE_UPLOADS_DIR;
   provider;
   existingSandboxId;
-  tenantName;
   existingSandboxInfo;
   // Cached promise to prevent concurrent sub-agents from creating duplicate sandboxes.
   sandboxCreationPromise;
@@ -119,12 +125,13 @@ var Sandbox = class _Sandbox extends LocalToolMCP {
   requestTimeoutSeconds;
   skillMounter;
   cachedSkillsSection;
-  mcpClientScriptBase64;
   logger;
   // Pre-resolved credential-store file content (null = clear / no git auth).
   resolvedGitCredentialsContent;
   codeModeDispatcher;
   codeModeTransport;
+  /** Cached from transport.getClientInstall after sandbox init (when Code Mode is configured). */
+  mcpClientInstall;
   tools = [
     defineTool({
       name: SANDBOX_EXEC_TOOL_NAME,
@@ -137,19 +144,24 @@ var Sandbox = class _Sandbox extends LocalToolMCP {
     super({ tracing: options.tracing });
     this.provider = options.provider;
     this.existingSandboxId = options.existingSandboxId;
-    this.tenantName = options.tenantName;
     this.skillMounter = options.skillMounter;
     this.fileDownloadEnabled = options.fileDownloadEnabled ?? false;
     const mcpBoundTimeoutMs = options.mcpRequestTimeoutMs + options.mcpConnectTimeoutMs;
     this.requestTimeoutSeconds = Math.ceil(mcpBoundTimeoutMs / 1e3) + NATS_REQUEST_TIMEOUT_BUFFER_SECONDS;
-    this.mcpClientScriptBase64 = Buffer.from(sandboxScripts.mcpClient, "utf-8").toString("base64");
     this.logger = options.logger.child({ module: "Sandbox" });
     this.resolvedGitCredentialsContent = options.resolvedGitCredentialsContent ?? null;
     if (this.existingSandboxId) {
-      validateSandboxOwnedByTenant(this.existingSandboxId, this.tenantName);
       this.existingSandboxInfo = { sandbox_id: this.existingSandboxId };
     }
   }
+  /** Provider-facing id (unwraps `v1:type:raw`; legacy ids pass through). */
+  providerSandboxId(sessionId) {
+    return rawSandboxId(sessionId);
+  }
+  /** Raw id for prompt layout paths before create (empty when this turn has no existing sandbox). */
+  promptSandboxId() {
+    return this.existingSandboxId === void 0 ? "" : rawSandboxId(this.existingSandboxId);
+  }
   buildMcpServersEnvelope() {
     const out = {};
     for (const server of this.codeExecToolSets) {
@@ -179,7 +191,7 @@ var Sandbox = class _Sandbox extends LocalToolMCP {
   renderSkillsSection() {
     if (this.cachedSkillsSection === void 0) {
       const skills = new InstructionBuilder("skills");
-      this.skillMounter?.instruction(skills);
+      this.skillMounter?.instruction(skills, { skillsDir: this.provider.getSkillsDir(this.promptSandboxId()) });
       this.cachedSkillsSection = skills.build();
     }
     return this.cachedSkillsSection;
@@ -203,7 +215,7 @@ var Sandbox = class _Sandbox extends LocalToolMCP {
   buildFileUploadsSection(builder) {
     builder.addSection(
       SANDBOX_FILE_UPLOADS_TAG,
-      `User-uploaded files are placed in ${_Sandbox.FILE_UPLOADS_DIR}/. The Agent must not modify files in this directory. Always create a copy at a different location and work on the copy.`
+      `User-uploaded files are placed in ${this.provider.getFileUploadsDir(this.promptSandboxId())}/. The Agent must not modify files in this directory. Always create a copy at a different location and work on the copy.`
     );
   }
   buildSchemaSection(builder) {
@@ -325,86 +337,168 @@ var Sandbox = class _Sandbox extends LocalToolMCP {
     }
     return this.existingSandboxInfo;
   }
+  clearExistingSandbox() {
+    this.existingSandboxInfo = void 0;
+    this.sandboxCreationPromise = void 0;
+    this.sandboxInitPromise = void 0;
+    this.mcpClientInstall = void 0;
+  }
   async ensureSandboxCreated() {
     if (this.existingSandboxInfo) {
       return { sandboxInfo: this.existingSandboxInfo, sandboxCreated: void 0 };
     }
-    this.sandboxCreationPromise ??= this.provider.createSandbox().then(({ sandboxId }) => {
-      validateSandboxOwnedByTenant(sandboxId, this.tenantName);
-      return { sandbox_id: sandboxId };
-    }).catch((e) => {
+    this.sandboxCreationPromise ??= this.provider.createSandbox().then(({ sandboxId }) => ({
+      sandbox_id: formatSandboxId({ providerType: this.provider.type, rawId: sandboxId })
+    })).catch((e) => {
       this.sandboxCreationPromise = void 0;
       throw e;
     });
     const sandboxInfo = await this.sandboxCreationPromise;
-    const prior = this.existingSandboxInfo;
-    const isNew = prior === void 0;
+    const raced = this.peekExistingSandboxInfo();
+    if (raced !== void 0) {
+      return { sandboxInfo: raced, sandboxCreated: void 0 };
+    }
     this.existingSandboxInfo = sandboxInfo;
-    return { sandboxInfo, sandboxCreated: isNew ? sandboxInfo : void 0 };
+    return { sandboxInfo, sandboxCreated: sandboxInfo };
   }
-  async handleExec(input) {
-    const { sandboxInfo, sandboxCreated } = await this.ensureSandboxCreated();
-    const sandboxCreatedFlag = Boolean(sandboxCreated);
+  peekExistingSandboxInfo() {
+    return this.existingSandboxInfo;
+  }
+  /** Same-type missing remote/local root: drop the stale id and create a new fancy id. */
+  async recreateAfterUnavailable() {
+    this.clearExistingSandbox();
+    const created = await this.ensureSandboxCreated();
+    if (created.sandboxCreated === void 0) {
+      throw new Error("Sandbox recreate did not create a new sandbox");
+    }
+    return { sandboxInfo: created.sandboxInfo, sandboxCreated: created.sandboxCreated };
+  }
+  /**
+   * Create or reattach, then init. A missing same-type sandbox throws
+   * `SandboxNotAvailableError` from the provider; reattach then recreates.
+   */
+  async ensureReadySandbox() {
+    const first = await this.ensureSandboxCreated();
     try {
       await this.ensureSandboxInitialized();
+      return first;
+    } catch (error) {
+      if (!(error instanceof SandboxNotAvailableError) || first.sandboxCreated !== void 0) {
+        throw error;
+      }
+      const recreated = await this.recreateAfterUnavailable();
+      await this.ensureSandboxInitialized();
+      return recreated;
+    }
+  }
+  async handleExec(input) {
+    let sandboxInfo;
+    let sandboxCreated;
+    try {
+      ({ sandboxInfo, sandboxCreated } = await this.ensureReadySandbox());
     } catch (e) {
       this.logger.error("Sandbox initialization failed", extractErrorLogFields(e));
       const message = e instanceof Error ? e.message : "Sandbox initialization failed";
+      const fallback = this.existingSandboxInfo;
       return toolResultResponse({
         text: `Sandbox initialization failed: ${message}`,
         isError: true,
-        overrides: { sandboxCreated: sandboxCreatedFlag, sandboxInfo }
+        overrides: {
+          sandboxCreated: Boolean(fallback),
+          ...fallback !== void 0 ? { sandboxInfo: fallback } : {}
+        }
       });
     }
-    const codeModeEnv = await this.ensureCodeModeStarted(sandboxInfo.sandbox_id);
+    const sandboxCreatedFlag = Boolean(sandboxCreated);
+    const rawId = this.providerSandboxId(sandboxInfo.sandbox_id);
+    const codeModeEnv = await this.ensureCodeModeStarted(rawId);
     const mcpClientEnv = injectMCPClientEnv({
       env: input.env,
       mcpServers: this.buildMcpServersEnvelope(),
-      codeModeEnv
+      codeModeEnv,
+      mcpClientInstall: this.mcpClientInstall
     });
-    const gitAuthEnv = this.resolvedGitCredentialsContent !== null ? buildGitCredentialHelperEnv(this.provider.getGitCredentialsPath(sandboxInfo.sandbox_id)) : {};
+    const gitAuthEnv = this.resolvedGitCredentialsContent !== null ? buildGitCredentialHelperEnv(this.provider.getGitCredentialsPath(rawId)) : {};
     const env = { ...mcpClientEnv, ...gitAuthEnv };
-    const result = await this.provider.exec({
-      sandboxId: sandboxInfo.sandbox_id,
-      command: input.command,
-      cwd: input.cwd,
-      env
-    });
-    return {
-      result: {
-        content: [{ type: "text", text: JSON.stringify(result) }],
-        isError: !result.success
-      },
-      wasInitialized: void 0,
-      sandboxCreated: sandboxCreatedFlag,
-      sandboxInfo
-    };
+    try {
+      const result = await this.provider.exec({
+        sandboxId: rawId,
+        command: input.command,
+        cwd: input.cwd,
+        env
+      });
+      return {
+        result: {
+          content: [{ type: "text", text: JSON.stringify(result) }],
+          isError: !result.success
+        },
+        wasInitialized: void 0,
+        sandboxCreated: sandboxCreatedFlag,
+        sandboxInfo
+      };
+    } catch (error) {
+      if (!(error instanceof SandboxNotAvailableError) || sandboxCreated !== void 0) {
+        throw error;
+      }
+      const recreated = await this.recreateAfterUnavailable();
+      await this.ensureSandboxInitialized();
+      const recreatedRawId = this.providerSandboxId(recreated.sandboxInfo.sandbox_id);
+      const retryCodeModeEnv = await this.ensureCodeModeStarted(recreatedRawId);
+      const retryEnv = {
+        ...injectMCPClientEnv({
+          env: input.env,
+          mcpServers: this.buildMcpServersEnvelope(),
+          codeModeEnv: retryCodeModeEnv,
+          mcpClientInstall: this.mcpClientInstall
+        }),
+        ...this.resolvedGitCredentialsContent !== null ? buildGitCredentialHelperEnv(this.provider.getGitCredentialsPath(recreatedRawId)) : {}
+      };
+      const retryResult = await this.provider.exec({
+        sandboxId: recreatedRawId,
+        command: input.command,
+        cwd: input.cwd,
+        env: retryEnv
+      });
+      return {
+        result: {
+          content: [{ type: "text", text: JSON.stringify(retryResult) }],
+          isError: !retryResult.success
+        },
+        wasInitialized: void 0,
+        sandboxCreated: true,
+        sandboxInfo: recreated.sandboxInfo
+      };
+    }
   }
   async getToolResultDumpDir() {
-    const { sandboxCreated } = await this.ensureSandboxCreated();
-    const dir = this.provider.getToolResultDumpDir(this.requiredSandboxInfo.sandbox_id).replace(/\/+$/, "");
+    const { sandboxCreated, sandboxInfo } = await this.ensureSandboxCreated();
+    const dir = this.provider.getToolResultDumpDir(this.providerSandboxId(sandboxInfo.sandbox_id)).replace(/\/+$/, "");
     return { dir, sandboxCreated };
   }
   async uploadFile(params) {
-    const { sandboxCreated } = await this.ensureSandboxCreated();
-    await this.ensureSandboxInitialized();
-    const { sandbox_id: sandboxId } = this.requiredSandboxInfo;
+    const { sandboxCreated, sandboxInfo } = await this.ensureReadySandbox();
     const fileName = params.fileName.replace(/^\/+/, "");
     const targetDir = params.targetDir.replace(/\/+$/, "");
     const filePath = `${targetDir}/${fileName}`;
-    await this.provider.uploadFile({ sandboxId, remotePath: filePath, content: params.content });
+    await this.provider.uploadFile({
+      sandboxId: this.providerSandboxId(sandboxInfo.sandbox_id),
+      remotePath: filePath,
+      content: params.content
+    });
     return { filePath, sandboxCreated };
   }
   async uploadUserFile(input) {
     validateNoPathTraversal(input.fileName);
+    const { sandboxCreated, sandboxInfo } = await this.ensureReadySandbox();
     const result = await this.uploadFile({
-      targetDir: _Sandbox.FILE_UPLOADS_DIR,
+      targetDir: this.provider.getFileUploadsDir(this.providerSandboxId(sandboxInfo.sandbox_id)),
       fileName: input.fileName,
       content: input.content
     });
+    const created = sandboxCreated ?? result.sandboxCreated;
     return {
       filePath: result.filePath,
-      ...result.sandboxCreated && { sandboxCreated: result.sandboxCreated }
+      ...created && { sandboxCreated: created }
     };
   }
   async writeArtifact(input) {
@@ -433,7 +527,7 @@ var Sandbox = class _Sandbox extends LocalToolMCP {
     await this.sandboxInitPromise;
   }
   async writeGitCredentials() {
-    const sandboxId = this.requiredSandboxInfo.sandbox_id;
+    const sandboxId = this.providerSandboxId(this.requiredSandboxInfo.sandbox_id);
     const credentialsPath = this.provider.getGitCredentialsPath(sandboxId);
     const result = await this.provider.exec({
       sandboxId,
@@ -442,30 +536,56 @@ var Sandbox = class _Sandbox extends LocalToolMCP {
     ensureExecSuccess(result);
   }
   async initSandboxEnvironment() {
-    const toolResultDumpDir = this.provider.getToolResultDumpDir(this.requiredSandboxInfo.sandbox_id);
+    const sandboxId = this.providerSandboxId(this.requiredSandboxInfo.sandbox_id);
+    const fileUploadsDir = this.provider.getFileUploadsDir(sandboxId);
+    const skillsDir = this.provider.getSkillsDir(sandboxId);
+    const toolResultDumpDir = this.provider.getToolResultDumpDir(sandboxId);
     this.logger.info("Uploading MCP client script and preparing skills directory in sandbox");
-    const initSteps = [
-      `mkdir -p ${MCP_CLIENT_DIR} ${_Sandbox.FILE_UPLOADS_DIR} ${toolResultDumpDir} ${SKILLS_DIR}`,
-      `rm -f ${MCP_CLIENT_PATH}`,
-      `echo '${this.mcpClientScriptBase64}' | base64 -d > ${MCP_CLIENT_PATH}`,
-      // Make executable + symlink onto PATH so `mcp-client` runs by name.
-      `chmod 0555 ${MCP_CLIENT_PATH}`,
-      `ln -sf ${MCP_CLIENT_PATH} ${MCP_CLIENT_BIN_SYMLINK}`
-    ];
-    const skillInit = this.skillMounter?.getSandboxInit();
+    this.mcpClientInstall = this.codeModeTransport?.getClientInstall({ sandboxId });
+    const install = this.mcpClientInstall;
+    const dirs = [shellEscape(fileUploadsDir), shellEscape(toolResultDumpDir), shellEscape(skillsDir)];
+    if (install !== void 0) {
+      const { pythonPath, binDir } = mcpClientLayout(install.remotePath);
+      dirs.push(shellEscape(pythonPath));
+      if (install.pathBinSymlink === void 0) {
+        dirs.push(shellEscape(binDir));
+      }
+    }
+    ensureExecSuccess(await this.provider.exec({ sandboxId, command: `mkdir -p ${dirs.join(" ")}` }));
+    const initSteps = [];
+    if (install !== void 0) {
+      await this.provider.uploadFile({
+        sandboxId,
+        remotePath: install.remotePath,
+        content: Buffer.from(install.content, "utf-8")
+      });
+      initSteps.push(`chmod 0555 ${shellEscape(install.remotePath)}`);
+      if (install.pathBinSymlink !== void 0) {
+        initSteps.push(`ln -sf ${shellEscape(install.remotePath)} ${shellEscape(install.pathBinSymlink)}`);
+      } else {
+        const { binDir, binLink } = mcpClientLayout(install.remotePath);
+        initSteps.push(`ln -sf ${shellEscape(relative(binDir, install.remotePath))} ${shellEscape(binLink)}`);
+      }
+    }
+    const skillInit = this.skillMounter?.getSandboxInit({
+      skillsDir,
+      gitDownloaderPath: this.provider.getGitDownloaderPath(sandboxId)
+    });
     if (skillInit) {
       initSteps.push(skillInit.command);
     }
-    const script = initSteps.join(" && ");
-    const result = await this.provider.exec({
-      sandboxId: this.requiredSandboxInfo.sandbox_id,
-      command: script,
-      env: skillInit?.env,
-      timeoutSeconds: skillInit?.timeoutSeconds
-    });
-    ensureExecSuccess(result);
+    if (initSteps.length > 0) {
+      ensureExecSuccess(
+        await this.provider.exec({
+          sandboxId,
+          command: initSteps.join(" && "),
+          env: skillInit?.env,
+          timeoutSeconds: skillInit?.timeoutSeconds
+        })
+      );
+    }
     this.logger.info(
-      `Sandbox initialized: MCP client at ${MCP_CLIENT_PATH} (symlinked to ${MCP_CLIENT_BIN_SYMLINK}); skills dir ${SKILLS_DIR}`
+      install === void 0 ? `Sandbox initialized: skills dir ${skillsDir}` : `Sandbox initialized: MCP client at ${install.remotePath}; skills dir ${skillsDir}`
     );
     await this.writeGitCredentials();
   }