@clinebot/core 0.0.22 → 0.0.23

package/src/runtime/workflows.test.ts

@@ -0,0 +1,119 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { createUserInstructionConfigWatcher } from "../agents";
+import {
+	listAvailableWorkflowsFromWatcher,
+	resolveWorkflowSlashCommandFromWatcher,
+} from "./workflows";
+
+describe("runtime workflows helpers", () => {
+	const tempRoots: string[] = [];
+
+	afterEach(async () => {
+		await Promise.all(
+			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
+		);
+		tempRoots.length = 0;
+	});
+
+	it("lists only enabled workflows from watcher snapshots", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-runtime-workflows-"));
+		tempRoots.push(tempRoot);
+		const workflowsDir = join(tempRoot, "workflows");
+		await mkdir(workflowsDir, { recursive: true });
+		await writeFile(
+			join(workflowsDir, "enabled.md"),
+			`---
+name: enabled-workflow
+---
+Run enabled workflow.`,
+		);
+		await writeFile(
+			join(workflowsDir, "disabled.md"),
+			`---
+name: disabled-workflow
+disabled: true
+---
+Run disabled workflow.`,
+		);
+
+		const watcher = createUserInstructionConfigWatcher({
+			skills: { directories: [] },
+			rules: { directories: [] },
+			workflows: { directories: [workflowsDir] },
+		});
+
+		try {
+			await watcher.start();
+			expect(listAvailableWorkflowsFromWatcher(watcher)).toEqual([
+				{
+					id: "enabled-workflow",
+					name: "enabled-workflow",
+					instructions: "Run enabled workflow.",
+				},
+			]);
+		} finally {
+			watcher.stop();
+		}
+	});
+
+	it("expands leading slash commands and preserves trailing user text", async () => {
+		const tempRoot = await mkdtemp(join(tmpdir(), "core-runtime-workflows-"));
+		tempRoots.push(tempRoot);
+		const workflowsDir = join(tempRoot, "workflows");
+		await mkdir(workflowsDir, { recursive: true });
+		await writeFile(
+			join(workflowsDir, "release.md"),
+			`---
+name: release
+---
+Run the release workflow.`,
+		);
+		await writeFile(
+			join(workflowsDir, "disabled.md"),
+			`---
+name: disabled
+disabled: true
+---
+Do not run this workflow.`,
+		);
+
+		const watcher = createUserInstructionConfigWatcher({
+			skills: { directories: [] },
+			rules: { directories: [] },
+			workflows: { directories: [workflowsDir] },
+		});
+
+		try {
+			await watcher.start();
+			expect(resolveWorkflowSlashCommandFromWatcher("/release", watcher)).toBe(
+				"Run the release workflow.",
+			);
+			expect(
+				resolveWorkflowSlashCommandFromWatcher("  /release  ", watcher),
+			).toBe("  /release  ");
+			expect(resolveWorkflowSlashCommandFromWatcher("/disabled", watcher)).toBe(
+				"/disabled",
+			);
+			expect(resolveWorkflowSlashCommandFromWatcher("/missing", watcher)).toBe(
+				"/missing",
+			);
+			expect(
+				resolveWorkflowSlashCommandFromWatcher("/release now", watcher),
+			).toBe("Run the release workflow. now");
+			expect(
+				resolveWorkflowSlashCommandFromWatcher(
+					"/release   use javascript",
+					watcher,
+				),
+			).toBe("Run the release workflow.   use javascript");
+			expect(
+				resolveWorkflowSlashCommandFromWatcher("please run /release", watcher),
+			).toBe("please run /release");
+		} finally {
+			watcher.stop();
+		}
+	});
+});

package/src/runtime/workflows.ts

