@clinebot/core 0.0.21 → 0.0.23

package/src/session/utils/helpers.ts

@@ -0,0 +1,139 @@
+import type { AgentConfig, AgentEvent, AgentResult } from "@clinebot/agents";
+import type * as LlmsProviders from "@clinebot/llms/providers";
+import type { SessionSource } from "../../types/common";
+import type { SessionRecord } from "../../types/sessions";
+import type { SessionRow } from "../session-service";
+import type { StoredMessageWithMetadata } from "./types";
+
+const WORKSPACE_CONFIGURATION_MARKER = "# Workspace Configuration";
+
+export function extractWorkspaceMetadataFromSystemPrompt(
+	systemPrompt: string,
+): string | undefined {
+	const markerIndex = systemPrompt.lastIndexOf(WORKSPACE_CONFIGURATION_MARKER);
+	if (markerIndex < 0) {
+		return undefined;
+	}
+	const metadata = systemPrompt.slice(markerIndex).trim();
+	return metadata.length > 0 ? metadata : undefined;
+}
+
+export function hasRuntimeHooks(hooks: AgentConfig["hooks"]): boolean {
+	if (!hooks) {
+		return false;
+	}
+	return Object.values(hooks).some((value) => typeof value === "function");
+}
+
+export function mergeAgentExtensions(
+	explicitExtensions: AgentConfig["extensions"] | undefined,
+	loadedExtensions: AgentConfig["extensions"] | undefined,
+): AgentConfig["extensions"] {
+	const merged = [...(explicitExtensions ?? []), ...(loadedExtensions ?? [])];
+	if (merged.length === 0) {
+		return undefined;
+	}
+	const deduped: NonNullable<AgentConfig["extensions"]> = [];
+	const seenNames = new Set<string>();
+	for (const extension of merged) {
+		if (seenNames.has(extension.name)) {
+			continue;
+		}
+		seenNames.add(extension.name);
+		deduped.push(extension);
+	}
+	return deduped;
+}
+
+export function serializeAgentEvent(event: AgentEvent): string {
+	return JSON.stringify(event, (_key, value) => {
+		if (value instanceof Error) {
+			return {
+				name: value.name,
+				message: value.message,
+				stack: value.stack,
+			};
+		}
+		return value;
+	});
+}
+
+export function withLatestAssistantTurnMetadata(
+	messages: LlmsProviders.Message[],
+	result: AgentResult,
+	previousMessages: LlmsProviders.MessageWithMetadata[] = [],
+): StoredMessageWithMetadata[] {
+	const next = messages.map((message, index) => {
+		const previous = previousMessages[index];
+		const sameMessage =
+			previous?.role === message.role &&
+			JSON.stringify(previous.content) === JSON.stringify(message.content);
+		return sameMessage
+			? ({
+					...previous,
+					...message,
+				} as StoredMessageWithMetadata)
+			: ({ ...message } as StoredMessageWithMetadata);
+	});
+	const assistantIndex = [...next]
+		.reverse()
+		.findIndex((message) => message.role === "assistant");
+	if (assistantIndex === -1) {
+		return next;
+	}
+
+	const targetIndex = next.length - 1 - assistantIndex;
+	const target = next[targetIndex];
+	const usage = result.usage;
+	next[targetIndex] = {
+		...target,
+		providerId: target.providerId ?? result.model.provider,
+		modelId: target.modelId ?? result.model.id,
+		modelInfo: target.modelInfo ?? {
+			id: result.model.id,
+			provider: result.model.provider,
+		},
+		metrics: {
+			...(target.metrics ?? {}),
+			inputTokens: usage.inputTokens,
+			outputTokens: usage.outputTokens,
+			cacheReadTokens: usage.cacheReadTokens,
+			cacheWriteTokens: usage.cacheWriteTokens,
+			cost: usage.totalCost,
+		},
+		ts: target.ts ?? result.endedAt.getTime(),
+	};
+	return next;
+}
+
+export function toSessionRecord(row: SessionRow): SessionRecord {
+	return {
+		sessionId: row.sessionId,
+		source: row.source as SessionSource,
+		pid: row.pid,
+		startedAt: row.startedAt,
+		endedAt: row.endedAt ?? null,
+		exitCode: row.exitCode ?? null,
+		status: row.status,
+		interactive: row.interactive,
+		provider: row.provider,
+		model: row.model,
+		cwd: row.cwd,
+		workspaceRoot: row.workspaceRoot,
+		teamName: row.teamName ?? undefined,
+		enableTools: row.enableTools,
+		enableSpawn: row.enableSpawn,
+		enableTeams: row.enableTeams,
+		parentSessionId: row.parentSessionId ?? undefined,
+		parentAgentId: row.parentAgentId ?? undefined,
+		agentId: row.agentId ?? undefined,
+		conversationId: row.conversationId ?? undefined,
+		isSubagent: row.isSubagent,
+		prompt: row.prompt ?? undefined,
+		metadata: row.metadata ?? undefined,
+		transcriptPath: row.transcriptPath,
+		hookPath: row.hookPath,
+		messagesPath: row.messagesPath ?? undefined,
+		updatedAt: row.updatedAt,
+	};
+}

