@clinebot/core 0.0.35 → 0.0.36

package/src/session/session-manifest-store.ts

@@ -0,0 +1,158 @@
+import {
+	appendFileSync,
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import type * as LlmsProviders from "@clinebot/llms";
+import { ensureHookLogDir } from "@clinebot/shared/storage";
+import { nowIso, SessionArtifacts } from "../services/session-artifacts";
+import {
+	buildMessagesFilePayload,
+	resolveMessagesFileContext,
+	writeEmptyMessagesFile,
+} from "../services/session-data";
+import type {
+	SessionMessagesArtifactUploader,
+	SessionPersistenceAdapter,
+	StoredMessageWithMetadata,
+} from "../types/session";
+import {
+	type SessionManifest,
+	SessionManifestSchema,
+} from "./session-manifest";
+
+export class SessionManifestStore {
+	readonly artifacts: SessionArtifacts;
+
+	constructor(
+		private readonly adapter: SessionPersistenceAdapter,
+		private readonly messagesArtifactUploader?: SessionMessagesArtifactUploader,
+	) {
+		this.artifacts = new SessionArtifacts(() => this.ensureSessionsDir());
+	}
+
+	ensureSessionsDir(): string {
+		return this.adapter.ensureSessionsDir();
+	}
+
+	initializeMessagesFile(
+		sessionId: string,
+		path: string,
+		startedAt: string,
+	): void {
+		writeEmptyMessagesFile(
+			path,
+			startedAt,
+			resolveMessagesFileContext(sessionId),
+		);
+	}
+
+	writeSessionManifest(manifestPath: string, manifest: SessionManifest): void {
+		mkdirSync(dirname(manifestPath), { recursive: true });
+		writeFileSync(
+			manifestPath,
+			`${JSON.stringify(SessionManifestSchema.parse(manifest), null, 2)}\n`,
+			"utf8",
+		);
+	}
+
+	readSessionManifest(sessionId: string): SessionManifest | undefined {
+		return this.readManifestFile(sessionId).manifest;
+	}
+
+	readManifestFile(sessionId: string): {
+		path: string;
+		manifest?: SessionManifest;
+	} {
+		const manifestPath = this.artifacts.sessionManifestPath(sessionId, false);
+		if (!existsSync(manifestPath)) {
+			return { path: manifestPath };
+		}
+		try {
+			return {
+				path: manifestPath,
+				manifest: SessionManifestSchema.parse(
+					JSON.parse(readFileSync(manifestPath, "utf8")) as SessionManifest,
+				),
+			};
+		} catch {
+			return { path: manifestPath };
+		}
+	}
+
+	async resolveArtifactPath(
+		sessionId: string,
+		kind: "messagesPath",
+		fallback: (id: string) => string,
+	): Promise<string> {
+		const row = await this.adapter.getSession(sessionId);
+		const value = row?.[kind];
+		return typeof value === "string" && value.trim().length > 0
+			? value
+			: fallback(sessionId);
+	}
+
+	async persistSessionMessages(
+		sessionId: string,
+		messages: LlmsProviders.Message[],
+		systemPrompt?: string,
+	): Promise<void> {
+		const path = await this.resolveArtifactPath(
+			sessionId,
+			"messagesPath",
+			(id) => this.artifacts.sessionMessagesPath(id),
+		);
+		const payload = buildMessagesFilePayload({
+			updatedAt: nowIso(),
+			context: resolveMessagesFileContext(sessionId),
+			messages: messages as StoredMessageWithMetadata[],
+			systemPrompt,
+		});
+		const contents = `${JSON.stringify(payload, null, 2)}\n`;
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, contents, "utf8");
+		if (!this.messagesArtifactUploader) {
+			return;
+		}
+		try {
+			const row = await this.adapter.getSession(sessionId);
+			await this.messagesArtifactUploader.uploadMessagesFile({
+				sessionId,
+				path,
+				contents,
+				row,
+			});
+		} catch (error) {
+			console.warn(
+				`Failed to upload persisted session messages for ${sessionId}`,
+				error,
+			);
+		}
+	}
+
+	appendStaleSessionHookLog(
+		detectedAt: string,
+		sessionId: string,
+		pid: number,
+		reason: string,
+		source: string,
+	): void {
+		const envPath = process.env.CLINE_HOOKS_LOG_PATH?.trim() || undefined;
+		const logPath = envPath ?? join(ensureHookLogDir(), "hooks.jsonl");
+		appendFileSync(
+			logPath,
+			`${JSON.stringify({
+				ts: detectedAt,
+				hookName: "session_shutdown",
+				reason,
+				sessionId,
+				pid,
+				source,
+			})}\n`,
+			"utf8",
+		);
+	}
+}

package/src/session/session-row.ts

