lael-labs/executor

apps/executor/src/server/server.test.ts+7−5

   controlPlaneOpenApiSpec,
 } from "@executor/platform-api";
 import {
-  buildLocalSourceArtifact,
   catalogSyncResultFromMcpManifest,
-  deriveLocalInstallation,
+  type ResolveExecutionEnvironment,
+} from "@executor/platform-sdk/runtime";
+import {
+  buildLocalSourceArtifact,
+  getOrProvisionLocalInstallation,
   resolveLocalWorkspaceContext,
   writeLocalSourceArtifact,
   writeProjectLocalExecutorConfig,
-  type ResolveExecutionEnvironment,
+} from "@executor/platform-sdk-file";
-} from "@executor/platform-sdk/runtime";
 import { SourceIdSchema } from "@executor/platform-sdk/schema";
 import { makeSesExecutor } from "@executor/runtime-ses";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
     const context = yield* resolveLocalWorkspaceContext({
       workspaceRoot: input.workspaceRoot,
     });
-    const installation = deriveLocalInstallation(context);
+    const installation = yield* getOrProvisionLocalInstallation({ context });
     yield* writeProjectLocalExecutorConfig({
       context,

bun.lock+28−0

         "@executor/platform-api": "workspace:*",
         "@executor/platform-internal": "workspace:*",
         "@executor/platform-sdk": "workspace:*",
+        "@executor/platform-sdk-file": "workspace:*",
         "@executor/server": "workspace:*",
         "effect": "catalog:",
       },
         "@effect/platform": "catalog:",
         "@effect/platform-node": "catalog:",
         "@effect/vitest": "catalog:",
+        "@executor/platform-sdk-file": "workspace:*",
         "@types/jsdom": "^21.1.7",
         "@types/node": "catalog:",
         "@types/react": "^19.2.10",
         "zod": "catalog:",
       },
     },
+    "packages/platform/sdk-file": {
+      "name": "@executor/platform-sdk-file",
+      "version": "0.0.0",
+      "dependencies": {
+        "@effect/platform": "catalog:",
+        "@effect/platform-node": "catalog:",
+        "@executor/codemode-core": "workspace:*",
+        "@executor/ir": "workspace:*",
+        "@executor/platform-sdk": "workspace:*",
+        "@executor/source-core": "workspace:*",
+        "@executor/source-graphql": "workspace:*",
+        "@executor/source-openapi": "workspace:*",
+        "effect": "catalog:",
+        "jsonc-parser": "3.3.1",
+      },
+      "devDependencies": {
+        "@effect/vitest": "catalog:",
+        "@types/node": "catalog:",
+        "bun-types": "catalog:",
+        "typescript": "^5.9.3",
+        "vitest": "catalog:",
+      },
+    },
     "packages/platform/server": {
       "name": "@executor/server",
       "version": "0.0.0",
         "@executor/platform-api": "workspace:*",
         "@executor/platform-internal": "workspace:*",
         "@executor/platform-sdk": "workspace:*",
+        "@executor/platform-sdk-file": "workspace:*",
         "@opentelemetry/api": "^1.9.0",
         "@opentelemetry/exporter-trace-otlp-grpc": "^0.213.0",
         "@opentelemetry/resources": "^2.6.0",
     "@executor/platform-sdk": ["@executor/platform-sdk@workspace:packages/platform/sdk"],
+    "@executor/platform-sdk-file": ["@executor/platform-sdk-file@workspace:packages/platform/sdk-file"],
     "@executor/react": ["@executor/react@workspace:packages/clients/react"],
     "@executor/runtime-deno-subprocess": ["@executor/runtime-deno-subprocess@workspace:packages/kernel/runtime-deno-subprocess"],

packages/platform/internal/src/tools/executor-admin.ts+28−5

 import {
   ControlPlaneStore,
+  LocalInstanceConfigService,
+  SecretMaterialDeleterService,
+  SecretMaterialStorerService,
+  SecretMaterialUpdaterService,
   type ControlPlaneStoreShape,
   type WorkspaceInternalToolContext,
-  RuntimeLocalWorkspaceState,
   RuntimeSourceAuthService,
   RuntimeSourceCatalogSyncService,
   RuntimeSourceStore,
   RuntimeSourceStoreService,
+} from "@executor/platform-sdk/runtime";
+import {
+  type RuntimeLocalWorkspaceState,
+  provideOptionalRuntimeLocalWorkspace,
+} from "../../../sdk/src/runtime/workspace/runtime-context";
+import {
   SourceArtifactStore,
   type SourceArtifactStoreShape,
   WorkspaceConfigStore,
   WorkspaceStateStore,
   type WorkspaceStateStoreShape,
   makeWorkspaceStorageLayer,
-  provideOptionalRuntimeLocalWorkspace,
+} from "../../../sdk/src/runtime/workspace/storage";
-} from "@executor/platform-sdk/runtime";
 import {
   CreateSecretPayloadSchema,
   CreateSecretResultSchema,
   deleteLocalSecret,
   discoverSource,
   discoverSourceInspectionTools,
-  getLocalInstanceConfig,
   getPolicy,
   getSource,
   getSourceInspection,
   workspaceConfigStore: WorkspaceConfigStoreShape;
   workspaceStateStore: WorkspaceStateStoreShape;
   sourceArtifactStore: SourceArtifactStoreShape;
+  instanceConfigResolver: WorkspaceInternalToolContext["instanceConfigResolver"];
+  storeSecretMaterial: WorkspaceInternalToolContext["storeSecretMaterial"];
+  deleteSecretMaterial: WorkspaceInternalToolContext["deleteSecretMaterial"];
+  updateSecretMaterial: WorkspaceInternalToolContext["updateSecretMaterial"];
 }) =>
   Layer.mergeAll(
     Layer.succeed(ControlPlaneStore, input.controlPlaneStore),
       RuntimeSourceCatalogSyncService,
       input.sourceCatalogSyncService,
     ),
+    Layer.succeed(LocalInstanceConfigService, input.instanceConfigResolver),
+    Layer.succeed(SecretMaterialStorerService, input.storeSecretMaterial),
+    Layer.succeed(SecretMaterialDeleterService, input.deleteSecretMaterial),
+    Layer.succeed(SecretMaterialUpdaterService, input.updateSecretMaterial),
     makeWorkspaceStorageLayer({
       workspaceConfigStore: input.workspaceConfigStore,
       workspaceStateStore: input.workspaceStateStore,
   effect: Effect.Effect<A, E, R>;
   runtimeLayer: Layer.Layer<
     | ControlPlaneStore
+    | LocalInstanceConfigService
     | RuntimeSourceStoreService
     | RuntimeSourceCatalogSyncService
+    | SecretMaterialStorerService
+    | SecretMaterialDeleterService
+    | SecretMaterialUpdaterService
     | WorkspaceConfigStore
     | WorkspaceStateStore
     | SourceArtifactStore,
     workspaceConfigStore: input.workspaceConfigStore,
     workspaceStateStore: input.workspaceStateStore,
     sourceArtifactStore: input.sourceArtifactStore,
+    instanceConfigResolver: input.instanceConfigResolver,
+    storeSecretMaterial: input.storeSecretMaterial,
+    deleteSecretMaterial: input.deleteSecretMaterial,
+    updateSecretMaterial: input.updateSecretMaterial,
   });
   const workspaceStorageLayer = makeWorkspaceStorageLayer({
     workspaceConfigStore: input.workspaceConfigStore,
           "Get local instance config such as supported secret providers.",
         inputSchema: emptyInputSchema,
         outputSchema: instanceConfigOutputSchema,
-        execute: () => Effect.runPromise(getLocalInstanceConfig()),
+        execute: () => Effect.runPromise(input.instanceConfigResolver()),
       },
       metadata,
     }),

packages/platform/sdk-file/package.json+33−0

@@ -0,0 +1,33 @@
	1	{
	2	"name": "@executor/platform-sdk-file",
	3	"private": true,
	4	"type": "module",
	5	"exports": {
	6	".": "./src/index.ts"
	7	},
	8	"scripts": {
	9	"fixture:release:capture": "bun run ./src/capture-release-workspace-fixture.ts",
	10	"test": "vitest run",
	11	"typecheck": "bunx tsc --noEmit -p tsconfig.json"
	12	},
	13	"dependencies": {
	14	"@effect/platform": "catalog:",
	15	"@effect/platform-node": "catalog:",
	16	"@executor/codemode-core": "workspace:*",
	17	"@executor/source-core": "workspace:*",
	18	"@executor/source-graphql": "workspace:*",
	19	"@executor/source-openapi": "workspace:*",
	20	"@executor/ir": "workspace:*",
	21	"@executor/platform-sdk": "workspace:*",
	22	"effect": "catalog:",
	23	"jsonc-parser": "3.3.1"
	24	},
	25	"devDependencies": {
	26	"@effect/vitest": "catalog:",
	27	"@types/node": "catalog:",
	28	"bun-types": "catalog:",
	29	"typescript": "^5.9.3",
	30	"vitest": "catalog:"
	31	},
	32	"version": "0.0.0"
	33	}

packages/platform/sdk-file/src/capture-release-workspace-fixture.tsrenamed from packages/platform/sdk/src/runtime/local/capture-release-workspace-fixture.ts+2−2

@@ -6,7 +6,7 @@ import * as Data from "effect/Data"; · 5 unmodified lines
6	import * as Effect from "effect/Effect";	6	import * as Effect from "effect/Effect";
7	import * as Exit from "effect/Exit";	7	import * as Exit from "effect/Exit";
8		8
9	import type { LocalExecutorConfig } from "#schema";	9	import type { LocalExecutorConfig } from "@executor/platform-sdk/schema";
10		10
11	import {	11	import {
12	readOptionalLocalExecutorConfig,	12	readOptionalLocalExecutorConfig,
@@ -37,7 +37,7 @@ type CaptureReleaseWorkspaceFixtureArgs = { · 24 unmodified lines
37	};	37	};
38		38
39	const usage = `Usage:	39	const usage = `Usage:
40	bun run ./src/runtime/local/capture-release-workspace-fixture.ts \\	40	bun run ./src/capture-release-workspace-fixture.ts \\
41	--workspace-root /path/to/workspace \\	41	--workspace-root /path/to/workspace \\
42	--source-id google-calendar \\	42	--source-id google-calendar \\
43	--release-version v1.2.4-beta.1 \\	43	--release-version v1.2.4-beta.1 \\

packages/platform/sdk-file/src/config.test.tsrenamed from packages/platform/sdk/src/runtime/local/config.test.ts+1−1

@@ -58,7 +58,7 @@ describe("local-config", () => { · 57 unmodified lines
58	"https://api.github.com",	58	"https://api.github.com",
59	);	59	);
60	expect(loaded.config?.runtime).toBe("ses");	60	expect(loaded.config?.runtime).toBe("ses");
61	expect(context.homeStateDirectory).toContain("executor");	61	expect(context.homeStateDirectory.toLowerCase()).toContain("executor");
62	}).pipe(Effect.provide(NodeFileSystem.layer)),	62	}).pipe(Effect.provide(NodeFileSystem.layer)),
63	);	63	);
64		64

packages/platform/sdk-file/src/config.tsrenamed from packages/platform/sdk/src/runtime/local/config.ts+31−30

   type LocalConfigPolicy,
   type LocalConfigSecretProvider,
   type LocalConfigSource,
-} from "#schema";
+} from "@executor/platform-sdk/schema";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
+import type { ExecutorWorkspaceDescriptor } from "@executor/platform-sdk";
+import type { LoadedLocalExecutorConfig } from "../../sdk/src/runtime/workspace-config";
 import {
   LocalExecutorConfigDecodeError,
   LocalFileSystemError,
 const decodeLocalExecutorConfig = Schema.decodeUnknownSync(LocalExecutorConfigSchema);
+export type FileLoadedExecutorConfig = LoadedLocalExecutorConfig & {
+  homeConfigPath: string;
+  projectConfigPath: string;
+};
+export const encodeLocalExecutorConfig = (config: LocalExecutorConfig): string =>
+  `${JSON.stringify(config, null, 2)}\n`;
+export const resolveConfigRelativePath = (input: {
+  path: string;
+  workspaceRoot: string;
+}): string => {
+  const trimmed = input.path.trim();
+  if (trimmed.startsWith("~/")) {
+    return join(homedir(), trimmed.slice(2));
+  }
+  if (trimmed === "~") {
+    return homedir();
+  }
+  if (isAbsolute(trimmed)) {
+    return trimmed;
+  }
+  return resolve(input.workspaceRoot, trimmed);
+};
+export type { LoadedLocalExecutorConfig } from "../../sdk/src/runtime/workspace-config";
 const PROJECT_CONFIG_BASENAME = "executor.jsonc";
 const PROJECT_CONFIG_DIRECTORY = ".executor";
 const EXECUTOR_CONFIG_DIR_ENV = "EXECUTOR_CONFIG_DIR";
   stateDirectory: string;
 };
-export type LoadedLocalExecutorConfig = {
-  config: LocalExecutorConfig | null;
-  homeConfig: LocalExecutorConfig | null;
-  projectConfig: LocalExecutorConfig | null;
-  homeConfigPath: string;
-  projectConfigPath: string;
-};
 export const resolveLocalWorkspaceContext = (input: {
   cwd?: string;
   workspaceRoot?: string;
 export const loadLocalExecutorConfig = (
   context: ResolvedLocalWorkspaceContext,
 ): Effect.Effect<
-  LoadedLocalExecutorConfig,
+  FileLoadedExecutorConfig,
   LocalFileSystemError | LocalExecutorConfigDecodeError,
   FileSystem.FileSystem
 > =>
     };
   });
-export const encodeLocalExecutorConfig = (config: LocalExecutorConfig): string =>
-  `${JSON.stringify(config, null, 2)}\n`;
 export const writeProjectLocalExecutorConfig = (input: {
   context: ResolvedLocalWorkspaceContext;
   config: LocalExecutorConfig;
     );
   });
-export const resolveConfigRelativePath = (input: {
-  path: string;
-  workspaceRoot: string;
-}): string => {
-  const trimmed = input.path.trim();
-  if (trimmed.startsWith("~/")) {
-    return join(homedir(), trimmed.slice(2));
-  }
-  if (trimmed === "~") {
-    return homedir();
-  }
-  if (isAbsolute(trimmed)) {
-    return trimmed;
-  }
-  return resolve(input.workspaceRoot, trimmed);
-};
 export const defaultWorkspaceDisplayName = (context: ResolvedLocalWorkspaceContext): string =>
   trimOrUndefined(context.workspaceName) ?? "workspace";

packages/platform/sdk-file/src/control-plane-store.test.tsrenamed from packages/platform/sdk/src/runtime/local/control-plane-store.test.ts+0−0

File renamed without changes.

packages/platform/sdk-file/src/control-plane-store.tsrenamed from packages/platform/sdk/src/runtime/local/control-plane-store.ts+1−1

@@ -24,7 +24,7 @@ import { · 23 unmodified lines
24	WorkspaceOauthClientSchema,	24	WorkspaceOauthClientSchema,
25	type WorkspaceSourceOauthClient,	25	type WorkspaceSourceOauthClient,
26	WorkspaceSourceOauthClientSchema,	26	WorkspaceSourceOauthClientSchema,
27	} from "#schema";	27	} from "@executor/platform-sdk/schema";
28	import * as Effect from "effect/Effect";	28	import * as Effect from "effect/Effect";
29	import * as Option from "effect/Option";	29	import * as Option from "effect/Option";
30	import * as Schema from "effect/Schema";	30	import * as Schema from "effect/Schema";

packages/platform/sdk-file/src/errors.tsrenamed from packages/platform/sdk/src/runtime/local/errors.ts+0−0

File renamed without changes.

packages/platform/sdk-file/src/index.ts+364−0

@@ -0,0 +1,364 @@
	1	import { FileSystem } from "@effect/platform";
	2	import { NodeFileSystem } from "@effect/platform-node";
	3	import {
	4	createExecutor,
	5	createExecutorEffect,
	6	type CreateExecutorOptions,
	7	type Executor,
	8	type ExecutorBackend,
	9	type ExecutorBackendServices,
	10	type ExecutorRuntimeOptions,
	11	type ExecutorWorkspaceDescriptor,
	12	} from "@executor/platform-sdk";
	13	import type {
	14	LocalExecutorConfig,
	15	LocalInstallation,
	16	} from "@executor/platform-sdk/schema";
	17	import {
	18	type RuntimeControlPlaneOptions,
	19	type ControlPlaneRuntime,
	20	type ResolveSecretMaterial,
	21	createControlPlaneRuntimeFromServices,
	22	} from "@executor/platform-sdk/runtime";
	23	import * as Effect from "effect/Effect";
	24	import type { LocalToolRuntime } from "../../sdk/src/runtime/local-tool-runtime";
	25	import {
	26	type LoadedLocalExecutorConfig,
	27	type ResolvedLocalWorkspaceContext,
	28	loadLocalExecutorConfig,
	29	resolveConfigRelativePath,
	30	resolveLocalWorkspaceContext,
	31	writeProjectLocalExecutorConfig,
	32	} from "./config";
	33	import { createLocalControlPlanePersistence } from "./control-plane-store";
	34	import {
	35	createDefaultSecretMaterialDeleter,
	36	createLocalInstanceConfigResolver,
	37	createDefaultSecretMaterialResolver,
	38	createDefaultSecretMaterialStorer,
	39	createDefaultSecretMaterialUpdater,
	40	} from "./secret-material-providers";
	41	import {
	42	buildLocalSourceArtifact,
	43	readLocalSourceArtifact,
	44	removeLocalSourceArtifact,
	45	writeLocalSourceArtifact,
	46	} from "./source-artifacts";
	47	import {
	48	getOrProvisionLocalInstallation,
	49	loadLocalInstallation,
	50	} from "./installation";
	51	import {
	52	loadLocalToolRuntime,
	53	} from "./tools";
	54	import {
	55	loadLocalWorkspaceState,
	56	writeLocalWorkspaceState,
	57	} from "./workspace-state";
	58	import {
	59	refreshSourceTypeDeclarationInBackground,
	60	refreshWorkspaceSourceTypeDeclarationsInBackground,
	61	} from "./source-type-declarations";
	62
	63	const toError = (cause: unknown): Error =>
	64	cause instanceof Error ? cause : new Error(String(cause));
	65
	66	const bindFileSystem = <A, E>(
	67	fileSystem: FileSystem.FileSystem,
	68	effect: Effect.Effect<A, E, FileSystem.FileSystem>,
	69	): Effect.Effect<A, E, never> =>
	70	effect.pipe(Effect.provideService(FileSystem.FileSystem, fileSystem));
	71
	72	export type CreateLocalExecutorBackendOptions = {
	73	cwd?: string;
	74	workspaceRoot?: string;
	75	homeConfigPath?: string;
	76	homeStateDirectory?: string;
	77	localDataDir?: string;
	78	};
	79
	80	type CreateLocalRuntimeOptions = CreateLocalExecutorBackendOptions &
	81	RuntimeControlPlaneOptions;
	82
	83	type LocalWorkspaceState = Parameters<
	84	typeof writeLocalWorkspaceState
	85	>[0]["state"];
	86
	87	type LocalSourceArtifact = Parameters<
	88	typeof writeLocalSourceArtifact
	89	>[0]["artifact"];
	90
	91	const createBoundInstallationStore = (
	92	context: ResolvedLocalWorkspaceContext,
	93	): {
	94	load: () => Effect.Effect<LocalInstallation, Error, never>;
	95	getOrProvision: () => Effect.Effect<LocalInstallation, Error, never>;
	96	} => ({
	97	load: () => loadLocalInstallation(context).pipe(Effect.mapError(toError)),
	98	getOrProvision: () =>
	99	getOrProvisionLocalInstallation({ context }).pipe(
	100	Effect.mapError(toError),
	101	),
	102	});
	103
	104	const createBoundWorkspaceConfigStore = (
	105	context: ResolvedLocalWorkspaceContext,
	106	fileSystem: FileSystem.FileSystem,
	107	): {
	108	load: () => Effect.Effect<LoadedLocalExecutorConfig, Error, never>;
	109	writeProject: (config: LocalExecutorConfig) => Effect.Effect<void, Error, never>;
	110	resolveRelativePath: typeof resolveConfigRelativePath;
	111	} => ({
	112	load: () =>
	113	bindFileSystem(fileSystem, loadLocalExecutorConfig(context)).pipe(
	114	Effect.mapError(toError),
	115	),
	116	writeProject: (config) =>
	117	bindFileSystem(
	118	fileSystem,
	119	writeProjectLocalExecutorConfig({ context, config }),
	120	).pipe(Effect.mapError(toError)),
	121	resolveRelativePath: resolveConfigRelativePath,
	122	});
	123
	124	const createBoundWorkspaceStateStore = (
	125	context: ResolvedLocalWorkspaceContext,
	126	fileSystem: FileSystem.FileSystem,
	127	): {
	128	load: () => Effect.Effect<LocalWorkspaceState, Error, never>;
	129	write: (state: LocalWorkspaceState) => Effect.Effect<void, Error, never>;
	130	} => ({
	131	load: () =>
	132	bindFileSystem(fileSystem, loadLocalWorkspaceState(context)).pipe(
	133	Effect.mapError(toError),
	134	),
	135	write: (state) =>
	136	bindFileSystem(
	137	fileSystem,
	138	writeLocalWorkspaceState({ context, state }),
	139	).pipe(Effect.mapError(toError)),
	140	});
	141
	142	const createBoundSourceArtifactStore = (
	143	context: ResolvedLocalWorkspaceContext,
	144	fileSystem: FileSystem.FileSystem,
	145	): {
	146	build: typeof buildLocalSourceArtifact;
	147	read: (sourceId: string) => Effect.Effect<LocalSourceArtifact \| null, Error, never>;
	148	write: (input: {
	149	sourceId: string;
	150	artifact: LocalSourceArtifact;
	151	}) => Effect.Effect<void, Error, never>;
	152	remove: (sourceId: string) => Effect.Effect<void, Error, never>;
	153	} => ({
	154	build: buildLocalSourceArtifact,
	155	read: (sourceId) =>
	156	bindFileSystem(
	157	fileSystem,
	158	readLocalSourceArtifact({ context, sourceId }),
	159	).pipe(Effect.mapError(toError)),
	160	write: ({ sourceId, artifact }) =>
	161	bindFileSystem(
	162	fileSystem,
	163	writeLocalSourceArtifact({ context, sourceId, artifact }),
	164	).pipe(Effect.mapError(toError)),
	165	remove: (sourceId) =>
	166	bindFileSystem(
	167	fileSystem,
	168	removeLocalSourceArtifact({ context, sourceId }),
	169	).pipe(Effect.mapError(toError)),
	170	});
	171
	172	const createBoundLocalToolRuntimeLoader = (
	173	context: ResolvedLocalWorkspaceContext,
	174	fileSystem: FileSystem.FileSystem,
	175	): ExecutorBackendServices["localToolRuntimeLoader"] => ({
	176	load: () =>
	177	bindFileSystem(fileSystem, loadLocalToolRuntime(context)),
	178	});
	179
	180	const createBoundSourceTypeDeclarationsRefresher = (
	181	context: ResolvedLocalWorkspaceContext,
	182	): NonNullable<ExecutorBackendServices["sourceTypeDeclarationsRefresher"]> => ({
	183	refreshWorkspaceInBackground: ({ entries }) =>
	184	Effect.sync(() => {
	185	refreshWorkspaceSourceTypeDeclarationsInBackground({
	186	context,
	187	entries,
	188	});
	189	}),
	190	refreshSourceInBackground: ({ source, snapshot }) =>
	191	Effect.sync(() => {
	192	refreshSourceTypeDeclarationInBackground({
	193	context,
	194	source,
	195	snapshot,
	196	});
	197	}),
	198	});
	199
	200	const toExecutorWorkspaceContext = (
	201	context: ResolvedLocalWorkspaceContext,
	202	): ExecutorWorkspaceDescriptor => ({
	203	workspaceName: context.workspaceName,
	204	workspaceRoot: context.workspaceRoot,
	205	metadata: {
	206	kind: "file",
	207	configDirectory: context.configDirectory,
	208	projectConfigPath: context.projectConfigPath,
	209	homeConfigPath: context.homeConfigPath,
	210	homeStateDirectory: context.homeStateDirectory,
	211	artifactsDirectory: context.artifactsDirectory,
	212	stateDirectory: context.stateDirectory,
	213	},
	214	});
	215
	216	export const createLocalExecutorServicesEffect = (
	217	options: CreateLocalExecutorBackendOptions = {},
	218	runtimeOptions: RuntimeControlPlaneOptions = {},
	219	): Effect.Effect<ExecutorBackendServices, Error> =>
	220	Effect.gen(function* () {
	221	const fileSystem = yield* FileSystem.FileSystem;
	222	const workspaceContext = yield* bindFileSystem(
	223	fileSystem,
	224	resolveLocalWorkspaceContext({
	225	cwd: options.cwd,
	226	workspaceRoot: options.workspaceRoot,
	227	homeConfigPath: options.homeConfigPath,
	228	homeStateDirectory: options.homeStateDirectory,
	229	}),
	230	).pipe(Effect.mapError(toError));
	231
	232	const persistence = createLocalControlPlanePersistence(
	233	workspaceContext,
	234	fileSystem,
	235	);
	236	const workspaceConfigStore = createBoundWorkspaceConfigStore(
	237	workspaceContext,
	238	fileSystem,
	239	);
	240	const loadedConfig = yield* workspaceConfigStore.load();
	241	const resolveSecretMaterial: ResolveSecretMaterial =
	242	runtimeOptions.resolveSecretMaterial
	243	?? createDefaultSecretMaterialResolver({
	244	rows: persistence.rows,
	245	localConfig: loadedConfig.config,
	246	workspaceRoot: workspaceContext.workspaceRoot,
	247	});
	248
	249	return {
	250	workspace: toExecutorWorkspaceContext(workspaceContext),
	251	installationStore: createBoundInstallationStore(workspaceContext),
	252	workspaceConfigStore,
	253	workspaceStateStore: createBoundWorkspaceStateStore(
	254	workspaceContext,
	255	fileSystem,
	256	),
	257	sourceArtifactStore: createBoundSourceArtifactStore(
	258	workspaceContext,
	259	fileSystem,
	260	),
	261	localToolRuntimeLoader: createBoundLocalToolRuntimeLoader(
	262	workspaceContext,
	263	fileSystem,
	264	),
	265	sourceTypeDeclarationsRefresher:
	266	createBoundSourceTypeDeclarationsRefresher(workspaceContext),
	267	secretMaterial: {
	268	resolve: resolveSecretMaterial,
	269	store: createDefaultSecretMaterialStorer({
	270	rows: persistence.rows,
	271	}),
	272	delete: createDefaultSecretMaterialDeleter({
	273	rows: persistence.rows,
	274	}),
	275	update: createDefaultSecretMaterialUpdater({
	276	rows: persistence.rows,
	277	}),
	278	},
	279	instanceConfig: {
	280	resolve: createLocalInstanceConfigResolver(),
	281	},
	282	persistence,
	283	} satisfies ExecutorBackendServices;
	284	}).pipe(Effect.provide(NodeFileSystem.layer));
	285
	286	export const createLocalExecutorBackend = (
	287	options: CreateLocalExecutorBackendOptions = {},
	288	): ExecutorBackend => ({
	289	createRuntime: (runtimeOptions) =>
	290	Effect.flatMap(
	291	createLocalExecutorServicesEffect(options, runtimeOptions),
	292	(services) =>
	293	createControlPlaneRuntimeFromServices({
	294	...runtimeOptions,
	295	services,
	296	}),
	297	).pipe(Effect.provide(NodeFileSystem.layer)),
	298	});
	299
	300	export const createLocalControlPlaneRuntime = (
	301	options: CreateLocalRuntimeOptions = {},
	302	): Effect.Effect<ControlPlaneRuntime, Error> =>
	303	Effect.flatMap(
	304	createLocalExecutorServicesEffect(options, options),
	305	(services) =>
	306	createControlPlaneRuntimeFromServices({
	307	executionResolver: options.executionResolver,
	308	createInternalToolMap: options.createInternalToolMap,
	309	resolveSecretMaterial: options.resolveSecretMaterial,
	310	getLocalServerBaseUrl: options.getLocalServerBaseUrl,
	311	services,
	312	}),
	313	).pipe(Effect.provide(NodeFileSystem.layer));
	314
	315	export const createLocalExecutorEffect = (
	316	options: CreateLocalExecutorBackendOptions & ExecutorRuntimeOptions = {},
	317	): Effect.Effect<Executor, Error> =>
	318	createExecutorEffect({
	319	backend: createLocalExecutorBackend(options),
	320	executionResolver: options.executionResolver,
	321	createInternalToolMap: options.createInternalToolMap,
	322	resolveSecretMaterial: options.resolveSecretMaterial,
	323	getLocalServerBaseUrl: options.getLocalServerBaseUrl,
	324	} satisfies CreateExecutorOptions);
	325
	326	export const createLocalExecutor = (
	327	options: CreateLocalExecutorBackendOptions & ExecutorRuntimeOptions = {},
	328	): Promise<Executor> => Effect.runPromise(createLocalExecutorEffect(options));
	329
	330	export {
	331	deriveLocalInstallation,
	332	getOrProvisionLocalInstallation,
	333	loadLocalInstallation,
	334	} from "./installation";
	335	export {
	336	loadLocalControlPlaneState,
	337	writeLocalControlPlaneState,
	338	} from "./control-plane-store";
	339	export {
	340	loadLocalExecutorConfig,
	341	resolveConfigRelativePath,
	342	resolveLocalWorkspaceContext,
	343	writeProjectLocalExecutorConfig,
	344	} from "./config";
	345	export {
	346	loadLocalWorkspaceState,
	347	writeLocalWorkspaceState,
	348	} from "./workspace-state";
	349	export {
	350	buildLocalSourceArtifact,
	351	readLocalSourceArtifact,
	352	removeLocalSourceArtifact,
	353	writeLocalSourceArtifact,
	354	} from "./source-artifacts";
	355	export {
	356	refreshSourceTypeDeclarationInBackground,
	357	refreshWorkspaceSourceTypeDeclarationsInBackground,
	358	syncSourceTypeDeclarationNode,
	359	syncWorkspaceSourceTypeDeclarationsNode,
	360	} from "./source-type-declarations";
	361	export type {
	362	LoadedLocalExecutorConfig,
	363	ResolvedLocalWorkspaceContext,
	364	} from "./config";

packages/platform/sdk-file/src/installation.test.tsrenamed from packages/platform/sdk/src/runtime/local/installation.test.ts+1−1

@@ -5,7 +5,7 @@ import { NodeFileSystem } from "@effect/platform-node"; · 4 unmodified lines
5	import { describe, expect, it } from "@effect/vitest";	5	import { describe, expect, it } from "@effect/vitest";
6	import * as Effect from "effect/Effect";	6	import * as Effect from "effect/Effect";
7		7
8	import { createLocalControlPlaneRuntime as createControlPlaneRuntime } from "../../../../sdk-file/src/index";	8	import { createLocalControlPlaneRuntime as createControlPlaneRuntime } from "./index";
9	import { getOrProvisionLocalInstallation } from "./installation";	9	import { getOrProvisionLocalInstallation } from "./installation";
10	import { resolveLocalWorkspaceContext } from "./config";	10	import { resolveLocalWorkspaceContext } from "./config";
11		11

packages/platform/sdk-file/src/installation.tsrenamed from packages/platform/sdk/src/runtime/local/installation.ts+1−1

