@mastra/react 0.0.0-studio-cli-20260504022012 → 0.0.0-sugared-octave-20261030170102

package/dist/hooks/workspace/index.js

@@ -0,0 +1,584 @@
+import { n as useMastraClient } from "../../mastra-client-context-DQ5z_ze9.js";
+import { a as isNonRetryableError } from "../../query-utils-DvMERIwf.js";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { coreFeatures } from "@mastra/core/features";
+// src/hooks/workspace/client-utils.ts
+/**
+* Checks if a method exists on an object and is callable.
+*/
+function hasMethod(obj, method) {
+	return method in obj && typeof obj[method] === "function";
+}
+// src/hooks/workspace/compatibility.ts
+/**
+* Checks if workspace v1 features are supported by both core and client.
+* This guards against version mismatches between playground-ui, core, and client-js.
+*/
+const isWorkspaceV1Supported = (client) => {
+	const workspaceClientMethods = ["listWorkspaces", "getWorkspace"];
+	const coreSupported = coreFeatures.has("workspaces-v1");
+	const clientSupported = workspaceClientMethods.every((method) => hasMethod(client, method));
+	return coreSupported && clientSupported;
+};
+/**
+* Gets the HTTP status code from an error if present.
+* Supports MastraClientError, fetch Response, and other HTTP client error formats.
+*/
+const getStatusCode = (error) => {
+	if (!error || typeof error !== "object") return void 0;
+	if ("status" in error && typeof error.status === "number") return error.status;
+	if ("statusCode" in error && typeof error.statusCode === "number") return error.statusCode;
+};
+/**
+* Checks if an error has a specific HTTP status code.
+* Supports MastraClientError, fetch Response, and other HTTP client error formats.
+*/
+const hasStatusCode = (error, statusCode) => {
+	return getStatusCode(error) === statusCode;
+};
+/**
+* Checks if an error is a 4xx client error (e.g., 400, 401, 403, 404).
+* Client errors won't resolve with retries.
+*/
+const isClientError = (error) => {
+	const status = getStatusCode(error);
+	return status !== void 0 && status >= 400 && status < 500;
+};
+/**
+* Checks if an error is a "Not Implemented" (501) error from the server.
+* This indicates the server's @mastra/core version doesn't support workspaces.
+*/
+const isWorkspaceNotSupportedError = (error) => {
+	if (hasStatusCode(error, 501)) return true;
+	if (error && typeof error === "object" && "message" in error) {
+		const message = error.message;
+		return message.includes("Workspace v1 not supported") || message.includes("501");
+	}
+	return false;
+};
+/**
+* React Query retry function that doesn't retry on client errors (4xx) or 501 errors.
+* Use this to prevent infinite retries when resources don't exist, access is denied, or workspaces aren't supported.
+*/
+const shouldRetryWorkspaceQuery = (failureCount, error) => {
+	if (isClientError(error)) return false;
+	if (isWorkspaceNotSupportedError(error)) return false;
+	if (isNonRetryableError(error)) return false;
+	return failureCount < 3;
+};
+// src/hooks/workspace/file-type.ts
+const IMAGE_EXTENSIONS = [
+	"png",
+	"jpg",
+	"jpeg",
+	"gif",
+	"svg",
+	"webp",
+	"bmp",
+	"avif",
+	"tiff",
+	"tif"
+];
+const VIDEO_MIME_TYPES = {
+	mp4: "video/mp4",
+	webm: "video/webm",
+	mov: "video/quicktime",
+	m4v: "video/mp4",
+	ogv: "video/ogg"
+};
+const extension = (path) => path.split("/").pop()?.split(".").pop()?.toLowerCase() ?? "";
+const isImageFile = (path, mimeType) => mimeType?.startsWith("image/") || IMAGE_EXTENSIONS.includes(extension(path));
+const isVideoFile = (path, mimeType) => mimeType?.startsWith("video/") || extension(path) in VIDEO_MIME_TYPES;
+/** Media must be read as base64: reading it as utf-8 corrupts the bytes. */
+const isMediaFile = (path) => isImageFile(path) || isVideoFile(path);
+const videoMimeType = (path, mimeType) => mimeType?.startsWith("video/") ? mimeType : VIDEO_MIME_TYPES[extension(path)] ?? "video/mp4";
+const isMarkdownFile = (path) => /\.mdx?$/i.test(path);
+// src/hooks/workspace/use-skills-sh.ts
+/**
+* Search skills on skills.sh (via server proxy)
+*/
+const useSearchSkillsSh = ({ workspaceId, queryOptions }) => {
+	const client = useMastraClient();
+	return useMutation({
+		mutationFn: (query) => {
+			if (!workspaceId) throw new Error("Workspace ID is required");
+			return client.getWorkspace(workspaceId).searchSkillsSh({
+				q: query,
+				limit: 10
+			});
+		},
+		...queryOptions
+	});
+};
+/**
+* Get popular skills from skills.sh (via server proxy, cached for 5 minutes)
+*
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const usePopularSkillsSh = ({ workspaceId, queryOptions }) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"skills-sh",
+			"popular",
+			workspaceId
+		],
+		queryFn: () => {
+			if (!workspaceId) throw new Error("Workspace ID is required");
+			return client.getWorkspace(workspaceId).listPopularSkillsSh({
+				limit: 10,
+				offset: 0
+			});
+		},
+		staleTime: 3e5,
+		...queryOptions
+	});
+};
+/**
+* Preview a skill by fetching its SKILL.md (via server proxy to avoid CORS)
+*
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useSkillPreview = ({ workspaceId, owner, repo, skillPath, queryOptions }) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"skills-sh",
+			"preview",
+			workspaceId,
+			owner,
+			repo,
+			skillPath
+		],
+		queryFn: async () => {
+			if (!workspaceId || !owner || !repo || !skillPath) throw new Error("workspaceId, owner, repo, and skillPath are required");
+			const { content } = await client.getWorkspace(workspaceId).previewSkillsSh({
+				owner,
+				repo,
+				path: skillPath
+			});
+			return content;
+		},
+		retry: false,
+		...queryOptions
+	});
+};
+/**
+* Parse a skill's topSource field to extract GitHub repository info
+*
+* skills.sh topSource formats:
+* - "owner/repo" (e.g., "vercel-labs/agent-skills")
+* - "owner/repo/path" (e.g., "anthropics/skills/frontend-design")
+* - "github.com/owner/repo/path" (full URL format)
+*
+* The skill name is used as the path within the repo when not specified
+*/
+function parseSkillSource(topSource, skillName) {
+	let cleanSource = topSource.replace(/^https?:\/\//, "");
+	cleanSource = cleanSource.replace(/^github\.com\//, "");
+	cleanSource = cleanSource.replace(/\/$/, "");
+	const parts = cleanSource.split("/").filter(Boolean);
+	const [owner, repo] = parts;
+	if (!owner || !repo) return null;
+	let skillPath;
+	if (parts.length > 2) skillPath = parts.slice(2).join("/");
+	else if (skillName) skillPath = skillName;
+	else return null;
+	return {
+		owner,
+		repo,
+		skillPath
+	};
+}
+/**
+* Install a skill by fetching from GitHub and writing to workspace filesystem.
+*/
+const useInstallSkill = ({ queryOptions } = {}) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (params) => {
+			const [owner, repo] = params.repository.split("/");
+			if (!owner || !repo) throw new Error("Invalid repository format. Expected owner/repo");
+			return client.getWorkspace(params.workspaceId).installSkillsSh({
+				owner,
+				repo,
+				skillName: params.skillName,
+				mount: params.mount
+			});
+		},
+		onSuccess: (_, variables) => {
+			queryClient.invalidateQueries({ queryKey: [
+				"workspace",
+				"skills",
+				variables.workspaceId
+			] });
+		},
+		...queryOptions
+	});
+};
+/**
+* Update installed skills by re-fetching from GitHub.
+*/
+const useUpdateSkills = ({ queryOptions } = {}) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (params) => client.getWorkspace(params.workspaceId).updateSkillsSh({ skillName: params.skillName }),
+		onSuccess: (_, variables) => {
+			queryClient.invalidateQueries({ queryKey: [
+				"workspace",
+				"skills",
+				variables.workspaceId
+			] });
+		},
+		...queryOptions
+	});
+};
+/**
+* Remove an installed skill by deleting its directory.
+*/
+const useRemoveSkill = ({ queryOptions } = {}) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (params) => client.getWorkspace(params.workspaceId).removeSkillsSh({ skillName: params.skillName }),
+		onSuccess: (_, variables) => {
+			queryClient.invalidateQueries({ queryKey: [
+				"workspace",
+				"skills",
+				variables.workspaceId
+			] });
+		},
+		...queryOptions
+	});
+};
+// src/hooks/workspace/use-stored-workspaces.ts
+/**
+* Hook to list stored workspaces from the database.
+* These are workspaces that have been persisted via the stored workspaces API,
+* as opposed to runtime-registered workspaces from code-defined agents.
+*/
+const useStoredWorkspaces = ({ queryOptions, ...params } = {}) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: ["stored-workspaces", params],
+		queryFn: async () => {
+			return client.listStoredWorkspaces(params);
+		},
+		...queryOptions
+	});
+};
+// src/hooks/workspace/use-workspace.ts
+function getParentPath(path) {
+	return path.split("/").slice(0, -1).join("/") || (path.startsWith("/") ? "/" : ".");
+}
+/**
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useWorkspaceInfo = ({ workspaceId, queryOptions } = {}) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"workspace",
+			"info",
+			workspaceId
+		],
+		queryFn: async () => {
+			if (!isWorkspaceV1Supported(client)) throw new Error("Workspace v1 not supported by core or client");
+			if (!workspaceId) throw new Error("workspaceId is required");
+			return client.getWorkspace(workspaceId).info();
+		},
+		retry: shouldRetryWorkspaceQuery,
+		...queryOptions,
+		enabled: isWorkspaceV1Supported(client) && (queryOptions?.enabled ?? true)
+	});
+};
+const useWorkspaces = ({ queryOptions } = {}) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: ["workspaces"],
+		queryFn: async () => {
+			if (!isWorkspaceV1Supported(client)) throw new Error("Workspace v1 not supported by core or client");
+			return client.listWorkspaces();
+		},
+		retry: shouldRetryWorkspaceQuery,
+		...queryOptions
+	});
+};
+/**
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useWorkspaceFileStat = ({ path, workspaceId, queryOptions }) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"workspace",
+			"stat",
+			path,
+			workspaceId
+		],
+		queryFn: async () => {
+			if (!isWorkspaceV1Supported(client)) throw new Error("Workspace v1 not supported by core or client");
+			if (!workspaceId) throw new Error("workspaceId is required");
+			return client.getWorkspace(workspaceId).stat(path);
+		},
+		retry: shouldRetryWorkspaceQuery,
+		...queryOptions,
+		enabled: isWorkspaceV1Supported(client) && (queryOptions?.enabled ?? true)
+	});
+};
+const useWriteWorkspaceFile = ({ queryOptions } = {}) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (params) => {
+			if (!isWorkspaceV1Supported(client)) throw new Error("Workspace v1 not supported by core or client");
+			return client.getWorkspace(params.workspaceId).writeFile(params.path, params.content, {
+				encoding: params.encoding,
+				recursive: params.recursive ?? true
+			});
+		},
+		onSuccess: (_, variables) => {
+			const parentPath = getParentPath(variables.path);
+			queryClient.invalidateQueries({ queryKey: [
+				"workspace",
+				"files",
+				parentPath
+			] });
+			queryClient.invalidateQueries({ queryKey: [
+				"workspace",
+				"file",
+				variables.path
+			] });
+		},
+		...queryOptions
+	});
+};
+const useWriteWorkspaceFileFromFile = ({ queryOptions } = {}) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (params) => {
+			if (!isWorkspaceV1Supported(client)) throw new Error("Workspace v1 not supported by core or client");
+			const arrayBuffer = await params.file.arrayBuffer();
+			const base64 = btoa(new Uint8Array(arrayBuffer).reduce((data, byte) => data + String.fromCharCode(byte), ""));
+			return client.getWorkspace(params.workspaceId).writeFile(params.path, base64, {
+				encoding: "base64",
+				recursive: params.recursive ?? true
+			});
+		},
+		onSuccess: (_, variables) => {
+			const parentPath = getParentPath(variables.path);
+			queryClient.invalidateQueries({ queryKey: [
+				"workspace",
+				"files",
+				parentPath
+			] });
+			queryClient.invalidateQueries({ queryKey: [
+				"workspace",
+				"file",
+				variables.path
+			] });
+		},
+		...queryOptions
+	});
+};
+const useDeleteWorkspaceFile = ({ queryOptions } = {}) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (params) => {
+			if (!isWorkspaceV1Supported(client)) throw new Error("Workspace v1 not supported by core or client");
+			return client.getWorkspace(params.workspaceId).delete(params.path, {
+				recursive: params.recursive,
+				force: params.force
+			});
+		},
+		onSuccess: (_, variables) => {
+			const parentPath = getParentPath(variables.path);
+			queryClient.invalidateQueries({ queryKey: [
+				"workspace",
+				"files",
+				parentPath
+			] });
+			queryClient.invalidateQueries({ queryKey: [
+				"workspace",
+				"file",
+				variables.path
+			] });
+		},
+		...queryOptions
+	});
+};
+const useCreateWorkspaceDirectory = ({ queryOptions } = {}) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: async (params) => {
+			if (!isWorkspaceV1Supported(client)) throw new Error("Workspace v1 not supported by core or client");
+			return client.getWorkspace(params.workspaceId).mkdir(params.path, params.recursive);
+		},
+		onSuccess: (_, variables) => {
+			const parentPath = getParentPath(variables.path);
+			queryClient.invalidateQueries({ queryKey: [
+				"workspace",
+				"files",
+				parentPath
+			] });
+		},
+		...queryOptions
+	});
+};
+const useIndexWorkspaceContent = ({ queryOptions } = {}) => {
+	const client = useMastraClient();
+	return useMutation({
+		mutationFn: async (params) => {
+			if (!isWorkspaceV1Supported(client)) throw new Error("Workspace v1 not supported by core or client");
+			return client.getWorkspace(params.workspaceId).index({
+				path: params.path,
+				content: params.content,
+				metadata: params.metadata
+			});
+		},
+		...queryOptions
+	});
+};
+// src/hooks/workspace/use-workspace-directory.ts
+const WORKSPACE_REFETCH_INTERVAL = 1e4;
+function useWorkspaceDirectory({ workspaceId, path, queryOptions }) {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"workspace",
+			workspaceId,
+			"fs",
+			"list",
+			path
+		],
+		queryFn: async () => (await client.getWorkspace(workspaceId).listFiles(path, false)).entries,
+		refetchInterval: WORKSPACE_REFETCH_INTERVAL,
+		...queryOptions
+	});
+}
+// src/hooks/workspace/use-workspace-file-content.ts
+/**
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+function useWorkspaceFileContent({ workspaceId, path, queryOptions }) {
+	const client = useMastraClient();
+	const encoding = path && isMediaFile(path) ? "base64" : void 0;
+	return useQuery({
+		queryKey: [
+			"workspace",
+			workspaceId,
+			"fs",
+			"read",
+			path,
+			encoding
+		],
+		queryFn: () => client.getWorkspace(workspaceId).readFile(path ?? "", encoding),
+		refetchInterval: WORKSPACE_REFETCH_INTERVAL,
+		...queryOptions
+	});
+}
+// src/hooks/workspace/use-workspace-search.ts
+const filePathFromId = (id) => id.replace(/#chunk-\d+$/, "");
+const basename = (path) => path.split("/").filter(Boolean).pop() ?? path;
+const skillFilePath = (result) => result.skillPath ? `${result.skillPath.replace(/\/$/, "")}/SKILL.md` : result.source;
+/** Searches files and skills in parallel; one failing source (e.g. 501 not configured) keeps the other's hits. */
+/**
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+function useWorkspaceSearch({ workspaceId, query, files: searchFiles = true, skills: searchSkills = true, queryOptions }) {
+	const client = useMastraClient();
+	const trimmed = query.trim();
+	return useQuery({
+		queryKey: [
+			"workspace",
+			workspaceId,
+			"search",
+			trimmed,
+			searchFiles,
+			searchSkills
+		],
+		queryFn: async () => {
+			const workspace = client.getWorkspace(workspaceId);
+			const [files, skills] = await Promise.allSettled([searchFiles ? workspace.search({ query: trimmed }) : Promise.reject(/* @__PURE__ */ new Error("File search disabled")), searchSkills ? workspace.searchSkills({ query: trimmed }) : Promise.reject(/* @__PURE__ */ new Error("Skill search disabled"))]);
+			if (files.status === "rejected" && skills.status === "rejected") throw (searchFiles ? files : skills).reason;
+			const hits = /* @__PURE__ */ new Map();
+			const add = (hit) => {
+				const existing = hits.get(hit.path);
+				if (!existing || existing.score < hit.score) hits.set(hit.path, hit);
+			};
+			if (files.status === "fulfilled") for (const result of files.value.results) {
+				const path = filePathFromId(result.id);
+				add({
+					kind: "file",
+					path,
+					label: basename(path),
+					score: result.score
+				});
+			}
+			if (skills.status === "fulfilled") for (const result of skills.value.results) add({
+				kind: "skill",
+				path: skillFilePath(result),
+				label: result.skillName,
+				score: result.score
+			});
+			return [...hits.values()].sort((a, b) => b.score - a.score);
+		},
+		...queryOptions
+	});
+}
+// src/hooks/workspace/use-workspace-skills.ts
+/**
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useWorkspaceSkills = ({ workspaceId, queryOptions } = {}) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"workspace",
+			"skills",
+			workspaceId
+		],
+		queryFn: async () => {
+			if (!isWorkspaceV1Supported(client)) throw new Error("Workspace v1 not supported by core or client");
+			if (!workspaceId) throw new Error("workspaceId is required");
+			return client.getWorkspace(workspaceId).listSkills();
+		},
+		retry: shouldRetryWorkspaceQuery,
+		...queryOptions,
+		enabled: isWorkspaceV1Supported(client) && (queryOptions?.enabled ?? true)
+	});
+};
+/**
+* Hook to get a specific skill from an agent's workspace
+*
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useAgentSkill = ({ agentId, skillName, workspaceId, path, queryOptions }) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"agents",
+			agentId,
+			"skills",
+			skillName,
+			path,
+			workspaceId
+		],
+		queryFn: async () => {
+			if (!isWorkspaceV1Supported(client)) throw new Error("Workspace v1 not supported by core or client");
+			if (!workspaceId) throw new Error("workspaceId is required");
+			return client.getWorkspace(workspaceId).getSkill(skillName, path).details();
+		},
+		retry: shouldRetryWorkspaceQuery,
+		...queryOptions,
+		enabled: isWorkspaceV1Supported(client) && (queryOptions?.enabled ?? true)
+	});
+};
+export { WORKSPACE_REFETCH_INTERVAL, isImageFile, isMarkdownFile, isMediaFile, isVideoFile, isWorkspaceNotSupportedError, isWorkspaceV1Supported, parseSkillSource, shouldRetryWorkspaceQuery, useAgentSkill, useCreateWorkspaceDirectory, useDeleteWorkspaceFile, useIndexWorkspaceContent, useInstallSkill, usePopularSkillsSh, useRemoveSkill, useSearchSkillsSh, useSkillPreview, useStoredWorkspaces, useUpdateSkills, useWorkspaceDirectory, useWorkspaceFileContent, useWorkspaceFileStat, useWorkspaceInfo, useWorkspaceSearch, useWorkspaceSkills, useWorkspaces, useWriteWorkspaceFile, useWriteWorkspaceFileFromFile, videoMimeType };
+
+//# sourceMappingURL=index.js.map