@clinebot/core 0.0.20 → 0.0.21

package/src/session/session-config-builder.ts

@@ -1,113 +0,0 @@
-import type { LlmsProviders } from "@clinebot/llms";
-import type { ITelemetryService } from "@clinebot/shared";
-import { resolveAndLoadAgentPlugins } from "../agents/plugin-config-loader";
-import {
-	createHookAuditHooks,
-	createHookConfigFileHooks,
-	mergeAgentHooks,
-} from "../runtime/hook-file-hooks";
-import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
-import type { CoreSessionConfig } from "../types/config";
-import {
-	type ProviderSettings,
-	toProviderConfig,
-} from "../types/provider-settings";
-import type { StartSessionInput } from "./session-manager";
-import { hasRuntimeHooks, mergeAgentExtensions } from "./utils/helpers";
-
-export function resolveWorkspacePath(config: CoreSessionConfig): string {
-	return config.workspaceRoot ?? config.cwd;
-}
-
-export async function buildEffectiveConfig(
-	input: StartSessionInput,
-	hookPath: string,
-	sessionId: string,
-	defaultTelemetry: ITelemetryService | undefined,
-	onPluginEvent?: (event: { name: string; payload?: unknown }) => void,
-): Promise<{
-	config: CoreSessionConfig;
-	pluginSandboxShutdown?: () => Promise<void>;
-}> {
-	const workspacePath = resolveWorkspacePath(input.config);
-
-	const fileHooks = createHookConfigFileHooks({
-		cwd: input.config.cwd,
-		workspacePath,
-		rootSessionId: sessionId,
-		hookLogPath: hookPath,
-		logger: input.config.logger,
-	});
-	const auditHooks = hasRuntimeHooks(input.config.hooks)
-		? undefined
-		: createHookAuditHooks({
-				hookLogPath: hookPath,
-				rootSessionId: sessionId,
-				workspacePath,
-			});
-	const effectiveHooks = mergeAgentHooks([
-		input.config.hooks,
-		fileHooks,
-		auditHooks,
-	]);
-
-	const loadedPlugins = await resolveAndLoadAgentPlugins({
-		pluginPaths: input.config.pluginPaths,
-		workspacePath,
-		cwd: input.config.cwd,
-		onEvent: onPluginEvent,
-	});
-	const effectiveExtensions = mergeAgentExtensions(
-		input.config.extensions,
-		loadedPlugins.extensions,
-	);
-
-	return {
-		config: {
-			...input.config,
-			hooks: effectiveHooks,
-			extensions: effectiveExtensions,
-			telemetry: input.config.telemetry ?? defaultTelemetry,
-		},
-		pluginSandboxShutdown: loadedPlugins.shutdown,
-	};
-}
-
-export function buildResolvedProviderConfig(
-	config: CoreSessionConfig,
-	providerSettingsManager: ProviderSettingsManager,
-	resolveReasoningFn: (
-		config: CoreSessionConfig,
-		storedReasoning: ProviderSettings["reasoning"],
-	) => ProviderSettings["reasoning"],
-): LlmsProviders.ProviderConfig {
-	const stored = providerSettingsManager.getProviderSettings(config.providerId);
-	const settings: ProviderSettings = {
-		...(stored ?? {}),
-		provider: config.providerId,
-		model: config.modelId,
-		apiKey: config.apiKey ?? stored?.apiKey,
-		baseUrl: config.baseUrl ?? stored?.baseUrl,
-		headers: config.headers ?? stored?.headers,
-		reasoning: resolveReasoningFn(config, stored?.reasoning),
-	};
-	const providerConfig = toProviderConfig(settings);
-	if (config.knownModels) {
-		providerConfig.knownModels = config.knownModels;
-	}
-	return providerConfig;
-}
-
-export function resolveReasoningSettings(
-	config: CoreSessionConfig,
-	storedReasoning: ProviderSettings["reasoning"],
-): ProviderSettings["reasoning"] {
-	const hasThinking = typeof config.thinking === "boolean";
-	const hasEffort = typeof config.reasoningEffort === "string";
-	if (!hasThinking && !hasEffort) return storedReasoning;
-	return {
-		...(storedReasoning ?? {}),
-		...(hasThinking ? { enabled: config.thinking } : {}),
-		...(hasEffort ? { effort: config.reasoningEffort } : {}),
-	};
-}

