History

Consolidate custom tools plugin wiring

Rhys Sullivan committed 4 months ago

Commit 3dba8101 parent aeb483318 files · +497 −310Browse files

Showing the changes to packages/plugins/apps/src/plugin (7 of 18 files). Show all

Unified · Split

7 files
  1. packages/plugins/apps/src/plugin/apps-plugin.test.ts +1 −1
  2. packages/plugins/apps/src/plugin/apps-plugin.ts +214 −50
  3. packages/plugins/apps/src/plugin/backings.ts +28 −0
  4. packages/plugins/apps/src/plugin/handlers.ts +49 −0
  5. packages/plugins/apps/src/plugin/resolver.ts +116 −0
  6. packages/plugins/apps/src/plugin/routes.ts +104 −0
  7. packages/plugins/apps/src/plugin/self-host-runtime.ts +7 −3
packages/plugins/apps/src/plugin/apps-plugin.test.ts+1−1
@@ -62,7 +62,7 @@ describe("appsPlugin custom-tools contract", () => { · 61 unmodified lines
62 inMemory: true,62 inMemory: true,
63 });63 });
64 const runtime = host.runtime;64 const runtime = host.runtime;
65 const plugin = appsPlugin({ runtime });65 const plugin = appsPlugin({ backings: host.backings });
66 const appIntegration = IntegrationSlug.make("rhys-tools");66 const appIntegration = IntegrationSlug.make("rhys-tools");
67 const appConfig = {67 const appConfig = {
68 kind: "github",68 kind: "github",
packages/plugins/apps/src/plugin/apps-plugin.ts+214−50
@@ -14,11 +14,17 @@ import { · 13 unmodified lines
14 type PluginCtx,14 type PluginCtx,
15 type ResolveToolsInput,15 type ResolveToolsInput,
16 type ResolveToolsResult,16 type ResolveToolsResult,
17 StorageError,
18 type StorageFailure,
17 type ToolDef,19 type ToolDef,
20 type IntegrationRemovalNotAllowedError,
18} from "@executor-js/sdk";21} from "@executor-js/sdk";
19 22
20import type { IntegrationDecl, ToolDescriptor } from "../pipeline/descriptor";23import type { IntegrationDecl, ToolDescriptor } from "../pipeline/descriptor";
21import { PublishError } from "../pipeline/discover";24import { PublishError } from "../pipeline/discover";
25import { ArtifactStoreError } from "../seams/artifact-store";
26import { ScopeDbError } from "../seams/scope-db";
27import { ToolSandboxError } from "../seams/tool-sandbox";
22import {28import {
23 parseGitHubSourceUrl,29 parseGitHubSourceUrl,
24 syncGitHubSource,30 syncGitHubSource,
@@ -28,7 +34,9 @@ import { · 3 unmodified lines
28import { slugifyCustomToolsAppName, validateCustomToolsAppSlug } from "../source/app-slug";34import { slugifyCustomToolsAppName, validateCustomToolsAppSlug } from "../source/app-slug";
29import type { AppsRuntime, GitHubCustomToolsSourceSummary } from "./runtime";35import type { AppsRuntime, GitHubCustomToolsSourceSummary } from "./runtime";
30import { makeAppsStore, type AppDescriptorRecord, type GitHubSourceTokenRef } from "./store";36import { makeAppsStore, type AppDescriptorRecord, type GitHubSourceTokenRef } from "./store";
31import type { ClientResolver, ConnectionCandidate } from "./bindings";37import { BindingError, type ClientResolver, type ConnectionCandidate } from "./bindings";
38import { makePluginCtxAppsResolver } from "./resolver";
39import { makeAppsRuntimeFromBackings, type AppsBackings } from "./backings";
32 40
33export const APPS_INTEGRATION_SLUG = "apps";41export const APPS_INTEGRATION_SLUG = "apps";
34export const APPS_PLUGIN_ID = "apps";42export const APPS_PLUGIN_ID = "apps";
@@ -44,17 +52,43 @@ interface AppsGitHubSourceConfig { · 9 unmodified lines
44 readonly token?: GitHubSourceTokenRef;52 readonly token?: GitHubSourceTokenRef;
45}53}
46 54
47export interface AppsPluginOptions {55type ResolverFactory = (input: {
56 readonly ctx: unknown;
57 readonly scope: string;
58 readonly tool: string;
59}) => ClientResolver;
60
61export type AppsPluginOptions =
62 | {
63 readonly backings: AppsBackings;
64 readonly runtime?: never;
65 readonly makeResolver?: ResolverFactory;
66 }
67 | {
68 readonly runtime: AppsRuntime;
69 readonly backings?: never;
70 readonly makeResolver?: ResolverFactory;
71 };
72
73interface AppsStoreShape {
48 readonly runtime: AppsRuntime;74 readonly runtime: AppsRuntime;
49 readonly makeResolver?: (input: {
50 readonly ctx: unknown;
51 readonly scope: string;
52 readonly tool: string;
53 }) => ClientResolver;
54}75}
55 76
56interface AppsStoreShape {77export interface AppsPluginExtension {
57 readonly runtime: AppsRuntime;78 readonly runtime: AppsRuntime;
79 readonly syncGitHubSource: (input: unknown) => Effect.Effect<GitHubSyncResult, StorageFailure>;
80 readonly listGitHubSources: () => Effect.Effect<{
81 readonly sources: readonly GitHubCustomToolsSourceSummary[];
82 }>;
83 readonly getGitHubSource: (slug: string) => Effect.Effect<{
84 readonly source: GitHubCustomToolsSourceSummary | null;
85 }>;
86 readonly removeGitHubSource: (
87 slug: string,
88 ) => Effect.Effect<
89 { readonly removed: true },
90 StorageFailure | IntegrationRemovalNotAllowedError
91 >;
58}92}
59 93
60const isRecord = (value: unknown): value is Record<string, unknown> =>94const isRecord = (value: unknown): value is Record<string, unknown> =>
@@ -65,6 +99,13 @@ const asString = (value: unknown): string | undefined => · 4 unmodified lines
65 99
66const unique = (values: readonly string[]): readonly string[] => [...new Set(values)];100const unique = (values: readonly string[]): readonly string[] => [...new Set(values)];
67 101
102const isPluginCtx = (value: unknown): value is PluginCtx =>
103 isRecord(value) &&
104 isRecord(value.connections) &&
105 typeof value.connections.list === "function" &&
106 typeof value.connections.get === "function" &&
107 typeof value.execute === "function";
108
68const syncFailure = (message: string, path?: string): GitHubSyncResult => ({109const syncFailure = (message: string, path?: string): GitHubSyncResult => ({
69 status: "failed",110 status: "failed",
70 tools: [],111 tools: [],
@@ -78,6 +119,98 @@ const syncFailure = (message: string, path?: string): GitHubSyncResult => ({ · 7 unmodified lines
78 ],119 ],
79});120});
80 121
122const missingResolver = (): ClientResolver => ({
123 listConnections: () => Effect.succeed([]),
124 resolveConnection: () => Effect.succeed(null),
125 call: ({ integration, connection }) =>
126 Effect.fail(
127 new BindingError({
128 role: integration,
129 integration,
130 requestedConnection: connection,
131 message: "apps resolver is unavailable outside a request-scoped executor",
132 }),
133 ),
134});
135
136const missingBackingsMessage = "apps plugin requires backings or runtime";
137
138const missingPublishError = (): PublishError =>
139 new PublishError({
140 message: missingBackingsMessage,
141 stage: "project",
142 diagnostics: [],
143 });
144
145const missingStorageError = (): StorageError =>
146 new StorageError({
147 message: missingBackingsMessage,
148 cause: missingBackingsMessage,
149 });
150
151const missingRuntime = (): AppsRuntime => ({
152 publish: () => Effect.fail(missingPublishError()),
153 getDescriptor: () => Effect.succeed(null),
154 listGitHubSources: () => Effect.succeed([]),
155 removeSource: () => Effect.fail(missingPublishError()),
156 repair: () => Effect.fail(missingPublishError()),
157 invokeTool: () => Effect.fail(missingPublishError()),
158 deps: {
159 artifactStore: {
160 forScope: () =>
161 Effect.fail(
162 new ArtifactStoreError({
163 message: missingBackingsMessage,
164 }),
165 ),
166 removeScope: () =>
167 Effect.fail(
168 new ArtifactStoreError({
169 message: missingBackingsMessage,
170 }),
171 ),
172 },
173 scopeDb: {
174 forScope: () =>
175 Effect.fail(
176 new ScopeDbError({
177 message: missingBackingsMessage,
178 }),
179 ),
180 removeScope: () =>
181 Effect.fail(
182 new ScopeDbError({
183 message: missingBackingsMessage,
184 }),
185 ),
186 close: () => Effect.void,
187 },
188 sandbox: {
189 collect: () =>
190 Effect.fail(
191 new ToolSandboxError({
192 message: missingBackingsMessage,
193 kind: "collect",
194 }),
195 ),
196 invoke: () =>
197 Effect.fail(
198 new ToolSandboxError({
199 message: missingBackingsMessage,
200 kind: "invoke",
201 }),
202 ),
203 },
204 store: {
205 putDescriptor: () => Effect.fail(missingStorageError()),
206 getDescriptor: () => Effect.succeed(null),
207 removeDescriptor: () => Effect.fail(missingStorageError()),
208 listDescriptors: () => Effect.succeed([]),
209 },
210 resolver: missingResolver(),
211 },
212});
213
81const sourceTokenItemId = (tenant: string, scope: string): ProviderItemId =>214const sourceTokenItemId = (tenant: string, scope: string): ProviderItemId =>
82 ProviderItemId.make(`apps:github-source:${tenant}:${scope}:token`);215 ProviderItemId.make(`apps:github-source:${tenant}:${scope}:token`);
83 216
@@ -160,7 +293,11 @@ const projectTool = (descriptor: ToolDescriptor): ToolDef => ({ · 76 unmodified lines
160});293});
161 294
162export const appsPlugin = definePlugin((options?: AppsPluginOptions) => {295export const appsPlugin = definePlugin((options?: AppsPluginOptions) => {
163 const runtime = options?.runtime as AppsRuntime;296 const runtime =
297 options?.runtime ??
298 (options?.backings
299 ? makeAppsRuntimeFromBackings(options.backings, missingResolver())
300 : missingRuntime());
164 const makeResolver = options?.makeResolver;301 const makeResolver = options?.makeResolver;
165 302
166 const tenantFor = (ctx: Pick<PluginCtx, "owner"> | undefined): string => {303 const tenantFor = (ctx: Pick<PluginCtx, "owner"> | undefined): string => {
@@ -436,6 +573,66 @@ export const appsPlugin = definePlugin((options?: AppsPluginOptions) => { · 269 unmodified lines
436 Effect.orElseSucceed(() => null),573 Effect.orElseSucceed(() => null),
437 );574 );
438 575
576 const requestResolver = (input: {
577 readonly ctx: unknown;
578 readonly scope: string;
579 readonly tool: string;
580 }): ClientResolver =>
581 makeResolver
582 ? makeResolver(input)
583 : isPluginCtx(input.ctx)
584 ? makePluginCtxAppsResolver({ ctx: input.ctx })
585 : runtime.deps.resolver;
586
587 const syncSourceFromPayload = (ctx: PluginCtx<AppsStoreShape>, args: unknown) =>
588 Effect.gen(function* () {
589 const payload = isRecord(args) ? args : {};
590 const url =
591 typeof payload.url === "string"
592 ? payload.url.trim()
593 : typeof payload.repo === "string"
594 ? payload.repo.trim()
595 : "";
596 const ref = asString(payload.ref);
597 const providedToken = asString(payload.token) ?? null;
598 const slug = asString(payload.slug);
599 if (slug && !url) return yield* syncExistingSource(ctx, slug, providedToken);
600 if (!url) return syncFailure('sync_github_source requires "url"');
601 return yield* addSource(ctx, {
602 url,
603 ...(ref ? { ref } : {}),
604 ...(asString(payload.name) ? { name: asString(payload.name) } : {}),
605 token: providedToken,
606 });
607 }).pipe(
608 Effect.catchTags({
609 CredentialProviderNotRegisteredError: (err) => Effect.succeed(syncFailure(err.message)),
610 IntegrationNotFoundError: (err) => Effect.succeed(syncFailure(err.message)),
611 InvalidConnectionInputError: (err) => Effect.succeed(syncFailure(err.message)),
612 }),
613 );
614
615 const extensionFor = (ctx: PluginCtx<AppsStoreShape>): AppsPluginExtension => ({
616 runtime,
617 syncGitHubSource: (input) => syncSourceFromPayload(ctx, input),
618 listGitHubSources: () =>
619 Effect.gen(function* () {
620 const sources = yield* listSources(ctx);
621 return { sources };
622 }),
623 getGitHubSource: (slug) =>
624 Effect.gen(function* () {
625 if (!slug) return { source: null };
626 const source = yield* getSource(ctx, slug);
627 return { source };
628 }),
629 removeGitHubSource: (slug) =>
630 Effect.gen(function* () {
631 yield* ctx.core.integrations.remove(IntegrationSlug.make(slug));
632 return { removed: true as const };
633 }),
634 });
635
439 return {636 return {
440 id: APPS_PLUGIN_ID as "apps",637 id: APPS_PLUGIN_ID as "apps",
441 packageName: "@executor-js/plugin-apps",638 packageName: "@executor-js/plugin-apps",
@@ -455,9 +652,9 @@ export const appsPlugin = definePlugin((options?: AppsPluginOptions) => { · 13 unmodified lines
455 },652 },
456 },653 },
457 654
458 extension: () => ({ runtime }),655 extension: extensionFor,
459 656
460 staticSources: () => [657 staticSources: (self) => [
461 {658 {
462 id: APPS_PLUGIN_ID,659 id: APPS_PLUGIN_ID,
463 kind: "executor",660 kind: "executor",
@@ -466,47 +663,18 @@ export const appsPlugin = definePlugin((options?: AppsPluginOptions) => { · 2 unmodified lines
466 tool<AppsStoreShape>({663 tool<AppsStoreShape>({
467 name: "sync_github_source",664 name: "sync_github_source",
468 description: "Sync a GitHub repository containing custom tool source files.",665 description: "Sync a GitHub repository containing custom tool source files.",
469 execute: (args, { ctx }) =>666 execute: (args) => self.syncGitHubSource(args),
470 Effect.gen(function* () {
471 const payload = isRecord(args) ? args : {};
472 const url =
473 typeof payload.url === "string"
474 ? payload.url.trim()
475 : typeof payload.repo === "string"
476 ? payload.repo.trim()
477 : "";
478 const ref = asString(payload.ref);
479 const providedToken = asString(payload.token) ?? null;
480 const slug = asString(payload.slug);
481 if (slug && !url) return yield* syncExistingSource(ctx, slug, providedToken);
482 if (!url) return syncFailure('sync_github_source requires "url"');
483 return yield* addSource(ctx, {
484 url,
485 ...(ref ? { ref } : {}),
486 ...(asString(payload.name) ? { name: asString(payload.name) } : {}),
487 token: providedToken,
488 });
489 }),
490 }),667 }),
491 tool<AppsStoreShape>({668 tool<AppsStoreShape>({
492 name: "list_github_sources",669 name: "list_github_sources",
493 description: "List synced GitHub repositories that publish custom tools.",670 description: "List synced GitHub repositories that publish custom tools.",
494 execute: (_args, { ctx }) =>671 execute: () => self.listGitHubSources(),
495 Effect.gen(function* () {
496 const sources = yield* listSources(ctx);
497 return { sources };
498 }),
499 }),672 }),
500 tool<AppsStoreShape>({673 tool<AppsStoreShape>({
501 name: "get_github_source",674 name: "get_github_source",
502 description: "Read one synced GitHub custom-tools source.",675 description: "Read one synced GitHub custom-tools source.",
503 execute: (args, { ctx }) =>676 execute: (args) =>
504 Effect.gen(function* () {677 self.getGitHubSource(isRecord(args) ? (asString(args.slug) ?? "") : ""),
505 const slug = isRecord(args) ? asString(args.slug) : undefined;
506 if (!slug) return { source: null };
507 const source = yield* getSource(ctx, slug);
508 return { source };
509 }),
510 }),678 }),
511 ],679 ],
512 },680 },
@@ -547,9 +715,7 @@ export const appsPlugin = definePlugin((options?: AppsPluginOptions) => { · 34 unmodified lines
547 const descriptor = yield* runtime.getDescriptor(tenant, source.scope);715 const descriptor = yield* runtime.getDescriptor(tenant, source.scope);
548 const toolDesc = descriptor?.tools.find((t) => t.name === toolRow.name);716 const toolDesc = descriptor?.tools.find((t) => t.name === toolRow.name);
549 if (!toolDesc) return { inputSchema, outputSchema };717 if (!toolDesc) return { inputSchema, outputSchema };
550 const resolver = makeResolver718 const resolver = requestResolver({ ctx, scope: source.scope, tool: toolRow.name });
551 ? makeResolver({ ctx, scope: source.scope, tool: toolRow.name })
552 : runtime.deps.resolver;
553 const byRole: Record<string, readonly ConnectionCandidate[]> = {};719 const byRole: Record<string, readonly ConnectionCandidate[]> = {};
554 for (const [role, decl] of Object.entries(toolDesc.integrations)) {720 for (const [role, decl] of Object.entries(toolDesc.integrations)) {
555 byRole[role] = yield* resolver721 byRole[role] = yield* resolver
@@ -589,9 +755,7 @@ export const appsPlugin = definePlugin((options?: AppsPluginOptions) => { · 33 unmodified lines
589 diagnostics: [],755 diagnostics: [],
590 });756 });
591 }757 }
592 const resolver = makeResolver758 const resolver = requestResolver({ ctx, scope: source.scope, tool: toolRow.name });
593 ? makeResolver({ ctx, scope: source.scope, tool: toolRow.name })
594 : undefined;
595 return yield* runtime.invokeTool({759 return yield* runtime.invokeTool({
596 tenant,760 tenant,
597 scope: source.scope,761 scope: source.scope,
packages/plugins/apps/src/plugin/backings.ts+28−0
@@ -0,0 +1,28 @@
1import type { ArtifactStore } from "../seams/artifact-store";
2import type { ScopeDb } from "../seams/scope-db";
3import type { ToolSandbox } from "../seams/tool-sandbox";
4import { makeAppsRuntime, type AppsRuntime } from "./runtime";
5import type { AppsStore } from "./store";
6import type { ClientResolver } from "./bindings";
7
8export interface AppsBackings {
9 readonly artifactStore: ArtifactStore;
10 readonly scopeDb: ScopeDb;
11 readonly sandbox: ToolSandbox;
12 readonly store: AppsStore;
13 readonly defaultTenant?: string;
14 readonly resolver?: ClientResolver;
15}
16
17export const makeAppsRuntimeFromBackings = (
18 backings: AppsBackings,
19 fallbackResolver: ClientResolver,
20): AppsRuntime =>
21 makeAppsRuntime({
22 artifactStore: backings.artifactStore,
23 scopeDb: backings.scopeDb,
24 sandbox: backings.sandbox,
25 store: backings.store,
26 resolver: backings.resolver ?? fallbackResolver,
27 defaultTenant: backings.defaultTenant,
28 });
packages/plugins/apps/src/plugin/handlers.ts+49−0
@@ -0,0 +1,49 @@
1import { Context, Effect } from "effect";
2import { HttpApiBuilder } from "effect/unstable/httpapi";
3
4import { addGroup, capture } from "@executor-js/api";
5import type { AppsPluginExtension } from "./apps-plugin";
6import { AppsGroup } from "./routes";
7
8export class AppsExtensionService extends Context.Service<
9 AppsExtensionService,
10 AppsPluginExtension
11>()("AppsExtensionService") {}
12
13const ExecutorApiWithApps = addGroup(AppsGroup);
14
15export const AppsHandlers = HttpApiBuilder.group(ExecutorApiWithApps, "apps", (handlers) =>
16 handlers
17 .handle("listGithubSources", () =>
18 capture(
19 Effect.gen(function* () {
20 const ext = yield* AppsExtensionService;
21 return yield* ext.listGitHubSources();
22 }),
23 ),
24 )
25 .handle("syncGithubSource", ({ payload }) =>
26 capture(
27 Effect.gen(function* () {
28 const ext = yield* AppsExtensionService;
29 return yield* ext.syncGitHubSource(payload);
30 }),
31 ),
32 )
33 .handle("getGithubSource", ({ params }) =>
34 capture(
35 Effect.gen(function* () {
36 const ext = yield* AppsExtensionService;
37 return yield* ext.getGitHubSource(params.slug);
38 }),
39 ),
40 )
41 .handle("removeGithubSource", ({ params }) =>
42 capture(
43 Effect.gen(function* () {
44 const ext = yield* AppsExtensionService;
45 return yield* ext.removeGitHubSource(params.slug);
46 }),
47 ),
48 ),
49);
packages/plugins/apps/src/plugin/resolver.ts+116−0
@@ -0,0 +1,116 @@
1import { Effect } from "effect";
2
3import {
4 ConnectionName,
5 IntegrationSlug,
6 ToolAddress,
7 isToolResult,
8 type ConnectionRef,
9 type Owner,
10 type PluginCtx,
11} from "@executor-js/sdk";
12import { BindingError, type ClientResolver, type ConnectionCandidate } from "./bindings";
13
14const parseConnectionAddress = (address: string): ConnectionRef | null => {
15 const parts = address.split(".");
16 if (parts.length !== 4 || parts[0] !== "tools") return null;
17 const [, integration, owner, name] = parts;
18 if (!integration || !name) return null;
19 if (owner !== "org" && owner !== "user") return null;
20 return {
21 owner: owner as Owner,
22 integration: IntegrationSlug.make(integration),
23 name: ConnectionName.make(name),
24 };
25};
26
27const toCandidate = (connection: {
28 readonly address: unknown;
29 readonly integration: unknown;
30 readonly name?: unknown;
31 readonly owner?: unknown;
32}): ConnectionCandidate => ({
33 address: String(connection.address),
34 integration: String(connection.integration),
35 ...(connection.name !== undefined ? { name: String(connection.name) } : {}),
36 ...(connection.owner !== undefined ? { owner: String(connection.owner) } : {}),
37});
38
39export const makePluginCtxAppsResolver = (input: { readonly ctx: PluginCtx }): ClientResolver => ({
40 listConnections: ({ integration }) =>
41 input.ctx.connections.list({ integration: IntegrationSlug.make(integration) }).pipe(
42 Effect.map((connections) => connections.map(toCandidate)),
43 Effect.mapError(
44 () =>
45 new BindingError({
46 role: integration,
47 integration,
48 message: `failed to list ${integration} connections`,
49 }),
50 ),
51 ),
52
53 resolveConnection: ({ connection }) =>
54 Effect.gen(function* () {
55 const ref = parseConnectionAddress(connection);
56 if (!ref) return null;
57 const row = yield* input.ctx.connections.get(ref).pipe(
58 Effect.mapError(
59 () =>
60 new BindingError({
61 role: String(ref.integration),
62 integration: String(ref.integration),
63 requestedConnection: connection,
64 message: `failed to resolve connection ${connection}`,
65 }),
66 ),
67 );
68 return row ? toCandidate(row) : null;
69 }),
70
71 call: ({ integration, connection, path, args, invokeOptions }) =>
72 Effect.gen(function* () {
73 const ref = parseConnectionAddress(connection);
74 if (!ref) {
75 return yield* new BindingError({
76 role: integration,
77 integration,
78 requestedConnection: connection,
79 message: `invalid connection address ${connection}`,
80 });
81 }
82 if (String(ref.integration) !== integration) {
83 return yield* new BindingError({
84 role: integration,
85 integration,
86 requestedConnection: connection,
87 message: `connection "${connection}" belongs to integration "${ref.integration}", not "${integration}"`,
88 });
89 }
90 const tool = path.join(".");
91 const address = ToolAddress.make(`${connection}.${tool}`);
92 const payload = args[0] ?? {};
93 const result = yield* input.ctx.execute(address, payload, invokeOptions).pipe(
94 Effect.mapError(
95 () =>
96 new BindingError({
97 role: integration,
98 integration,
99 requestedConnection: connection,
100 message: `failed to execute ${address}`,
101 }),
102 ),
103 );
104 if (isToolResult(result)) {
105 if (result.ok) return result.data;
106 const { message } = result.error;
107 return yield* new BindingError({
108 role: integration,
109 integration,
110 requestedConnection: connection,
111 message,
112 });
113 }
114 return result;
115 }),
116});
packages/plugins/apps/src/plugin/routes.ts+104−0
@@ -0,0 +1,104 @@
1import { Schema } from "effect";
2import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
3import { IntegrationRemovalNotAllowedError, InternalError } from "@executor-js/sdk/shared";
4
5const GitHubSourcePayload = Schema.Struct({
6 url: Schema.optional(Schema.String),
7 repo: Schema.optional(Schema.String),
8 name: Schema.optional(Schema.String),
9 slug: Schema.optional(Schema.String),
10 ref: Schema.optional(Schema.String),
11 token: Schema.optional(Schema.String),
12});
13
14const SourceSlugParams = {
15 slug: Schema.String,
16};
17
18const SkippedArtifact = Schema.Struct({
19 path: Schema.String,
20 reason: Schema.Literals(["not supported yet", "unsupported file type", "ignored"]),
21});
22
23const FileDiagnostic = Schema.Struct({
24 path: Schema.String,
25 message: Schema.String,
26});
27
28const SyncErrorData = Schema.Struct({
29 stage: Schema.Literals(["source", "discover", "bundle", "collect", "project"]),
30 message: Schema.String,
31 diagnostics: Schema.optional(Schema.Array(FileDiagnostic)),
32});
33
34const GitHubSyncResponse = Schema.Struct({
35 status: Schema.Literals(["published", "up-to-date", "failed"]),
36 snapshotId: Schema.optional(Schema.String),
37 upstreamSha: Schema.optional(Schema.String),
38 tools: Schema.Array(Schema.String),
39 skipped: Schema.Array(SkippedArtifact),
40 errors: Schema.optional(Schema.Array(SyncErrorData)),
41});
42
43const GitHubSourceSummary = Schema.Struct({
44 slug: Schema.String,
45 name: Schema.String,
46 scope: Schema.String,
47 url: Schema.String,
48 repo: Schema.String,
49 ref: Schema.String,
50 hasToken: Schema.Boolean,
51 upstreamSha: Schema.String,
52 snapshotId: Schema.String,
53 description: Schema.optional(Schema.String),
54 publishedAt: Schema.String,
55 tools: Schema.Array(Schema.String),
56 skipped: Schema.Array(SkippedArtifact),
57});
58
59const GitHubSourcesResponse = Schema.Struct({
60 sources: Schema.Array(GitHubSourceSummary),
61});
62
63const GitHubSourceResponse = Schema.Struct({
64 source: Schema.NullOr(GitHubSourceSummary),
65});
66
67const RemoveSourceResponse = Schema.Struct({
68 removed: Schema.Boolean,
69});
70
71const DomainErrors = [InternalError] as const;
72const IntegrationRemovalNotAllowed = IntegrationRemovalNotAllowedError.annotate({
73 httpApiStatus: 409,
74});
75const RemoveSourceErrors = [InternalError, IntegrationRemovalNotAllowed] as const;
76
77export const AppsGroup = HttpApiGroup.make("apps")
78 .add(
79 HttpApiEndpoint.get("listGithubSources", "/apps/sources/github", {
80 success: GitHubSourcesResponse,
81 error: DomainErrors,
82 }),
83 )
84 .add(
85 HttpApiEndpoint.post("syncGithubSource", "/apps/sources/github/sync", {
86 payload: GitHubSourcePayload,
87 success: GitHubSyncResponse,
88 error: DomainErrors,
89 }),
90 )
91 .add(
92 HttpApiEndpoint.get("getGithubSource", "/apps/sources/github/:slug", {
93 params: SourceSlugParams,
94 success: GitHubSourceResponse,
95 error: DomainErrors,
96 }),
97 )
98 .add(
99 HttpApiEndpoint.delete("removeGithubSource", "/apps/sources/github/:slug", {
100 params: SourceSlugParams,
101 success: RemoveSourceResponse,
102 error: RemoveSourceErrors,
103 }),
104 );
packages/plugins/apps/src/plugin/self-host-runtime.ts+7−3
@@ -6,9 +6,10 @@ import { makeGitArtifactStore } from "../backing/git-artifact-store"; · 5 unmodified lines
6import { makeLibsqlScopeDb } from "../backing/libsql-scope-db";6import { makeLibsqlScopeDb } from "../backing/libsql-scope-db";
7import { makeQuickjsToolSandbox } from "../backing/quickjs-tool-sandbox";7import { makeQuickjsToolSandbox } from "../backing/quickjs-tool-sandbox";
8import type { ScopeDb } from "../seams/scope-db";8import type { ScopeDb } from "../seams/scope-db";
9import { makeAppsRuntime, type AppsRuntime } from "./runtime";9import { type AppsRuntime } from "./runtime";
10import type { AppsStore } from "./store";10import type { AppsStore } from "./store";
11import type { ClientResolver } from "./bindings";11import type { ClientResolver } from "./bindings";
12import { makeAppsRuntimeFromBackings, type AppsBackings } from "./backings";
12 13
13export interface SelfHostAppsRuntimeOptions {14export interface SelfHostAppsRuntimeOptions {
14 /** Data dir root; `<root>/artifacts` and `<root>/scope-db`. */15 /** Data dir root; `<root>/artifacts` and `<root>/scope-db`. */
@@ -24,6 +25,7 @@ export interface SelfHostAppsRuntimeOptions { · 9 unmodified lines
24 25
25export interface SelfHostAppsRuntime {26export interface SelfHostAppsRuntime {
26 readonly runtime: AppsRuntime;27 readonly runtime: AppsRuntime;
28 readonly backings: AppsBackings;
27 readonly scopeDb: ScopeDb;29 readonly scopeDb: ScopeDb;
28 readonly close: () => Promise<void>;30 readonly close: () => Promise<void>;
29}31}
@@ -39,17 +41,19 @@ export const makeSelfHostAppsRuntime = ( · 9 unmodified lines
39 root: inMem ? ":memory:" : join(options.dataDir, "scope-db"),41 root: inMem ? ":memory:" : join(options.dataDir, "scope-db"),
40 });42 });
41 const sandbox = makeQuickjsToolSandbox();43 const sandbox = makeQuickjsToolSandbox();
42 const runtime = makeAppsRuntime({44 const backings: AppsBackings = {
43 artifactStore,45 artifactStore,
44 scopeDb,46 scopeDb,
45 sandbox,47 sandbox,
46 store: options.store,48 store: options.store,
47 resolver: options.resolver,49 resolver: options.resolver,
48 defaultTenant: options.tenant,50 defaultTenant: options.tenant,
49 });51 };
52 const runtime = makeAppsRuntimeFromBackings(backings, options.resolver);
50 53
51 return {54 return {
52 runtime,55 runtime,
56 backings,
53 scopeDb,57 scopeDb,
54 close: async () => {58 close: async () => {
55 await Effect.runPromise(scopeDb.close().pipe(Effect.orElseSucceed(() => undefined)));59 await Effect.runPromise(scopeDb.close().pipe(Effect.orElseSucceed(() => undefined)));