@clinebot/core 0.0.22 → 0.0.23

package/src/storage/provider-settings-manager.test.ts

@@ -0,0 +1,191 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import * as LlmsModels from "@clinebot/llms/models";
+import { afterEach, describe, expect, it } from "vitest";
+import { ProviderSettingsManager } from "./provider-settings-manager";
+
+describe("ProviderSettingsManager", () => {
+	const tempDirs: string[] = [];
+
+	afterEach(() => {
+		LlmsModels.resetRegistry();
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("persists and restores provider settings", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "provider-settings.json");
+		const manager = new ProviderSettingsManager({ filePath });
+
+		manager.saveProviderSettings(
+			{
+				provider: "anthropic",
+				model: "claude-sonnet-4-6",
+				apiKey: "test-key",
+			},
+			{ setLastUsed: true },
+		);
+
+		const reloaded = new ProviderSettingsManager({ filePath });
+		expect(reloaded.getLastUsedProviderSettings()).toEqual({
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+			apiKey: "test-key",
+		});
+		expect(reloaded.getProviderConfig("anthropic")?.providerId).toBe(
+			"anthropic",
+		);
+		expect(reloaded.getProviderConfig("anthropic")?.modelId).toBe(
+			"claude-sonnet-4-6",
+		);
+		expect(reloaded.read().providers.anthropic?.tokenSource).toBe("manual");
+	});
+
+	it("migrates legacy provider settings during manager construction", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "settings", "providers.json");
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "anthropic",
+					actModeApiModelId: "claude-sonnet-4-6",
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify({ apiKey: "legacy-key" }, null, 2),
+		);
+
+		const manager = new ProviderSettingsManager({ filePath, dataDir: tempDir });
+
+		expect(manager.getLastUsedProviderSettings()).toEqual({
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+			apiKey: "legacy-key",
+		});
+		expect(manager.read().providers.anthropic?.tokenSource).toBe("migration");
+	});
+
+	it("registers migrated custom providers during manager construction", async () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "settings", "providers.json");
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "openai",
+					actModeOpenAiModelId: "gpt-oss-120b",
+					openAiBaseUrl: "https://gateway.example.invalid/v1",
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify({ openAiApiKey: "legacy-key" }, null, 2),
+		);
+
+		const manager = new ProviderSettingsManager({ filePath, dataDir: tempDir });
+		const providers = await LlmsModels.getAllProviders();
+		const openAiProvider = providers.find(
+			(provider) => provider.id === "openai",
+		);
+
+		expect(manager.getProviderSettings("openai")).toEqual({
+			provider: "openai",
+			model: "gpt-oss-120b",
+			apiKey: "legacy-key",
+			baseUrl: "https://gateway.example.invalid/v1",
+		});
+		expect(openAiProvider).toMatchObject({
+			id: "openai",
+			baseUrl: "https://gateway.example.invalid/v1",
+			defaultModelId: "gpt-oss-120b",
+		});
+	});
+
+	it("tracks provider-specific settings while preserving last-used provider", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "provider-settings.json");
+		const manager = new ProviderSettingsManager({ filePath });
+
+		manager.saveProviderSettings({
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+		});
+		manager.saveProviderSettings(
+			{
+				provider: "openai-native",
+				model: "gpt-5",
+			},
+			{ setLastUsed: false },
+		);
+
+		expect(manager.getProviderSettings("anthropic")?.model).toBe(
+			"claude-sonnet-4-6",
+		);
+		expect(manager.getProviderSettings("openai-native")?.model).toBe("gpt-5");
+		expect(manager.getLastUsedProviderSettings()?.provider).toBe("anthropic");
+		expect(manager.read().providers["openai-native"]?.tokenSource).toBe(
+			"manual",
+		);
+	});
+
+	it("allows overriding token source metadata", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "provider-settings.json");
+		const manager = new ProviderSettingsManager({ filePath });
+
+		manager.saveProviderSettings(
+			{
+				provider: "openai-codex",
+				apiKey: "oauth-token",
+			},
+			{ tokenSource: "oauth" },
+		);
+
+		expect(manager.read().providers["openai-codex"]?.tokenSource).toBe("oauth");
+	});
+
+	it("ignores invalid persisted JSON and falls back to empty state", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-provider-settings-"),
+		);
+		tempDirs.push(tempDir);
+		const filePath = path.join(tempDir, "provider-settings.json");
+		writeFileSync(filePath, "{ not-json", "utf8");
+
+		const manager = new ProviderSettingsManager({ filePath });
+		expect(manager.read()).toEqual({
+			version: 1,
+			providers: {},
+		});
+	});
+});

package/src/storage/provider-settings-manager.ts