package/src/session/session-graph.ts

@@ -1,92 +0,0 @@
-import type { HookEventPayload } from "@clinebot/agents";
-import { nanoid } from "nanoid";
-import type { SessionStatus } from "../types/common";
-
-export function sanitizeSessionToken(value: string): string {
-	return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
-}
-
-export function makeSubSessionId(
-	rootSessionId: string,
-	agentId: string,
-): string {
-	const root = sanitizeSessionToken(rootSessionId);
-	const agent = sanitizeSessionToken(agentId);
-	const joined = `${root}__${agent}`;
-	return joined.length > 180 ? joined.slice(0, 180) : joined;
-}
-
-export function makeTeamTaskSubSessionId(
-	rootSessionId: string,
-	agentId: string,
-): string {
-	const root = sanitizeSessionToken(rootSessionId);
-	const agent = sanitizeSessionToken(agentId);
-	return `${root}__teamtask__${agent}__${nanoid(6)}`;
-}
-
-export function parseTeamTaskSubSessionId(
-	sessionId: string,
-): { rootSessionId: string; agentId: string; teamTaskId: string } | null {
-	const marker = "__teamtask__";
-	const markerIndex = sessionId.indexOf(marker);
-	if (markerIndex <= 0) {
-		return null;
-	}
-	const rootSessionId = sessionId.slice(0, markerIndex);
-	const remainder = sessionId.slice(markerIndex + marker.length);
-	const lastSeparator = remainder.lastIndexOf("__");
-	if (lastSeparator <= 0) {
-		return null;
-	}
-	const agentId = remainder.slice(0, lastSeparator);
-	const teamTaskId = remainder.slice(lastSeparator + 2);
-	if (!rootSessionId || !agentId || !teamTaskId) {
-		return null;
-	}
-	return { rootSessionId, agentId, teamTaskId };
-}
-
-export function parseSubSessionId(
-	sessionId: string,
-): { rootSessionId: string; agentId: string } | null {
-	if (parseTeamTaskSubSessionId(sessionId)) {
-		return null;
-	}
-	const separator = "__";
-	const separatorIndex = sessionId.indexOf(separator);
-	if (separatorIndex <= 0) {
-		return null;
-	}
-	const rootSessionId = sessionId.slice(0, separatorIndex);
-	const agentId = sessionId.slice(separatorIndex + separator.length);
-	if (!rootSessionId || !agentId) {
-		return null;
-	}
-	return { rootSessionId, agentId };
-}
-
-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 (
-				reason.includes("cancel") ||
-				reason.includes("abort") ||
-				reason.includes("interrupt")
-			) {
-				return "cancelled";
-			}
-			if (reason.includes("fail") || reason.includes("error")) {
-				return "failed";
-			}
-			return "completed";
-		}
-		default:
-			return "running";
-	}
-}

package/src/session/session-host.test.ts

@@ -1,29 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-vi.mock("@clinebot/rpc", () => ({
-	getRpcServerDefaultAddress: () => "ws://127.0.0.1:0",
-	getRpcServerHealth: vi.fn(async () => undefined),
-}));
-
-describe("resolveSessionBackend", () => {
-	afterEach(() => {
-		vi.resetModules();
-		vi.restoreAllMocks();
-	});
-
-	it("falls back to file session storage when sqlite initialization fails", async () => {
-		vi.doMock("../storage/sqlite-session-store", () => ({
-			SqliteSessionStore: class {
-				init(): void {
-					throw new Error("sqlite unavailable");
-				}
-			},
-		}));
-
-		const { resolveSessionBackend } = await import("./session-host");
-		const { FileSessionService } = await import("./file-session-service");
-
-		const backend = await resolveSessionBackend({ backendMode: "local" });
-		expect(backend).toBeInstanceOf(FileSessionService);
-	});
-});

package/src/session/session-host.ts

