@clinebot/core 0.0.20 → 0.0.22

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

@@ -1,143 +0,0 @@
-import { mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { Tool } from "@clinebot/agents";
-import { describe, expect, it } from "vitest";
-import { createBuiltinTools } from "../tools";
-import { DefaultRuntimeBuilder } from "./runtime-builder";
-
-type LegacyConfig = {
-	providerId: string;
-	modelId: string;
-	apiKey: string;
-	systemPrompt: string;
-	cwd: string;
-	enableTools: boolean;
-	enableSpawnAgent: boolean;
-	enableAgentTeams: boolean;
-};
-
-function legacyBuiltinTools(cwd: string): Tool[] {
-	return createBuiltinTools({
-		cwd,
-		enableReadFiles: true,
-		enableSearch: true,
-		enableBash: true,
-		enableWebFetch: true,
-	});
-}
-
-function legacyBuildRuntimeEnvironment(
-	config: LegacyConfig,
-	createSpawnTool?: () => Tool,
-): Tool[] {
-	const tools: Tool[] = [];
-	if (config.enableTools) {
-		tools.push(...legacyBuiltinTools(config.cwd));
-	}
-	if (config.enableSpawnAgent && createSpawnTool) {
-		const spawnTool = createSpawnTool();
-		tools.push({
-			...spawnTool,
-			execute: async (input, context) => spawnTool.execute(input, context),
-		});
-	}
-	return tools;
-}
-
-function normalizeParityToolNames(toolNames: string[]): string[] {
-	// Skills are discovered from user/workspace config and can appear in tests
-	// depending on the machine state. They are intentionally excluded from
-	// strict legacy parity checks.
-	return toolNames.filter((toolName) => toolName !== "skills");
-}
-
-function makeEmptyWorkspaceCwd(): string {
-	return mkdtempSync(join(tmpdir(), "runtime-parity-"));
-}
-
-function makeSpawnTool(): Tool {
-	return {
-		name: "spawn_agent",
-		description: "Spawn a subagent",
-		inputSchema: { type: "object", properties: {}, required: [] },
-		execute: async () => ({ ok: true }),
-	};
-}
-
-describe("runtime tool parity", () => {
-	it("matches legacy tool list when tools+spawn are enabled", () => {
-		const config: LegacyConfig = {
-			providerId: "anthropic",
-			modelId: "claude-sonnet-4-6",
-			apiKey: "key",
-			systemPrompt: "test",
-			cwd: makeEmptyWorkspaceCwd(),
-			enableTools: true,
-			enableSpawnAgent: true,
-			enableAgentTeams: false,
-		};
-		const createSpawnTool = makeSpawnTool;
-		const expected = normalizeParityToolNames(
-			legacyBuildRuntimeEnvironment(config, createSpawnTool).map(
-				(tool) => tool.name,
-			),
-		);
-		const actual = new DefaultRuntimeBuilder()
-			.build({
-				config,
-				createSpawnTool,
-			})
-			.tools.map((tool) => tool.name);
-
-		expect(normalizeParityToolNames(actual)).toEqual(expected);
-	});
-
-	it("matches legacy tool list when only spawn is enabled", () => {
-		const config: LegacyConfig = {
-			providerId: "anthropic",
-			modelId: "claude-sonnet-4-6",
-			apiKey: "key",
-			systemPrompt: "test",
-			cwd: makeEmptyWorkspaceCwd(),
-			enableTools: false,
-			enableSpawnAgent: true,
-			enableAgentTeams: false,
-		};
-		const createSpawnTool = makeSpawnTool;
-		const expected = normalizeParityToolNames(
-			legacyBuildRuntimeEnvironment(config, createSpawnTool).map(
-				(tool) => tool.name,
-			),
-		);
-		const actual = new DefaultRuntimeBuilder()
-			.build({
-				config,
-				createSpawnTool,
-			})
-			.tools.map((tool) => tool.name);
-
-		expect(normalizeParityToolNames(actual)).toEqual(expected);
-	});
-
-	it("matches legacy tool list when tools+spawn are disabled", () => {
-		const config: LegacyConfig = {
-			providerId: "anthropic",
-			modelId: "claude-sonnet-4-6",
-			apiKey: "key",
-			systemPrompt: "test",
-			cwd: makeEmptyWorkspaceCwd(),
-			enableTools: false,
-			enableSpawnAgent: false,
-			enableAgentTeams: false,
-		};
-		const expected = normalizeParityToolNames(
-			legacyBuildRuntimeEnvironment(config).map((tool) => tool.name),
-		);
-		const actual = new DefaultRuntimeBuilder()
-			.build({ config })
-			.tools.map((tool) => tool.name);
-
-		expect(normalizeParityToolNames(actual)).toEqual(expected);
-	});
-});

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

@@ -1,231 +0,0 @@
-import { type ChildProcess, spawn } from "node:child_process";
-
-interface SandboxCallMessage {
-	type: "call";
-	id: string;
-	method: string;
-	args: unknown;
-}
-
-interface SandboxResponseMessage {
-	type: "response";
-	id: string;
-	ok: boolean;
-	result?: unknown;
-	error?: { message: string; stack?: string };
-}
-
-interface SandboxEventMessage {
-	type: "event";
-	name: string;
-	payload?: unknown;
-}
-
-export interface SubprocessSandboxOptions {
-	/** 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 {
-	timeoutMs?: number;
-}
-
-type PendingRequest = {
-	resolve: (value: unknown) => void;
-	reject: (error: Error) => void;
-	timeout?: NodeJS.Timeout;
-};
-
-function asError(value: unknown): Error {
-	if (value instanceof Error) {
-		return value;
-	}
-	return new Error(String(value));
-}
-
-export class SubprocessSandbox {
-	private readonly options: SubprocessSandboxOptions;
-	private process: ChildProcess | null = null;
-	private requestCounter = 0;
-	private readonly pending = new Map<string, PendingRequest>();
-
-	constructor(options: SubprocessSandboxOptions) {
-		this.options = options;
-	}
-
-	start(): void {
-		if (this.process && this.process.exitCode === null) {
-			return;
-		}
-
-		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 | SandboxEventMessage);
-		});
-		child.on("error", (error) => {
-			this.failPending(
-				new Error(
-					`${this.options.name ?? "sandbox"} process error: ${asError(error).message}`,
-				),
-			);
-		});
-		child.on("exit", (code, signal) => {
-			this.process = null;
-			this.failPending(
-				new Error(
-					`${this.options.name ?? "sandbox"} process exited (code=${String(code)}, signal=${String(signal)})`,
-				),
-			);
-		});
-	}
-
-	async call<TResult = unknown>(
-		method: string,
-		args: unknown,
-		options: SandboxCallOptions = {},
-	): Promise<TResult> {
-		this.start();
-		const child = this.process;
-		if (!child || child.exitCode !== null) {
-			throw new Error(
-				`${this.options.name ?? "sandbox"} process is not available`,
-			);
-		}
-
-		const id = `req_${++this.requestCounter}`;
-		const message: SandboxCallMessage = {
-			type: "call",
-			id,
-			method,
-			args,
-		};
-
-		return await new Promise<TResult>((resolve, reject) => {
-			const pending: PendingRequest = {
-				resolve: (value) => resolve(value as TResult),
-				reject,
-			};
-			if ((options.timeoutMs ?? 0) > 0) {
-				pending.timeout = setTimeout(() => {
-					this.pending.delete(id);
-					this.shutdown().catch(() => {
-						// Best-effort process shutdown after timeout.
-					});
-					reject(
-						new Error(
-							`${this.options.name ?? "sandbox"} call timed out after ${options.timeoutMs}ms: ${method}`,
-						),
-					);
-				}, options.timeoutMs);
-			}
-			this.pending.set(id, pending);
-			child.send(message, (error) => {
-				if (!error) {
-					return;
-				}
-				const entry = this.pending.get(id);
-				if (!entry) {
-					return;
-				}
-				this.pending.delete(id);
-				if (entry.timeout) {
-					clearTimeout(entry.timeout);
-				}
-				entry.reject(
-					new Error(
-						`${this.options.name ?? "sandbox"} failed to send call "${method}": ${asError(error).message}`,
-					),
-				);
-			});
-		});
-	}
-
-	async shutdown(): Promise<void> {
-		const child = this.process;
-		this.process = null;
-		if (!child || child.exitCode !== null) {
-			this.failPending(new Error(`${this.options.name ?? "sandbox"} shutdown`));
-			return;
-		}
-		await new Promise<void>((resolve) => {
-			const timeout = setTimeout(() => {
-				try {
-					child.kill("SIGKILL");
-				} catch {
-					// Ignore kill failures.
-				}
-				resolve();
-			}, 300);
-			child.once("exit", () => {
-				clearTimeout(timeout);
-				resolve();
-			});
-			try {
-				child.kill("SIGTERM");
-			} catch {
-				clearTimeout(timeout);
-				resolve();
-			}
-		});
-		this.failPending(new Error(`${this.options.name ?? "sandbox"} shutdown`));
-	}
-
-	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);
-		if (!pending) {
-			return;
-		}
-		this.pending.delete(message.id);
-		if (pending.timeout) {
-			clearTimeout(pending.timeout);
-		}
-		if (message.ok) {
-			pending.resolve(message.result);
-			return;
-		}
-		pending.reject(
-			new Error(
-				message.error?.message ||
-					`${this.options.name ?? "sandbox"} call failed`,
-			),
-		);
-	}
-
-	private failPending(error: Error): void {
-		for (const [id, pending] of this.pending.entries()) {
-			this.pending.delete(id);
-			if (pending.timeout) {
-				clearTimeout(pending.timeout);
-			}
-			pending.reject(error);
-		}
-	}
-}

package/src/runtime/session-runtime.ts

@@ -1,46 +0,0 @@
-import type {
-	AgentConfig,
-	AgentHooks,
-	AgentResult,
-	AgentTeamsRuntime,
-	Tool,
-} from "@clinebot/agents";
-import type { BasicLogger, ITelemetryService } from "@clinebot/shared";
-import type { UserInstructionConfigWatcher } from "../agents";
-import type { ToolExecutors } from "../tools";
-import type { CoreSessionConfig } from "../types/config";
-
-export interface BuiltRuntime {
-	tools: Tool[];
-	hooks?: AgentHooks;
-	logger?: BasicLogger;
-	telemetry?: ITelemetryService;
-	teamRuntime?: AgentTeamsRuntime;
-	completionGuard?: () => string | undefined;
-	shutdown: (reason: string) => Promise<void> | void;
-}
-
-export interface RuntimeBuilderInput {
-	config: CoreSessionConfig;
-	hooks?: AgentHooks;
-	extensions?: AgentConfig["extensions"];
-	onTeamEvent?: (event: import("@clinebot/agents").TeamEvent) => void;
-	createSpawnTool?: () => Tool;
-	onTeamRestored?: () => void;
-	userInstructionWatcher?: UserInstructionConfigWatcher;
-	defaultToolExecutors?: Partial<ToolExecutors>;
-	logger?: BasicLogger;
-	telemetry?: ITelemetryService;
-}
-
-export interface RuntimeBuilder {
-	build(input: RuntimeBuilderInput): BuiltRuntime;
-}
-
-export interface SessionRuntime {
-	start(config: CoreSessionConfig): Promise<{ sessionId: string }>;
-	send(sessionId: string, prompt: string): Promise<AgentResult | undefined>;
-	abort(sessionId: string, reason?: unknown): Promise<void>;
-	stop(sessionId: string): Promise<void>;
-	poll(): Promise<string[]>;
-}

package/src/runtime/skills.ts

@@ -1,44 +0,0 @@
-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/tool-approval.ts

@@ -1,104 +0,0 @@
-import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import type { ToolApprovalRequest, ToolApprovalResult } from "@clinebot/agents";
-
-export type DesktopToolApprovalOptions = {
-	approvalDir?: string;
-	sessionId?: string;
-	timeoutMs?: number;
-	pollIntervalMs?: number;
-	nowIso?: () => string;
-};
-
-function sanitizeApprovalToken(value: string): string {
-	return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
-}
-
-function delay(ms: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export async function requestDesktopToolApproval(
-	request: ToolApprovalRequest,
-	options: DesktopToolApprovalOptions = {},
-): Promise<ToolApprovalResult> {
-	const approvalDir = options.approvalDir?.trim();
-	const sessionId = options.sessionId?.trim();
-	if (!approvalDir || !sessionId) {
-		return {
-			approved: false,
-			reason: "Desktop tool approval IPC is not configured",
-		};
-	}
-
-	await mkdir(approvalDir, { recursive: true });
-	const requestId = sanitizeApprovalToken(`${request.toolCallId}`);
-	const requestPath = join(
-		approvalDir,
-		`${sessionId}.request.${requestId}.json`,
-	);
-	const decisionPath = join(
-		approvalDir,
-		`${sessionId}.decision.${requestId}.json`,
-	);
-	const nowIso = options.nowIso ?? (() => new Date().toISOString());
-
-	await writeFile(
-		requestPath,
-		`${JSON.stringify(
-			{
-				requestId,
-				sessionId,
-				createdAt: nowIso(),
-				toolCallId: request.toolCallId,
-				toolName: request.toolName,
-				input: request.input,
-				iteration: request.iteration,
-				agentId: request.agentId,
-				conversationId: request.conversationId,
-			},
-			null,
-			2,
-		)}\n`,
-		"utf8",
-	);
-
-	const timeoutMs = options.timeoutMs ?? 5 * 60_000;
-	const pollIntervalMs = options.pollIntervalMs ?? 200;
-	const startedAt = Date.now();
-	while (Date.now() - startedAt < timeoutMs) {
-		try {
-			const raw = await readFile(decisionPath, "utf8");
-			const parsed = JSON.parse(raw) as {
-				approved?: boolean;
-				reason?: string;
-			};
-			const result = {
-				approved: parsed.approved === true,
-				reason: typeof parsed.reason === "string" ? parsed.reason : undefined,
-			};
-			try {
-				await unlink(decisionPath);
-			} catch {
-				// Best-effort cleanup.
-			}
-			try {
-				await unlink(requestPath);
-			} catch {
-				// Best-effort cleanup.
-			}
-			return result;
-		} catch {
-			// Decision not available yet.
-		}
-		await delay(pollIntervalMs);
-	}
-
-	try {
-		await unlink(requestPath);
-	} catch {
-		// Best-effort cleanup.
-	}
-
-	return { approved: false, reason: "Tool approval request timed out" };
-}

package/src/runtime/workflows.test.ts

@@ -1,119 +0,0 @@
-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 {
-	listAvailableWorkflowsFromWatcher,
-	resolveWorkflowSlashCommandFromWatcher,
-} from "./workflows";
-
-describe("runtime workflows helpers", () => {
-	const tempRoots: string[] = [];
-
-	afterEach(async () => {
-		await Promise.all(
-			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
-		);
-		tempRoots.length = 0;
-	});
-
-	it("lists only enabled workflows from watcher snapshots", async () => {
-		const tempRoot = await mkdtemp(join(tmpdir(), "core-runtime-workflows-"));
-		tempRoots.push(tempRoot);
-		const workflowsDir = join(tempRoot, "workflows");
-		await mkdir(workflowsDir, { recursive: true });
-		await writeFile(
-			join(workflowsDir, "enabled.md"),
-			`---
-name: enabled-workflow
----
-Run enabled workflow.`,
-		);
-		await writeFile(
-			join(workflowsDir, "disabled.md"),
-			`---
-name: disabled-workflow
-disabled: true
----
-Run disabled workflow.`,
-		);
-
-		const watcher = createUserInstructionConfigWatcher({
-			skills: { directories: [] },
-			rules: { directories: [] },
-			workflows: { directories: [workflowsDir] },
-		});
-
-		try {
-			await watcher.start();
-			expect(listAvailableWorkflowsFromWatcher(watcher)).toEqual([
-				{
-					id: "enabled-workflow",
-					name: "enabled-workflow",
-					instructions: "Run enabled workflow.",
-				},
-			]);
-		} finally {
-			watcher.stop();
-		}
-	});
-
-	it("expands leading slash commands and preserves trailing user text", async () => {
-		const tempRoot = await mkdtemp(join(tmpdir(), "core-runtime-workflows-"));
-		tempRoots.push(tempRoot);
-		const workflowsDir = join(tempRoot, "workflows");
-		await mkdir(workflowsDir, { recursive: true });
-		await writeFile(
-			join(workflowsDir, "release.md"),
-			`---
-name: release
----
-Run the release workflow.`,
-		);
-		await writeFile(
-			join(workflowsDir, "disabled.md"),
-			`---
-name: disabled
-disabled: true
----
-Do not run this workflow.`,
-		);
-
-		const watcher = createUserInstructionConfigWatcher({
-			skills: { directories: [] },
-			rules: { directories: [] },
-			workflows: { directories: [workflowsDir] },
-		});
-
-		try {
-			await watcher.start();
-			expect(resolveWorkflowSlashCommandFromWatcher("/release", watcher)).toBe(
-				"Run the release workflow.",
-			);
-			expect(
-				resolveWorkflowSlashCommandFromWatcher("  /release  ", watcher),
-			).toBe("  /release  ");
-			expect(resolveWorkflowSlashCommandFromWatcher("/disabled", watcher)).toBe(
-				"/disabled",
-			);
-			expect(resolveWorkflowSlashCommandFromWatcher("/missing", watcher)).toBe(
-				"/missing",
-			);
-			expect(
-				resolveWorkflowSlashCommandFromWatcher("/release now", watcher),
-			).toBe("Run the release workflow. now");
-			expect(
-				resolveWorkflowSlashCommandFromWatcher(
-					"/release   use javascript",
-					watcher,
-				),
-			).toBe("Run the release workflow.   use javascript");
-			expect(
-				resolveWorkflowSlashCommandFromWatcher("please run /release", watcher),
-			).toBe("please run /release");
-		} finally {
-			watcher.stop();
-		}
-	});
-});