@mastra/factory 0.2.1 → 0.2.2-alpha.1

package/dist/integrations/platform/github/integration.js

@@ -113,8 +113,23 @@ async function teardownProjectSandbox(options) {
 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) {
@@ -151,7 +166,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, {
@@ -160,7 +176,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");
@@ -171,13 +188,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 });
@@ -1076,43 +1094,56 @@ function buildGithubRoutes(options) {
       handler: async (c) => {
         const resolved = await resolveOrgTenant(loose(c), auth);
         if ("response" in resolved) return resolved.response;
-        const installs = await github.sourceControlStorage.installations.list({ orgId: resolved.tenant.orgId });
+        const orgId = resolved.tenant.orgId;
+        const installs = await github.sourceControlStorage.installations.list({ orgId });
         const query = (c.req.query("q") ?? "").toLowerCase();
-        const repos = [];
+        const listed = await Promise.all(
+          installs.map(async (inst) => {
+            try {
+              return { inst, list: await github.listInstallationRepos(Number(inst.externalId)) };
+            } catch (err) {
+              if (err.status !== 404) throw err;
+              console.error(`[Mastra Factory] pruning stale GitHub installation ${inst.externalId} (404 from GitHub)`);
+              await github.sourceControlStorage.installations.delete({ orgId, id: inst.id });
+              return { inst, list: [] };
+            }
+          })
+        );
+        const matches = [];
         const seenRepositoryIds = /* @__PURE__ */ new Set();
-        for (const inst of installs) {
-          let list;
-          try {
-            list = await github.listInstallationRepos(Number(inst.externalId));
-          } catch (err) {
-            if (err.status !== 404) throw err;
-            console.error(`[Mastra Factory] pruning stale GitHub installation ${inst.externalId} (404 from GitHub)`);
-            await github.sourceControlStorage.installations.delete({ orgId: resolved.tenant.orgId, id: inst.id });
-            continue;
-          }
+        for (const { inst, list } of listed) {
           for (const repo of list) {
             if (query && !repo.fullName.toLowerCase().includes(query)) continue;
             if (seenRepositoryIds.has(repo.id)) continue;
             seenRepositoryIds.add(repo.id);
-            const repository = await github.sourceControlStorage.repositories.upsert({
-              orgId: resolved.tenant.orgId,
-              input: {
-                installationId: inst.id,
-                externalId: repo.id.toString(),
-                slug: repo.fullName,
-                defaultBranch: isValidGitRef2(repo.defaultBranch) ? repo.defaultBranch : "main",
-                providerMetadata: { private: repo.private, owner: repo.owner }
-              }
-            });
-            repos.push({
-              ...repo,
-              installationStorageId: inst.id,
-              repositoryStorageId: repository.id,
-              sandboxProvider: fleet.provider,
-              sandboxWorkdir: fleet.computeWorkdir(repo.fullName)
-            });
+            matches.push({ inst, repo });
           }
         }
+        const repos = new Array(matches.length);
+        const upsertConcurrency = 10;
+        for (let start = 0; start < matches.length; start += upsertConcurrency) {
+          await Promise.all(
+            matches.slice(start, start + upsertConcurrency).map(async ({ inst, repo }, offset) => {
+              const repository = await github.sourceControlStorage.repositories.upsert({
+                orgId,
+                input: {
+                  installationId: inst.id,
+                  externalId: repo.id.toString(),
+                  slug: repo.fullName,
+                  defaultBranch: isValidGitRef2(repo.defaultBranch) ? repo.defaultBranch : "main",
+                  providerMetadata: { private: repo.private, owner: repo.owner }
+                }
+              });
+              repos[start + offset] = {
+                ...repo,
+                installationStorageId: inst.id,
+                repositoryStorageId: repository.id,
+                sandboxProvider: fleet.provider,
+                sandboxWorkdir: fleet.computeWorkdir(repo.fullName)
+              };
+            })
+          );
+        }
         return c.json({ repos });
       }
     })