package/src/session/utils/types.ts

@@ -0,0 +1,57 @@
+import type { Agent } from "@clinebot/agents";
+import type * as LlmsProviders from "@clinebot/llms/providers";
+import type { BuiltRuntime } from "../../runtime/session-runtime";
+import type { SessionSource } from "../../types/common";
+import type { CoreSessionConfig } from "../../types/config";
+import type { SessionAccumulatedUsage } from "../session-manager";
+import type { RootSessionArtifacts } from "../session-service";
+
+export type ActiveSession = {
+	sessionId: string;
+	config: CoreSessionConfig;
+	artifacts?: RootSessionArtifacts;
+	source: SessionSource;
+	startedAt: string;
+	pendingPrompt?: string;
+	runtime: BuiltRuntime;
+	agent: Agent;
+	started: boolean;
+	aborting: boolean;
+	interactive: boolean;
+	persistedMessages?: LlmsProviders.MessageWithMetadata[];
+	activeTeamRunIds: Set<string>;
+	pendingTeamRunUpdates: TeamRunUpdate[];
+	teamRunWaiters: Array<() => void>;
+	pendingPrompts: PendingPrompt[];
+	drainingPendingPrompts: boolean;
+	pluginSandboxShutdown?: () => Promise<void>;
+	turnUsageBaseline?: SessionAccumulatedUsage;
+};
+
+export type PendingPrompt = {
+	id: string;
+	prompt: string;
+	delivery: "queue" | "steer";
+	userImages?: string[];
+	userFiles?: string[];
+};
+
+export type TeamRunUpdate = {
+	runId: string;
+	agentId: string;
+	taskId?: string;
+	status: "completed" | "failed" | "cancelled" | "interrupted";
+	error?: string;
+	iterations?: number;
+};
+
+export type StoredMessageWithMetadata = LlmsProviders.MessageWithMetadata & {
+	providerId?: string;
+	modelId?: string;
+};
+
+export type PreparedTurnInput = {
+	prompt: string;
+	userImages?: string[];
+	userFiles?: string[];
+};

package/src/session/utils/usage.ts

@@ -0,0 +1,32 @@
+import type { SessionAccumulatedUsage } from "../session-manager";
+
+export function createInitialAccumulatedUsage(): SessionAccumulatedUsage {
+	return {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0,
+		totalCost: 0,
+	};
+}
+
+export function accumulateUsageTotals(
+	baseline: SessionAccumulatedUsage,
+	usage: {
+		inputTokens?: number;
+		outputTokens?: number;
+		cacheReadTokens?: number;
+		cacheWriteTokens?: number;
+		totalCost?: number;
+	},
+): SessionAccumulatedUsage {
+	return {
+		inputTokens: baseline.inputTokens + Math.max(0, usage.inputTokens ?? 0),
+		outputTokens: baseline.outputTokens + Math.max(0, usage.outputTokens ?? 0),
+		cacheReadTokens:
+			baseline.cacheReadTokens + Math.max(0, usage.cacheReadTokens ?? 0),
+		cacheWriteTokens:
+			baseline.cacheWriteTokens + Math.max(0, usage.cacheWriteTokens ?? 0),
+		totalCost: baseline.totalCost + Math.max(0, usage.totalCost ?? 0),
+	};
+}