@@ -0,0 +1,152 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname } from "node:path";
+import { resolveProviderSettingsPath } from "@clinebot/shared/storage";
+import { ensureCustomProvidersLoadedSync } from "../providers/local-provider-registry";
+import {
+	emptyStoredProviderSettings,
+	type ProviderConfig,
+	type ProviderSettings,
+	ProviderSettingsSchema,
+	type ProviderTokenSource,
+	type StoredProviderSettings,
+	StoredProviderSettingsSchema,
+	toProviderConfig,
+} from "../types/provider-settings";
+import { migrateLegacyProviderSettings } from "./provider-settings-legacy-migration";
+
+function nowIso(): string {
+	return new Date().toISOString();
+}
+
+export interface ProviderSettingsManagerOptions {
+	filePath?: string;
+	dataDir?: string;
+}
+
+export interface SaveProviderSettingsOptions {
+	setLastUsed?: boolean;
+	tokenSource?: ProviderTokenSource;
+}
+
+function inferLegacyDataDir(filePath: string): string | undefined {
+	if (basename(filePath) !== "providers.json") {
+		return undefined;
+	}
+	const settingsDir = dirname(filePath);
+	if (basename(settingsDir) !== "settings") {
+		return undefined;
+	}
+	return dirname(settingsDir);
+}
+
+export class ProviderSettingsManager {
+	private readonly filePath: string;
+	private readonly dataDir?: string;
+
+	constructor(options: ProviderSettingsManagerOptions = {}) {
+		this.filePath = options.filePath ?? resolveProviderSettingsPath();
+		this.dataDir = options.dataDir ?? inferLegacyDataDir(this.filePath);
+		if (this.dataDir || !options.filePath) {
+			migrateLegacyProviderSettings({
+				providerSettingsManager: this,
+				dataDir: this.dataDir,
+			});
+		}
+		ensureCustomProvidersLoadedSync(this);
+	}
+
+	getFilePath(): string {
+		return this.filePath;
+	}
+
+	read(): StoredProviderSettings {
+		if (!existsSync(this.filePath)) {
+			return emptyStoredProviderSettings();
+		}
+
+		try {
+			const raw = readFileSync(this.filePath, "utf8");
+			const parsed = JSON.parse(raw) as unknown;
+			const result = StoredProviderSettingsSchema.safeParse(parsed);
+			if (result.success) {
+				return result.data;
+			}
+		} catch {
+			// Invalid content falls back to a clean state.
+		}
+
+		return emptyStoredProviderSettings();
+	}
+
+	write(state: StoredProviderSettings): void {
+		const normalized = StoredProviderSettingsSchema.parse(state);
+		const dir = dirname(this.filePath);
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+		writeFileSync(
+			this.filePath,
+			`${JSON.stringify(normalized, null, 2)}\n`,
+			"utf8",
+		);
+	}
+
+	saveProviderSettings(
+		settings: unknown,
+		options: SaveProviderSettingsOptions = {},
+	): StoredProviderSettings {
+		const validatedSettings = ProviderSettingsSchema.parse(settings);
+		const previous = this.read();
+		const providerId = validatedSettings.provider;
+		const shouldSetLastUsed = options.setLastUsed !== false;
+		const previousEntry = previous.providers[providerId];
+		const tokenSource =
+			options.tokenSource ?? previousEntry?.tokenSource ?? "manual";
+		const next: StoredProviderSettings = {
+			...previous,
+			providers: {
+				...previous.providers,
+				[providerId]: {
+					settings: validatedSettings,
+					updatedAt: nowIso(),
+					tokenSource,
+				},
+			},
+			lastUsedProvider: shouldSetLastUsed
+				? providerId
+				: previous.lastUsedProvider,
+		};
+		this.write(next);
+		return next;
+	}
+
+	getProviderSettings(providerId: string): ProviderSettings | undefined {
+		const state = this.read();
+		return state.providers[providerId]?.settings;
+	}
+
+	getLastUsedProviderSettings(): ProviderSettings | undefined {
+		const state = this.read();
+		const providerId = state.lastUsedProvider;
+		if (!providerId) {
+			return undefined;
+		}
+		return state.providers[providerId]?.settings;
+	}
+
+	getProviderConfig(providerId: string): ProviderConfig | undefined {
+		const settings = this.getProviderSettings(providerId);
+		if (!settings) {
+			return undefined;
+		}
+		return toProviderConfig(settings);
+	}
+
+	getLastUsedProviderConfig(): ProviderConfig | undefined {
+		const settings = this.getLastUsedProviderSettings();
+		if (!settings) {
+			return undefined;
+		}
+		return toProviderConfig(settings);
+	}
+}

