@clinebot/core 0.0.11 → 0.0.13

package/src/runtime/commands.test.ts

@@ -0,0 +1,98 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { createUserInstructionConfigWatcher } from "../agents";
+import {
+	listAvailableRuntimeCommandsFromWatcher,
+	resolveRuntimeSlashCommandFromWatcher,
+} from "./commands";
+
+describe("runtime command registry", () => {
+	const tempRoots: string[] = [];
+
+	afterEach(async () => {
+		await Promise.all(
+			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
+		);
+		tempRoots.length = 0;
+	});
+
+	it("lists workflow and skill commands together", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-runtime-commands-"));
+		tempRoots.push(tempRoot);
+		const skillDir = join(tempRoot, "skills", "debug");
+		const workflowsDir = join(tempRoot, "workflows");
+		await mkdir(skillDir, { recursive: true });
+		await mkdir(workflowsDir, { recursive: true });
+		await writeFile(join(skillDir, "SKILL.md"), "Use the debugging skill.");
+		await writeFile(
+			join(workflowsDir, "release.md"),
+			`---
+name: release
+---
+Run the release workflow.`,
+		);
+
+		const watcher = createUserInstructionConfigWatcher({
+			skills: { directories: [join(tempRoot, "skills")] },
+			rules: { directories: [] },
+			workflows: { directories: [workflowsDir] },
+		});
+
+		try {
+			await watcher.start();
+			expect(listAvailableRuntimeCommandsFromWatcher(watcher)).toEqual([
+				{
+					id: "debug",
+					name: "debug",
+					instructions: "Use the debugging skill.",
+					kind: "skill",
+				},
+				{
+					id: "release",
+					name: "release",
+					instructions: "Run the release workflow.",
+					kind: "workflow",
+				},
+			]);
+		} finally {
+			watcher.stop();
+		}
+	});
+
+	it("expands skill and workflow slash commands with workflow precedence", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-runtime-commands-"));
+		tempRoots.push(tempRoot);
+		const skillDir = join(tempRoot, "skills", "ship");
+		const workflowsDir = join(tempRoot, "workflows");
+		await mkdir(skillDir, { recursive: true });
+		await mkdir(workflowsDir, { recursive: true });
+		await writeFile(join(skillDir, "SKILL.md"), "Use the ship skill.");
+		await writeFile(
+			join(workflowsDir, "ship.md"),
+			`---
+name: ship
+---
+Run the ship workflow.`,
+		);
+
+		const watcher = createUserInstructionConfigWatcher({
+			skills: { directories: [join(tempRoot, "skills")] },
+			rules: { directories: [] },
+			workflows: { directories: [workflowsDir] },
+		});
+
+		try {
+			await watcher.start();
+			expect(resolveRuntimeSlashCommandFromWatcher("/ship", watcher)).toBe(
+				"Run the ship workflow.",
+			);
+			expect(resolveRuntimeSlashCommandFromWatcher("/ship now", watcher)).toBe(
+				"Run the ship workflow. now",
+			);
+		} finally {
+			watcher.stop();
+		}
+	});
+});

package/src/runtime/commands.ts