package/src/session/workspace-manager.ts

@@ -0,0 +1,98 @@
+import type { WorkspaceInfo } from "../types/workspace";
+import {
+	generateWorkspaceInfo,
+	normalizeWorkspacePath,
+	upsertWorkspaceInfo,
+	type WorkspaceManifest,
+	WorkspaceManifestSchema,
+} from "./workspace-manifest";
+
+export interface WorkspaceManagerEvent {
+	type: "workspace_added" | "workspace_switched";
+	workspace: WorkspaceInfo;
+}
+
+export interface WorkspaceManager {
+	addWorkspacePath(workspacePath: string): Promise<WorkspaceInfo>;
+	switchWorkspace(workspacePath: string): Promise<WorkspaceInfo>;
+	subscribe(listener: (event: WorkspaceManagerEvent) => void): () => void;
+	getCurrentWorkspace(): WorkspaceInfo | undefined;
+	getWorkspace(workspacePath: string): WorkspaceInfo | undefined;
+	listWorkspaces(): WorkspaceInfo[];
+	getManifest(): WorkspaceManifest;
+}
+
+export class InMemoryWorkspaceManager implements WorkspaceManager {
+	private manifest: WorkspaceManifest;
+	private readonly listeners = new Set<
+		(event: WorkspaceManagerEvent) => void
+	>();
+
+	constructor(manifest?: WorkspaceManifest) {
+		this.manifest = WorkspaceManifestSchema.parse(
+			manifest ?? { workspaces: {} },
+		);
+	}
+
+	async addWorkspacePath(workspacePath: string): Promise<WorkspaceInfo> {
+		const info = await generateWorkspaceInfo(workspacePath);
+		this.manifest = upsertWorkspaceInfo(this.manifest, info);
+		this.emit({ type: "workspace_added", workspace: info });
+		return info;
+	}
+
+	async switchWorkspace(workspacePath: string): Promise<WorkspaceInfo> {
+		const normalizedPath = normalizeWorkspacePath(workspacePath);
+		const existing = this.manifest.workspaces[normalizedPath];
+		if (existing) {
+			this.manifest = WorkspaceManifestSchema.parse({
+				...this.manifest,
+				currentWorkspacePath: normalizedPath,
+			});
+			this.emit({ type: "workspace_switched", workspace: existing });
+			return existing;
+		}
+
+		const added = await this.addWorkspacePath(normalizedPath);
+		this.manifest = WorkspaceManifestSchema.parse({
+			...this.manifest,
+			currentWorkspacePath: added.rootPath,
+		});
+		this.emit({ type: "workspace_switched", workspace: added });
+		return added;
+	}
+
+	subscribe(listener: (event: WorkspaceManagerEvent) => void): () => void {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+
+	getCurrentWorkspace(): WorkspaceInfo | undefined {
+		const currentPath = this.manifest.currentWorkspacePath;
+		if (!currentPath) {
+			return undefined;
+		}
+		return this.manifest.workspaces[currentPath];
+	}
+
+	getWorkspace(workspacePath: string): WorkspaceInfo | undefined {
+		const normalizedPath = normalizeWorkspacePath(workspacePath);
+		return this.manifest.workspaces[normalizedPath];
+	}
+
+	listWorkspaces(): WorkspaceInfo[] {
+		return Object.values(this.manifest.workspaces);
+	}
+
+	getManifest(): WorkspaceManifest {
+		return this.manifest;
+	}
+
+	private emit(event: WorkspaceManagerEvent): void {
+		for (const listener of this.listeners) {
+			listener(event);
+		}
+	}
+}

package/src/session/workspace-manifest.ts

@@ -0,0 +1,100 @@
+import { basename, resolve } from "node:path";
+import simpleGit from "simple-git";
+import { z } from "zod";
+import type { WorkspaceInfo } from "../types/workspace";
+
+export const WorkspaceInfoSchema = z.object({
+	rootPath: z.string().min(1),
+	hint: z.string().min(1).optional(),
+	associatedRemoteUrls: z.array(z.string().min(1)).optional(),
+	latestGitCommitHash: z.string().min(1).optional(),
+	latestGitBranchName: z.string().min(1).optional(),
+});
+
+export const WorkspaceManifestSchema = z.object({
+	currentWorkspacePath: z.string().min(1).optional(),
+	workspaces: z.record(z.string().min(1), WorkspaceInfoSchema),
+});
+
+export type WorkspaceManifest = z.infer<typeof WorkspaceManifestSchema>;
+
+export function emptyWorkspaceManifest(): WorkspaceManifest {
+	return { workspaces: {} };
+}
+
+export function normalizeWorkspacePath(workspacePath: string): string {
+	return resolve(workspacePath);
+}
+
+export async function generateWorkspaceInfo(
+	workspacePath: string,
+): Promise<WorkspaceInfo> {
+	const rootPath = normalizeWorkspacePath(workspacePath);
+	const info: WorkspaceInfo = {
+		rootPath,
+		hint: basename(rootPath),
+	};
+
+	try {
+		const git = simpleGit({ baseDir: rootPath });
+		const isRepo = await git.checkIsRepo();
+		if (!isRepo) {
+			return info;
+		}
+
+		const remotes = await git.getRemotes(true);
+		if (remotes.length > 0) {
+			const associatedRemoteUrls = remotes.map((remote) => {
+				const remoteUrl = remote.refs.fetch || remote.refs.push;
+				return `${remote.name}: ${remoteUrl}`;
+			});
+			info.associatedRemoteUrls = associatedRemoteUrls;
+		}
+
+		const latestGitCommitHash = (await git.revparse(["HEAD"])).trim();
+		if (latestGitCommitHash.length > 0) {
+			info.latestGitCommitHash = latestGitCommitHash;
+		}
+
+		const latestGitBranchName = (await git.branch()).current.trim();
+		if (latestGitBranchName.length > 0) {
+			info.latestGitBranchName = latestGitBranchName;
+		}
+	} catch {
+		// Non-git workspaces keep only path + hint.
+	}
+
+	return info;
+}
+
+export function upsertWorkspaceInfo(
+	manifest: WorkspaceManifest,
+	info: WorkspaceInfo,
+): WorkspaceManifest {
+	const nextManifest: WorkspaceManifest = {
+		...manifest,
+		workspaces: {
+			...manifest.workspaces,
+			[info.rootPath]: info,
+		},
+	};
+	if (!nextManifest.currentWorkspacePath) {
+		nextManifest.currentWorkspacePath = info.rootPath;
+	}
+	return WorkspaceManifestSchema.parse(nextManifest);
+}
+
+export async function buildWorkspaceMetadata(cwd: string): Promise<string> {
+	const workspaceInfo = await generateWorkspaceInfo(cwd);
+	const workspaceConfig = {
+		workspaces: {
+			[workspaceInfo.rootPath]: {
+				hint: workspaceInfo.hint,
+				associatedRemoteUrls: workspaceInfo.associatedRemoteUrls,
+				latestGitCommitHash: workspaceInfo.latestGitCommitHash,
+				latestGitBranchName: workspaceInfo.latestGitBranchName,
+			},
+		},
+	};
+	return `# Workspace Configuration\n${JSON.stringify(workspaceConfig, null, 2)}`;
+}

package/src/storage/artifact-store.ts

@@ -0,0 +1 @@
+export type { ArtifactStore } from "../types/storage";

package/src/storage/file-team-store.ts

@@ -0,0 +1,257 @@
+import {
+	appendFileSync,
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	renameSync,
+	writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import type {
+	TeamEvent,
+	TeamRuntimeState,
+	TeamTeammateSpec,
+} from "@clinebot/agents";
+import { resolveTeamDataDir } from "@clinebot/shared/storage";
+import type { TeamStore } from "../types/storage";
+
+function nowIso(): string {
+	return new Date().toISOString();
+}
+
+function sanitizeTeamName(name: string): string {
+	return name
+		.toLowerCase()
+		.replace(/[^a-z0-9._-]+/g, "-")
+		.replace(/^-+|-+$/g, "");
+}
+
+function reviveTeamRuntimeStateDates(
+	state: TeamRuntimeState,
+): TeamRuntimeState {
+	return {
+		...state,
+		tasks: state.tasks.map((task) => ({
+			...task,
+			createdAt: new Date(task.createdAt),
+			updatedAt: new Date(task.updatedAt),
+		})),
+		mailbox: state.mailbox.map((message) => ({
+			...message,
+			sentAt: new Date(message.sentAt),
+			readAt: message.readAt ? new Date(message.readAt) : undefined,
+		})),
+		missionLog: state.missionLog.map((entry) => ({
+			...entry,
+			ts: new Date(entry.ts),
+		})),
+		runs: (state.runs ?? []).map((run) => ({
+			...run,
+			startedAt: new Date(run.startedAt),
+			endedAt: run.endedAt ? new Date(run.endedAt) : undefined,
+			nextAttemptAt: run.nextAttemptAt
+				? new Date(run.nextAttemptAt)
+				: undefined,
+			heartbeatAt: run.heartbeatAt ? new Date(run.heartbeatAt) : undefined,
+		})),
+		outcomes: (state.outcomes ?? []).map((outcome) => ({
+			...outcome,
+			createdAt: new Date(outcome.createdAt),
+			finalizedAt: outcome.finalizedAt
+				? new Date(outcome.finalizedAt)
+				: undefined,
+		})),
+		outcomeFragments: (state.outcomeFragments ?? []).map((fragment) => ({
+			...fragment,
+			createdAt: new Date(fragment.createdAt),
+			reviewedAt: fragment.reviewedAt
+				? new Date(fragment.reviewedAt)
+				: undefined,
+		})),
+	};
+}
+
+interface PersistedTeamEnvelope {
+	version: 1;
+	updatedAt: string;
+	teamState: TeamRuntimeState;
+	teammates: TeamTeammateSpec[];
+}
+
+export interface FileTeamStoreOptions {
+	teamDir?: string;
+}
+
+export interface TeamRuntimeLoadResult {
+	state?: TeamRuntimeState;
+	teammates: TeamTeammateSpec[];
+	interruptedRunIds: string[];
+}
+
+export class FileTeamStore implements TeamStore {
+	private readonly teamDirPath: string;
+
+	constructor(options: FileTeamStoreOptions = {}) {
+		this.teamDirPath = options.teamDir ?? resolveTeamDataDir();
+	}
+
+	init(): void {
+		this.ensureTeamDir();
+	}
+
+	listTeamNames(): string[] {
+		if (!existsSync(this.teamDirPath)) {
+			return [];
+		}
+		return readdirSync(this.teamDirPath, { withFileTypes: true })
+			.filter((entry) => entry.isDirectory())
+			.filter((entry) => existsSync(this.statePath(entry.name)))
+			.map((entry) => entry.name)
+			.sort();
+	}
+
+	readState(teamName: string): TeamRuntimeState | undefined {
+		const envelope = this.readEnvelope(teamName);
+		return envelope?.teamState
+			? reviveTeamRuntimeStateDates(envelope.teamState)
+			: undefined;
+	}
+
+	readHistory(teamName: string, limit = 200): unknown[] {
+		const historyPath = this.historyPath(teamName);
+		if (!existsSync(historyPath)) {
+			return [];
+		}
+		return readFileSync(historyPath, "utf8")
+			.split("\n")
+			.map((line) => line.trim())
+			.filter(Boolean)
+			.map((line) => {
+				try {
+					return JSON.parse(line) as unknown;
+				} catch {
+					return undefined;
+				}
+			})
+			.filter((item): item is unknown => item !== undefined)
+			.reverse()
+			.slice(0, limit);
+	}
+
+	loadRuntime(teamName: string): TeamRuntimeLoadResult {
+		const envelope = this.readEnvelope(teamName);
+		const interruptedRunIds = this.markInProgressRunsInterrupted(
+			teamName,
+			"runtime_recovered",
+		);
+		return {
+			state: envelope?.teamState
+				? reviveTeamRuntimeStateDates(envelope.teamState)
+				: undefined,
+			teammates: envelope?.teammates ?? [],
+			interruptedRunIds,
+		};
+	}
+
+	handleTeamEvent(teamName: string, event: TeamEvent): void {
+		this.ensureTeamSubdir(teamName);
+		appendFileSync(
+			this.historyPath(teamName),
+			`${JSON.stringify({ ts: nowIso(), eventType: event.type, payload: event })}\n`,
+			"utf8",
+		);
+	}
+
+	persistRuntime(
+		teamName: string,
+		state: TeamRuntimeState,
+		teammates: TeamTeammateSpec[],
+	): void {
+		this.ensureTeamSubdir(teamName);
+		const envelope: PersistedTeamEnvelope = {
+			version: 1,
+			updatedAt: nowIso(),
+			teamState: state,
+			teammates,
+		};
+		const path = this.statePath(teamName);
+		const tempPath = `${path}.tmp`;
+		writeFileSync(tempPath, `${JSON.stringify(envelope, null, 2)}\n`, "utf8");
+		renameSync(tempPath, path);
+	}
+
+	markInProgressRunsInterrupted(teamName: string, reason: string): string[] {
+		const envelope = this.readEnvelope(teamName);
+		if (!envelope?.teamState?.runs?.length) {
+			return [];
+		}
+		const interrupted = envelope.teamState.runs
+			.filter((run) => run.status === "queued" || run.status === "running")
+			.map((run) => run.id);
+		if (interrupted.length === 0) {
+			return [];
+		}
+		const endedAt = new Date();
+		envelope.teamState = {
+			...envelope.teamState,
+			runs: envelope.teamState.runs.map((run) =>
+				run.status === "queued" || run.status === "running"
+					? {
+							...run,
+							status: "interrupted",
+							error: reason,
+							endedAt,
+						}
+					: run,
+			),
+		};
+		this.persistRuntime(teamName, envelope.teamState, envelope.teammates);
+		return interrupted;
+	}
+
+	private ensureTeamDir(): string {
+		if (!existsSync(this.teamDirPath)) {
+			mkdirSync(this.teamDirPath, { recursive: true });
+		}
+		return this.teamDirPath;
+	}
+
+	private ensureTeamSubdir(teamName: string): string {
+		const path = join(this.ensureTeamDir(), sanitizeTeamName(teamName));
+		if (!existsSync(path)) {
+			mkdirSync(path, { recursive: true });
+		}
+		return path;
+	}
+
+	private statePath(teamName: string): string {
+		return join(this.ensureTeamDir(), sanitizeTeamName(teamName), "state.json");
+	}
+
+	private historyPath(teamName: string): string {
+		return join(
+			this.ensureTeamDir(),
+			sanitizeTeamName(teamName),
+			"task-history.jsonl",
+		);
+	}
+
+	private readEnvelope(teamName: string): PersistedTeamEnvelope | undefined {
+		const path = this.statePath(teamName);
+		if (!existsSync(path)) {
+			return undefined;
+		}
+		try {
+			const parsed = JSON.parse(
+				readFileSync(path, "utf8"),
+			) as PersistedTeamEnvelope;
+			if (parsed?.version === 1 && parsed.teamState) {
+				return parsed;
+			}
+		} catch {
+			// Ignore invalid persistence and fall back to undefined.
+		}
+		return undefined;
+	}
+}

package/src/storage/index.ts

@@ -0,0 +1,11 @@
+export type { ArtifactStore } from "./artifact-store";
+export {
+	type MigrateLegacyProviderSettingsOptions,
+	type MigrateLegacyProviderSettingsResult,
+	migrateLegacyProviderSettings,
+} from "./provider-settings-legacy-migration";
+export { ProviderSettingsManager } from "./provider-settings-manager";
+export type { SessionStore } from "./session-store";
+export { SqliteSessionStore } from "./sqlite-session-store";
+export type { TeamStore } from "./team-store";
+export { SqliteTeamStore, type SqliteTeamStoreOptions } from "./team-store";