@mastra/factory 0.24.0-alpha.9 → 0.25.0-alpha.0

package/dist/routes/source-control-sessions.js

@@ -1,21 +1,26 @@
 import { isValidGitRef } from "../sandbox/git-ref.js";
+import { canReadSessionResource, canSwitchSessionModel, canViewSourceControlSession } from "./session-access.js";
 import { waitForPendingFilesystemCapture } from "../session/filesystem-capture.js";
+import { isRunBound, isWorkerSession, listFactorySessionThreads, sessionMemoryResourceId, sessionThreadsToMove, userSessionResourceFor } from "../session/session-threads.js";
 import { normalizeSessionTitle } from "../session/session-title.js";
 import { reclaimDeletedSessionSandbox } from "../integrations/github/sandbox-release.js";
 import { seedSessionOrg } from "../session/org-seed.js";
+import { SESSION_OWNER_SIGNAL_TAG } from "../session-owner-signal.js";
 import { RequestContext } from "@mastra/core/request-context";
 import { registerApiRoute } from "@mastra/core/server";
 import { UniqueViolationError } from "@mastra/core/storage";
 import { resolveModel } from "@mastra/code-sdk/agents/model";
+import { createSignal } from "@mastra/core/signals";
 //#region src/routes/source-control-sessions.ts
 function loose(c) {
 	return c;
 }
 const USER_SESSION_BRANCH_PREFIX = "user/session-";
+const SLACK_SESSION_BRANCH_PREFIX = "slack/";
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 const MAX_SESSION_OWNER_PROFILES = 100;
 const MAX_SESSION_OWNER_PROFILE_CACHE_ENTRIES = 500;