@@ -1443,8 +1474,25 @@ async function loadOrCreateSandboxRow(github, project, userId) {
   return github.sourceControlStorage.sandboxes.getOrCreate({ projectRepository: project, userId });
 }
 async function prepareProject(options) {
-  const { github, fleet, project, userId, onProgress } = options;
-  const sandboxRow = await loadOrCreateSandboxRow(github, project, userId);
+  const { github, fleet, userId, onProgress } = options;
+  let project = options.project;
+  if (project.sandboxProvider !== fleet.provider) {
+    const sandboxWorkdir = fleet.computeWorkdir(project.repository.slug);
+    await github.sourceControlStorage.projectRepositories.update({
+      orgId: project.installation.orgId,
+      id: project.id,
+      input: { sandboxProvider: fleet.provider, sandboxWorkdir }
+    });
+    project = { ...project, sandboxProvider: fleet.provider, sandboxWorkdir };
+  }
+  let sandboxRow = await loadOrCreateSandboxRow(github, project, userId);
+  if (sandboxRow.sandboxWorkdir !== project.sandboxWorkdir) {
+    await github.sourceControlStorage.sandboxes.setWorkdir({
+      id: sandboxRow.id,
+      sandboxWorkdir: project.sandboxWorkdir
+    });
+    sandboxRow = { ...sandboxRow, sandboxWorkdir: project.sandboxWorkdir, materializedAt: null };
+  }
   const access = await github.versionControl.getRepositoryAccess({
     orgId: project.installation.orgId,
     repositoryId: project.repository.id
@@ -3015,6 +3063,17 @@ function retryDelay(error, fallbackMs) {
 // src/integrations/platform/github/integration.ts
 var PAGE_SIZE = 30;
 var API_PREFIX2 = "/v1/server";
+var INSTALLATION_REPOS_CACHE_TTL_MS = 3e4;
+var REPOSITORY_ACCESS_CACHE_TTL_MS = 5 * 6e4;
+var MAX_CACHE_ENTRIES = 1e3;
+function setBounded(cache, key, value) {
+  cache.delete(key);
+  cache.set(key, value);
+  if (cache.size > MAX_CACHE_ENTRIES) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) cache.delete(oldest);
+  }
+}
 var REPOSITORY_TOKEN_PERMISSIONS = {
   contents: "write",
   issues: "write",
@@ -3034,6 +3093,10 @@ var PlatformGithubIntegration = class {
   #pollingIntervalMs;
   #storage;
   #integrationStorage;
+  /** installationId → cached repository listing (TTL-bounded). */
+  #installationReposCache = /* @__PURE__ */ new Map();
+  /** `orgId:repositoryId` → cached repository access (TTL-bounded). */
+  #repositoryAccessCache = /* @__PURE__ */ new Map();
   intake = {
     resolveIntakeDispatch: (input) => this.#resolveIntakeDispatch(input),
     listSources: async ({ orgId, userId }) => {
@@ -3164,6 +3227,10 @@ var PlatformGithubIntegration = class {
       )
     ),
     getRepositoryAccess: async ({ orgId, repositoryId }) => {
+      const cacheKey = `${orgId}:${repositoryId}`;
+      const cached = this.#repositoryAccessCache.get(cacheKey);
+      if (cached && cached.expiresAt > Date.now()) return cached.access;
+      this.#repositoryAccessCache.delete(cacheKey);
       const repository = await this.storage.repositories.get({ orgId, id: repositoryId });
       if (!repository) throw new Error("Version-control repository not found.");
       const cloneUrl = `https://github.com/${repository.slug}.git`;
@@ -3177,10 +3244,15 @@ var PlatformGithubIntegration = class {
         `${API_PREFIX2}/github-app/installations/${installationId}/token`,
         { repositories: [repositoryName], permissions: REPOSITORY_TOKEN_PERMISSIONS }
       );
-      return {
+      const access = {
         cloneUrl,
         authorization: { scheme: "bearer", token: token.token }
       };
+      setBounded(this.#repositoryAccessCache, cacheKey, {
+        access,
+        expiresAt: Date.now() + REPOSITORY_ACCESS_CACHE_TTL_MS
+      });
+      return access;
     },
     listPullRequests: (input) => this.#listPullRequests(input),
     getPullRequest: (input) => this.#getPullRequest(input),
@@ -3475,8 +3547,16 @@ var PlatformGithubIntegration = class {
     }
   }
   async listInstallationRepos(installationId) {
+    const cached = this.#installationReposCache.get(installationId);
+    if (cached && cached.expiresAt > Date.now()) return cached.repos;
+    this.#installationReposCache.delete(installationId);
     const result = await this.#client.request("GET", `${API_PREFIX2}/github-app/installations/${installationId}/repositories`);
-    return result.repositories.map((repository) => ({ ...repository, installationId }));
+    const repos = result.repositories.map((repository) => ({ ...repository, installationId }));
+    setBounded(this.#installationReposCache, installationId, {
+      repos,
+      expiresAt: Date.now() + INSTALLATION_REPOS_CACHE_TTL_MS
+    });
+    return repos;
   }
   async mintInstallationToken(installationId) {
     const repositories = await this.listInstallationRepos(installationId);