@clinebot/core 0.0.35 → 0.0.37

package/src/services/providers/local-provider-service.ts

@@ -1,23 +1,30 @@
 import * as LlmsModels from "@clinebot/llms";
-import * as LlmsProviders from "@clinebot/llms";
 import type {
-	RpcAddProviderActionRequest,
-	RpcOAuthProviderId,
-	RpcProviderCapability,
-	RpcProviderListItem,
-	RpcProviderModel,
-	RpcSaveProviderSettingsActionRequest,
+	AddProviderActionRequest,
+	OAuthProviderId,
+	ProviderCapability,
+	ProviderListItem,
+	ProviderModel,
+	SaveProviderSettingsActionRequest,
 } from "@clinebot/shared";
 import { createOAuthClientCallbacks } from "../../auth/client";
 import { loginClineOAuth } from "../../auth/cline";
 import { loginOpenAICodex } from "../../auth/codex";
 import { loginOcaOAuth } from "../../auth/oca";
+import { resolveProviderConfig } from "../../llms/provider-defaults";
+import type {
+	ModelInfo,
+	ProviderClient,
+	ProviderConfig,
+	ProviderProtocol,
+	ProviderSettings,
+} from "../../llms/provider-settings";
 import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
 import {
 	readModelsFile,
 	registerCustomProvider,
 	resolveModelsRegistryPath,
-	toRpcProviderModel,
+	toProviderModel,
 	writeModelsFile,
 } from "./local-provider-registry";
 
