@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-410w4w39.js

@@ -0,0 +1,381 @@
+import {
+  ID12,
+  aisdk2,
+  mergeOverlay2
+} from "./worktree-9qn3qky1.js";
+import {
+  ID11
+} from "./worktree-esam66tc.js";
+import {
+  Service79
+} from "./worktree-vrm5r67w.js";
+import {
+  OAuth3,
+  Event16
+} from "./worktree-0tg2xvbt.js";
+import {
+  ID8,
+  MethodID2
+} from "./worktree-g0he3e83.js";
+import {
+  Service63
+} from "./worktree-e3fx731j.js";
+import {
+  get2
+} from "./worktree-seak0fhn.js";
+import {
+  useragent2
+} from "./worktree-xrd4famk.js";
+
+// src/plugin/provider/github-copilot.ts
+import { Effect, Option, Schema, Semaphore, Stream } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var clientID = "Ov23li8tweQw6odWQebz";
+var apiVersion = "2026-08-01";
+var userApiVersion = "2025-04-01";
+var pollingSafetyMargin = 3000;
+var methodID = MethodID2.make("device");
+var Device = Schema.Struct({
+  verification_uri: Schema.String,
+  user_code: Schema.String,
+  device_code: Schema.String,
+  interval: Schema.Number
+});
+var Token = Schema.Struct({
+  access_token: Schema.optional(Schema.String),
+  error: Schema.optional(Schema.String),
+  interval: Schema.optional(Schema.Number)
+});
+var User = Schema.Struct({
+  chat_enabled: Schema.optional(Schema.Boolean),
+  can_signup_for_limited: Schema.optional(Schema.Boolean),
+  endpoints: Schema.optional(Schema.Struct({
+    api: Schema.optional(Schema.String)
+  }))
+});
+var decodeUser = Schema.decodeUnknownOption(User);
+var JsonBody = Schema.fromJsonString(Schema.Unknown);
+var decodeBody = Schema.decodeUnknownOption(JsonBody);
+var oauth = (app) => ({
+  integrationID: ID8.make("github-copilot"),
+  method: {
+    id: methodID,
+    type: "oauth",
+    label: "Login with GitHub Copilot",
+    form: [
+      {
+        type: "string",
+        key: "deploymentType",
+        title: "Select GitHub deployment type",
+        required: true,
+        options: [
+          { label: "GitHub.com", value: "github.com", description: "Public" },
+          { label: "GitHub Enterprise", value: "enterprise", description: "Data residency or self-hosted" }
+        ]
+      },
+      {
+        type: "string",
+        key: "enterpriseUrl",
+        title: "Enter your GitHub Enterprise URL or domain",
+        placeholder: "company.ghe.com or https://company.ghe.com",
+        required: true,
+        when: [{ key: "deploymentType", op: "eq", value: "enterprise" }]
+      }
+    ]
+  },
+  authorize: (answer) => Effect.gen(function* () {
+    const enterprise = answer.deploymentType === "enterprise";
+    const enterpriseUrl = typeof answer.enterpriseUrl === "string" ? answer.enterpriseUrl : undefined;
+    if (enterprise && !enterpriseUrl)
+      return yield* Effect.fail(new Error("Enterprise URL is required"));
+    const domain = enterprise ? normalizeDomain(enterpriseUrl ?? "") : "github.com";
+    const urls = oauthURLs(domain);
+    const device = yield* request(urls.device, {
+      method: "POST",
+      headers: headers(app),
+      body: JSON.stringify({ client_id: clientID, scope: "read:user" })
+    }).pipe(Effect.map(Schema.decodeUnknownSync(Device)));
+    const interval = Math.max(device.interval, 1) * 1000;
+    const poll = (wait) => request(urls.token, {
+      method: "POST",
+      headers: headers(app),
+      body: JSON.stringify({
+        client_id: clientID,
+        device_code: device.device_code,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+      })
+    }).pipe(Effect.map(Schema.decodeUnknownSync(Token)), Effect.flatMap((token) => {
+      if (token.access_token) {
+        const access = token.access_token;
+        return request(`${domain === "github.com" ? "https://api.github.com" : `https://api.${domain}`}/copilot_internal/user`, {
+          headers: {
+            Accept: "application/json",
+            Authorization: `Bearer ${access}`,
+            "User-Agent": useragent2(app),
+            "X-GitHub-Api-Version": userApiVersion
+          }
+        }).pipe(Effect.map((user) => Option.getOrUndefined(decodeUser(user))), Effect.orElseSucceed(() => {
+          return;
+        }), Effect.flatMap((user) => {
+          const denied = user && copilotEntitlementError2(user);
+          if (denied)
+            return Effect.fail(new Error(denied));
+          const apiEndpoint = user?.endpoints?.api?.replace(/\/+$/, "");
+          return Effect.succeed(OAuth3.make({
+            type: "oauth",
+            methodID,
+            refresh: access,
+            access,
+            expires: 0,
+            ...(enterprise || apiEndpoint) && {
+              metadata: {
+                ...enterprise ? { enterpriseUrl: domain } : {},
+                ...apiEndpoint ? { apiEndpoint } : {}
+              }
+            }
+          }));
+        }));
+      }
+      if (token.error === "authorization_pending")
+        return Effect.sleep(wait + pollingSafetyMargin).pipe(Effect.andThen(poll(wait)));
+      if (token.error === "slow_down") {
+        const next = token.interval && token.interval > 0 ? token.interval * 1000 : wait + 5000;
+        return Effect.sleep(next + pollingSafetyMargin).pipe(Effect.andThen(poll(next)));
+      }
+      return Effect.fail(new Error(`Device authorization failed${token.error ? `: ${token.error}` : ""}`));
+    }));
+    return {
+      mode: "auto",
+      url: device.verification_uri,
+      instructions: `Enter code: ${device.user_code}`,
+      callback: poll(interval)
+    };
+  })
+});
+var GithubCopilotPlugin2 = define({
+  id: "opencode.provider.github.copilot",
+  effect: Effect.fn(function* (ctx) {
+    const catalog = yield* Service63;
+    const bus = yield* Service79;
+    const loading = Semaphore.makeUnsafe(1);
+    const loaded = {};
+    const load = Effect.fn("GithubCopilotPlugin.load")(function* () {
+      const connection = yield* ctx.integration.connection.active("github-copilot");
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
+        return;
+      })) : undefined;
+      if (credential?.type !== "oauth") {
+        loaded.baseURL = undefined;
+        loaded.models = undefined;
+        return;
+      }
+      loaded.baseURL = copilotBaseURL2(credential.metadata);
+      const provider = yield* catalog.provider.get(ID12.githubCopilot);
+      const existing = (yield* catalog.model.all()).filter((model) => model.providerID === ID12.githubCopilot);
+      loaded.models = yield* Effect.tryPromise({
+        try: () => get2(loaded.baseURL ?? baseURL(), {
+          ...provider?.headers,
+          Authorization: `Bearer ${credential.refresh}`,
+          "User-Agent": useragent2(ctx.app),
+          "X-GitHub-Api-Version": apiVersion
+        }, existing),
+        catch: (cause) => cause
+      }).pipe(Effect.catch((cause) => Effect.logWarning("failed to sync GitHub Copilot models", { cause }).pipe(Effect.as(undefined))));
+    });
+    yield* ctx.integration.transform((editor) => {
+      editor.method.remove("github-copilot", { type: "key" });
+      editor.method.update(oauth(ctx.app));
+    });
+    yield* ctx.catalog.transform((evt) => {
+      const item = evt.provider.get(ID12.githubCopilot);
+      if (!item)
+        return;
+      if (loaded.models) {
+        for (const id of item.models.keys()) {
+          if (!loaded.models.has(ID11.make(id)))
+            evt.model.remove(item.provider.id, id);
+        }
+        for (const [id, model] of loaded.models) {
+          evt.model.update(item.provider.id, id, (draft) => Object.assign(draft, structuredClone(model)));
+        }
+      } else {
+        for (const id of item.models.keys()) {
+          evt.model.update(item.provider.id, id, (model) => {
+            model.package = aisdk2("@ai-sdk/github-copilot");
+            if (loaded.baseURL)
+              model.settings = mergeOverlay2(model.settings, { baseURL: loaded.baseURL });
+          });
+        }
+      }
+      if (item.models.has(ID11.make("gpt-5-chat-latest"))) {
+        evt.model.update(item.provider.id, ID11.make("gpt-5-chat-latest"), (model) => {
+          model.enabled = false;
+        });
+      }
+    });
+    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
+    yield* bus.subscribe(Event16.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID8.make("github-copilot")), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
+    yield* refresh().pipe(Effect.forkScoped);
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== ID12.githubCopilot)
+        return;
+      if (evt.package !== "@ai-sdk/github-copilot")
+        return;
+      evt.options.fetch = copilotFetch2(typeof evt.options.apiKey === "string" ? evt.options.apiKey : undefined, evt.options.fetch, ctx.app);
+      const mod = yield* Effect.promise(() => import("../github-copilot/copilot-provider.js"));
+      evt.sdk = mod.createOpenaiCompatible(evt.options);
+    }));
+    yield* ctx.session.hook("model.request", (evt) => Effect.gen(function* () {
+      if (evt.model.providerID !== ID12.githubCopilot)
+        return;
+      const session = yield* ctx.session.get({ sessionID: evt.sessionID }).pipe(Effect.orElseSucceed(() => {
+        return;
+      }));
+      const interaction = interactionType2(evt.kind, session?.parentID !== undefined);
+      evt.headers["X-Interaction-Type"] = interaction;
+      evt.headers["X-Interaction-Id"] = evt.sessionID;
+      if (interaction !== "conversation-agent")
+        evt.headers["x-initiator"] = "agent";
+    }), { providerID: ID12.githubCopilot });
+    yield* ctx.session.hook("http.request", (evt) => Effect.gen(function* () {
+      if (evt.model.providerID !== ID12.githubCopilot)
+        return;
+      const token = evt.request.headers.get("x-api-key");
+      if (!token)
+        return;
+      const text = yield* Effect.promise(() => evt.request.clone().text());
+      const body = Option.getOrUndefined(decodeBody(text));
+      applyHeaders(evt.request.headers, token, ctx.app, requestMetadata(evt.request.url, body), true);
+    }), { providerID: ID12.githubCopilot });
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== ID12.githubCopilot)
+        return;
+      if (evt.sdk.responses === undefined && evt.sdk.chat === undefined) {
+        evt.language = evt.sdk.languageModel(evt.model.modelID ?? evt.model.id);
+        return;
+      }
+      if (evt.options.endpoint === "responses" && evt.sdk.responses) {
+        evt.language = evt.sdk.responses(evt.model.modelID ?? evt.model.id);
+        return;
+      }
+      if (evt.options.endpoint === "chat" && evt.sdk.chat) {
+        evt.language = evt.sdk.chat(evt.model.modelID ?? evt.model.id);
+        return;
+      }
+      const id = evt.model.modelID ?? evt.model.id;
+      const match = /^gpt-(\d+)/.exec(id);
+      evt.language = match && Number(match[1]) >= 5 && !id.startsWith("gpt-5-mini") ? evt.sdk.responses(id) : evt.sdk.chat(id);
+    }));
+  })
+});
+function normalizeDomain(input) {
+  return input.replace(/^https?:\/\//, "").replace(/\/$/, "");
+}
+function oauthURLs(domain) {
+  return {
+    device: `https://${domain}/login/device/code`,
+    token: `https://${domain}/login/oauth/access_token`
+  };
+}
+function baseURL(enterprise) {
+  return enterprise ? `https://copilot-api.${normalizeDomain(enterprise)}` : "https://api.githubcopilot.com";
+}
+function copilotEntitlementError2(user) {
+  if (user.chat_enabled !== false)
+    return;
+  if (user.can_signup_for_limited)
+    return "This GitHub account is not signed up for GitHub Copilot. Sign up for Copilot Free at https://github.com/features/copilot/plans and connect again.";
+  return "This GitHub account does not have GitHub Copilot access. It needs an active Copilot subscription or a seat assigned by an organization.";
+}
+function copilotBaseURL2(metadata) {
+  const endpoint = metadata?.apiEndpoint;
+  if (typeof endpoint === "string" && endpoint)
+    return endpoint;
+  const enterprise = metadata?.enterpriseUrl;
+  return baseURL(typeof enterprise === "string" ? enterprise : undefined);
+}
+function headers(app) {
+  return {
+    Accept: "application/json",
+    "Content-Type": "application/json",
+    "User-Agent": useragent2(app)
+  };
+}
+function request(url, init) {
+  return Effect.tryPromise({
+    try: async (signal) => {
+      const response = await fetch(url, { ...init, signal });
+      if (!response.ok)
+        throw new Error(`Request failed: ${response.status}`);
+      return response.json();
+    },
+    catch: (cause) => cause
+  });
+}
+function copilotFetch2(token, upstream, app) {
+  const send = upstream ?? fetch;
+  return async (input, init) => {
+    const requestHeaders = new Headers(init?.headers);
+    const url = input instanceof URL ? input.href : typeof input === "string" ? input : input.url;
+    const body = typeof init?.body === "string" ? Option.getOrUndefined(decodeBody(init.body)) : undefined;
+    applyHeaders(requestHeaders, token, app, requestMetadata(url, body), false);
+    return send(input, { ...init, headers: requestHeaders });
+  };
+}
+function applyHeaders(headers, token, app, metadata, anthropic) {
+  if (token) {
+    headers.delete("authorization");
+    headers.delete("x-api-key");
+    headers.set("Authorization", `Bearer ${token}`);
+  }
+  headers.set("User-Agent", useragent2(app));
+  headers.set("Openai-Intent", "conversation-edits");
+  headers.set("X-GitHub-Api-Version", apiVersion);
+  if (metadata.agent)
+    headers.set("x-initiator", "agent");
+  else if (!headers.has("x-initiator"))
+    headers.set("x-initiator", "user");
+  if (metadata.vision)
+    headers.set("Copilot-Vision-Request", "true");
+  if (anthropic)
+    headers.set("anthropic-beta", "interleaved-thinking-2025-05-14");
+}
+function interactionType2(kind, child) {
+  if (kind === "title")
+    return "conversation-background";
+  if (kind === "compaction")
+    return "conversation-compaction";
+  if (child)
+    return "conversation-subagent";
+  return "conversation-agent";
+}
+function requestMetadata(url, body) {
+  if (!record(body))
+    return { agent: false, vision: false };
+  if (Array.isArray(body.input)) {
+    const last = body.input.at(-1);
+    return {
+      agent: !record(last) || last.role !== "user",
+      vision: body.input.some((item) => record(item) && Array.isArray(item.content) && item.content.some((part) => record(part) && part.type === "input_image"))
+    };
+  }
+  if (!Array.isArray(body.messages))
+    return { agent: false, vision: false };
+  const last = body.messages.at(-1);
+  if (url.includes("completions")) {
+    return {
+      agent: !record(last) || last.role !== "user",
+      vision: body.messages.some((message) => record(message) && Array.isArray(message.content) && message.content.some((part) => record(part) && part.type === "image_url"))
+    };
+  }
+  const content = record(last) && Array.isArray(last.content) ? last.content : [];
+  return {
+    agent: !record(last) || last.role !== "user" || !content.some((part) => record(part) && part.type !== "tool_result"),
+    vision: body.messages.some((message) => record(message) && Array.isArray(message.content) && message.content.some((part) => record(part) && (part.type === "image" || part.type === "tool_result" && Array.isArray(part.content) && part.content.some((nested) => record(nested) && nested.type === "image"))))
+  };
+}
+function record(input) {
+  return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+
+export { GithubCopilotPlugin2, copilotEntitlementError2, copilotBaseURL2, copilotFetch2, interactionType2 };

package/dist/chunks/worktree-43n2bw4t.js

@@ -0,0 +1,30 @@
+// src/database/migration/20260427172553_slow_nightmare.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260427172553_slow_nightmare",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_message\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_session_message_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_entry_session_idx\`;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_entry_session_type_idx\`;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_entry_time_created_idx\`;`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_idx\` ON \`session_message\` (\`session_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_type_idx\` ON \`session_message\` (\`session_id\`,\`type\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_time_created_idx\` ON \`session_message\` (\`time_created\`);`);
+      yield* tx.run(`DROP TABLE \`session_entry\`;`);
+    });
+  }
+};
+var _20260427172553_slow_nightmare_default = migration;
+
+export { _20260427172553_slow_nightmare_default };

