@mastra/factory 0.11.1 → 0.12.0-alpha.1

package/dist/integrations/github/sandbox.js

@@ -1,58 +1,6 @@
 import { timedPhase } from "../../timing.js";
-import { reportProgress } from "../../sandbox/fleet.js";
-import { createHash } from "crypto";
 //#region src/integrations/github/sandbox.ts
 /**
-* Repo materialization for GitHub-backed repositories.
-*
-* A GitHub repo is never cloned onto the server host. Instead each project gets
-* its own isolated sandbox (provisioned by the fleet in `../sandbox/fleet`) and
-* the repo is cloned *inside* that sandbox. The agent's file tools and command
-* tools then operate entirely against the remote checkout.
-*
-* - `ensureProjectSandbox(row)` / `teardownProjectSandbox(row)` bind the fleet's
-*   provision/reattach/teardown lifecycle to the per-(project,user) sandbox row.
-* - `materializeRepo(row, token)` runs `git clone` (first open) or `git pull`
-*   (re-open) inside the sandbox, using a short-lived installation token that is
-*   scrubbed from the git remote afterwards so it never persists in the VM.
-*
-* This module owns everything git/GitHub: clone/pull, commit/push, worktrees,
-* and `gh pr create`. Sandbox provisioning, budgets, and workdir layout live in
-* the fleet module.
-*/
-/** Adapt a per-(project,user) sandbox binding row to the fleet's persistence seam. */
-function bindingStore(row, storage, seedCheckpointName) {
-	return {
-		sandboxId: row.sandboxId,
-		...seedCheckpointName ? { seedCheckpointName } : {},
-		setSandboxId: (id) => id === null ? storage.clearBinding({ id: row.id }) : storage.setSandboxId({
-			id: row.id,
-			sandboxId: id
-		}),
-		clear: () => storage.clearBinding({ id: row.id })
-	};
-}
-/**
-* Provision a new sandbox (persisting its provider id on first open) or
-* reattach to the stored one. Returns a started, live sandbox.
-*/
-async function ensureProjectSandbox(options) {
-	const { fleet, row, storage, token, onProgress, seedCheckpointName } = options;
-	return fleet.ensureSandbox(bindingStore(row, storage, seedCheckpointName), { GH_TOKEN: token }, onProgress, { actingUserId: row.userId });
-}
-/**
-* Tear down a user's sandbox for a project: stop the live VM (best-effort) and
-* clear the persisted `sandboxId`/`materializedAt` on the per-(project,user)
-* binding row so the next open re-provisions cleanly.
-*
-* @param row     the per-(project,user) sandbox binding to tear down
-* @param sandbox an already-reattached live sandbox to stop, when available
-*/
-async function teardownProjectSandbox(options) {
-	const { fleet, row, storage, sandbox } = options;
-	return fleet.teardownSandbox(bindingStore(row, storage), sandbox);
-}
-/**
 * Single-quote a string for safe POSIX shell interpolation. Wraps the value in
 * single quotes and escapes any embedded single quote using the canonical
 * close-quote / escaped-quote / reopen-quote sequence (`'\''`). This is the
@@ -190,13 +138,12 @@ function cleanUrl(repoFullName) {
 * Materialize the repo inside the user's sandbox. Clones on first open, pulls on
 * re-open. Always scrubs the install token from the remote afterwards and sets
 * `materialized_at` on the per-user sandbox binding row.
-*
 */
 async function materializeRepo(options) {
 	return timedPhase("workspace.materialize", () => materializeRepoImpl(options));
 }
 async function materializeRepoImpl(options) {
-	const { row: sandboxRow, repoInfo, sandbox, token, storage, onProgress, skipPullOnExistingCheckout } = options;
+	const { row: sandboxRow, repoInfo, sandbox, token, storage } = options;
 	const workdir = sandboxRow.sandboxWorkdir;
 	const repo = repoInfo.repoFullName;
 	if (!/^[\w.-]+\/[\w.-]+$/.test(repo)) throw new MaterializeError(`Refusing to materialize: invalid repo full name '${repo}'.`, "clone-failed");
@@ -207,18 +154,10 @@ async function materializeRepoImpl(options) {
 	let tokenInRemote = false;
 	try {
 		if (!alreadyMaterialized) {
-			reportProgress(onProgress, {
-				phase: "cloning",
-				message: `Cloning ${repo} (first open can take a minute)…`
-			});
 			await sh(sandbox, `mkdir -p ${shellQuote(workdir)} && find ${shellQuote(workdir)} -mindepth 1 -maxdepth 1 -exec rm -rf -- {} +`);
 			const clone = await gitTransfer(sandbox, `git clone --depth=1 --single-branch --branch ${shellQuote(repoInfo.defaultBranch)} ${shellQuote(authUrl)} ${shellQuote(workdir)}`, {
 				phase: "repository clone",
-				beforeRetry: async (attempt) => {
-					reportProgress(onProgress, {
-						phase: "cloning",
-						message: `Lost the connection to github.com — retrying the clone (attempt ${attempt + 1})…`
-					});
+				beforeRetry: async () => {
 					await sh(sandbox, `mkdir -p ${shellQuote(workdir)} && find ${shellQuote(workdir)} -mindepth 1 -maxdepth 1 -exec rm -rf -- {} +`);
 				}
 			});
@@ -227,68 +166,21 @@ async function materializeRepoImpl(options) {
 				throw classifyGitFailure(clone, "clone-failed");
 			}
 			tokenInRemote = true;
-		} else if (skipPullOnExistingCheckout) {
-			const setUrl = await sh(sandbox, `git -C ${shellQuote(workdir)} remote set-url origin ${shellQuote(authUrl)}`);
-			if (setUrl.exitCode !== 0) throw new MaterializeError(`Failed to set git remote: ${setUrl.stderr}`, "pull-failed");
-			tokenInRemote = true;
 		} else {
-			reportProgress(onProgress, {
-				phase: "pulling",
-				message: `Updating ${repo} to the latest changes…`
-			});
 			const setUrl = await sh(sandbox, `git -C ${shellQuote(workdir)} remote set-url origin ${shellQuote(authUrl)}`);
 			if (setUrl.exitCode !== 0) throw new MaterializeError(`Failed to set git remote: ${setUrl.stderr}`, "pull-failed");
 			tokenInRemote = true;
-			const pull = await gitTransfer(sandbox, `git -C ${shellQuote(workdir)} pull --ff-only`, {
-				phase: "repository pull",
-				beforeRetry: async (attempt) => reportProgress(onProgress, {
-					phase: "pulling",
-					message: `Lost the connection to github.com — retrying the update (attempt ${attempt + 1})…`
-				})
-			});
+			const pull = await gitTransfer(sandbox, `git -C ${shellQuote(workdir)} pull --ff-only`, { phase: "repository pull" });
 			if (pull.exitCode !== 0) {
 				if (!isBenignNonFastForward(pull)) throw classifyGitFailure(pull, "pull-failed");
-				reportProgress(onProgress, {
-					phase: "pulling",
-					message: isDeletedUpstreamRef(pull) ? "Workspace could not be updated from its remote — keeping the existing checkout as-is." : "Workspace has local changes that diverge from the remote — keeping them as-is."
-				});
 			}
 		}
 	} catch (primary) {
 		throw await scrubbedFailure(sandbox, workdir, repo, tokenInRemote, primary, "pull-failed");
 	}
 	await scrubRemote(sandbox, workdir, repo, tokenInRemote);
-	reportProgress(onProgress, {
-		phase: "finalizing",
-		message: "Finalizing workspace…"
-	});
 	await storage.markMaterialized({ id: sandboxRow.id });
 }
-/**
-* Reset a pooled workdir that a new session just claimed: the previous
-* session's branch and dirty state must not leak into the new session, so
-* force-checkout the default branch, drop all local modifications, and delete
-* every other local branch (a surviving branch would otherwise hand the next
-* session for the same branch the previous session's stale tip instead of a
-* fresh fork from the base branch). When the claimed VM was reaped and
-* re-provisioned there is no checkout yet and this is a no-op (the clone path
-* handles it). A wedged checkout falls back to wiping the workdir so
-* `materializeRepo` re-clones inside the same VM instead of permanently
-* failing the session.
-*/
-async function recycleClaimedWorkdir(sandbox, workdir, defaultBranch) {
-	if (!/^[A-Za-z0-9_./-]+$/.test(defaultBranch)) throw new MaterializeError(`Refusing to recycle: invalid default branch '${defaultBranch}'.`, "clone-failed");
-	const w = shellQuote(workdir);
-	if ((await sh(sandbox, `git -C ${w} rev-parse --is-inside-work-tree`)).exitCode !== 0) return;
-	const recycle = await sh(sandbox, `git -C ${w} checkout -f ${shellQuote(defaultBranch)} && git -C ${w} reset --hard && git -C ${w} clean -fdx`, { phase: "claimed workdir recycle" });
-	let failure = recycle;
-	if (recycle.exitCode === 0) {
-		const sweep = await sh(sandbox, `set -e; for ref in $(git -C ${w} for-each-ref --format='%(refname)' refs/heads); do [ "$ref" = ${shellQuote(`refs/heads/${defaultBranch}`)} ] || git -C ${w} update-ref --no-deref -d "$ref"; done`, { phase: "claimed workdir branch sweep" });
-		if (sweep.exitCode === 0) return;
-		failure = sweep;
-	}
-	if ((await sh(sandbox, `rm -rf ${w}`)).exitCode !== 0) throw new MaterializeError(`Failed to recycle claimed sandbox workdir: ${failure.stderr}`, "clone-failed");
-}
 /** Check out a session's branch inside its isolated repository clone. */
 async function checkoutSessionBranch(sandbox, workdir, options) {
 	return timedPhase("workspace.checkout", () => checkoutSessionBranchImpl(sandbox, workdir, options));
@@ -521,7 +413,7 @@ async function pushBranch(sandbox, workdir, branch, token, repoFullName) {
 * error, so callers can safely commit-then-push without first diffing.
 *
 * @param sandbox  the live sandbox containing the checkout
-* @param workdir  the worktree (or repo) path to commit in
+* @param workdir  the session workdir to commit in
 * @param message  the commit message (quoted; arbitrary text is safe)
 * @param identity authorship identity for the commit
 */
@@ -534,81 +426,21 @@ async function commitAll(sandbox, workdir, message, identity) {
 	if (commit.exitCode !== 0) throw new MaterializeError(`git commit failed: ${commit.stderr.trim() || commit.stdout.trim()}`, "commit-failed");
 	return { committed: true };
 }
-/** Error raised when a worktree cannot be created/reused inside the sandbox. */
-var WorktreeError = class extends Error {
+/** Error raised when the org's setup or teardown command fails in the sandbox. */
+var SetupCommandError = class extends Error {
 	code;
 	constructor(message, code) {
 		super(message);
 		this.code = code;
-		this.name = "WorktreeError";
+		this.name = "SetupCommandError";
 	}
 };
 /**
-* Reduce a (already ref-validated) branch name to a filesystem-safe directory
-* segment for the worktree path: slashes/dots/unsafe chars collapsed to `-`.
-* This only affects the *directory name*, never the git branch itself.
-*
-* Sanitization is lossy (e.g. `feat/a` and `feat-a` both reduce to `feat-a`),
-* so an 8-char hash of the original branch is appended whenever the sanitized
-* form differs from the input. That keeps clean names (`main`) readable while
-* guaranteeing distinct branches never share a worktree directory.
-*/
-function safeBranchDir(branch) {
-	const sanitized = branch.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/\/+/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, 100) || "work";
-	if (sanitized === branch) return sanitized;
-	return `${sanitized}-${createHash("sha256").update(branch).digest("hex").slice(0, 8)}`;
-}
-/**
-* Compute the absolute worktree path for a branch, server-side only. Worktrees
-* live alongside the repo checkout under a sibling `worktrees/` directory so the
-* repo's `.git` is shared. Never derived from client-supplied paths.
-*/
-function computeWorktreePath(repoWorkdir, branch) {
-	return `${repoWorkdir.replace(/\/+$/, "").split("/").slice(0, -1).join("/") || ""}/worktrees/${safeBranchDir(branch)}`;
-}
-/**
-* Create (or reuse) a git worktree + branch inside the sandbox for a unit of
-* work. Idempotent: if a worktree already exists at the computed path it is
-* reused. The branch is created from the freshly fetched `origin/<baseBranch>`
-* — never the sandbox's possibly stale local ref — so new worktrees always
-* start from the latest remote state.
-*
-* @param sandbox       live sandbox containing the base checkout
-* @param repoWorkdir   the base repo checkout path inside the sandbox
-* @param branch        the feature branch (ref-validated server-side)
-* @param baseBranch    the branch to fork from (ref-validated; defaults to the repo's default branch)
-* @param token         short-lived installation token used only for the base-branch fetch
-* @param repoFullName  `owner/repo` used to build the tokenized remote URL
-*/
-async function ensureWorktree(sandbox, repoWorkdir, { branch, baseBranch, token, repoFullName }) {
-	if (!isValidGitRef(branch)) throw new WorktreeError(`Invalid branch name '${branch}'.`, "invalid-branch");
-	if (!isValidGitRef(baseBranch)) throw new WorktreeError(`Invalid base branch name '${baseBranch}'.`, "invalid-branch");
-	const worktreePath = computeWorktreePath(repoWorkdir, branch);
-	if ((await sh(sandbox, `test -e ${shellQuote(`${worktreePath}/.git`)}`)).exitCode === 0) return {
-		worktreePath,
-		branch,
-		baseBranch,
-		reused: true
-	};
-	const baseRef = `origin/${baseBranch}`;
-	await withInstallToken(sandbox, repoWorkdir, repoFullName, token, async () => {
-		const fetch = await sh(sandbox, `git -C ${shellQuote(repoWorkdir)} fetch origin ${shellQuote(`+refs/heads/${baseBranch}:refs/remotes/${baseRef}`)}`);
-		if (fetch.exitCode !== 0) throw classifyGitFailure(fetch, "pull-failed");
-	});
-	const add = await sh(sandbox, `git -C ${shellQuote(repoWorkdir)} worktree add --no-track -B ${shellQuote(branch)} ${shellQuote(worktreePath)} ${shellQuote(baseRef)}`);
-	if (add.exitCode !== 0) throw new WorktreeError(`git worktree add failed: ${add.stderr.trim() || add.stdout.trim()}`, "worktree-failed");
-	return {
-		worktreePath,
-		branch,
-		baseBranch,
-		reused: false
-	};
-}
-/**
-* Run the project's setup command (e.g. `pnpm i && pnpm build`) inside a
-* freshly created worktree. Called before the worktree is handed to any agent
-* run so the checkout is ready to build/test. A non-zero exit is a hard error —
-* starting agent work in a half-set-up tree is worse than failing the request.
+* Run the project's setup command (e.g. `pnpm i && pnpm build`) inside the
+* freshly materialized session workdir. Called before the checkout is handed
+* to any agent run so it is ready to build/test. A non-zero exit is a hard
+* error — starting agent work in a half-set-up tree is worse than failing the
+* request.
 *
 * Security model: the command is intentionally arbitrary shell — that is the
 * feature (install deps, build, seed fixtures). It is only configurable by
@@ -620,22 +452,22 @@ async function ensureWorktree(sandbox, repoWorkdir, { branch, baseBranch, token,
 * server host, so it grants no privilege beyond what sandbox access already
 * provides.
 *
-* @param sandbox       live sandbox containing the worktree
-* @param worktreePath  the server-computed worktree path the command runs in
-* @param command       the org-configured setup shell command
+* @param sandbox  live sandbox containing the checkout
+* @param workdir  the server-resolved session workdir the command runs in
+* @param command  the org-configured setup shell command
 */
-async function runWorktreeLifecycleCommand(sandbox, worktreePath, command, options) {
-	const result = await sh(sandbox, `cd ${shellQuote(worktreePath)} && { ${command}\n}`, {
-		phase: `worktree ${options.phase}`,
+async function runLifecycleCommand(sandbox, workdir, command, options) {
+	const result = await sh(sandbox, `cd ${shellQuote(workdir)} && { ${command}\n}`, {
+		phase: `${options.phase} command`,
 		...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {}
 	});
 	if (result.exitCode !== 0) {
 		const detail = (result.stderr.trim() || result.stdout.trim()).slice(-1800);
-		throw new WorktreeError(`${options.phase === "setup" ? "Setup" : "Teardown"} command failed (exit ${result.exitCode}): ${detail}`, options.phase === "setup" ? "setup-failed" : "teardown-failed");
+		throw new SetupCommandError(`${options.phase === "setup" ? "Setup" : "Teardown"} command failed (exit ${result.exitCode}): ${detail}`, options.phase === "setup" ? "setup-failed" : "teardown-failed");
 	}
 }
-async function runWorktreeSetup(sandbox, worktreePath, command) {
-	return runWorktreeLifecycleCommand(sandbox, worktreePath, command, { phase: "setup" });
+async function runSetupCommand(sandbox, workdir, command) {
+	return runLifecycleCommand(sandbox, workdir, command, { phase: "setup" });
 }
 /**
 * Run the repository's best-effort teardown command from the materialized
@@ -643,33 +475,13 @@ async function runWorktreeSetup(sandbox, worktreePath, command) {
 * so the retirement coordinator can log them while still continuing with
 * scrub, pooling/destruction, cache invalidation, and row deletion.
 */
-async function runWorktreeTeardown(sandbox, worktreePath, command, options = {}) {
-	return runWorktreeLifecycleCommand(sandbox, worktreePath, command, {
+async function runTeardownCommand(sandbox, workdir, command, options = {}) {
+	return runLifecycleCommand(sandbox, workdir, command, {
 		phase: "teardown",
 		...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {}
 	});
 }
 /**
-* Remove a worktree (and its local feature branch) from the sandbox. The
-* checkout is removed with `--force` — the caller owns confirming that any
-* uncommitted work in it can be discarded. Idempotent: a worktree whose
-* directory is already gone only has its metadata pruned.
-*
-* @param sandbox       live sandbox containing the base checkout
-* @param repoWorkdir   the base repo checkout path inside the sandbox
-* @param branch        the worktree's feature branch (ref-validated)
-* @param worktreePath  the persisted, server-computed worktree path
-*/
-async function removeWorktree(sandbox, repoWorkdir, { branch, worktreePath }) {
-	if (!isValidGitRef(branch)) throw new WorktreeError(`Invalid branch name '${branch}'.`, "invalid-branch");
-	const remove = await sh(sandbox, `git -C ${shellQuote(repoWorkdir)} worktree remove --force ${shellQuote(worktreePath)}`);
-	if (remove.exitCode !== 0) {
-		await sh(sandbox, `git -C ${shellQuote(repoWorkdir)} worktree prune`);
-		if ((await sh(sandbox, `test -e ${shellQuote(worktreePath)}`)).exitCode === 0) throw new WorktreeError(`git worktree remove failed: ${remove.stderr.trim() || remove.stdout.trim()}`, "worktree-failed");
-	}
-	await sh(sandbox, `git -C ${shellQuote(repoWorkdir)} branch -D ${shellQuote(branch)}`);
-}
-/**
 * Preflight that `gh` is installed in the sandbox. Only called on the PR path so
 * a missing `gh` never blocks clone/open. Surfaces an actionable error naming
 * the sandbox template requirement.
@@ -712,6 +524,6 @@ async function createPullRequest(sandbox, workdir, { token, base, head, title, b
 	return { url };
 }
 //#endregion
-export { CHECKOUT_COMMAND_TIMEOUT_MS, DEFAULT_COMMAND_TIMEOUT_MS, MaterializeError, WorktreeError, checkoutSessionBranch, commitAll, computeWorktreePath, configureGitIdentity, createPullRequest, ensureProjectSandbox, ensureWorktree, hasExistingCheckout, isValidGitRef, materializeRepo, pushBranch, recycleClaimedWorkdir, removeWorktree, resolveGitIdentity, runWorktreeSetup, runWorktreeTeardown, safeBranchDir, sh, shellQuote, teardownProjectSandbox, withInstallToken };
+export { CHECKOUT_COMMAND_TIMEOUT_MS, DEFAULT_COMMAND_TIMEOUT_MS, MaterializeError, SetupCommandError, checkoutSessionBranch, commitAll, configureGitIdentity, createPullRequest, hasExistingCheckout, isValidGitRef, materializeRepo, pushBranch, resolveGitIdentity, runSetupCommand, runTeardownCommand, sh, shellQuote, withInstallToken };
 
 //# sourceMappingURL=sandbox.js.map