@xopcai/xopc 0.0.179 → 0.0.187

package/dist/src/agent-manifest/schema.js

@@ -1,9 +1,10 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { z } from "zod";
 //#region src/agent-manifest/schema.ts
-var IdSchema, DEFAULT_CAPABILITY_PRESET_ID, ManifestModelRoleSchema, AgentToolModelSchema, ModelPolicySchema, ModelPolicyPatchSchema, ToolModeSchema, ToolScopeSchema, ToolPolicySchema, ToolPolicySetSchema, SkillPolicySchema, WorkflowPolicySchema, BoundaryPolicySchema, WorkspacePolicySchema, RuntimePolicySchema, PromptPolicySchema, AgentIdentitySchema, AgentResponsibilitiesSchema, AgentManifestSchema, AgentConfigEntrySchema, CapabilityPresetSchema;
+var IdSchema, LockPathSchema, DEFAULT_CAPABILITY_PRESET_ID, ManifestModelRoleSchema, AgentToolModelSchema, ModelPolicySchema, ModelPolicyPatchSchema, ToolModeSchema, ToolScopeSchema, ToolPolicySchema, ToolPolicySetSchema, ToolPolicySetPatchSchema, SkillPolicySchema, SkillPolicyPatchSchema, WorkflowPolicySchema, WorkflowPolicyPatchSchema, BoundaryPolicySchema, BoundaryPolicyPatchSchema, WorkspacePolicySchema, RuntimePolicySchema, PromptPolicySchema, AgentIdentitySchema, AgentResponsibilitiesSchema, AgentManifestSchema, AgentConfigEntrySchema, CapabilityPresetSchema;
 var init_schema = __esmMin((() => {
 	IdSchema = z.string().regex(/^[a-z][a-z0-9_-]{0,63}$/);
+	LockPathSchema = z.string().regex(/^(models|tools|skills|workflows|boundaries|runtime)(?:\.[^.\s]+)*$/, "lock path must target a capability policy field");
 	DEFAULT_CAPABILITY_PRESET_ID = "default";
 	ManifestModelRoleSchema = z.object({
 		model: z.string().min(1),
@@ -101,6 +102,13 @@ var init_schema = __esmMin((() => {
 			tools: z.record(z.string().min(1), ToolPolicySchema).optional()
 		}).strict().optional()
 	}).strict().default({ builtin: {} });
+	ToolPolicySetPatchSchema = z.object({
+		builtin: z.record(z.string().min(1), ToolPolicySchema).optional(),
+		mcp: z.object({
+			servers: z.record(z.string().min(1), ToolPolicySchema).optional(),
+			tools: z.record(z.string().min(1), ToolPolicySchema).optional()
+		}).strict().optional()
+	}).strict();
 	SkillPolicySchema = z.object({
 		mode: z.enum([
 			"all",
@@ -111,6 +119,16 @@ var init_schema = __esmMin((() => {
 		allow: z.array(z.string().min(1)).optional(),
 		deny: z.array(z.string().min(1)).optional()
 	}).strict().default({ mode: "all" });
+	SkillPolicyPatchSchema = z.object({
+		mode: z.enum([
+			"all",
+			"allowlist",
+			"denylist",
+			"off"
+		]),
+		allow: z.array(z.string().min(1)).optional(),
+		deny: z.array(z.string().min(1)).optional()
+	}).strict();
 	WorkflowPolicySchema = z.object({
 		default: z.string().min(1).optional(),
 		allowed: z.array(z.string().min(1)).optional(),
@@ -119,6 +137,7 @@ var init_schema = __esmMin((() => {
 			workflow: z.string().min(1)
 		}).strict()).optional()
 	}).strict().default({});
+	WorkflowPolicyPatchSchema = WorkflowPolicySchema.removeDefault();
 	BoundaryPolicySchema = z.object({
 		requiresConfirmation: z.array(z.string().min(1)).default([]),
 		forbidden: z.array(z.string().min(1)).default([]),
@@ -128,6 +147,11 @@ var init_schema = __esmMin((() => {
 		forbidden: [],
 		escalation: []
 	});
+	BoundaryPolicyPatchSchema = z.object({
+		requiresConfirmation: z.array(z.string().min(1)).optional(),
+		forbidden: z.array(z.string().min(1)).optional(),
+		escalation: z.array(z.string().min(1)).optional()
+	}).strict();
 	WorkspacePolicySchema = z.object({ root: z.string().min(1) }).strict();
 	RuntimePolicySchema = z.object({
 		maxTurns: z.number().int().positive().optional(),
@@ -163,7 +187,21 @@ var init_schema = __esmMin((() => {
 		runtime: RuntimePolicySchema,
 		prompt: PromptPolicySchema
 	}).strict();
-	AgentConfigEntrySchema = AgentManifestSchema.extend({ models: ModelPolicySchema.optional() }).strict();
+	AgentConfigEntrySchema = z.object({
+		id: IdSchema,
+		enabled: z.boolean().default(true),
+		extends: z.array(IdSchema).optional(),
+		identity: AgentIdentitySchema,
+		responsibilities: AgentResponsibilitiesSchema,
+		workspace: WorkspacePolicySchema,
+		models: ModelPolicyPatchSchema.optional(),
+		tools: ToolPolicySetPatchSchema.optional(),
+		skills: SkillPolicyPatchSchema.optional(),
+		workflows: WorkflowPolicyPatchSchema.optional(),
+		boundaries: BoundaryPolicyPatchSchema.optional(),
+		runtime: RuntimePolicySchema,
+		prompt: PromptPolicySchema
+	}).strict();
 	CapabilityPresetSchema = z.object({
 		id: IdSchema,
 		name: z.string().min(1),
@@ -171,14 +209,14 @@ var init_schema = __esmMin((() => {
 		version: z.number().int().positive().default(1),
 		extends: z.array(IdSchema).optional(),
 		models: ModelPolicyPatchSchema.optional(),
-		tools: ToolPolicySetSchema.optional(),
-		skills: SkillPolicySchema.optional(),
-		workflows: WorkflowPolicySchema.optional(),
-		boundaries: BoundaryPolicySchema.optional(),
+		tools: ToolPolicySetPatchSchema.optional(),
+		skills: SkillPolicyPatchSchema.optional(),
+		workflows: WorkflowPolicyPatchSchema.optional(),
+		boundaries: BoundaryPolicyPatchSchema.optional(),
 		runtime: RuntimePolicySchema,
-		locks: z.array(z.string().min(1)).optional()
+		locks: z.array(LockPathSchema).optional()
 	}).strict();
 }));
 //#endregion
 init_schema();
-export { AgentConfigEntrySchema, AgentIdentitySchema, AgentManifestSchema, AgentResponsibilitiesSchema, AgentToolModelSchema, BoundaryPolicySchema, CapabilityPresetSchema, DEFAULT_CAPABILITY_PRESET_ID, ManifestModelRoleSchema, ModelPolicyPatchSchema, ModelPolicySchema, PromptPolicySchema, RuntimePolicySchema, SkillPolicySchema, ToolModeSchema, ToolPolicySchema, ToolPolicySetSchema, ToolScopeSchema, WorkflowPolicySchema, WorkspacePolicySchema, init_schema };
+export { AgentConfigEntrySchema, AgentIdentitySchema, AgentManifestSchema, AgentResponsibilitiesSchema, AgentToolModelSchema, BoundaryPolicyPatchSchema, BoundaryPolicySchema, CapabilityPresetSchema, DEFAULT_CAPABILITY_PRESET_ID, ManifestModelRoleSchema, ModelPolicyPatchSchema, ModelPolicySchema, PromptPolicySchema, RuntimePolicySchema, SkillPolicyPatchSchema, SkillPolicySchema, ToolModeSchema, ToolPolicySchema, ToolPolicySetPatchSchema, ToolPolicySetSchema, ToolScopeSchema, WorkflowPolicyPatchSchema, WorkflowPolicySchema, WorkspacePolicySchema, init_schema };

package/dist/src/agent-runtime/index.js

@@ -1,7 +1,7 @@
-import { buildMemoryRuntime } from "./memory-runtime.js";
 import { checkBoundary } from "./boundary-guard.js";
 import { resolveModelRole } from "./model-router.js";
 import { buildRuntimeToolRegistry } from "./tool-registry.js";
+import { buildMemoryRuntime } from "./memory-runtime.js";
 import { resolveWorkflow, validateWorkflowForRuntime } from "./workflow-runtime.js";
 import { buildAgentRuntimeProfile } from "./runtime-profile.js";
 import { appendAgentRunEvent, createAgentRunTrace, finishAgentRunTrace, hashEffectiveManifest } from "./run-trace.js";

package/dist/src/agent-runtime/memory-runtime.d.ts

@@ -1,6 +1,6 @@
 import type { UserContextConfig } from '../user-context/config.js';
-export type MemorySource = 'session' | 'userProfile' | 'agentProfile' | 'curated' | 'workspace' | 'connectedSources';
-export type MemoryWriteTarget = 'userProfile' | 'agentProfile' | 'curated' | 'workspace';
+export type MemorySource = 'session' | 'userProfile' | 'agentProfile' | 'understanding' | 'workspace' | 'connectedSources';
+export type MemoryWriteTarget = 'userProfile' | 'agentProfile' | 'understanding' | 'workspace';
 export type MemoryWriteDecision = 'allow' | 'confirm' | 'deny';
 export interface MemoryCandidate {
     target: MemoryWriteTarget;

package/dist/src/agent-runtime/runtime-profile.js

@@ -1,9 +1,9 @@
 import { buildAgentManifestPromptSection } from "../agent-manifest/prompt.js";
 import "../agent-manifest/index.js";
-import { buildMemoryRuntime } from "./memory-runtime.js";
 import { checkBoundary } from "./boundary-guard.js";
 import { resolveModelRole } from "./model-router.js";
 import { buildRuntimeToolRegistry } from "./tool-registry.js";
+import { buildMemoryRuntime } from "./memory-runtime.js";
 import { resolveWorkflow, validateWorkflowForRuntime } from "./workflow-runtime.js";
 //#region src/agent-runtime/runtime-profile.ts
 function buildAgentRuntimeProfile(params) {

package/dist/src/ai-assist/text-assist.js

@@ -3,7 +3,7 @@ import { init_logger } from "../utils/logger.js";
 import { getDefaultModelSync, init_providers, resolveModel } from "../providers/index.js";
 import { createExtensionAwareStreamFn } from "../providers/extension-stream-bridge.js";
 import { isLocalModelBaseUrl, resolveModelCallApiKey, resolveModelCallOptions } from "../providers/model-call.js";
-import { getAssistantMessageErrorReason, stripCodeFences } from "../agent/goals/judge.js";
+import { getAssistantMessageErrorReason, stripCodeFences } from "../providers/model-response.js";
 //#region src/ai-assist/text-assist.ts
 init_providers();
 init_logger();
@@ -39,7 +39,7 @@ const SCENARIOS = {
 	},
 	"cron.workflowGoal": {
 		id: "cron.workflowGoal",
-		system: "You rewrite goals for workflow runs triggered by cron jobs. The workflow already defines the procedure; the field should define the desired outcome.",
+		system: "You rewrite goals for workflow runs triggered by cron jobs. The workflow already defines the procedure; the field should define the desired task.",
 		userGuidance: [
 			"Make the goal concrete, bounded, and easy to verify.",
 			"Include success criteria and important constraints when they are implied by the input or context.",
@@ -67,7 +67,7 @@ const SCENARIOS = {
 	},
 	"workflow.goal": {
 		id: "workflow.goal",
-		system: "You rewrite goals for workflow runs started manually by a user. The workflow already defines the procedure; the goal defines the desired outcome for this run.",
+		system: "You rewrite goals for workflow runs started manually by a user. The workflow already defines the procedure; the goal defines the desired task for this run.",
 		userGuidance: [
 			"Make the goal concrete, bounded, and easy to verify.",
 			"Include success criteria and important constraints when implied by the input or workflow context.",
@@ -95,7 +95,7 @@ const SCENARIOS = {
 	},
 	"automation.workflowGoal": {
 		id: "automation.workflowGoal",
-		system: "You rewrite goals for workflow runs triggered by automations. The workflow defines the procedure; the goal defines the desired outcome.",
+		system: "You rewrite goals for workflow runs triggered by automations. The workflow defines the procedure; the goal defines the desired task.",
 		userGuidance: [
 			"Make the goal concrete, bounded, and easy to verify after the run.",
 			"Include success criteria and important constraints when implied by the input or context.",

package/dist/src/auth/credentials.d.ts

@@ -1,4 +1,5 @@
 import type { Config } from '../config/schema.js';
+import type { OAuthCredentials } from './oauth/types.js';
 export type CredentialType = 'api_key' | 'oauth';
 export interface ApiKeyProfile {
     type: 'api_key';
@@ -17,6 +18,7 @@ export interface OAuthToken {
     createdAt: string;
     updatedAt: string;
 }
+type OAuthTokenInput = Omit<OAuthToken, 'type' | 'provider' | 'updatedAt'> & Record<string, unknown>;
 export type CredentialProfile = ApiKeyProfile;
 export interface AuthProfilesFile {
     version: number;
@@ -77,6 +79,7 @@ export declare class CredentialResolver {
      * Load OAuth token for a provider.
      */
     loadOAuthToken(provider: string): Promise<OAuthToken | null>;
+    private hasUsableOAuthTokenRecord;
     /**
      * Load the raw OAuth token record, including expired tokens for status UIs.
      */
@@ -88,10 +91,14 @@ export declare class CredentialResolver {
         hasAccess: boolean;
         hasRefresh: boolean;
     }>>;
+    /**
+     * Save raw provider OAuth credentials without converting them to an API key representation.
+     */
+    saveOAuthCredentials(provider: string, credentials: OAuthCredentials): Promise<void>;
     /**
      * Save OAuth token for a provider.
      */
-    saveOAuthToken(provider: string, token: Omit<OAuthToken, 'type' | 'provider' | 'updatedAt'>): Promise<void>;
+    saveOAuthToken(provider: string, token: OAuthTokenInput): Promise<void>;
     /**
      * Delete the OAuth token persisted for a provider.
      */
@@ -114,3 +121,4 @@ export declare class CredentialResolver {
 export declare function getCredentialResolver(options?: CredentialResolverOptions): CredentialResolver;
 export declare function resolveApiKey(provider: string, options?: CredentialResolverOptions): Promise<string | null>;
 export declare function hasCredentials(provider: string, options?: CredentialResolverOptions): Promise<boolean>;
+export {};

package/dist/src/auth/credentials.js

@@ -5,9 +5,37 @@ import { init_paths, resolveAgentAuthProfilesPath, resolveAuthProfilesPath, reso
 import { init_write_file_atomic, writeTextAtomic } from "../infra/write-file-atomic.js";
 import { getOAuthProviderDefinition, init_registry } from "./oauth/registry.js";
 import { getApiKeyFromEnv, init_env_keys } from "../providers/env-keys.js";
+import { init_oauth_provider_lock, withOAuthProviderLock } from "./oauth-provider-lock.js";
 import { dirname, join } from "path";
 import { mkdir, readFile, readdir, rm } from "fs/promises";
 //#region src/auth/credentials.ts
+function toOAuthCredentials(token) {
+	const { type: _type, provider: _provider, expiresAt, createdAt: _createdAt, updatedAt: _updatedAt, ...providerFields } = token;
+	return {
+		...providerFields,
+		access: token.access,
+		refresh: token.refresh ?? "",
+		expires: expiresAt ?? Number.MAX_SAFE_INTEGER
+	};
+}
+function normalizeLegacyOAuthToken(token) {
+	if (token.provider !== "google-gemini-cli" && token.provider !== "google-antigravity") return token;
+	let access = token.access;
+	let projectId = token.projectId;
+	for (let depth = 0; depth < 5; depth += 1) try {
+		const legacy = JSON.parse(access);
+		if (typeof legacy.token !== "string" || !legacy.token) break;
+		access = legacy.token;
+		if (typeof projectId !== "string" && typeof legacy.projectId === "string") projectId = legacy.projectId;
+	} catch {
+		break;
+	}
+	return access === token.access ? token : {
+		...token,
+		access,
+		projectId
+	};
+}
 function getCredentialResolver(options) {
 	if (options) return new CredentialResolver(options);
 	defaultResolver ??= new CredentialResolver();
@@ -19,16 +47,16 @@ async function resolveApiKey(provider, options) {
 async function hasCredentials(provider, options) {
 	return getCredentialResolver(options).hasCredentials(provider);
 }
-var log, warnedExpiredOAuthTokens, oauthRefreshes, CredentialResolver, defaultResolver;
+var log, warnedExpiredOAuthTokens, CredentialResolver, defaultResolver;
 var init_credentials = __esmMin((() => {
 	init_write_file_atomic();
 	init_logger();
 	init_env_keys();
 	init_paths();
 	init_registry();
+	init_oauth_provider_lock();
 	log = createLogger("Credentials");
 	warnedExpiredOAuthTokens = /* @__PURE__ */ new Set();
-	oauthRefreshes = /* @__PURE__ */ new Map();
 	CredentialResolver = class {
 		credentialsDir;
 		agentId;
@@ -45,7 +73,11 @@ var init_credentials = __esmMin((() => {
 		*/
 		async resolveApiKey(provider) {
 			const normalizedProvider = provider.toLowerCase();
-			if (getOAuthProviderDefinition(normalizedProvider)?.oauthOnly) return (await this.loadOAuthToken(normalizedProvider))?.access ?? null;
+			const oauthDefinition = getOAuthProviderDefinition(normalizedProvider);
+			if (oauthDefinition?.oauthOnly) {
+				const token = await this.loadOAuthToken(normalizedProvider);
+				return token ? oauthDefinition.provider.getApiKey(toOAuthCredentials(token)) : null;
+			}
 			if (this.agentId) {
 				const agentKey = await this.loadFromAgentCredentials(normalizedProvider);
 				if (agentKey) {
@@ -70,7 +102,7 @@ var init_credentials = __esmMin((() => {
 					provider,
 					source: "oauth"
 				}, "Resolved API key from OAuth token");
-				return oauthToken.access;
+				return oauthDefinition ? oauthDefinition.provider.getApiKey(toOAuthCredentials(oauthToken)) : oauthToken.access;
 			}
 			const envKey = getApiKeyFromEnv(normalizedProvider);
 			if (envKey) {
@@ -86,19 +118,19 @@ var init_credentials = __esmMin((() => {
 		* Check if a provider has credentials configured
 		*/
 		async hasCredentials(provider) {
-			return await this.resolveApiKey(provider) !== null;
+			return await this.resolveApiKeySource(provider) !== null;
 		}
 		/**
 		* Which step in {@link resolveApiKey} would supply the key (no secret material).
 		*/
 		async resolveApiKeySource(provider) {
 			const normalizedProvider = provider.toLowerCase();
-			if (getOAuthProviderDefinition(normalizedProvider)?.oauthOnly) return await this.loadOAuthToken(normalizedProvider) ? "oauth" : null;
+			if (getOAuthProviderDefinition(normalizedProvider)?.oauthOnly) return await this.hasUsableOAuthTokenRecord(normalizedProvider) ? "oauth" : null;
 			if (this.agentId) {
 				if (await this.loadFromAgentCredentials(normalizedProvider)) return "agent";
 			}
 			if (await this.loadFromGlobalCredentials(normalizedProvider)) return "global";
-			if (await this.loadOAuthToken(normalizedProvider)) return "oauth";
+			if (await this.hasUsableOAuthTokenRecord(normalizedProvider)) return "oauth";
 			if (getApiKeyFromEnv(normalizedProvider)) return "env";
 			return null;
 		}
@@ -169,42 +201,42 @@ var init_credentials = __esmMin((() => {
 		* Load OAuth token for a provider.
 		*/
 		async loadOAuthToken(provider) {
-			const token = await this.loadOAuthTokenRecord(provider);
+			const normalizedProvider = provider.toLowerCase();
+			let token = await this.loadOAuthTokenRecord(normalizedProvider);
 			if (!token) return null;
-			const expiresAt = token.expiresAt ?? Number.POSITIVE_INFINITY;
+			let expiresAt = token.expiresAt ?? Number.POSITIVE_INFINITY;
 			if (expiresAt <= Date.now() + 6e4 && token.refresh) {
-				const definition = getOAuthProviderDefinition(provider);
-				if (definition) {
-					let pending = oauthRefreshes.get(provider);
-					if (!pending) {
-						pending = definition.provider.refreshToken({
-							access: token.access,
-							refresh: token.refresh,
-							expires: expiresAt
-						}).then(async (refreshed) => {
-							const updated = {
-								...token,
-								access: definition.provider.getApiKey(refreshed),
-								refresh: refreshed.refresh,
-								expiresAt: refreshed.expires,
-								scope: Array.isArray(refreshed.scope) ? refreshed.scope.filter((value) => typeof value === "string") : token.scope,
-								updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-							};
-							await this.saveOAuthToken(provider, updated);
-							return updated;
-						}).finally(() => oauthRefreshes.delete(provider));
-						oauthRefreshes.set(provider, pending);
-					}
-					try {
-						return await pending;
-					} catch (err) {
-						if (expiresAt > Date.now()) {
-							log.warn({
-								err,
-								provider
-							}, "OAuth refresh failed; using the current access token");
-							return token;
-						}
+				const definition = getOAuthProviderDefinition(normalizedProvider);
+				if (definition) try {
+					token = await withOAuthProviderLock(normalizedProvider, async () => {
+						const current = await this.loadOAuthTokenRecord(normalizedProvider);
+						if (!current) return null;
+						if ((current.expiresAt ?? Number.POSITIVE_INFINITY) > Date.now() + 6e4 || !current.refresh) return current;
+						const refreshed = await definition.provider.refreshToken(toOAuthCredentials(current));
+						const { expires, ...refreshedFields } = refreshed;
+						const updated = {
+							...current,
+							...refreshedFields,
+							access: refreshed.access,
+							refresh: refreshed.refresh,
+							expiresAt: expires,
+							scope: Array.isArray(refreshed.scope) ? refreshed.scope.filter((value) => typeof value === "string") : current.scope,
+							updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+						};
+						await this.saveOAuthToken(normalizedProvider, updated);
+						return updated;
+					});
+					if (!token) return null;
+					expiresAt = token.expiresAt ?? Number.POSITIVE_INFINITY;
+				} catch (err) {
+					token = await this.loadOAuthTokenRecord(normalizedProvider) ?? token;
+					expiresAt = token.expiresAt ?? Number.POSITIVE_INFINITY;
+					if (expiresAt > Date.now()) {
+						log.warn({
+							err,
+							provider: normalizedProvider
+						}, "OAuth refresh failed; using the current access token");
+						return token;
 					}
 				}
 			}
@@ -221,6 +253,12 @@ var init_credentials = __esmMin((() => {
 			}
 			return token;
 		}
+		async hasUsableOAuthTokenRecord(provider) {
+			const token = await this.loadOAuthTokenRecord(provider);
+			if (!token?.access?.trim()) return null;
+			if (token.expiresAt && token.expiresAt <= Date.now() && !token.refresh?.trim()) return null;
+			return token;
+		}
 		/**
 		* Load the raw OAuth token record, including expired tokens for status UIs.
 		*/
@@ -230,7 +268,7 @@ var init_credentials = __esmMin((() => {
 			try {
 				const content = await readFile(oauthPath, "utf-8");
 				const token = JSON.parse(content);
-				return token.provider === normalizedProvider ? token : null;
+				return token.provider === normalizedProvider ? normalizeLegacyOAuthToken(token) : null;
 			} catch {
 				return null;
 			}
@@ -266,28 +304,46 @@ var init_credentials = __esmMin((() => {
 			return tokens.sort((a, b) => a.provider.localeCompare(b.provider));
 		}
 		/**
+		* Save raw provider OAuth credentials without converting them to an API key representation.
+		*/
+		async saveOAuthCredentials(provider, credentials) {
+			const { access, refresh, expires, scope, ...providerFields } = credentials;
+			await this.saveOAuthToken(provider, {
+				...providerFields,
+				access,
+				refresh,
+				expiresAt: expires,
+				scope: Array.isArray(scope) ? scope.filter((value) => typeof value === "string") : void 0,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		}
+		/**
 		* Save OAuth token for a provider.
 		*/
 		async saveOAuthToken(provider, token) {
 			const normalizedProvider = provider.toLowerCase();
-			const oauthPath = resolveOAuthPath(normalizedProvider);
-			await mkdir(dirname(oauthPath), { recursive: true });
-			const fullToken = {
-				...token,
-				type: "oauth",
-				provider: normalizedProvider,
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			};
-			await writeTextAtomic(oauthPath, JSON.stringify(fullToken, null, 2));
-			log.info({ provider: normalizedProvider }, "Saved OAuth token");
+			await withOAuthProviderLock(normalizedProvider, async () => {
+				const oauthPath = resolveOAuthPath(normalizedProvider);
+				await mkdir(dirname(oauthPath), { recursive: true });
+				const fullToken = {
+					...token,
+					type: "oauth",
+					provider: normalizedProvider,
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				await writeTextAtomic(oauthPath, JSON.stringify(fullToken, null, 2));
+				log.info({ provider: normalizedProvider }, "Saved OAuth token");
+			});
 		}
 		/**
 		* Delete the OAuth token persisted for a provider.
 		*/
 		async deleteOAuthToken(provider) {
 			const normalizedProvider = provider.toLowerCase();
-			await rm(resolveOAuthPath(normalizedProvider), { force: true });
-			log.info({ provider: normalizedProvider }, "Deleted OAuth token");
+			await withOAuthProviderLock(normalizedProvider, async () => {
+				await rm(resolveOAuthPath(normalizedProvider), { force: true });
+				log.info({ provider: normalizedProvider }, "Deleted OAuth token");
+			});
 		}
 		/**
 		* Disconnect the default credential for a provider from local storage.

package/dist/src/auth/model-credential-store.js

@@ -1,4 +1,5 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { init_oauth_provider_lock, withOAuthProviderLock } from "./oauth-provider-lock.js";
 import { CredentialResolver, init_credentials } from "./credentials.js";
 //#region src/auth/model-credential-store.ts
 function normalizeProviderId(providerId) {
@@ -30,26 +31,10 @@ function toPersistedToken(credential, current) {
 		createdAt: current?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
 	};
 }
-async function serializeProviderModification(providerId, operation) {
-	const previous = providerModificationTails.get(providerId) ?? Promise.resolve();
-	let release;
-	const gate = new Promise((resolve) => {
-		release = resolve;
-	});
-	const tail = previous.catch(() => void 0).then(() => gate);
-	providerModificationTails.set(providerId, tail);
-	await previous.catch(() => void 0);
-	try {
-		return await operation();
-	} finally {
-		release();
-		if (providerModificationTails.get(providerId) === tail) providerModificationTails.delete(providerId);
-	}
-}
-var providerModificationTails, XopcModelCredentialStore;
+var XopcModelCredentialStore;
 var init_model_credential_store = __esmMin((() => {
 	init_credentials();
-	providerModificationTails = /* @__PURE__ */ new Map();
+	init_oauth_provider_lock();
 	XopcModelCredentialStore = class {
 		runtimeApiKeys = /* @__PURE__ */ new Map();
 		constructor(repository = new CredentialResolver()) {
@@ -81,7 +66,7 @@ var init_model_credential_store = __esmMin((() => {
 		}
 		async modify(providerId, update, options) {
 			const normalizedProvider = normalizeProviderId(providerId);
-			return serializeProviderModification(normalizedProvider, async () => {
+			return withOAuthProviderLock(normalizedProvider, async () => {
 				options?.signal?.throwIfAborted();
 				const persisted = await this.repository.loadOAuthTokenRecord(normalizedProvider);
 				const current = this.runtimeApiKeys.get(normalizedProvider) ?? (persisted ? toRuntimeCredential(persisted) : void 0);
@@ -93,15 +78,15 @@ var init_model_credential_store = __esmMin((() => {
 					this.runtimeApiKeys.delete(normalizedProvider);
 				} else this.runtimeApiKeys.set(normalizedProvider, updated);
 				return updated;
-			});
+			}, { signal: options?.signal });
 		}
 		async delete(providerId, options) {
 			const normalizedProvider = normalizeProviderId(providerId);
-			await serializeProviderModification(normalizedProvider, async () => {
+			await withOAuthProviderLock(normalizedProvider, async () => {
 				options?.signal?.throwIfAborted();
 				await this.repository.deleteOAuthToken(normalizedProvider);
 				this.runtimeApiKeys.delete(normalizedProvider);
-			});
+			}, { signal: options?.signal });
 		}
 	};
 }));

package/dist/src/auth/oauth-provider-lock.d.ts

@@ -0,0 +1,5 @@
+interface OAuthProviderLockOptions {
+    signal?: AbortSignal;
+}
+export declare function withOAuthProviderLock<T>(providerId: string, operation: () => Promise<T>, options?: OAuthProviderLockOptions): Promise<T>;
+export {};

package/dist/src/auth/oauth-provider-lock.js

@@ -0,0 +1,91 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { init_paths, resolveOAuthPath } from "../config/paths.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { dirname } from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdir, open, readFile, rm, stat } from "node:fs/promises";
+import { setTimeout } from "node:timers/promises";
+//#region src/auth/oauth-provider-lock.ts
+function lockPath(providerId) {
+	return `${resolveOAuthPath(providerId.toLowerCase())}.lock`;
+}
+function isAlreadyExists(error) {
+	return error?.code === "EEXIST";
+}
+function isMissing(error) {
+	return error?.code === "ENOENT";
+}
+async function removeStaleLock(path) {
+	try {
+		const info = await stat(path);
+		if (Date.now() - info.mtimeMs < STALE_LOCK_MS) return false;
+		await rm(path, { force: true });
+		return true;
+	} catch (error) {
+		if (isMissing(error)) return true;
+		throw error;
+	}
+}
+async function acquireFileLock(providerId, options) {
+	const path = lockPath(providerId);
+	const owner = `${process.pid}:${randomUUID()}`;
+	const deadline = Date.now() + LOCK_TIMEOUT_MS;
+	await mkdir(dirname(path), { recursive: true });
+	while (true) {
+		options.signal?.throwIfAborted();
+		try {
+			const handle = await open(path, "wx", 384);
+			try {
+				await handle.writeFile(owner, "utf8");
+			} finally {
+				await handle.close();
+			}
+			return async () => {
+				try {
+					if (await readFile(path, "utf8") === owner) await rm(path, { force: true });
+				} catch {}
+			};
+		} catch (error) {
+			if (!isAlreadyExists(error)) throw error;
+			if (await removeStaleLock(path)) continue;
+			if (Date.now() >= deadline) throw new Error(`Timed out waiting for OAuth credential lock for ${providerId}`);
+			await setTimeout(LOCK_RETRY_MS, void 0, options.signal ? { signal: options.signal } : void 0);
+		}
+	}
+}
+async function withOAuthProviderLock(providerId, operation, options = {}) {
+	const normalizedProvider = providerId.toLowerCase();
+	const heldLocks = heldProviderLocks.getStore();
+	if (heldLocks?.has(normalizedProvider)) return operation();
+	const previous = providerModificationTails.get(normalizedProvider) ?? Promise.resolve();
+	let releaseQueue;
+	const queueGate = new Promise((resolve) => {
+		releaseQueue = resolve;
+	});
+	const tail = previous.catch(() => void 0).then(() => queueGate);
+	providerModificationTails.set(normalizedProvider, tail);
+	await previous.catch(() => void 0);
+	let releaseFileLock;
+	try {
+		releaseFileLock = await acquireFileLock(normalizedProvider, options);
+		const nextHeldLocks = new Set(heldLocks);
+		nextHeldLocks.add(normalizedProvider);
+		return await heldProviderLocks.run(nextHeldLocks, operation);
+	} finally {
+		await releaseFileLock?.();
+		releaseQueue();
+		if (providerModificationTails.get(normalizedProvider) === tail) providerModificationTails.delete(normalizedProvider);
+	}
+}
+var LOCK_RETRY_MS, LOCK_TIMEOUT_MS, STALE_LOCK_MS, providerModificationTails, heldProviderLocks;
+var init_oauth_provider_lock = __esmMin((() => {
+	init_paths();
+	LOCK_RETRY_MS = 50;
+	LOCK_TIMEOUT_MS = 9e4;
+	STALE_LOCK_MS = 6e4;
+	providerModificationTails = /* @__PURE__ */ new Map();
+	heldProviderLocks = new AsyncLocalStorage();
+}));
+//#endregion
+init_oauth_provider_lock();
+export { init_oauth_provider_lock, withOAuthProviderLock };

package/dist/src/automations/domain/defaults.d.ts

@@ -1 +1,8 @@
-export declare const DEFAULT_AUTOMATION_TIMEOUT_SECONDS = 300;
+import type { AutomationAction } from './types.js';
+export declare const DEFAULT_AUTOMATION_TIMEOUT_SECONDS: number;
+export declare const DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS: number;
+export declare function defaultAutomationTimeoutSeconds(action: AutomationAction): number;
+export declare function resolveAutomationTimeoutSeconds(action: AutomationAction, reliability?: {
+    executionTimeoutSeconds?: number;
+    timeoutSeconds?: number;
+}): number;