@@ -1,242 +0,0 @@
-import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-import type {
-	AgentConfig,
-	ToolApprovalRequest,
-	ToolApprovalResult,
-} from "@clinebot/agents";
-import { getRpcServerDefaultAddress, getRpcServerHealth } from "@clinebot/rpc";
-import type { ITelemetryService } from "@clinebot/shared";
-import { resolveSessionDataDir } from "@clinebot/shared/storage";
-import { nanoid } from "nanoid";
-import { SqliteSessionStore } from "../storage/sqlite-session-store";
-import type { ToolExecutors } from "../tools";
-import { DefaultSessionManager } from "./default-session-manager";
-import { FileSessionService } from "./file-session-service";
-import { RpcCoreSessionService } from "./rpc-session-service";
-import { tryAcquireRpcSpawnLease } from "./rpc-spawn-lease";
-import type { SessionManager } from "./session-manager";
-import { CoreSessionService } from "./session-service";
-
-const DEFAULT_RPC_ADDRESS =
-	process.env.CLINE_RPC_ADDRESS?.trim() || getRpcServerDefaultAddress();
-
-export type SessionBackend =
-	| RpcCoreSessionService
-	| CoreSessionService
-	| FileSessionService;
-
-let cachedBackend: SessionBackend | undefined;
-let backendInitPromise: Promise<SessionBackend> | undefined;
-
-export interface CreateSessionHostOptions {
-	distinctId?: string;
-	sessionService?: SessionBackend;
-	backendMode?: "auto" | "rpc" | "local";
-	rpcAddress?: string;
-	autoStartRpcServer?: boolean;
-	rpcConnectAttempts?: number;
-	rpcConnectDelayMs?: number;
-	defaultToolExecutors?: Partial<ToolExecutors>;
-	telemetry?: ITelemetryService;
-	toolPolicies?: AgentConfig["toolPolicies"];
-	requestToolApproval?: (
-		request: ToolApprovalRequest,
-	) => Promise<ToolApprovalResult>;
-}
-
-export type SessionHost = SessionManager;
-
-async function reconcileDeadSessionsIfSupported(
-	backend: SessionBackend,
-): Promise<void> {
-	const service = backend as SessionBackend & {
-		reconcileDeadSessions?: (limit?: number) => Promise<number>;
-	};
-	await service.reconcileDeadSessions?.().catch(() => {});
-}
-
-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) =>
-		arg.startsWith("--conditions="),
-	);
-	const args = [
-		...(conditionsArg ? [conditionsArg] : []),
-		entry,
-		"rpc",
-		"start",
-		"--address",
-		address,
-	];
-
-	const child = spawn(launcher, args, {
-		detached: true,
-		stdio: "ignore",
-		env: {
-			...process.env,
-			CLINE_NO_INTERACTIVE: "1",
-		},
-		cwd: process.cwd(),
-	});
-	child.unref();
-	setTimeout(() => lease.release(), 10_000).unref();
-}
-
-async function tryConnectRpcBackend(
-	address: string,
-): Promise<RpcCoreSessionService | undefined> {
-	try {
-		const health = await getRpcServerHealth(address);
-		if (!health) {
-			return undefined;
-		}
-		return new RpcCoreSessionService({
-			address,
-			sessionsDir: resolveSessionDataDir(),
-		});
-	} catch {
-		return undefined;
-	}
-}
-
-function createLocalBackend(): SessionBackend {
-	try {
-		const store = new SqliteSessionStore();
-		store.init();
-		return new CoreSessionService(store);
-	} catch (error) {
-		console.warn(
-			"SQLite session persistence unavailable, falling back to file-based session storage.",
-			error,
-		);
-		return new FileSessionService();
-	}
-}
-
-function resolveHostDistinctId(explicitDistinctId: string | undefined): string {
-	if (
-		typeof explicitDistinctId === "string" &&
-		explicitDistinctId.trim().length > 0
-	) {
-		return explicitDistinctId.trim();
-	}
-
-	const sessionDataDir = resolveSessionDataDir();
-	const distinctIdPath = resolve(sessionDataDir, "machine-id");
-	try {
-		if (existsSync(distinctIdPath)) {
-			const savedDistinctId = readFileSync(distinctIdPath, "utf8").trim();
-			if (savedDistinctId.length > 0) {
-				return savedDistinctId;
-			}
-		}
-	} catch {
-		// Ignore read errors and generate a fresh fallback ID.
-	}
-
-	const generatedDistinctId = nanoid();
-	try {
-		mkdirSync(sessionDataDir, { recursive: true });
-		writeFileSync(distinctIdPath, generatedDistinctId, "utf8");
-	} catch {
-		// Ignore write errors and continue with in-memory fallback.
-	}
-	return generatedDistinctId;
-}
-
-export async function resolveSessionBackend(
-	options: CreateSessionHostOptions,
-): Promise<SessionBackend> {
-	if (cachedBackend) {
-		return cachedBackend;
-	}
-	if (backendInitPromise) {
-		return await backendInitPromise;
-	}
-
-	const mode = options.backendMode ?? "auto";
-	const address = options.rpcAddress?.trim() || DEFAULT_RPC_ADDRESS;
-	const attempts = Math.max(1, options.rpcConnectAttempts ?? 5);
-	const delayMs = Math.max(0, options.rpcConnectDelayMs ?? 100);
-	const autoStartRpc = options.autoStartRpcServer !== false;
-
-	backendInitPromise = (async () => {
-		if (mode === "local") {
-			cachedBackend = createLocalBackend();
-			await reconcileDeadSessionsIfSupported(cachedBackend);
-			return cachedBackend;
-		}
-
-		const existingRpcBackend = await tryConnectRpcBackend(address);
-		if (existingRpcBackend) {
-			cachedBackend = existingRpcBackend;
-			await reconcileDeadSessionsIfSupported(cachedBackend);
-			return cachedBackend;
-		}
-
-		if (mode === "rpc") {
-			throw new Error(`RPC backend unavailable at ${address}`);
-		}
-
-		if (autoStartRpc) {
-			try {
-				startRpcServerInBackground(address);
-			} catch {
-				// Ignore launch failures and fall back to local backend.
-			}
-
-			for (let attempt = 0; attempt < attempts; attempt += 1) {
-				const rpcBackend = await tryConnectRpcBackend(address);
-				if (rpcBackend) {
-					cachedBackend = rpcBackend;
-					await reconcileDeadSessionsIfSupported(cachedBackend);
-					return cachedBackend;
-				}
-				if (delayMs > 0) {
-					await new Promise((resolve) => setTimeout(resolve, delayMs));
-				}
-			}
-		}
-
-		cachedBackend = createLocalBackend();
-		await reconcileDeadSessionsIfSupported(cachedBackend);
-		return cachedBackend;
-	})().finally(() => {
-		backendInitPromise = undefined;
-	});
-
-	return await backendInitPromise;
-}
-
-export async function createSessionHost(
-	options: CreateSessionHostOptions,
-): Promise<SessionHost> {
-	const distinctId = resolveHostDistinctId(options.distinctId);
-	options.telemetry?.setDistinctId(distinctId);
-	const backend =
-		options.sessionService ?? (await resolveSessionBackend(options));
-	return new DefaultSessionManager({
-		sessionService: backend,
-		defaultToolExecutors: options.defaultToolExecutors,
-		telemetry: options.telemetry,
-		toolPolicies: options.toolPolicies,
-		requestToolApproval: options.requestToolApproval,
-		distinctId,
-	});
-}