@@ -0,0 +1,83 @@
+import type {
+	SkillConfig,
+	UserInstructionConfigWatcher,
+	WorkflowConfig,
+} from "../agents";
+
+export type RuntimeCommandKind = "skill" | "workflow";
+
+export type AvailableRuntimeCommand = {
+	id: string;
+	name: string;
+	instructions: string;
+	kind: RuntimeCommandKind;
+};
+
+type CommandRecord = {
+	item: SkillConfig | WorkflowConfig;
+};
+
+function isCommandEnabled(command: SkillConfig | WorkflowConfig): boolean {
+	return command.disabled !== true;
+}
+
+function listCommandsForKind(
+	watcher: UserInstructionConfigWatcher,
+	kind: RuntimeCommandKind,
+): AvailableRuntimeCommand[] {
+	return [...watcher.getSnapshot(kind).entries()]
+		.map(([id, record]) => ({ id, record: record as CommandRecord }))
+		.filter(({ record }) => isCommandEnabled(record.item))
+		.map(({ id, record }) => ({
+			id,
+			name: record.item.name,
+			instructions: record.item.instructions,
+			kind,
+		}))
+		.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function listAvailableRuntimeCommandsFromWatcher(
+	watcher: UserInstructionConfigWatcher,
+): AvailableRuntimeCommand[] {
+	const byName = new Map<string, AvailableRuntimeCommand>();
+	for (const command of [
+		...listCommandsForKind(watcher, "workflow"),
+		...listCommandsForKind(watcher, "skill"),
+	]) {
+		if (!byName.has(command.name)) {
+			byName.set(command.name, command);
+		}
+	}
+	return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function resolveRuntimeSlashCommandFromWatcher(
+	input: string,
+	watcher: UserInstructionConfigWatcher,
+): string {
+	if (!input.startsWith("/") || input.length < 2) {
+		return input;
+	}
+	const match = input.match(/^\/(\S+)/);
+	if (!match) {
+		return input;
+	}
+	const name = match[1];
+	if (!name) {
+		return input;
+	}
+	const commandLength = name.length + 1;
+	const remainder = input.slice(commandLength);
+	const matched = listAvailableRuntimeCommandsFromWatcher(watcher).find(
+		(command) => command.name === name,
+	);
+	return matched ? `${matched.instructions}${remainder}` : input;
+}
+
+export function listAvailableRuntimeCommandsForKindFromWatcher(
+	watcher: UserInstructionConfigWatcher,
+	kind: RuntimeCommandKind,
+): AvailableRuntimeCommand[] {
+	return listCommandsForKind(watcher, kind);
+}

package/src/runtime/hook-file-hooks.test.ts

@@ -57,7 +57,7 @@ describe("createHookConfigFileHooks", () => {
 	it("executes extensionless legacy hook files via bash fallback", async () => {
 		const { workspace } = await createWorkspaceWithHook(
 			"PreToolUse",
-			'echo \'HOOK_CONTROL\t{"cancel":true,"context":"legacy-ok"}\'\n',
+			'echo \'HOOK_CONTROL\t{"cancel":true,"context":"legacy-ok"}\'\nexit 0\n',
 		);
 		try {
 			const hooks = createHookConfigFileHooks({

package/src/runtime/hook-file-hooks.ts

@@ -215,13 +215,17 @@ async function writeToChildStdin(
 
 	await new Promise<void>((resolve, reject) => {
 		let settled = false;
+		const cleanup = () => {
+			stdin.off("error", onError);
+			stdin.off("finish", onFinish);
+			child.off("close", onChildClose);
+		};
 		const finish = (error?: Error | null) => {
 			if (settled) {
 				return;
 			}
 			settled = true;
-			stdin.off("error", onError);
-			stdin.off("close", onClose);
+			cleanup();
 			if (error) {
 				const code = (error as Error & { code?: string }).code;
 				if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") {
@@ -234,10 +238,16 @@ async function writeToChildStdin(
 			resolve();
 		};
 		const onError = (error: Error) => finish(error);
-		const onClose = () => finish();
+		const onFinish = () => finish();
+		const onChildClose = () => finish();
 		stdin.on("error", onError);
-		stdin.once("close", onClose);
-		stdin.end(body, (error?: Error | null) => finish(error));
+		stdin.once("finish", onFinish);
+		child.once("close", onChildClose);
+		try {
+			stdin.end(body);
+		} catch (error) {
+			finish(error as Error);
+		}
 	});
 }
 
@@ -270,10 +280,10 @@ async function runHookCommand(
 	});
 
 	const body = JSON.stringify(payload);
+	await Promise.race([spawned, childError]);
 	await writeToChildStdin(child, body);
 
 	if (options.detached) {
-		await Promise.race([spawned, childError]);
 		child.unref();
 		return;
 	}

package/src/runtime/index.ts

@@ -1,3 +1,8 @@
+export {
+	type AvailableRuntimeCommand,
+	listAvailableRuntimeCommandsFromWatcher,
+	resolveRuntimeSlashCommandFromWatcher,
+} from "./commands";
 export {
 	formatRulesForSystemPrompt,
 	isRuleEnabled,
@@ -16,6 +21,11 @@ export type {
 	RuntimeBuilderInput,
 	SessionRuntime,
 } from "./session-runtime";
+export {
+	type AvailableSkill,
+	listAvailableSkillsFromWatcher,
+	resolveSkillsSlashCommandFromWatcher,
+} from "./skills";
 export {
 	type DesktopToolApprovalOptions,
 	requestDesktopToolApproval,

package/src/runtime/runtime-builder.test.ts

@@ -301,4 +301,71 @@ Disabled skill.`,
 
 		runtime.shutdown("test");
 	});
+
+	it("scopes skills tool to session-configured skills", async () => {
+		const cwd = mkdtempSync(join(tmpdir(), "runtime-builder-skills-scoped-"));
+		const commitDir = join(cwd, ".cline", "skills", "commit");
+		const reviewDir = join(cwd, ".cline", "skills", "review");
+		mkdirSync(commitDir, { recursive: true });
+		mkdirSync(reviewDir, { recursive: true });
+		writeFileSync(
+			join(commitDir, "SKILL.md"),
+			`---
+name: commit
+---
+Commit skill.`,
+			"utf8",
+		);
+		writeFileSync(
+			join(reviewDir, "SKILL.md"),
+			`---
+name: review
+---
+Review skill.`,
+			"utf8",
+		);
+
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd,
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+				skills: ["commit"],
+			},
+		});
+
+		const skillsTool = runtime.tools.find((tool) => tool.name === "skills");
+		expect(skillsTool).toBeDefined();
+		if (!skillsTool) {
+			throw new Error("Expected skills tool.");
+		}
+
+		const known = await skillsTool.execute(
+			{ skill: "commit" },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+		expect(known).toContain("<command-name>commit</command-name>");
+
+		const blocked = await skillsTool.execute(
+			{ skill: "review" },
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+		expect(blocked).toContain('Skill "review" not found.');
+		expect(blocked).toContain("Available skills: commit");
+
+		runtime.shutdown("test");
+	});
 });

package/src/runtime/runtime-builder.ts

@@ -86,27 +86,72 @@ const SKILL_FILE_NAME = "SKILL.md";
 
 function listAvailableSkillNames(
 	watcher: UserInstructionConfigWatcher,
+	allowedSkillNames?: ReadonlyArray<string>,
 ): string[] {
-	return listConfiguredSkills(watcher)
+	return listConfiguredSkills(watcher, allowedSkillNames)
 		.filter((skill) => !skill.disabled)
 		.map((skill) => skill.name.trim())
 		.filter((name) => name.length > 0)
 		.sort((a, b) => a.localeCompare(b));
 }
 
+function normalizeSkillToken(token: string): string {
+	return token.trim().replace(/^\/+/, "").toLowerCase();
+}
+
+function toAllowedSkillSet(
+	allowedSkillNames?: ReadonlyArray<string>,
+): Set<string> | undefined {
+	if (!allowedSkillNames || allowedSkillNames.length === 0) {
+		return undefined;
+	}
+	const normalized = allowedSkillNames
+		.map(normalizeSkillToken)
+		.filter((token) => token.length > 0);
+	return normalized.length > 0 ? new Set(normalized) : undefined;
+}
+
+function isSkillAllowed(
+	skillId: string,
+	skillName: string,
+	allowedSkills?: Set<string>,
+): boolean {
+	if (!allowedSkills) {
+		return true;
+	}
+	const normalizedId = normalizeSkillToken(skillId);
+	const normalizedName = normalizeSkillToken(skillName);
+	const bareId = normalizedId.includes(":")
+		? (normalizedId.split(":").at(-1) ?? normalizedId)
+		: normalizedId;
+	const bareName = normalizedName.includes(":")
+		? (normalizedName.split(":").at(-1) ?? normalizedName)
+		: normalizedName;
+	return (
+		allowedSkills.has(normalizedId) ||
+		allowedSkills.has(normalizedName) ||
+		allowedSkills.has(bareId) ||
+		allowedSkills.has(bareName)
+	);
+}
+
 function listConfiguredSkills(
 	watcher: UserInstructionConfigWatcher,
+	allowedSkillNames?: ReadonlyArray<string>,
 ): SkillsExecutorMetadataItem[] {
+	const allowedSkills = toAllowedSkillSet(allowedSkillNames);
 	const snapshot = watcher.getSnapshot("skill");
-	return [...snapshot.entries()].map(([id, record]) => {
-		const skill = record.item as SkillConfig;
-		return {
-			id,
-			name: skill.name.trim(),
-			description: skill.description?.trim(),
-			disabled: skill.disabled === true,
-		};
-	});
+	return [...snapshot.entries()]
+		.map(([id, record]) => {
+			const skill = record.item as SkillConfig;
+			return {
+				id,
+				name: skill.name.trim(),
+				description: skill.description?.trim(),
+				disabled: skill.disabled === true,
+			};
+		})
+		.filter((skill) => isSkillAllowed(skill.id, skill.name, allowedSkills));
 }
 
 function hasSkillsFiles(workspacePath: string): boolean {
@@ -141,14 +186,21 @@ function hasSkillsFiles(workspacePath: string): boolean {
 function resolveSkillRecord(
 	watcher: UserInstructionConfigWatcher,
 	requestedSkill: string,
+	allowedSkillNames?: ReadonlyArray<string>,
 ): { id: string; skill: SkillConfig } | { error: string } {
+	const allowedSkills = toAllowedSkillSet(allowedSkillNames);
 	const normalized = requestedSkill.trim().replace(/^\/+/, "").toLowerCase();
 	if (!normalized) {
 		return { error: "Missing skill name." };
 	}
 
 	const snapshot = watcher.getSnapshot("skill");
-	const exact = snapshot.get(normalized);
+	const scopedEntries = [...snapshot.entries()].filter(([id, record]) => {
+		const skill = record.item as SkillConfig;
+		return isSkillAllowed(id, skill.name, allowedSkills);
+	});
+	const scopedSnapshot = new Map(scopedEntries);
+	const exact = scopedSnapshot.get(normalized);
 	if (exact) {
 		const skill = exact.item as SkillConfig;
 		if (skill.disabled === true) {
@@ -166,7 +218,7 @@ function resolveSkillRecord(
 		? (normalized.split(":").at(-1) ?? normalized)
 		: normalized;
 
-	const suffixMatches = [...snapshot.entries()].filter(([id]) => {
+	const suffixMatches = [...scopedSnapshot.entries()].filter(([id]) => {
 		if (id === bareName) {
 			return true;
 		}
@@ -193,7 +245,7 @@ function resolveSkillRecord(
 		};
 	}
 
-	const available = listAvailableSkillNames(watcher);
+	const available = listAvailableSkillNames(watcher, allowedSkillNames);
 	return {
 		error:
 			available.length > 0
@@ -205,11 +257,12 @@ function resolveSkillRecord(
 function createSkillsExecutor(
 	watcher: UserInstructionConfigWatcher,
 	watcherReady: Promise<void>,
+	allowedSkillNames?: ReadonlyArray<string>,
 ): SkillsExecutorWithMetadata {
 	const runningSkills = new Set<string>();
 	const executor: SkillsExecutorWithMetadata = async (skillName, args) => {
 		await watcherReady;
-		const resolved = resolveSkillRecord(watcher, skillName);
+		const resolved = resolveSkillRecord(watcher, skillName, allowedSkillNames);
 		if ("error" in resolved) {
 			return resolved.error;
 		}
@@ -235,7 +288,7 @@ function createSkillsExecutor(
 		}
 	};
 	Object.defineProperty(executor, "configuredSkills", {
-		get: () => listConfiguredSkills(watcher),
+		get: () => listConfiguredSkills(watcher, allowedSkillNames),
 		enumerable: true,
 		configurable: false,
 	});
@@ -340,11 +393,12 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 			userInstructionWatcher &&
 			(watcherProvided ||
 				hasSkillsFiles(config.cwd) ||
-				listConfiguredSkills(userInstructionWatcher).length > 0)
+				listConfiguredSkills(userInstructionWatcher, config.skills).length > 0)
 		) {
 			skillsExecutor = createSkillsExecutor(
 				userInstructionWatcher,
 				watcherReady,
+				config.skills,
 			);
 		}
 

package/src/runtime/sandbox/subprocess-sandbox.ts

@@ -15,9 +15,19 @@ interface SandboxResponseMessage {
 	error?: { message: string; stack?: string };
 }
 
+interface SandboxEventMessage {
+	type: "event";
+	name: string;
+	payload?: unknown;
+}
+
 export interface SubprocessSandboxOptions {
-	bootstrapScript: string;
+	/** Inline script to execute via `node -e`. Mutually exclusive with {@link bootstrapFile}. */
+	bootstrapScript?: string;
+	/** Path to a JavaScript file to execute via `node <file>`. Mutually exclusive with {@link bootstrapScript}. */
+	bootstrapFile?: string;
 	name?: string;
+	onEvent?: (event: { name: string; payload?: unknown }) => void;
 }
 
 export interface SandboxCallOptions {
@@ -52,16 +62,16 @@ export class SubprocessSandbox {
 			return;
 		}
 
-		const child = spawn(
-			process.execPath,
-			["-e", this.options.bootstrapScript],
-			{
-				stdio: ["ignore", "ignore", "ignore", "ipc"],
-			},
-		);
+		const args = this.options.bootstrapFile
+			? [this.options.bootstrapFile]
+			: ["-e", this.options.bootstrapScript ?? ""];
+
+		const child = spawn(process.execPath, args, {
+			stdio: ["ignore", "ignore", "ignore", "ipc"],
+		});
 		this.process = child;
 		child.on("message", (message) => {
-			this.onMessage(message as SandboxResponseMessage);
+			this.onMessage(message as SandboxResponseMessage | SandboxEventMessage);
 		});
 		child.on("error", (error) => {
 			this.failPending(
@@ -171,8 +181,22 @@ export class SubprocessSandbox {
 		this.failPending(new Error(`${this.options.name ?? "sandbox"} shutdown`));
 	}
 
-	private onMessage(message: SandboxResponseMessage): void {
-		if (!message || message.type !== "response" || !message.id) {
+	private onMessage(
+		message: SandboxResponseMessage | SandboxEventMessage,
+	): void {
+		if (!message) {
+			return;
+		}
+		if (message.type === "event") {
+			if (typeof message.name === "string" && message.name.length > 0) {
+				this.options.onEvent?.({
+					name: message.name,
+					payload: message.payload,
+				});
+			}
+			return;
+		}
+		if (message.type !== "response" || !message.id) {
 			return;
 		}
 		const pending = this.pending.get(message.id);

package/src/runtime/skills.ts

@@ -0,0 +1,44 @@
+import type { UserInstructionConfigWatcher } from "../agents";
+import {
+	listAvailableRuntimeCommandsForKindFromWatcher,
+	resolveRuntimeSlashCommandFromWatcher,
+} from "./commands";
+
+export type AvailableSkill = {
+	id: string;
+	name: string;
+	instructions: string;
+};
+
+function matchesLeadingSlashCommand(input: string, name: string): boolean {
+	const match = input.match(/^\/(\S+)/);
+	return match?.[1] === name;
+}
+
+export function listAvailableSkillsFromWatcher(
+	watcher: UserInstructionConfigWatcher,
+): AvailableSkill[] {
+	return listAvailableRuntimeCommandsForKindFromWatcher(watcher, "skill").map(
+		(skill) => ({
+			id: skill.id,
+			name: skill.name,
+			instructions: skill.instructions,
+		}),
+	);
+}
+
+/**
+ * Expands a leading slash command (e.g. "/release") to skill instructions.
+ * If the input starts with "/<skill-name>", that prefix is replaced and the
+ * remaining input is preserved unchanged.
+ */
+export function resolveSkillsSlashCommandFromWatcher(
+	input: string,
+	watcher: UserInstructionConfigWatcher,
+): string {
+	const resolved = resolveRuntimeSlashCommandFromWatcher(input, watcher);
+	const matched = listAvailableSkillsFromWatcher(watcher).some((skill) =>
+		matchesLeadingSlashCommand(input, skill.name),
+	);
+	return matched ? resolved : input;
+}

package/src/runtime/workflows.ts

@@ -1,4 +1,8 @@
-import type { UserInstructionConfigWatcher, WorkflowConfig } from "../agents";
+import type { UserInstructionConfigWatcher } from "../agents";
+import {
+	listAvailableRuntimeCommandsForKindFromWatcher,
+	resolveRuntimeSlashCommandFromWatcher,
+} from "./commands";
 
 export type AvailableWorkflow = {
 	id: string;
@@ -6,23 +10,22 @@ export type AvailableWorkflow = {
 	instructions: string;
 };
 
-function isWorkflowEnabled(workflow: WorkflowConfig): boolean {
-	return workflow.disabled !== true;
+function matchesLeadingSlashCommand(input: string, name: string): boolean {
+	const match = input.match(/^\/(\S+)/);
+	return match?.[1] === name;
 }
 
 export function listAvailableWorkflowsFromWatcher(
 	watcher: UserInstructionConfigWatcher,
 ): AvailableWorkflow[] {
-	const snapshot = watcher.getSnapshot("workflow");
-	return [...snapshot.entries()]
-		.map(([id, record]) => ({ id, workflow: record.item as WorkflowConfig }))
-		.filter(({ workflow }) => isWorkflowEnabled(workflow))
-		.map(({ id, workflow }) => ({
-			id,
-			name: workflow.name,
-			instructions: workflow.instructions,
-		}))
-		.sort((a, b) => a.name.localeCompare(b.name));
+	return listAvailableRuntimeCommandsForKindFromWatcher(
+		watcher,
+		"workflow",
+	).map((workflow) => ({
+		id: workflow.id,
+		name: workflow.name,
+		instructions: workflow.instructions,
+	}));
 }
 
 /**
@@ -34,21 +37,9 @@ export function resolveWorkflowSlashCommandFromWatcher(
 	input: string,
 	watcher: UserInstructionConfigWatcher,
 ): string {
-	if (!input.startsWith("/") || input.length < 2) {
-		return input;
-	}
-	const match = input.match(/^\/(\S+)/);
-	if (!match) {
-		return input;
-	}
-	const workflowName = match[1];
-	if (!workflowName) {
-		return input;
-	}
-	const commandLength = workflowName.length + 1;
-	const remainder = input.slice(commandLength);
-	const matched = listAvailableWorkflowsFromWatcher(watcher).find(
-		(workflow) => workflow.name === workflowName,
+	const resolved = resolveRuntimeSlashCommandFromWatcher(input, watcher);
+	const matched = listAvailableWorkflowsFromWatcher(watcher).some((workflow) =>
+		matchesLeadingSlashCommand(input, workflow.name),
 	);
-	return matched ? `${matched.instructions}${remainder}` : input;
+	return matched ? resolved : input;
 }