package/src/storage/session-store.ts

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

package/src/storage/sqlite-session-store.ts

@@ -0,0 +1,275 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import {
+	asBool,
+	asOptionalString,
+	asString,
+	ensureSessionSchema,
+	loadSqliteDb,
+	nowIso,
+	type SqliteDb,
+	toBoolInt,
+} from "@clinebot/shared/db";
+import { resolveSessionDataDir } from "@clinebot/shared/storage";
+import type { SessionStatus } from "../types/common";
+import type { SessionRecord } from "../types/sessions";
+import type { SessionStore } from "../types/storage";
+
+function defaultSessionsDir(): string {
+	return resolveSessionDataDir();
+}
+
+export interface SqliteSessionStoreOptions {
+	sessionsDir?: string;
+}
+
+export class SqliteSessionStore implements SessionStore {
+	private readonly sessionsDirPath: string;
+	private db: SqliteDb | undefined;
+
+	constructor(options: SqliteSessionStoreOptions = {}) {
+		this.sessionsDirPath = options.sessionsDir ?? defaultSessionsDir();
+	}
+
+	init(): void {
+		this.getRawDb();
+	}
+
+	ensureSessionsDir(): string {
+		if (!existsSync(this.sessionsDirPath)) {
+			mkdirSync(this.sessionsDirPath, { recursive: true });
+		}
+		return this.sessionsDirPath;
+	}
+
+	sessionDbPath(): string {
+		return join(this.ensureSessionsDir(), "sessions.db");
+	}
+
+	getRawDb(): SqliteDb {
+		if (this.db) {
+			return this.db;
+		}
+		const db = loadSqliteDb(this.sessionDbPath());
+		ensureSessionSchema(db, { includeLegacyMigrations: true });
+
+		this.db = db;
+		return db;
+	}
+
+	close(): void {
+		this.db?.close?.();
+		this.db = undefined;
+	}
+
+	run(sql: string, params: unknown[] = []): { changes?: number } {
+		return this.getRawDb()
+			.prepare(sql)
+			.run(...params);
+	}
+
+	queryOne<T>(sql: string, params: unknown[] = []): T | undefined {
+		const row = this.getRawDb()
+			.prepare(sql)
+			.get(...params);
+		return (row as T | null) ?? undefined;
+	}
+
+	queryAll<T>(sql: string, params: unknown[] = []): T[] {
+		return this.getRawDb()
+			.prepare(sql)
+			.all(...params) as T[];
+	}
+
+	create(record: SessionRecord): void {
+		const now = nowIso();
+		this.run(
+			`INSERT OR REPLACE INTO sessions (
+				session_id, source, pid, started_at, ended_at, exit_code, status, status_lock, interactive,
+				provider, model, cwd, workspace_root, team_name, enable_tools, enable_spawn, enable_teams,
+				parent_session_id, parent_agent_id, agent_id, conversation_id, is_subagent, prompt,
+				metadata_json, transcript_path, hook_path, messages_path, updated_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			[
+				record.sessionId,
+				record.source,
+				record.pid,
+				record.startedAt,
+				record.endedAt ?? null,
+				record.exitCode ?? null,
+				record.status,
+				0,
+				toBoolInt(record.interactive),
+				record.provider,
+				record.model,
+				record.cwd,
+				record.workspaceRoot,
+				record.teamName ?? null,
+				toBoolInt(record.enableTools),
+				toBoolInt(record.enableSpawn),
+				toBoolInt(record.enableTeams),
+				record.parentSessionId ?? null,
+				record.parentAgentId ?? null,
+				record.agentId ?? null,
+				record.conversationId ?? null,
+				toBoolInt(record.isSubagent),
+				record.prompt ?? null,
+				record.metadata ? JSON.stringify(record.metadata) : null,
+				record.transcriptPath ?? "",
+				record.hookPath ?? "",
+				record.messagesPath ?? null,
+				now,
+			],
+		);
+	}
+
+	update(record: Partial<SessionRecord> & { sessionId: string }): void {
+		const fields: string[] = [];
+		const params: unknown[] = [];
+		if (record.endedAt !== undefined) {
+			fields.push("ended_at = ?");
+			params.push(record.endedAt);
+		}
+		if (record.exitCode !== undefined) {
+			fields.push("exit_code = ?");
+			params.push(record.exitCode);
+		}
+		if (record.status !== undefined) {
+			fields.push("status = ?");
+			params.push(record.status);
+		}
+		if (record.prompt !== undefined) {
+			fields.push("prompt = ?");
+			params.push(record.prompt);
+		}
+		if (record.metadata !== undefined) {
+			fields.push("metadata_json = ?");
+			params.push(record.metadata ? JSON.stringify(record.metadata) : null);
+		}
+		if (record.parentSessionId !== undefined) {
+			fields.push("parent_session_id = ?");
+			params.push(record.parentSessionId);
+		}
+		if (record.parentAgentId !== undefined) {
+			fields.push("parent_agent_id = ?");
+			params.push(record.parentAgentId);
+		}
+		if (record.agentId !== undefined) {
+			fields.push("agent_id = ?");
+			params.push(record.agentId);
+		}
+		if (record.conversationId !== undefined) {
+			fields.push("conversation_id = ?");
+			params.push(record.conversationId);
+		}
+		if (fields.length === 0) {
+			return;
+		}
+		fields.push("updated_at = ?");
+		params.push(nowIso());
+		params.push(record.sessionId);
+		this.run(
+			`UPDATE sessions SET ${fields.join(", ")} WHERE session_id = ?`,
+			params,
+		);
+	}
+
+	updateStatus(
+		sessionId: string,
+		status: SessionStatus,
+		exitCode?: number | null,
+	): void {
+		this.update({
+			sessionId,
+			status,
+			endedAt: status === "running" ? null : nowIso(),
+			exitCode:
+				status === "running"
+					? null
+					: (exitCode ?? (status === "failed" ? 1 : 0)),
+		});
+	}
+
+	get(sessionId: string): SessionRecord | undefined {
+		const row = this.queryOne<Record<string, unknown>>(
+			`SELECT session_id, source, pid, started_at, ended_at, exit_code, status, interactive,
+				provider, model, cwd, workspace_root, team_name,
+				enable_tools, enable_spawn, enable_teams,
+				parent_session_id, parent_agent_id, agent_id, conversation_id, is_subagent,
+				prompt, metadata_json, transcript_path, hook_path, messages_path, updated_at
+			 FROM sessions WHERE session_id = ?`,
+			[sessionId],
+		);
+		if (!row) {
+			return undefined;
+		}
+		return {
+			sessionId: asString(row.session_id),
+			source: asString(row.source) as SessionRecord["source"],
+			pid: Number(row.pid ?? 0),
+			startedAt: asString(row.started_at),
+			endedAt: (row.ended_at as string | null | undefined) ?? null,
+			exitCode: (row.exit_code as number | null | undefined) ?? null,
+			status: asString(row.status) as SessionRecord["status"],
+			interactive: asBool(row.interactive),
+			provider: asString(row.provider),
+			model: asString(row.model),
+			cwd: asString(row.cwd),
+			workspaceRoot: asString(row.workspace_root),
+			teamName: asOptionalString(row.team_name),
+			enableTools: asBool(row.enable_tools),
+			enableSpawn: asBool(row.enable_spawn),
+			enableTeams: asBool(row.enable_teams),
+			parentSessionId: asOptionalString(row.parent_session_id),
+			parentAgentId: asOptionalString(row.parent_agent_id),
+			agentId: asOptionalString(row.agent_id),
+			conversationId: asOptionalString(row.conversation_id),
+			isSubagent: asBool(row.is_subagent),
+			prompt: asOptionalString(row.prompt),
+			metadata: (() => {
+				const raw = asOptionalString(row.metadata_json);
+				if (!raw) {
+					return undefined;
+				}
+				try {
+					const parsed = JSON.parse(raw) as unknown;
+					if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+						return parsed as Record<string, unknown>;
+					}
+				} catch {
+					// Ignore malformed metadata payloads.
+				}
+				return undefined;
+			})(),
+			transcriptPath: asOptionalString(row.transcript_path),
+			hookPath: asOptionalString(row.hook_path),
+			messagesPath: asOptionalString(row.messages_path),
+			updatedAt: asOptionalString(row.updated_at) ?? nowIso(),
+		};
+	}
+
+	list(limit = 200): SessionRecord[] {
+		const rows = this.queryAll<Record<string, unknown>>(
+			`SELECT session_id FROM sessions ORDER BY started_at DESC LIMIT ?`,
+			[limit],
+		);
+		const result: SessionRecord[] = [];
+		for (const row of rows) {
+			const item = this.get(asString(row.session_id));
+			if (item) {
+				result.push(item);
+			}
+		}
+		return result;
+	}
+
+	delete(sessionId: string, cascade = false): boolean {
+		const changed =
+			this.run(`DELETE FROM sessions WHERE session_id = ?`, [sessionId])
+				.changes ?? 0;
+		if (cascade) {
+			this.run(`DELETE FROM sessions WHERE parent_session_id = ?`, [sessionId]);
+		}
+		return changed > 0;
+	}
+}