@@ -4,7 +4,7 @@ import { · 3 unmodified lines
4	AccountIdSchema,	4	AccountIdSchema,
5	WorkspaceIdSchema,	5	WorkspaceIdSchema,
6	type LocalInstallation,	6	type LocalInstallation,
7	} from "#schema";	7	} from "@executor/platform-sdk/schema";
8	import * as Effect from "effect/Effect";	8	import * as Effect from "effect/Effect";
9		9
10	import type { ResolvedLocalWorkspaceContext } from "./config";	10	import type { ResolvedLocalWorkspaceContext } from "./config";

packages/platform/sdk-file/src/release-upgrade-fixtures.tsrenamed from packages/platform/sdk/src/runtime/local/release-upgrade-fixtures.ts+1−1

@@ -28,7 +28,7 @@ export type ReleaseWorkspaceFixture = ReleaseWorkspaceFixtureManifest & { · 27 unmodified lines
28	};	28	};
29		29
30	export const releaseWorkspaceFixturesRoot = fileURLToPath(	30	export const releaseWorkspaceFixturesRoot = fileURLToPath(
31	new URL("../__fixtures__", import.meta.url),	31	new URL("../../sdk/src/runtime/__fixtures__", import.meta.url),
32	);	32	);
33		33
34	const decodeReleaseWorkspaceFixtureManifest = Schema.decodeUnknownSync(	34	const decodeReleaseWorkspaceFixtureManifest = Schema.decodeUnknownSync(

packages/platform/sdk-file/src/secret-material-providers.tsrenamed from packages/platform/sdk/src/runtime/local/secret-material-providers.ts+67−64

 import {
   type LocalConfigSecretProvider,
   type LocalExecutorConfig,
-  type SecretMaterial,
   type SecretMaterialPurpose,
-  SecretMaterialIdSchema,
   type SecretRef,
-} from "#schema";
+  type SecretMaterial,
-import * as Context from "effect/Context";
+  SecretMaterialIdSchema,
+} from "@executor/platform-sdk/schema";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
+import {
+  LocalInstanceConfigService,
+  SecretMaterialDeleterService,
+  SecretMaterialResolverService,
+  SecretMaterialStorerService,
+  SecretMaterialUpdaterService,
+  type ResolveSecretMaterial,
+  type ResolveInstanceConfig,
+  type SecretMaterialResolveContext,
+  type StoreSecretMaterial,
+  type DeleteSecretMaterial,
+  type UpdateSecretMaterial,
+} from "../../sdk/src/runtime/workspace/secret-material-providers";
+import { fromConfigSecretProviderId } from "../../sdk/src/runtime/workspace/config-secrets";
+import { getRuntimeLocalWorkspaceOption } from "../../sdk/src/runtime/workspace/runtime-context";
+import { ControlPlaneStore } from "../../sdk/src/runtime/store";
+import type { ControlPlaneStoreShape } from "../../sdk/src/runtime/store";
+import { runtimeEffectError } from "../../sdk/src/runtime/effect-errors";
 import { resolveConfigRelativePath } from "./config";
-import { fromConfigSecretProviderId } from "./config-secrets";
-import { getRuntimeLocalWorkspaceOption } from "./runtime-context";
-import { ControlPlaneStore } from "../store";
-import type { ControlPlaneStoreShape } from "../store";
-import { runtimeEffectError } from "../effect-errors";
 export const ENV_SECRET_PROVIDER_ID = "env";
 export const PARAMS_SECRET_PROVIDER_ID = "params";
   | typeof KEYCHAIN_SECRET_PROVIDER_ID
   | typeof LOCAL_SECRET_PROVIDER_ID;
-export type SecretMaterialResolveContext = {
-  params?: Readonly<Record<string, string | undefined>>;
-};
-export type ResolveSecretMaterial = (input: {
-  ref: SecretRef;
-  context?: SecretMaterialResolveContext;
-}) => Effect.Effect<string, Error, never>;
-export type StoreSecretMaterial = (input: {
-  purpose: SecretMaterialPurpose;
-  value: string;
-  name?: string | null;
-}) => Effect.Effect<SecretRef, Error, never>;
-export type DeleteSecretMaterial = (
-  ref: SecretRef,
-) => Effect.Effect<boolean, Error, never>;
-export type UpdateSecretMaterial = (input: {
-  ref: SecretRef;
-  name?: string | null;
-  value?: string;
-}) => Effect.Effect<{
-  id: string;
-  providerId: string;
-  name: string | null;
-  purpose: string;
-  createdAt: number;
-  updatedAt: number;
-}, Error, never>;
-export class SecretMaterialResolverService extends Context.Tag(
-  "#runtime/SecretMaterialResolverService",
-)<SecretMaterialResolverService, ResolveSecretMaterial>() {}
-export class SecretMaterialStorerService extends Context.Tag(
-  "#runtime/SecretMaterialStorerService",
-)<SecretMaterialStorerService, StoreSecretMaterial>() {}
-export class SecretMaterialDeleterService extends Context.Tag(
-  "#runtime/SecretMaterialDeleterService",
-)<SecretMaterialDeleterService, DeleteSecretMaterial>() {}
-export class SecretMaterialUpdaterService extends Context.Tag(
-  "#runtime/SecretMaterialUpdaterService",
-)<SecretMaterialUpdaterService, UpdateSecretMaterial>() {}
 type SecretMaterialProviderRuntime = {
   rows: ControlPlaneStoreShape;
   env: NodeJS.ProcessEnv;
 export const createDefaultSecretMaterialStorer = (input: {
   rows: ControlPlaneStoreShape;
-  storeProviderId?: SecretStoreProviderId;
   dangerouslyAllowEnvSecrets?: boolean;
   keychainServiceName?: string;
 }): StoreSecretMaterial => {
   const providers = createSecretMaterialProviderRegistry();
   const runtime = createSecretMaterialProviderRuntime(input);
-  return ({ purpose, value, name }) =>
+  return ({ purpose, value, name, providerId }) =>
     Effect.gen(function* () {
       const defaultStoreProviderId = yield* resolveDefaultSecretStoreProviderId({
-        storeProviderId: input.storeProviderId,
+        storeProviderId: parseSecretStoreProviderId(providerId) ?? undefined,
         env: runtime.env,
       });
       const provider = yield* getSecretMaterialProvider({
         ?? runtimeLocalWorkspace?.loadedConfig.config
         ?? null,
       workspaceRoot: input.workspaceRoot
-        ?? runtimeLocalWorkspace?.context.workspaceRoot
+        ?? runtimeLocalWorkspace?.workspace.workspaceRoot
         ?? null,
     };
   });
       );
 export const SecretMaterialStorerLive = (input: {
-  storeProviderId?: SecretStoreProviderId;
   dangerouslyAllowEnvSecrets?: boolean;
   keychainServiceName?: string;
 } = {}) =>
       return createDefaultSecretMaterialStorer({
         rows,
-        storeProviderId: input.storeProviderId,
         dangerouslyAllowEnvSecrets: input.dangerouslyAllowEnvSecrets,
         keychainServiceName: input.keychainServiceName,
       });
 export const SecretMaterialLive = (input: {
   resolveSecretMaterial?: ResolveSecretMaterial;
-  storeProviderId?: SecretStoreProviderId;
   dangerouslyAllowEnvSecrets?: boolean;
   keychainServiceName?: string;
   localConfig?: LocalExecutorConfig | null;
     SecretMaterialDeleterLive(input),
     SecretMaterialUpdaterLive(input),
   );
+export const createLocalInstanceConfigResolver = (): ResolveInstanceConfig => () => {
+  const explicitDefaultStoreProvider = parseSecretStoreProviderId(
+    process.env[SECRET_STORE_PROVIDER_ENV],
+  );
+  const providers = [
+    {
+      id: LOCAL_SECRET_PROVIDER_ID,
+      name: "Local store",
+      canStore: true,
+    },
+  ];
+  if (process.platform === "darwin" || process.platform === "linux") {
+    providers.push({
+      id: KEYCHAIN_SECRET_PROVIDER_ID,
+      name:
+        process.platform === "darwin" ? "macOS Keychain" : "Desktop Keyring",
+      canStore:
+        process.platform === "darwin" ||
+        explicitDefaultStoreProvider === KEYCHAIN_SECRET_PROVIDER_ID,
+    });
+  }
+  providers.push({
+    id: ENV_SECRET_PROVIDER_ID,
+    name: "Environment variable",
+    canStore: false,
+  });
+  return resolveDefaultSecretStoreProviderId({
+    storeProviderId: explicitDefaultStoreProvider ?? undefined,
+  }).pipe(
+    Effect.map((resolvedDefaultStoreProvider) => ({
+      platform: process.platform,
+      secretProviders: providers,
+      defaultSecretStoreProvider: resolvedDefaultStoreProvider,
+    })),
+  );
+};
+export const LocalInstanceConfigLive = () =>
+  Layer.succeed(LocalInstanceConfigService, createLocalInstanceConfigResolver());

packages/platform/sdk-file/src/source-artifacts.test.tsrenamed from packages/platform/sdk/src/runtime/local/source-artifacts.test.ts+6−2

 import { describe, expect, it } from "@effect/vitest";
 import * as Effect from "effect/Effect";
-import { SourceIdSchema, WorkspaceIdSchema, type Source } from "#schema";
+import {
+  SourceIdSchema,
+  WorkspaceIdSchema,
+  type Source,
+} from "@executor/platform-sdk/schema";
 import {
   buildLocalSourceArtifact,
     documents: [
       {
         documentKind: "openapi",
-        documentKey: source.binding.specUrl,
+        documentKey: String(source.binding.specUrl),
         contentText: '{"openapi":"3.1.0"}',
         fetchedAt: 1,
       },

packages/platform/sdk-file/src/source-artifacts.ts+172−0

@@ -0,0 +1,172 @@
	1	import { join } from "node:path";
	2	import { FileSystem } from "@effect/platform";
	3
	4	import type { NativeBlob } from "@executor/ir/model";
	5	import * as Effect from "effect/Effect";
	6	import type { Source } from "@executor/platform-sdk/schema";
	7	import type { SourceCatalogSyncResult } from "@executor/source-core";
	8	import {
	9	buildLocalSourceArtifact,
	10	decodeStoredLocalSourceArtifact,
	11	hydrateLocalSourceArtifactDocuments,
	12	splitLocalSourceArtifactDocuments,
	13	type LocalSourceArtifact,
	14	} from "../../sdk/src/runtime/source-artifacts";
	15	import type { ResolvedLocalWorkspaceContext } from "./config";
	16	import {
	17	LocalFileSystemError,
	18	unknownLocalErrorDetails,
	19	} from "./errors";
	20
	21	const mapFileSystemError = (path: string, action: string) => (cause: unknown) =>
	22	new LocalFileSystemError({
	23	message: `Failed to ${action} ${path}: ${unknownLocalErrorDetails(cause)}`,
	24	action,
	25	path,
	26	details: unknownLocalErrorDetails(cause),
	27	});
	28
	29	const localSourceArtifactPath = (input: {
	30	context: ResolvedLocalWorkspaceContext;
	31	sourceId: string;
	32	}): string =>
	33	join(input.context.artifactsDirectory, "sources", `${input.sourceId}.json`);
	34
	35	const localSourceDocumentDirectory = (input: {
	36	context: ResolvedLocalWorkspaceContext;
	37	sourceId: string;
	38	}): string =>
	39	join(input.context.artifactsDirectory, "sources", input.sourceId, "documents");
	40
	41	const localSourceDocumentPath = (input: {
	42	context: ResolvedLocalWorkspaceContext;
	43	sourceId: string;
	44	documentId: string;
	45	}): string =>
	46	join(localSourceDocumentDirectory(input), `${input.documentId}.txt`);
	47
	48	export { buildLocalSourceArtifact };
	49	export type { LocalSourceArtifact };
	50
	51	export const readLocalSourceArtifact = (input: {
	52	context: ResolvedLocalWorkspaceContext;
	53	sourceId: string;
	54	}): Effect.Effect<
	55	LocalSourceArtifact \| null,
	56	LocalFileSystemError,
	57	FileSystem.FileSystem
	58	> =>
	59	Effect.gen(function* () {
	60	const fs = yield* FileSystem.FileSystem;
	61	const path = localSourceArtifactPath(input);
	62	const exists = yield* fs.exists(path).pipe(
	63	Effect.mapError(mapFileSystemError(path, "check source artifact path")),
	64	);
	65	if (!exists) {
	66	return null;
	67	}
	68
	69	const content = yield* fs.readFileString(path, "utf8").pipe(
	70	Effect.mapError(mapFileSystemError(path, "read source artifact")),
	71	);
	72	const decodedSnapshotArtifact = decodeStoredLocalSourceArtifact(content);
	73	if (decodedSnapshotArtifact === null) {
	74	return null;
	75	}
	76
	77	const rawDocuments: Record<string, NativeBlob> = {};
	78	for (const documentId of Object.keys(decodedSnapshotArtifact.snapshot.catalog.documents)) {
	79	const sourceDocumentPath = localSourceDocumentPath({
	80	context: input.context,
	81	sourceId: input.sourceId,
	82	documentId,
	83	});
	84	const sourceDocumentExists = yield* fs.exists(sourceDocumentPath).pipe(
	85	Effect.mapError(mapFileSystemError(sourceDocumentPath, "check source document path")),
	86	);
	87	if (!sourceDocumentExists) {
	88	continue;
	89	}
	90
	91	const sourceContent = yield* fs.readFileString(sourceDocumentPath, "utf8").pipe(
	92	Effect.mapError(mapFileSystemError(sourceDocumentPath, "read source document")),
	93	);
	94	rawDocuments[documentId] = {
	95	sourceKind: decodedSnapshotArtifact.snapshot.import.sourceKind,
	96	kind: "source_document",
	97	value: sourceContent,
	98	} satisfies NativeBlob;
	99	}
	100
	101	return Object.keys(rawDocuments).length > 0
	102	? hydrateLocalSourceArtifactDocuments({
	103	artifact: decodedSnapshotArtifact,
	104	rawDocuments,
	105	})
	106	: decodedSnapshotArtifact;
	107	});
	108
	109	export const writeLocalSourceArtifact = (input: {
	110	context: ResolvedLocalWorkspaceContext;
	111	sourceId: string;
	112	artifact: LocalSourceArtifact;
	113	}): Effect.Effect<void, LocalFileSystemError, FileSystem.FileSystem> =>
	114	Effect.gen(function* () {
	115	const fs = yield* FileSystem.FileSystem;
	116	const directory = join(input.context.artifactsDirectory, "sources");
	117	const path = localSourceArtifactPath(input);
	118	const sourceDocumentDirectory = localSourceDocumentDirectory(input);
	119	const split = splitLocalSourceArtifactDocuments(input.artifact);
	120
	121	yield* fs.makeDirectory(directory, { recursive: true }).pipe(
	122	Effect.mapError(mapFileSystemError(directory, "create source artifact directory")),
	123	);
	124	yield* fs.remove(sourceDocumentDirectory, { recursive: true, force: true }).pipe(
	125	Effect.mapError(
	126	mapFileSystemError(sourceDocumentDirectory, "remove source document directory"),
	127	),
	128	);
	129	if (split.rawDocuments.length > 0) {
	130	yield* fs.makeDirectory(sourceDocumentDirectory, { recursive: true }).pipe(
	131	Effect.mapError(
	132	mapFileSystemError(sourceDocumentDirectory, "create source document directory"),
	133	),
	134	);
	135	for (const rawDocument of split.rawDocuments) {
	136	const sourceDocumentPath = localSourceDocumentPath({
	137	context: input.context,
	138	sourceId: input.sourceId,
	139	documentId: rawDocument.documentId,
	140	});
	141	yield* fs.writeFileString(sourceDocumentPath, rawDocument.content).pipe(
	142	Effect.mapError(mapFileSystemError(sourceDocumentPath, "write source document")),
	143	);
	144	}
	145	}
	146	yield* fs.writeFileString(path, `${JSON.stringify(split.artifact)}\n`).pipe(
	147	Effect.mapError(mapFileSystemError(path, "write source artifact")),
	148	);
	149	});
	150
	151	export const removeLocalSourceArtifact = (input: {
	152	context: ResolvedLocalWorkspaceContext;
	153	sourceId: string;
	154	}): Effect.Effect<void, LocalFileSystemError, FileSystem.FileSystem> =>
	155	Effect.gen(function* () {
	156	const fs = yield* FileSystem.FileSystem;
	157	const path = localSourceArtifactPath(input);
	158	const exists = yield* fs.exists(path).pipe(
	159	Effect.mapError(mapFileSystemError(path, "check source artifact path")),
	160	);
	161	if (exists) {
	162	yield* fs.remove(path).pipe(
	163	Effect.mapError(mapFileSystemError(path, "remove source artifact")),
	164	);
	165	}
	166	const sourceDocumentDirectory = localSourceDocumentDirectory(input);
	167	yield* fs.remove(sourceDocumentDirectory, { recursive: true, force: true }).pipe(
	168	Effect.mapError(
	169	mapFileSystemError(sourceDocumentDirectory, "remove source document directory"),
	170	),
	171	);
	172	});

packages/platform/sdk-file/src/source-type-declarations.test.tsrenamed from packages/platform/sdk/src/runtime/catalog/source/type-declarations.test.ts+6−2

 import { describe, expect, it } from "@effect/vitest";
 import * as Effect from "effect/Effect";
-import { SourceIdSchema, WorkspaceIdSchema, type Source } from "#schema";
+import {
+  SourceIdSchema,
+  WorkspaceIdSchema,
+  type Source,
+} from "@executor/platform-sdk/schema";
 import {
   createCatalogSnapshotV1,
   ShapeSymbolIdSchema,
 } from "@executor/ir/ids";
 import type { CatalogV1, ProvenanceRef } from "@executor/ir/model";
-import { syncWorkspaceSourceTypeDeclarationsNode } from "./type-declarations";
+import { syncWorkspaceSourceTypeDeclarationsNode } from "./source-type-declarations";
 const put = <K extends string, V>(record: Record<K, V>, key: K, value: V) => {
   record[key] = value;

packages/platform/sdk-file/src/source-type-declarations.ts+427−0

@@ -0,0 +1,427 @@
	1	import { join } from "node:path";
	2	import { FileSystem } from "@effect/platform";
	3	import { NodeFileSystem } from "@effect/platform-node";
	4	import type { Source } from "@executor/platform-sdk/schema";
	5	import * as Cause from "effect/Cause";
	6	import * as Effect from "effect/Effect";
	7	import * as Fiber from "effect/Fiber";
	8	import type { CatalogSnapshotV1 } from "@executor/ir/model";
	9
	10	import { projectCatalogForAgentSdk } from "@executor/ir/catalog";
	11	import {
	12	createCatalogTypeProjector,
	13	formatPropertyKey,
	14	joinTypeNameSegments,
	15	projectedCatalogTypeRoots,
	16	shapeAllowsOmittedArgs,
	17	} from "../../sdk/src/runtime/catalog/catalog-typescript";
	18	import type { ResolvedLocalWorkspaceContext } from "./config";
	19	import {
	20	LocalFileSystemError,
	21	unknownLocalErrorDetails,
	22	} from "./errors";
	23
	24	type SourceDeclarationEntry = {
	25	source: Source;
	26	snapshot: CatalogSnapshotV1;
	27	};
	28
	29	type ToolMethodNode = {
	30	readonly segments: readonly string[];
	31	readonly inputType: string;
	32	readonly outputType: string;
	33	readonly argsOptional: boolean;
	34	};
	35
	36	type SourceDeclarationModel = {
	37	readonly methods: readonly ToolMethodNode[];
	38	readonly supportingTypes: readonly string[];
	39	};
	40
	41	type ToolTreeNode = {
	42	method: ToolMethodNode \| null;
	43	children: Map<string, ToolTreeNode>;
	44	};
	45
	46	type SourceDeclarationStub = {
	47	sourceId: string;
	48	};
	49
	50	const GENERATED_TYPES_DIRECTORY = "types";
	51	const GENERATED_SOURCE_TYPES_DIRECTORY = "sources";
	52
	53	const mapFileSystemError = (path: string, action: string) => (cause: unknown) =>
	54	new LocalFileSystemError({
	55	message: `Failed to ${action} ${path}: ${unknownLocalErrorDetails(cause)}`,
	56	action,
	57	path,
	58	details: unknownLocalErrorDetails(cause),
	59	});
	60
	61	const declarationDirectory = (context: ResolvedLocalWorkspaceContext): string =>
	62	join(context.configDirectory, GENERATED_TYPES_DIRECTORY);
	63
	64	const sourceDeclarationDirectory = (context: ResolvedLocalWorkspaceContext): string =>
	65	join(declarationDirectory(context), GENERATED_SOURCE_TYPES_DIRECTORY);
	66
	67	const sourceDeclarationFileName = (sourceId: string): string => `${sourceId}.d.ts`;
	68
	69	const sourceDeclarationPath = (context: ResolvedLocalWorkspaceContext, sourceId: string): string =>
	70	join(sourceDeclarationDirectory(context), sourceDeclarationFileName(sourceId));
	71
	72	const aggregateDeclarationPath = (context: ResolvedLocalWorkspaceContext): string =>
	73	join(declarationDirectory(context), "index.d.ts");
	74
	75	const sourceTypeInterfaceName = (sourceId: string): string =>
	76	`SourceTools_${sourceId.replace(/[^A-Za-z0-9_$]+/g, "_")}`;
	77
	78	const methodSignature = (method: ToolMethodNode): string =>
	79	`(${method.argsOptional ? "args?:" : "args:"} ${method.inputType}) => Promise<${method.outputType}>`;
	80
	81	const createToolTreeNode = (): ToolTreeNode => ({
	82	method: null,
	83	children: new Map(),
	84	});
	85
	86	const objectTypeLiteral = (
	87	lines: readonly string[],
	88	indent: string,
	89	): string => {
	90	if (lines.length === 0) {
	91	return "{}";
	92	}
	93
	94	return [
	95	"{",
	96	...lines.map((line) => `${indent}${line}`),
	97	`${indent.slice(0, -2)}}`,
	98	].join("\n");
	99	};
	100
	101	const renderToolTreeType = (node: ToolTreeNode, indentLevel: number): string => {
	102	const indent = " ".repeat(indentLevel + 1);
	103	const childLines = [...node.children.entries()]
	104	.sort(([left], [right]) => left.localeCompare(right))
	105	.map(([segment, child]) =>
	106	`${formatPropertyKey(segment)}: ${renderToolTreeType(child, indentLevel + 1)};`
	107	);
	108
	109	const objectType = objectTypeLiteral(childLines, indent);
	110	if (node.method === null) {
	111	return objectType;
	112	}
	113
	114	const callable = methodSignature(node.method);
	115	return node.children.size === 0
	116	? callable
	117	: `(${callable}) & ${objectType}`;
	118	};
	119
	120	const buildToolTree = (methods: readonly ToolMethodNode[]): ToolTreeNode => {
	121	const root = createToolTreeNode();
	122
	123	for (const method of methods) {
	124	let current = root;
	125	for (const segment of method.segments) {
	126	const existing = current.children.get(segment);
	127	if (existing) {
	128	current = existing;
	129	continue;
	130	}
	131
	132	const next = createToolTreeNode();
	133	current.children.set(segment, next);
	134	current = next;
	135	}
	136
	137	current.method = method;
	138	}
	139
	140	return root;
	141	};
	142
	143	const buildSourceDeclarationModel = (snapshot: CatalogSnapshotV1): SourceDeclarationModel => {
	144	const projected = projectCatalogForAgentSdk({
	145	catalog: snapshot.catalog,
	146	});
	147	const toolDescriptors = Object.values(projected.toolDescriptors)
	148	.sort((left, right) => left.toolPath.join(".").localeCompare(right.toolPath.join(".")));
	149	const renderer = createCatalogTypeProjector({
	150	catalog: projected.catalog,
	151	roots: projectedCatalogTypeRoots(projected),
	152	});
	153
	154	const methods = toolDescriptors
	155	.map((descriptor) => ({
	156	segments: descriptor.toolPath,
	157	inputType: renderer.renderDeclarationShape(descriptor.callShapeId, {
	158	aliasHint: joinTypeNameSegments(...descriptor.toolPath, "call"),
	159	}),
	160	outputType: descriptor.resultShapeId
	161	? renderer.renderDeclarationShape(descriptor.resultShapeId, {
	162	aliasHint: joinTypeNameSegments(...descriptor.toolPath, "result"),
	163	})
	164	: "unknown",
	165	argsOptional: shapeAllowsOmittedArgs(projected.catalog, descriptor.callShapeId),
	166	}) satisfies ToolMethodNode);
	167
	168	return {
	169	methods,
	170	supportingTypes: renderer.supportingDeclarations(),
	171	};
	172	};
	173
	174	const sourceDeclarationText = (entry: SourceDeclarationEntry): string => {
	175	const interfaceName = sourceTypeInterfaceName(entry.source.id);
	176	const declarationModel = buildSourceDeclarationModel(entry.snapshot);
	177	const tree = buildToolTree(declarationModel.methods);
	178	const body = renderToolTreeType(tree, 0);
	179
	180	return [
	181	"// Generated by executor. Do not edit by hand.",
	182	`// Source: ${entry.source.name} (${entry.source.id})`,
	183	"",
	184	...declarationModel.supportingTypes,
	185	...(declarationModel.supportingTypes.length > 0 ? [""] : []),
	186	`export interface ${interfaceName} ${body}`,
	187	"",
	188	`export declare const tools: ${interfaceName};`,
	189	`export type ${interfaceName}Tools = ${interfaceName};`,
	190	"export default tools;",
	191	"",
	192	].join("\n");
	193	};
	194
	195	const aggregateDeclarationText = (entries: readonly SourceDeclarationEntry[]): string => {
	196	return aggregateDeclarationTextFromSourceIds(
	197	entries.map((entry) => ({ sourceId: entry.source.id })),
	198	);
	199	};
	200
	201	const aggregateDeclarationTextFromSourceIds = (entries: readonly SourceDeclarationStub[]): string => {
	202	const sorted = [...entries].sort((left, right) => left.sourceId.localeCompare(right.sourceId));
	203	const imports = sorted.map((entry) =>
	204	`import type { ${sourceTypeInterfaceName(entry.sourceId)} } from "../sources/${entry.sourceId}";`
	205	);
	206	const intersections = sorted.map((entry) => sourceTypeInterfaceName(entry.sourceId));
	207	const executorToolsType = intersections.length > 0
	208	? intersections.join(" & ")
	209	: "{}";
	210
	211	return [
	212	"// Generated by executor. Do not edit by hand.",
	213	...imports,
	214	...(imports.length > 0 ? [""] : []),
	215	`export type ExecutorSourceTools = ${executorToolsType};`,
	216	"",
	217	"declare global {",
	218	" const tools: ExecutorSourceTools;",
	219	"}",
	220	"",
	221	"export declare const tools: ExecutorSourceTools;",
	222	"export default tools;",
	223	"",
	224	].join("\n");
	225	};
	226
	227	export const syncWorkspaceSourceTypeDeclarations = (input: {
	228	context: ResolvedLocalWorkspaceContext;
	229	entries: readonly SourceDeclarationEntry[];
	230	}): Effect.Effect<void, LocalFileSystemError, FileSystem.FileSystem> =>
	231	Effect.gen(function* () {
	232	const fs = yield* FileSystem.FileSystem;
	233	const declarationsDir = declarationDirectory(input.context);
	234	const perSourceDir = sourceDeclarationDirectory(input.context);
	235	const activeEntries = input.entries
	236	.filter((entry) => entry.source.enabled && entry.source.status === "connected")
	237	.sort((left, right) => left.source.id.localeCompare(right.source.id));
	238
	239	yield* fs.makeDirectory(declarationsDir, { recursive: true }).pipe(
	240	Effect.mapError(mapFileSystemError(declarationsDir, "create declaration directory")),
	241	);
	242	yield* fs.makeDirectory(perSourceDir, { recursive: true }).pipe(
	243	Effect.mapError(mapFileSystemError(perSourceDir, "create source declaration directory")),
	244	);
	245
	246	const expectedFiles = new Set(
	247	activeEntries.map((entry) => sourceDeclarationFileName(entry.source.id)),
	248	);
	249	const existingFiles = yield* fs.readDirectory(perSourceDir).pipe(
	250	Effect.mapError(mapFileSystemError(perSourceDir, "read source declaration directory")),
	251	);
	252
	253	for (const existingFile of existingFiles) {
	254	if (expectedFiles.has(existingFile)) {
	255	continue;
	256	}
	257
	258	const stalePath = join(perSourceDir, existingFile);
	259	yield* fs.remove(stalePath).pipe(
	260	Effect.mapError(mapFileSystemError(stalePath, "remove stale source declaration")),
	261	);
	262	}
	263
	264	for (const entry of activeEntries) {
	265	const filePath = sourceDeclarationPath(input.context, entry.source.id);
	266	yield* fs.writeFileString(filePath, sourceDeclarationText(entry)).pipe(
	267	Effect.mapError(mapFileSystemError(filePath, "write source declaration")),
	268	);
	269	}
	270
	271	const aggregatePath = aggregateDeclarationPath(input.context);
	272	yield* fs.writeFileString(
	273	aggregatePath,
	274	aggregateDeclarationText(activeEntries),
	275	).pipe(
	276	Effect.mapError(mapFileSystemError(aggregatePath, "write aggregate declaration")),
	277	);
	278	});
	279
	280	export const syncSourceTypeDeclaration = (input: {
	281	context: ResolvedLocalWorkspaceContext;
	282	source: Source;
	283	snapshot: CatalogSnapshotV1 \| null;
	284	}): Effect.Effect<void, LocalFileSystemError, FileSystem.FileSystem> =>
	285	Effect.gen(function* () {
	286	const fs = yield* FileSystem.FileSystem;
	287	const declarationsDir = declarationDirectory(input.context);
	288	const perSourceDir = sourceDeclarationDirectory(input.context);
	289
	290	yield* fs.makeDirectory(declarationsDir, { recursive: true }).pipe(
	291	Effect.mapError(mapFileSystemError(declarationsDir, "create declaration directory")),
	292	);
	293	yield* fs.makeDirectory(perSourceDir, { recursive: true }).pipe(
	294	Effect.mapError(mapFileSystemError(perSourceDir, "create source declaration directory")),
	295	);
	296
	297	const filePath = sourceDeclarationPath(input.context, input.source.id);
	298	const shouldWrite = input.source.enabled
	299	&& input.source.status === "connected"
	300	&& input.snapshot !== null;
	301
	302	if (shouldWrite) {
	303	const snapshot = input.snapshot;
	304	if (snapshot === null) {
	305	return;
	306	}
	307	yield* fs.writeFileString(
	308	filePath,
	309	sourceDeclarationText({
	310	source: input.source,
	311	snapshot,
	312	}),
	313	).pipe(
	314	Effect.mapError(mapFileSystemError(filePath, "write source declaration")),
	315	);
	316	} else {
	317	const exists = yield* fs.exists(filePath).pipe(
	318	Effect.mapError(mapFileSystemError(filePath, "check source declaration path")),
	319	);
	320	if (exists) {
	321	yield* fs.remove(filePath).pipe(
	322	Effect.mapError(mapFileSystemError(filePath, "remove source declaration")),
	323	);
	324	}
	325	}
	326
	327	const sourceIds = (yield* fs.readDirectory(perSourceDir).pipe(
	328	Effect.mapError(mapFileSystemError(perSourceDir, "read source declaration directory")),
	329	))
	330	.filter((fileName) => fileName.endsWith(".d.ts"))
	331	.map((fileName) => ({ sourceId: fileName.slice(0, -".d.ts".length) }));
	332
	333	const aggregatePath = aggregateDeclarationPath(input.context);
	334	yield* fs.writeFileString(
	335	aggregatePath,
	336	aggregateDeclarationTextFromSourceIds(sourceIds),
	337	).pipe(
	338	Effect.mapError(mapFileSystemError(aggregatePath, "write aggregate declaration")),
	339	);
	340	});
	341
	342	export const syncWorkspaceSourceTypeDeclarationsNode = (input: {
	343	context: ResolvedLocalWorkspaceContext;
	344	entries: readonly SourceDeclarationEntry[];
	345	}): Effect.Effect<void, LocalFileSystemError, never> =>
	346	syncWorkspaceSourceTypeDeclarations(input).pipe(Effect.provide(NodeFileSystem.layer));
	347
	348	export const syncSourceTypeDeclarationNode = (input: {
	349	context: ResolvedLocalWorkspaceContext;
	350	source: Source;
	351	snapshot: CatalogSnapshotV1 \| null;
	352	}): Effect.Effect<void, LocalFileSystemError, never> =>
	353	syncSourceTypeDeclaration(input).pipe(Effect.provide(NodeFileSystem.layer));
	354
	355	const logBackgroundDeclarationError = (label: string, cause: unknown): void => {
	356	const message = Cause.isCause(cause)
	357	? Cause.pretty(cause)
	358	: cause instanceof Error
	359	? cause.message
	360	: String(cause);
	361	console.warn(`[source-types] ${label} failed: ${message}`);
	362	};
	363
	364	const BACKGROUND_DECLARATION_REFRESH_DELAY = "1500 millis";
	365	const workspaceRefreshFibers = new Map<string, Fiber.RuntimeFiber<void, never>>();
	366	const sourceRefreshFibers = new Map<string, Fiber.RuntimeFiber<void, never>>();
	367
	368	export const refreshWorkspaceSourceTypeDeclarationsInBackground = (input: {
	369	context: ResolvedLocalWorkspaceContext;
	370	entries: readonly SourceDeclarationEntry[];
	371	}): void => {
	372	const key = input.context.configDirectory;
	373	const existingFiber = workspaceRefreshFibers.get(key);
	374	if (existingFiber) {
	375	Effect.runFork(Fiber.interruptFork(existingFiber));
	376	}
	377
	378	const fiber = Effect.runFork(
	379	Effect.sleep(BACKGROUND_DECLARATION_REFRESH_DELAY).pipe(
	380	Effect.zipRight(
	381	syncWorkspaceSourceTypeDeclarationsNode(input).pipe(
	382	Effect.catchAllCause((cause) =>
	383	Effect.sync(() => {
	384	logBackgroundDeclarationError("workspace declaration refresh", cause);
	385	})
	386	),
	387	),
	388	),
	389	),
	390	);
	391
	392	workspaceRefreshFibers.set(key, fiber);
	393	fiber.addObserver(() => {
	394	workspaceRefreshFibers.delete(key);
	395	});
	396	};
	397
	398	export const refreshSourceTypeDeclarationInBackground = (input: {
	399	context: ResolvedLocalWorkspaceContext;
	400	source: Source;
	401	snapshot: CatalogSnapshotV1 \| null;
	402	}): void => {
	403	const key = `${input.context.configDirectory}:${input.source.id}`;
	404	const existingFiber = sourceRefreshFibers.get(key);
	405	if (existingFiber) {
	406	Effect.runFork(Fiber.interruptFork(existingFiber));
	407	}
	408
	409	const fiber = Effect.runFork(
	410	Effect.sleep(BACKGROUND_DECLARATION_REFRESH_DELAY).pipe(
	411	Effect.zipRight(
	412	syncSourceTypeDeclarationNode(input).pipe(
	413	Effect.catchAllCause((cause) =>
	414	Effect.sync(() => {
	415	logBackgroundDeclarationError(`source ${input.source.id} declaration refresh`, cause);
	416	})
	417	),
	418	),
	419	),
	420	),
	421	);
	422
	423	sourceRefreshFibers.set(key, fiber);
	424	fiber.addObserver(() => {
	425	sourceRefreshFibers.delete(key);
	426	});
	427	};

packages/platform/sdk-file/src/tools.tsrenamed from packages/platform/sdk/src/runtime/local/tools.ts+1−41

@@ -15,11 +15,10 @@ import { · 14 unmodified lines
15	type ToolMetadata,	15	type ToolMetadata,
16	type ToolPath,	16	type ToolPath,
17	} from "@executor/codemode-core";	17	} from "@executor/codemode-core";
18	import * as Context from "effect/Context";
19	import * as Effect from "effect/Effect";	18	import * as Effect from "effect/Effect";
20	import * as Layer from "effect/Layer";
21	import * as ts from "typescript";	19	import * as ts from "typescript";
22		20
		21	import type { LocalToolRuntime } from "../../sdk/src/runtime/local-tool-runtime";
23	import type { ResolvedLocalWorkspaceContext } from "./config";	22	import type { ResolvedLocalWorkspaceContext } from "./config";
24	import {	23	import {
25	LocalFileSystemError,	24	LocalFileSystemError,
@@ -79,13 +78,6 @@ export const defineLocalTool = < · 53 unmodified lines
79	\| LocalToolWithMetadata<TInputSchema, TOutputSchema>,	78	\| LocalToolWithMetadata<TInputSchema, TOutputSchema>,
80	): typeof input => input;	79	): typeof input => input;
81		80
82	export type LocalToolRuntime = {
83	tools: ToolMap;
84	catalog: ToolCatalog;
85	toolInvoker: ToolInvoker;
86	toolPaths: Set<string>;
87	};
88
89	const emptyLocalToolRuntime = (): LocalToolRuntime => {	81	const emptyLocalToolRuntime = (): LocalToolRuntime => {
90	const tools: ToolMap = {};	82	const tools: ToolMap = {};
91	return {	83	return {
@@ -651,35 +643,3 @@ export const loadLocalToolRuntime = ( · 559 unmodified lines
651	toolPaths: new Set(Object.keys(tools)),	643	toolPaths: new Set(Object.keys(tools)),
652	} satisfies LocalToolRuntime;	644	} satisfies LocalToolRuntime;
653	});	645	});
654
655	export type LocalToolRuntimeLoaderShape = {
656	load: (
657	context: ResolvedLocalWorkspaceContext,
658	) => Effect.Effect<
659	LocalToolRuntime,
660	\| LocalFileSystemError
661	\| LocalToolDefinitionError
662	\| LocalToolImportError
663	\| LocalToolPathConflictError
664	\| LocalToolTranspileError,
665	never
666	>;
667	};
668
669	export class LocalToolRuntimeLoaderService extends Context.Tag(
670	"#runtime/LocalToolRuntimeLoaderService",
671	)<LocalToolRuntimeLoaderService, LocalToolRuntimeLoaderShape>() {}
672
673	export const LocalToolRuntimeLoaderLive = Layer.effect(
674	LocalToolRuntimeLoaderService,
675	Effect.gen(function* () {
676	const fileSystem = yield* FileSystem.FileSystem;
677
678	return LocalToolRuntimeLoaderService.of({
679	load: (context) =>
680	loadLocalToolRuntime(context).pipe(
681	Effect.provideService(FileSystem.FileSystem, fileSystem),
682	),
683	});
684	}),
685	);

packages/platform/sdk-file/src/workspace-state.tsrenamed from packages/platform/sdk/src/runtime/local/workspace-state.ts+14−52

 import { join } from "node:path";
 import { FileSystem } from "@effect/platform";
-import {
-  PolicyIdSchema,
-  SourceStatusSchema,
-  TimestampMsSchema,
-} from "#schema";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
+import type { LocalWorkspaceState } from "../../sdk/src/runtime/workspace-state";
+import {
+  defaultLocalWorkspaceState,
+  LocalWorkspaceStateSchema,
+} from "../../sdk/src/runtime/workspace-state";
 import type { ResolvedLocalWorkspaceContext } from "./config";
 import {
   LocalFileSystemError,
 const WORKSPACE_STATE_BASENAME = "workspace-state.json";
-const LocalWorkspaceSourceStateSchema = Schema.Struct({
-  status: SourceStatusSchema,
-  lastError: Schema.NullOr(Schema.String),
-  sourceHash: Schema.NullOr(Schema.String),
-  createdAt: TimestampMsSchema,
-  updatedAt: TimestampMsSchema,
-});
-const LocalWorkspacePolicyStateSchema = Schema.Struct({
-  id: PolicyIdSchema,
-  createdAt: TimestampMsSchema,
-  updatedAt: TimestampMsSchema,
-});
-export const LocalWorkspaceStateSchema = Schema.Struct({
-  version: Schema.Literal(1),
-  sources: Schema.Record({
-    key: Schema.String,
-    value: LocalWorkspaceSourceStateSchema,
-  }),
-  policies: Schema.Record({
-    key: Schema.String,
-    value: LocalWorkspacePolicyStateSchema,
-  }),
-});
-export type LocalWorkspaceSourceState = typeof LocalWorkspaceSourceStateSchema.Type;
-export type LocalWorkspacePolicyState = typeof LocalWorkspacePolicyStateSchema.Type;
-export type LocalWorkspaceState = typeof LocalWorkspaceStateSchema.Type;
 const decodeLocalWorkspaceState = Schema.decodeUnknownSync(LocalWorkspaceStateSchema);
 const mapFileSystemError = (path: string, action: string) => (cause: unknown) =>
     details: unknownLocalErrorDetails(cause),
   });
-const defaultLocalWorkspaceState = (): LocalWorkspaceState => ({
-  version: 1,
-  sources: {},
-  policies: {},
-});
 export const localWorkspaceStatePath = (
   context: ResolvedLocalWorkspaceContext,
 ): string => join(context.stateDirectory, WORKSPACE_STATE_BASENAME);
     );
     return yield* Effect.try({
       try: () => decodeLocalWorkspaceState(JSON.parse(content) as unknown),
-      catch: (cause) => {
+      catch: (cause) =>
-        return new LocalWorkspaceStateDecodeError({
+        new LocalWorkspaceStateDecodeError({
           message: `Invalid local workspace state at ${path}: ${unknownLocalErrorDetails(cause)}`,
           path,
           details: unknownLocalErrorDetails(cause),
-        });
+        }),
-      },
     });
   });
   Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
     yield* fs.makeDirectory(input.context.stateDirectory, { recursive: true }).pipe(
-      Effect.mapError(mapFileSystemError(input.context.stateDirectory, "create state directory")),
+      Effect.mapError(
+        mapFileSystemError(input.context.stateDirectory, "create state directory"),
+      ),
     );
-    yield* fs.writeFileString(
+    const path = localWorkspaceStatePath(input.context);
-      localWorkspaceStatePath(input.context),
+    yield* fs.writeFileString(path, `${JSON.stringify(input.state, null, 2)}\n`).pipe(
-      `${JSON.stringify(input.state, null, 2)}\n`,
+      Effect.mapError(mapFileSystemError(path, "write workspace state")),
-    ).pipe(
-      Effect.mapError(mapFileSystemError(localWorkspaceStatePath(input.context), "write workspace state")),
     );
   });