@@ -0,0 +1,199 @@
+import type { TeamTeammateSpec } from "@clinebot/shared";
+import type { AgentTeamsRuntime } from "../extensions/tools/team";
+import type { SessionSource, SessionStatus } from "../types/common";
+import type { SessionManifest } from "./session-manifest";
+
+export interface SessionRow {
+	sessionId: string;
+	source: string;
+	pid: number;
+	startedAt: string;
+	endedAt?: string | null;
+	exitCode?: number | null;
+	status: SessionStatus;
+	statusLock: number;
+	interactive: boolean;
+	provider: string;
+	model: string;
+	cwd: string;
+	workspaceRoot: string;
+	teamName?: string | null;
+	enableTools: boolean;
+	enableSpawn: boolean;
+	enableTeams: boolean;
+	parentSessionId?: string | null;
+	parentAgentId?: string | null;
+	agentId?: string | null;
+	conversationId?: string | null;
+	isSubagent: boolean;
+	prompt?: string | null;
+	metadata?: Record<string, unknown> | null;
+	hookPath?: string;
+	messagesPath?: string | null;
+	updatedAt: string;
+}
+
+export interface CreateRootSessionInput {
+	sessionId: string;
+	source: SessionSource;
+	pid: number;
+	startedAt: string;
+	interactive: boolean;
+	provider: string;
+	model: string;
+	cwd: string;
+	workspaceRoot: string;
+	teamName?: string;
+	enableTools: boolean;
+	enableSpawn: boolean;
+	enableTeams: boolean;
+	prompt?: string;
+	metadata?: Record<string, unknown>;
+	messagesPath: string;
+}
+
+export interface CreateRootSessionWithArtifactsInput {
+	sessionId: string;
+	source: SessionSource;
+	pid: number;
+	interactive: boolean;
+	provider: string;
+	model: string;
+	cwd: string;
+	workspaceRoot: string;
+	teamName?: string;
+	enableTools: boolean;
+	enableSpawn: boolean;
+	enableTeams: boolean;
+	prompt?: string;
+	metadata?: Record<string, unknown>;
+	startedAt?: string;
+}
+
+export interface RootSessionArtifacts {
+	manifestPath: string;
+	messagesPath: string;
+	manifest: SessionManifest;
+}
+
+export interface UpsertSubagentInput {
+	agentId: string;
+	parentAgentId: string;
+	conversationId: string;
+	prompt?: string;
+	rootSessionId?: string;
+}
+
+/** SELECT clause that aliases snake_case columns to camelCase SessionRow keys. */
+export const SESSION_SELECT_COLUMNS = `
+	session_id    AS sessionId,
+	source,
+	pid,
+	started_at    AS startedAt,
+	ended_at      AS endedAt,
+	exit_code     AS exitCode,
+	status,
+	status_lock   AS statusLock,
+	interactive,
+	provider,
+	model,
+	cwd,
+	workspace_root AS workspaceRoot,
+	team_name      AS teamName,
+	enable_tools   AS enableTools,
+	enable_spawn   AS enableSpawn,
+	enable_teams   AS enableTeams,
+	parent_session_id AS parentSessionId,
+	parent_agent_id   AS parentAgentId,
+	agent_id       AS agentId,
+	conversation_id AS conversationId,
+	is_subagent    AS isSubagent,
+	prompt,
+	metadata_json  AS metadata,
+	hook_path       AS hookPath,
+	messages_path   AS messagesPath,
+	updated_at      AS updatedAt`;
+
+export function patchSqliteRow(raw: Record<string, unknown>): SessionRow {
+	raw.interactive = raw.interactive === 1;
+	raw.enableTools = raw.enableTools === 1;
+	raw.enableSpawn = raw.enableSpawn === 1;
+	raw.enableTeams = raw.enableTeams === 1;
+	raw.isSubagent = raw.isSubagent === 1;
+	const meta = raw.metadata;
+	if (typeof meta === "string" && meta.trim()) {
+		try {
+			const parsed = JSON.parse(meta) as unknown;
+			raw.metadata =
+				parsed && typeof parsed === "object" && !Array.isArray(parsed)
+					? parsed
+					: null;
+		} catch {
+			raw.metadata = null;
+		}
+	} else {
+		raw.metadata = null;
+	}
+	return raw as unknown as SessionRow;
+}
+
+export function stringifyMetadata(
+	metadata: Record<string, unknown> | null | undefined,
+): string | null {
+	if (!metadata || Object.keys(metadata).length === 0) return null;
+	return JSON.stringify(metadata);
+}
+
+export type TeamRuntimeState = ReturnType<AgentTeamsRuntime["exportState"]>;
+
+export interface PersistedTeamEnvelope {
+	version: 1;
+	updatedAt: string;
+	teamState: TeamRuntimeState;
+	teammates: TeamTeammateSpec[];
+}
+
+export function reviveTeamStateDates(
+	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,
+		})),
+	};
+}