import { Data, Effect, Predicate } from "effect";import { ToolName, ToolResult, definePlugin, type PluginCtx, type ToolDef } from "@executor-js/sdk"; import { makeInProcessAppToolExecutor, type AppToolExecutor } from "../executor/app-tool-executor";import { publish } from "../pipeline/publish";import { buildBridge, resolveIntegrationBindings } from "./bindings";import { makePluginCtxAppsResolver } from "./resolver";import { descriptorCollection, makeAppsStore, toolCollection, type AppsStore } from "./store"; const APPS_INTEGRATION = "apps";const APPS_CONNECTION = "published"; class AppPluginError extends Data.TaggedError("AppPluginError")<{  readonly message: string;}> {} interface ProjectedToolSchema {  readonly inputSchema?: unknown;  readonly outputSchema?: unknown;} const innerToolError = (  cause: unknown,): { readonly address: string; readonly innerMessage: string; readonly code?: string } | null => {  const direct =    Predicate.isTagged("AppInnerToolError")(cause) && typeof cause === "object" && cause !== null      ? (cause as {          readonly address?: unknown;          readonly innerMessage?: unknown;          readonly code?: unknown;        })      : null;  const nested =    direct === null &&    cause !== null &&    typeof cause === "object" &&    "cause" in cause &&    Predicate.isTagged("AppInnerToolError")(cause.cause)      ? (cause.cause as {          readonly address?: unknown;          readonly innerMessage?: unknown;          readonly code?: unknown;        })      : direct;  if (    nested === null ||    typeof nested.address !== "string" ||    typeof nested.innerMessage !== "string"  ) {    return null;  }  return {    address: nested.address,    innerMessage: nested.innerMessage,    ...(typeof nested.code === "string" ? { code: nested.code } : {}),  };}; const makeAppsExtension = (ctx: PluginCtx<AppsStore>, executor?: AppToolExecutor) => ({  publish: (input: Parameters<typeof publish>[1]) =>    publish({ store: ctx.storage, executor: executor ?? makeInProcessAppToolExecutor() }, input),}); export type AppsExtension = ReturnType<typeof makeAppsExtension>; export const makeAppsPlugin = (options?: { readonly executor?: AppToolExecutor }) =>  definePlugin(() => ({    id: "apps",    packageName: "@executor-js/plugin-apps",    pluginStorage: {      [descriptorCollection.name]: descriptorCollection,      [toolCollection.name]: toolCollection,    },    storage: ({ blobs, pluginStorage }) => makeAppsStore({ blobs, pluginStorage }),    extension: (ctx: PluginCtx<AppsStore>) => makeAppsExtension(ctx, options?.executor),    staticSources: () => [      {        id: "apps",        kind: "apps",        name: "Apps",        canRemove: false,        canRefresh: false,        tools: [],      },    ],    resolveTools: ({ storage }) =>      storage.listActiveTools().pipe(        Effect.map((tools) => ({          tools: tools.map(            (tool): ToolDef => ({              name: ToolName.make(tool.name),              description: tool.description,              inputSchema: tool.inputSchema,              outputSchema: tool.outputSchema,              annotations: {                ...(tool.annotations?.requiresApproval !== undefined                  ? { requiresApproval: tool.annotations.requiresApproval }                  : {}),                ...(tool.annotations?.readOnly === true ? { requiresApproval: false } : {}),              },            }),          ),        })),      ),    projectToolSchema: ({ ctx, toolRow, inputSchema, outputSchema }) =>      projectAppsToolSchema(ctx, String(toolRow.name), inputSchema, outputSchema),    validateToolArgs: ({ ctx, toolRow, args }) =>      Effect.gen(function* () {        const tool = yield* ctx.storage.getTool(String(toolRow.name));        if (!tool) return;        const resolver = makePluginCtxAppsResolver({ ctx });        yield* resolveIntegrationBindings(tool.integrations, args, resolver);      }),    invokeTool: ({ ctx, toolRow, args, invokeOptions }) =>      Effect.gen(function* () {        const tool = yield* ctx.storage.getTool(String(toolRow.name));        if (!tool) {          return yield* new AppPluginError({ message: `app tool not found: ${toolRow.name}` });        }        const bundle = yield* ctx.storage.getBlob(tool.bundleKey);        if (!bundle) {          return yield* new AppPluginError({ message: `app tool bundle missing: ${tool.name}` });        }        const resolver = makePluginCtxAppsResolver({ ctx });        const bindings = yield* resolveIntegrationBindings(tool.integrations, args, resolver);        const bridge = buildBridge({          declared: tool.integrations,          bindings: bindings.bindings,          resolver,          invokeOptions,        });        const result = yield* (options?.executor ?? makeInProcessAppToolExecutor())          .invoke(            bundle,            { toolName: tool.name },            { ...bindings.input, ...bindings.bindings },            bridge,            { timeoutMs: 30_000 },          )          .pipe(            Effect.catch((cause: unknown) => {              const inner = innerToolError(cause);              return inner                ? Effect.succeed(                    ToolResult.fail({                      code: inner.code ?? "inner_tool_error",                      message: `Inner tool ${inner.address} failed: "${inner.innerMessage}"`,                    }),                  )                : Effect.fail(cause);            }),          );        return "output" in result ? result.output : result;      }),  }))(); export const projectAppsToolSchema = (  ctx: PluginCtx<AppsStore>,  toolName: string,  inputSchema: unknown,  outputSchema: unknown,): Effect.Effect<ProjectedToolSchema, unknown> =>  Effect.gen(function* () {    const tool = yield* ctx.storage.getTool(toolName);    if (!tool || !inputSchema || typeof inputSchema !== "object" || Array.isArray(inputSchema)) {      return { inputSchema, outputSchema };    }    const schema = inputSchema as Record<string, unknown>;    const properties =      schema.properties &&      typeof schema.properties === "object" &&      !Array.isArray(schema.properties)        ? { ...(schema.properties as Record<string, unknown>) }        : {};    for (const [field, decl] of Object.entries(tool.integrations)) {      const connections = yield* ctx.connections.list({ integration: decl.slug as never });      const enumValues = connections.map((connection) => String(connection.address));      properties[field] =        decl.mode === "many"          ? { type: "array", items: { type: "string", enum: enumValues } }          : { type: "string", enum: enumValues };    }    return { inputSchema: { ...schema, properties }, outputSchema };  }); export const appsPlugin = makeAppsPlugin(); export { APPS_INTEGRATION, APPS_CONNECTION };