package/dist/chunks/worktree-44gvr517.js

@@ -0,0 +1,123 @@
+import {
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  Service26,
+  node31
+} from "./worktree-146a62k1.js";
+import {
+  Service70,
+  node75
+} from "./worktree-k56d8zdx.js";
+import {
+  Service67,
+  node72
+} from "./worktree-249ffbnn.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/tool/mcp.ts
+var exports_mcp3 = {};
+__export(exports_mcp3, {
+  McpTool: () => exports_mcp3,
+  Service: () => Service25,
+  layer: () => layer12,
+  name: () => name14,
+  namespace: () => namespace2,
+  node: () => node30
+});
+import { ToolFailure } from "@opencode/ai";
+import { McpEvent } from "@opencode/schema/mcp-event";
+import { Context, Effect, Fiber, Layer, PubSub, Semaphore, Stream } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+var namespace2 = (server) => server.replace(/[^a-zA-Z0-9_-]/g, "_");
+var name14 = (server, tool) => `${namespace2(server)}_${tool.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+
+class Service25 extends Context.Service()("@opencode/McpTool") {
+}
+var layer12 = Layer.effect(Service25, Effect.gen(function* () {
+  const mcp = yield* Service26;
+  const tools = yield* Service67;
+  const bus = yield* Service79;
+  const permission = yield* Service70;
+  const lock = Semaphore.makeUnsafe(1);
+  let discovered = [];
+  const initial = yield* lock.withPermit(Effect.gen(function* () {
+    discovered = yield* mcp.tools();
+    yield* tools.transform((editor) => {
+      for (const tool of discovered) {
+        const schema = tool.inputSchema ?? {};
+        editor.add({
+          name: tool.name,
+          options: { namespace: namespace2(tool.server), codemode: tool.codemode !== false },
+          description: tool.description ?? "",
+          input: {
+            ...schema,
+            type: "object",
+            properties: schema.properties ?? {},
+            additionalProperties: false
+          },
+          output: tool.outputSchema ?? {},
+          execute: (input, context) => Effect.gen(function* () {
+            yield* permission.assert({
+              action: name14(tool.server, tool.name),
+              resources: ["*"],
+              save: ["*"],
+              metadata: {},
+              sessionID: context.sessionID,
+              agent: context.agent,
+              source: {
+                type: "tool",
+                messageID: context.messageID,
+                id: context.id
+              }
+            });
+            const result = yield* mcp.callTool({
+              server: tool.server,
+              name: tool.name,
+              args: input ?? {},
+              sessionID: context.sessionID
+            }).pipe(Effect.catchTags({
+              "MCP.NotFoundError": (error) => new ToolFailure({ message: `MCP server "${error.server}" is not available` }),
+              "MCP.ToolCallError": (error) => new ToolFailure({ message: error.message })
+            }));
+            if (result.isError)
+              return yield* new ToolFailure({
+                message: result.content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+`).trim() || "MCP tool returned an error"
+              });
+            const content = result.content.map((part) => part.type === "text" ? { type: "text", text: part.text } : {
+              type: "file",
+              uri: `data:${part.mimeType};base64,${part.data}`,
+              mime: part.mimeType
+            });
+            const text = content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+`);
+            return {
+              output: result.structured ?? (text === "" ? null : text),
+              ...content.length === 0 ? {} : { content }
+            };
+          }).pipe(Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to execute ${name14(tool.server, tool.name)}` })))
+        });
+      }
+    });
+  })).pipe(Effect.forkScoped);
+  const reconcile = lock.withPermit(Effect.gen(function* () {
+    discovered = yield* mcp.tools();
+    yield* tools.reload();
+  }));
+  const changes = yield* PubSub.sliding(1);
+  yield* bus.subscribe(McpEvent.ToolsChanged).pipe(Stream.runForEach(() => PubSub.publish(changes, undefined)), Effect.forkScoped({ startImmediately: true }));
+  const updates = yield* PubSub.subscribe(changes);
+  yield* Stream.fromSubscription(updates).pipe(Stream.debounce("100 millis"), Stream.runForEach(() => reconcile), Effect.forkScoped({ startImmediately: true }));
+  return Service25.of({ flush: Effect.asVoid(Fiber.await(initial)) });
+}));
+var node30 = makeLocationNode({
+  service: Service25,
+  layer: layer12,
+  deps: [node72, node31, node84, node75]
+});
+
+export { namespace2, name14, Service25, layer12, node30, exports_mcp3 };

