@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-tzjcchbs.js

@@ -0,0 +1,605 @@
+import {
+  Metadata2,
+  node63
+} from "./worktree-xrd4famk.js";
+import {
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  ID15,
+  Service73,
+  node78
+} from "./worktree-7vcja736.js";
+import {
+  ID12
+} from "./worktree-9qn3qky1.js";
+import {
+  Service62,
+  node67
+} from "./worktree-b1x7x3xx.js";
+import {
+  ID11
+} from "./worktree-esam66tc.js";
+import {
+  ID10,
+  OAuth3
+} from "./worktree-0tg2xvbt.js";
+import {
+  ID8,
+  MethodID2,
+  AttemptID2,
+  Method2,
+  Service64,
+  node69
+} from "./worktree-g0he3e83.js";
+import {
+  Service63,
+  node68
+} from "./worktree-e3fx731j.js";
+import {
+  Service44,
+  node47
+} from "./worktree-4m55frd1.js";
+import {
+  Service58,
+  node62
+} from "./worktree-madgwgkk.js";
+import {
+  AbsolutePath2
+} from "./worktree-922hggd3.js";
+import {
+  Info31,
+  Ref4,
+  Service74,
+  node79
+} from "./worktree-z82wee6n.js";
+import {
+  Service38,
+  node41
+} from "./worktree-w2jjwenf.js";
+import {
+  ID7
+} from "./worktree-vq45zjjz.js";
+import {
+  Service26,
+  node31
+} from "./worktree-146a62k1.js";
+import {
+  Service77,
+  node82
+} from "./worktree-r05k2dy1.js";
+import {
+  Service70,
+  node75
+} from "./worktree-k56d8zdx.js";
+import {
+  Service67,
+  node72
+} from "./worktree-249ffbnn.js";
+import {
+  Source4,
+  Service41,
+  node44
+} from "./worktree-q3ac6zk1.js";
+import {
+  Info6,
+  Service39,
+  node42
+} from "./worktree-5ycqwtsz.js";
+import {
+  Service17,
+  node21
+} from "./worktree-p9690q97.js";
+import {
+  Service43,
+  node46
+} from "./worktree-jwd18bs2.js";
+import {
+  Service50,
+  node53
+} from "./worktree-2t421ajn.js";
+import {
+  Service40,
+  node43
+} from "./worktree-vp47j2z8.js";
+import {
+  ID4,
+  Service30,
+  node34
+} from "./worktree-2qnjyx3m.js";
+import {
+  StrategyID2,
+  Info21,
+  ListEntry3,
+  UnsupportedLocationError2,
+  Service59,
+  node64
+} from "./worktree-nrs7ag5n.js";
+import {
+  Service60,
+  node65
+} from "./worktree-fvhg6c42.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/plugin/host.ts
+var exports_host = {};
+__export(exports_host, {
+  PluginHost: () => exports_host,
+  make: () => make11,
+  requirements: () => requirements3,
+  storage: () => storage2
+});
+import { EventManifest } from "@opencode/schema/event-manifest";
+import { ServerConfig } from "@opencode/schema/mcp";
+import { Effect, Schema, Stream } from "effect";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+var mutable = (value) => value;
+var isRpcEvent = (event) => event.type.startsWith("rpc.");
+var make11 = Effect.fn("PluginHost.make")(function* (plugin, pluginID = "test") {
+  const app = yield* Metadata2;
+  const agents = yield* Service73;
+  const aisdk = yield* Service62;
+  const catalog = yield* Service63;
+  const commands = yield* Service44;
+  const bus = yield* Service79;
+  const integration = yield* Service64;
+  const kv = yield* Service58;
+  const mcp = yield* Service26;
+  const location = yield* Service74;
+  const reference = yield* Service41;
+  const rpc = yield* Service50;
+  const skill = yield* Service39;
+  const tools = yield* Service67;
+  const vcs = yield* Service40;
+  const websearch = yield* Service30;
+  const generate = yield* Service60;
+  const permission = yield* Service70;
+  const hooks = yield* Service77;
+  const sessions = yield* Service17;
+  const persistentPty = yield* Service43;
+  const locations = yield* Service38;
+  const worktrees = yield* Service59;
+  const locationInfo = () => new Info31({
+    directory: location.directory,
+    workspaceID: location.workspaceID,
+    project: location.project
+  });
+  const locationRef = (input) => input?.location === undefined ? undefined : Ref4.make({
+    directory: AbsolutePath2.make(input.location.directory ?? location.directory),
+    workspaceID: input.location.workspace === undefined ? location.workspaceID : ID7.make(input.location.workspace)
+  });
+  const isCurrentLocation = (ref) => ref.directory === location.directory && ref.workspaceID === location.workspaceID;
+  const response = (effect) => effect.pipe(Effect.map((data) => ({ location: locationInfo(), data })));
+  const atWorktree = (ref, run) => {
+    if (ref?.workspaceID)
+      return Effect.fail(new UnsupportedLocationError2({ directory: ref.directory }));
+    if (!ref || isCurrentLocation(ref))
+      return run(worktrees);
+    return Effect.gen(function* () {
+      const { Plugin } = yield* Effect.promise(() => import("../plugin.js"));
+      const plugins = yield* Plugin.Service;
+      const target = yield* Service59;
+      yield* plugins.awaitActivation;
+      return yield* run(target);
+    }).pipe(Effect.provide(locations.get(ref)));
+  };
+  const decodeWorktree = Schema.decodeUnknownEffect(Info21);
+  const decodeWorktrees = Schema.decodeUnknownEffect(Schema.Array(ListEntry3));
+  const listAgents = Effect.fn("PluginHost.listAgents")((ref) => Effect.gen(function* () {
+    const location = yield* Service74;
+    const agents = yield* Service73;
+    return {
+      location: new Info31({
+        directory: location.directory,
+        workspaceID: location.workspaceID,
+        project: location.project
+      }),
+      data: yield* agents.list()
+    };
+  }).pipe(Effect.provide(locations.get(ref)), Effect.orDie));
+  const context = {
+    app,
+    location: locationInfo(),
+    options: {},
+    rpc: Object.assign(rpc.client, { register: rpc.register }),
+    agent: {
+      get: (input) => {
+        const ref = locationRef(input);
+        const output = ref && !isCurrentLocation(ref) ? listAgents(ref).pipe(Effect.map((result) => ({
+          ...result,
+          data: result.data.find((agent) => agent.id === input.agentID)
+        }))) : response(agents.get(input.agentID));
+        return output.pipe(Effect.flatMap((result) => result.data ? Effect.succeed({ ...result, data: result.data }) : Effect.fail(new Error(`Agent not found: ${input.agentID}`))));
+      },
+      list: (input) => {
+        const ref = locationRef(input);
+        if (ref && !isCurrentLocation(ref))
+          return listAgents(ref);
+        return response(agents.list());
+      },
+      reload: agents.reload,
+      transform: (callback) => agents.transform((editor) => {
+        callback({
+          list: () => mutable(editor.list()),
+          get: (id) => mutable(editor.get(ID15.make(id))),
+          default: (id) => editor.default(id === undefined ? undefined : ID15.make(id)),
+          update: (id, update) => editor.update(ID15.make(id), update),
+          remove: (id) => editor.remove(ID15.make(id))
+        });
+      })
+    },
+    aisdk: {
+      hook: (name, callback, options) => {
+        if (name === "sdk") {
+          return aisdk.hook.sdk((event) => {
+            if (options?.providerID !== undefined && options.providerID !== event.model.providerID)
+              return Effect.void;
+            const output = {
+              model: mutable(event.model),
+              package: event.package,
+              options: event.options,
+              sdk: event.sdk
+            };
+            return Reflect.apply(callback, undefined, [output]).pipe(Effect.tap(() => Effect.sync(() => event.sdk = output.sdk)));
+          });
+        }
+        return aisdk.hook.language((event) => {
+          if (options?.providerID !== undefined && options.providerID !== event.model.providerID)
+            return Effect.void;
+          const output = {
+            model: mutable(event.model),
+            options: event.options,
+            sdk: event.sdk,
+            language: event.language
+          };
+          return Reflect.apply(callback, undefined, [output]).pipe(Effect.tap(() => Effect.sync(() => event.language = output.language)));
+        });
+      }
+    },
+    catalog: {
+      provider: {
+        list: () => response(catalog.provider.available()),
+        get: (input) => catalog.provider.get(ID12.make(input.providerID)).pipe(Effect.flatMap((provider) => provider === undefined ? Effect.fail(new Error(`Provider not found: ${input.providerID}`)) : response(Effect.succeed(provider))))
+      },
+      model: {
+        list: () => response(catalog.model.available()),
+        default: () => response(catalog.model.default())
+      },
+      reload: catalog.reload,
+      transform: (callback) => catalog.transform((editor) => {
+        callback({
+          provider: {
+            list: () => mutable(editor.provider.list()),
+            get: (id) => mutable(editor.provider.get(ID12.make(id))),
+            update: (id, update) => editor.provider.update(ID12.make(id), update),
+            remove: (id) => editor.provider.remove(ID12.make(id))
+          },
+          model: {
+            get: (providerID, modelID) => mutable(editor.model.get(ID12.make(providerID), ID11.make(modelID))),
+            update: (providerID, modelID, update) => editor.model.update(ID12.make(providerID), ID11.make(modelID), update),
+            remove: (providerID, modelID) => editor.model.remove(ID12.make(providerID), ID11.make(modelID)),
+            default: {
+              get: editor.model.default.get,
+              set: (providerID, modelID) => editor.model.default.set(ID12.make(providerID), ID11.make(modelID))
+            }
+          }
+        });
+      })
+    },
+    command: {
+      list: () => response(commands.list()),
+      reload: commands.reload,
+      transform: commands.transform
+    },
+    event: {
+      subscribe: () => bus.subscribe().pipe(Stream.filter((event) => EventManifest.isServer(event) || isRpcEvent(event)))
+    },
+    experimental: {
+      terminal: {
+        read: (input) => persistentPty.read(input.sessionID, input.lines)
+      }
+    },
+    generate: {
+      text: (input) => generate.text(input).pipe(Effect.map((text) => ({ text })))
+    },
+    integration: {
+      list: () => response(integration.list()),
+      get: (input) => response(integration.get(ID8.make(input.integrationID))),
+      connect: {
+        key: (input) => integration.connection.key({
+          integrationID: ID8.make(input.integrationID),
+          key: input.key,
+          answer: input.answer,
+          label: input.label
+        })
+      },
+      oauth: {
+        connect: (input) => response(integration.oauth.connect({
+          integrationID: ID8.make(input.integrationID),
+          methodID: MethodID2.make(input.methodID),
+          answer: input.answer,
+          label: input.label
+        })),
+        status: (input) => response(integration.oauth.status({
+          integrationID: ID8.make(input.integrationID),
+          attemptID: AttemptID2.make(input.attemptID)
+        })),
+        complete: (input) => integration.oauth.complete({
+          integrationID: ID8.make(input.integrationID),
+          attemptID: AttemptID2.make(input.attemptID),
+          code: input.code
+        }),
+        cancel: (input) => integration.oauth.cancel({
+          integrationID: ID8.make(input.integrationID),
+          attemptID: AttemptID2.make(input.attemptID)
+        })
+      },
+      command: {
+        connect: (input) => response(integration.command.connect({
+          integrationID: ID8.make(input.integrationID),
+          methodID: MethodID2.make(input.methodID),
+          label: input.label
+        })),
+        status: (input) => response(integration.command.status({
+          integrationID: ID8.make(input.integrationID),
+          attemptID: AttemptID2.make(input.attemptID)
+        })),
+        cancel: (input) => integration.command.cancel({
+          integrationID: ID8.make(input.integrationID),
+          attemptID: AttemptID2.make(input.attemptID)
+        })
+      },
+      reload: integration.reload,
+      connection: {
+        active: (id) => integration.connection.active(ID8.make(id)),
+        resolve: (connection) => integration.connection.resolve(connection.type === "credential" ? { ...connection, id: ID10.make(connection.id) } : connection)
+      },
+      transform: (callback) => integration.transform((editor) => {
+        callback({
+          list: () => mutable(editor.list()),
+          get: (id) => mutable(editor.get(ID8.make(id))),
+          update: (id, update) => editor.update(ID8.make(id), update),
+          remove: (id) => editor.remove(ID8.make(id)),
+          method: {
+            list: (id) => editor.method.list(ID8.make(id)),
+            update: (input) => editor.method.update(methodImplementation(input)),
+            remove: (id, method) => editor.method.remove(ID8.make(id), Schema.decodeUnknownSync(Method2)(method))
+          }
+        });
+      })
+    },
+    mcp: {
+      list: (input) => {
+        const ref = locationRef(input);
+        if (ref && !isCurrentLocation(ref))
+          return Effect.gen(function* () {
+            const location = yield* Service74;
+            const mcp = yield* Service26;
+            return {
+              location: new Info31({
+                directory: location.directory,
+                workspaceID: location.workspaceID,
+                project: location.project
+              }),
+              data: yield* mcp.servers()
+            };
+          }).pipe(Effect.provide(locations.get(ref)));
+        return response(mcp.servers());
+      },
+      reload: mcp.reload,
+      transform: (callback) => mcp.transform((editor) => {
+        callback({
+          list: () => editor.list().map(([name, config]) => [name, mutable(config)]),
+          get: (name) => mutable(editor.get(name)),
+          set: (name, config) => editor.set(name, Schema.decodeUnknownSync(ServerConfig)(config)),
+          update: editor.update,
+          remove: editor.remove
+        });
+      })
+    },
+    permission: {
+      hook: (name, callback) => hooks.register("permission", name, callback),
+      list: (input) => permission.forSession(input.sessionID),
+      get: (input) => permission.get(input.requestID).pipe(Effect.flatMap((request) => request?.sessionID === input.sessionID ? Effect.succeed(request) : Effect.fail(new Error(`Permission request not found: ${input.requestID}`)))),
+      reply: (input) => permission.get(input.requestID).pipe(Effect.flatMap((request) => request?.sessionID === input.sessionID ? permission.reply({ requestID: input.requestID, reply: input.reply, message: input.message }) : Effect.fail(new Error(`Permission request not found: ${input.requestID}`))))
+    },
+    plugin: {
+      list: () => response(plugin.list())
+    },
+    reference: {
+      list: () => response(reference.list()),
+      reload: reference.reload,
+      transform: (callback) => reference.transform((editor) => {
+        callback({
+          add: (name, source) => editor.add(name, Schema.decodeUnknownSync(Source4)(source)),
+          remove: editor.remove,
+          list: editor.list,
+          get: editor.get
+        });
+      })
+    },
+    skill: {
+      list: () => response(skill.list()),
+      reload: skill.reload,
+      transform: (callback) => skill.transform((editor) => {
+        callback({
+          list: () => mutable(editor.list()),
+          get: editor.get,
+          add: (value) => editor.add(Schema.decodeUnknownSync(Info6)(value)),
+          update: editor.update,
+          remove: editor.remove
+        });
+      })
+    },
+    storage: storage2(kv, pluginID),
+    shell: {
+      hook: (name, callback) => hooks.register("shell", name, callback)
+    },
+    tool: {
+      transform: tools.transform,
+      reload: tools.reload,
+      hook: (name, callback) => hooks.register("tool", name, callback)
+    },
+    vcs: {
+      get: () => response(vcs.info()),
+      base: () => response(vcs.base()),
+      branches: (input) => response(vcs.branches({ search: input?.search, limit: input?.limit })),
+      status: () => response(vcs.status()),
+      diff: (input) => response(vcs.diff(input.mode, { context: input.context, base: input.base })),
+      transform: vcs.transform,
+      reload: vcs.reload
+    },
+    websearch: {
+      providers: () => response(websearch.providers()),
+      query: (input) => response(websearch.query({
+        query: input.query,
+        providerID: input.providerID === undefined ? undefined : ID4.make(input.providerID)
+      })),
+      reload: websearch.reload,
+      transform: (callback) => websearch.transform((editor) => {
+        callback({
+          add: (definition) => editor.add({
+            id: ID4.make(definition.id),
+            name: definition.name,
+            execute: definition.execute
+          }),
+          default: {
+            get: editor.default.get,
+            set: (selection) => editor.default.set(selection === false || selection === "random" ? selection : ID4.make(selection))
+          }
+        });
+      })
+    },
+    worktree: {
+      list: (input) => atWorktree(locationRef(input), (service) => service.list()),
+      create: (input) => atWorktree(locationRef(input), (service) => service.create(input)),
+      refresh: (input) => atWorktree(locationRef(input), (service) => service.refresh()).pipe(Effect.asVoid),
+      remove: (input) => atWorktree(locationRef(input), (service) => service.remove(input)),
+      reload: worktrees.reload,
+      transform: (callback) => worktrees.transform((editor) => callback({
+        add: (definition) => editor.add({
+          id: StrategyID2.make(definition.id),
+          create: (input) => definition.create(input).pipe(Effect.flatMap(decodeWorktree)),
+          remove: (input) => definition.remove(input),
+          list: (directory) => definition.list(directory).pipe(Effect.flatMap(decodeWorktrees))
+        })
+      }))
+    },
+    session: {
+      hook: (name, callback, options) => hooks.register("session", name, callback, options),
+      create: (input) => sessions.create({
+        id: input?.id,
+        title: input?.title,
+        agent: input?.agent,
+        model: input?.model,
+        location: input?.location ?? Ref4.make({ directory: location.directory, workspaceID: location.workspaceID })
+      }),
+      get: (input) => sessions.get(input.sessionID),
+      switchAgent: sessions.switchAgent,
+      switchModel: sessions.switchModel,
+      prompt: sessions.prompt,
+      generate: (input) => sessions.generate(input).pipe(Effect.map((text) => ({ text }))),
+      command: sessions.command,
+      rename: sessions.rename,
+      move: sessions.move,
+      synthetic: sessions.synthetic,
+      interrupt: (input) => sessions.interrupt(input.sessionID, { continue: input.continue }).pipe(Effect.map((interrupted) => ({ interrupted }))),
+      wait: (input) => sessions.wait(input.sessionID),
+      context: (input) => sessions.context(input.sessionID)
+    }
+  };
+  return context;
+});
+var requirements3 = LayerNode.group([
+  node63,
+  node78,
+  node67,
+  node68,
+  node47,
+  node84,
+  node69,
+  node62,
+  node31,
+  node79,
+  node44,
+  node53,
+  node42,
+  node72,
+  node43,
+  node34,
+  node64,
+  node65,
+  node75,
+  node82,
+  node21,
+  node46,
+  node41
+]);
+function storage2(kv, pluginID) {
+  const namespace = `plugin:${pluginID.split("").map((value) => value.charCodeAt(0).toString(16).padStart(4, "0")).join("")}:`;
+  return {
+    get: (key) => kv.get(namespace + key),
+    set: (key, value) => kv.set(namespace + key, value),
+    remove: (key) => kv.remove(namespace + key),
+    scan: (options) => kv.scan({
+      prefix: namespace + options.prefix,
+      after: options.after === undefined ? undefined : namespace + options.after,
+      limit: options.limit
+    }).pipe(Effect.map((result) => {
+      const entries = result.entries.map((entry) => ({
+        key: entry.key.slice(namespace.length),
+        value: entry.value
+      }));
+      if (result.next === undefined)
+        return { entries };
+      return { entries, next: result.next.slice(namespace.length) };
+    }))
+  };
+}
+function methodImplementation(input) {
+  if ("authorize" in input) {
+    const refresh = input.refresh;
+    return {
+      integrationID: ID8.make(input.integrationID),
+      method: { ...input.method, id: MethodID2.make(input.method.id) },
+      authorize: (answer) => input.authorize(answer).pipe(Effect.map((authorization) => {
+        if (authorization.mode === "auto") {
+          return {
+            ...authorization,
+            callback: authorization.callback.pipe(Effect.map(credential))
+          };
+        }
+        return {
+          ...authorization,
+          callback: (code) => authorization.callback(code).pipe(Effect.map(credential))
+        };
+      })),
+      ...refresh ? { refresh: (value) => refresh(value).pipe(Effect.map(credential)) } : {},
+      ...input.label ? { label: input.label } : {}
+    };
+  }
+  if (input.method.type === "env") {
+    return {
+      integrationID: ID8.make(input.integrationID),
+      method: input.method
+    };
+  }
+  if (input.method.type === "command") {
+    return {
+      integrationID: ID8.make(input.integrationID),
+      method: { ...input.method, id: MethodID2.make(input.method.id) }
+    };
+  }
+  return {
+    integrationID: ID8.make(input.integrationID),
+    method: input.method
+  };
+}
+function credential(value) {
+  return OAuth3.make({ ...value, methodID: MethodID2.make(value.methodID) });
+}
+
+export { make11, requirements3, storage2, exports_host };