@mastra/factory 0.2.1 → 0.2.2-alpha.1

package/dist/workspace.js

@@ -58,8 +58,23 @@ function reportProgress(onProgress, event) {
 function shellQuote(value) {
   return `'` + value.split(`'`).join(`'\\''`) + `'`;
 }
-async function sh(sandbox, script) {
-  return sandbox.executeCommand("sh", ["-c", script]);
+var DEFAULT_COMMAND_TIMEOUT_MS = 15 * 6e4;
+var CHECKOUT_COMMAND_TIMEOUT_MS = 5 * 6e4;
+async function sh(sandbox, script, options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
+  let timer;
+  const hangGuard = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      const phase = options.phase ? ` during ${options.phase}` : "";
+      reject(new Error(`Sandbox command timed out after ${Math.round(timeoutMs / 1e3)}s${phase}.`));
+    }, timeoutMs);
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([sandbox.executeCommand("sh", ["-c", script], { timeout: timeoutMs }), hangGuard]);
+  } finally {
+    clearTimeout(timer);
+  }
 }
 var MaterializeError = class extends Error {
   constructor(message, code) {
@@ -96,7 +111,8 @@ async function materializeRepo(options) {
     );
   }
   const authUrl = tokenUrl(repo, token);
-  const alreadyMaterialized = Boolean(sandboxRow.materializedAt) || await hasExistingCheckout(sandbox, workdir, repo);
+  const alreadyMaterialized = await hasExistingCheckout(sandbox, workdir, repo);
+  let succeeded = false;
   try {
     if (!alreadyMaterialized) {
       reportProgress(onProgress, {
@@ -105,7 +121,8 @@ async function materializeRepo(options) {
       });
       const clone = await sh(
         sandbox,
-        `git clone --depth=1 --single-branch --branch ${shellQuote(repoInfo.defaultBranch)} ${shellQuote(authUrl)} ${shellQuote(workdir)}`
+        `git clone --depth=1 --single-branch --branch ${shellQuote(repoInfo.defaultBranch)} ${shellQuote(authUrl)} ${shellQuote(workdir)}`,
+        { phase: "repository clone" }
       );
       if (clone.exitCode !== 0) {
         throw classifyGitFailure(clone, "clone-failed");
@@ -116,13 +133,14 @@ async function materializeRepo(options) {
       if (setUrl.exitCode !== 0) {
         throw new MaterializeError(`Failed to set git remote: ${setUrl.stderr}`, "pull-failed");
       }
-      const pull = await sh(sandbox, `git -C ${shellQuote(workdir)} pull --ff-only`);
+      const pull = await sh(sandbox, `git -C ${shellQuote(workdir)} pull --ff-only`, { phase: "repository pull" });
       if (pull.exitCode !== 0) {
         throw classifyGitFailure(pull, "pull-failed");
       }
     }
+    succeeded = true;
   } finally {
-    await scrubRemote(sandbox, workdir, repo, alreadyMaterialized);
+    await scrubRemote(sandbox, workdir, repo, succeeded);
   }
   reportProgress(onProgress, { phase: "finalizing", message: "Finalizing workspace\u2026" });
   await storage.markMaterialized({ id: sandboxRow.id });
@@ -153,7 +171,8 @@ async function checkoutSessionBranch(sandbox, workdir, {
     if (setUrl.exitCode !== 0) throw classifyGitFailure(setUrl, "pull-failed");
     const fetch = await sh(
       sandbox,
-      `git -C ${shellQuote(workdir)} fetch origin ${shellQuote(baseBranch)} && git -C ${shellQuote(workdir)} checkout -b ${shellQuote(branch)} FETCH_HEAD`
+      `git -C ${shellQuote(workdir)} fetch origin ${shellQuote(baseBranch)} && git -C ${shellQuote(workdir)} checkout -b ${shellQuote(branch)} FETCH_HEAD`,
+      { timeoutMs: CHECKOUT_COMMAND_TIMEOUT_MS, phase: "branch checkout" }
     );
     if (fetch.exitCode !== 0) throw classifyGitFailure(fetch, "clone-failed");
   } finally {
@@ -205,7 +224,7 @@ var WorktreeError = class extends Error {
 };
 async function runWorktreeSetup(sandbox, worktreePath, command) {
   const result = await sh(sandbox, `cd ${shellQuote(worktreePath)} && { ${command}
-}`);
+}`, { phase: "worktree setup" });
   if (result.exitCode !== 0) {
     const detail = (result.stderr.trim() || result.stdout.trim()).slice(-2e3);
     throw new WorktreeError(`Setup command failed (exit ${result.exitCode}): ${detail}`, "setup-failed");
@@ -312,6 +331,7 @@ function createWorkspaceFactory(options = {}) {
   const { sandbox: sandboxConfig, github, fleet, workItems } = options;
   const isLocalSandbox = sandboxConfig?.machine instanceof LocalSandbox;
   const githubTokenInjectors = /* @__PURE__ */ new Map();
+  const inflightMaterializations = /* @__PURE__ */ new Map();
   return async ({ requestContext, mastra, skillExtension }) => {
     const effectiveSkillExtension = skillExtension ?? factorySkillExtension;
     const ctx = requestContext.get("controller");
@@ -379,65 +399,84 @@ function createWorkspaceFactory(options = {}) {
       }
     } catch {
     }
-    const access = await github.versionControl.getRepositoryAccess({
-      orgId: session.orgId,
-      repositoryId: repository.id
-    });
-    const token = access.authorization?.token;
-    if (!token) throw new Error("Repository access did not include a bearer token for the Factory session");
-    let patKind = "default";
-    if (workItems) {
-      try {
-        const address = getFactorySessionAddress(requestContext);
-        const runBinding = address ? await workItems.findRunBindingBySession(address) : null;
-        if (runBinding?.role === "review" && runBinding.orgId === session.orgId) patKind = "reviewer";
-      } catch {
-      }
-    }
-    const ghCliToken = await getGithubPat(() => github.integrationStorage, session.orgId, patKind) ?? token;
-    const sandbox = await fleet.ensureSandbox(
-      binding,
-      { GH_TOKEN: ghCliToken },
-      void 0,
-      isLocalSandbox ? { workingDirectory: workdir } : {}
-    );
-    await materializeRepo({
-      row: { id: session.id, sandboxWorkdir: workdir, materializedAt: session.materializedAt },
-      repoInfo: { repoFullName, defaultBranch: repository.defaultBranch },
-      sandbox,
-      token,
-      storage: storage.sessions
-    });
-    await checkoutSessionBranch(sandbox, workdir, {
-      branch: session.branch,
-      baseBranch: session.baseBranch || projectRepository.branch || repository.defaultBranch,
-      token,
-      repoFullName
-    });
-    if (projectRepository.setupCommand) await runWorktreeSetup(sandbox, workdir, projectRepository.setupCommand);
-    const injectGithubToken = (freshToken) => {
-      if (!sandbox.setEnvironmentVariable) {
-        throw new Error("The active sandbox provider does not support runtime GitHub token refresh.");
+    const materialize = async () => {
+      const access = await github.versionControl.getRepositoryAccess({
+        orgId: session.orgId,
+        repositoryId: repository.id
+      });
+      const token = access.authorization?.token;
+      if (!token) throw new Error("Repository access did not include a bearer token for the Factory session");
+      let patKind = "default";
+      if (workItems) {
+        try {
+          const address = getFactorySessionAddress(requestContext);
+          const runBinding = address ? await workItems.findRunBindingBySession(address) : null;
+          if (runBinding?.role === "review" && runBinding.orgId === session.orgId) patKind = "reviewer";
+        } catch {
+        }
       }
-      sandbox.setEnvironmentVariable("GH_TOKEN", freshToken);
-      const registered = githubTokenInjectors.get(workspaceId);
-      if (registered) registered.ghToken = freshToken;
+      const ghCliToken = await getGithubPat(() => github.integrationStorage, session.orgId, patKind) ?? token;
+      const sandbox = await fleet.ensureSandbox(
+        binding,
+        { GH_TOKEN: ghCliToken },
+        void 0,
+        isLocalSandbox ? { workingDirectory: workdir } : {}
+      );
+      await materializeRepo({
+        row: { id: session.id, sandboxWorkdir: workdir, materializedAt: session.materializedAt },
+        repoInfo: { repoFullName, defaultBranch: repository.defaultBranch },
+        sandbox,
+        token,
+        storage: storage.sessions
+      });
+      await checkoutSessionBranch(sandbox, workdir, {
+        branch: session.branch,
+        baseBranch: session.baseBranch || projectRepository.branch || repository.defaultBranch,
+        token,
+        repoFullName
+      });
+      if (projectRepository.setupCommand) await runWorktreeSetup(sandbox, workdir, projectRepository.setupCommand);
+      const injectGithubToken = (freshToken) => {
+        if (!sandbox.setEnvironmentVariable) {
+          throw new Error("The active sandbox provider does not support runtime GitHub token refresh.");
+        }
+        sandbox.setEnvironmentVariable("GH_TOKEN", freshToken);
+        const registered = githubTokenInjectors.get(workspaceId);
+        if (registered) registered.ghToken = freshToken;
+      };
+      githubTokenInjectors.set(workspaceId, { inject: injectGithubToken, patKind, ghToken: ghCliToken });
+      registerGithubTokenInjector(requestContext, injectGithubToken);
+      registerGithubPatKind(requestContext, patKind);
+      const filesystem = new SandboxFilesystem({ sandbox, workdir });
+      const projectSkillPaths = [path2.join(configDir, "skills"), ".claude/skills", ".agents/skills"];
+      const skillPaths = [...effectiveSkillExtension?.paths ?? [], ...projectSkillPaths];
+      return new Workspace({
+        id: workspaceId,
+        name: "Mastra Code Factory Session Workspace",
+        filesystem,
+        sandbox,
+        tools: MASTRACODE_WORKSPACE_TOOLS,
+        skills: skillPaths,
+        skillSource: effectiveSkillExtension?.createSource(filesystem, projectSkillPaths) ?? filesystem
+      });
     };
-    githubTokenInjectors.set(workspaceId, { inject: injectGithubToken, patKind, ghToken: ghCliToken });
-    registerGithubTokenInjector(requestContext, injectGithubToken);
-    registerGithubPatKind(requestContext, patKind);
-    const filesystem = new SandboxFilesystem({ sandbox, workdir });
-    const projectSkillPaths = [path2.join(configDir, "skills"), ".claude/skills", ".agents/skills"];
-    const skillPaths = [...effectiveSkillExtension?.paths ?? [], ...projectSkillPaths];
-    return new Workspace({
-      id: workspaceId,
-      name: "Mastra Code Factory Session Workspace",
-      filesystem,
-      sandbox,
-      tools: MASTRACODE_WORKSPACE_TOOLS,
-      skills: skillPaths,
-      skillSource: effectiveSkillExtension?.createSource(filesystem, projectSkillPaths) ?? filesystem
-    });
+    const inflight = inflightMaterializations.get(workspaceId);
+    if (inflight) {
+      const workspace = await inflight;
+      const registered = githubTokenInjectors.get(workspaceId);
+      if (registered) {
+        registerGithubTokenInjector(requestContext, registered.inject);
+        registerGithubPatKind(requestContext, registered.patKind);
+      }
+      return workspace;
+    }
+    const materialization = materialize();
+    inflightMaterializations.set(workspaceId, materialization);
+    try {
+      return await materialization;
+    } finally {
+      inflightMaterializations.delete(workspaceId);
+    }
   };
 }
 var getFactoryWorkspace = createWorkspaceFactory();