@@ -33,7 +40,9 @@ export interface UpdateLocalProviderRequest {
 	models?: string[];
 	defaultModelId?: string | null;
 	modelsSourceUrl?: string | null;
-	capabilities?: RpcProviderCapability[] | null;
+	protocol?: ProviderProtocol | null;
+	client?: ProviderClient | null;
+	capabilities?: ProviderCapability[] | null;
 }
 
 export interface DeleteLocalProviderRequest {
@@ -86,12 +95,12 @@ function stableColor(id: string): string {
 	return palette[hash % palette.length];
 }
 
-function toSortedRpcProviderModels(
-	modelMap: Record<string, LlmsProviders.ModelInfo>,
-): RpcProviderModel[] {
+function toSortedProviderModels(
+	modelMap: Record<string, ModelInfo>,
+): ProviderModel[] {
 	return Object.entries(modelMap)
 		.sort(([a], [b]) => a.localeCompare(b))
-		.map(([modelId, info]) => toRpcProviderModel(modelId, info));
+		.map(([modelId, info]) => toProviderModel(modelId, info));
 }
 
 // --- Model ID parsing ---
@@ -163,14 +172,14 @@ async function fetchModelIdsFromSource(
 
 async function resolveProviderModelMap(
 	providerId: string,
-	config?: LlmsProviders.ProviderConfig,
-): Promise<Record<string, LlmsProviders.ModelInfo>> {
+	config?: ProviderConfig,
+): Promise<Record<string, ModelInfo>> {
 	const registeredModels = await LlmsModels.getModelsForProvider(providerId);
 	if (!config) {
 		return registeredModels;
 	}
 
-	const resolved = await LlmsProviders.resolveProviderConfig(
+	const resolved = await resolveProviderConfig(
 		providerId,
 		{
 			loadPrivateOnAuth: true,
@@ -202,7 +211,7 @@ function normalizeHeaders(
 
 function buildProviderModels(
 	modelIds: string[],
-	capabilities: RpcProviderCapability[] | undefined,
+	capabilities: ProviderCapability[] | undefined,
 ) {
 	const supportsVision = capabilities?.includes("vision") ?? false;
 	const supportsReasoning = capabilities?.includes("reasoning") ?? false;
@@ -251,13 +260,14 @@ function removeProviderFromSettingsState(
 		mutated = true;
 	}
 	if (mutated) manager.write(state);
+	LlmsModels.unregisterProvider(providerId);
 }
 
 // --- Public API ---
 
 export async function addLocalProvider(
 	manager: ProviderSettingsManager,
-	request: Omit<RpcAddProviderActionRequest, "action">,
+	request: Omit<AddProviderActionRequest, "action">,
 ): Promise<{
 	providerId: string;
 	settingsPath: string;
@@ -333,6 +343,8 @@ export async function addLocalProvider(
 			headers: normalizedHeaders,
 			timeout: request.timeoutMs,
 			model: defaultModelId,
+			protocol: request.protocol,
+			client: request.client,
 		},
 		{ setLastUsed: false },
 	);
@@ -345,6 +357,8 @@ export async function addLocalProvider(
 			name: providerName,
 			baseUrl,
 			defaultModelId,
+			protocol: request.protocol,
+			client: request.client,
 			capabilities,
 			modelsSourceUrl: sourceUrl,
 		},
@@ -375,11 +389,40 @@ export async function updateLocalProvider(
 
 	const modelsPath = resolveModelsRegistryPath(manager);
 	const modelsState = await readModelsFile(modelsPath);
-	const existingEntry = modelsState.providers[providerId];
+	let existingEntry = modelsState.providers[providerId];
 	if (!existingEntry) {
-		throw new Error(`provider "${providerId}" does not exist`);
-	}
+		const existingSettings = manager.getProviderSettings(providerId);
+		if (!existingSettings) {
+			throw new Error(`provider "${providerId}" does not exist`);
+		}
+
+		const seedModelId =
+			uniqueTrimmed(request.models)[0] ?? existingSettings.model?.trim();
+		if (!seedModelId) {
+			throw new Error(
+				`provider "${providerId}" cannot be updated because no model is configured`,
+			);
+		}
 
+		// Ephemeral seed for the existing update path; final state is computed and written below.
+		existingEntry = {
+			provider: {
+				name: request.name?.trim() || titleCaseFromId(providerId),
+				baseUrl:
+					request.baseUrl?.trim() ?? existingSettings.baseUrl?.trim() ?? "",
+				defaultModelId: seedModelId,
+				protocol: existingSettings.protocol,
+				client: existingSettings.client,
+				capabilities: existingSettings.capabilities,
+			},
+			models: buildProviderModels([seedModelId], existingSettings.capabilities),
+		};
+	}
+	if (!existingEntry.provider) {
+		throw new Error(
+			`provider "${providerId}" cannot be updated because it is a model overlay (no provider metadata)`,
+		);
+	}
 	const providerName =
 		request.name?.trim() ?? existingEntry.provider.name.trim();
 	if (!providerName) throw new Error("name is required");
@@ -394,6 +437,14 @@ export async function updateLocalProvider(
 			: request.capabilities === null
 				? undefined
 				: [...new Set(request.capabilities)];
+	const protocol =
+		request.protocol === undefined
+			? existingEntry.provider.protocol
+			: (request.protocol ?? undefined);
+	const client =
+		request.client === undefined
+			? existingEntry.provider.client
+			: (request.client ?? undefined);
 
 	const explicitModels = uniqueTrimmed(request.models);
 	const nextModelsSourceUrl =
@@ -403,7 +454,7 @@ export async function updateLocalProvider(
 	const shouldRecomputeModels =
 		request.models !== undefined ||
 		(request.modelsSourceUrl !== undefined && !!nextModelsSourceUrl);
-	const existingModelIds = Object.keys(existingEntry.models)
+	const existingModelIds = Object.keys(existingEntry.models ?? {})
 		.map((id) => id.trim())
 		.filter(Boolean);
 	const modelIds = await resolveModelIds({
@@ -435,6 +486,10 @@ export async function updateLocalProvider(
 		baseUrl,
 		model: defaultModelId,
 	};
+	if (protocol) nextSettings.protocol = protocol;
+	else delete nextSettings.protocol;
+	if (client) nextSettings.client = client;
+	else delete nextSettings.client;
 	if (request.apiKey !== undefined) {
 		const apiKey = request.apiKey?.trim() ?? "";
 		if (apiKey) nextSettings.apiKey = apiKey;
@@ -460,6 +515,8 @@ export async function updateLocalProvider(
 			name: providerName,
 			baseUrl,
 			defaultModelId,
+			protocol,
+			client,
 			capabilities,
 			modelsSourceUrl: nextModelsSourceUrl,
 		},
@@ -508,17 +565,17 @@ export async function deleteLocalProvider(
 
 export async function listLocalProviders(
 	manager: ProviderSettingsManager,
-): Promise<{ providers: RpcProviderListItem[]; settingsPath: string }> {
+): Promise<{ providers: ProviderListItem[]; settingsPath: string }> {
 	const state = manager.read();
 	const ids = LlmsModels.getProviderIds().sort((a, b) => a.localeCompare(b));
 
 	const providers = await Promise.all(
-		ids.map(async (id): Promise<RpcProviderListItem> => {
+		ids.map(async (id): Promise<ProviderListItem> => {
 			const [info, registeredModels] = await Promise.all([
 				LlmsModels.getProvider(id),
 				LlmsModels.getModelsForProvider(id),
 			]);
-			const modelList = toSortedRpcProviderModels(registeredModels);
+			const modelList = toSortedProviderModels(registeredModels);
 			const persistedSettings = state.providers[id]?.settings;
 			const name = info?.name ?? titleCaseFromId(id);
 			return {
@@ -536,6 +593,8 @@ export async function listLocalProviders(
 					: undefined,
 				baseUrl: persistedSettings?.baseUrl ?? info?.baseUrl,
 				defaultModelId: info?.defaultModelId,
+				protocol: persistedSettings?.protocol ?? info?.protocol,
+				client: persistedSettings?.client ?? info?.client,
 				authDescription: "This provider uses API keys for authentication.",
 				baseUrlDescription: "The base endpoint to use for provider requests.",
 				modelList,
@@ -548,17 +607,17 @@ export async function listLocalProviders(
 
 export async function getLocalProviderModels(
 	providerId: string,
-	config?: LlmsProviders.ProviderConfig,
-): Promise<{ providerId: string; models: RpcProviderModel[] }> {
+	config?: ProviderConfig,
+): Promise<{ providerId: string; models: ProviderModel[] }> {
 	const id = providerId.trim();
 	const modelMap = await resolveProviderModelMap(id, config);
-	const models = toSortedRpcProviderModels(modelMap);
+	const models = toSortedProviderModels(modelMap);
 	return { providerId: id, models };
 }
 
 export function saveLocalProviderSettings(
 	manager: ProviderSettingsManager,
-	request: Omit<RpcSaveProviderSettingsActionRequest, "action">,
+	request: Omit<SaveProviderSettingsActionRequest, "action">,
 ): { providerId: string; enabled: boolean; settingsPath: string } {
 	const providerId = request.providerId.trim();
 
@@ -591,6 +650,9 @@ export function saveLocalProviderSettings(
 		"contextWindow",
 		"timeout",
 		"apiLine",
+		"protocol",
+		"client",
+		"routingProviderId",
 		"capabilities",
 	] as const) {
 		if (Object.hasOwn(request, key)) next[key] = request[key];
@@ -621,7 +683,7 @@ export function saveLocalProviderSettings(
 	return { providerId, enabled: true, settingsPath: manager.getFilePath() };
 }
 
-export function normalizeOAuthProvider(provider: string): RpcOAuthProviderId {
+export function normalizeOAuthProvider(provider: string): OAuthProviderId {
 	const normalized = provider.trim().toLowerCase();
 	if (normalized === "codex" || normalized === "openai-codex")
 		return "openai-codex";
@@ -632,17 +694,20 @@ export function normalizeOAuthProvider(provider: string): RpcOAuthProviderId {
 }
 
 function toProviderApiKey(
-	providerId: RpcOAuthProviderId,
+	providerId: OAuthProviderId,
 	credentials: { access: string },
 ): string {
-	return providerId === "cline"
-		? `workos:${credentials.access}`
-		: credentials.access;
+	if (providerId === "cline") {
+		return credentials.access.startsWith("workos:")
+			? credentials.access
+			: `workos:${credentials.access}`;
+	}
+	return credentials.access;
 }
 
 export async function loginLocalProvider(
-	providerId: RpcOAuthProviderId,
-	existing: LlmsProviders.ProviderSettings | undefined,
+	providerId: OAuthProviderId,
+	existing: ProviderSettings | undefined,
 	openUrl: (url: string) => void,
 ): Promise<{
 	access: string;
@@ -671,28 +736,28 @@ export async function loginLocalProvider(
 
 export function saveLocalProviderOAuthCredentials(
 	manager: ProviderSettingsManager,
-	providerId: RpcOAuthProviderId,
-	existing: LlmsProviders.ProviderSettings | undefined,
+	providerId: OAuthProviderId,
+	existing: ProviderSettings | undefined,
 	credentials: {
 		access: string;
 		refresh: string;
 		expires: number;
 		accountId?: string;
 	},
-): LlmsProviders.ProviderSettings {
+): ProviderSettings {
 	const auth = {
 		...(existing?.auth ?? {}),
 		accessToken: toProviderApiKey(providerId, credentials),
 		refreshToken: credentials.refresh,
 		accountId: credentials.accountId,
 		expiresAt: credentials.expires,
-	} as LlmsProviders.ProviderSettings["auth"] & { expiresAt?: number };
+	} as ProviderSettings["auth"] & { expiresAt?: number };
 
-	const merged: LlmsProviders.ProviderSettings = {
+	const merged: ProviderSettings = {
 		...(existing ?? {
-			provider: providerId as LlmsProviders.ProviderSettings["provider"],
+			provider: providerId as ProviderSettings["provider"],
 		}),
-		provider: providerId as LlmsProviders.ProviderSettings["provider"],
+		provider: providerId as ProviderSettings["provider"],
 		auth,
 	};
 	manager.saveProviderSettings(merged, { tokenSource: "oauth" });
@@ -700,7 +765,7 @@ export function saveLocalProviderOAuthCredentials(
 }
 
 export function resolveLocalClineAuthToken(
-	settings: LlmsProviders.ProviderSettings | undefined,
+	settings: ProviderSettings | undefined,
 ): string | undefined {
 	const token = settings?.auth?.accessToken?.trim() || settings?.apiKey?.trim();
 	return token && token.length > 0 ? token : undefined;

package/src/services/session-data.ts

@@ -12,7 +12,7 @@ import {
 	type SessionManifest,
 	SessionManifestSchema,
 } from "../session/session-manifest";
-import type { SessionRow } from "../session/session-service";
+import type { SessionRow } from "../session/session-row";
 import type { SessionSource, SessionStatus } from "../types/common";
 import type { StoredMessageWithMetadata } from "../types/session";
 import type { SessionRecord } from "../types/sessions";
@@ -153,23 +153,31 @@ export function withLatestAssistantTurnMetadata(
 		assistantIndexes.push(next.length - 1 - lastAssistantIndex);
 	}
 
-	const usage = result.usage;
+	const lastAssistantIndex = assistantIndexes[assistantIndexes.length - 1];
 	for (const targetIndex of assistantIndexes) {
 		const target = next[targetIndex];
+		// Use per-turn metrics already stamped on the message if available.
+		// Only fall back to result.usage (total run usage) for the terminal
+		// assistant message when no per-turn metrics are present, to avoid
+		// attaching session totals to intermediate turn messages.
+		let metrics = target.metrics;
+		if (!metrics && targetIndex === lastAssistantIndex) {
+			const usage = result.usage;
+			metrics = {
+				inputTokens: usage.inputTokens,
+				outputTokens: usage.outputTokens,
+				cacheReadTokens: usage.cacheReadTokens ?? 0,
+				cacheWriteTokens: usage.cacheWriteTokens ?? 0,
+				cost: usage.totalCost,
+			};
+		}
 		next[targetIndex] = {
 			...normalizeStoredMessageModelMetadata(target, {
 				id: result.model.id,
 				provider: result.model.provider,
 				family: result.model.info?.family,
 			}),
-			metrics: {
-				...(target.metrics ?? {}),
-				inputTokens: usage.inputTokens,
-				outputTokens: usage.outputTokens,
-				cacheReadTokens: usage.cacheReadTokens ?? 0,
-				cacheWriteTokens: usage.cacheWriteTokens ?? 0,
-				cost: usage.totalCost,
-			},
+			...(metrics ? { metrics } : {}),
 			ts: target.ts ?? result.endedAt.getTime(),
 		};
 	}

package/src/services/session-telemetry.ts

@@ -1,7 +1,6 @@
 import type { ITelemetryService } from "@clinebot/shared";
 import { resolveDocumentsExtensionPath } from "@clinebot/shared/storage";
 import { listHookConfigFiles } from "../extensions/config/hooks-config-loader";
-import type { SessionSource } from "../types/common";
 import type { CoreSessionConfig } from "../types/config";
 import {
 	captureHookDiscovery,
@@ -14,10 +13,15 @@ import {
 } from "./telemetry/core-events";
 import type { enrichPromptWithMentions } from "./workspace";
 
+/**
+ * Emits local-only session creation telemetry (task.created/restarted and
+ * hook discovery). The transport-agnostic `session.started` event is
+ * emitted from `ClineCore.start` so it fires for every backend (local,
+ * hub, remote) at the outer API boundary.
+ */
 export function emitSessionCreationTelemetry(
 	config: CoreSessionConfig,
 	sessionId: string,
-	source: SessionSource,
 	isRestart: boolean,
 	workspacePath: string,
 	agentIdentity?: Partial<TelemetryAgentIdentityProperties>,
@@ -36,19 +40,6 @@ export function emitSessionCreationTelemetry(
 		});
 	}
 	captureHookDiscoveryTelemetry(config.telemetry, { workspacePath });
-	config.telemetry?.capture({
-		event: "session.started",
-		properties: {
-			sessionId,
-			source,
-			providerId: config.providerId,
-			modelId: config.modelId,
-			enableTools: config.enableTools,
-			enableSpawnAgent: config.enableSpawnAgent,
-			enableAgentTeams: config.enableAgentTeams,
-			...agentIdentity,
-		},
-	});
 }
 
 export function captureHookDiscoveryTelemetry(

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

@@ -138,16 +138,12 @@ export class FileTeamStore implements TeamStore {
 
 	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,
+			interruptedRunIds: [],
 		};
 	}
 

package/src/services/storage/provider-settings-legacy-migration.ts

@@ -1,10 +1,17 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import * as LlmsModels from "@clinebot/llms";
-import * as LlmsProviders from "@clinebot/llms";
 import { resolveClineDataDir } from "@clinebot/shared/storage";
-import type { ProviderSettings } from "../../types/provider-settings";
-import { emptyStoredProviderSettings } from "../../types/provider-settings";
+import {
+	emptyStoredProviderSettings,
+	type ProviderSettings,
+	ProviderSettingsSchemaTyped as ProviderSettingsSchema,
+} from "../../types/provider-settings";
+import {
+	readModelsFileSync,
+	type StoredModelsFile,
+	writeModelsFileSync,
+} from "../providers/local-provider-registry";
 import type { ProviderSettingsManager } from "./provider-settings-manager";
 
 type LegacyMode = "plan" | "act";
@@ -150,27 +157,6 @@ interface LegacyProviderStorage {
 	secrets: LegacySecrets;
 }
 
-type StoredModelsFile = {
-	version: 1;
-	providers: Record<
-		string,
-		{
-			provider: {
-				name: string;
-				baseUrl: string;
-				defaultModelId?: string;
-			};
-			models: Record<
-				string,
-				{
-					id: string;
-					name: string;
-				}
-			>;
-		}
-	>;
-};
-
 const LEGACY_OPENAI_COMPATIBLE_PROVIDER_ID = "openai";
 
 export interface MigrateLegacyProviderSettingsOptions {
@@ -254,29 +240,6 @@ function readJsonObject<T extends object>(filePath: string): T | undefined {
 	return undefined;
 }
 
-function readModelsFile(filePath: string): StoredModelsFile {
-	const parsed = readJsonObject<StoredModelsFile>(filePath);
-	if (
-		parsed?.version === 1 &&
-		parsed.providers &&
-		typeof parsed.providers === "object"
-	) {
-		return parsed;
-	}
-	return {
-		version: 1,
-		providers: {},
-	};
-}
-
-function writeModelsFile(filePath: string, state: StoredModelsFile): void {
-	const dir = dirname(filePath);
-	if (!existsSync(dir)) {
-		mkdirSync(dir, { recursive: true });
-	}
-	writeFileSync(filePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
-}
-
 function resolveLegacyStorage(
 	options: MigrateLegacyProviderSettingsOptions,
 ): LegacyProviderStorage | undefined {
@@ -659,7 +622,7 @@ function buildLegacyProviderSettings(
 		...(timeout ? { timeout } : {}),
 		...providerSpecific,
 	};
-	const parsed = LlmsProviders.ProviderSettingsSchema.safeParse(settings);
+	const parsed = ProviderSettingsSchema.safeParse(settings);
 	if (!parsed.success) {
 		return undefined;
 	}
@@ -758,7 +721,7 @@ export function migrateLegacyProviderSettings(
 		dirname(options.providerSettingsManager.getFilePath()),
 		"models.json",
 	);
-	const modelsState = readModelsFile(modelsPath);
+	const modelsState = readModelsFileSync(modelsPath);
 	let addedCustomProviderCount = 0;
 
 	for (const legacyProviderId of candidates) {
@@ -815,7 +778,7 @@ export function migrateLegacyProviderSettings(
 
 	options.providerSettingsManager.write(next);
 	if (addedCustomProviderCount > 0) {
-		writeModelsFile(modelsPath, modelsState);
+		writeModelsFileSync(modelsPath, modelsState);
 	}
 
 	return {

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

@@ -1,17 +1,21 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname } from "node:path";
 import { resolveProviderSettingsPath } from "@clinebot/shared/storage";
+import { getLiveModelsCatalog } from "../..";
 import {
 	emptyStoredProviderSettings,
 	type ProviderConfig,
 	type ProviderSettings,
-	ProviderSettingsSchema,
+	ProviderSettingsSchemaTyped as ProviderSettingsSchema,
 	type ProviderTokenSource,
 	type StoredProviderSettings,
 	StoredProviderSettingsSchema,
 	toProviderConfig,
 } from "../../types/provider-settings";
-import { ensureCustomProvidersLoadedSync } from "../providers/local-provider-registry";
+import {
+	ensureCustomProvidersLoadedSync,
+	registerConfiguredProvidersFromSettings,
+} from "../providers/local-provider-registry";
 import { migrateLegacyProviderSettings } from "./provider-settings-legacy-migration";
 
 function nowIso(): string {
@@ -53,6 +57,7 @@ export class ProviderSettingsManager {
 			});
 		}
 		ensureCustomProvidersLoadedSync(this);
+		registerConfiguredProvidersFromSettings(this.read());
 	}
 
 	getFilePath(): string {
@@ -69,6 +74,7 @@ export class ProviderSettingsManager {
 			const parsed = JSON.parse(raw) as unknown;
 			const result = StoredProviderSettingsSchema.safeParse(parsed);
 			if (result.success) {
+				registerConfiguredProvidersFromSettings(result.data);
 				return result.data;
 			}
 		} catch {
@@ -89,6 +95,7 @@ export class ProviderSettingsManager {
 			`${JSON.stringify(normalized, null, 2)}\n`,
 			"utf8",
 		);
+		registerConfiguredProvidersFromSettings(normalized);
 	}
 
 	saveProviderSettings(
@@ -149,4 +156,12 @@ export class ProviderSettingsManager {
 		}
 		return toProviderConfig(settings);
 	}
+
+	async refreshCatalog(): Promise<void> {
+		try {
+			await getLiveModelsCatalog({});
+		} catch {
+			// Ignore errors
+		}
+	}
 }

package/src/services/storage/sqlite-team-store.ts

@@ -359,14 +359,10 @@ export class SqliteTeamStore implements TeamStore {
 		const teammates = snapshotRow
 			? parseTeammatesJson(snapshotRow.teammates_json)
 			: [];
-		const interruptedRunIds = this.markInProgressRunsInterrupted(
-			safeTeamName,
-			"runtime_recovered",
-		);
 		return {
 			state,
 			teammates,
-			interruptedRunIds,
+			interruptedRunIds: [],
 		};
 	}
 

package/src/services/workspace-manifest.ts

@@ -52,3 +52,21 @@ export async function buildWorkspaceMetadata(cwd: string): Promise<string> {
 	const workspaceInfo = await generateWorkspaceInfo(cwd);
 	return processWorkspaceInfo(workspaceInfo);
 }
+
+/**
+ * Generate workspace metadata as both a structured `WorkspaceInfo` object and
+ * its pre-serialized string form.
+ *
+ * Use this instead of calling `buildWorkspaceMetadata` + `generateWorkspaceInfo`
+ * separately so the git I/O only happens once.
+ */
+export async function buildWorkspaceMetadataWithInfo(cwd: string): Promise<{
+	workspaceInfo: WorkspaceInfo;
+	workspaceMetadata: string;
+}> {
+	const workspaceInfo = await generateWorkspaceInfo(cwd);
+	return {
+		workspaceInfo,
+		workspaceMetadata: processWorkspaceInfo(workspaceInfo),
+	};
+}