@clinebot/core 0.0.37 → 0.0.38

package/src/runtime/session-runtime.ts

@@ -1,69 +0,0 @@
-import type {
-	AgentConfig,
-	AgentHooks,
-	AgentResult,
-	BasicLogger,
-	ITelemetryService,
-	RuntimeConfigExtensionKind,
-	Tool,
-} from "@clinebot/shared";
-import type { UserInstructionConfigWatcher } from "../extensions/config";
-import type { ToolExecutors } from "../extensions/tools";
-import type {
-	AgentTeamsRuntime,
-	DelegatedAgentConfigProvider,
-	TeamEvent,
-} from "../extensions/tools/team";
-import type { CoreSessionConfig } from "../types/config";
-
-/**
- * Internal structural alias for the lead-agent handle that
- * {@link BuiltRuntime.registerLeadAgent} hands off to
- * `runtime-builder.ts`. Narrowed to only the `.addTools()` surface the
- * callback exercises; avoids depending on `@clinebot/agents`' `Agent`
- * class during the PLAN.md §3.6 Step 5 type-only migration. When
- * SessionRuntime is rebuilt in Step 6, this field is expected to be
- * dropped entirely per §3.5 row #2.
- */
-type LeadAgentHandle = {
-	addTools(tools: Tool[]): unknown;
-};
-
-export interface BuiltRuntime {
-	tools: Tool[];
-	hooks?: AgentHooks;
-	logger?: BasicLogger;
-	telemetry?: ITelemetryService;
-	teamRuntime?: AgentTeamsRuntime;
-	teamRestoredFromPersistence?: boolean;
-	delegatedAgentConfigProvider?: DelegatedAgentConfigProvider;
-	completionGuard?: () => string | undefined;
-	registerLeadAgent?: (agent: LeadAgentHandle) => void;
-	shutdown: (reason: string) => Promise<void> | void;
-}
-
-export interface RuntimeBuilderInput {
-	config: CoreSessionConfig;
-	hooks?: AgentHooks;
-	extensions?: AgentConfig["extensions"];
-	onTeamEvent?: (event: TeamEvent) => void;
-	createSpawnTool?: () => Tool;
-	onTeamRestored?: () => void;
-	userInstructionWatcher?: UserInstructionConfigWatcher;
-	configExtensions?: RuntimeConfigExtensionKind[];
-	defaultToolExecutors?: Partial<ToolExecutors>;
-	logger?: BasicLogger;
-	telemetry?: ITelemetryService;
-}
-
-export interface RuntimeBuilder {
-	build(input: RuntimeBuilderInput): Promise<BuiltRuntime> | 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/subprocess-sandbox.ts

@@ -1,255 +0,0 @@
-import { type ChildProcess, spawn } from "node:child_process";
-import {
-	augmentNodeCommandForDebug,
-	withResolvedClineBuildEnv,
-} from "@clinebot/shared";
-
-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;
-	}
-
-	private get processLabel(): string {
-		return this.options.name ?? "sandbox";
-	}
-
-	private clearPendingRequest(id: string): PendingRequest | undefined {
-		const pending = this.pending.get(id);
-		if (!pending) {
-			return undefined;
-		}
-		this.pending.delete(id);
-		if (pending.timeout) {
-			clearTimeout(pending.timeout);
-		}
-		return pending;
-	}
-
-	start(): void {
-		if (this.process && this.process.exitCode === null) {
-			return;
-		}
-
-		const args = this.options.bootstrapFile
-			? [this.options.bootstrapFile]
-			: ["-e", this.options.bootstrapScript ?? ""];
-
-		const command = augmentNodeCommandForDebug([process.execPath, ...args], {
-			debugRole:
-				this.options.name === "plugin-sandbox" ? "plugin-sandbox" : "sandbox",
-		});
-		const child = spawn(command[0] ?? process.execPath, command.slice(1), {
-			stdio: ["ignore", "ignore", "pipe", "ipc"],
-			env: withResolvedClineBuildEnv(process.env),
-		});
-		this.process = child;
-		let stderrBuffer = "";
-		const appendStderr = (chunk: string) => {
-			const next = stderrBuffer + chunk;
-			// Keep only a small tail so errors include useful context
-			// without unbounded memory growth.
-			stderrBuffer = next.length > 4000 ? next.slice(-4000) : next;
-		};
-		child.stderr?.setEncoding("utf8");
-		child.stderr?.on("data", (chunk: string) => {
-			appendStderr(chunk);
-		});
-		child.on("message", (message) => {
-			this.onMessage(message as SandboxResponseMessage | SandboxEventMessage);
-		});
-		child.on("error", (error) => {
-			this.failPending(
-				new Error(
-					`${this.processLabel} process error: ${asError(error).message}`,
-				),
-			);
-		});
-		child.on("exit", (code, signal) => {
-			this.process = null;
-			const stderrDetail = stderrBuffer.trim();
-			this.failPending(
-				new Error(
-					`${this.options.name ?? "sandbox"} process exited (code=${String(code)}, signal=${String(signal)})${stderrDetail ? `: ${stderrDetail}` : ""}`,
-				),
-			);
-		});
-	}
-
-	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.processLabel} 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.clearPendingRequest(id);
-					this.shutdown().catch(() => {
-						// Best-effort process shutdown after timeout.
-					});
-					reject(
-						new Error(
-							`${this.processLabel} 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.clearPendingRequest(id);
-				if (!entry) {
-					return;
-				}
-				entry.reject(
-					new Error(
-						`${this.processLabel} 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.processLabel} 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.processLabel} 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.clearPendingRequest(message.id);
-		if (!pending) {
-			return;
-		}
-		if (message.ok) {
-			pending.resolve(message.result);
-			return;
-		}
-		pending.reject(
-			new Error(message.error?.message || `${this.processLabel} 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/tool-approval.ts

@@ -1,102 +0,0 @@
-import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import type { ToolApprovalRequest, ToolApprovalResult } from "@clinebot/shared";
-
-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));
-}
-
-async function unlinkIfPresent(path: string): Promise<void> {
-	try {
-		await unlink(path);
-	} catch {
-		// Best-effort cleanup.
-	}
-}
-
-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,
-			};
-			await Promise.all([
-				unlinkIfPresent(decisionPath),
-				unlinkIfPresent(requestPath),
-			]);
-			return result;
-		} catch {
-			// Decision not available yet.
-		}
-		await delay(pollIntervalMs);
-	}
-
-	await unlinkIfPresent(requestPath);
-
-	return { approved: false, reason: "Tool approval request timed out" };
-}

package/src/runtime/user-input-builder.ts

@@ -1,167 +0,0 @@
-/**
- * User-input / first-turn content assembler.
- *
- * @see PLAN.md §3.1 — moved from `packages/agents/src/utils/agent-input.ts`.
- * @see PLAN.md §3.2.4 — called from the `Agent.run/continue` facade via
- *                      the `buildInitialUserContent` helper.
- *
- * Pure port. Opens the first user ContentBlock[] for a turn, loading user
- * file contents via the injected `userFileContentLoader` (already
- * core-owned per §3.1 notes on `packages/core/src/transports/local.ts`).
- */
-
-import type * as LlmsProviders from "@clinebot/llms";
-
-export async function buildInitialUserContent(
-	userMessage: string,
-	userImages?: string[],
-	userFiles?: string[],
-	userFileContentLoader?: (path: string) => Promise<string>,
-): Promise<string | LlmsProviders.ContentBlock[]> {
-	const imageBlocks = buildImageBlocks(userImages);
-	const fileTextBlocks = await buildUserFileContentBlock(
-		userFiles,
-		userFileContentLoader,
-	);
-
-	if (imageBlocks.length === 0 && !fileTextBlocks) {
-		return userMessage;
-	}
-
-	const content: LlmsProviders.ContentBlock[] = [
-		{
-			type: "text",
-			text: userMessage,
-		},
-		...imageBlocks,
-	];
-	if (fileTextBlocks) {
-		content.push(...fileTextBlocks);
-	}
-	return content;
-}
-
-/**
- * Normalize a user message shape into a plain string when possible.
- *
- * @see PLAN.md §3.1 — exported from the user-input-builder module so
- *                    SessionRuntime can use it to sanitise ad-hoc input.
- *
- * Accepts either a string or a LlmsProviders.Message; returns the best-effort
- * concatenated plain-text body. Non-text content is ignored.
- */
-export function normalizeUserMessage(
-	input: string | LlmsProviders.Message | undefined,
-): string {
-	if (input == null) {
-		return "";
-	}
-	if (typeof input === "string") {
-		return input;
-	}
-	const content = input.content;
-	if (typeof content === "string") {
-		return content;
-	}
-	if (!Array.isArray(content)) {
-		return "";
-	}
-	const textParts: string[] = [];
-	for (const block of content) {
-		if (block && typeof block === "object" && block.type === "text") {
-			const text = (block as { text?: unknown }).text;
-			if (typeof text === "string") {
-				textParts.push(text);
-			}
-		}
-	}
-	return textParts.join("\n");
-}
-
-function buildImageBlocks(userImages?: string[]): LlmsProviders.ImageContent[] {
-	if (!userImages || userImages.length === 0) {
-		return [];
-	}
-
-	const blocks: LlmsProviders.ImageContent[] = [];
-	for (const image of userImages) {
-		const block = parseDataUrlImage(image);
-		if (block) {
-			blocks.push(block);
-		}
-	}
-	return blocks;
-}
-
-function parseDataUrlImage(
-	image: string,
-): LlmsProviders.ImageContent | undefined {
-	const value = image.trim();
-	if (!value) {
-		return undefined;
-	}
-
-	const dataUrlMatch = value.match(/^data:([^;,]+);base64,(.+)$/);
-	if (dataUrlMatch) {
-		const mediaType = dataUrlMatch[1];
-		const data = dataUrlMatch[2];
-		if (!mediaType || !data) {
-			return undefined;
-		}
-		return {
-			type: "image",
-			mediaType,
-			data,
-		};
-	}
-
-	// Fallback: treat as plain base64 payload.
-	return {
-		type: "image",
-		mediaType: "image/png",
-		data: value,
-	};
-}
-
-async function buildUserFileContentBlock(
-	userFiles?: string[],
-	userFileContentLoader?: (path: string) => Promise<string>,
-): Promise<LlmsProviders.FileContent[] | undefined> {
-	if (!userFiles || userFiles.length === 0) {
-		return undefined;
-	}
-
-	const loader =
-		userFileContentLoader ??
-		(async () => {
-			throw new Error(
-				"File loading is not configured in this runtime. Provide userFileContentLoader to enable userFiles support.",
-			);
-		});
-
-	const contents = await Promise.all(
-		userFiles.map(async (filePath) => {
-			const normalizedPath = filePath.replace(/\\/g, "/");
-			try {
-				const content = await loader(filePath);
-				return {
-					type: "file",
-					path: normalizedPath,
-					content,
-				} satisfies LlmsProviders.FileContent;
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				return {
-					type: "file",
-					path: normalizedPath,
-					content: `Error fetching content: ${message}`,
-				} satisfies LlmsProviders.FileContent;
-			}
-		}),
-	);
-
-	if (contents.length === 0) {
-		return undefined;
-	}
-	return contents;
-}