-const SESSION_OWNER_PROFILE_TTL_MS = 5 * 6e4;
+const SESSION_OWNER_PROFILE_TTL_MS = 3e5;
 const ABORT_SETTLE_TIMEOUT_MS = 5e3;
 const ABORT_SETTLE_POLL_MS = 50;
 /**
@@ -33,25 +38,58 @@ async function sessionManagePermission(c, auth, tenant, session) {
 function canRecreateSandbox(options) {
 	return Boolean(options.sessionRetirement) && options.sandboxRecreateSupported === true;
 }
-function withCapabilities(session, recreateSandbox) {
+function withCapabilities(session, capabilities) {
 	return {
 		...session,
-		capabilities: { recreateSandbox }
+		capabilities
 	};
 }
+async function ownershipRefusal(session, options) {
+	if (!session.factoryProjectId) return {
+		status: 409,
+		error: "This session isn't linked to a Factory, so it can't change owner."
+	};
+	if (!options.workItems) return {
+		status: 503,
+		error: "Session ownership can't change yet: Factory storage is still starting up. Try again in a moment."
+	};
+	if (session.branch.startsWith(SLACK_SESSION_BRANCH_PREFIX) || await isWorkerSession(session, options.workItems)) return {
+		status: 409,
+		error: "Only user sessions can change owner"
+	};
+	return null;
+}
+/** Marks the takeover in every thread of the session: the transcript draws it as a divider and the model reads it as context. */
+async function markOwnerChange(options, session, newOwner) {
+	const { controller } = options;
+	const memory = await controller?.getMastra()?.getStorage()?.getStore("memory");
+	if (!controller || !memory) return;
+	const threads = await listFactorySessionThreads(controller, session, options.workItems);
+	if (threads.length === 0) return;
+	const contents = `${newOwner.name ?? "A teammate"} took ownership`;
+	await memory.saveMessages({ messages: threads.map((thread) => createSignal({
+		type: "reactive",
+		tagName: SESSION_OWNER_SIGNAL_TAG,
+		contents,
+		author: newOwner
+	}).toDBMessage({
+		threadId: thread.id,
+		resourceId: thread.resourceId
+	})) });
+}
 /** Abort the session's active run and wait (bounded) for it to stop. Returns whether a run was aborted. */
 async function abortActiveRun(controller, sessionId, settleTimeoutMs) {
 	if (!controller) return false;
 	try {
-		const live = await controller.getSessionByResource(sessionId);
+		const live = await controller.getSession(sessionId);
 		if (!live?.stream.isActive()) return false;
 		live.abort();
 		const deadline = Date.now() + settleTimeoutMs;
 		while (live.stream.isActive() && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, ABORT_SETTLE_POLL_MS));
-		if (live.stream.isActive()) console.warn("[Factory Sessions] Aborted run did not settle before sandbox recreate", { sessionId });
+		if (live.stream.isActive()) console.warn("[Factory Sessions] Aborted run did not settle in time", { sessionId });
 		return true;
 	} catch (error) {
-		console.warn("[Factory Sessions] Failed to abort the active run before sandbox recreate", {
+		console.warn("[Factory Sessions] Failed to abort the active run", {
 			sessionId,
 			error
 		});
@@ -109,14 +147,25 @@ async function resolveSession(sourceControls, sessionId) {
 	if (matches.length > 1) throw new Error("Factory session exists in multiple source-control providers.");
 	return matches[0] ?? null;
 }
+async function resolveReadableSession(options, sessionId, viewer) {
+	const match = await resolveSession(options.sourceControls, sessionId);
+	if (!match || !canViewSourceControlSession(match.session, viewer)) return null;
+	const resourceId = await sessionMemoryResourceId(options.controller, match.session, options.workItems);
+	if (!canReadSessionResource(match.session, resourceId, viewer)) return null;
+	return {
+		...match,
+		resourceId
+	};
+}
 /**
-* Start the live conversation for a user session on its own thread (thread id === session id). Agent-controller
+* Start the live conversation for a user session on its own thread (thread id === session id), under the resource
+* its visibility gives it. Agent-controller
 * routes only act on started sessions, so the first prompt the page sends right after creation always lands on the
 * thread the page reads, with the org and Factory address already in state. Get-or-create, so retried or repeated
 * creates are safe.
 */
-async function startUserSessionConversation(controller, session) {
-	if (!controller) return;
+async function startUserSessionConversation(controller, session, resourceId = userSessionResourceFor(session, session.visibility === "org" ? "org" : "private")) {
+	if (!controller) return void 0;
 	const requestContext = new RequestContext();
 	requestContext.set("user", {
 		workosId: session.userId,
@@ -124,7 +173,7 @@ async function startUserSessionConversation(controller, session) {
 	});
 	const live = await controller.createSession({
 		id: session.sessionId,
-		resourceId: session.sessionId,
+		resourceId,
 		threadId: session.sessionId,
 		ownerId: session.userId,
 		requestContext
@@ -134,6 +183,7 @@ async function startUserSessionConversation(controller, session) {
 		factoryProjectId: session.factoryProjectId,
 		...session.projectRepositoryId ? { projectRepositoryId: session.projectRepositoryId } : {}
 	});
+	return live;
 }
 function isJsonObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -148,6 +198,10 @@ function createSessionNaming() {
 		return started;
 	};
 }
+const OWNER_CONFLICT_MESSAGES = {
+	stale_owner: "Someone else owns this session now",
+	branch_owned: "You already have a session on this branch"
+};
 function titleModel(modelId) {
 	return ({ requestContext }) => resolveModel(modelId, {
 		remapForCodexOAuth: true,
@@ -254,6 +308,8 @@ function projectSessionRoutes(path, options, resolveOwnerProfiles) {
 			const sessionId = requestedSessionId ?? globalThis.crypto.randomUUID();
 			if (body.title !== void 0 && typeof body.title !== "string") return c.json({ error: "Invalid title" }, 400);
 			const normalizedTitle = body.title === void 0 ? null : normalizeSessionTitle(body.title);
+			if (body.visibility !== void 0 && body.visibility !== "private" && body.visibility !== "org") return c.json({ error: "visibility must be 'private' or 'org'" }, 400);
+			const visibility = body.visibility ?? "org";
 			let branch;
 			if (body.branch === void 0) branch = `${USER_SESSION_BRANCH_PREFIX}${sessionId}`;
 			else if (isValidGitRef(body.branch)) branch = body.branch;
@@ -263,7 +319,11 @@ function projectSessionRoutes(path, options, resolveOwnerProfiles) {
 				if (existing) {
 					if (existing.projectRepositoryId !== project.project.id || existing.orgId !== orgId || existing.userId !== userId || existing.branch !== branch) return c.json({ error: "Session ID conflict" }, 409);
 					await startUserSessionConversation(options.controller, existing);
-					return c.json({ session: withCapabilities(existing, canRecreateSandbox(options)) });
+					return c.json({ session: withCapabilities(existing, {
+						recreateSandbox: canRecreateSandbox(options),
+						takeOwnership: false,
+						switchModel: true
+					}) });
 				}
 			}
 			const session = await project.sourceControl.sessions.create({
@@ -275,7 +335,7 @@ function projectSessionRoutes(path, options, resolveOwnerProfiles) {
 				branch,
 				baseBranch,
 				title: normalizedTitle,
-				visibility: "org"
+				visibility
 			}).catch(async (error) => {
 				if (!(error instanceof UniqueViolationError) || !requestedSessionId) throw error;
 				const conflict = await project.sourceControl.sessions.getBySessionId(sessionId);
@@ -284,7 +344,11 @@ function projectSessionRoutes(path, options, resolveOwnerProfiles) {
 			});
 			if (requestedSessionId && (session.sessionId !== sessionId || session.projectRepositoryId !== project.project.id || session.orgId !== orgId || session.userId !== userId || session.branch !== branch)) return c.json({ error: "Session ID conflict" }, 409);
 			await startUserSessionConversation(options.controller, session);
-			return c.json({ session: withCapabilities(session, canRecreateSandbox(options)) });
+			return c.json({ session: withCapabilities(session, {
+				recreateSandbox: canRecreateSandbox(options),
+				takeOwnership: false,
+				switchModel: true
+			}) });
 		}
 	})];
 }
@@ -322,11 +386,47 @@ function buildSourceControlSessionRoutes(options) {
 			handler: async (c) => {
 				const resolved = await resolveOrgTenant(loose(c), options.auth);
 				if ("response" in resolved) return resolved.response;
-				const session = (await resolveSession(options.sourceControls, c.req.param("sessionId")))?.session;
-				if (!session || session.orgId !== resolved.tenant.orgId || session.visibility === "private" && session.userId !== resolved.tenant.userId) return c.json({ error: "Session not found" }, 404);
+				const readable = await resolveReadableSession(options, c.req.param("sessionId"), resolved.tenant);
+				if (!readable) return c.json({ error: "Session not found" }, 404);
+				const { session, resourceId } = readable;
 				const owners = await resolveOwnerProfiles([session.userId]);
 				const recreateSandbox = canRecreateSandbox(options) && await sessionManagePermission(loose(c), options.auth, resolved.tenant, session) === "allowed";
-				return c.json({ session: withCapabilities(withOwnerProfile(session, owners), recreateSandbox) });
+				const takeOwnership = session.userId !== resolved.tenant.userId && await ownershipRefusal(session, options) === null;
+				return c.json({ session: {
+					...withCapabilities(withOwnerProfile(session, owners), {
+						recreateSandbox,
+						takeOwnership,
+						switchModel: canSwitchSessionModel(session, resolved.tenant)
+					}),
+					resourceId
+				} });
+			}
+		}),
+		registerApiRoute("/web/user-sessions/:sessionId/sandbox/start", {
+			method: "POST",
+			requiresAuth: false,
+			handler: async (c) => {
+				const resolved = await resolveOrgTenant(loose(c), options.auth);
+				if ("response" in resolved) return resolved.response;
+				const session = (await resolveSession(options.sourceControls, c.req.param("sessionId")))?.session;
+				if (!session) return c.json({ error: "Session not found" }, 404);
+				const permission = await sessionManagePermission(loose(c), options.auth, resolved.tenant, session);
+				if (permission === "not-found") return c.json({ error: "Session not found" }, 404);
+				if (permission === "forbidden") return c.json({ error: "Only the session's owner or an organization admin can start its sandbox." }, 403);
+				const controller = options.controller;
+				if (!controller) return c.json({ error: "Sessions are not available on this server." }, 503);
+				try {
+					const sandbox = (await controller.getSession(session.sessionId) ?? await startUserSessionConversation(controller, session, await sessionMemoryResourceId(controller, session, options.workItems)))?.getWorkspace()?.sandbox;
+					if (!sandbox?.start) return c.json({ error: "This session has no sandbox to start." }, 409);
+					await sandbox.start();
+					return c.json({ started: true });
+				} catch (error) {
+					console.error("[Factory Sessions] Failed to start session sandbox", {
+						sessionId: session.sessionId,
+						error
+					});
+					return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);
+				}
 			}
 		}),
 		registerApiRoute("/web/user-sessions/:sessionId/sandbox/recreate", {
@@ -375,6 +475,82 @@ function buildSourceControlSessionRoutes(options) {
 				}
 			}
 		}),
+		registerApiRoute("/web/user-sessions/:sessionId/owner", {
+			method: "POST",
+			requiresAuth: false,
+			handler: async (c) => {
+				const resolved = await resolveOrgTenant(loose(c), options.auth);
+				if ("response" in resolved) return resolved.response;
+				const { orgId, userId } = resolved.tenant;
+				const sessionId = c.req.param("sessionId");
+				const readable = await resolveReadableSession(options, sessionId, resolved.tenant);
+				if (!readable) return c.json({ error: "Session not found" }, 404);
+				const { sourceControl, session } = readable;
+				let body;
+				try {
+					body = await c.req.json();
+				} catch {
+					return c.json({ error: "Invalid JSON body" }, 400);
+				}
+				if (!isJsonObject(body) || typeof body.expectedOwnerId !== "string" || !body.expectedOwnerId.trim()) return c.json({ error: "Invalid expectedOwnerId" }, 400);
+				const expectedOwnerId = body.expectedOwnerId;
+				if (session.userId === userId) return c.json({ session });
+				const refusal = await ownershipRefusal(session, options);
+				if (refusal) return c.json({ error: refusal.error }, refusal.status);
+				const transferred = await sourceControl.sessions.transferOwner({
+					sessionId,
+					expectedUserId: expectedOwnerId,
+					toUserId: userId
+				});
+				if (transferred.status === "conflict") {
+					const current = transferred.session;
+					if (!current || !canViewSourceControlSession(current, resolved.tenant)) return c.json({ error: "Session not found" }, 404);
+					if (current.userId === userId) return c.json({ session: current });
+					return c.json({
+						error: OWNER_CONFLICT_MESSAGES[transferred.reason],
+						reason: transferred.reason,
+						currentOwnerId: current.userId
+					}, 409);
+				}
+				const controller = options.controller;
+				await abortActiveRun(controller, sessionId, options.abortSettleTimeoutMs ?? ABORT_SETTLE_TIMEOUT_MS);
+				if (controller && await controller.getSession(sessionId)) await controller.deleteSession({ sessionId }).catch((error) => {
+					console.error("[Factory Sessions] Failed to recycle transferred live session", {
+						sessionId,
+						error
+					});
+				});
+				const newOwner = (await resolveOwnerProfiles([userId])).get(userId) ?? { id: userId };
+				await markOwnerChange(options, transferred.session, newOwner).catch((error) => {
+					console.error("[Factory Sessions] Failed to mark the ownership change in the transcript", {
+						sessionId,
+						error
+					});
+				});
+				await options.audit?.record({
+					orgId,
+					actorId: userId,
+					action: "factory.session.owner_transferred",
+					targets: [{
+						type: "session",
+						id: session.id,
+						name: session.title ?? session.branch
+					}],
+					metadata: {
+						fromOwnerId: expectedOwnerId,
+						toOwnerId: userId
+					},
+					factoryProjectId: session.factoryProjectId ?? void 0,
+					projectRepositoryId: session.projectRepositoryId ?? void 0
+				}).catch((error) => {
+					console.error("[Factory Sessions] Failed to record ownership transfer audit event", {
+						sessionId,
+						error
+					});
+				});
+				return c.json({ session: transferred.session });
+			}
+		}),
 		registerApiRoute("/web/user-sessions/:sessionId", {
 			method: "DELETE",
 			requiresAuth: false,
@@ -391,7 +567,7 @@ function buildSourceControlSessionRoutes(options) {
 							error
 						});
 					});
-					await options.controller?.deleteSession({ resourceId: session.sessionId });
+					await options.controller?.deleteSession({ sessionId: session.sessionId });
 				} catch (error) {
 					console.error("[Factory Sessions] Failed to tear down live controller session", {
 						sessionId: session.sessionId,
@@ -422,6 +598,50 @@ function buildSourceControlSessionRoutes(options) {
 				return c.json({ removed: true });
 			}
 		}),
+		registerApiRoute("/web/user-sessions/:sessionId/visibility", {
+			method: "PUT",
+			requiresAuth: false,
+			handler: async (c) => {
+				const resolved = await resolveOrgTenant(loose(c), options.auth);
+				if ("response" in resolved) return resolved.response;
+				const visibility = (await c.req.json().catch(() => void 0))?.visibility;
+				if (visibility !== "private" && visibility !== "org") return c.json({ error: "visibility must be 'private' or 'org'" }, 400);
+				const sessionId = c.req.param("sessionId");
+				const match = await resolveSession(options.sourceControls, sessionId);
+				const row = match?.session;
+				if (!match || !row || row.orgId !== resolved.tenant.orgId || row.userId !== resolved.tenant.userId) return c.json({ error: "Session not found" }, 404);
+				if (!options.workItems) return c.json({ error: "Session visibility can't be changed yet: Factory storage is still starting up. Try again in a moment." }, 503);
+				if (row.branch.startsWith(SLACK_SESSION_BRANCH_PREFIX) || await isRunBound(row, options.workItems)) return c.json({ error: "Only user sessions can change visibility" }, 409);
+				if (visibility === "org" && !row.factoryProjectId) return c.json({ error: "This session isn't linked to a Factory, so it can't be shared." }, 409);
+				const resourceId = userSessionResourceFor(row, visibility);
+				const controller = options.controller;
+				const threadIds = controller ? await sessionThreadsToMove(controller, row, resourceId) : [];
+				if (threadIds.length > 0 && !options.moveThread) return c.json({ error: "Changing session visibility is not available on this server." }, 503);
+				if (controller?.listActiveThreadRuns().some((run) => threadIds.includes(run.threadId))) return c.json({ error: "Wait for the session to finish its run before changing visibility" }, 409);
+				const moveThreads = async (to) => {
+					for (const threadId of threadIds) await options.moveThread({
+						threadId,
+						resourceId: to
+					});
+				};
+				if (visibility === "private") await moveThreads(resourceId);
+				const updated = await match.sourceControl.sessions.setVisibility({
+					sessionId,
+					visibility,
+					expectedUserId: row.userId
+				});
+				if (!updated) {
+					if (visibility === "private") await moveThreads(userSessionResourceFor(row, "org"));
+					return c.json({ error: "Session not found" }, 404);
+				}
+				if (visibility === "org") await moveThreads(resourceId);
+				const live = await controller?.getSession(sessionId);
+				if (live && threadIds.length > 0) await controller.deleteSession({ sessionId });
+				else if (live) await controller.setResourceId(live, { resourceId });
+				const owners = await resolveOwnerProfiles([updated.userId]);
+				return c.json({ session: withOwnerProfile(updated, owners) });
+			}
+		}),
 		registerApiRoute("/web/user-sessions/:sessionId/title", {
 			method: "POST",
 			requiresAuth: false,
@@ -433,7 +653,7 @@ function buildSourceControlSessionRoutes(options) {
 				const row = match?.session;
 				if (!match || !row || row.orgId !== resolved.tenant.orgId || row.userId !== resolved.tenant.userId) return c.json({ error: "Session not found" }, 404);
 				if (!options.controller) return c.json({ error: "Sessions are not available on this server." }, 503);
-				const thread = (await options.controller.queryThreads({ resourceId: sessionId })).sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())[0];
+				const thread = (await listFactorySessionThreads(options.controller, row, options.workItems)).sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())[0];
 				if (!thread) return c.json({ error: "This session has no conversation to name yet." }, 409);
 				const stored = await options.memorySettings.get({
 					orgId: row.orgId,
@@ -448,7 +668,7 @@ function buildSourceControlSessionRoutes(options) {
 					const title = await nameSession(sessionId, async () => {
 						const generated = await options.controller.generateThreadTitle({
 							threadId: thread.id,
-							resourceId: sessionId,
+							sessionId,
 							requestContext,
 							...stored?.observerModelId ? { model: titleModel(stored.observerModelId) } : {}
 						});