package/src/session/session-manager.ts

@@ -1,69 +0,0 @@
-import type { AgentResult } from "@clinebot/agents";
-import type { LlmsProviders } from "@clinebot/llms";
-import type { SessionSource } from "../types/common";
-import type { CoreSessionConfig } from "../types/config";
-import type { CoreSessionEvent } from "../types/events";
-import type { SessionRecord } from "../types/sessions";
-import type { SessionManifest } from "./session-manifest";
-
-export interface StartSessionInput {
-	config: CoreSessionConfig;
-	source?: SessionSource;
-	prompt?: string;
-	interactive?: boolean;
-	initialMessages?: LlmsProviders.Message[];
-	userImages?: string[];
-	userFiles?: string[];
-	userInstructionWatcher?: import("../agents").UserInstructionConfigWatcher;
-	onTeamRestored?: () => void;
-	defaultToolExecutors?: Partial<import("../tools").ToolExecutors>;
-	toolPolicies?: import("@clinebot/agents").AgentConfig["toolPolicies"];
-	requestToolApproval?: (
-		request: import("@clinebot/agents").ToolApprovalRequest,
-	) => Promise<import("@clinebot/agents").ToolApprovalResult>;
-}
-
-export interface StartSessionResult {
-	sessionId: string;
-	manifest: SessionManifest;
-	manifestPath: string;
-	transcriptPath: string;
-	hookPath: string;
-	messagesPath: string;
-	result?: AgentResult;
-}
-
-export interface SendSessionInput {
-	sessionId: string;
-	prompt: string;
-	userImages?: string[];
-	userFiles?: string[];
-	delivery?: "queue" | "steer";
-}
-
-export interface SessionAccumulatedUsage {
-	inputTokens: number;
-	outputTokens: number;
-	cacheReadTokens: number;
-	cacheWriteTokens: number;
-	totalCost: number;
-}
-
-export interface SessionManager {
-	start(input: StartSessionInput): Promise<StartSessionResult>;
-	send(input: SendSessionInput): Promise<AgentResult | undefined>;
-	getAccumulatedUsage(
-		sessionId: string,
-	): Promise<SessionAccumulatedUsage | undefined>;
-	abort(sessionId: string, reason?: unknown): Promise<void>;
-	stop(sessionId: string): Promise<void>;
-	dispose(reason?: string): Promise<void>;
-	get(sessionId: string): Promise<SessionRecord | undefined>;
-	list(limit?: number): Promise<SessionRecord[]>;
-	delete(sessionId: string): Promise<boolean>;
-	readMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
-	readTranscript(sessionId: string, maxChars?: number): Promise<string>;
-	readHooks(sessionId: string, limit?: number): Promise<unknown[]>;
-	subscribe(listener: (event: CoreSessionEvent) => void): () => void;
-	updateSessionModel?(sessionId: string, modelId: string): Promise<void>;
-}

