agents 0.22.0 → 0.23.0

package/dist/skills/index.js

@@ -1097,11 +1097,158 @@ function runner(options) {
 	} };
 }
 //#endregion
+//#region src/skills/workspace.ts
+/** @internal Parse and adapt a Computer or legacy Shell Workspace. */
+function createSkillWorkspaceFiles(workspace, rootOverride) {
+	const computer = isComputerWorkspace(workspace);
+	const root = parseRoot(rootOverride ?? (computer ? "/workspace/.agents/skills" : "/.agents/skills"));
+	const exists = async (path) => {
+		try {
+			const stat = computer ? await workspace.fs.stat(path) : await workspace.stat(path);
+			return stat !== null && stat !== void 0;
+		} catch (error) {
+			if (isNotFound(error)) return false;
+			throw error;
+		}
+	};
+	const readText = async (path) => {
+		try {
+			return computer ? await workspace.fs.readFile(path, "utf8") : await workspace.readFile(path);
+		} catch (error) {
+			if (isNotFound(error)) return null;
+			throw error;
+		}
+	};
+	const readBytes = async (path) => {
+		if (!computer) return workspace.readFileBytes(path);
+		try {
+			return await drain(await workspace.fs.readFile(path));
+		} catch (error) {
+			if (isNotFound(error)) return null;
+			throw error;
+		}
+	};
+	const mkdirParent = async (path) => {
+		const parent = path.slice(0, path.lastIndexOf("/"));
+		if (!parent) return;
+		if (computer) await workspace.fs.mkdir(parent, { recursive: true });
+		else await workspace.mkdir(parent, { recursive: true });
+	};
+	return {
+		root,
+		path(name, relativePath) {
+			return `${root}/${parseSkillDirectoryName(name)}/${parseRelativePath(relativePath)}`;
+		},
+		exists,
+		readText,
+		async readResource(path, descriptor) {
+			if ((descriptor.encoding ?? "text") === "text") {
+				const content = await readText(path);
+				return content === null ? null : {
+					...descriptor,
+					content
+				};
+			}
+			const bytes = await readBytes(path);
+			return bytes === null ? null : {
+				...descriptor,
+				content: encodeBase64(bytes)
+			};
+		},
+		async writeText(path, content) {
+			await mkdirParent(path);
+			if (computer) await workspace.fs.writeFile(path, content);
+			else await workspace.writeFile(path, content);
+		},
+		async writeResource(path, resource) {
+			await mkdirParent(path);
+			if ((resource.encoding ?? "text") === "text") {
+				if (computer) await workspace.fs.writeFile(path, resource.content);
+				else await workspace.writeFile(path, resource.content);
+				return;
+			}
+			const bytes = decodeBase64(resource.content);
+			if (computer) await workspace.fs.writeFile(path, bytes);
+			else await workspace.writeFileBytes(path, bytes, resource.mimeType);
+		}
+	};
+}
+function isComputerWorkspace(workspace) {
+	return "fs" in workspace;
+}
+function parseRoot(root) {
+	if (!root.startsWith("/") || root.includes("\0") || root.split("/").some((part) => part === "." || part === "..")) throw new Error(`Skill Workspace root must be a normalized absolute path: ${root}`);
+	const normalized = root.replace(/\/{2,}/g, "/").replace(/\/$/, "");
+	if (!normalized) throw new Error("Skill Workspace root cannot be /");
+	return normalized;
+}
+function parseSkillDirectoryName(name) {
+	if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name)) throw new Error(`Skill name must be a safe Workspace directory name: ${name}`);
+	return name;
+}
+function parseRelativePath(path) {
+	if (path.startsWith("/") || path.includes("\0") || path.split("/").some((part) => part === "" || part === "." || part === "..")) throw new Error(`Skill file path must be normalized and relative: ${path}`);
+	return path;
+}
+function isNotFound(error) {
+	if (!error || typeof error !== "object") return false;
+	const record = error;
+	return record.code === "ENOENT" || typeof record.message === "string" && /ENOENT|no such file|not found/i.test(record.message);
+}
+async function drain(stream) {
+	const parts = [];
+	let total = 0;
+	const reader = stream.getReader();
+	try {
+		while (true) {
+			const { value, done } = await reader.read();
+			if (done) break;
+			if (!value || value.byteLength === 0) continue;
+			parts.push(value);
+			total += value.byteLength;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	if (parts.length === 1) return parts[0];
+	const bytes = new Uint8Array(total);
+	let offset = 0;
+	for (const part of parts) {
+		bytes.set(part, offset);
+		offset += part.byteLength;
+	}
+	return bytes;
+}
+function decodeBase64(value) {
+	const binary = atob(value);
+	const bytes = new Uint8Array(binary.length);
+	for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+	return bytes;
+}
+function encodeBase64(bytes) {
+	const parts = [];
+	for (let offset = 0; offset < bytes.byteLength; offset += 32768) parts.push(String.fromCharCode(...bytes.subarray(offset, offset + 32768)));
+	return btoa(parts.join(""));
+}
+//#endregion
 //#region src/skills/registry.ts
 const SKILL_CONTEXT_LABEL = "think_skills";
 function stableSourceFingerprint(sources) {
 	return sources.map((source) => `${source.id}:${source.fingerprint}`).join("|");
 }
+function renderSkillMarkdown(skill) {
+	const lines = [
+		"---",
+		`name: ${JSON.stringify(skill.name)}`,
+		`description: ${JSON.stringify(skill.description)}`
+	];
+	if (skill.compatibility) lines.push(`compatibility: ${JSON.stringify(skill.compatibility)}`);
+	if (skill.license) lines.push(`license: ${JSON.stringify(skill.license)}`);
+	if (skill.allowedTools) lines.push(`allowed-tools: ${JSON.stringify(skill.allowedTools)}`);
+	if (skill.metadata) lines.push(`metadata: ${JSON.stringify(skill.metadata)}`);
+	lines.push("---", "", skill.body);
+	return lines.join("\n");
+}
 function wrapSkillContent(skill) {
 	const version = skill.version ? ` version="${skill.version}"` : "";
 	const resourceList = skill.resources?.length ? [
@@ -1137,6 +1284,9 @@ var SkillRegistry = class {
 		this.descriptors = /* @__PURE__ */ new Map();
 		this.sourceBySkill = /* @__PURE__ */ new Map();
 		this.loaded = false;
+		this.workspaceFiles = null;
+		this.workspaceSkillNames = /* @__PURE__ */ new Set();
+		this.workspaceResources = /* @__PURE__ */ new Map();
 		this.sources = sources;
 		this.scriptRunner = scriptRunner;
 	}
@@ -1184,6 +1334,72 @@ var SkillRegistry = class {
 		await this.load();
 		this.warnings.push(...refreshErrors);
 	}
+	/**
+	* Seed resolved Agent Skills into Computer or legacy Shell storage.
+	* Existing files are preserved by default, and become authoritative for
+	* activation, resource reads, and script execution.
+	*/
+	async seedWorkspace(workspace, options = {}) {
+		await this.load();
+		const files = createSkillWorkspaceFiles(workspace, options.root);
+		const result = {
+			written: 0,
+			preserved: 0,
+			skipped: 0,
+			warnings: [],
+			root: files.root
+		};
+		const seeded = /* @__PURE__ */ new Set();
+		const resources = /* @__PURE__ */ new Map();
+		for (const descriptor of this.descriptors.values()) {
+			const source = this.sourceBySkill.get(descriptor.name);
+			let skill = null;
+			try {
+				skill = await source?.load(descriptor.name) ?? null;
+			} catch (error) {
+				result.skipped++;
+				result.warnings.push(`Could not load skill "${descriptor.name}" for Workspace seeding: ${error instanceof Error ? error.message : String(error)}`);
+				continue;
+			}
+			if (!skill) {
+				result.skipped++;
+				result.warnings.push(`Could not load skill "${descriptor.name}" for Workspace seeding.`);
+				continue;
+			}
+			resources.set(descriptor.name, new Map((skill.resources ?? []).map((resource) => [resource.path, resource])));
+			const skillPath = files.path(descriptor.name, "SKILL.md");
+			if (await this.writeSeedFile(files, skillPath, skill.rawContent ?? renderSkillMarkdown(skill), options, result)) seeded.add(descriptor.name);
+		}
+		this.workspaceFiles = files;
+		this.workspaceSkillNames = seeded;
+		this.workspaceResources = resources;
+		return result;
+	}
+	/**
+	* Route skill reads through an already-seeded Workspace without probing or
+	* rewriting its files. Hosts use this when the durable source fingerprint
+	* matches the recorded projection fingerprint.
+	*/
+	async useWorkspace(workspace, options = {}) {
+		await this.load();
+		this.workspaceFiles = createSkillWorkspaceFiles(workspace, options.root);
+		this.workspaceSkillNames = new Set(this.descriptors.keys());
+		this.workspaceResources.clear();
+	}
+	async writeSeedFile(files, path, content, options, result) {
+		try {
+			if (options.onConflict !== "replace" && await files.exists(path)) {
+				result.preserved++;
+				return true;
+			}
+			await files.writeText(path, content);
+			result.written++;
+			return true;
+		} catch {
+			result.skipped++;
+			return false;
+		}
+	}
 	async snapshot() {
 		await this.load();
 		const catalog = [];
@@ -1192,6 +1408,7 @@ var SkillRegistry = class {
 			fingerprint: this.fingerprint,
 			catalogPrompt: catalog.length ? [
 				"Available skills. When a task matches a skill, use activate_skill with its name before proceeding.",
+				...this.workspaceFiles ? [`Skill files are available at ${this.workspaceFiles.root}. Workspace edits affect later activations and resource reads.`] : [],
 				"",
 				...catalog
 			].join("\n") : null
@@ -1203,7 +1420,23 @@ var SkillRegistry = class {
 	async loadSkill(name) {
 		await this.load();
 		const source = this.sourceBySkill.get(name);
-		return source ? source.load(name) : null;
+		if (!source) return null;
+		const original = await source.load(name);
+		if (!original) return null;
+		this.workspaceResources.set(name, new Map((original.resources ?? []).map((resource) => [resource.path, resource])));
+		if (!this.workspaceSkillNames.has(name)) return original;
+		const rawContent = await this.workspaceFiles?.readText(this.workspaceFiles.path(name, "SKILL.md"));
+		if (rawContent === null || rawContent === void 0) return null;
+		const parsed = parseSkillMarkdown(rawContent);
+		if (!parsed) return null;
+		return {
+			...original,
+			...parsed,
+			rawContent,
+			sourceId: original.sourceId,
+			version: original.version,
+			resources: original.resources
+		};
 	}
 	resolveResourceTarget(name, path) {
 		const pathError = validateResourcePath(path);
@@ -1233,6 +1466,24 @@ var SkillRegistry = class {
 	}
 	async readResource(name, path) {
 		const source = this.sourceBySkill.get(name);
+		if (this.workspaceSkillNames.has(name) && this.workspaceFiles) {
+			let descriptor = this.workspaceResources.get(name)?.get(path);
+			if (!descriptor) {
+				const skill = await source?.load(name);
+				const resources = new Map((skill?.resources ?? []).map((resource) => [resource.path, resource]));
+				this.workspaceResources.set(name, resources);
+				descriptor = resources.get(path);
+			}
+			if (!descriptor) return `Resource not found: ${name}/${path}`;
+			const workspacePath = this.workspaceFiles.path(name, path);
+			const existing = await this.workspaceFiles.readResource(workspacePath, descriptor);
+			if (existing) return existing;
+			if (!source?.readResource) return `Skill "${name}" has no readable resources.`;
+			const resource = await source.readResource(name, path);
+			if (!resource) return `Resource not found: ${name}/${path}`;
+			await this.workspaceFiles.writeResource(workspacePath, resource);
+			return resource;
+		}
 		if (!source?.readResource) return `Skill "${name}" has no readable resources.`;
 		return await source.readResource(name, path) ?? `Resource not found: ${name}/${path}`;
 	}
@@ -1296,10 +1547,8 @@ var SkillRegistry = class {
 				const script = skill.resources?.find((resource) => resource.path === path);
 				if (!script) return `Script not found: ${name}/${path}`;
 				if (script.kind !== "script") return `Resource is not a script: ${name}/${path}`;
-				const source = this.sourceBySkill.get(name);
-				if (!source?.readResource) return `Skill "${name}" has no readable resources.`;
-				const resource = await source.readResource(name, path);
-				if (!resource) return `Script not found: ${name}/${path}`;
+				const resource = await this.readResource(name, path);
+				if (typeof resource === "string") return resource;
 				if ((resource.encoding ?? "text") !== "text") return `Script resource must be text, got ${resource.encoding}: ${name}/${path}`;
 				try {
 					return await this.scriptRunner.run({