@clinebot/core 0.0.18 → 0.0.21

package/src/session/file-session-service.ts

@@ -1,280 +0,0 @@
-import {
-	existsSync,
-	mkdirSync,
-	readFileSync,
-	renameSync,
-	writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import { resolveSessionDataDir } from "@clinebot/shared/storage";
-import type { SessionRow } from "./session-service";
-import type {
-	PersistedSessionUpdateInput,
-	SessionPersistenceAdapter,
-} from "./unified-session-persistence-service";
-import { UnifiedSessionPersistenceService } from "./unified-session-persistence-service";
-
-interface FileSessionIndex {
-	version: 1;
-	sessions: Record<string, SessionRow>;
-}
-
-interface FileSpawnRequest {
-	id: number;
-	rootSessionId: string;
-	parentAgentId: string;
-	task?: string;
-	systemPrompt?: string;
-	createdAt: string;
-	consumedAt?: string;
-}
-
-interface FileSpawnQueue {
-	version: 1;
-	nextId: number;
-	requests: FileSpawnRequest[];
-}
-
-function nowIso(): string {
-	return new Date().toISOString();
-}
-
-function atomicWriteJson(path: string, value: unknown): void {
-	const tempPath = `${path}.tmp`;
-	writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-	renameSync(tempPath, path);
-}
-
-function defaultSessionsDir(): string {
-	return resolveSessionDataDir();
-}
-
-class FileSessionPersistenceAdapter implements SessionPersistenceAdapter {
-	constructor(
-		private readonly sessionsDirPath: string = defaultSessionsDir(),
-	) {}
-
-	ensureSessionsDir(): string {
-		if (!existsSync(this.sessionsDirPath)) {
-			mkdirSync(this.sessionsDirPath, { recursive: true });
-		}
-		return this.sessionsDirPath;
-	}
-
-	private indexPath(): string {
-		return join(this.ensureSessionsDir(), "sessions.index.json");
-	}
-
-	private spawnQueuePath(): string {
-		return join(this.ensureSessionsDir(), "subagent-spawn-queue.json");
-	}
-
-	private readIndex(): FileSessionIndex {
-		const path = this.indexPath();
-		if (!existsSync(path)) {
-			return { version: 1, sessions: {} };
-		}
-		try {
-			const parsed = JSON.parse(readFileSync(path, "utf8")) as FileSessionIndex;
-			if (parsed?.version === 1 && parsed.sessions) {
-				return parsed;
-			}
-		} catch {
-			// Ignore invalid persistence and fall back to an empty index.
-		}
-		return { version: 1, sessions: {} };
-	}
-
-	private writeIndex(index: FileSessionIndex): void {
-		atomicWriteJson(this.indexPath(), index);
-	}
-
-	private readQueue(): FileSpawnQueue {
-		const path = this.spawnQueuePath();
-		if (!existsSync(path)) {
-			return { version: 1, nextId: 1, requests: [] };
-		}
-		try {
-			const parsed = JSON.parse(readFileSync(path, "utf8")) as FileSpawnQueue;
-			if (
-				parsed?.version === 1 &&
-				typeof parsed.nextId === "number" &&
-				Array.isArray(parsed.requests)
-			) {
-				return parsed;
-			}
-		} catch {
-			// Ignore invalid persistence and fall back to an empty queue.
-		}
-		return { version: 1, nextId: 1, requests: [] };
-	}
-
-	private writeQueue(queue: FileSpawnQueue): void {
-		atomicWriteJson(this.spawnQueuePath(), queue);
-	}
-
-	async upsertSession(row: SessionRow): Promise<void> {
-		const index = this.readIndex();
-		index.sessions[row.sessionId] = row;
-		this.writeIndex(index);
-	}
-
-	async getSession(sessionId: string): Promise<SessionRow | undefined> {
-		return this.readIndex().sessions[sessionId];
-	}
-
-	async listSessions(options: {
-		limit: number;
-		parentSessionId?: string;
-		status?: string;
-	}): Promise<SessionRow[]> {
-		return Object.values(this.readIndex().sessions)
-			.filter((row) =>
-				options.parentSessionId !== undefined
-					? row.parentSessionId === options.parentSessionId
-					: true,
-			)
-			.filter((row) =>
-				options.status !== undefined ? row.status === options.status : true,
-			)
-			.sort((a, b) => b.startedAt.localeCompare(a.startedAt))
-			.slice(0, options.limit);
-	}
-
-	async updateSession(
-		input: PersistedSessionUpdateInput,
-	): Promise<{ updated: boolean; statusLock: number }> {
-		const index = this.readIndex();
-		const existing = index.sessions[input.sessionId];
-		if (!existing) {
-			return { updated: false, statusLock: 0 };
-		}
-		if (
-			input.expectedStatusLock !== undefined &&
-			existing.statusLock !== input.expectedStatusLock
-		) {
-			return { updated: false, statusLock: existing.statusLock };
-		}
-
-		const nextStatusLock =
-			input.expectedStatusLock !== undefined
-				? input.expectedStatusLock + 1
-				: existing.statusLock;
-		const next: SessionRow = {
-			...existing,
-			status: input.status ?? existing.status,
-			endedAt:
-				input.endedAt !== undefined
-					? input.endedAt
-					: (existing.endedAt ?? null),
-			exitCode:
-				input.exitCode !== undefined
-					? input.exitCode
-					: (existing.exitCode ?? null),
-			prompt:
-				input.prompt !== undefined ? input.prompt : (existing.prompt ?? null),
-			metadata:
-				input.metadata !== undefined
-					? (input.metadata ?? null)
-					: (existing.metadata ?? null),
-			parentSessionId:
-				input.parentSessionId !== undefined
-					? (input.parentSessionId ?? null)
-					: (existing.parentSessionId ?? null),
-			parentAgentId:
-				input.parentAgentId !== undefined
-					? (input.parentAgentId ?? null)
-					: (existing.parentAgentId ?? null),
-			agentId:
-				input.agentId !== undefined
-					? (input.agentId ?? null)
-					: (existing.agentId ?? null),
-			conversationId:
-				input.conversationId !== undefined
-					? (input.conversationId ?? null)
-					: (existing.conversationId ?? null),
-			statusLock: nextStatusLock,
-			isSubagent:
-				input.setRunning || input.parentSessionId !== undefined
-					? true
-					: existing.isSubagent,
-			updatedAt: nowIso(),
-		};
-
-		if (input.setRunning) {
-			next.status = "running";
-			next.endedAt = null;
-			next.exitCode = null;
-		}
-
-		index.sessions[input.sessionId] = next;
-		this.writeIndex(index);
-		return { updated: true, statusLock: next.statusLock };
-	}
-
-	async deleteSession(sessionId: string, cascade: boolean): Promise<boolean> {
-		const index = this.readIndex();
-		const existing = index.sessions[sessionId];
-		if (!existing) {
-			return false;
-		}
-		delete index.sessions[sessionId];
-		if (cascade) {
-			for (const row of Object.values(index.sessions)) {
-				if (row.parentSessionId === sessionId) {
-					delete index.sessions[row.sessionId];
-				}
-			}
-		}
-		this.writeIndex(index);
-		return true;
-	}
-
-	async enqueueSpawnRequest(input: {
-		rootSessionId: string;
-		parentAgentId: string;
-		task?: string;
-		systemPrompt?: string;
-	}): Promise<void> {
-		const queue = this.readQueue();
-		queue.requests.push({
-			id: queue.nextId,
-			rootSessionId: input.rootSessionId,
-			parentAgentId: input.parentAgentId,
-			task: input.task,
-			systemPrompt: input.systemPrompt,
-			createdAt: nowIso(),
-		});
-		queue.nextId += 1;
-		this.writeQueue(queue);
-	}
-
-	async claimSpawnRequest(
-		rootSessionId: string,
-		parentAgentId: string,
-	): Promise<string | undefined> {
-		const queue = this.readQueue();
-		const request = queue.requests.find(
-			(item) =>
-				item.rootSessionId === rootSessionId &&
-				item.parentAgentId === parentAgentId &&
-				!item.consumedAt,
-		);
-		if (!request) {
-			return undefined;
-		}
-		request.consumedAt = nowIso();
-		this.writeQueue(queue);
-		return request.task;
-	}
-}
-
-export class FileSessionService extends UnifiedSessionPersistenceService {
-	constructor(sessionsDir?: string) {
-		super(new FileSessionPersistenceAdapter(sessionsDir));
-	}
-
-	override ensureSessionsDir(): string {
-		return super.ensureSessionsDir();
-	}
-}

package/src/session/index.ts

@@ -1,42 +0,0 @@
-export { DefaultSessionManager } from "./default-session-manager";
-export { RpcCoreSessionService } from "./rpc-session-service";
-export {
-	deriveSubsessionStatus,
-	makeSubSessionId,
-	makeTeamTaskSubSessionId,
-	sanitizeSessionToken,
-} from "./session-graph";
-export type {
-	CreateSessionHostOptions,
-	SessionBackend,
-	SessionHost,
-} from "./session-host";
-export { createSessionHost, resolveSessionBackend } from "./session-host";
-export type {
-	SendSessionInput,
-	SessionAccumulatedUsage,
-	SessionManager,
-	StartSessionInput,
-	StartSessionResult,
-} from "./session-manager";
-export type { SessionManifest } from "./session-manifest";
-export type {
-	CreateRootSessionWithArtifactsInput,
-	RootSessionArtifacts,
-} from "./session-service";
-export { CoreSessionService } from "./session-service";
-export type {
-	WorkspaceManager,
-	WorkspaceManagerEvent,
-} from "./workspace-manager";
-export { InMemoryWorkspaceManager } from "./workspace-manager";
-export type { WorkspaceManifest } from "./workspace-manifest";
-export {
-	buildWorkspaceMetadata,
-	emptyWorkspaceManifest,
-	generateWorkspaceInfo,
-	normalizeWorkspacePath,
-	upsertWorkspaceInfo,
-	WorkspaceInfoSchema,
-	WorkspaceManifestSchema,
-} from "./workspace-manifest";

package/src/session/rpc-session-service.ts

@@ -1,107 +0,0 @@
-import { existsSync, mkdirSync } from "node:fs";
-import { RpcSessionClient, type RpcSessionRow } from "@clinebot/rpc";
-import type { SessionRow } from "./session-service";
-import type {
-	PersistedSessionUpdateInput,
-	SessionPersistenceAdapter,
-} from "./unified-session-persistence-service";
-import { UnifiedSessionPersistenceService } from "./unified-session-persistence-service";
-
-// ── Adapter ──────────────────────────────────────────────────────────
-
-class RpcSessionPersistenceAdapter implements SessionPersistenceAdapter {
-	constructor(private readonly client: RpcSessionClient) {}
-
-	ensureSessionsDir(): string {
-		return "";
-	}
-
-	async upsertSession(row: SessionRow): Promise<void> {
-		await this.client.upsertSession(row as RpcSessionRow);
-	}
-
-	async getSession(sessionId: string): Promise<SessionRow | undefined> {
-		const row = await this.client.getSession(sessionId);
-		return (row as SessionRow | undefined) ?? undefined;
-	}
-
-	async listSessions(options: {
-		limit: number;
-		parentSessionId?: string;
-		status?: string;
-	}): Promise<SessionRow[]> {
-		const rows = await this.client.listSessions(options);
-		return rows as SessionRow[];
-	}
-
-	async updateSession(
-		input: PersistedSessionUpdateInput,
-	): Promise<{ updated: boolean; statusLock: number }> {
-		return this.client.updateSession({
-			sessionId: input.sessionId,
-			status: input.status,
-			endedAt: input.endedAt,
-			exitCode: input.exitCode,
-			prompt: input.prompt,
-			metadata: input.metadata,
-			parentSessionId: input.parentSessionId,
-			parentAgentId: input.parentAgentId,
-			agentId: input.agentId,
-			conversationId: input.conversationId,
-			expectedStatusLock: input.expectedStatusLock,
-			setRunning: input.setRunning,
-		});
-	}
-
-	async deleteSession(sessionId: string, cascade: boolean): Promise<boolean> {
-		return this.client.deleteSession(sessionId, cascade);
-	}
-
-	async enqueueSpawnRequest(input: {
-		rootSessionId: string;
-		parentAgentId: string;
-		task?: string;
-		systemPrompt?: string;
-	}): Promise<void> {
-		await this.client.enqueueSpawnRequest(input);
-	}
-
-	async claimSpawnRequest(
-		rootSessionId: string,
-		parentAgentId: string,
-	): Promise<string | undefined> {
-		return this.client.claimSpawnRequest(rootSessionId, parentAgentId);
-	}
-}
-
-// ── Service ──────────────────────────────────────────────────────────
-
-export interface RpcCoreSessionServiceOptions {
-	address?: string;
-	sessionsDir: string;
-}
-
-export class RpcCoreSessionService extends UnifiedSessionPersistenceService {
-	private readonly sessionsDirPath: string;
-	private readonly client: RpcSessionClient;
-
-	constructor(options: RpcCoreSessionServiceOptions) {
-		const client = new RpcSessionClient({
-			address: options.address?.trim() || "127.0.0.1:4317",
-		});
-		super(new RpcSessionPersistenceAdapter(client));
-		this.sessionsDirPath = options.sessionsDir;
-		this.client = client;
-	}
-
-	override ensureSessionsDir(): string {
-		if (!existsSync(this.sessionsDirPath)) {
-			mkdirSync(this.sessionsDirPath, { recursive: true });
-		}
-		return this.sessionsDirPath;
-	}
-
-	close(): void {
-		this.client.close();
-	}
-}

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

@@ -1,49 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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.
-			}
-		},
-	};
-}