package/src/session/session-manifest.ts

@@ -1,29 +0,0 @@
-import { z } from "zod";
-import { SESSION_STATUSES, SessionSource } from "../types/common";
-
-const SessionStatusSchema = z.enum(SESSION_STATUSES);
-
-export const SessionManifestSchema = z.object({
-	version: z.literal(1),
-	session_id: z.string().min(1),
-	source: z.enum(SessionSource),
-	pid: z.number().int(),
-	started_at: z.string().min(1),
-	ended_at: z.string().min(1).optional(),
-	exit_code: z.number().int().nullable().optional(),
-	status: SessionStatusSchema,
-	interactive: z.boolean(),
-	provider: z.string().min(1),
-	model: z.string().min(1),
-	cwd: z.string().min(1),
-	workspace_root: z.string().min(1),
-	team_name: z.string().min(1).optional(),
-	enable_tools: z.boolean(),
-	enable_spawn: z.boolean(),
-	enable_teams: z.boolean(),
-	prompt: z.string().optional(),
-	metadata: z.record(z.string(), z.unknown()).optional(),
-	messages_path: z.string().min(1).optional(),
-});
-
-export type SessionManifest = z.infer<typeof SessionManifestSchema>;

package/src/session/session-service.team-persistence.test.ts

@@ -1,48 +0,0 @@
-import { existsSync, mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { AgentTeamsRuntime } from "@clinebot/agents";
-import { describe, expect, it } from "vitest";
-import { FileTeamPersistenceStore } from "./session-service";
-
-describe("FileTeamPersistenceStore", () => {
-	it("does not create state.json for an empty runtime", () => {
-		const baseDir = mkdtempSync(join(tmpdir(), "team-store-"));
-		const store = new FileTeamPersistenceStore({
-			teamName: "agent-team-nmnn9",
-			baseDir,
-		});
-		const runtime = new AgentTeamsRuntime({ teamName: "agent-team-nmnn9" });
-
-		store.persist(runtime);
-
-		expect(
-			existsSync(join(baseDir, "agent-team-nmnn9", "state.json")),
-		).toBeFalsy();
-	});
-
-	it("removes persisted state when runtime becomes empty again", () => {
-		const baseDir = mkdtempSync(join(tmpdir(), "team-store-"));
-		const store = new FileTeamPersistenceStore({
-			teamName: "agent-team-cleanup",
-			baseDir,
-		});
-		const runtime = new AgentTeamsRuntime({ teamName: "agent-team-cleanup" });
-
-		store.upsertTeammateSpec({
-			agentId: "worker",
-			rolePrompt: "Implement tasks",
-		});
-		store.persist(runtime);
-		expect(
-			existsSync(join(baseDir, "agent-team-cleanup", "state.json")),
-		).toBeTruthy();
-
-		store.removeTeammateSpec("worker");
-		runtime.cleanup();
-		store.persist(runtime);
-		expect(
-			existsSync(join(baseDir, "agent-team-cleanup", "state.json")),
-		).toBeFalsy();
-	});
-});