@clinebot/core 0.0.6 → 0.0.7

package/dist/session/rpc-spawn-lease.d.ts

@@ -0,0 +1,7 @@
+export interface RpcSpawnLease {
+    path: string;
+    release: () => void;
+}
+export declare function tryAcquireRpcSpawnLease(address: string, options?: {
+    ttlMs?: number;
+}): RpcSpawnLease | undefined;

package/dist/storage/provider-settings-legacy-migration.d.ts

@@ -1,3 +1,4 @@
+import type { ProviderSettings } from "../types/provider-settings";
 import type { ProviderSettingsManager } from "./provider-settings-manager";
 export interface MigrateLegacyProviderSettingsOptions {
     providerSettingsManager: ProviderSettingsManager;
@@ -10,4 +11,28 @@ export interface MigrateLegacyProviderSettingsResult {
     providerCount: number;
     lastUsedProvider?: string;
 }
+export type LegacyClineUserInfo = {
+    idToken: string;
+    expiresAt: number;
+    refreshToken: string;
+    userInfo: {
+        id: string;
+        email: string;
+        displayName: string;
+        termsAcceptedAt: string;
+        clineBenchConsent: boolean;
+        createdAt: string;
+        updatedAt: string;
+    };
+    provider: string;
+    startedAt: number;
+};
+/**
+ * Resolves legacy Cline account auth data from the raw `cline:clineAccountId`
+ * secret string into the auth fields used by `ProviderSettings`.
+ *
+ * Returns `undefined` when the input is missing, empty, whitespace-only, or
+ * unparseable JSON.
+ */
+export declare function resolveLegacyClineAuth(rawAccountData: string | undefined): ProviderSettings["auth"] | undefined;
 export declare function migrateLegacyProviderSettings(options: MigrateLegacyProviderSettingsOptions): MigrateLegacyProviderSettingsResult;

package/dist/tools/schemas.d.ts

@@ -61,15 +61,9 @@ export declare const FetchWebContentInputSchema: z.ZodObject<{
  * Schema for editor tool input
  */
 export declare const EditFileInputSchema: z.ZodObject<{
-    command: z.ZodEnum<{
-        create: "create";
-        str_replace: "str_replace";
-        insert: "insert";
-    }>;
     path: z.ZodString;
-    file_text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    old_str: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    new_str: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    old_text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    new_text: z.ZodString;
     insert_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>;
 /**

package/dist/types/events.d.ts

@@ -11,7 +11,7 @@ export interface SessionEndedEvent {
 }
 export interface SessionToolEvent {
     sessionId: string;
-    hookEventName: "tool_call" | "tool_result" | "agent_end" | "session_shutdown";
+    hookEventName: "tool_call" | "tool_result" | "agent_end" | "agent_error" | "session_shutdown";
     agentId?: string;
     conversationId?: string;
     parentAgentId?: string;

package/package.json

@@ -1,10 +1,10 @@
 {
 	"name": "@clinebot/core",
-	"version": "0.0.6",
+	"version": "0.0.7",
 	"main": "./dist/index.node.js",
 	"dependencies": {
-		"@clinebot/agents": "0.0.6",
-		"@clinebot/llms": "0.0.6",
+		"@clinebot/agents": "0.0.7",
+		"@clinebot/llms": "0.0.7",
 		"@opentelemetry/api": "^1.9.0",
 		"@opentelemetry/api-logs": "^0.56.0",
 		"@opentelemetry/exporter-logs-otlp-http": "^0.56.0",

package/src/agents/hooks-config-loader.ts

@@ -20,6 +20,7 @@ export enum HookConfigFileName {
 	TaskResume = "TaskResume",
 	TaskCancel = "TaskCancel",
 	TaskComplete = "TaskComplete",
+	TaskError = "TaskError",
 	PreToolUse = "PreToolUse",
 	PostToolUse = "PostToolUse",
 	UserPromptSubmit = "UserPromptSubmit",
@@ -34,6 +35,7 @@ export const HOOK_CONFIG_FILE_EVENT_MAP: Readonly<
 	[HookConfigFileName.TaskResume]: "agent_resume",
 	[HookConfigFileName.TaskCancel]: "agent_abort",
 	[HookConfigFileName.TaskComplete]: "agent_end",
+	[HookConfigFileName.TaskError]: "agent_error",
 	[HookConfigFileName.PreToolUse]: "tool_call",
 	[HookConfigFileName.PostToolUse]: "tool_result",
 	[HookConfigFileName.UserPromptSubmit]: "prompt_submit",

package/src/index.node.ts

@@ -170,6 +170,10 @@ export {
 } from "./runtime/workflows";
 export { DefaultSessionManager } from "./session/default-session-manager";
 export { RpcCoreSessionService } from "./session/rpc-session-service";
+export {
+	type RpcSpawnLease,
+	tryAcquireRpcSpawnLease,
+} from "./session/rpc-spawn-lease";
 export {
 	deriveSubsessionStatus,
 	makeSubSessionId,

package/src/input/file-indexer.test.ts

@@ -84,4 +84,44 @@ describe("file indexer", () => {
 			await rm(cwd, { recursive: true, force: true });
 		}
 	});
+
+	it("evicts stale workspace indexes after 10 minutes when multiple workspaces exist", async () => {
+		vi.useFakeTimers();
+		const firstWorkspace = await createTempWorkspace();
+		const secondWorkspace = await createTempWorkspace();
+		try {
+			await writeFile(
+				path.join(firstWorkspace, "first.ts"),
+				"export const first = 1\n",
+				"utf8",
+			);
+			await writeFile(
+				path.join(secondWorkspace, "second.ts"),
+				"export const second = 2\n",
+				"utf8",
+			);
+
+			const firstIndex = await getFileIndex(firstWorkspace, { ttlMs: 60_000 });
+			expect(firstIndex.has("first.ts")).toBe(true);
+
+			await getFileIndex(secondWorkspace, { ttlMs: 60_000 });
+			vi.advanceTimersByTime(10 * 60_000 + 1);
+
+			await getFileIndex(secondWorkspace, { ttlMs: 60_000 });
+			await writeFile(
+				path.join(firstWorkspace, "later.ts"),
+				"export const later = 3\n",
+				"utf8",
+			);
+
+			const rebuiltFirstIndex = await getFileIndex(firstWorkspace, {
+				ttlMs: 60_000,
+			});
+			expect(rebuiltFirstIndex.has("later.ts")).toBe(true);
+		} finally {
+			vi.useRealTimers();
+			await rm(firstWorkspace, { recursive: true, force: true });
+			await rm(secondWorkspace, { recursive: true, force: true });
+		}
+	});
 });

package/src/input/file-indexer.ts

@@ -4,6 +4,7 @@ import path from "node:path";
 import { isMainThread, parentPort, Worker } from "node:worker_threads";
 
 const DEFAULT_INDEX_TTL_MS = 15_000;
+const STALE_CACHE_EVICTION_MS = 10 * 60_000;
 const WORKER_INDEX_REQUEST_TIMEOUT_MS = 1_000;
 const DEFAULT_EXCLUDE_DIRS = new Set([
 	".git",
@@ -21,6 +22,7 @@ const DEFAULT_EXCLUDE_DIRS = new Set([
 interface CacheEntry {
 	files: Set<string>;
 	lastBuiltAt: number;
+	lastAccessedAt: number;
 	pending: Promise<Set<string>> | null;
 }
 
@@ -43,6 +45,20 @@ interface IndexResponseMessage {
 
 const CACHE = new Map<string, CacheEntry>();
 
+function pruneStaleCacheEntries(now: number): void {
+	if (CACHE.size <= 1) {
+		return;
+	}
+	for (const [cwd, entry] of CACHE.entries()) {
+		if (entry.pending) {
+			continue;
+		}
+		if (now - entry.lastAccessedAt > STALE_CACHE_EVICTION_MS) {
+			CACHE.delete(cwd);
+		}
+	}
+}
+
 function toPosixRelative(cwd: string, absolutePath: string): string {
 	return path.relative(cwd, absolutePath).split(path.sep).join("/");
 }
@@ -265,6 +281,7 @@ export async function getFileIndex(
 ): Promise<Set<string>> {
 	const ttlMs = options.ttlMs ?? DEFAULT_INDEX_TTL_MS;
 	const now = Date.now();
+	pruneStaleCacheEntries(now);
 	const existing = CACHE.get(cwd);
 
 	if (
@@ -273,10 +290,12 @@ export async function getFileIndex(
 		now - existing.lastBuiltAt <= ttlMs &&
 		existing.files.size > 0
 	) {
+		existing.lastAccessedAt = now;
 		return existing.files;
 	}
 
 	if (existing?.pending) {
+		existing.lastAccessedAt = now;
 		return existing.pending;
 	}
 
@@ -284,6 +303,7 @@ export async function getFileIndex(
 		CACHE.set(cwd, {
 			files,
 			lastBuiltAt: Date.now(),
+			lastAccessedAt: Date.now(),
 			pending: null,
 		});
 		return files;
@@ -292,6 +312,7 @@ export async function getFileIndex(
 	CACHE.set(cwd, {
 		files: existing?.files ?? new Set<string>(),
 		lastBuiltAt: existing?.lastBuiltAt ?? 0,
+		lastAccessedAt: now,
 		pending,
 	});
 

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

@@ -1,9 +1,30 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 import { createHookConfigFileHooks } from "./hook-file-hooks";
 
+async function waitForFile(
+	filePath: string,
+	timeoutMs = 1500,
+): Promise<string> {
+	const started = Date.now();
+	for (;;) {
+		try {
+			return await readFile(filePath, "utf8");
+		} catch (error) {
+			const code =
+				error && typeof error === "object" && "code" in error
+					? String((error as { code?: unknown }).code)
+					: undefined;
+			if (code !== "ENOENT" || Date.now() - started >= timeoutMs) {
+				throw error;
+			}
+			await new Promise((resolve) => setTimeout(resolve, 25));
+		}
+	}
+}
+
 async function createWorkspaceWithHook(
 	fileName: string,
 	body: string,
@@ -150,4 +171,33 @@ describe("createHookConfigFileHooks", () => {
 			await rm(workspace, { recursive: true, force: true });
 		}
 	});
+
+	it("maps TaskError hook files to agent_error stop events", async () => {
+		const outputPath = join(tmpdir(), `hooks-task-error-${Date.now()}.json`);
+		const { workspace } = await createWorkspaceWithHook(
+			"TaskError.js",
+			`let data='';process.stdin.on('data',c=>data+=c);process.stdin.on('end',()=>{require('node:fs').writeFileSync(${JSON.stringify(outputPath)}, data);});\n`,
+		);
+		try {
+			const hooks = createHookConfigFileHooks({
+				cwd: workspace,
+				workspacePath: workspace,
+			});
+			await hooks?.onStopError?.({
+				agentId: "agent_1",
+				conversationId: "conv_1",
+				parentAgentId: null,
+				iteration: 3,
+				error: new Error("401 unauthorized"),
+			});
+			const payload = JSON.parse(await waitForFile(outputPath)) as {
+				hookName: string;
+				error?: { message?: string };
+			};
+			expect(payload.hookName).toBe("agent_error");
+			expect(payload.error?.message).toBe("401 unauthorized");
+		} finally {
+			await rm(workspace, { recursive: true, force: true });
+		}
+	});
 });

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

@@ -30,6 +30,9 @@ type AgentHookToolCallEndContext = Parameters<
 type AgentHookTurnEndContext = Parameters<
 	NonNullable<AgentHooks["onTurnEnd"]>
 >[0];
+type AgentHookStopErrorContext = Parameters<
+	NonNullable<AgentHooks["onStopError"]>
+>[0];
 type AgentHookSessionShutdownContext = Parameters<
 	NonNullable<AgentHooks["onSessionShutdown"]>
 >[0];
@@ -201,6 +204,42 @@ function parseHookStdout(stdout: string): {
 	}
 }
 
+async function writeToChildStdin(
+	child: ReturnType<typeof spawn>,
+	body: string,
+): Promise<void> {
+	const stdin = child.stdin;
+	if (!stdin) {
+		throw new Error("hook command failed to create stdin");
+	}
+
+	await new Promise<void>((resolve, reject) => {
+		const onError = (error: Error) => {
+			stdin.off("error", onError);
+			const code = (error as Error & { code?: string }).code;
+			if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") {
+				resolve();
+				return;
+			}
+			reject(error);
+		};
+		stdin.once("error", onError);
+		stdin.end(body, (error?: Error | null) => {
+			stdin.off("error", onError);
+			if (error) {
+				const code = (error as Error & { code?: string }).code;
+				if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") {
+					resolve();
+					return;
+				}
+				reject(error);
+				return;
+			}
+			resolve();
+		});
+	});
+}
+
 async function runHookCommand(
 	payload: HookEventPayload,
 	options: {
@@ -222,19 +261,18 @@ async function runHookCommand(
 			: ["pipe", "pipe", "pipe"],
 		detached: options.detached,
 	});
+	const spawned = new Promise<void>((resolve) => {
+		child.once("spawn", () => resolve());
+	});
+	const childError = new Promise<never>((_, reject) => {
+		child.once("error", (error) => reject(error));
+	});
 
 	const body = JSON.stringify(payload);
-	if (!child.stdin) {
-		throw new Error("hook command failed to create stdin");
-	}
-	child.stdin.write(body);
-	child.stdin.end();
+	await writeToChildStdin(child, body);
 
 	if (options.detached) {
-		await new Promise<void>((resolve, reject) => {
-			child.once("error", reject);
-			child.once("spawn", () => resolve());
-		});
+		await Promise.race([spawned, childError]);
 		child.unref();
 		return;
 	}
@@ -253,8 +291,7 @@ async function runHookCommand(
 		stderr += chunk.toString();
 	});
 
-	return await new Promise<HookCommandResult>((resolve, reject) => {
-		child.once("error", reject);
+	const result = new Promise<HookCommandResult>((resolve) => {
 		if ((options.timeoutMs ?? 0) > 0) {
 			timeoutId = setTimeout(() => {
 				timedOut = true;
@@ -276,6 +313,7 @@ async function runHookCommand(
 			});
 		});
 	});
+	return await Promise.race([result, childError]);
 }
 
 function parseShebangCommand(path: string): string[] | undefined {
@@ -491,6 +529,19 @@ export function createHookAuditHooks(options: {
 			});
 			return undefined;
 		},
+		onStopError: async (ctx: AgentHookStopErrorContext) => {
+			append({
+				...createPayloadBase(ctx, runtimeOptions),
+				hookName: "agent_error",
+				iteration: ctx.iteration,
+				error: {
+					name: ctx.error.name,
+					message: ctx.error.message,
+					stack: ctx.error.stack,
+				},
+			});
+			return undefined;
+		},
 		onSessionShutdown: async (ctx: AgentHookSessionShutdownContext) => {
 			if (isAbortReason(ctx.reason)) {
 				append({
@@ -634,6 +685,30 @@ export function createHookConfigFileHooks(
 		});
 	};
 
+	const runStopError = async (
+		ctx: AgentHookStopErrorContext,
+	): Promise<void> => {
+		const commandPaths = commandMap.agent_error ?? [];
+		if (commandPaths.length === 0) {
+			return;
+		}
+		runAsyncHookCommands({
+			commands: commandPaths,
+			cwd: options.cwd,
+			logger: options.logger,
+			payload: {
+				...createPayloadBase(ctx, options),
+				hookName: "agent_error",
+				iteration: ctx.iteration,
+				error: {
+					name: ctx.error.name,
+					message: ctx.error.message,
+					stack: ctx.error.stack,
+				},
+			},
+		});
+	};
+
 	const runSessionShutdown = async (
 		ctx: AgentHookSessionShutdownContext,
 	): Promise<void> => {
@@ -684,6 +759,10 @@ export function createHookConfigFileHooks(
 			await runTurnEnd(ctx);
 			return undefined;
 		},
+		onStopError: async (ctx: AgentHookStopErrorContext) => {
+			await runStopError(ctx);
+			return undefined;
+		},
 		onSessionShutdown: async (ctx: AgentHookSessionShutdownContext) => {
 			await runSessionShutdown(ctx);
 			return undefined;

package/src/session/rpc-spawn-lease.test.ts

@@ -0,0 +1,49 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { tryAcquireRpcSpawnLease } from "./rpc-spawn-lease";
+
+describe("tryAcquireRpcSpawnLease", () => {
+	const tempDirs: string[] = [];
+
+	afterEach(() => {
+		delete process.env.CLINE_DATA_DIR;
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("allows only one active lease per address", () => {
+		const dataDir = mkdtempSync(path.join(os.tmpdir(), "rpc-spawn-lease-"));
+		tempDirs.push(dataDir);
+		process.env.CLINE_DATA_DIR = dataDir;
+
+		const first = tryAcquireRpcSpawnLease("127.0.0.1:4317");
+		const second = tryAcquireRpcSpawnLease("127.0.0.1:4317");
+
+		expect(first).toBeDefined();
+		expect(second).toBeUndefined();
+
+		first?.release();
+
+		const third = tryAcquireRpcSpawnLease("127.0.0.1:4317");
+		expect(third).toBeDefined();
+		third?.release();
+	});
+
+	it("lets different addresses acquire independent leases", () => {
+		const dataDir = mkdtempSync(path.join(os.tmpdir(), "rpc-spawn-lease-"));
+		tempDirs.push(dataDir);
+		process.env.CLINE_DATA_DIR = dataDir;
+
+		const first = tryAcquireRpcSpawnLease("127.0.0.1:4317");
+		const second = tryAcquireRpcSpawnLease("127.0.0.1:4318");
+
+		expect(first).toBeDefined();
+		expect(second).toBeDefined();
+
+		first?.release();
+		second?.release();
+	});
+});

package/src/session/rpc-spawn-lease.ts

@@ -0,0 +1,122 @@
+import {
+	closeSync,
+	existsSync,
+	mkdirSync,
+	openSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { dirname, resolve } from "node:path";
+import { resolveSessionDataDir } from "@clinebot/shared/storage";
+
+const DEFAULT_LEASE_TTL_MS = 15_000;
+
+interface RpcSpawnLeaseRecord {
+	address: string;
+	pid: number;
+	createdAt: number;
+}
+
+export interface RpcSpawnLease {
+	path: string;
+	release: () => void;
+}
+
+function encodeAddress(address: string): string {
+	return Buffer.from(address).toString("base64url");
+}
+
+function getLeasePath(address: string): string {
+	return resolve(
+		resolveSessionDataDir(),
+		"rpc",
+		"spawn-leases",
+		`${encodeAddress(address)}.lock`,
+	);
+}
+
+function isProcessAlive(pid: number): boolean {
+	if (!Number.isInteger(pid) || pid <= 0) {
+		return false;
+	}
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function shouldClearLease(path: string, ttlMs: number): boolean {
+	try {
+		const raw = readFileSync(path, "utf8");
+		const parsed = JSON.parse(raw) as Partial<RpcSpawnLeaseRecord>;
+		const createdAt = Number(parsed.createdAt ?? 0);
+		if (!Number.isFinite(createdAt) || createdAt <= 0) {
+			return true;
+		}
+		if (Date.now() - createdAt > ttlMs) {
+			return true;
+		}
+		return !isProcessAlive(Number(parsed.pid ?? 0));
+	} catch {
+		return true;
+	}
+}
+
+export function tryAcquireRpcSpawnLease(
+	address: string,
+	options?: { ttlMs?: number },
+): RpcSpawnLease | undefined {
+	const ttlMs = Math.max(1_000, options?.ttlMs ?? DEFAULT_LEASE_TTL_MS);
+	const path = getLeasePath(address);
+	mkdirSync(dirname(path), { recursive: true });
+
+	if (existsSync(path) && shouldClearLease(path, ttlMs)) {
+		rmSync(path, { force: true });
+	}
+
+	let fd: number | undefined;
+	try {
+		fd = openSync(path, "wx");
+		const record: RpcSpawnLeaseRecord = {
+			address,
+			pid: process.pid,
+			createdAt: Date.now(),
+		};
+		writeFileSync(fd, JSON.stringify(record), "utf8");
+	} catch {
+		if (typeof fd === "number") {
+			try {
+				closeSync(fd);
+			} catch {
+				// Best effort.
+			}
+		}
+		return undefined;
+	}
+
+	let released = false;
+	return {
+		path,
+		release: () => {
+			if (released) {
+				return;
+			}
+			released = true;
+			try {
+				if (typeof fd === "number") {
+					closeSync(fd);
+				}
+			} catch {
+				// Best effort.
+			}
+			try {
+				rmSync(path, { force: true });
+			} catch {
+				// Best effort.
+			}
+		},
+	};
+}

package/src/session/session-graph.ts

@@ -70,6 +70,8 @@ export function deriveSubsessionStatus(event: HookEventPayload): SessionStatus {
 	switch (event.hookName) {
 		case "agent_end":
 			return "completed";
+		case "agent_error":
+			return "failed";
 		case "session_shutdown": {
 			const reason = String(event.reason ?? "").toLowerCase();
 			if (

package/src/session/session-host.ts

@@ -14,6 +14,7 @@ import { SqliteSessionStore } from "../storage/sqlite-session-store";
 import type { ToolExecutors } from "../tools";
 import { DefaultSessionManager } from "./default-session-manager";
 import { RpcCoreSessionService } from "./rpc-session-service";
+import { tryAcquireRpcSpawnLease } from "./rpc-spawn-lease";
 import type { SessionManager } from "./session-manager";
 import { CoreSessionService } from "./session-service";
 
@@ -44,13 +45,19 @@ export interface CreateSessionHostOptions {
 export type SessionHost = SessionManager;
 
 function startRpcServerInBackground(address: string): void {
+	const lease = tryAcquireRpcSpawnLease(address);
+	if (!lease) {
+		return;
+	}
 	const launcher = process.execPath;
 	const entryArg = process.argv[1]?.trim();
 	if (!entryArg) {
+		lease.release();
 		return;
 	}
 	const entry = resolve(process.cwd(), entryArg);
 	if (!existsSync(entry)) {
+		lease.release();
 		return;
 	}
 	const conditionsArg = process.execArgv.find((arg) =>
@@ -75,6 +82,7 @@ function startRpcServerInBackground(address: string): void {
 		cwd: process.cwd(),
 	});
 	child.unref();
+	setTimeout(() => lease.release(), 10_000).unref();
 }
 
 async function tryConnectRpcBackend(