package/dist/chunks/worktree-4knz6hnm.js

@@ -0,0 +1,22 @@
+// src/database/migration/20260808023530_workspace_domain.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260808023530_workspace_domain",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP TABLE \`workspace\`;`);
+      yield* tx.run(`
+        CREATE TABLE \`workspace\` (
+          \`id\` text PRIMARY KEY,
+          \`provider\` text NOT NULL,
+          \`binding\` text NOT NULL,
+          \`created_at\` integer NOT NULL,
+          \`last_used_at\` integer NOT NULL
+        );
+      `);
+    });
+  }
+};
+var _20260808023530_workspace_domain_default = migration;
+
+export { _20260808023530_workspace_domain_default };

package/dist/chunks/worktree-4m55frd1.js

@@ -0,0 +1,89 @@
+import {
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  create3
+} from "./worktree-kg06axw8.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/command.ts
+var exports_command4 = {};
+__export(exports_command4, {
+  Command: () => exports_command4,
+  Event: () => Event8,
+  ExecutionError: () => ExecutionError2,
+  Info: () => Info9,
+  NotFoundError: () => NotFoundError5,
+  Service: () => Service44,
+  layer: () => layer17,
+  node: () => node47
+});
+import { Command } from "@opencode/schema/command";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Event as Event8 } from "@opencode/schema/command";
+var Info9 = Command.Info;
+
+class NotFoundError5 extends Schema.TaggedError()("Command.NotFoundError", {
+  command: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class ExecutionError2 extends Schema.TaggedError()("Command.ExecutionError", {
+  command: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service44 extends Context.Service()("@opencode/Command") {
+}
+var layer17 = Layer.effect(Service44, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const state = create3({
+    name: "command",
+    initial: () => new Map,
+    editor: (editor) => ({
+      add: (definition) => editor.set(definition.name, definition)
+    }),
+    notify: () => bus.publish(Command.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  const info = (definition) => Info9.make({
+    name: definition.name,
+    description: definition.description
+  });
+  return Service44.of({
+    reload: state.reload,
+    transform: state.transform,
+    get: Effect.fn("Command.get")((name) => Effect.sync(() => {
+      const definition = state.get().get(name);
+      return definition ? info(definition) : undefined;
+    })),
+    list: Effect.fn("Command.list")(() => Effect.sync(() => Array.from(state.get().values(), info))),
+    execute: Effect.fn("Command.execute")(function* (input) {
+      const definition = state.get().get(input.name);
+      if (!definition)
+        return yield* new NotFoundError5({ command: input.name, message: `Command not found: ${input.name}` });
+      return yield* definition.execute(input.invocation).pipe(Effect.tapError((error) => Effect.logError("command execution failed", { command: input.name, error })), Effect.mapError((error) => new ExecutionError2({ command: input.name, message: errorMessage(error) })));
+    })
+  });
+}));
+var node47 = makeLocationNode({
+  service: Service44,
+  layer: layer17,
+  deps: [node84]
+});
+function errorMessage(error) {
+  if (error instanceof Error)
+    return error.message;
+  if (typeof error === "string")
+    return error;
+  if (error && typeof error === "object" && "message" in error && typeof error.message === "string")
+    return error.message;
+  return "Command execution failed";
+}
+
+export { Info9, NotFoundError5, ExecutionError2, Service44, layer17, node47, exports_command4, Event8 };