@@ -0,0 +1,45 @@
+import type { UserInstructionConfigWatcher } from "../agents";
+import {
+	listAvailableRuntimeCommandsForKindFromWatcher,
+	resolveRuntimeSlashCommandFromWatcher,
+} from "./commands";
+
+export type AvailableWorkflow = {
+	id: string;
+	name: string;
+	instructions: string;
+};
+
+function matchesLeadingSlashCommand(input: string, name: string): boolean {
+	const match = input.match(/^\/(\S+)/);
+	return match?.[1] === name;
+}
+
+export function listAvailableWorkflowsFromWatcher(
+	watcher: UserInstructionConfigWatcher,
+): AvailableWorkflow[] {
+	return listAvailableRuntimeCommandsForKindFromWatcher(
+		watcher,
+		"workflow",
+	).map((workflow) => ({
+		id: workflow.id,
+		name: workflow.name,
+		instructions: workflow.instructions,
+	}));
+}
+
+/**
+ * Expands a leading slash command (e.g. "/release") to workflow instructions.
+ * If the input starts with "/<workflow-name>", that prefix is replaced and the
+ * remaining input is preserved unchanged.
+ */
+export function resolveWorkflowSlashCommandFromWatcher(
+	input: string,
+	watcher: UserInstructionConfigWatcher,
+): string {
+	const resolved = resolveRuntimeSlashCommandFromWatcher(input, watcher);
+	const matched = listAvailableWorkflowsFromWatcher(watcher).some((workflow) =>
+		matchesLeadingSlashCommand(input, workflow.name),
+	);
+	return matched ? resolved : input;
+}

package/src/session/default-session-manager.e2e.test.ts