packages/platform/sdk-file/tsconfig.json+13−0

@@ -0,0 +1,13 @@
	1	{
	2	"compilerOptions": {
	3	"target": "ES2022",
	4	"module": "ESNext",
	5	"moduleResolution": "Bundler",
	6	"strict": true,
	7	"skipLibCheck": true,
	8	"noEmit": true,
	9	"lib": ["ES2022"],
	10	"types": ["bun-types", "node"]
	11	},
	12	"include": ["src/*/.ts"]
	13	}

packages/platform/sdk/package.json+0−1

@@ -18,7 +18,6 @@ · 17 unmodified lines
18	"#schema": "./src/schema/index.ts"	18	"#schema": "./src/schema/index.ts"
19	},	19	},
20	"scripts": {	20	"scripts": {
21	"fixture:release:capture": "bun run ./src/runtime/local/capture-release-workspace-fixture.ts",
22	"test": "vitest run",	21	"test": "vitest run",
23	"test:watch": "vitest",	22	"test:watch": "vitest",
24	"typecheck": "bunx tsc --noEmit -p tsconfig.json"	23	"typecheck": "bunx tsc --noEmit -p tsconfig.json"

packages/platform/sdk/src/backend.ts+4−0

   type RuntimeControlPlaneServices,
   type RuntimeSecretMaterialServices,
 } from "./runtime";
+export type {
+  ExecutorWorkspaceContext,
+  ExecutorWorkspaceDescriptor,
+} from "./workspace";
 export type ExecutorBackend = {
   createRuntime: (

packages/platform/sdk/src/local/operations.ts+9−23

@@ -14,12 +14,7 @@ import * as Option from "effect/Option"; · 13 unmodified lines
14	import { submitExecutionInteractionResponse } from "../runtime/execution/service";	14	import { submitExecutionInteractionResponse } from "../runtime/execution/service";
15	import { LiveExecutionManagerService } from "../runtime/execution/live";	15	import { LiveExecutionManagerService } from "../runtime/execution/live";
16	import { operationErrors } from "../runtime/policy/operation-errors";	16	import { operationErrors } from "../runtime/policy/operation-errors";
17	import { resolveLocalWorkspaceContext } from "../runtime/local/config";	17	import { InstallationStore } from "../runtime/workspace/storage";
18	import {
19	InstallationStore,
20	LocalInstallationStore,
21	} from "../runtime/local/storage";
22	import { getRuntimeLocalWorkspaceOption } from "../runtime/local/runtime-context";
23	import { RuntimeSourceAuthServiceTag } from "../runtime/sources/source-auth-service";	18	import { RuntimeSourceAuthServiceTag } from "../runtime/sources/source-auth-service";
24	import {	19	import {
25	createSourceCredentialSelectionBearerContent,	20	createSourceCredentialSelectionBearerContent,
@@ -190,24 +185,15 @@ const loadSourceCredentialInteraction = (input: { · 164 unmodified lines
190		185
191	export const getLocalInstallation = () =>	186	export const getLocalInstallation = () =>
192	Effect.gen(function* () {	187	Effect.gen(function* () {
193	const runtimeLocalWorkspace = yield* getRuntimeLocalWorkspaceOption();	188	const installationStore = yield* InstallationStore;
194	const context =	189	return yield* installationStore.load().pipe(
195	runtimeLocalWorkspace?.context ??	190	Effect.mapError((error) =>
196	(yield* resolveLocalWorkspaceContext().pipe(	191	localOps.installation.unknownStorage(
197	Effect.mapError((error) =>	192	error,
198	localOps.installation.unknownStorage(	193	"Failed loading local installation",
199	error,
200	"Failed resolving local workspace context",
201	),
202	),	194	),
203	));	195	),
204		196	);
205	const installationStore =
206	runtimeLocalWorkspace !== null
207	? yield* InstallationStore
208	: LocalInstallationStore;
209
210	return yield* installationStore.load(context);
211	});	197	});
212		198
213	export const getSourceCredentialInteraction = (input: {	199	export const getSourceCredentialInteraction = (input: {

packages/platform/sdk/src/local/secrets.ts+12−72

@@ -16,22 +16,16 @@ import { · 15 unmodified lines
16	ControlPlaneNotFoundError,	16	ControlPlaneNotFoundError,
17	ControlPlaneStorageError,	17	ControlPlaneStorageError,
18	} from "../errors";	18	} from "../errors";
19	import { requireRuntimeLocalWorkspace } from "../runtime/local/runtime-context";	19	import { requireRuntimeLocalWorkspace } from "../runtime/workspace/runtime-context";
20	import {	20	import {
21	createDefaultSecretMaterialDeleter,	21	LocalInstanceConfigService,
22	createDefaultSecretMaterialStorer,	22	SecretMaterialDeleterService,
23	createDefaultSecretMaterialUpdater,	23	SecretMaterialStorerService,
24	ENV_SECRET_PROVIDER_ID,	24	SecretMaterialUpdaterService,
25	KEYCHAIN_SECRET_PROVIDER_ID,	25	} from "../runtime/workspace/secret-material-providers";
26	LOCAL_SECRET_PROVIDER_ID,
27	parseSecretStoreProviderId,
28	resolveDefaultSecretStoreProviderId,
29	} from "../runtime/local/secret-material-providers";
30	import { RuntimeSourceStoreService } from "../runtime/sources/source-store";	26	import { RuntimeSourceStoreService } from "../runtime/sources/source-store";
31	import { ControlPlaneStore } from "../runtime/store";	27	import { ControlPlaneStore } from "../runtime/store";
32		28
33	const SECRET_STORE_PROVIDER_ENV = "EXECUTOR_SECRET_STORE_PROVIDER";
34
35	const secretStorageError = (operation: string, message: string) =>	29	const secretStorageError = (operation: string, message: string) =>
36	new ControlPlaneStorageError({	30	new ControlPlaneStorageError({
37	operation,	31	operation,
@@ -39,45 +33,8 @@ const secretStorageError = (operation: string, message: string) => · 1 unmodified line
39	details: message,	33	details: message,
40	});	34	});
41		35
42	export const getLocalInstanceConfig = (): Effect.Effect<InstanceConfig> => {	36	export const getLocalInstanceConfig = (): Effect.Effect<InstanceConfig, Error, LocalInstanceConfigService> =>
43	const explicitDefaultStoreProvider = parseSecretStoreProviderId(	37	Effect.flatMap(LocalInstanceConfigService, (resolveInstanceConfig) => resolveInstanceConfig());
44	process.env[SECRET_STORE_PROVIDER_ENV],
45	);
46	const providers = [
47	{
48	id: LOCAL_SECRET_PROVIDER_ID,
49	name: "Local store",
50	canStore: true,
51	},
52	];
53
54	if (process.platform === "darwin" \|\| process.platform === "linux") {
55	providers.push({
56	id: KEYCHAIN_SECRET_PROVIDER_ID,
57	name:
58	process.platform === "darwin" ? "macOS Keychain" : "Desktop Keyring",
59	canStore:
60	process.platform === "darwin" \|\|
61	explicitDefaultStoreProvider === KEYCHAIN_SECRET_PROVIDER_ID,
62	});
63	}
64
65	providers.push({
66	id: ENV_SECRET_PROVIDER_ID,
67	name: "Environment variable",
68	canStore: false,
69	});
70
71	return resolveDefaultSecretStoreProviderId({
72	storeProviderId: explicitDefaultStoreProvider ?? undefined,
73	}).pipe(
74	Effect.map((resolvedDefaultStoreProvider) => ({
75	platform: process.platform,
76	secretProviders: providers,
77	defaultSecretStoreProvider: resolvedDefaultStoreProvider,
78	})),
79	);
80	};
81		38
82	export const listLocalSecrets = () =>	39	export const listLocalSecrets = () =>
83	Effect.gen(function* () {	40	Effect.gen(function* () {
@@ -119,10 +76,6 @@ export const createLocalSecret = (payload: CreateSecretPayload) => · 35 unmodified lines
119	const name = payload.name.trim();	76	const name = payload.name.trim();
120	const value = payload.value;	77	const value = payload.value;
121	const purpose = payload.purpose ?? "auth_material";	78	const purpose = payload.purpose ?? "auth_material";
122	const requestedProviderId =
123	payload.providerId === undefined
124	? null
125	: parseSecretStoreProviderId(payload.providerId);
126		79
127	if (name.length === 0) {	80	if (name.length === 0) {
128	return yield* new ControlPlaneBadRequestError({	81	return yield* new ControlPlaneBadRequestError({
@@ -131,23 +84,14 @@ export const createLocalSecret = (payload: CreateSecretPayload) => · 2 unmodified lines
131	details: "Secret name is required.",	84	details: "Secret name is required.",
132	});	85	});
133	}	86	}
134	if (payload.providerId !== undefined && requestedProviderId === null) {
135	return yield* new ControlPlaneBadRequestError({
136	operation: "secrets.create",
137	message: `Unsupported secret provider: ${payload.providerId}`,
138	details: `Unsupported secret provider: ${payload.providerId}`,
139	});
140	}
141		87
142	const store = yield* ControlPlaneStore;	88	const store = yield* ControlPlaneStore;
143	const storeSecretMaterial = createDefaultSecretMaterialStorer({	89	const storeSecretMaterial = yield* SecretMaterialStorerService;
144	rows: store,
145	...(requestedProviderId ? { storeProviderId: requestedProviderId } : {}),
146	});
147	const ref = yield* storeSecretMaterial({	90	const ref = yield* storeSecretMaterial({
148	name,	91	name,
149	purpose,	92	purpose,
150	value,	93	value,
		94	providerId: payload.providerId,
151	}).pipe(	95	}).pipe(
152	Effect.mapError((cause) =>	96	Effect.mapError((cause) =>
153	secretStorageError(	97	secretStorageError(
@@ -214,9 +158,7 @@ export const updateLocalSecret = (input: { · 60 unmodified lines
214	update.name = input.payload.name.trim() \|\| null;	158	update.name = input.payload.name.trim() \|\| null;
215	if (input.payload.value !== undefined) update.value = input.payload.value;	159	if (input.payload.value !== undefined) update.value = input.payload.value;
216		160
217	const updateSecretMaterial = createDefaultSecretMaterialUpdater({	161	const updateSecretMaterial = yield* SecretMaterialUpdaterService;
218	rows: store,
219	});
220	const updated = yield* updateSecretMaterial({	162	const updated = yield* updateSecretMaterial({
221	ref: {	163	ref: {
222	providerId: existing.value.providerId,	164	providerId: existing.value.providerId,
@@ -260,9 +202,7 @@ export const deleteLocalSecret = (secretId: string) => · 37 unmodified lines
260	});	202	});
261	}	203	}
262		204
263	const deleteSecretMaterial = createDefaultSecretMaterialDeleter({	205	const deleteSecretMaterial = yield* SecretMaterialDeleterService;
264	rows: store,
265	});
266	const removed = yield* deleteSecretMaterial({	206	const removed = yield* deleteSecretMaterial({
267	providerId: existing.value.providerId,	207	providerId: existing.value.providerId,
268	handle: existing.value.id,	208	handle: existing.value.id,

packages/platform/sdk/src/policies/operations.ts+32−26

 } from "../schema";
 import * as Effect from "effect/Effect";
-import { requireRuntimeLocalWorkspace } from "../runtime/local/runtime-context";
+import { requireRuntimeLocalWorkspace } from "../runtime/workspace/runtime-context";
 import type {
   WorkspaceConfigStoreShape,
   WorkspaceStateStoreShape,
-} from "../runtime/local/storage";
+} from "../runtime/workspace/storage";
 import {
   WorkspaceConfigStore,
   WorkspaceStateStore,
-} from "../runtime/local/storage";
+} from "../runtime/workspace/storage";
-import type { ResolvedLocalWorkspaceContext } from "../runtime/local/config";
+import { type LocalWorkspaceState } from "../runtime/workspace-state";
-import { type LocalWorkspaceState } from "../runtime/local/workspace-state";
+import { derivePolicyConfigKey } from "../runtime/workspace/workspace-sync";
-import { derivePolicyConfigKey } from "../runtime/local/workspace-sync";
 import {
   type OperationErrors,
   operationErrors,
 const cloneJson = <T>(value: T): T => JSON.parse(JSON.stringify(value)) as T;
+const workspacePolicyStableKey = (input: {
+  workspaceId: WorkspaceId;
+  workspaceRoot?: string | null;
+}): string => input.workspaceRoot?.trim() || input.workspaceId;
 const localPolicyIdForKey = (input: {
-  workspaceRoot: string;
+  workspaceStableKey: string;
   key: string;
 }): PolicyId =>
   PolicyIdSchema.make(
-    `pol_local_${createHash("sha256").update(`${input.workspaceRoot}:${input.key}`).digest("hex").slice(0, 16)}`,
+    `pol_local_${createHash("sha256").update(`${input.workspaceStableKey}:${input.key}`).digest("hex").slice(0, 16)}`,
   );
 const toLocalWorkspacePolicy = (input: {
   workspaceId: WorkspaceId;
-  workspaceRoot: string;
+  workspaceStableKey: string;
   key: string;
   policyConfig: NonNullable<LocalExecutorConfig["policies"]>[string];
   state: LocalWorkspaceState["policies"][string] | undefined;
   id:
     input.state?.id ??
     localPolicyIdForKey({
-      workspaceRoot: input.workspaceRoot,
+      workspaceStableKey: input.workspaceStableKey,
       key: input.key,
     }),
   key: input.key,
       yield* requireRuntimeLocalWorkspace(workspaceId);
     const workspaceConfigStore = yield* WorkspaceConfigStore;
     const workspaceStateStore = yield* WorkspaceStateStore;
-    const loadedConfig = yield* workspaceConfigStore.load(
+    const loadedConfig = yield* workspaceConfigStore.load();
-      runtimeLocalWorkspace.context,
+    const workspaceState = yield* workspaceStateStore.load();
-    );
-    const workspaceState = yield* workspaceStateStore.load(
-      runtimeLocalWorkspace.context,
-    );
     const policies = Object.entries(loadedConfig.config?.policies ?? {}).map(
       ([key, policyConfig]) =>
         toLocalWorkspacePolicy({
           workspaceId,
-          workspaceRoot: runtimeLocalWorkspace.context.workspaceRoot,
+          workspaceStableKey: workspacePolicyStableKey({
+            workspaceId,
+            workspaceRoot: runtimeLocalWorkspace.workspace.workspaceRoot,
+          }),
           key,
           policyConfig,
           state: workspaceState.policies[key],
 const writeLocalPolicyFiles = (input: {
   operation: OperationErrors;
-  context: ResolvedLocalWorkspaceContext;
   workspaceConfigStore: WorkspaceConfigStoreShape;
   workspaceStateStore: WorkspaceStateStoreShape;
   projectConfig: LocalExecutorConfig;
   Effect.all(
     [
       input.workspaceConfigStore.writeProject({
-        context: input.context,
         config: input.projectConfig,
       }),
       input.workspaceStateStore.write({
-        context: input.context,
         state: input.workspaceState,
       }),
     ],
           id:
             existingState?.id ??
             localPolicyIdForKey({
-              workspaceRoot: runtimeLocalWorkspace.context.workspaceRoot,
+              workspaceStableKey: workspacePolicyStableKey({
+                workspaceId: input.workspaceId,
+                workspaceRoot: runtimeLocalWorkspace.workspace.workspaceRoot,
+              }),
               key,
             }),
           createdAt: existingState?.createdAt ?? now,
     yield* writeLocalPolicyFiles({
       operation: policyOps.create,
-      context: runtimeLocalWorkspace.context,
       workspaceConfigStore,
       workspaceStateStore,
       projectConfig: {
     return toLocalWorkspacePolicy({
       workspaceId: input.workspaceId,
-      workspaceRoot: runtimeLocalWorkspace.context.workspaceRoot,
+      workspaceStableKey: workspacePolicyStableKey({
+        workspaceId: input.workspaceId,
+        workspaceRoot: runtimeLocalWorkspace.workspace.workspaceRoot,
+      }),
       key,
       policyConfig: policies[key]!,
       state: workspaceState.policies[key],
     yield* writeLocalPolicyFiles({
       operation: policyOps.update,
-      context: runtimeLocalWorkspace.context,
       workspaceConfigStore,
       workspaceStateStore,
       projectConfig: {
     return toLocalWorkspacePolicy({
       workspaceId: input.workspaceId,
-      workspaceRoot: runtimeLocalWorkspace.context.workspaceRoot,
+      workspaceStableKey: workspacePolicyStableKey({
+        workspaceId: input.workspaceId,
+        workspaceRoot: runtimeLocalWorkspace.workspace.workspaceRoot,
+      }),
       key: existing.key,
       policyConfig: policies[existing.key]!,
       state: workspaceState.policies[existing.key],
       localWorkspace.workspaceState.policies;
     yield* writeLocalPolicyFiles({
       operation: policyOps.remove,
-      context: runtimeLocalWorkspace.context,
       workspaceConfigStore,
       workspaceStateStore,
       projectConfig: {

packages/platform/sdk/src/runtime/__fixtures__/README.md+2−2

@@ -9,7 +9,7 @@ Each fixture directory should contain: · 8 unmodified lines
9	- `.executor/state/workspace-state.json`: a trimmed workspace state with only the captured source	9	- `.executor/state/workspace-state.json`: a trimmed workspace state with only the captured source
10	- `.executor/artifacts/sources/...`: the real artifact JSON and any sidecar files that release wrote	10	- `.executor/artifacts/sources/...`: the real artifact JSON and any sidecar files that release wrote
11		11
12	`src/runtime/local/source-artifacts.test.ts` auto-discovers every fixture directory here that has a `fixture.json` file. Adding a new release fixture should not require changing the test.	12	`packages/platform/sdk-file/src/source-artifacts.test.ts` auto-discovers every fixture directory here that has a `fixture.json` file. Adding a new release fixture should not require changing the test.
13		13
14	## Capture A New Release Fixture	14	## Capture A New Release Fixture
15		15
@@ -35,4 +35,4 @@ On releases where you want upgrade coverage: · 19 unmodified lines
35	1. Start from a real workspace that has a fully synced source on the released version.	35	1. Start from a real workspace that has a fully synced source on the released version.
36	2. Run `bun run fixture:release:capture -- ...` for that source.	36	2. Run `bun run fixture:release:capture -- ...` for that source.
37	3. Review the fixture for secrets before committing it.	37	3. Review the fixture for secrets before committing it.
38	4. Run `bun run --cwd packages/platform/sdk test -- src/runtime/local/source-artifacts.test.ts`.	38	4. Run `bun run --cwd packages/platform/sdk-file test -- src/source-artifacts.test.ts`.

packages/platform/sdk/src/runtime/auth/auth-artifacts.ts+1−1

@@ -35,7 +35,7 @@ import * as Schema from "effect/Schema"; · 34 unmodified lines
35	import type {	35	import type {
36	ResolveSecretMaterial,	36	ResolveSecretMaterial,
37	SecretMaterialResolveContext,	37	SecretMaterialResolveContext,
38	} from "../local/secret-material-providers";	38	} from "../workspace/secret-material-providers";
39	import { runtimeEffectError } from "../effect-errors";	39	import { runtimeEffectError } from "../effect-errors";
40		40
41	export type ResolvedSourceAuthMaterial = {	41	export type ResolvedSourceAuthMaterial = {

packages/platform/sdk/src/runtime/auth/auth-leases.ts+30−26

 import type { ControlPlaneStoreShape } from "../store";
 import { resolveAuthArtifactMaterial, type ResolvedSourceAuthMaterial } from "./auth-artifacts";
 import {
-  createDefaultSecretMaterialDeleter,
+  type DeleteSecretMaterial,
-  createDefaultSecretMaterialStorer,
   type ResolveSecretMaterial,
   type SecretMaterialResolveContext,
-} from "../local/secret-material-providers";
+  type StoreSecretMaterial,
+} from "../workspace/secret-material-providers";
 import { refreshOAuth2AccessToken } from "./oauth2-pkce";
 import type { OAuth2TokenResponse } from "./oauth2-pkce";
 import { createPersistedMcpAuthProvider } from "./mcp-auth-provider";
     previous: Pick<AuthLease, "placementsTemplateJson"> | null;
     next: Pick<AuthLease, "placementsTemplateJson"> | null;
   },
+  deleteSecretMaterial: DeleteSecretMaterial,
 ) =>
   Effect.gen(function* () {
     if (input.previous === null) {
       return;
     }
-    const deleteSecretMaterial = createDefaultSecretMaterialDeleter({ rows });
     const nextRefKeys = new Set(
       (input.next === null ? [] : authLeaseSecretRefs(input.next)).map(secretRefKey),
     );
   artifact: AuthArtifact;
   lease: AuthLease | null;
   resolveSecretMaterial: ResolveSecretMaterial;
+  storeSecretMaterial: StoreSecretMaterial;
+  deleteSecretMaterial: DeleteSecretMaterial;
   context?: SecretMaterialResolveContext;
 }): Effect.Effect<AuthLease, Error, never> =>
   Effect.gen(function* () {
       refreshToken,
     });
-    const storeSecretMaterial = createDefaultSecretMaterialStorer({
+    const accessTokenRef = yield* input.storeSecretMaterial({
-      rows: input.rows,
-    });
-    const accessTokenRef = yield* storeSecretMaterial({
       purpose: "oauth_access_token",
       value: tokenResponse.access_token,
       name: `${decoded.config.clientId} Access Token`,
     yield* cleanupAuthLeaseSecretRefs(input.rows, {
       previous: input.lease,
       next: nextLease,
-    });
+    }, input.deleteSecretMaterial);
     return nextLease;
   });
 const cleanupProviderGrantRefreshToken = (rows: ControlPlaneStoreShape, input: {
   previous: SecretRef;
   next: SecretRef;
-}) =>
+}, deleteSecretMaterial: DeleteSecretMaterial) =>
   secretRefKey(input.previous) === secretRefKey(input.next)
     ? Effect.void
-    : createDefaultSecretMaterialDeleter({ rows })(input.previous).pipe(
+    : deleteSecretMaterial(input.previous).pipe(
         Effect.either,
         Effect.ignore,
       );
   artifact: AuthArtifact;
   lease: AuthLease | null;
   resolveSecretMaterial: ResolveSecretMaterial;
+  storeSecretMaterial: StoreSecretMaterial;
+  deleteSecretMaterial: DeleteSecretMaterial;
   context?: SecretMaterialResolveContext;
 }): Effect.Effect<AuthLease, Error, never> =>
   Effect.gen(function* () {
       scopes: config.requiredScopes.length > 0 ? config.requiredScopes : null,
     });
-    const storeSecretMaterial = createDefaultSecretMaterialStorer({
+    const accessTokenRef = yield* input.storeSecretMaterial({
-      rows: input.rows,
-    });
-    const accessTokenRef = yield* storeSecretMaterial({
       purpose: "oauth_access_token",
       value: tokenResponse.access_token,
       name: `${grant.providerKey} Access Token`,
     });
     const rotatedRefreshTokenRef = tokenResponse.refresh_token
-      ? yield* storeSecretMaterial({
+      ? yield* input.storeSecretMaterial({
           purpose: "oauth_refresh_token",
           value: tokenResponse.refresh_token,
           name: `${grant.providerKey} Refresh Token`,
     yield* cleanupProviderGrantRefreshToken(input.rows, {
       previous: grant.refreshToken,
       next: rotatedRefreshTokenRef,
-    });
+    }, input.deleteSecretMaterial);
     const expiresInMs =
       typeof tokenResponse.expires_in === "number" && Number.isFinite(tokenResponse.expires_in)
     yield* cleanupAuthLeaseSecretRefs(input.rows, {
       previous: input.lease,
       next: nextLease,
-    });
+    }, input.deleteSecretMaterial);
     return nextLease;
   });
 export const removeAuthLeaseAndSecrets = (rows: ControlPlaneStoreShape, input: {
   authArtifactId: AuthArtifact["id"];
-}): Effect.Effect<void, Error, never> =>
+}, deleteSecretMaterial: DeleteSecretMaterial): Effect.Effect<void, Error, never> =>
   Effect.gen(function* () {
     const existingLease = yield* rows.authLeases.getByAuthArtifactId(input.authArtifactId);
     if (Option.isNone(existingLease)) {
     yield* cleanupAuthLeaseSecretRefs(rows, {
       previous: existingLease.value,
       next: null,
-    });
+    }, deleteSecretMaterial);
   });
 export const upsertOauth2AuthorizedUserLeaseFromTokenResponse = (input: {
   rows: ControlPlaneStoreShape;
   artifact: AuthArtifact;
   tokenResponse: OAuth2TokenResponse;
+  storeSecretMaterial: StoreSecretMaterial;
+  deleteSecretMaterial: DeleteSecretMaterial;
 }): Effect.Effect<void, Error, never> =>
   Effect.gen(function* () {
     const decoded = decodeBuiltInAuthArtifactConfig(input.artifact);
     const existingLeaseOption = yield* input.rows.authLeases.getByAuthArtifactId(input.artifact.id);
     const existingLease = Option.isSome(existingLeaseOption) ? existingLeaseOption.value : null;
-    const storeSecretMaterial = createDefaultSecretMaterialStorer({
+    const accessTokenRef = yield* input.storeSecretMaterial({
-      rows: input.rows,
-    });
-    const accessTokenRef = yield* storeSecretMaterial({
       purpose: "oauth_access_token",
       value: input.tokenResponse.access_token,
       name: `${decoded.config.clientId} Access Token`,
     yield* cleanupAuthLeaseSecretRefs(input.rows, {
       previous: existingLease,
       next: nextLease,
-    });
+    }, input.deleteSecretMaterial);
   });
 export const resolveAuthArtifactMaterialWithLeases = (input: {
   rows: ControlPlaneStoreShape;
   artifact: AuthArtifact | null;
   resolveSecretMaterial: ResolveSecretMaterial;
+  storeSecretMaterial: StoreSecretMaterial;
+  deleteSecretMaterial: DeleteSecretMaterial;
   context?: SecretMaterialResolveContext;
 }): Effect.Effect<ResolvedSourceAuthMaterial, Error, never> =>
   Effect.gen(function* () {
             artifact: input.artifact,
             lease: existingLease,
             resolveSecretMaterial: input.resolveSecretMaterial,
+            storeSecretMaterial: input.storeSecretMaterial,
+            deleteSecretMaterial: input.deleteSecretMaterial,
             context: input.context,
           });
             artifact: input.artifact,
             lease: existingLease,
             resolveSecretMaterial: input.resolveSecretMaterial,
+            storeSecretMaterial: input.storeSecretMaterial,
+            deleteSecretMaterial: input.deleteSecretMaterial,
             context: input.context,
           });
           artifact: input.artifact,
           config: mcpOAuthConfig,
           resolveSecretMaterial: input.resolveSecretMaterial,
+          storeSecretMaterial: input.storeSecretMaterial,
+          deleteSecretMaterial: input.deleteSecretMaterial,
           context: input.context,
         }),
       };

packages/platform/sdk/src/runtime/auth/mcp-auth-provider.ts+13−15

 import type { ControlPlaneStoreShape } from "../store";
 import {
-  createDefaultSecretMaterialDeleter,
+  type DeleteSecretMaterial,
-  createDefaultSecretMaterialStorer,
   type ResolveSecretMaterial,
   type SecretMaterialResolveContext,
-} from "../local/secret-material-providers";
+  type StoreSecretMaterial,
+} from "../workspace/secret-material-providers";
 const encodeMcpOAuthAuthArtifactConfig = Schema.encodeSync(
   McpOAuthAuthArtifactConfigJsonSchema,
   (left?.providerId ?? null) === (right?.providerId ?? null)
   && (left?.handle ?? null) === (right?.handle ?? null);
-const cleanupReplacedSecretRefs = (rows: ControlPlaneStoreShape, input: {
+const cleanupReplacedSecretRefs = (input: {
+  deleteSecretMaterial: DeleteSecretMaterial;
   previousAccessToken: SecretRef;
   nextAccessToken: SecretRef;
   previousRefreshToken: SecretRef | null;
   nextRefreshToken: SecretRef | null;
 }) =>
   Effect.gen(function* () {
-    const deleteSecretMaterial = createDefaultSecretMaterialDeleter({ rows });
     if (!secretRefEquals(input.previousAccessToken, input.nextAccessToken)) {
-      yield* Effect.either(deleteSecretMaterial(input.previousAccessToken));
+      yield* Effect.either(input.deleteSecretMaterial(input.previousAccessToken));
     }
     if (
       input.previousRefreshToken !== null
       && !secretRefEquals(input.previousRefreshToken, input.nextRefreshToken)
     ) {
-      yield* Effect.either(deleteSecretMaterial(input.previousRefreshToken));
+      yield* Effect.either(input.deleteSecretMaterial(input.previousRefreshToken));
     }
   });
   artifact: AuthArtifact;
   config: McpOAuthAuthArtifactConfig;
   resolveSecretMaterial: ResolveSecretMaterial;
+  storeSecretMaterial: StoreSecretMaterial;
+  deleteSecretMaterial: DeleteSecretMaterial;
   context?: SecretMaterialResolveContext;
 }): OAuthClientProvider => {
-  const storeSecretMaterial = createDefaultSecretMaterialStorer({
-    rows: input.rows,
-  });
   let currentArtifact = input.artifact;
   let currentConfig = input.config;
     saveTokens: (tokens) =>
       Effect.runPromise(Effect.gen(function* () {
         const previousConfig = currentConfig;
-        const accessTokenRef = yield* storeSecretMaterial({
+        const accessTokenRef = yield* input.storeSecretMaterial({
           purpose: "oauth_access_token",
           value: tokens.access_token,
           name: `${currentArtifact.sourceId} MCP Access Token`,
         });
         const refreshTokenRef = tokens.refresh_token
-          ? yield* storeSecretMaterial({
+          ? yield* input.storeSecretMaterial({
               purpose: "oauth_refresh_token",
               value: tokens.refresh_token,
               name: `${currentArtifact.sourceId} MCP Refresh Token`,
         };
         yield* persistConfig(nextConfig);
-        yield* cleanupReplacedSecretRefs(input.rows, {
+        yield* cleanupReplacedSecretRefs({
+          deleteSecretMaterial: input.deleteSecretMaterial,
           previousAccessToken: previousConfig.accessToken,
           nextAccessToken: accessTokenRef,
           previousRefreshToken: previousConfig.refreshToken,

packages/platform/sdk/src/runtime/auth/provider-grant-lifecycle.ts+4−5

 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import { createDefaultSecretMaterialDeleter } from "../local/secret-material-providers";
+import {
+  type DeleteSecretMaterial,
+} from "../workspace/secret-material-providers";
 import type { ControlPlaneStoreShape } from "../store";
 const providerGrantRefFromArtifact = (
 export const removeProviderAuthGrantSecret = (rows: ControlPlaneStoreShape, input: {
   grant: ProviderAuthGrant;
-}): Effect.Effect<void, Error, never> =>
+}, deleteSecretMaterial: DeleteSecretMaterial): Effect.Effect<void, Error, never> =>
   Effect.gen(function* () {
-    const deleteSecretMaterial = createDefaultSecretMaterialDeleter({
-      rows,
-    });
     yield* deleteSecretMaterial(input.grant.refreshToken).pipe(
       Effect.either,
       Effect.ignore,

packages/platform/sdk/src/runtime/auth/source-auth-material.ts+18−2

 } from "./auth-artifacts";
 import { resolveAuthArtifactMaterialWithLeases } from "./auth-leases";
 import type {
+  DeleteSecretMaterial,
   ResolveSecretMaterial,
   SecretMaterialResolveContext,
-} from "../local/secret-material-providers";
+  StoreSecretMaterial,
-import { SecretMaterialResolverService } from "../local/secret-material-providers";
+} from "../workspace/secret-material-providers";
+import {
+  SecretMaterialDeleterService,
+  SecretMaterialResolverService,
+  SecretMaterialStorerService,
+} from "../workspace/secret-material-providers";
 import { runtimeEffectError } from "../effect-errors";
 const authForSlot = (input: {
   actorAccountId?: AccountId | null;
   rows?: ControlPlaneStoreShape;
   resolveSecretMaterial: ResolveSecretMaterial;
+  storeSecretMaterial?: StoreSecretMaterial;
+  deleteSecretMaterial?: DeleteSecretMaterial;
   context?: SecretMaterialResolveContext;
 }): Effect.Effect<ResolvedSourceAuthMaterial, Error, never> =>
   Effect.gen(function* () {
             rows: input.rows,
             artifact: artifactOption.value,
             resolveSecretMaterial: input.resolveSecretMaterial,
+            storeSecretMaterial: input.storeSecretMaterial ?? (() => Effect.dieMessage("storeSecretMaterial unavailable")),
+            deleteSecretMaterial: input.deleteSecretMaterial ?? (() => Effect.dieMessage("deleteSecretMaterial unavailable")),
             context: input.context,
           });
         }
         rows: input.rows,
         artifact,
         resolveSecretMaterial: input.resolveSecretMaterial,
+        storeSecretMaterial: input.storeSecretMaterial ?? (() => Effect.dieMessage("storeSecretMaterial unavailable")),
+        deleteSecretMaterial: input.deleteSecretMaterial ?? (() => Effect.dieMessage("deleteSecretMaterial unavailable")),
         context: input.context,
       });
     }
   Effect.gen(function* () {
     const rows = yield* ControlPlaneStore;
     const resolveSecretMaterial = yield* SecretMaterialResolverService;
+    const storeSecretMaterial = yield* SecretMaterialStorerService;
+    const deleteSecretMaterial = yield* SecretMaterialDeleterService;
     return RuntimeSourceAuthMaterialService.of({
       resolve: (input) =>
           ...input,
           rows,
           resolveSecretMaterial,
+          storeSecretMaterial,
+          deleteSecretMaterial,
         }),
     });
   }),

packages/platform/sdk/src/runtime/catalog/source/reconcile.ts+2−3

 } from "#schema";
 import * as Effect from "effect/Effect";
-import { RuntimeLocalWorkspaceService } from "../../local/runtime-context";
+import { RuntimeLocalWorkspaceService } from "../../workspace/runtime-context";
-import { SourceArtifactStore } from "../../local/storage";
+import { SourceArtifactStore } from "../../workspace/storage";
 import { getSourceAdapterForSource } from "../../sources/source-adapters";
 import { RuntimeSourceStoreService } from "../../sources/source-store";
 import { RuntimeSourceCatalogSyncService } from "./sync";
       }
       const artifact = yield* sourceArtifactStore.read({
-        context: runtimeLocalWorkspace.context,
         sourceId: source.id,
       });
       if (artifact !== null) {

packages/platform/sdk/src/runtime/catalog/source/runtime.ts+11−20

@@ -27,7 +27,7 @@ import type { · 26 unmodified lines
27	Executable,	27	Executable,
28	ShapeSymbol,	28	ShapeSymbol,
29	} from "@executor/ir/model";	29	} from "@executor/ir/model";
30	import { LocalSourceArtifactMissingError } from "../../local/errors";	30	import { LocalSourceArtifactMissingError } from "../../workspace-errors";
31	import {	31	import {
32	createCatalogTypeProjector,	32	createCatalogTypeProjector,
33	documentationComment,	33	documentationComment,
@@ -40,12 +40,12 @@ import { formatWithPrettier } from "../prettier-format"; · 6 unmodified lines
40	import {	40	import {
41	RuntimeLocalWorkspaceService,	41	RuntimeLocalWorkspaceService,
42	type RuntimeLocalWorkspaceState,	42	type RuntimeLocalWorkspaceState,
43	} from "../../local/runtime-context";	43	} from "../../workspace/runtime-context";
44	import type { LocalSourceArtifact } from "../../local/source-artifacts";	44	import type { LocalSourceArtifact } from "../../source-artifacts";
45	import {	45	import {
46	SourceArtifactStore,	46	SourceArtifactStore,
47	type SourceArtifactStoreShape,	47	type SourceArtifactStoreShape,
48	} from "../../local/storage";	48	} from "../../workspace/storage";
49	import {	49	import {
50	RuntimeSourceStoreService,	50	RuntimeSourceStoreService,
51	type RuntimeSourceStore,	51	type RuntimeSourceStore,
@@ -704,17 +704,16 @@ type SourceCatalogRuntimeServices = · 652 unmodified lines
704	const ensureRuntimeCatalogWorkspace = (	704	const ensureRuntimeCatalogWorkspace = (
705	deps: RuntimeSourceCatalogStoreDeps,	705	deps: RuntimeSourceCatalogStoreDeps,
706	workspaceId: WorkspaceId,	706	workspaceId: WorkspaceId,
707	) => {	707	) =>
		708	Effect.gen(function* () {
708	if (deps.runtimeLocalWorkspace.installation.workspaceId !== workspaceId) {	709	if (deps.runtimeLocalWorkspace.installation.workspaceId !== workspaceId) {
709	return Effect.fail(	710	return yield* Effect.fail(
710	runtimeEffectError("catalog/source/runtime",	711	runtimeEffectError("catalog/source/runtime",
711	`Runtime local workspace mismatch: expected ${workspaceId}, got ${deps.runtimeLocalWorkspace.installation.workspaceId}`,	712	`Runtime local workspace mismatch: expected ${workspaceId}, got ${deps.runtimeLocalWorkspace.installation.workspaceId}`,
712	),	713	),
713	);	714	);
714	}	715	}
715		716	});
716	return Effect.succeed(deps.runtimeLocalWorkspace.context);
717	};
718		717
719	const buildSnapshotFromArtifact = (input: {	718	const buildSnapshotFromArtifact = (input: {
720	source: Source;	719	source: Source;
@@ -728,10 +727,7 @@ const loadWorkspaceSourceCatalogsWithDeps = (deps: RuntimeSourceCatalogStoreDeps · 7 unmodified lines
728	actorAccountId?: AccountId \| null;	727	actorAccountId?: AccountId \| null;
729	}): Effect.Effect<readonly LoadedSourceCatalog[], Error, never> =>	728	}): Effect.Effect<readonly LoadedSourceCatalog[], Error, never> =>
730	Effect.gen(function* () {	729	Effect.gen(function* () {
731	const workspaceContext = yield* ensureRuntimeCatalogWorkspace(	730	yield* ensureRuntimeCatalogWorkspace(deps, input.workspaceId);
732	deps,
733	input.workspaceId,
734	);
735	const sources = yield* deps.sourceStore.loadSourcesInWorkspace(	731	const sources = yield* deps.sourceStore.loadSourcesInWorkspace(
736	input.workspaceId,	732	input.workspaceId,
737	{	733	{
@@ -742,7 +738,6 @@ const loadWorkspaceSourceCatalogsWithDeps = (deps: RuntimeSourceCatalogStoreDeps · 4 unmodified lines
742	const localCatalogs = yield* Effect.forEach(sources, (source) =>	738	const localCatalogs = yield* Effect.forEach(sources, (source) =>
743	Effect.gen(function* () {	739	Effect.gen(function* () {
744	const artifact = yield* deps.sourceArtifactStore.read({	740	const artifact = yield* deps.sourceArtifactStore.read({
745	context: workspaceContext,
746	sourceId: source.id,	741	sourceId: source.id,
747	});	742	});
748	if (artifact === null) {	743	if (artifact === null) {
@@ -783,17 +778,13 @@ const loadSourceWithCatalogWithDeps = (deps: RuntimeSourceCatalogStoreDeps, inpu · 34 unmodified lines
783	actorAccountId?: AccountId \| null;	778	actorAccountId?: AccountId \| null;
784	}): Effect.Effect<LoadedSourceCatalog, Error \| LocalSourceArtifactMissingError, never> =>	779	}): Effect.Effect<LoadedSourceCatalog, Error \| LocalSourceArtifactMissingError, never> =>
785	Effect.gen(function* () {	780	Effect.gen(function* () {
786	const workspaceContext = yield* ensureRuntimeCatalogWorkspace(	781	yield* ensureRuntimeCatalogWorkspace(deps, input.workspaceId);
787	deps,
788	input.workspaceId,
789	);
790	const source = yield* deps.sourceStore.loadSourceById({	782	const source = yield* deps.sourceStore.loadSourceById({
791	workspaceId: input.workspaceId,	783	workspaceId: input.workspaceId,
792	sourceId: input.sourceId,	784	sourceId: input.sourceId,
793	actorAccountId: input.actorAccountId,	785	actorAccountId: input.actorAccountId,
794	});	786	});
795	const artifact = yield* deps.sourceArtifactStore.read({	787	const artifact = yield* deps.sourceArtifactStore.read({
796	context: workspaceContext,
797	sourceId: source.id,	788	sourceId: source.id,
798	});	789	});
799	if (artifact === null) {	790	if (artifact === null) {

packages/platform/sdk/src/runtime/catalog/source/sync.ts+34−42

@@ -11,16 +11,16 @@ import * as Layer from "effect/Layer"; · 10 unmodified lines
11	import {	11	import {
12	RuntimeLocalWorkspaceService,	12	RuntimeLocalWorkspaceService,
13	type RuntimeLocalWorkspaceState,	13	type RuntimeLocalWorkspaceState,
14	} from "../../local/runtime-context";	14	} from "../../workspace/runtime-context";
15	import {	15	import {
16	SourceArtifactStore,	16	SourceArtifactStore,
17	type SourceArtifactStoreShape,	17	type SourceArtifactStoreShape,
18	WorkspaceStateStore,	18	WorkspaceStateStore,
19	type WorkspaceStateStoreShape,	19	type WorkspaceStateStoreShape,
20	} from "../../local/storage";	20	} from "../../workspace/storage";
21	import {	21	import {
22	type LocalWorkspaceState,	22	type LocalWorkspaceState,
23	} from "../../local/workspace-state";	23	} from "../../workspace-state";
24	import {	24	import {
25	RuntimeSourceAuthMaterialService,	25	RuntimeSourceAuthMaterialService,
26	} from "../../auth/source-auth-material";	26	} from "../../auth/source-auth-material";
@@ -30,10 +30,11 @@ import { · 3 unmodified lines
30	import {	30	import {
31	catalogSyncResultFromMcpManifest,	31	catalogSyncResultFromMcpManifest,
32	} from "@executor/source-mcp";	32	} from "@executor/source-mcp";
33	import { SecretMaterialResolverService } from "../../local/secret-material-providers";	33	import { SecretMaterialResolverService } from "../../workspace/secret-material-providers";
34	import { snapshotFromSourceCatalogSyncResult } from "@executor/source-core";	34	import { snapshotFromSourceCatalogSyncResult } from "@executor/source-core";
35	import {	35	import {
36	refreshSourceTypeDeclarationInBackground,	36	SourceTypeDeclarationsRefresherService,
		37	type SourceTypeDeclarationsRefresherShape,
37	} from "./type-declarations";	38	} from "./type-declarations";
38	import { runtimeEffectError } from "../../effect-errors";	39	import { runtimeEffectError } from "../../effect-errors";
39		40
@@ -46,6 +47,7 @@ type RuntimeSourceCatalogSyncDeps = { · 6 unmodified lines
46	runtimeLocalWorkspace: RuntimeLocalWorkspaceState;	47	runtimeLocalWorkspace: RuntimeLocalWorkspaceState;
47	workspaceStateStore: WorkspaceStateStoreShape;	48	workspaceStateStore: WorkspaceStateStoreShape;
48	sourceArtifactStore: SourceArtifactStoreShape;	49	sourceArtifactStore: SourceArtifactStoreShape;
		50	sourceTypeDeclarationsRefresher: SourceTypeDeclarationsRefresherShape;
49	resolveSecretMaterial: Effect.Effect.Success<typeof SecretMaterialResolverService>;	51	resolveSecretMaterial: Effect.Effect.Success<typeof SecretMaterialResolverService>;
50	sourceAuthMaterialService: Effect.Effect.Success<typeof RuntimeSourceAuthMaterialService>;	52	sourceAuthMaterialService: Effect.Effect.Success<typeof RuntimeSourceAuthMaterialService>;
51	};	53	};
@@ -54,6 +56,7 @@ type SourceCatalogSyncServices = · 2 unmodified lines
54	\| RuntimeLocalWorkspaceService	56	\| RuntimeLocalWorkspaceService
55	\| WorkspaceStateStore	57	\| WorkspaceStateStore
56	\| SourceArtifactStore	58	\| SourceArtifactStore
		59	\| SourceTypeDeclarationsRefresherService
57	\| RuntimeSourceAuthMaterialService	60	\| RuntimeSourceAuthMaterialService
58	\| SecretMaterialResolverService;	61	\| SecretMaterialResolverService;
59		62
@@ -75,17 +78,16 @@ export class RuntimeSourceCatalogSyncService extends Context.Tag( · 15 unmodified lines
75	const ensureRuntimeCatalogSyncWorkspace = (	78	const ensureRuntimeCatalogSyncWorkspace = (
76	deps: RuntimeSourceCatalogSyncDeps,	79	deps: RuntimeSourceCatalogSyncDeps,
77	workspaceId: Source["workspaceId"],	80	workspaceId: Source["workspaceId"],
78	) => {	81	) =>
		82	Effect.gen(function* () {
79	if (deps.runtimeLocalWorkspace.installation.workspaceId !== workspaceId) {	83	if (deps.runtimeLocalWorkspace.installation.workspaceId !== workspaceId) {
80	return Effect.fail(	84	return yield* Effect.fail(
81	runtimeEffectError("catalog/source/sync",	85	runtimeEffectError("catalog/source/sync",
82	`Runtime local workspace mismatch: expected ${workspaceId}, got ${deps.runtimeLocalWorkspace.installation.workspaceId}`,	86	`Runtime local workspace mismatch: expected ${workspaceId}, got ${deps.runtimeLocalWorkspace.installation.workspaceId}`,
83	),	87	),
84	);	88	);
85	}	89	}
86		90	});
87	return Effect.succeed(deps.runtimeLocalWorkspace.context);
88	};
89		91
90	const syncSourceCatalogWithDeps = (	92	const syncSourceCatalogWithDeps = (
91	deps: RuntimeSourceCatalogSyncDeps,	93	deps: RuntimeSourceCatalogSyncDeps,
@@ -95,13 +97,10 @@ const syncSourceCatalogWithDeps = ( · 3 unmodified lines
95	},	97	},
96	): Effect.Effect<void, Error, never> =>	98	): Effect.Effect<void, Error, never> =>
97	Effect.gen(function* () {	99	Effect.gen(function* () {
98	const workspaceContext = yield* ensureRuntimeCatalogSyncWorkspace(	100	yield* ensureRuntimeCatalogSyncWorkspace(deps, input.source.workspaceId);
99	deps,
100	input.source.workspaceId,
101	);
102		101
103	if (!shouldIndexSource(input.source)) {	102	if (!shouldIndexSource(input.source)) {
104	const state = yield* deps.workspaceStateStore.load(workspaceContext);	103	const state = yield* deps.workspaceStateStore.load();
105	const existingSourceState = state.sources[input.source.id];	104	const existingSourceState = state.sources[input.source.id];
106	const nextState: LocalWorkspaceState = {	105	const nextState: LocalWorkspaceState = {
107	...state,	106	...state,
@@ -117,15 +116,11 @@ const syncSourceCatalogWithDeps = ( · 9 unmodified lines
117	},	116	},
118	};	117	};
119	yield* deps.workspaceStateStore.write({	118	yield* deps.workspaceStateStore.write({
120	context: workspaceContext,
121	state: nextState,	119	state: nextState,
122	});	120	});
123	yield* Effect.sync(() => {	121	yield* deps.sourceTypeDeclarationsRefresher.refreshSourceInBackground({
124	refreshSourceTypeDeclarationInBackground({	122	source: input.source,
125	context: workspaceContext,	123	snapshot: null,
126	source: input.source,
127	snapshot: null,
128	});
129	});	124	});
130	return;	125	return;
131	}	126	}
@@ -143,7 +138,6 @@ const syncSourceCatalogWithDeps = ( · 11 unmodified lines
143	});	138	});
144	const snapshot = snapshotFromSourceCatalogSyncResult(syncResult);	139	const snapshot = snapshotFromSourceCatalogSyncResult(syncResult);
145	yield* deps.sourceArtifactStore.write({	140	yield* deps.sourceArtifactStore.write({
146	context: workspaceContext,
147	sourceId: input.source.id,	141	sourceId: input.source.id,
148	artifact: deps.sourceArtifactStore.build({	142	artifact: deps.sourceArtifactStore.build({
149	source: input.source,	143	source: input.source,
@@ -151,7 +145,7 @@ const syncSourceCatalogWithDeps = ( · 1 unmodified line
151	}),	145	}),
152	});	146	});
153		147
154	const state = yield* deps.workspaceStateStore.load(workspaceContext);	148	const state = yield* deps.workspaceStateStore.load();
155	const existingSourceState = state.sources[input.source.id];	149	const existingSourceState = state.sources[input.source.id];
156	const nextState: LocalWorkspaceState = {	150	const nextState: LocalWorkspaceState = {
157	...state,	151	...state,
@@ -167,16 +161,12 @@ const syncSourceCatalogWithDeps = ( · 9 unmodified lines
167	},	161	},
168	};	162	};
169	yield* deps.workspaceStateStore.write({	163	yield* deps.workspaceStateStore.write({
170	context: workspaceContext,
171	state: nextState,	164	state: nextState,
172	});	165	});
173		166
174	yield* Effect.sync(() => {	167	yield* deps.sourceTypeDeclarationsRefresher.refreshSourceInBackground({
175	refreshSourceTypeDeclarationInBackground({	168	source: input.source,
176	context: workspaceContext,	169	snapshot,
177	source: input.source,
178	snapshot,
179	});
180	});	170	});
181	}).pipe(	171	}).pipe(
182	Effect.withSpan("source.catalog.sync", {	172	Effect.withSpan("source.catalog.sync", {
@@ -197,10 +187,7 @@ const persistMcpCatalogSnapshotFromManifestWithDeps = ( · 14 unmodified lines
197	},	187	},
198	): Effect.Effect<void, Error, never> =>	188	): Effect.Effect<void, Error, never> =>
199	Effect.gen(function* () {	189	Effect.gen(function* () {
200	const workspaceContext = yield* ensureRuntimeCatalogSyncWorkspace(	190	yield* ensureRuntimeCatalogSyncWorkspace(deps, input.source.workspaceId);
201	deps,
202	input.source.workspaceId,
203	);
204	const syncResult = catalogSyncResultFromMcpManifest({	191	const syncResult = catalogSyncResultFromMcpManifest({
205	source: input.source,	192	source: input.source,
206	endpoint: input.source.endpoint,	193	endpoint: input.source.endpoint,
@@ -209,7 +196,6 @@ const persistMcpCatalogSnapshotFromManifestWithDeps = ( · 2 unmodified lines
209	const snapshot = snapshotFromSourceCatalogSyncResult(syncResult);	196	const snapshot = snapshotFromSourceCatalogSyncResult(syncResult);
210		197
211	yield* deps.sourceArtifactStore.write({	198	yield* deps.sourceArtifactStore.write({
212	context: workspaceContext,
213	sourceId: input.source.id,	199	sourceId: input.source.id,
214	artifact: deps.sourceArtifactStore.build({	200	artifact: deps.sourceArtifactStore.build({
215	source: input.source,	201	source: input.source,
@@ -217,12 +203,9 @@ const persistMcpCatalogSnapshotFromManifestWithDeps = ( · 1 unmodified line
217	}),	203	}),
218	});	204	});
219		205
220	yield* Effect.sync(() => {	206	yield* deps.sourceTypeDeclarationsRefresher.refreshSourceInBackground({
221	refreshSourceTypeDeclarationInBackground({	207	source: input.source,
222	context: workspaceContext,	208	snapshot,
223	source: input.source,
224	snapshot,
225	});
226	});	209	});
227	});	210	});
228		211
@@ -234,6 +217,8 @@ export const syncSourceCatalog = (input: { · 5 unmodified lines
234	const runtimeLocalWorkspace = yield* RuntimeLocalWorkspaceService;	217	const runtimeLocalWorkspace = yield* RuntimeLocalWorkspaceService;
235	const workspaceStateStore = yield* WorkspaceStateStore;	218	const workspaceStateStore = yield* WorkspaceStateStore;
236	const sourceArtifactStore = yield* SourceArtifactStore;	219	const sourceArtifactStore = yield* SourceArtifactStore;
		220	const sourceTypeDeclarationsRefresher =
		221	yield* SourceTypeDeclarationsRefresherService;
237	const resolveSecretMaterial = yield* SecretMaterialResolverService;	222	const resolveSecretMaterial = yield* SecretMaterialResolverService;
238	const sourceAuthMaterialService = yield* RuntimeSourceAuthMaterialService;	223	const sourceAuthMaterialService = yield* RuntimeSourceAuthMaterialService;
239		224
@@ -242,6 +227,7 @@ export const syncSourceCatalog = (input: { · 2 unmodified lines
242	runtimeLocalWorkspace,	227	runtimeLocalWorkspace,
243	workspaceStateStore,	228	workspaceStateStore,
244	sourceArtifactStore,	229	sourceArtifactStore,
		230	sourceTypeDeclarationsRefresher,
245	resolveSecretMaterial,	231	resolveSecretMaterial,
246	sourceAuthMaterialService,	232	sourceAuthMaterialService,
247	},	233	},
@@ -260,6 +246,8 @@ export const persistMcpCatalogSnapshotFromManifest = (input: { · 12 unmodified lines
260	const runtimeLocalWorkspace = yield* RuntimeLocalWorkspaceService;	246	const runtimeLocalWorkspace = yield* RuntimeLocalWorkspaceService;
261	const workspaceStateStore = yield* WorkspaceStateStore;	247	const workspaceStateStore = yield* WorkspaceStateStore;
262	const sourceArtifactStore = yield* SourceArtifactStore;	248	const sourceArtifactStore = yield* SourceArtifactStore;
		249	const sourceTypeDeclarationsRefresher =
		250	yield* SourceTypeDeclarationsRefresherService;
263	const resolveSecretMaterial = yield* SecretMaterialResolverService;	251	const resolveSecretMaterial = yield* SecretMaterialResolverService;
264	const sourceAuthMaterialService = yield* RuntimeSourceAuthMaterialService;	252	const sourceAuthMaterialService = yield* RuntimeSourceAuthMaterialService;
265		253
@@ -268,6 +256,7 @@ export const persistMcpCatalogSnapshotFromManifest = (input: { · 2 unmodified lines
268	runtimeLocalWorkspace,	256	runtimeLocalWorkspace,
269	workspaceStateStore,	257	workspaceStateStore,
270	sourceArtifactStore,	258	sourceArtifactStore,
		259	sourceTypeDeclarationsRefresher,
271	resolveSecretMaterial,	260	resolveSecretMaterial,
272	sourceAuthMaterialService,	261	sourceAuthMaterialService,
273	},	262	},
@@ -281,6 +270,8 @@ export const RuntimeSourceCatalogSyncLive = Layer.effect( · 7 unmodified lines
281	const runtimeLocalWorkspace = yield* RuntimeLocalWorkspaceService;	270	const runtimeLocalWorkspace = yield* RuntimeLocalWorkspaceService;
282	const workspaceStateStore = yield* WorkspaceStateStore;	271	const workspaceStateStore = yield* WorkspaceStateStore;
283	const sourceArtifactStore = yield* SourceArtifactStore;	272	const sourceArtifactStore = yield* SourceArtifactStore;
		273	const sourceTypeDeclarationsRefresher =
		274	yield* SourceTypeDeclarationsRefresherService;
284	const resolveSecretMaterial = yield* SecretMaterialResolverService;	275	const resolveSecretMaterial = yield* SecretMaterialResolverService;
285	const sourceAuthMaterialService = yield* RuntimeSourceAuthMaterialService;	276	const sourceAuthMaterialService = yield* RuntimeSourceAuthMaterialService;
286		277
@@ -288,6 +279,7 @@ export const RuntimeSourceCatalogSyncLive = Layer.effect( · 1 unmodified line
288	runtimeLocalWorkspace,	279	runtimeLocalWorkspace,
289	workspaceStateStore,	280	workspaceStateStore,
290	sourceArtifactStore,	281	sourceArtifactStore,
		282	sourceTypeDeclarationsRefresher,
291	resolveSecretMaterial,	283	resolveSecretMaterial,
292	sourceAuthMaterialService,	284	sourceAuthMaterialService,
293	};	285	};

packages/platform/sdk/src/runtime/catalog/source/type-declarations.ts+14−418

@@ -1,427 +1,23 @@
1	import { join } from "node:path";
2	import { FileSystem } from "@effect/platform";
3	import { NodeFileSystem } from "@effect/platform-node";
4	import type { Source } from "#schema";	1	import type { Source } from "#schema";
5	import * as Cause from "effect/Cause";
6	import * as Effect from "effect/Effect";
7	import * as Fiber from "effect/Fiber";
8
9	import { projectCatalogForAgentSdk } from "@executor/ir/catalog";
10	import type { CatalogSnapshotV1 } from "@executor/ir/model";	2	import type { CatalogSnapshotV1 } from "@executor/ir/model";
11	import {	3	import * as Context from "effect/Context";
12	createCatalogTypeProjector,	4	import * as Effect from "effect/Effect";
13	formatPropertyKey,
14	joinTypeNameSegments,
15	projectedCatalogTypeRoots,
16	shapeAllowsOmittedArgs,
17	} from "../catalog-typescript";
18	import type { ResolvedLocalWorkspaceContext } from "../../local/config";
19	import {
20	LocalFileSystemError,
21	unknownLocalErrorDetails,
22	} from "../../local/errors";
23		5
24	type SourceDeclarationEntry = {	6	export type BoundSourceDeclarationEntry = {
25	source: Source;	7	source: Source;
26	snapshot: CatalogSnapshotV1;	8	snapshot: CatalogSnapshotV1;
27	};	9	};
28		10
29	type ToolMethodNode = {	11	export type SourceTypeDeclarationsRefresherShape = {
30	readonly segments: readonly string[];	12	refreshWorkspaceInBackground: (input: {
31	readonly inputType: string;	13	entries: readonly BoundSourceDeclarationEntry[];
32	readonly outputType: string;	14	}) => Effect.Effect<void, never, never>;
33	readonly argsOptional: boolean;	15	refreshSourceInBackground: (input: {
34	};	16	source: Source;
35		17	snapshot: CatalogSnapshotV1 \| null;
36	type SourceDeclarationModel = {	18	}) => Effect.Effect<void, never, never>;
37	readonly methods: readonly ToolMethodNode[];
38	readonly supportingTypes: readonly string[];
39	};
40
41	type ToolTreeNode = {
42	method: ToolMethodNode \| null;
43	children: Map<string, ToolTreeNode>;
44	};
45
46	type SourceDeclarationStub = {
47	sourceId: string;
48	};
49
50	const GENERATED_TYPES_DIRECTORY = "types";
51	const GENERATED_SOURCE_TYPES_DIRECTORY = "sources";
52
53	const mapFileSystemError = (path: string, action: string) => (cause: unknown) =>
54	new LocalFileSystemError({
55	message: `Failed to ${action} ${path}: ${unknownLocalErrorDetails(cause)}`,
56	action,
57	path,
58	details: unknownLocalErrorDetails(cause),
59	});
60
61	const declarationDirectory = (context: ResolvedLocalWorkspaceContext): string =>
62	join(context.configDirectory, GENERATED_TYPES_DIRECTORY);
63
64	const sourceDeclarationDirectory = (context: ResolvedLocalWorkspaceContext): string =>
65	join(declarationDirectory(context), GENERATED_SOURCE_TYPES_DIRECTORY);
66
67	const sourceDeclarationFileName = (sourceId: string): string => `${sourceId}.d.ts`;
68
69	const sourceDeclarationPath = (context: ResolvedLocalWorkspaceContext, sourceId: string): string =>
70	join(sourceDeclarationDirectory(context), sourceDeclarationFileName(sourceId));
71
72	const aggregateDeclarationPath = (context: ResolvedLocalWorkspaceContext): string =>
73	join(declarationDirectory(context), "index.d.ts");
74
75	const sourceTypeInterfaceName = (sourceId: string): string =>
76	`SourceTools_${sourceId.replace(/[^A-Za-z0-9_$]+/g, "_")}`;
77
78	const methodSignature = (method: ToolMethodNode): string =>
79	`(${method.argsOptional ? "args?:" : "args:"} ${method.inputType}) => Promise<${method.outputType}>`;
80
81	const createToolTreeNode = (): ToolTreeNode => ({
82	method: null,
83	children: new Map(),
84	});
85
86	const objectTypeLiteral = (
87	lines: readonly string[],
88	indent: string,
89	): string => {
90	if (lines.length === 0) {
91	return "{}";
92	}
93
94	return [
95	"{",
96	...lines.map((line) => `${indent}${line}`),
97	`${indent.slice(0, -2)}}`,
98	].join("\n");
99	};
100
101	const renderToolTreeType = (node: ToolTreeNode, indentLevel: number): string => {
102	const indent = " ".repeat(indentLevel + 1);
103	const childLines = [...node.children.entries()]
104	.sort(([left], [right]) => left.localeCompare(right))
105	.map(([segment, child]) =>
106	`${formatPropertyKey(segment)}: ${renderToolTreeType(child, indentLevel + 1)};`
107	);
108
109	const objectType = objectTypeLiteral(childLines, indent);
110	if (node.method === null) {
111	return objectType;
112	}
113
114	const callable = methodSignature(node.method);
115	return node.children.size === 0
116	? callable
117	: `(${callable}) & ${objectType}`;
118	};
119
120	const buildToolTree = (methods: readonly ToolMethodNode[]): ToolTreeNode => {
121	const root = createToolTreeNode();
122
123	for (const method of methods) {
124	let current = root;
125	for (const segment of method.segments) {
126	const existing = current.children.get(segment);
127	if (existing) {
128	current = existing;
129	continue;
130	}
131
132	const next = createToolTreeNode();
133	current.children.set(segment, next);
134	current = next;
135	}
136
137	current.method = method;
138	}
139
140	return root;
141	};
142
143	const buildSourceDeclarationModel = (snapshot: CatalogSnapshotV1): SourceDeclarationModel => {
144	const projected = projectCatalogForAgentSdk({
145	catalog: snapshot.catalog,
146	});
147	const toolDescriptors = Object.values(projected.toolDescriptors)
148	.sort((left, right) => left.toolPath.join(".").localeCompare(right.toolPath.join(".")));
149	const renderer = createCatalogTypeProjector({
150	catalog: projected.catalog,
151	roots: projectedCatalogTypeRoots(projected),
152	});
153
154	const methods = toolDescriptors
155	.map((descriptor) => ({
156	segments: descriptor.toolPath,
157	inputType: renderer.renderDeclarationShape(descriptor.callShapeId, {
158	aliasHint: joinTypeNameSegments(...descriptor.toolPath, "call"),
159	}),
160	outputType: descriptor.resultShapeId
161	? renderer.renderDeclarationShape(descriptor.resultShapeId, {
162	aliasHint: joinTypeNameSegments(...descriptor.toolPath, "result"),
163	})
164	: "unknown",
165	argsOptional: shapeAllowsOmittedArgs(projected.catalog, descriptor.callShapeId),
166	}) satisfies ToolMethodNode);
167
168	return {
169	methods,
170	supportingTypes: renderer.supportingDeclarations(),
171	};
172	};
173
174	const sourceDeclarationText = (entry: SourceDeclarationEntry): string => {
175	const interfaceName = sourceTypeInterfaceName(entry.source.id);
176	const declarationModel = buildSourceDeclarationModel(entry.snapshot);
177	const tree = buildToolTree(declarationModel.methods);
178	const body = renderToolTreeType(tree, 0);
179
180	return [
181	"// Generated by executor. Do not edit by hand.",
182	`// Source: ${entry.source.name} (${entry.source.id})`,
183	"",
184	...declarationModel.supportingTypes,
185	...(declarationModel.supportingTypes.length > 0 ? [""] : []),
186	`export interface ${interfaceName} ${body}`,
187	"",
188	`export declare const tools: ${interfaceName};`,
189	`export type ${interfaceName}Tools = ${interfaceName};`,
190	"export default tools;",
191	"",
192	].join("\n");
193	};
194
195	const aggregateDeclarationText = (entries: readonly SourceDeclarationEntry[]): string => {
196	return aggregateDeclarationTextFromSourceIds(
197	entries.map((entry) => ({ sourceId: entry.source.id })),
198	);
199	};
200
201	const aggregateDeclarationTextFromSourceIds = (entries: readonly SourceDeclarationStub[]): string => {
202	const sorted = [...entries].sort((left, right) => left.sourceId.localeCompare(right.sourceId));
203	const imports = sorted.map((entry) =>
204	`import type { ${sourceTypeInterfaceName(entry.sourceId)} } from "../sources/${entry.sourceId}";`
205	);
206	const intersections = sorted.map((entry) => sourceTypeInterfaceName(entry.sourceId));
207	const executorToolsType = intersections.length > 0
208	? intersections.join(" & ")
209	: "{}";
210
211	return [
212	"// Generated by executor. Do not edit by hand.",
213	...imports,
214	...(imports.length > 0 ? [""] : []),
215	`export type ExecutorSourceTools = ${executorToolsType};`,
216	"",
217	"declare global {",
218	" const tools: ExecutorSourceTools;",
219	"}",
220	"",
221	"export declare const tools: ExecutorSourceTools;",
222	"export default tools;",
223	"",
224	].join("\n");
225	};
226
227	export const syncWorkspaceSourceTypeDeclarations = (input: {
228	context: ResolvedLocalWorkspaceContext;
229	entries: readonly SourceDeclarationEntry[];
230	}): Effect.Effect<void, LocalFileSystemError, FileSystem.FileSystem> =>
231	Effect.gen(function* () {
232	const fs = yield* FileSystem.FileSystem;
233	const declarationsDir = declarationDirectory(input.context);
234	const perSourceDir = sourceDeclarationDirectory(input.context);
235	const activeEntries = input.entries
236	.filter((entry) => entry.source.enabled && entry.source.status === "connected")
237	.sort((left, right) => left.source.id.localeCompare(right.source.id));
238
239	yield* fs.makeDirectory(declarationsDir, { recursive: true }).pipe(
240	Effect.mapError(mapFileSystemError(declarationsDir, "create declaration directory")),
241	);
242	yield* fs.makeDirectory(perSourceDir, { recursive: true }).pipe(
243	Effect.mapError(mapFileSystemError(perSourceDir, "create source declaration directory")),
244	);
245
246	const expectedFiles = new Set(
247	activeEntries.map((entry) => sourceDeclarationFileName(entry.source.id)),
248	);
249	const existingFiles = yield* fs.readDirectory(perSourceDir).pipe(
250	Effect.mapError(mapFileSystemError(perSourceDir, "read source declaration directory")),
251	);
252
253	for (const existingFile of existingFiles) {
254	if (expectedFiles.has(existingFile)) {
255	continue;
256	}
257
258	const stalePath = join(perSourceDir, existingFile);
259	yield* fs.remove(stalePath).pipe(
260	Effect.mapError(mapFileSystemError(stalePath, "remove stale source declaration")),
261	);
262	}
263
264	for (const entry of activeEntries) {
265	const filePath = sourceDeclarationPath(input.context, entry.source.id);
266	yield* fs.writeFileString(filePath, sourceDeclarationText(entry)).pipe(
267	Effect.mapError(mapFileSystemError(filePath, "write source declaration")),
268	);
269	}
270
271	const aggregatePath = aggregateDeclarationPath(input.context);
272	yield* fs.writeFileString(
273	aggregatePath,
274	aggregateDeclarationText(activeEntries),
275	).pipe(
276	Effect.mapError(mapFileSystemError(aggregatePath, "write aggregate declaration")),
277	);
278	});
279
280	export const syncSourceTypeDeclaration = (input: {
281	context: ResolvedLocalWorkspaceContext;
282	source: Source;
283	snapshot: CatalogSnapshotV1 \| null;
284	}): Effect.Effect<void, LocalFileSystemError, FileSystem.FileSystem> =>
285	Effect.gen(function* () {
286	const fs = yield* FileSystem.FileSystem;
287	const declarationsDir = declarationDirectory(input.context);
288	const perSourceDir = sourceDeclarationDirectory(input.context);
289
290	yield* fs.makeDirectory(declarationsDir, { recursive: true }).pipe(
291	Effect.mapError(mapFileSystemError(declarationsDir, "create declaration directory")),
292	);
293	yield* fs.makeDirectory(perSourceDir, { recursive: true }).pipe(
294	Effect.mapError(mapFileSystemError(perSourceDir, "create source declaration directory")),
295	);
296
297	const filePath = sourceDeclarationPath(input.context, input.source.id);
298	const shouldWrite = input.source.enabled
299	&& input.source.status === "connected"
300	&& input.snapshot !== null;
301
302	if (shouldWrite) {
303	const snapshot = input.snapshot;
304	if (snapshot === null) {
305	return;
306	}
307	yield* fs.writeFileString(
308	filePath,
309	sourceDeclarationText({
310	source: input.source,
311	snapshot,
312	}),
313	).pipe(
314	Effect.mapError(mapFileSystemError(filePath, "write source declaration")),
315	);
316	} else {
317	const exists = yield* fs.exists(filePath).pipe(
318	Effect.mapError(mapFileSystemError(filePath, "check source declaration path")),
319	);
320	if (exists) {
321	yield* fs.remove(filePath).pipe(
322	Effect.mapError(mapFileSystemError(filePath, "remove source declaration")),
323	);
324	}
325	}
326
327	const sourceIds = (yield* fs.readDirectory(perSourceDir).pipe(
328	Effect.mapError(mapFileSystemError(perSourceDir, "read source declaration directory")),
329	))
330	.filter((fileName) => fileName.endsWith(".d.ts"))
331	.map((fileName) => ({ sourceId: fileName.slice(0, -".d.ts".length) }));
332
333	const aggregatePath = aggregateDeclarationPath(input.context);
334	yield* fs.writeFileString(
335	aggregatePath,
336	aggregateDeclarationTextFromSourceIds(sourceIds),
337	).pipe(
338	Effect.mapError(mapFileSystemError(aggregatePath, "write aggregate declaration")),
339	);
340	});
341
342	export const syncWorkspaceSourceTypeDeclarationsNode = (input: {
343	context: ResolvedLocalWorkspaceContext;
344	entries: readonly SourceDeclarationEntry[];
345	}): Effect.Effect<void, LocalFileSystemError, never> =>
346	syncWorkspaceSourceTypeDeclarations(input).pipe(Effect.provide(NodeFileSystem.layer));
347
348	export const syncSourceTypeDeclarationNode = (input: {
349	context: ResolvedLocalWorkspaceContext;
350	source: Source;
351	snapshot: CatalogSnapshotV1 \| null;
352	}): Effect.Effect<void, LocalFileSystemError, never> =>
353	syncSourceTypeDeclaration(input).pipe(Effect.provide(NodeFileSystem.layer));
354
355	const logBackgroundDeclarationError = (label: string, cause: unknown): void => {
356	const message = Cause.isCause(cause)
357	? Cause.pretty(cause)
358	: cause instanceof Error
359	? cause.message
360	: String(cause);
361	console.warn(`[source-types] ${label} failed: ${message}`);
362	};
363
364	const BACKGROUND_DECLARATION_REFRESH_DELAY = "1500 millis";
365	const workspaceRefreshFibers = new Map<string, Fiber.RuntimeFiber<void, never>>();
366	const sourceRefreshFibers = new Map<string, Fiber.RuntimeFiber<void, never>>();
367
368	export const refreshWorkspaceSourceTypeDeclarationsInBackground = (input: {
369	context: ResolvedLocalWorkspaceContext;
370	entries: readonly SourceDeclarationEntry[];
371	}): void => {
372	const key = input.context.configDirectory;
373	const existingFiber = workspaceRefreshFibers.get(key);
374	if (existingFiber) {
375	Effect.runFork(Fiber.interruptFork(existingFiber));
376	}
377
378	const fiber = Effect.runFork(
379	Effect.sleep(BACKGROUND_DECLARATION_REFRESH_DELAY).pipe(
380	Effect.zipRight(
381	syncWorkspaceSourceTypeDeclarationsNode(input).pipe(
382	Effect.catchAllCause((cause) =>
383	Effect.sync(() => {
384	logBackgroundDeclarationError("workspace declaration refresh", cause);
385	})
386	),
387	),
388	),
389	),
390	);
391
392	workspaceRefreshFibers.set(key, fiber);
393	fiber.addObserver(() => {
394	workspaceRefreshFibers.delete(key);
395	});
396	};	19	};
397		20
398	export const refreshSourceTypeDeclarationInBackground = (input: {	21	export class SourceTypeDeclarationsRefresherService extends Context.Tag(
399	context: ResolvedLocalWorkspaceContext;	22	"#runtime/SourceTypeDeclarationsRefresherService",
400	source: Source;	23	)<SourceTypeDeclarationsRefresherService, SourceTypeDeclarationsRefresherShape>() {}
401	snapshot: CatalogSnapshotV1 \| null;
402	}): void => {
403	const key = `${input.context.configDirectory}:${input.source.id}`;
404	const existingFiber = sourceRefreshFibers.get(key);
405	if (existingFiber) {
406	Effect.runFork(Fiber.interruptFork(existingFiber));
407	}
408
409	const fiber = Effect.runFork(
410	Effect.sleep(BACKGROUND_DECLARATION_REFRESH_DELAY).pipe(
411	Effect.zipRight(
412	syncSourceTypeDeclarationNode(input).pipe(
413	Effect.catchAllCause((cause) =>
414	Effect.sync(() => {
415	logBackgroundDeclarationError(`source ${input.source.id} declaration refresh`, cause);
416	})
417	),
418	),
419	),
420	),
421	);
422
423	sourceRefreshFibers.set(key, fiber);
424	fiber.addObserver(() => {
425	sourceRefreshFibers.delete(key);
426	});
427	};

packages/platform/sdk/src/runtime/control-plane-runtime.test.ts+9−11

   provideControlPlaneRuntime,
   RuntimeExecutionResolverService,
 } from "./index";
-import { createLocalControlPlaneRuntime as createControlPlaneRuntime } from "../../../sdk-file/src/index";
 import { createSourceFromPayload } from "./sources/source-definitions";
 import { decodeSourceCredentialSelectionContent } from "./sources/source-credential-interactions";
 import { persistSource } from "./sources/source-store";
 import { withControlPlaneClient } from "./execution/test-http-client";
 import { runtimeEffectError } from "./effect-errors";
 import {
+  buildLocalSourceArtifact,
+  createLocalControlPlaneRuntime as createControlPlaneRuntime,
+  deriveLocalInstallation,
+  readLocalSourceArtifact,
   resolveLocalWorkspaceContext,
+  writeLocalControlPlaneState,
+  writeLocalSourceArtifact,
   writeProjectLocalExecutorConfig,
-} from "./local/config";
+  writeLocalWorkspaceState,
-import { writeLocalControlPlaneState } from "./local/control-plane-store";
+} from "../../../sdk-file/src/index";
-import { deriveLocalInstallation } from "./local/installation";
 import {
   decodeSourceCredentialInteraction,
   submitSourceCredentialInteraction,
-} from "./local/operations";
+} from "../local/operations";
-import {
-  buildLocalSourceArtifact,
-  readLocalSourceArtifact,
-  writeLocalSourceArtifact,
-} from "./local/source-artifacts";
-import { writeLocalWorkspaceState } from "./local/workspace-state";
 const makeRuntime = Effect.gen(function* () {
   const fs = yield* FileSystem.FileSystem;

packages/platform/sdk/src/runtime/execution/service.ts+1−1

@@ -38,7 +38,7 @@ import { · 37 unmodified lines
38	import {	38	import {
39	getRuntimeLocalWorkspaceOption,	39	getRuntimeLocalWorkspaceOption,
40	provideOptionalRuntimeLocalWorkspace,	40	provideOptionalRuntimeLocalWorkspace,
41	} from "../local/runtime-context";	41	} from "../workspace/runtime-context";
42	import {	42	import {
43	asOperationErrors,	43	asOperationErrors,
44	operationErrors,	44	operationErrors,

packages/platform/sdk/src/runtime/execution/workspace/authorization.ts+13−11

 import * as Schema from "effect/Schema";
 import type { LoadedSourceCatalogToolIndexEntry } from "../../catalog/source/runtime";
-import type { SecretMaterialResolveContext } from "../../local/secret-material-providers";
+import type { SecretMaterialResolveContext } from "../../workspace/secret-material-providers";
-import type { WorkspaceStorageServices } from "../../local/storage";
+import type { WorkspaceStorageServices } from "../../workspace/storage";
 import { invocationDescriptorFromTool } from "../ir-execution";
 import { evaluateInvocationPolicy } from "../../policy/invocation-policy-engine";
-import { loadRuntimeLocalWorkspacePolicies } from "../../policy/policies-operations";
+import { loadRuntimeLocalWorkspacePolicies } from "../../../policies/operations";
-import { runtimeEffectError } from "../../effect-errors";
 const asToolPath = (value: string): ToolPath => value as ToolPath;
   };
 };
+const failAuthorization = (message: string): Effect.Effect<never, Error, never> =>
+  Effect.fail(new Error(message));
 type WorkspaceToolElicitation = Parameters<
   typeof makeToolInvokerFromTools
 >[0]["onElicitation"];
     }
     if (decision.kind === "deny") {
-      return yield* runtimeEffectError("execution/workspace/authorization", decision.reason);
+      return yield* failAuthorization(decision.reason);
     }
     if (!input.onElicitation) {
-      return yield* runtimeEffectError("execution/workspace/authorization",
+      return yield* failAuthorization(
-          `Approval required for ${descriptor.toolPath}, but no elicitation-capable host is available`,
+        `Approval required for ${descriptor.toolPath}, but no elicitation-capable host is available`,
-        );
+      );
     }
     const interactionId =
       );
     if (response.action !== "accept") {
-      return yield* runtimeEffectError("execution/workspace/authorization",
+      return yield* failAuthorization(
-          `Tool invocation not approved for ${descriptor.toolPath}`,
+        `Tool invocation not approved for ${descriptor.toolPath}`,
-        );
+      );
     }
   });

packages/platform/sdk/src/runtime/execution/workspace/environment.ts+27−9

 import { RuntimeSourceCatalogStoreService } from "../../catalog/source/runtime";
 import { RuntimeSourceAuthMaterialService } from "../../auth/source-auth-material";
 import { RuntimeSourceCatalogSyncService } from "../../catalog/source/sync";
-import { getRuntimeLocalWorkspaceOption } from "../../local/runtime-context";
+import { getRuntimeLocalWorkspaceOption } from "../../workspace/runtime-context";
+import {
+  LocalInstanceConfigService,
+  SecretMaterialDeleterService,
+  SecretMaterialStorerService,
+  SecretMaterialUpdaterService,
+} from "../../workspace/secret-material-providers";
 import {
   LocalToolRuntimeLoaderService,
   type LocalToolRuntimeLoaderShape,
   type LocalToolRuntime,
-} from "../../local/tools";
+} from "../../local-tool-runtime";
 import {
   InstallationStore,
   type InstallationStoreShape,
   type WorkspaceConfigStoreShape,
   WorkspaceStateStore,
   type WorkspaceStateStoreShape,
-} from "../../local/storage";
+} from "../../workspace/storage";
 import { ControlPlaneStore } from "../../store";
 import { RuntimeSourceStoreService } from "../../sources/source-store";
 import type { CreateWorkspaceInternalToolMap } from "./tool-invoker";
     >;
     localToolRuntimeLoader: LocalToolRuntimeLoaderShape;
     installationStore: InstallationStoreShape;
+    instanceConfigResolver: Effect.Effect.Success<typeof LocalInstanceConfigService>;
+    storeSecretMaterial: Effect.Effect.Success<typeof SecretMaterialStorerService>;
+    deleteSecretMaterial: Effect.Effect.Success<typeof SecretMaterialDeleterService>;
+    updateSecretMaterial: Effect.Effect.Success<typeof SecretMaterialUpdaterService>;
     workspaceConfigStore: WorkspaceConfigStoreShape;
     workspaceStateStore: WorkspaceStateStoreShape;
     sourceArtifactStore: SourceArtifactStoreShape;
       const loadedConfig =
         runtimeLocalWorkspace === null
           ? null
-          : yield* input.workspaceConfigStore.load(
+          : yield* input.workspaceConfigStore.load();
-              runtimeLocalWorkspace.context,
-            );
       const localToolRuntime =
         runtimeLocalWorkspace === null
           ? createEmptyLocalToolRuntime()
-          : yield* input.localToolRuntimeLoader.load(
+          : yield* input.localToolRuntimeLoader.load();
-              runtimeLocalWorkspace.context,
-            );
       const { catalog, toolInvoker } = createWorkspaceToolInvoker({
         workspaceId,
         accountId,
         sourceCatalogSyncService: input.sourceCatalogSyncService,
         sourceCatalogStore: input.sourceCatalogStore,
         installationStore: input.installationStore,
+        instanceConfigResolver: input.instanceConfigResolver,
+        storeSecretMaterial: input.storeSecretMaterial,
+        deleteSecretMaterial: input.deleteSecretMaterial,
+        updateSecretMaterial: input.updateSecretMaterial,
         workspaceConfigStore: input.workspaceConfigStore,
         workspaceStateStore: input.workspaceStateStore,
         sourceArtifactStore: input.sourceArtifactStore,
           const sourceCatalogStore = yield* RuntimeSourceCatalogStoreService;
           const localToolRuntimeLoader = yield* LocalToolRuntimeLoaderService;
           const installationStore = yield* InstallationStore;
+          const instanceConfigResolver = yield* LocalInstanceConfigService;
+          const storeSecretMaterial = yield* SecretMaterialStorerService;
+          const deleteSecretMaterial = yield* SecretMaterialDeleterService;
+          const updateSecretMaterial = yield* SecretMaterialUpdaterService;
           const workspaceConfigStore = yield* WorkspaceConfigStore;
           const workspaceStateStore = yield* WorkspaceStateStore;
           const sourceArtifactStore = yield* SourceArtifactStore;
             sourceCatalogStore,
             localToolRuntimeLoader,
             installationStore,
+            instanceConfigResolver,
+            storeSecretMaterial,
+            deleteSecretMaterial,
+            updateSecretMaterial,
             workspaceConfigStore,
             workspaceStateStore,
             sourceArtifactStore,

packages/platform/sdk/src/runtime/execution/workspace/local.ts+1−1

@@ -3,7 +3,7 @@ import * as Effect from "effect/Effect"; · 2 unmodified lines
3	import {	3	import {
4	provideOptionalRuntimeLocalWorkspace,	4	provideOptionalRuntimeLocalWorkspace,
5	type RuntimeLocalWorkspaceState,	5	type RuntimeLocalWorkspaceState,
6	} from "../../local/runtime-context";	6	} from "../../workspace/runtime-context";
7		7
8	export const provideRuntimeLocalWorkspace = <A, E, R>(	8	export const provideRuntimeLocalWorkspace = <A, E, R>(
9	effect: Effect.Effect<A, E, R>,	9	effect: Effect.Effect<A, E, R>,

packages/platform/sdk/src/runtime/execution/workspace/source-catalog.ts+2−2

@@ -10,14 +10,14 @@ import { · 9 unmodified lines
10	type LoadedSourceCatalogToolIndexEntry,	10	type LoadedSourceCatalogToolIndexEntry,
11	catalogToolCatalogEntry,	11	catalogToolCatalogEntry,
12	} from "../../catalog/source/runtime";	12	} from "../../catalog/source/runtime";
13	import type { RuntimeLocalWorkspaceState } from "../../local/runtime-context";	13	import type { RuntimeLocalWorkspaceState } from "../../workspace/runtime-context";
14	import {	14	import {
15	makeWorkspaceStorageLayer,	15	makeWorkspaceStorageLayer,
16	type SourceArtifactStoreShape,	16	type SourceArtifactStoreShape,
17	type WorkspaceConfigStoreShape,	17	type WorkspaceConfigStoreShape,
18	type WorkspaceStateStoreShape,	18	type WorkspaceStateStoreShape,
19	type WorkspaceStorageServices,	19	type WorkspaceStorageServices,
20	} from "../../local/storage";	20	} from "../../workspace/storage";
21	import { provideRuntimeLocalWorkspace } from "./local";	21	import { provideRuntimeLocalWorkspace } from "./local";
22		22
23	const tokenize = (value: string): string[] =>	23	const tokenize = (value: string): string[] =>

packages/platform/sdk/src/runtime/execution/workspace/tool-invoker.ts+21−3

 import { RuntimeSourceAuthMaterialService } from "../../auth/source-auth-material";
 import { RuntimeSourceCatalogStoreService } from "../../catalog/source/runtime";
-import type { RuntimeLocalWorkspaceState } from "../../local/runtime-context";
+import type { RuntimeLocalWorkspaceState } from "../../workspace/runtime-context";
-import { type LocalToolRuntime } from "../../local/tools";
+import { type LocalToolRuntime } from "../../local-tool-runtime";
 import {
   type InstallationStoreShape,
   makeWorkspaceStorageLayer,
   type SourceArtifactStoreShape,
   type WorkspaceConfigStoreShape,
   type WorkspaceStateStoreShape,
-} from "../../local/storage";
+} from "../../workspace/storage";
+import type {
+  DeleteSecretMaterial,
+  ResolveInstanceConfig,
+  StoreSecretMaterial,
+  UpdateSecretMaterial,
+} from "../../workspace/secret-material-providers";
 import type { ControlPlaneStoreShape } from "../../store";
 import { RuntimeSourceAuthService } from "../../sources/source-auth-service";
 import { type RuntimeSourceStore } from "../../sources/source-store";
   >;
   sourceAuthService: RuntimeSourceAuthService;
   installationStore: InstallationStoreShape;
+  instanceConfigResolver: ResolveInstanceConfig;
+  storeSecretMaterial: StoreSecretMaterial;
+  deleteSecretMaterial: DeleteSecretMaterial;
+  updateSecretMaterial: UpdateSecretMaterial;
   workspaceConfigStore: WorkspaceConfigStoreShape;
   workspaceStateStore: WorkspaceStateStoreShape;
   sourceArtifactStore: SourceArtifactStoreShape;
     typeof RuntimeSourceCatalogStoreService
   >;
   installationStore: InstallationStoreShape;
+  instanceConfigResolver: ResolveInstanceConfig;
+  storeSecretMaterial: StoreSecretMaterial;
+  deleteSecretMaterial: DeleteSecretMaterial;
+  updateSecretMaterial: UpdateSecretMaterial;
   workspaceConfigStore: WorkspaceConfigStoreShape;
   workspaceStateStore: WorkspaceStateStoreShape;
   sourceArtifactStore: SourceArtifactStoreShape;
       sourceCatalogSyncService: input.sourceCatalogSyncService,
       sourceAuthService: input.sourceAuthService,
       installationStore: input.installationStore,
+      instanceConfigResolver: input.instanceConfigResolver,
+      storeSecretMaterial: input.storeSecretMaterial,
+      deleteSecretMaterial: input.deleteSecretMaterial,
+      updateSecretMaterial: input.updateSecretMaterial,
       workspaceConfigStore: input.workspaceConfigStore,
       workspaceStateStore: input.workspaceStateStore,
       sourceArtifactStore: input.sourceArtifactStore,

packages/platform/sdk/src/runtime/index.ts+82−32

 import { RuntimeSourceCatalogStoreLive } from "./catalog/source/runtime";
 import { reconcileMissingSourceCatalogArtifacts } from "./catalog/source/reconcile";
 import { RuntimeSourceCatalogSyncLive } from "./catalog/source/sync";
+import {
+  SourceTypeDeclarationsRefresherService,
+  type SourceTypeDeclarationsRefresherShape,
+} from "./catalog/source/type-declarations";
 import { createLiveExecutionManager, LiveExecutionManagerService } from "./execution/live";
 import { RuntimeExecutionResolverLive } from "./execution/workspace/environment";
 import type { CreateWorkspaceInternalToolMap, WorkspaceInternalToolContext } from "./execution/workspace/tool-invoker";
-import type {
+import type { LoadedLocalExecutorConfig } from "./workspace-config";
-  LoadedLocalExecutorConfig,
-  ResolvedLocalWorkspaceContext,
-} from "./local/config";
 import type { LocalExecutorConfig } from "#schema";
-import type { LocalControlPlanePersistence } from "./local/control-plane-store";
+import type { InstanceConfig } from "../local/contracts";
+import type {
+  ExecutorWorkspaceContext,
+  ExecutorWorkspaceDescriptor,
+} from "../workspace";
 import {
+  LocalInstanceConfigService,
   type DeleteSecretMaterial,
   type ResolveSecretMaterial,
   SecretMaterialDeleterService,
   SecretMaterialUpdaterService,
   type StoreSecretMaterial,
   type UpdateSecretMaterial,
-} from "./local/secret-material-providers";
+} from "./workspace/secret-material-providers";
-import type { LocalSourceArtifact } from "./local/source-artifacts";
+import type { LocalSourceArtifact } from "./source-artifacts";
 import {
   type RuntimeLocalWorkspaceState,
   RuntimeLocalWorkspaceLive,
-} from "./local/runtime-context";
+} from "./workspace/runtime-context";
 import {
   type LocalToolRuntime,
   type LocalToolRuntimeLoaderShape,
   LocalToolRuntimeLoaderService,
-} from "./local/tools";
+} from "./local-tool-runtime";
 import {
   InstallationStore,
   makeLocalStorageLayer,
   type SourceArtifactStoreShape,
   type WorkspaceConfigStoreShape,
   type WorkspaceStateStoreShape,
-} from "./local/storage";
+} from "./workspace/storage";
-import type { LocalWorkspaceState } from "./local/workspace-state";
+import type { LocalWorkspaceState } from "./workspace-state";
-import { synchronizeLocalWorkspaceState } from "./local/workspace-sync";
+import { synchronizeLocalWorkspaceState } from "./workspace/workspace-sync";
 import { ControlPlaneStore, type ControlPlaneStoreShape } from "./store";
 import { RuntimeSourceAuthServiceLive } from "./sources/source-auth-service";
 import { RuntimeSourceStoreLive } from "./sources/source-store";
 export * from "./execution/state";
 export * from "./sources/executor-tools";
 export * from "./execution/live";
-export * from "./local/config";
-export * from "./local/control-plane-store";
-export * from "./local/errors";
-export * from "./local/installation";
-export * from "./local/runtime-context";
-export * from "./local/storage";
-export * from "./local/source-artifacts";
-export * from "./local/tools";
 export * from "./catalog/schema-type-signature";
 export * from "./catalog/source/runtime";
 export * from "./catalog/source/sync";
 export * from "./sources/source-auth-service";
-export * from "./local/secret-material-providers";
 export * from "./sources/source-credential-interactions";
 export * from "./sources/source-adapters/mcp";
 export * from "./sources/source-store";
   CreateWorkspaceInternalToolMap,
   WorkspaceInternalToolContext,
 } from "./execution/workspace/tool-invoker";
+export {
+  LocalInstanceConfigService,
+  SecretMaterialDeleterService,
+  SecretMaterialResolverService,
+  SecretMaterialStorerService,
+  SecretMaterialUpdaterService,
+} from "./workspace/secret-material-providers";
+export type {
+  DeleteSecretMaterial,
+  ResolveInstanceConfig,
+  ResolveSecretMaterial,
+  StoreSecretMaterial,
+  UpdateSecretMaterial,
+} from "./workspace/secret-material-providers";
 export {
   builtInSourceAdapters,
   connectableSourceAdapters,
   load: () => ReturnType<LocalToolRuntimeLoaderShape["load"]>;
 };
+export type BoundSourceTypeDeclarationsRefresher =
+  SourceTypeDeclarationsRefresherShape;
 export type RuntimeSecretMaterialServices = {
   resolve: ResolveSecretMaterial;
   store: StoreSecretMaterial;
   update: UpdateSecretMaterial;
 };
+export type RuntimeInstanceConfigService = {
+  resolve: () => Effect.Effect<InstanceConfig, Error, never>;
+};
+export type RuntimePersistence = {
+  rows: ControlPlaneStoreShape;
+  close: () => Promise<void>;
+};
 export type RuntimeControlPlaneServices = {
-  workspaceContext: ResolvedLocalWorkspaceContext;
+  workspace: ExecutorWorkspaceDescriptor;
   installationStore: BoundInstallationStore;
   workspaceConfigStore: BoundWorkspaceConfigStore;
   workspaceStateStore: BoundWorkspaceStateStore;
   sourceArtifactStore: BoundSourceArtifactStore;
   localToolRuntimeLoader?: BoundLocalToolRuntimeLoader;
+  sourceTypeDeclarationsRefresher?: BoundSourceTypeDeclarationsRefresher;
   secretMaterial: RuntimeSecretMaterialServices;
-  persistence: LocalControlPlanePersistence;
+  instanceConfig: RuntimeInstanceConfigService;
+  persistence: RuntimePersistence;
 };
 const emptyToolRuntime = (): LocalToolRuntime => {
   };
 };
+const noopSourceTypeDeclarationsRefresher: BoundSourceTypeDeclarationsRefresher = {
+  refreshWorkspaceInBackground: () => Effect.void,
+  refreshSourceInBackground: () => Effect.void,
+};
 const toInstallationStoreShape = (
   input: BoundInstallationStore,
 ): InstallationStoreShape => ({
-  load: () => input.load(),
+  load: input.load,
-  getOrProvision: () => input.getOrProvision(),
+  getOrProvision: input.getOrProvision,
 });
 const toWorkspaceConfigStoreShape = (
   input: BoundWorkspaceConfigStore,
 ): WorkspaceConfigStoreShape => ({
-  load: () => input.load(),
+  load: input.load,
   writeProject: ({ config }) => input.writeProject(config),
   resolveRelativePath: input.resolveRelativePath,
 });
 const toWorkspaceStateStoreShape = (
   input: BoundWorkspaceStateStore,
 ): WorkspaceStateStoreShape => ({
-  load: () => input.load(),
+  load: input.load,
   write: ({ state }) => input.write(state),
 });
     Layer.succeed(SecretMaterialUpdaterService, input.update),
   );
+const makeInstanceConfigLayer = (input: RuntimeInstanceConfigService) =>
+  Layer.succeed(LocalInstanceConfigService, input.resolve);
 export const createRuntimeControlPlaneLayer = (
   input: RuntimeControlPlaneOptions & RuntimeControlPlaneServices & {
     store: ControlPlaneStoreShape;
         input.localToolRuntimeLoader?.load() ?? Effect.succeed(emptyToolRuntime()),
     }),
   );
+  const sourceTypeDeclarationsRefresherLayer = Layer.succeed(
+    SourceTypeDeclarationsRefresherService,
+    SourceTypeDeclarationsRefresherService.of(
+      input.sourceTypeDeclarationsRefresher
+        ?? noopSourceTypeDeclarationsRefresher,
+    ),
+  );
   const baseLayer = Layer.mergeAll(
     Layer.succeed(ControlPlaneStore, input.store),
     RuntimeLocalWorkspaceLive(input.localWorkspaceState),
     storageLayer,
     Layer.succeed(LiveExecutionManagerService, input.liveExecutionManager),
+    sourceTypeDeclarationsRefresherLayer,
   );
   const secretMaterialLayer = makeSecretMaterialLayer(input.secretMaterial).pipe(
     Layer.provide(baseLayer),
   );
+  const instanceConfigLayer = makeInstanceConfigLayer(input.instanceConfig);
-  const sourceStoreLayer = RuntimeSourceStoreLive.pipe(Layer.provide(baseLayer));
+  const sourceStoreLayer = RuntimeSourceStoreLive.pipe(
+    Layer.provide(Layer.mergeAll(baseLayer, secretMaterialLayer)),
+  );
   const sourceCatalogStoreLayer = RuntimeSourceCatalogStoreLive.pipe(
     Layer.provide(Layer.mergeAll(baseLayer, sourceStoreLayer)),
     Layer.provide(
       Layer.mergeAll(
         baseLayer,
+        instanceConfigLayer,
         secretMaterialLayer,
         sourceStoreLayer,
         sourceCatalogSyncLayer,
     Layer.provide(
       Layer.mergeAll(
         baseLayer,
+        instanceConfigLayer,
         secretMaterialLayer,
         sourceStoreLayer,
         sourceAuthMaterialLayer,
   return Layer.mergeAll(
     baseLayer,
+    instanceConfigLayer,
     secretMaterialLayer,
     sourceStoreLayer,
     sourceAuthMaterialLayer,
 };
 export type ControlPlaneRuntime = {
-  persistence: LocalControlPlanePersistence;
+  persistence: RuntimePersistence;
   localInstallation: LocalInstallation;
   managedRuntime: ManagedRuntime.ManagedRuntime<any, never>;
   runtimeLayer: RuntimeControlPlaneLayer;
       .load()
       .pipe(Effect.mapError(toRuntimeBootstrapError));
+    const runtimeWorkspace: ExecutorWorkspaceContext = {
+      ...input.services.workspace,
+      workspaceId: localInstallation.workspaceId,
+      accountId: localInstallation.accountId,
+    };
     const effectiveLocalConfig = yield* synchronizeLocalWorkspaceState({
-      context: input.services.workspaceContext,
       loadedConfig: loadedLocalConfig,
     })
       .pipe(
         ),
       )
       .pipe(Effect.mapError(toRuntimeBootstrapError));
     const runtimeLocalWorkspaceState: RuntimeLocalWorkspaceState = {
-      context: input.services.workspaceContext,
+      workspace: runtimeWorkspace,
       installation: {
         workspaceId: localInstallation.workspaceId,
         accountId: localInstallation.accountId,

packages/platform/sdk/src/runtime/local-tool-runtime.ts+37−0

@@ -0,0 +1,37 @@
	1	import type {
	2	ToolCatalog,
	3	ToolInvoker,
	4	ToolMap,
	5	} from "@executor/codemode-core";
	6	import * as Context from "effect/Context";
	7	import * as Effect from "effect/Effect";
	8	import * as Layer from "effect/Layer";
	9
	10	export type LocalToolRuntime = {
	11	tools: ToolMap;
	12	catalog: ToolCatalog;
	13	toolInvoker: ToolInvoker;
	14	toolPaths: Set<string>;
	15	};
	16
	17	export type LocalToolRuntimeLoaderShape = {
	18	load: () => Effect.Effect<LocalToolRuntime, Error, never>;
	19	};
	20
	21	export class LocalToolRuntimeLoaderService extends Context.Tag(
	22	"#runtime/LocalToolRuntimeLoaderService",
	23	)<LocalToolRuntimeLoaderService, LocalToolRuntimeLoaderShape>() {}
	24
	25	export const LocalToolRuntimeLoaderLive = Layer.effect(
	26	LocalToolRuntimeLoaderService,
	27	Effect.succeed(
	28	LocalToolRuntimeLoaderService.of({
	29	load: () =>
	30	Effect.die(
	31	new Error(
	32	"LocalToolRuntimeLoaderLive is unsupported; provide a bound local tool runtime loader from the host adapter.",
	33	),
	34	),
	35	}),
	36	),
	37	);

packages/platform/sdk/src/runtime/local/operations.ts+0−1

@@ -1 +0,0 @@
1	export * from "../../local/operations";

packages/platform/sdk/src/runtime/local/source-artifacts.ts+0−377

@@ -1,377 +0,0 @@
1	import { join } from "node:path";
2	import { FileSystem } from "@effect/platform";
3
4	import {
5	SourceIdSchema,
6	SourceCatalogIdSchema,
7	StoredSourceCatalogRevisionRecordSchema,
8	TimestampMsSchema,
9	type Source,
10	type SourceCatalogId,
11	} from "#schema";
12	import * as Effect from "effect/Effect";
13	import * as Option from "effect/Option";
14	import * as Schema from "effect/Schema";
15
16	import { decodeCatalogSnapshotV1 } from "@executor/ir/catalog";
17	import {
18	CatalogSnapshotV1Schema,
19	type CatalogSnapshotV1,
20	type NativeBlob,
21	type SourceDocument,
22	} from "@executor/ir/model";
23	import {
24	contentHash,
25	snapshotFromSourceCatalogSyncResult,
26	type SourceCatalogSyncResult,
27	} from "@executor/source-core";
28	import type { ResolvedLocalWorkspaceContext } from "./config";
29	import {
30	LocalFileSystemError,
31	unknownLocalErrorDetails,
32	} from "./errors";
33	import {
34	createSourceCatalogRevisionRecord,
35	stableSourceCatalogId,
36	} from "../sources/source-definitions";
37	const LEGACY_LOCAL_SOURCE_ARTIFACT_VERSION = 3 as const;
38	const LOCAL_SOURCE_ARTIFACT_VERSION = 4 as const;
39
40	const LegacyLocalSourceArtifactSchema = Schema.Struct({
41	version: Schema.Literal(LEGACY_LOCAL_SOURCE_ARTIFACT_VERSION),
42	sourceId: SourceIdSchema,
43	catalogId: SourceCatalogIdSchema,
44	generatedAt: TimestampMsSchema,
45	revision: StoredSourceCatalogRevisionRecordSchema,
46	snapshot: CatalogSnapshotV1Schema,
47	});
48
49	export const LocalSourceArtifactSchema = Schema.Struct({
50	version: Schema.Literal(LOCAL_SOURCE_ARTIFACT_VERSION),
51	sourceId: SourceIdSchema,
52	catalogId: SourceCatalogIdSchema,
53	generatedAt: TimestampMsSchema,
54	revision: StoredSourceCatalogRevisionRecordSchema,
55	snapshot: CatalogSnapshotV1Schema,
56	});
57
58	export type LocalSourceArtifact = typeof LocalSourceArtifactSchema.Type;
59	type LegacyLocalSourceArtifact = typeof LegacyLocalSourceArtifactSchema.Type;
60
61	const ReadableLegacyLocalSourceArtifactSchema = Schema.Struct({
62	version: Schema.Literal(LEGACY_LOCAL_SOURCE_ARTIFACT_VERSION),
63	sourceId: SourceIdSchema,
64	catalogId: SourceCatalogIdSchema,
65	generatedAt: TimestampMsSchema,
66	revision: StoredSourceCatalogRevisionRecordSchema,
67	snapshot: Schema.Unknown,
68	});
69
70	const ReadableLocalSourceArtifactSchema = Schema.Struct({
71	version: Schema.Literal(LOCAL_SOURCE_ARTIFACT_VERSION),
72	sourceId: SourceIdSchema,
73	catalogId: SourceCatalogIdSchema,
74	generatedAt: TimestampMsSchema,
75	revision: StoredSourceCatalogRevisionRecordSchema,
76	snapshot: Schema.Unknown,
77	});
78
79	type ReadableLegacyLocalSourceArtifact =
80	typeof ReadableLegacyLocalSourceArtifactSchema.Type;
81	type ReadableLocalSourceArtifact =
82	typeof ReadableLocalSourceArtifactSchema.Type;
83
84	const decodeReadableLocalSourceArtifactOption = Schema.decodeUnknownOption(
85	Schema.parseJson(
86	Schema.Union(
87	ReadableLocalSourceArtifactSchema,
88	ReadableLegacyLocalSourceArtifactSchema,
89	),
90	),
91	);
92
93	const normalizeLocalSourceArtifact = (
94	artifact: ReadableLocalSourceArtifact \| ReadableLegacyLocalSourceArtifact,
95	): Omit<LocalSourceArtifact, "snapshot"> & { snapshot: unknown } =>
96	artifact.version === LOCAL_SOURCE_ARTIFACT_VERSION
97	? artifact
98	: {
99	...artifact,
100	version: LOCAL_SOURCE_ARTIFACT_VERSION,
101	};
102
103	const mapFileSystemError = (path: string, action: string) => (cause: unknown) =>
104	new LocalFileSystemError({
105	message: `Failed to ${action} ${path}: ${unknownLocalErrorDetails(cause)}`,
106	action,
107	path,
108	details: unknownLocalErrorDetails(cause),
109	});
110
111	const mutableRecord = <K extends string, V>(value: Readonly<Record<K, V>>): Record<K, V> =>
112	value as Record<K, V>;
113
114	const localSourceArtifactPath = (input: {
115	context: ResolvedLocalWorkspaceContext;
116	sourceId: string;
117	}): string =>
118	join(
119	input.context.artifactsDirectory,
120	"sources",
121	`${input.sourceId}.json`,
122	);
123
124	const localSourceDocumentDirectory = (input: {
125	context: ResolvedLocalWorkspaceContext;
126	sourceId: string;
127	}): string =>
128	join(input.context.artifactsDirectory, "sources", input.sourceId, "documents");
129
130	const localSourceDocumentPath = (input: {
131	context: ResolvedLocalWorkspaceContext;
132	sourceId: string;
133	documentId: string;
134	}): string =>
135	join(localSourceDocumentDirectory(input), `${input.documentId}.txt`);
136
137	const splitArtifactSourceDocuments = (artifact: LocalSourceArtifact): {
138	artifact: LocalSourceArtifact;
139	rawDocuments: ReadonlyArray<{
140	documentId: string;
141	blob: NativeBlob;
142	content: string;
143	}>;
144	} => {
145	const nextArtifact = structuredClone(artifact);
146	const rawDocuments: Array<{
147	documentId: string;
148	blob: NativeBlob;
149	content: string;
150	}> = [];
151
152	for (const [documentId, document] of Object.entries(nextArtifact.snapshot.catalog.documents)) {
153	const mutableDocument = document as SourceDocument & { native?: NativeBlob[] };
154	const sourceDocumentBlob = document.native?.find((blob) =>
155	blob.kind === "source_document" && typeof blob.value === "string"
156	);
157	if (!sourceDocumentBlob \|\| typeof sourceDocumentBlob.value !== "string") {
158	continue;
159	}
160
161	rawDocuments.push({
162	documentId,
163	blob: sourceDocumentBlob,
164	content: sourceDocumentBlob.value,
165	});
166
167	const remainingBlobs = (document.native ?? []).filter((blob) => blob !== sourceDocumentBlob);
168	if (remainingBlobs.length > 0) {
169	mutableDocument.native = remainingBlobs;
170	} else {
171	delete mutableDocument.native;
172	}
173	}
174
175	return {
176	artifact: nextArtifact,
177	rawDocuments,
178	};
179	};
180
181	const hydrateArtifactSourceDocuments = (input: {
182	artifact: LocalSourceArtifact;
183	rawDocuments: Readonly<Record<string, NativeBlob>>;
184	}): LocalSourceArtifact => {
185	const nextArtifact = structuredClone(input.artifact);
186	const mutableDocuments = mutableRecord(nextArtifact.snapshot.catalog.documents);
187
188	for (const [documentId, rawDocument] of Object.entries(input.rawDocuments)) {
189	const document = mutableDocuments[documentId as keyof typeof mutableDocuments] as (SourceDocument & { native?: NativeBlob[] }) \| undefined;
190	if (!document) {
191	continue;
192	}
193
194	const remainingBlobs = (document.native ?? []).filter((blob) => blob.kind !== "source_document");
195	document.native = [rawDocument, ...remainingBlobs];
196	}
197
198	return nextArtifact;
199	};
200
201	const snapshotHash = (snapshot: CatalogSnapshotV1): string =>
202	contentHash(JSON.stringify(snapshot));
203
204	const importMetadataHash = (snapshot: { import: SourceCatalogSyncResult["importMetadata"] }): string =>
205	contentHash(JSON.stringify(snapshot.import));
206
207	const decodeCatalogSnapshotV1Option = (
208	snapshot: unknown,
209	): CatalogSnapshotV1 \| null => {
210	try {
211	return decodeCatalogSnapshotV1(snapshot);
212	} catch {
213	return null;
214	}
215	};
216
217	export const buildLocalSourceArtifact = (input: {
218	source: Source;
219	syncResult: SourceCatalogSyncResult;
220	}): LocalSourceArtifact => {
221	const catalogId: SourceCatalogId = stableSourceCatalogId(input.source);
222	const generatedAt = Date.now();
223	const snapshot = snapshotFromSourceCatalogSyncResult(input.syncResult);
224	const importHash = importMetadataHash(snapshot);
225	const hash = snapshotHash(snapshot);
226	const revision = createSourceCatalogRevisionRecord({
227	source: input.source,
228	catalogId,
229	revisionNumber: 1,
230	importMetadataJson: JSON.stringify(snapshot.import),
231	importMetadataHash: importHash,
232	snapshotHash: hash,
233	});
234
235	return {
236	version: LOCAL_SOURCE_ARTIFACT_VERSION,
237	sourceId: input.source.id,
238	catalogId,
239	generatedAt,
240	revision,
241	snapshot,
242	};
243	};
244
245	export const readLocalSourceArtifact = (input: {
246	context: ResolvedLocalWorkspaceContext;
247	sourceId: string;
248	}): Effect.Effect<
249	LocalSourceArtifact \| null,
250	LocalFileSystemError,
251	FileSystem.FileSystem
252	> =>
253	Effect.gen(function* () {
254	const fs = yield* FileSystem.FileSystem;
255	const path = localSourceArtifactPath(input);
256	const exists = yield* fs.exists(path).pipe(
257	Effect.mapError(mapFileSystemError(path, "check source artifact path")),
258	);
259	if (!exists) {
260	return null;
261	}
262
263	const readPath = path;
264	const content = yield* fs.readFileString(readPath, "utf8").pipe(
265	Effect.mapError(mapFileSystemError(readPath, "read source artifact")),
266	);
267
268	const decodedArtifact = decodeReadableLocalSourceArtifactOption(content);
269	if (Option.isNone(decodedArtifact)) {
270	return null;
271	}
272
273	const artifact = normalizeLocalSourceArtifact(decodedArtifact.value);
274	const snapshot = decodeCatalogSnapshotV1Option(artifact.snapshot);
275	if (snapshot === null) {
276	return null;
277	}
278
279	const decodedSnapshotArtifact: LocalSourceArtifact = {
280	...artifact,
281	snapshot,
282	};
283
284	const rawDocuments: Record<string, NativeBlob> = {};
285	for (const documentId of Object.keys(decodedSnapshotArtifact.snapshot.catalog.documents)) {
286	const sourceDocumentPath = localSourceDocumentPath({
287	context: input.context,
288	sourceId: input.sourceId,
289	documentId,
290	});
291	const sourceDocumentExists = yield* fs.exists(sourceDocumentPath).pipe(
292	Effect.mapError(mapFileSystemError(sourceDocumentPath, "check source document path")),
293	);
294	if (!sourceDocumentExists) {
295	continue;
296	}
297
298	const sourceContent = yield* fs.readFileString(sourceDocumentPath, "utf8").pipe(
299	Effect.mapError(mapFileSystemError(sourceDocumentPath, "read source document")),
300	);
301	rawDocuments[documentId] = {
302	sourceKind: decodedSnapshotArtifact.snapshot.import.sourceKind,
303	kind: "source_document",
304	value: sourceContent,
305	} satisfies NativeBlob;
306	}
307
308	const hydratedArtifact = Object.keys(rawDocuments).length > 0
309	? hydrateArtifactSourceDocuments({
310	artifact: decodedSnapshotArtifact,
311	rawDocuments,
312	})
313	: decodedSnapshotArtifact;
314
315	return {
316	...hydratedArtifact,
317	snapshot: hydratedArtifact.snapshot,
318	};
319	});
320
321	export const writeLocalSourceArtifact = (input: {
322	context: ResolvedLocalWorkspaceContext;
323	sourceId: string;
324	artifact: LocalSourceArtifact;
325	}): Effect.Effect<void, LocalFileSystemError, FileSystem.FileSystem> =>
326	Effect.gen(function* () {
327	const fs = yield* FileSystem.FileSystem;
328	const directory = join(input.context.artifactsDirectory, "sources");
329	const path = localSourceArtifactPath(input);
330	const sourceDocumentDirectory = localSourceDocumentDirectory(input);
331	const split = splitArtifactSourceDocuments(input.artifact);
332	yield* fs.makeDirectory(directory, { recursive: true }).pipe(
333	Effect.mapError(mapFileSystemError(directory, "create source artifact directory")),
334	);
335	yield* fs.remove(sourceDocumentDirectory, { recursive: true, force: true }).pipe(
336	Effect.mapError(mapFileSystemError(sourceDocumentDirectory, "remove source document directory")),
337	);
338	if (split.rawDocuments.length > 0) {
339	yield* fs.makeDirectory(sourceDocumentDirectory, { recursive: true }).pipe(
340	Effect.mapError(mapFileSystemError(sourceDocumentDirectory, "create source document directory")),
341	);
342	for (const rawDocument of split.rawDocuments) {
343	const sourceDocumentPath = localSourceDocumentPath({
344	context: input.context,
345	sourceId: input.sourceId,
346	documentId: rawDocument.documentId,
347	});
348	yield* fs.writeFileString(sourceDocumentPath, rawDocument.content).pipe(
349	Effect.mapError(mapFileSystemError(sourceDocumentPath, "write source document")),
350	);
351	}
352	}
353	yield* fs.writeFileString(path, `${JSON.stringify(split.artifact)}\n`).pipe(
354	Effect.mapError(mapFileSystemError(path, "write source artifact")),
355	);
356	});
357
358	export const removeLocalSourceArtifact = (input: {
359	context: ResolvedLocalWorkspaceContext;
360	sourceId: string;
361	}): Effect.Effect<void, LocalFileSystemError, FileSystem.FileSystem> =>
362	Effect.gen(function* () {
363	const fs = yield* FileSystem.FileSystem;
364	const path = localSourceArtifactPath(input);
365	const exists = yield* fs.exists(path).pipe(
366	Effect.mapError(mapFileSystemError(path, "check source artifact path")),
367	);
368	if (exists) {
369	yield* fs.remove(path).pipe(
370	Effect.mapError(mapFileSystemError(path, "remove source artifact")),
371	);
372	}
373	const sourceDocumentDirectory = localSourceDocumentDirectory(input);
374	yield* fs.remove(sourceDocumentDirectory, { recursive: true, force: true }).pipe(
375	Effect.mapError(mapFileSystemError(sourceDocumentDirectory, "remove source document directory")),
376	);
377	});

packages/platform/sdk/src/runtime/local/storage.ts+0−225

@@ -1,225 +0,0 @@
1	import { FileSystem } from "@effect/platform";
2	import { NodeFileSystem } from "@effect/platform-node";
3	import type { LocalInstallation, LocalExecutorConfig } from "#schema";
4	import * as Context from "effect/Context";
5	import * as Effect from "effect/Effect";
6	import * as Layer from "effect/Layer";
7
8	import type {
9	LoadedLocalExecutorConfig,
10	ResolvedLocalWorkspaceContext,
11	} from "./config";
12	import {
13	loadLocalExecutorConfig,
14	resolveConfigRelativePath,
15	writeProjectLocalExecutorConfig,
16	} from "./config";
17	import {
18	getOrProvisionLocalInstallation,
19	loadLocalInstallation,
20	} from "./installation";
21	import type {
22	LocalSourceArtifact,
23	} from "./source-artifacts";
24	import {
25	buildLocalSourceArtifact,
26	readLocalSourceArtifact,
27	removeLocalSourceArtifact,
28	writeLocalSourceArtifact,
29	} from "./source-artifacts";
30	import type { LocalWorkspaceState } from "./workspace-state";
31	import {
32	loadLocalWorkspaceState,
33	writeLocalWorkspaceState,
34	} from "./workspace-state";
35	import type { SourceCatalogSyncResult } from "@executor/source-core";
36	import type { Source } from "#schema";
37
38	export type InstallationStoreShape = {
39	load: (
40	context: ResolvedLocalWorkspaceContext,
41	) => Effect.Effect<LocalInstallation, Error, never>;
42	getOrProvision: (input: {
43	context: ResolvedLocalWorkspaceContext;
44	}) => Effect.Effect<LocalInstallation, Error, never>;
45	};
46
47	export class InstallationStore extends Context.Tag(
48	"#runtime/InstallationStore",
49	)<InstallationStore, InstallationStoreShape>() {}
50
51	export type WorkspaceConfigStoreShape = {
52	load: (
53	context: ResolvedLocalWorkspaceContext,
54	) => Effect.Effect<LoadedLocalExecutorConfig, Error, never>;
55	writeProject: (input: {
56	context: ResolvedLocalWorkspaceContext;
57	config: LocalExecutorConfig;
58	}) => Effect.Effect<void, Error, never>;
59	resolveRelativePath: (input: { path: string; workspaceRoot: string }) => string;
60	};
61
62	export class WorkspaceConfigStore extends Context.Tag(
63	"#runtime/WorkspaceConfigStore",
64	)<WorkspaceConfigStore, WorkspaceConfigStoreShape>() {}
65
66	export type WorkspaceStateStoreShape = {
67	load: (
68	context: ResolvedLocalWorkspaceContext,
69	) => Effect.Effect<LocalWorkspaceState, Error, never>;
70	write: (input: {
71	context: ResolvedLocalWorkspaceContext;
72	state: LocalWorkspaceState;
73	}) => Effect.Effect<void, Error, never>;
74	};
75
76	export class WorkspaceStateStore extends Context.Tag(
77	"#runtime/WorkspaceStateStore",
78	)<WorkspaceStateStore, WorkspaceStateStoreShape>() {}
79
80	export type SourceArtifactStoreShape = {
81	build: (input: {
82	source: Source;
83	syncResult: SourceCatalogSyncResult;
84	}) => LocalSourceArtifact;
85	read: (input: {
86	context: ResolvedLocalWorkspaceContext;
87	sourceId: string;
88	}) => Effect.Effect<LocalSourceArtifact \| null, Error, never>;
89	write: (input: {
90	context: ResolvedLocalWorkspaceContext;
91	sourceId: string;
92	artifact: LocalSourceArtifact;
93	}) => Effect.Effect<void, Error, never>;
94	remove: (input: {
95	context: ResolvedLocalWorkspaceContext;
96	sourceId: string;
97	}) => Effect.Effect<void, Error, never>;
98	};
99
100	export class SourceArtifactStore extends Context.Tag(
101	"#runtime/SourceArtifactStore",
102	)<SourceArtifactStore, SourceArtifactStoreShape>() {}
103
104	export type LocalStorageServices =
105	\| InstallationStore
106	\| WorkspaceConfigStore
107	\| WorkspaceStateStore
108	\| SourceArtifactStore;
109
110	export type WorkspaceStorageServices =
111	\| WorkspaceConfigStore
112	\| WorkspaceStateStore
113	\| SourceArtifactStore;
114
115	export const LocalInstallationStore: InstallationStoreShape = {
116	load: loadLocalInstallation,
117	getOrProvision: getOrProvisionLocalInstallation,
118	};
119
120	export const LocalInstallationStoreLive = Layer.succeed(
121	InstallationStore,
122	LocalInstallationStore,
123	);
124
125	const bindFileSystem = <A, E>(
126	fileSystem: FileSystem.FileSystem,
127	effect: Effect.Effect<A, E, FileSystem.FileSystem>,
128	): Effect.Effect<A, E, never> =>
129	effect.pipe(Effect.provideService(FileSystem.FileSystem, fileSystem));
130
131	const bindNodeFileSystem = <A, E>(
132	effect: Effect.Effect<A, E, FileSystem.FileSystem>,
133	): Effect.Effect<A, E, never> =>
134	effect.pipe(Effect.provide(NodeFileSystem.layer));
135
136	export const LocalWorkspaceConfigStore: WorkspaceConfigStoreShape = {
137	load: (context) => bindNodeFileSystem(loadLocalExecutorConfig(context)),
138	writeProject: (input) => bindNodeFileSystem(writeProjectLocalExecutorConfig(input)),
139	resolveRelativePath: resolveConfigRelativePath,
140	};
141
142	export const LocalWorkspaceConfigStoreLive = Layer.effect(
143	WorkspaceConfigStore,
144	Effect.gen(function* () {
145	const fileSystem = yield* FileSystem.FileSystem;
146
147	return WorkspaceConfigStore.of({
148	load: (context) => bindFileSystem(fileSystem, loadLocalExecutorConfig(context)),
149	writeProject: (input) =>
150	bindFileSystem(fileSystem, writeProjectLocalExecutorConfig(input)),
151	resolveRelativePath: resolveConfigRelativePath,
152	});
153	}),
154	);
155
156	export const LocalWorkspaceStateStore: WorkspaceStateStoreShape = {
157	load: (context) => bindNodeFileSystem(loadLocalWorkspaceState(context)),
158	write: (input) => bindNodeFileSystem(writeLocalWorkspaceState(input)),
159	};
160
161	export const LocalWorkspaceStateStoreLive = Layer.effect(
162	WorkspaceStateStore,
163	Effect.gen(function* () {
164	const fileSystem = yield* FileSystem.FileSystem;
165
166	return WorkspaceStateStore.of({
167	load: (context) => bindFileSystem(fileSystem, loadLocalWorkspaceState(context)),
168	write: (input) => bindFileSystem(fileSystem, writeLocalWorkspaceState(input)),
169	});
170	}),
171	);
172
173	export const LocalSourceArtifactStore: SourceArtifactStoreShape = {
174	build: buildLocalSourceArtifact,
175	read: (input) => bindNodeFileSystem(readLocalSourceArtifact(input)),
176	write: (input) => bindNodeFileSystem(writeLocalSourceArtifact(input)),
177	remove: (input) => bindNodeFileSystem(removeLocalSourceArtifact(input)),
178	};
179
180	export const LocalSourceArtifactStoreLive = Layer.effect(
181	SourceArtifactStore,
182	Effect.gen(function* () {
183	const fileSystem = yield* FileSystem.FileSystem;
184
185	return SourceArtifactStore.of({
186	build: buildLocalSourceArtifact,
187	read: (input) => bindFileSystem(fileSystem, readLocalSourceArtifact(input)),
188	write: (input) => bindFileSystem(fileSystem, writeLocalSourceArtifact(input)),
189	remove: (input) => bindFileSystem(fileSystem, removeLocalSourceArtifact(input)),
190	});
191	}),
192	);
193
194	export const makeWorkspaceStorageLayer = (input: {
195	workspaceConfigStore: WorkspaceConfigStoreShape;
196	workspaceStateStore: WorkspaceStateStoreShape;
197	sourceArtifactStore: SourceArtifactStoreShape;
198	}) =>
199	Layer.mergeAll(
200	Layer.succeed(WorkspaceConfigStore, input.workspaceConfigStore),
201	Layer.succeed(WorkspaceStateStore, input.workspaceStateStore),
202	Layer.succeed(SourceArtifactStore, input.sourceArtifactStore),
203	);
204
205	export const makeLocalStorageLayer = (input: {
206	installationStore: InstallationStoreShape;
207	workspaceConfigStore: WorkspaceConfigStoreShape;
208	workspaceStateStore: WorkspaceStateStoreShape;
209	sourceArtifactStore: SourceArtifactStoreShape;
210	}) =>
211	Layer.mergeAll(
212	Layer.succeed(InstallationStore, input.installationStore),
213	makeWorkspaceStorageLayer(input),
214	);
215
216	export const WorkspaceStorageLive = Layer.mergeAll(
217	LocalWorkspaceConfigStoreLive,
218	LocalWorkspaceStateStoreLive,
219	LocalSourceArtifactStoreLive,
220	);
221
222	export const LocalStorageLive = Layer.mergeAll(
223	LocalInstallationStoreLive,
224	WorkspaceStorageLive,
225	);

packages/platform/sdk/src/runtime/policy/policies-operations.ts+0−1

@@ -1 +0,0 @@
1	export * from "../../policies/operations";

packages/platform/sdk/src/runtime/source-artifacts.ts+234−0

@@ -0,0 +1,234 @@
	1	import {
	2	SourceIdSchema,
	3	SourceCatalogIdSchema,
	4	StoredSourceCatalogRevisionRecordSchema,
	5	TimestampMsSchema,
	6	type Source,
	7	type SourceCatalogId,
	8	} from "#schema";
	9	import * as Option from "effect/Option";
	10	import * as Schema from "effect/Schema";
	11
	12	import { decodeCatalogSnapshotV1 } from "@executor/ir/catalog";
	13	import {
	14	CatalogSnapshotV1Schema,
	15	type CatalogSnapshotV1,
	16	type NativeBlob,
	17	type SourceDocument,
	18	} from "@executor/ir/model";
	19	import {
	20	contentHash,
	21	snapshotFromSourceCatalogSyncResult,
	22	type SourceCatalogSyncResult,
	23	} from "@executor/source-core";
	24	import {
	25	createSourceCatalogRevisionRecord,
	26	stableSourceCatalogId,
	27	} from "./sources/source-definitions";
	28
	29	const LEGACY_LOCAL_SOURCE_ARTIFACT_VERSION = 3 as const;
	30	const LOCAL_SOURCE_ARTIFACT_VERSION = 4 as const;
	31
	32	const LegacyLocalSourceArtifactSchema = Schema.Struct({
	33	version: Schema.Literal(LEGACY_LOCAL_SOURCE_ARTIFACT_VERSION),
	34	sourceId: SourceIdSchema,
	35	catalogId: SourceCatalogIdSchema,
	36	generatedAt: TimestampMsSchema,
	37	revision: StoredSourceCatalogRevisionRecordSchema,
	38	snapshot: CatalogSnapshotV1Schema,
	39	});
	40
	41	export const LocalSourceArtifactSchema = Schema.Struct({
	42	version: Schema.Literal(LOCAL_SOURCE_ARTIFACT_VERSION),
	43	sourceId: SourceIdSchema,
	44	catalogId: SourceCatalogIdSchema,
	45	generatedAt: TimestampMsSchema,
	46	revision: StoredSourceCatalogRevisionRecordSchema,
	47	snapshot: CatalogSnapshotV1Schema,
	48	});
	49
	50	export type LocalSourceArtifact = typeof LocalSourceArtifactSchema.Type;
	51	type LegacyLocalSourceArtifact = typeof LegacyLocalSourceArtifactSchema.Type;
	52
	53	const ReadableLegacyLocalSourceArtifactSchema = Schema.Struct({
	54	version: Schema.Literal(LEGACY_LOCAL_SOURCE_ARTIFACT_VERSION),
	55	sourceId: SourceIdSchema,
	56	catalogId: SourceCatalogIdSchema,
	57	generatedAt: TimestampMsSchema,
	58	revision: StoredSourceCatalogRevisionRecordSchema,
	59	snapshot: Schema.Unknown,
	60	});
	61
	62	const ReadableLocalSourceArtifactSchema = Schema.Struct({
	63	version: Schema.Literal(LOCAL_SOURCE_ARTIFACT_VERSION),
	64	sourceId: SourceIdSchema,
	65	catalogId: SourceCatalogIdSchema,
	66	generatedAt: TimestampMsSchema,
	67	revision: StoredSourceCatalogRevisionRecordSchema,
	68	snapshot: Schema.Unknown,
	69	});
	70
	71	type ReadableLegacyLocalSourceArtifact =
	72	typeof ReadableLegacyLocalSourceArtifactSchema.Type;
	73	type ReadableLocalSourceArtifact =
	74	typeof ReadableLocalSourceArtifactSchema.Type;
	75
	76	const decodeReadableLocalSourceArtifactOption = Schema.decodeUnknownOption(
	77	Schema.parseJson(
	78	Schema.Union(
	79	ReadableLocalSourceArtifactSchema,
	80	ReadableLegacyLocalSourceArtifactSchema,
	81	),
	82	),
	83	);
	84
	85	const normalizeLocalSourceArtifact = (
	86	artifact: ReadableLocalSourceArtifact \| ReadableLegacyLocalSourceArtifact,
	87	): Omit<LocalSourceArtifact, "snapshot"> & { snapshot: unknown } =>
	88	artifact.version === LOCAL_SOURCE_ARTIFACT_VERSION
	89	? artifact
	90	: {
	91	...artifact,
	92	version: LOCAL_SOURCE_ARTIFACT_VERSION,
	93	};
	94
	95	const mutableRecord = <K extends string, V>(
	96	value: Readonly<Record<K, V>>,
	97	): Record<K, V> => value as Record<K, V>;
	98
	99	export type SourceArtifactDocumentContent = {
	100	documentId: string;
	101	blob: NativeBlob;
	102	content: string;
	103	};
	104
	105	export const splitLocalSourceArtifactDocuments = (
	106	artifact: LocalSourceArtifact,
	107	): {
	108	artifact: LocalSourceArtifact;
	109	rawDocuments: readonly SourceArtifactDocumentContent[];
	110	} => {
	111	const nextArtifact = structuredClone(artifact);
	112	const rawDocuments: Array<SourceArtifactDocumentContent> = [];
	113
	114	for (const [documentId, document] of Object.entries(
	115	nextArtifact.snapshot.catalog.documents,
	116	)) {
	117	const mutableDocument = document as SourceDocument & { native?: NativeBlob[] };
	118	const sourceDocumentBlob = document.native?.find(
	119	(blob) => blob.kind === "source_document" && typeof blob.value === "string",
	120	);
	121	if (!sourceDocumentBlob \|\| typeof sourceDocumentBlob.value !== "string") {
	122	continue;
	123	}
	124
	125	rawDocuments.push({
	126	documentId,
	127	blob: sourceDocumentBlob,
	128	content: sourceDocumentBlob.value,
	129	});
	130
	131	const remainingBlobs = (document.native ?? []).filter(
	132	(blob) => blob !== sourceDocumentBlob,
	133	);
	134	if (remainingBlobs.length > 0) {
	135	mutableDocument.native = remainingBlobs;
	136	} else {
	137	delete mutableDocument.native;
	138	}
	139	}
	140
	141	return {
	142	artifact: nextArtifact,
	143	rawDocuments,
	144	};
	145	};
	146
	147	export const hydrateLocalSourceArtifactDocuments = (input: {
	148	artifact: LocalSourceArtifact;
	149	rawDocuments: Readonly<Record<string, NativeBlob>>;
	150	}): LocalSourceArtifact => {
	151	const nextArtifact = structuredClone(input.artifact);
	152	const mutableDocuments = mutableRecord(nextArtifact.snapshot.catalog.documents);
	153
	154	for (const [documentId, rawDocument] of Object.entries(input.rawDocuments)) {
	155	const document = mutableDocuments[
	156	documentId as keyof typeof mutableDocuments
	157	] as (SourceDocument & { native?: NativeBlob[] }) \| undefined;
	158	if (!document) {
	159	continue;
	160	}
	161
	162	const remainingBlobs = (document.native ?? []).filter(
	163	(blob) => blob.kind !== "source_document",
	164	);
	165	document.native = [rawDocument, ...remainingBlobs];
	166	}
	167
	168	return nextArtifact;
	169	};
	170
	171	const snapshotHash = (snapshot: CatalogSnapshotV1): string =>
	172	contentHash(JSON.stringify(snapshot));
	173
	174	const importMetadataHash = (snapshot: {
	175	import: SourceCatalogSyncResult["importMetadata"];
	176	}): string => contentHash(JSON.stringify(snapshot.import));
	177
	178	const decodeCatalogSnapshotV1Option = (
	179	snapshot: unknown,
	180	): CatalogSnapshotV1 \| null => {
	181	try {
	182	return decodeCatalogSnapshotV1(snapshot);
	183	} catch {
	184	return null;
	185	}
	186	};
	187
	188	export const decodeStoredLocalSourceArtifact = (
	189	content: string,
	190	): LocalSourceArtifact \| null => {
	191	const decodedArtifact = decodeReadableLocalSourceArtifactOption(content);
	192	if (Option.isNone(decodedArtifact)) {
	193	return null;
	194	}
	195
	196	const artifact = normalizeLocalSourceArtifact(decodedArtifact.value);
	197	const snapshot = decodeCatalogSnapshotV1Option(artifact.snapshot);
	198	if (snapshot === null) {
	199	return null;
	200	}
	201
	202	return {
	203	...artifact,
	204	snapshot,
	205	};
	206	};
	207
	208	export const buildLocalSourceArtifact = (input: {
	209	source: Source;
	210	syncResult: SourceCatalogSyncResult;
	211	}): LocalSourceArtifact => {
	212	const catalogId: SourceCatalogId = stableSourceCatalogId(input.source);
	213	const generatedAt = Date.now();
	214	const snapshot = snapshotFromSourceCatalogSyncResult(input.syncResult);
	215	const importHash = importMetadataHash(snapshot);
	216	const hash = snapshotHash(snapshot);
	217	const revision = createSourceCatalogRevisionRecord({
	218	source: input.source,
	219	catalogId,
	220	revisionNumber: 1,
	221	importMetadataJson: JSON.stringify(snapshot.import),
	222	importMetadataHash: importHash,
	223	snapshotHash: hash,
	224	});
	225
	226	return {
	227	version: LOCAL_SOURCE_ARTIFACT_VERSION,
	228	sourceId: input.source.id,
	229	catalogId,
	230	generatedAt,
	231	revision,
	232	snapshot,
	233	};
	234	};

packages/platform/sdk/src/runtime/sources/executor-tools.ts+3−3

@@ -19,7 +19,7 @@ import * as Effect from "effect/Effect"; · 18 unmodified lines
19	import * as Cause from "effect/Cause";	19	import * as Cause from "effect/Cause";
20	import * as Exit from "effect/Exit";	20	import * as Exit from "effect/Exit";
21	import * as Schema from "effect/Schema";	21	import * as Schema from "effect/Schema";
22	import type { RuntimeLocalWorkspaceState } from "../local/runtime-context";	22	import type { RuntimeLocalWorkspaceState } from "../workspace/runtime-context";
23	import {	23	import {
24	type LocalStorageServices,	24	type LocalStorageServices,
25	type InstallationStoreShape,	25	type InstallationStoreShape,
@@ -27,8 +27,8 @@ import { · 1 unmodified line
27	type WorkspaceConfigStoreShape,	27	type WorkspaceConfigStoreShape,
28	type WorkspaceStateStoreShape,	28	type WorkspaceStateStoreShape,
29	makeLocalStorageLayer,	29	makeLocalStorageLayer,
30	} from "../local/storage";	30	} from "../workspace/storage";
31	import { provideOptionalRuntimeLocalWorkspace } from "../local/runtime-context";	31	import { provideOptionalRuntimeLocalWorkspace } from "../workspace/runtime-context";
32	import { runtimeEffectError } from "../effect-errors";	32	import { runtimeEffectError } from "../effect-errors";
33		33
34	/** Run an Effect as a Promise, preserving the original error (not FiberFailure). */	34	/** Run an Effect as a Promise, preserving the original error (not FiberFailure). */

packages/platform/sdk/src/runtime/sources/source-auth-service.ts+25−18

   getRuntimeLocalWorkspaceOption,
   provideOptionalRuntimeLocalWorkspace,
   type RuntimeLocalWorkspaceState,
-} from "../local/runtime-context";
+} from "../workspace/runtime-context";
 import {
   exchangeMcpOAuthAuthorizationCode,
   startMcpOAuthAuthorization,
   sourceBindingStateFromSource,
 } from "./source-adapters";
 import {
-  createDefaultSecretMaterialDeleter,
+  type DeleteSecretMaterial,
   type ResolveSecretMaterial,
+  SecretMaterialDeleterService,
   SecretMaterialResolverService,
   SecretMaterialStorerService,
   type StoreSecretMaterial,
-} from "../local/secret-material-providers";
+} from "../workspace/secret-material-providers";
 import {
   removeAuthLeaseAndSecrets,
   upsertOauth2AuthorizedUserLeaseFromTokenResponse,
   type RuntimeSourceStore,
   RuntimeSourceStoreService,
 } from "./source-store";
-import type { WorkspaceStorageServices } from "../local/storage";
+import type { WorkspaceStorageServices } from "../workspace/storage";
 import { ControlPlaneStore, type ControlPlaneStoreShape } from "../store";
 import { runtimeEffectError } from "../effect-errors";
   source: Source;
   oauthClient: SourceOauthClientInput;
   storeSecretMaterial: StoreSecretMaterial;
+  deleteSecretMaterial: DeleteSecretMaterial;
 }): Effect.Effect<ResolvedSourceOauthClient, Error, never> =>
   Effect.gen(function* () {
     const adapter = getSourceAdapterForSource(input.source);
         || previousClientSecretRef.handle !== clientSecretRef.handle
       )
     ) {
-      const deleteSecretMaterial = createDefaultSecretMaterialDeleter({
+      yield* input.deleteSecretMaterial(previousClientSecretRef).pipe(
-        rows: input.rows,
-      });
-      yield* deleteSecretMaterial(previousClientSecretRef).pipe(
         Effect.either,
         Effect.ignore,
       );
   grantedScopes: ReadonlyArray<string>;
   refreshToken: string | null;
   storeSecretMaterial: StoreSecretMaterial;
+  deleteSecretMaterial: DeleteSecretMaterial;
   existingGrant?: import("#schema").ProviderAuthGrant | null;
 }): Effect.Effect<import("#schema").ProviderAuthGrant, Error, never> =>
   Effect.gen(function* () {
         || existingGrant.refreshToken.handle !== refreshTokenRef.handle
       )
     ) {
-      const deleteSecretMaterial = createDefaultSecretMaterialDeleter({
+      yield* input.deleteSecretMaterial(existingGrant.refreshToken).pipe(
-        rows: input.rows,
-      });
-      yield* deleteSecretMaterial(existingGrant.refreshToken).pipe(
         Effect.either,
         Effect.ignore,
       );
   sourceStore: RuntimeSourceStore;
   workspaceId: WorkspaceId;
   grantId: ProviderAuthGrant["id"];
+  deleteSecretMaterial: DeleteSecretMaterial;
 }): Effect.Effect<boolean, Error, WorkspaceStorageServices> =>
   Effect.gen(function* () {
     const grantOption = yield* input.rows.providerAuthGrants.getById(input.grantId);
           if (latestSource === null) {
             yield* removeAuthLeaseAndSecrets(input.rows, {
               authArtifactId: artifact.id,
-            });
+            }, input.deleteSecretMaterial);
             yield* input.rows.authArtifacts.removeByWorkspaceSourceAndActor({
               workspaceId: artifact.workspaceId,
               sourceId: artifact.sourceId,
     yield* removeProviderAuthGrantSecret(input.rows, {
       grant: grantOption.value,
-    });
+    }, input.deleteSecretMaterial);
     yield* input.rows.providerAuthGrants.removeById(input.grantId);
     return true;
   });
   sourceCatalogSync: RuntimeSourceCatalogSyncShape;
   sourceInput: ExecutorHttpEndpointSourceInput;
   storeSecretMaterial: StoreSecretMaterial;
+  deleteSecretMaterial: DeleteSecretMaterial;
   resolveSecretMaterial: ResolveSecretMaterial;
   getLocalServerBaseUrl?: () => string | undefined;
   baseUrl?: string | null;
   sourceCatalogSync: RuntimeSourceCatalogSyncShape;
   sourceInput: Extract<ExecutorAddSourceInput, { kind: "google_discovery" }>;
   storeSecretMaterial: StoreSecretMaterial;
+  deleteSecretMaterial: DeleteSecretMaterial;
   resolveSecretMaterial: ResolveSecretMaterial;
   getLocalServerBaseUrl?: () => string | undefined;
   baseUrl?: string | null;
         source: persistedDraft,
         oauthClient: input.sourceInput.oauthClient,
         storeSecretMaterial: input.storeSecretMaterial,
+        deleteSecretMaterial: input.deleteSecretMaterial,
       });
     }
   sourceCatalogSync: RuntimeSourceCatalogSyncShape;
   resolveSecretMaterial: ResolveSecretMaterial;
   storeSecretMaterial: StoreSecretMaterial;
+  deleteSecretMaterial: DeleteSecretMaterial;
   getLocalServerBaseUrl?: () => string | undefined;
   localWorkspaceState?: RuntimeLocalWorkspaceState;
 };
               sourceCatalogSync: input.sourceCatalogSync,
               sourceInput,
               storeSecretMaterial: input.storeSecretMaterial,
+              deleteSecretMaterial: input.deleteSecretMaterial,
               resolveSecretMaterial: input.resolveSecretMaterial,
               getLocalServerBaseUrl: input.getLocalServerBaseUrl,
               baseUrl: options?.baseUrl,
               sourceCatalogSync: input.sourceCatalogSync,
               sourceInput,
               storeSecretMaterial: input.storeSecretMaterial,
+              deleteSecretMaterial: input.deleteSecretMaterial,
               resolveSecretMaterial: input.resolveSecretMaterial,
               getLocalServerBaseUrl: input.getLocalServerBaseUrl,
               baseUrl: options?.baseUrl,
           const secretRef = sourceOauthClientSecretRef(oauthClient.value);
           const removed = yield* input.rows.workspaceOauthClients.removeById(oauthClientId);
           if (removed && secretRef) {
-            const deleteSecretMaterial = createDefaultSecretMaterialDeleter({
+            yield* input.deleteSecretMaterial(secretRef).pipe(
-              rows: input.rows,
-            });
-            yield* deleteSecretMaterial(secretRef).pipe(
               Effect.either,
               Effect.ignore,
             );
           sourceStore: input.sourceStore,
           workspaceId,
           grantId,
+          deleteSecretMaterial: input.deleteSecretMaterial,
         }),
       ),
   };
         refreshToken: trimOrNull(exchanged.refresh_token),
         existingGrant,
         storeSecretMaterial: input.storeSecretMaterial,
+        deleteSecretMaterial: input.deleteSecretMaterial,
       });
       const targets = yield* Effect.forEach(
             rows: input.rows,
             artifact: authArtifact.value,
             tokenResponse: exchanged,
+            storeSecretMaterial: input.storeSecretMaterial,
+            deleteSecretMaterial: input.deleteSecretMaterial,
           });
         }
       const sourceCatalogSync = yield* RuntimeSourceCatalogSyncService;
       const resolveSecretMaterial = yield* SecretMaterialResolverService;
       const storeSecretMaterial = yield* SecretMaterialStorerService;
+      const deleteSecretMaterial = yield* SecretMaterialDeleterService;
       const runtimeLocalWorkspace = yield* getRuntimeLocalWorkspaceOption();
       return createRuntimeSourceAuthService({
         sourceCatalogSync,
         resolveSecretMaterial,
         storeSecretMaterial,
+        deleteSecretMaterial,
         getLocalServerBaseUrl: input.getLocalServerBaseUrl,
         localWorkspaceState: runtimeLocalWorkspace ?? undefined,
       });

packages/platform/sdk/src/runtime/sources/source-discovery.ts+0−1

@@ -1 +0,0 @@
1	export * from "../../sources/discovery";

packages/platform/sdk/src/runtime/sources/source-inspection.ts+0−1

@@ -1 +0,0 @@
1	export * from "../../sources/inspection";

packages/platform/sdk/src/runtime/sources/source-store.test.ts+2−2

@@ -7,9 +7,9 @@ import { · 6 unmodified lines
7	type Source,	7	type Source,
8	} from "#schema";	8	} from "#schema";
9		9
10	import type { LoadedLocalExecutorConfig } from "../local/config";	10	import type { LoadedLocalExecutorConfig } from "../workspace-config";
11	import { buildLocalSourceRecord } from "./source-store";	11	import { buildLocalSourceRecord } from "./source-store";
12	import type { LocalWorkspaceState } from "../local/workspace-state";	12	import type { LocalWorkspaceState } from "../workspace-state";
13		13
14	const workspaceId = WorkspaceIdSchema.make("ws_source_store");	14	const workspaceId = WorkspaceIdSchema.make("ws_source_store");
15	const sourceId = SourceIdSchema.make("linear");	15	const sourceId = SourceIdSchema.make("linear");

packages/platform/sdk/src/runtime/sources/source-store.ts+45−17

 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import { SourceTypeDeclarationsRefresherService } from "../catalog/source/type-declarations";
 import {
   SourceArtifactStore,
   type WorkspaceStorageServices,
   WorkspaceConfigStore,
   WorkspaceStateStore,
-} from "../local/storage";
+} from "../workspace/storage";
-import { RuntimeLocalWorkspaceService } from "../local/runtime-context";
+import { SecretMaterialDeleterService } from "../workspace/secret-material-providers";
+import { RuntimeLocalWorkspaceService } from "../workspace/runtime-context";
 import { ControlPlaneStore, type ControlPlaneStoreShape } from "../store";
 import {
   loadRuntimeSourceStoreDeps,
   options: {
     actorAccountId?: AccountId | null;
   } = {},
-): Effect.Effect<readonly Source[], Error, WorkspaceStorageServices> =>
+): Effect.Effect<
+  readonly Source[],
+  Error,
+  WorkspaceStorageServices | SourceTypeDeclarationsRefresherService
+> =>
   Effect.flatMap(
     loadRuntimeSourceStoreDeps(rows, workspaceId),
     (deps) => loadSourcesInWorkspaceWithDeps(deps, workspaceId, options),
 ): Effect.Effect<
   Map<string, Array<{ sourceId: string; sourceName: string }>>,
   Error,
-  WorkspaceStorageServices
+  WorkspaceStorageServices | SourceTypeDeclarationsRefresherService
 > =>
   Effect.flatMap(
     loadRuntimeSourceStoreDeps(rows, workspaceId),
     sourceId: Source["id"];
     actorAccountId?: AccountId | null;
   },
-): Effect.Effect<Source, Error, WorkspaceStorageServices> =>
+): Effect.Effect<
+  Source,
+  Error,
+  WorkspaceStorageServices | SourceTypeDeclarationsRefresherService
+> =>
   Effect.flatMap(
     loadRuntimeSourceStoreDeps(rows, input.workspaceId),
     (deps) => loadSourceByIdWithDeps(deps, input),
     workspaceId: WorkspaceId;
     sourceId: Source["id"];
   },
-): Effect.Effect<boolean, Error, WorkspaceStorageServices> =>
+): Effect.Effect<
-  Effect.flatMap(
+  boolean,
-    loadRuntimeSourceStoreDeps(rows, input.workspaceId),
+  Error,
-    (deps) => removeSourceByIdWithDeps(deps, input),
+  | WorkspaceStorageServices
-  );
+  | SourceTypeDeclarationsRefresherService
+  | SecretMaterialDeleterService
+> =>
+  Effect.gen(function* () {
+    const deps = yield* loadRuntimeSourceStoreDeps(rows, input.workspaceId);
+    const deleteSecretMaterial = yield* SecretMaterialDeleterService;
+    return yield* removeSourceByIdWithDeps(deps, input, deleteSecretMaterial);
+  });
 export const persistSource = (
   rows: ControlPlaneStoreShape,
   options: {
     actorAccountId?: AccountId | null;
   } = {},
-): Effect.Effect<Source, Error, WorkspaceStorageServices> =>
+): Effect.Effect<
-  Effect.flatMap(
+  Source,
-    loadRuntimeSourceStoreDeps(rows, source.workspaceId),
+  Error,
-    (deps) => persistSourceWithDeps(deps, source, options),
+  | WorkspaceStorageServices
-  );
+  | SourceTypeDeclarationsRefresherService
+  | SecretMaterialDeleterService
+> =>
+  Effect.gen(function* () {
+    const deps = yield* loadRuntimeSourceStoreDeps(rows, source.workspaceId);
+    const deleteSecretMaterial = yield* SecretMaterialDeleterService;
+    return yield* persistSourceWithDeps(deps, source, options, deleteSecretMaterial);
+  });
 export class RuntimeSourceStoreService extends Context.Tag(
   "#runtime/RuntimeSourceStoreService",
     const workspaceConfigStore = yield* WorkspaceConfigStore;
     const workspaceStateStore = yield* WorkspaceStateStore;
     const sourceArtifactStore = yield* SourceArtifactStore;
+    const sourceTypeDeclarationsRefresher =
+      yield* SourceTypeDeclarationsRefresherService;
+    const deleteSecretMaterial = yield* SecretMaterialDeleterService;
     const deps: RuntimeSourceStoreDeps = {
       rows,
       workspaceConfigStore,
       workspaceStateStore,
       sourceArtifactStore,
+      sourceTypeDeclarationsRefresher,
     };
     return RuntimeSourceStoreService.of({
       loadSourceById: (input) =>
         loadSourceByIdWithDeps(deps, input),
       removeSourceById: (input) =>
-        removeSourceByIdWithDeps(deps, input),
+        removeSourceByIdWithDeps(deps, input, deleteSecretMaterial),
       persistSource: (source, options = {}) =>
-        persistSourceWithDeps(deps, source, options),
+        persistSourceWithDeps(deps, source, options, deleteSecretMaterial),
     });
   }),
 );

packages/platform/sdk/src/runtime/sources/source-store/auth.ts+5−5

 import { authArtifactSecretMaterialRefs } from "../../auth/auth-artifacts";
 import { removeAuthLeaseAndSecrets } from "../../auth/auth-leases";
-import { createDefaultSecretMaterialDeleter } from "../../local/secret-material-providers";
+import type { DeleteSecretMaterial } from "../../workspace/secret-material-providers";
 import type { ControlPlaneStoreShape } from "../../store";
 const secretRefKey = (ref: { providerId: string; handle: string }): string =>
     previous: AuthArtifact | null;
     next: AuthArtifact | null;
   },
+  deleteSecretMaterial: DeleteSecretMaterial,
 ) =>
   Effect.gen(function* () {
     if (input.previous === null) {
       return;
     }
-    const deleteSecretMaterial = createDefaultSecretMaterialDeleter({ rows });
     const nextRefKeys = new Set(
       (input.next === null ? [] : authArtifactSecretMaterialRefs(input.next)).map(
         secretRefKey,
     workspaceId: WorkspaceId;
     sourceId: Source["id"];
   },
+  deleteSecretMaterial: DeleteSecretMaterial,
 ) =>
   Effect.gen(function* () {
     const existingAuthArtifacts = yield* rows.authArtifacts.listByWorkspaceAndSourceId({
       (artifact) =>
         removeAuthLeaseAndSecrets(rows, {
           authArtifactId: artifact.id,
-        }),
+        }, deleteSecretMaterial),
       { discard: true },
     );
         cleanupAuthArtifactSecretRefs(rows, {
           previous: artifact,
           next: null,
-        }),
+        }, deleteSecretMaterial),
       { discard: true },
     );

packages/platform/sdk/src/runtime/sources/source-store/config.ts+3−3

@@ -6,12 +6,12 @@ import type { · 5 unmodified lines
6	} from "#schema";	6	} from "#schema";
7	import { SourceIdSchema } from "#schema";	7	import { SourceIdSchema } from "#schema";
8		8
9	import type { LoadedLocalExecutorConfig } from "../../local/config";	9	import type { LoadedLocalExecutorConfig } from "../../workspace-config";
10	import { LocalUnsupportedSourceKindError } from "../../local/errors";	10	import { LocalUnsupportedSourceKindError } from "../../workspace-errors";
11	import {	11	import {
12	fromConfigSecretProviderId,	12	fromConfigSecretProviderId,
13	toConfigSecretProviderId,	13	toConfigSecretProviderId,
14	} from "../../local/config-secrets";	14	} from "../../workspace/config-secrets";
15	import { getSourceAdapterForSource } from "../source-adapters";	15	import { getSourceAdapterForSource } from "../source-adapters";
16	import { slugify } from "../slug";	16	import { slugify } from "../slug";
17		17

packages/platform/sdk/src/runtime/sources/source-store/deps.ts+20−27

 import type { AccountId, WorkspaceId } from "#schema";
 import * as Effect from "effect/Effect";
-import type {
+import type { LoadedLocalExecutorConfig } from "../../workspace-config";
-  LoadedLocalExecutorConfig,
+import {
-  ResolvedLocalWorkspaceContext,
+  SourceTypeDeclarationsRefresherService,
-} from "../../local/config";
+  type SourceTypeDeclarationsRefresherShape,
+} from "../../catalog/source/type-declarations";
 import {
-  LocalExecutorConfigDecodeError,
-  LocalFileSystemError,
-  LocalWorkspaceStateDecodeError,
   RuntimeLocalWorkspaceMismatchError,
   RuntimeLocalWorkspaceUnavailableError,
-} from "../../local/errors";
+} from "../../workspace-errors";
 import {
   requireRuntimeLocalWorkspace,
   type RuntimeLocalWorkspaceState,
-} from "../../local/runtime-context";
+} from "../../workspace/runtime-context";
 import type {
   SourceArtifactStoreShape,
   WorkspaceStorageServices,
   WorkspaceConfigStoreShape,
   WorkspaceStateStoreShape,
-} from "../../local/storage";
+} from "../../workspace/storage";
 import {
   SourceArtifactStore,
   WorkspaceConfigStore,
   WorkspaceStateStore,
-} from "../../local/storage";
+} from "../../workspace/storage";
-import type { LocalWorkspaceState } from "../../local/workspace-state";
+import type { LocalWorkspaceState } from "../../workspace-state";
 import type { ControlPlaneStoreShape } from "../../store";
 export type RuntimeSourceStoreDeps = {
   workspaceConfigStore: WorkspaceConfigStoreShape;
   workspaceStateStore: WorkspaceStateStoreShape;
   sourceArtifactStore: SourceArtifactStoreShape;
+  sourceTypeDeclarationsRefresher: SourceTypeDeclarationsRefresherShape;
 };
 export type ResolvedSourceStoreWorkspace = {
-  context: ResolvedLocalWorkspaceContext;
   installation: {
     workspaceId: WorkspaceId;
     accountId: AccountId;
   workspaceState: LocalWorkspaceState;
 };
+export type RuntimeSourceStoreServices =
+  WorkspaceStorageServices | SourceTypeDeclarationsRefresherService;
 export const resolveRuntimeLocalWorkspaceFromDeps = (
   deps: RuntimeSourceStoreDeps,
   workspaceId: WorkspaceId,
   ResolvedSourceStoreWorkspace,
   | RuntimeLocalWorkspaceUnavailableError
   | RuntimeLocalWorkspaceMismatchError
-  | LocalFileSystemError
-  | LocalExecutorConfigDecodeError
-  | LocalWorkspaceStateDecodeError
   | Error,
   never
 > =>
         });
     }
-    const loadedConfig = yield* deps.workspaceConfigStore.load(
+    const loadedConfig = yield* deps.workspaceConfigStore.load();
-      deps.runtimeLocalWorkspace.context,
+    const workspaceState = yield* deps.workspaceStateStore.load();
-    );
-    const workspaceState = yield* deps.workspaceStateStore.load(
-      deps.runtimeLocalWorkspace.context,
-    );
     return {
-      context: deps.runtimeLocalWorkspace.context,
       installation: deps.runtimeLocalWorkspace.installation,
       workspaceConfigStore: deps.workspaceConfigStore,
       workspaceStateStore: deps.workspaceStateStore,
   RuntimeSourceStoreDeps,
   | RuntimeLocalWorkspaceUnavailableError
   | RuntimeLocalWorkspaceMismatchError
-  | LocalFileSystemError
-  | LocalExecutorConfigDecodeError
-  | LocalWorkspaceStateDecodeError
   | Error,
-  WorkspaceStorageServices
+  RuntimeSourceStoreServices
 > =>
   Effect.gen(function* () {
     const runtimeLocalWorkspace = yield* requireRuntimeLocalWorkspace(workspaceId);
     const workspaceConfigStore = yield* WorkspaceConfigStore;
     const workspaceStateStore = yield* WorkspaceStateStore;
     const sourceArtifactStore = yield* SourceArtifactStore;
+    const sourceTypeDeclarationsRefresher =
+      yield* SourceTypeDeclarationsRefresherService;
     return {
       rows,
       workspaceConfigStore,
       workspaceStateStore,
       sourceArtifactStore,
+      sourceTypeDeclarationsRefresher,
     };
   });

packages/platform/sdk/src/runtime/sources/source-store/lifecycle.ts+11−13

   clearProviderGrantOrphanedAt,
   markProviderGrantOrphanedIfUnused,
 } from "../../auth/provider-grant-lifecycle";
-import type { LocalWorkspaceState } from "../../local/workspace-state";
+import type { DeleteSecretMaterial } from "../../workspace/secret-material-providers";
+import type { LocalWorkspaceState } from "../../workspace-state";
 import {
   stableSourceCatalogId,
   stableSourceCatalogRevisionId,
     workspaceId: WorkspaceId;
     sourceId: Source["id"];
   },
+  deleteSecretMaterial: DeleteSecretMaterial,
 ): Effect.Effect<boolean, Error, never> =>
   Effect.gen(function* () {
     const localWorkspace = yield* resolveRuntimeLocalWorkspaceFromDeps(
     };
     delete sources[input.sourceId];
     yield* localWorkspace.workspaceConfigStore.writeProject({
-      context: localWorkspace.context,
       config: {
         ...projectConfig,
         sources,
       sources: remainingSources,
     };
     yield* localWorkspace.workspaceStateStore.write({
-      context: localWorkspace.context,
       state: workspaceState,
     });
     yield* localWorkspace.sourceArtifactStore.remove({
-      context: localWorkspace.context,
       sourceId: input.sourceId,
     });
     const existingAuthArtifacts =
       workspaceId: input.workspaceId,
       sourceId: input.sourceId,
     });
-    yield* removeAuthArtifactsForSource(deps.rows, input);
+    yield* removeAuthArtifactsForSource(deps.rows, input, deleteSecretMaterial);
     yield* Effect.forEach(
       [...removedGrantIds],
       (grantId) =>
   options: {
     actorAccountId?: AccountId | null;
   } = {},
+  deleteSecretMaterial: DeleteSecretMaterial,
 ): Effect.Effect<Source, Error, never> =>
   Effect.gen(function* () {
     const localWorkspace = yield* resolveRuntimeLocalWorkspaceFromDeps(
       config: localWorkspace.loadedConfig.config,
     });
     yield* localWorkspace.workspaceConfigStore.writeProject({
-      context: localWorkspace.context,
       config: {
         ...projectConfig,
         sources,
       if (existingRuntimeAuthArtifact !== null) {
         yield* removeAuthLeaseAndSecrets(deps.rows, {
           authArtifactId: existingRuntimeAuthArtifact.id,
-        });
+        }, deleteSecretMaterial);
       }
       yield* deps.rows.authArtifacts.removeByWorkspaceSourceAndActor({
         workspaceId: nextSource.workspaceId,
       ) {
         yield* removeAuthLeaseAndSecrets(deps.rows, {
           authArtifactId: existingRuntimeAuthArtifact.id,
-        });
+        }, deleteSecretMaterial);
       }
     }
     yield* cleanupAuthArtifactSecretRefs(deps.rows, {
       previous: existingRuntimeAuthArtifact ?? null,
       next: runtimeAuthArtifact,
-    });
+    }, deleteSecretMaterial);
     if (importAuthArtifact === null) {
       if (existingImportAuthArtifact !== null) {
         yield* removeAuthLeaseAndSecrets(deps.rows, {
           authArtifactId: existingImportAuthArtifact.id,
-        });
+        }, deleteSecretMaterial);
       }
       yield* deps.rows.authArtifacts.removeByWorkspaceSourceAndActor({
         workspaceId: nextSource.workspaceId,
       ) {
         yield* removeAuthLeaseAndSecrets(deps.rows, {
           authArtifactId: existingImportAuthArtifact.id,
-        });
+        }, deleteSecretMaterial);
       }
     }
     yield* cleanupAuthArtifactSecretRefs(deps.rows, {
       previous: existingImportAuthArtifact ?? null,
       next: importAuthArtifact,
-    });
+    }, deleteSecretMaterial);
     const previousGrantIds = providerGrantIdsFromArtifacts([
       existingRuntimeAuthArtifact,
       },
     };
     yield* localWorkspace.workspaceStateStore.write({
-      context: localWorkspace.context,
       state: workspaceState,
     });

packages/platform/sdk/src/runtime/sources/source-store/records.ts+7−24

 import { sourceAuthFromAuthArtifact } from "../../auth/auth-artifacts";
 import { authArtifactSecretMaterialRefs } from "../../auth/auth-artifacts";
-import { refreshWorkspaceSourceTypeDeclarationsInBackground } from "../../catalog/source/type-declarations";
+import type { LoadedLocalExecutorConfig } from "../../workspace-config";
-import type { LoadedLocalExecutorConfig } from "../../local/config";
 import {
   LocalConfiguredSourceNotFoundError,
-  LocalExecutorConfigDecodeError,
-  LocalFileSystemError,
-  LocalWorkspaceStateDecodeError,
   RuntimeLocalWorkspaceMismatchError,
   RuntimeLocalWorkspaceUnavailableError,
-} from "../../local/errors";
+} from "../../workspace-errors";
-import type { LocalWorkspaceState } from "../../local/workspace-state";
+import type { LocalWorkspaceState } from "../../workspace-state";
 import { getSourceAdapter } from "../source-adapters";
 import {
   resolveRuntimeLocalWorkspaceFromDeps,
   readonly Source[],
   | RuntimeLocalWorkspaceUnavailableError
   | RuntimeLocalWorkspaceMismatchError
-  | LocalFileSystemError
-  | LocalExecutorConfigDecodeError
-  | LocalWorkspaceStateDecodeError
   | LocalConfiguredSourceNotFoundError
   | Error,
   never
     const entries = yield* Effect.forEach(sources, (source) =>
       Effect.map(
         deps.sourceArtifactStore.read({
-          context: localWorkspace.context,
           sourceId: source.id,
         }),
         (artifact) =>
       ),
     );
-    yield* Effect.sync(() => {
+    yield* deps.sourceTypeDeclarationsRefresher.refreshWorkspaceInBackground({
-      refreshWorkspaceSourceTypeDeclarationsInBackground({
+      entries: entries.filter(
-        context: localWorkspace.context,
+        (entry): entry is NonNullable<typeof entry> => entry !== null,
-        entries: entries.filter(
+      ),
-          (entry): entry is NonNullable<typeof entry> => entry !== null,
-        ),
-      });
     });
   }).pipe(
     Effect.withSpan("source.types.refresh_workspace.schedule", {
   Map<string, Array<{ sourceId: string; sourceName: string }>>,
   | RuntimeLocalWorkspaceUnavailableError
   | RuntimeLocalWorkspaceMismatchError
-  | LocalFileSystemError
-  | LocalExecutorConfigDecodeError
-  | LocalWorkspaceStateDecodeError
   | LocalConfiguredSourceNotFoundError
   | Error,
   never
   Source,
   | RuntimeLocalWorkspaceUnavailableError
   | RuntimeLocalWorkspaceMismatchError
-  | LocalFileSystemError
-  | LocalExecutorConfigDecodeError
-  | LocalWorkspaceStateDecodeError
   | LocalConfiguredSourceNotFoundError
   | Error,
   never

packages/platform/sdk/src/runtime/workspace-config.ts+9−0

@@ -0,0 +1,9 @@
	1	import type { LocalExecutorConfig } from "#schema";
	2
	3	export type LoadedExecutorConfig = {
	4	config: LocalExecutorConfig \| null;
	5	homeConfig: LocalExecutorConfig \| null;
	6	projectConfig: LocalExecutorConfig \| null;
	7	};
	8
	9	export type LoadedLocalExecutorConfig = LoadedExecutorConfig;

packages/platform/sdk/src/runtime/workspace-errors.ts+36−0

@@ -0,0 +1,36 @@
	1	import * as Data from "effect/Data";
	2
	3	export class RuntimeLocalWorkspaceUnavailableError extends Data.TaggedError(
	4	"RuntimeLocalWorkspaceUnavailableError",
	5	)<{
	6	readonly message: string;
	7	}> {}
	8
	9	export class RuntimeLocalWorkspaceMismatchError extends Data.TaggedError(
	10	"RuntimeLocalWorkspaceMismatchError",
	11	)<{
	12	readonly message: string;
	13	readonly requestedWorkspaceId: string;
	14	readonly activeWorkspaceId: string;
	15	}> {}
	16
	17	export class LocalConfiguredSourceNotFoundError extends Data.TaggedError(
	18	"LocalConfiguredSourceNotFoundError",
	19	)<{
	20	readonly message: string;
	21	readonly sourceId: string;
	22	}> {}
	23
	24	export class LocalSourceArtifactMissingError extends Data.TaggedError(
	25	"LocalSourceArtifactMissingError",
	26	)<{
	27	readonly message: string;
	28	readonly sourceId: string;
	29	}> {}
	30
	31	export class LocalUnsupportedSourceKindError extends Data.TaggedError(
	32	"LocalUnsupportedSourceKindError",
	33	)<{
	34	readonly message: string;
	35	readonly kind: string;
	36	}> {}

packages/platform/sdk/src/runtime/workspace-state.ts+42−0

@@ -0,0 +1,42 @@
	1	import {
	2	PolicyIdSchema,
	3	SourceStatusSchema,
	4	TimestampMsSchema,
	5	} from "#schema";
	6	import * as Schema from "effect/Schema";
	7
	8	const LocalWorkspaceSourceStateSchema = Schema.Struct({
	9	status: SourceStatusSchema,
	10	lastError: Schema.NullOr(Schema.String),
	11	sourceHash: Schema.NullOr(Schema.String),
	12	createdAt: TimestampMsSchema,
	13	updatedAt: TimestampMsSchema,
	14	});
	15
	16	const LocalWorkspacePolicyStateSchema = Schema.Struct({
	17	id: PolicyIdSchema,
	18	createdAt: TimestampMsSchema,
	19	updatedAt: TimestampMsSchema,
	20	});
	21
	22	export const LocalWorkspaceStateSchema = Schema.Struct({
	23	version: Schema.Literal(1),
	24	sources: Schema.Record({
	25	key: Schema.String,
	26	value: LocalWorkspaceSourceStateSchema,
	27	}),
	28	policies: Schema.Record({
	29	key: Schema.String,
	30	value: LocalWorkspacePolicyStateSchema,
	31	}),
	32	});
	33
	34	export type LocalWorkspaceSourceState = typeof LocalWorkspaceSourceStateSchema.Type;
	35	export type LocalWorkspacePolicyState = typeof LocalWorkspacePolicyStateSchema.Type;
	36	export type LocalWorkspaceState = typeof LocalWorkspaceStateSchema.Type;
	37
	38	export const defaultLocalWorkspaceState = (): LocalWorkspaceState => ({
	39	version: 1,
	40	sources: {},
	41	policies: {},
	42	});

packages/platform/sdk/src/runtime/workspace/config-secrets.tsrenamed from packages/platform/sdk/src/runtime/local/config-secrets.ts+0−0

File renamed without changes.

packages/platform/sdk/src/runtime/workspace/runtime-context.tsrenamed from packages/platform/sdk/src/runtime/local/runtime-context.ts+4−6

 import * as Option from "effect/Option";
 import type { AccountId, WorkspaceId } from "#schema";
-import type {
+import type { ExecutorWorkspaceContext } from "../../workspace";
-  LoadedLocalExecutorConfig,
+import type { LoadedLocalExecutorConfig } from "../workspace-config";
-  ResolvedLocalWorkspaceContext,
-} from "./config";
 import {
   RuntimeLocalWorkspaceMismatchError,
   RuntimeLocalWorkspaceUnavailableError,
-} from "./errors";
+} from "../workspace-errors";
 export type RuntimeLocalWorkspaceState = {
-  context: ResolvedLocalWorkspaceContext;
+  workspace: ExecutorWorkspaceContext;
   installation: {
     workspaceId: WorkspaceId;
     accountId: AccountId;

packages/platform/sdk/src/runtime/workspace/secret-material-providers.ts+63−0

@@ -0,0 +1,63 @@
	1	import type { InstanceConfig } from "../../local/contracts";
	2	import * as Context from "effect/Context";
	3	import * as Effect from "effect/Effect";
	4
	5	import type {
	6	SecretMaterialPurpose,
	7	SecretRef,
	8	} from "#schema";
	9
	10	export type SecretMaterialResolveContext = {
	11	params?: Readonly<Record<string, string \| undefined>>;
	12	};
	13
	14	export type ResolveSecretMaterial = (input: {
	15	ref: SecretRef;
	16	context?: SecretMaterialResolveContext;
	17	}) => Effect.Effect<string, Error, never>;
	18
	19	export type StoreSecretMaterial = (input: {
	20	purpose: SecretMaterialPurpose;
	21	value: string;
	22	name?: string \| null;
	23	providerId?: string;
	24	}) => Effect.Effect<SecretRef, Error, never>;
	25
	26	export type DeleteSecretMaterial = (
	27	ref: SecretRef,
	28	) => Effect.Effect<boolean, Error, never>;
	29
	30	export type UpdateSecretMaterial = (input: {
	31	ref: SecretRef;
	32	name?: string \| null;
	33	value?: string;
	34	}) => Effect.Effect<{
	35	id: string;
	36	providerId: string;
	37	name: string \| null;
	38	purpose: string;
	39	createdAt: number;
	40	updatedAt: number;
	41	}, Error, never>;
	42
	43	export type ResolveInstanceConfig = () => Effect.Effect<InstanceConfig, Error, never>;
	44
	45	export class SecretMaterialResolverService extends Context.Tag(
	46	"#runtime/SecretMaterialResolverService",
	47	)<SecretMaterialResolverService, ResolveSecretMaterial>() {}
	48
	49	export class SecretMaterialStorerService extends Context.Tag(
	50	"#runtime/SecretMaterialStorerService",
	51	)<SecretMaterialStorerService, StoreSecretMaterial>() {}
	52
	53	export class SecretMaterialDeleterService extends Context.Tag(
	54	"#runtime/SecretMaterialDeleterService",
	55	)<SecretMaterialDeleterService, DeleteSecretMaterial>() {}
	56
	57	export class SecretMaterialUpdaterService extends Context.Tag(
	58	"#runtime/SecretMaterialUpdaterService",
	59	)<SecretMaterialUpdaterService, UpdateSecretMaterial>() {}
	60
	61	export class LocalInstanceConfigService extends Context.Tag(
	62	"#runtime/LocalInstanceConfigService",
	63	)<LocalInstanceConfigService, ResolveInstanceConfig>() {}

packages/platform/sdk/src/runtime/workspace/storage.ts+95−0

@@ -0,0 +1,95 @@
	1	import type { LocalInstallation, LocalExecutorConfig } from "#schema";
	2	import * as Context from "effect/Context";
	3	import * as Layer from "effect/Layer";
	4
	5	import type { LoadedLocalExecutorConfig } from "../workspace-config";
	6	import type { LocalSourceArtifact } from "../source-artifacts";
	7	import type { LocalWorkspaceState } from "../workspace-state";
	8	import type { SourceCatalogSyncResult } from "@executor/source-core";
	9	import type { Source } from "#schema";
	10
	11	export type InstallationStoreShape = {
	12	load: () => import("effect/Effect").Effect<LocalInstallation, Error, never>;
	13	getOrProvision: () => import("effect/Effect").Effect<LocalInstallation, Error, never>;
	14	};
	15
	16	export class InstallationStore extends Context.Tag(
	17	"#runtime/InstallationStore",
	18	)<InstallationStore, InstallationStoreShape>() {}
	19
	20	export type WorkspaceConfigStoreShape = {
	21	load: () => import("effect/Effect").Effect<LoadedLocalExecutorConfig, Error, never>;
	22	writeProject: (input: {
	23	config: LocalExecutorConfig;
	24	}) => import("effect/Effect").Effect<void, Error, never>;
	25	resolveRelativePath: (input: { path: string; workspaceRoot: string }) => string;
	26	};
	27
	28	export class WorkspaceConfigStore extends Context.Tag(
	29	"#runtime/WorkspaceConfigStore",
	30	)<WorkspaceConfigStore, WorkspaceConfigStoreShape>() {}
	31
	32	export type WorkspaceStateStoreShape = {
	33	load: () => import("effect/Effect").Effect<LocalWorkspaceState, Error, never>;
	34	write: (input: {
	35	state: LocalWorkspaceState;
	36	}) => import("effect/Effect").Effect<void, Error, never>;
	37	};
	38
	39	export class WorkspaceStateStore extends Context.Tag(
	40	"#runtime/WorkspaceStateStore",
	41	)<WorkspaceStateStore, WorkspaceStateStoreShape>() {}
	42
	43	export type SourceArtifactStoreShape = {
	44	build: (input: {
	45	source: Source;
	46	syncResult: SourceCatalogSyncResult;
	47	}) => LocalSourceArtifact;
	48	read: (input: {
	49	sourceId: string;
	50	}) => import("effect/Effect").Effect<LocalSourceArtifact \| null, Error, never>;
	51	write: (input: {
	52	sourceId: string;
	53	artifact: LocalSourceArtifact;
	54	}) => import("effect/Effect").Effect<void, Error, never>;
	55	remove: (input: {
	56	sourceId: string;
	57	}) => import("effect/Effect").Effect<void, Error, never>;
	58	};
	59
	60	export class SourceArtifactStore extends Context.Tag(
	61	"#runtime/SourceArtifactStore",
	62	)<SourceArtifactStore, SourceArtifactStoreShape>() {}
	63
	64	export type LocalStorageServices =
	65	\| InstallationStore
	66	\| WorkspaceConfigStore
	67	\| WorkspaceStateStore
	68	\| SourceArtifactStore;
	69
	70	export type WorkspaceStorageServices =
	71	\| WorkspaceConfigStore
	72	\| WorkspaceStateStore
	73	\| SourceArtifactStore;
	74
	75	export const makeWorkspaceStorageLayer = (input: {
	76	workspaceConfigStore: WorkspaceConfigStoreShape;
	77	workspaceStateStore: WorkspaceStateStoreShape;
	78	sourceArtifactStore: SourceArtifactStoreShape;
	79	}) =>
	80	Layer.mergeAll(
	81	Layer.succeed(WorkspaceConfigStore, input.workspaceConfigStore),
	82	Layer.succeed(WorkspaceStateStore, input.workspaceStateStore),
	83	Layer.succeed(SourceArtifactStore, input.sourceArtifactStore),
	84	);
	85
	86	export const makeLocalStorageLayer = (input: {
	87	installationStore: InstallationStoreShape;
	88	workspaceConfigStore: WorkspaceConfigStoreShape;
	89	workspaceStateStore: WorkspaceStateStoreShape;
	90	sourceArtifactStore: SourceArtifactStoreShape;
	91	}) =>
	92	Layer.mergeAll(
	93	Layer.succeed(InstallationStore, input.installationStore),
	94	makeWorkspaceStorageLayer(input),
	95	);

packages/platform/sdk/src/runtime/workspace/workspace-sync.tsrenamed from packages/platform/sdk/src/runtime/local/workspace-sync.ts+8−18

-import { FileSystem } from "@effect/platform";
 import * as Effect from "effect/Effect";
-import {
+import { type LoadedLocalExecutorConfig } from "../workspace-config";
-  type LoadedLocalExecutorConfig,
+import { WorkspaceStateStore } from "./storage";
-  type ResolvedLocalWorkspaceContext,
+import { type LocalWorkspaceState } from "../workspace-state";
-} from "./config";
-import {
-  loadLocalWorkspaceState,
-  writeLocalWorkspaceState,
-  type LocalWorkspaceState,
-} from "./workspace-state";
 const trimOrNull = (value: string | null | undefined): string | null => {
   if (value == null) {
 };
 const pruneLocalWorkspaceState = (input: {
-  context: ResolvedLocalWorkspaceContext;
   loadedConfig: LoadedLocalExecutorConfig;
-}): Effect.Effect<LocalWorkspaceState, Error, FileSystem.FileSystem> =>
+}): Effect.Effect<LocalWorkspaceState, Error, WorkspaceStateStore> =>
   Effect.gen(function* () {
-    const currentState = yield* loadLocalWorkspaceState(input.context);
+    const workspaceStateStore = yield* WorkspaceStateStore;
+    const currentState = yield* workspaceStateStore.load();
     const configuredSourceIds = new Set(
       Object.keys(input.loadedConfig.config?.sources ?? {}),
       return currentState;
     }
-    yield* writeLocalWorkspaceState({
+    yield* workspaceStateStore.write({
-      context: input.context,
       state: nextState,
     });
   });
 export const synchronizeLocalWorkspaceState = (input: {
-  context: ResolvedLocalWorkspaceContext;
   loadedConfig: LoadedLocalExecutorConfig;
-}): Effect.Effect<LoadedLocalExecutorConfig["config"], Error, FileSystem.FileSystem> =>
+}): Effect.Effect<LoadedLocalExecutorConfig["config"], Error, WorkspaceStateStore> =>
   Effect.gen(function* () {
     yield* pruneLocalWorkspaceState({
-      context: input.context,
       loadedConfig: input.loadedConfig,
     });

packages/platform/sdk/src/sources/inspection.ts+1−1

@@ -16,7 +16,7 @@ import { · 15 unmodified lines
16	} from "../errors";	16	} from "../errors";
17	import * as Effect from "effect/Effect";	17	import * as Effect from "effect/Effect";
18		18
19	import { LocalSourceArtifactMissingError } from "../runtime/local/errors";	19	import { LocalSourceArtifactMissingError } from "../runtime/workspace-errors";
20	import { operationErrors } from "../runtime/policy/operation-errors";	20	import { operationErrors } from "../runtime/policy/operation-errors";
21	import {	21	import {
22	buildLoadedSourceCatalogToolContract,	22	buildLoadedSourceCatalogToolContract,

packages/platform/sdk/src/workspace.ts+15−0

@@ -0,0 +1,15 @@
	1	import type {
	2	AccountId,
	3	WorkspaceId,
	4	} from "./schema";
	5
	6	export type ExecutorWorkspaceDescriptor = {
	7	workspaceName: string;
	8	workspaceRoot?: string \| null;
	9	metadata?: Readonly<Record<string, unknown>>;
	10	};
	11
	12	export type ExecutorWorkspaceContext = ExecutorWorkspaceDescriptor & {
	13	workspaceId: WorkspaceId;
	14	accountId: AccountId;
	15	};