@clinebot/core 0.0.34 → 0.0.36

package/src/session/session-service.ts

@@ -1,395 +1,32 @@
-import {
-	appendFileSync,
-	existsSync,
-	mkdirSync,
-	readFileSync,
-	renameSync,
-	unlinkSync,
-	writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import type { TeamTeammateSpec } from "@clinebot/shared";
-import { resolveTeamDataDir } from "@clinebot/shared/storage";
-import type { SqliteSessionStore } from "../storage/sqlite-session-store";
-import type { AgentTeamsRuntime, TeamEvent } from "../team";
-import type { SessionSource, SessionStatus } from "../types/common";
+import { existsSync, mkdirSync } from "node:fs";
+import { resolveSessionDataDir } from "@clinebot/shared/storage";
+import { nowIso } from "../services/session-artifacts";
+import type { SqliteSessionStore } from "../services/storage/sqlite-session-store";
+import type { SessionMessagesArtifactUploader } from "../types/session";
 import type {
 	PersistedSessionUpdateInput,
 	SessionPersistenceAdapter,
 } from "./persistence-service";
 import { UnifiedSessionPersistenceService } from "./persistence-service";
-import { nowIso } from "./session-artifacts";
-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;
-	transcriptPath: string;
-	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>;
-	transcriptPath: string;
-	hookPath: string;
-	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;
-	transcriptPath: string;
-	hookPath: string;
-	messagesPath: string;
-	manifest: SessionManifest;
-}
-
-export interface UpsertSubagentInput {
-	agentId: string;
-	parentAgentId: string;
-	conversationId: string;
-	prompt?: string;
-	rootSessionId?: string;
-}
-
-// ── SQLite helpers ───────────────────────────────────────────────────
-
-/** SELECT clause that aliases snake_case columns to camelCase SessionRow keys. */
-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,
-	transcript_path AS transcriptPath,
-	hook_path       AS hookPath,
-	messages_path   AS messagesPath,
-	updated_at      AS updatedAt`;
-
-/**
- * Patch a raw SQLite result into a proper SessionRow.
- * SQLite returns 0/1 for booleans and a JSON string for metadata —
- * this converts them in-place to avoid allocating a second object.
- */
-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;
-}
-
-function stringifyMetadata(
-	metadata: Record<string, unknown> | null | undefined,
-): string | null {
-	if (!metadata || Object.keys(metadata).length === 0) return null;
-	return JSON.stringify(metadata);
-}
-
-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,
-		})),
-	};
-}
-
-function sanitizeTeamName(name: string): string {
-	return name
-		.toLowerCase()
-		.replace(/[^a-z0-9._-]+/g, "-")
-		.replace(/^-+|-+$/g, "");
-}
-
-interface PersistedTeamEnvelope {
-	version: 1;
-	updatedAt: string;
-	teamState: TeamRuntimeState;
-	teammates: TeamTeammateSpec[];
-}
-
-type TeamRuntimeState = ReturnType<AgentTeamsRuntime["exportState"]>;
-
-export interface FileTeamPersistenceStoreOptions {
-	teamName: string;
-	baseDir?: string;
-}
-
-export class FileTeamPersistenceStore {
-	private readonly dirPath: string;
-	private readonly statePath: string;
-	private readonly taskHistoryPath: string;
-	private readonly teammateSpecs: Map<string, TeamTeammateSpec> = new Map();
-
-	constructor(options: FileTeamPersistenceStoreOptions) {
-		const safeTeamName = sanitizeTeamName(options.teamName);
-		const baseDir = options.baseDir?.trim() || resolveTeamDataDir();
-		this.dirPath = join(baseDir, safeTeamName);
-		this.statePath = join(this.dirPath, "state.json");
-		this.taskHistoryPath = join(this.dirPath, "task-history.jsonl");
-	}
-
-	loadState(): TeamRuntimeState | undefined {
-		if (!existsSync(this.statePath)) {
-			return undefined;
-		}
-		try {
-			const raw = readFileSync(this.statePath, "utf8");
-			const parsed = JSON.parse(raw) as PersistedTeamEnvelope;
-			if (parsed.version !== 1 || !parsed.teamState) {
-				return undefined;
-			}
-			for (const spec of parsed.teammates ?? []) {
-				this.teammateSpecs.set(spec.agentId, spec);
-			}
-			return reviveTeamStateDates(parsed.teamState);
-		} catch {
-			return undefined;
-		}
-	}
-
-	getTeammateSpecs(): TeamTeammateSpec[] {
-		return Array.from(this.teammateSpecs.values());
-	}
-
-	upsertTeammateSpec(spec: TeamTeammateSpec): void {
-		this.teammateSpecs.set(spec.agentId, spec);
-	}
-
-	removeTeammateSpec(agentId: string): void {
-		this.teammateSpecs.delete(agentId);
-	}
-
-	persist(runtime: AgentTeamsRuntime): void {
-		if (!this.hasPersistableState(runtime)) {
-			this.clearPersistedState();
-			return;
-		}
-		this.ensureDir();
-		const envelope: PersistedTeamEnvelope = {
-			version: 1,
-			updatedAt: new Date().toISOString(),
-			teamState: runtime.exportState(),
-			teammates: Array.from(this.teammateSpecs.values()),
-		};
-		const tmpPath = `${this.statePath}.tmp`;
-		writeFileSync(tmpPath, `${JSON.stringify(envelope, null, 2)}\n`, "utf8");
-		renameSync(tmpPath, this.statePath);
-	}
-
-	appendTaskHistory(event: TeamEvent): void {
-		let task: Record<string, unknown> = {};
-		switch (event.type) {
-			case "team_task_updated":
-				task = event.task as unknown as Record<string, unknown>;
-				break;
-			case "team_message":
-				task = {
-					agentId: event.message.fromAgentId,
-					toAgentId: event.message.toAgentId,
-					subject: event.message.subject,
-					taskId: event.message.taskId,
-				};
-				break;
-			case "team_mission_log":
-				task = {
-					agentId: event.entry.agentId,
-					kind: event.entry.kind,
-					summary: event.entry.summary,
-					taskId: event.entry.taskId,
-				};
-				break;
-			case "teammate_spawned":
-			case "teammate_shutdown":
-			case "task_start":
-				task = {
-					agentId: event.agentId,
-					message: "message" in event ? event.message : undefined,
-				};
-				break;
-			case "task_end":
-				task = {
-					agentId: event.agentId,
-					finishReason: event.result?.finishReason,
-					error: event.error?.message,
-				};
-				break;
-			case "agent_event":
-				task = {
-					agentId: event.agentId,
-					eventType: event.event.type,
-				};
-				break;
-		}
-		this.ensureDir();
-		appendFileSync(
-			this.taskHistoryPath,
-			`${JSON.stringify({
-				ts: new Date().toISOString(),
-				type: event.type,
-				task,
-			})}\n`,
-			"utf8",
-		);
-	}
-
-	private ensureDir(): void {
-		if (!existsSync(this.dirPath)) {
-			mkdirSync(this.dirPath, { recursive: true });
-		}
-	}
-
-	private hasPersistableState(runtime: AgentTeamsRuntime): boolean {
-		const state = runtime.exportState();
-		if (this.teammateSpecs.size > 0) {
-			return true;
-		}
-		if (state.members.some((member) => member.role === "teammate")) {
-			return true;
-		}
-		return (
-			state.tasks.length > 0 ||
-			state.mailbox.length > 0 ||
-			state.missionLog.length > 0
-		);
-	}
-
-	private clearPersistedState(): void {
-		if (existsSync(this.statePath)) {
-			unlinkSync(this.statePath);
-		}
-	}
-}
+import {
+	type CreateRootSessionInput,
+	patchSqliteRow,
+	SESSION_SELECT_COLUMNS,
+	type SessionRow,
+	stringifyMetadata,
+} from "./session-row";
 
 class LocalSessionPersistenceAdapter implements SessionPersistenceAdapter {
-	constructor(private readonly store: SqliteSessionStore) {}
+	constructor(
+		private readonly store: SqliteSessionStore,
+		private readonly sessionsDirPath: string = resolveSessionDataDir(),
+	) {}
 
 	ensureSessionsDir(): string {
-		return this.store.ensureSessionsDir();
+		if (!existsSync(this.sessionsDirPath)) {
+			mkdirSync(this.sessionsDirPath, { recursive: true });
+		}
+		return this.sessionsDirPath;
 	}
 
 	async upsertSession(row: SessionRow): Promise<void> {
@@ -425,8 +62,8 @@ class LocalSessionPersistenceAdapter implements SessionPersistenceAdapter {
 				row.isSubagent ? 1 : 0,
 				row.prompt ?? null,
 				stringifyMetadata(row.metadata),
-				row.transcriptPath,
-				row.hookPath,
+				"",
+				row.hookPath ?? "",
 				row.messagesPath ?? null,
 				row.updatedAt,
 			],
@@ -623,8 +260,17 @@ class LocalSessionPersistenceAdapter implements SessionPersistenceAdapter {
 }
 
 export class CoreSessionService extends UnifiedSessionPersistenceService {
-	constructor(private readonly store: SqliteSessionStore) {
-		super(new LocalSessionPersistenceAdapter(store));
+	constructor(
+		private readonly store: SqliteSessionStore,
+		options: {
+			sessionArtifactsDir?: string;
+			messagesArtifactUploader?: SessionMessagesArtifactUploader;
+		} = {},
+	) {
+		super(
+			new LocalSessionPersistenceAdapter(store, options.sessionArtifactsDir),
+			options,
+		);
 	}
 
 	createRootSession(input: CreateRootSessionInput): void {
@@ -660,11 +306,19 @@ export class CoreSessionService extends UnifiedSessionPersistenceService {
 				0,
 				input.prompt ?? null,
 				input.metadata ? JSON.stringify(input.metadata) : null,
-				input.transcriptPath,
-				input.hookPath,
+				"",
+				"",
 				input.messagesPath,
 				nowIso(),
 			],
 		);
 	}
 }
+
+export type {
+	CreateRootSessionInput,
+	CreateRootSessionWithArtifactsInput,
+	RootSessionArtifacts,
+	SessionRow,
+	UpsertSubagentInput,
+} from "./session-row";

package/src/session/session-team-coordination.ts

@@ -1,11 +1,15 @@
-import { type AgentResult, formatUserInputBlock } from "@clinebot/shared";
-import type { TeamEvent } from "../team";
+import {
+	type AgentMode,
+	type AgentResult,
+	formatUserInputBlock,
+} from "@clinebot/shared";
+import type { TeamEvent } from "../extensions/tools/team";
 import {
 	buildTeamProgressSummary,
 	toTeamProgressLifecycleEvent,
-} from "../team";
+} from "../extensions/tools/team";
 import type { CoreSessionEvent } from "../types/events";
-import type { ActiveSession, TeamRunUpdate } from "./utils/types";
+import type { ActiveSession, TeamRunUpdate } from "../types/session";
 
 export function trackTeamRunState(
 	session: ActiveSession,
@@ -137,7 +141,7 @@ export function emitTeamProgress(
 	emit: (event: CoreSessionEvent) => void,
 ): void {
 	if (!session.runtime.teamRuntime) return;
-	const teamName = session.config.teamName?.trim() || "team";
+	const teamName = session.runtime.teamRuntime.getTeamName();
 	emit({
 		type: "team_progress",
 		payload: {
@@ -227,7 +231,10 @@ export function buildTeamRunContinuationPrompt(
 
 export function formatModePrompt(
 	prompt: string,
-	mode: "act" | "plan" | undefined,
+	mode: AgentMode | undefined,
 ): string {
-	return formatUserInputBlock(prompt, mode === "plan" ? "plan" : "act");
+	return formatUserInputBlock(
+		prompt,
+		mode === "plan" ? "plan" : mode === "yolo" ? "yolo" : "act",
+	);
 }