@@ -0,0 +1,384 @@
+import {
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { AgentResult } from "@clinebot/agents";
+import type * as LlmsProviders from "@clinebot/llms/providers";
+import { setClineDir, setHomeDir } from "@clinebot/shared/storage";
+import { nanoid } from "nanoid";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { SessionSource, SessionStatus } from "../types/common";
+import { DefaultSessionManager } from "./default-session-manager";
+import type { SessionManifest } from "./session-manifest";
+import type { RootSessionArtifacts, SessionRow } from "./session-service";
+
+function nowIso(): string {
+	return new Date().toISOString();
+}
+
+function createResult(overrides: Partial<AgentResult> = {}): AgentResult {
+	return {
+		text: "ok",
+		iterations: 1,
+		finishReason: "completed",
+		usage: {
+			inputTokens: 1,
+			outputTokens: 2,
+			totalCost: 0,
+		},
+		messages: [],
+		toolCalls: [],
+		durationMs: 1,
+		model: {
+			id: "mock-model",
+			provider: "mock-provider",
+		},
+		startedAt: new Date("2026-01-01T00:00:00.000Z"),
+		endedAt: new Date("2026-01-01T00:00:01.000Z"),
+		...overrides,
+	};
+}
+
+class LocalFileSessionService {
+	private readonly rows = new Map<string, SessionRow>();
+
+	constructor(private readonly sessionsDir: string) {}
+
+	ensureSessionsDir(): string {
+		mkdirSync(this.sessionsDir, { recursive: true });
+		return this.sessionsDir;
+	}
+
+	createRootSessionWithArtifacts(input: {
+		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;
+		startedAt?: string;
+	}): RootSessionArtifacts {
+		const startedAt = input.startedAt ?? nowIso();
+		const sessionId = input.sessionId.trim() || `${Date.now()}_${nanoid(5)}`;
+		const sessionPath = join(this.sessionsDir, sessionId);
+		mkdirSync(sessionPath, { recursive: true });
+
+		const manifestPath = join(sessionPath, `${sessionId}.json`);
+		const transcriptPath = join(sessionPath, `${sessionId}.log`);
+		const hookPath = join(sessionPath, `${sessionId}.hooks.jsonl`);
+		const messagesPath = join(sessionPath, `${sessionId}.messages.json`);
+		const prompt = input.prompt?.trim() || undefined;
+		const manifest: SessionManifest = {
+			version: 1,
+			session_id: sessionId,
+			source: input.source,
+			pid: input.pid,
+			started_at: startedAt,
+			status: "running",
+			interactive: input.interactive,
+			provider: input.provider,
+			model: input.model,
+			cwd: input.cwd,
+			workspace_root: input.workspaceRoot,
+			team_name: input.teamName,
+			enable_tools: input.enableTools,
+			enable_spawn: input.enableSpawn,
+			enable_teams: input.enableTeams,
+			prompt,
+			messages_path: messagesPath,
+		};
+		writeFileSync(
+			manifestPath,
+			`${JSON.stringify(manifest, null, 2)}\n`,
+			"utf8",
+		);
+		writeFileSync(transcriptPath, "", "utf8");
+		writeFileSync(hookPath, "", "utf8");
+		writeFileSync(
+			messagesPath,
+			`${JSON.stringify({ version: 1, updated_at: startedAt, messages: [] }, null, 2)}\n`,
+			"utf8",
+		);
+
+		this.rows.set(sessionId, {
+			sessionId,
+			source: input.source,
+			pid: input.pid,
+			startedAt,
+			endedAt: null,
+			exitCode: null,
+			status: "running",
+			statusLock: 0,
+			interactive: input.interactive,
+			provider: input.provider,
+			model: input.model,
+			cwd: input.cwd,
+			workspaceRoot: input.workspaceRoot,
+			teamName: input.teamName ?? null,
+			enableTools: input.enableTools,
+			enableSpawn: input.enableSpawn,
+			enableTeams: input.enableTeams,
+			parentSessionId: null,
+			parentAgentId: null,
+			agentId: null,
+			conversationId: null,
+			isSubagent: false,
+			prompt: prompt ?? null,
+			transcriptPath,
+			hookPath,
+			messagesPath,
+			updatedAt: startedAt,
+		});
+
+		return {
+			manifestPath,
+			transcriptPath,
+			hookPath,
+			messagesPath,
+			manifest,
+		};
+	}
+
+	persistSessionMessages(
+		sessionId: string,
+		messages: LlmsProviders.Message[],
+		systemPrompt?: string,
+	): void {
+		const row = this.rows.get(sessionId);
+		if (!row?.messagesPath) {
+			throw new Error(`session not found: ${sessionId}`);
+		}
+		const payload: {
+			version: number;
+			updated_at: string;
+			systemPrompt?: string;
+			messages: LlmsProviders.Message[];
+		} = { version: 1, updated_at: nowIso(), messages };
+		if (systemPrompt !== undefined && systemPrompt !== "") {
+			payload.systemPrompt = systemPrompt;
+		}
+		writeFileSync(
+			row.messagesPath,
+			`${JSON.stringify(payload, null, 2)}\n`,
+			"utf8",
+		);
+	}
+
+	updateSessionStatus(
+		sessionId: string,
+		status: SessionStatus,
+		exitCode?: number | null,
+	): { updated: boolean; endedAt?: string } {
+		const row = this.rows.get(sessionId);
+		if (!row) {
+			return { updated: false };
+		}
+		const endedAt = nowIso();
+		row.status = status;
+		row.endedAt = endedAt;
+		row.exitCode = typeof exitCode === "number" ? exitCode : null;
+		row.updatedAt = endedAt;
+		row.statusLock = row.statusLock + 1;
+		return { updated: true, endedAt };
+	}
+
+	writeSessionManifest(manifestPath: string, manifest: SessionManifest): void {
+		writeFileSync(
+			manifestPath,
+			`${JSON.stringify(manifest, null, 2)}\n`,
+			"utf8",
+		);
+	}
+
+	listSessions(limit = 200): SessionRow[] {
+		return Array.from(this.rows.values()).slice(0, limit);
+	}
+
+	deleteSession(sessionId: string): { deleted: boolean } {
+		const row = this.rows.get(sessionId);
+		if (!row) {
+			return { deleted: false };
+		}
+		this.rows.delete(sessionId);
+		unlinkSync(row.transcriptPath);
+		unlinkSync(row.hookPath);
+		unlinkSync(row.messagesPath ?? "");
+		unlinkSync(join(this.sessionsDir, sessionId, `${sessionId}.json`));
+		return { deleted: true };
+	}
+}
+
+describe("DefaultSessionManager e2e", () => {
+	const envSnapshot = {
+		HOME: process.env.HOME,
+		CLINE_DIR: process.env.CLINE_DIR,
+	};
+	const tempDirs: string[] = [];
+	let isolatedHomeDir = "";
+
+	beforeEach(() => {
+		isolatedHomeDir = mkdtempSync(join(tmpdir(), "core-session-home-"));
+		process.env.HOME = isolatedHomeDir;
+		process.env.CLINE_DIR = join(isolatedHomeDir, ".cline");
+		setHomeDir(isolatedHomeDir);
+		setClineDir(process.env.CLINE_DIR);
+	});
+
+	afterEach(() => {
+		process.env.HOME = envSnapshot.HOME;
+		process.env.CLINE_DIR = envSnapshot.CLINE_DIR;
+		setHomeDir(envSnapshot.HOME ?? "~");
+		setClineDir(envSnapshot.CLINE_DIR ?? join("~", ".cline"));
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+		rmSync(isolatedHomeDir, { recursive: true, force: true });
+	});
+
+	it("runs an interactive lifecycle with real artifact files", async () => {
+		const sessionsDir = mkdtempSync(join(tmpdir(), "core-e2e-sessions-"));
+		tempDirs.push(sessionsDir);
+
+		const sessionService = new LocalFileSessionService(sessionsDir);
+		const runtimeShutdown = vi.fn();
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: runtimeShutdown,
+			}),
+		};
+
+		let messages: LlmsProviders.Message[] = [];
+		let turn = 0;
+		const run = vi.fn(async (prompt: string) => {
+			turn += 1;
+			messages = [
+				...messages,
+				{
+					role: "user",
+					content: [{ type: "text", text: prompt }],
+				},
+				{
+					role: "assistant",
+					content: [{ type: "text", text: `reply:${turn}:${prompt}` }],
+				},
+			] as LlmsProviders.Message[];
+			return createResult({
+				text: `reply:${turn}:${prompt}`,
+				messages: [...messages],
+			});
+		});
+		const continueFn = vi.fn(async (prompt: string) => {
+			turn += 1;
+			messages = [
+				...messages,
+				{
+					role: "user",
+					content: [{ type: "text", text: prompt }],
+				},
+				{
+					role: "assistant",
+					content: [{ type: "text", text: `reply:${turn}:${prompt}` }],
+				},
+			] as LlmsProviders.Message[];
+			return createResult({
+				text: `reply:${turn}:${prompt}`,
+				messages: [...messages],
+			});
+		});
+		const agentShutdown = vi.fn().mockResolvedValue(undefined);
+
+		const manager = new DefaultSessionManager({
+			distinctId: `test-${nanoid(5)}`,
+			sessionService: sessionService as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent: () =>
+				({
+					run,
+					continue: continueFn,
+					abort: vi.fn(),
+					restore: vi.fn((baseline: LlmsProviders.Message[]) => {
+						messages = [...baseline];
+					}),
+					updateConnection: vi.fn(),
+					shutdown: agentShutdown,
+					getMessages: vi.fn(() => [...messages]),
+					messages: [],
+				}) as never,
+		});
+
+		const started = await manager.start({
+			interactive: true,
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "test-key",
+				cwd: sessionsDir,
+				systemPrompt: "You are a test agent",
+				enableTools: false,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			},
+		});
+
+		expect(started.sessionId.length).toBeGreaterThan(0);
+		expect(existsSync(started.manifestPath)).toBe(false);
+		expect(existsSync(started.messagesPath)).toBe(false);
+
+		const first = await manager.send({
+			sessionId: started.sessionId,
+			prompt: "first prompt",
+		});
+		const second = await manager.send({
+			sessionId: started.sessionId,
+			prompt: "second prompt",
+		});
+		expect(existsSync(started.manifestPath)).toBe(true);
+		expect(existsSync(started.messagesPath)).toBe(true);
+
+		expect(first?.text).toContain("first prompt");
+		expect(second?.text).toContain("second prompt");
+		expect(run).toHaveBeenCalledTimes(1);
+		expect(continueFn).toHaveBeenCalledTimes(1);
+
+		const persistedMessages = await manager.readMessages(started.sessionId);
+		expect(persistedMessages.length).toBeGreaterThan(0);
+		expect(JSON.stringify(persistedMessages)).toContain("second prompt");
+
+		const listed = await manager.list(20);
+		expect(
+			listed.some((session) => session.sessionId === started.sessionId),
+		).toBe(true);
+
+		await manager.stop(started.sessionId);
+		const stopped = await manager.get(started.sessionId);
+		expect(stopped?.status).toBe("cancelled");
+		expect(stopped?.exitCode).toBe(0);
+		expect(agentShutdown).toHaveBeenCalledTimes(1);
+		expect(runtimeShutdown).toHaveBeenCalledTimes(1);
+		const parsedManifest = JSON.parse(
+			readFileSync(started.manifestPath, "utf8"),
+		) as SessionManifest;
+		expect(parsedManifest.status).toBe("cancelled");
+
+		const deleted = await manager.delete(started.sessionId);
+		expect(deleted).toBe(true);
+		expect(await manager.get(started.sessionId)).toBeUndefined();
+		expect(existsSync(started.manifestPath)).toBe(false);
+		expect(existsSync(started.messagesPath)).toBe(false);
+	});
+});