@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-8gs4w1fy.js

@@ -0,0 +1,381 @@
+import {
+  ID16,
+  aisdk2,
+  mergeOverlay2
+} from "./repository-pye8sh6e.js";
+import {
+  ID14
+} from "./repository-nxamnhdf.js";
+import {
+  Service78
+} from "./repository-x6rcf4cj.js";
+import {
+  OAuth3,
+  Event19
+} from "./repository-sztg2hv4.js";
+import {
+  ID13,
+  MethodID2
+} from "./repository-0zkv00cg.js";
+import {
+  Service73
+} from "./repository-gtm8txn9.js";
+import {
+  get2
+} from "./repository-sm236kpq.js";
+import {
+  useragent2
+} from "./repository-j4z2qnee.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: ID13.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* Service73;
+    const bus = yield* Service78;
+    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(ID16.githubCopilot);
+      const existing = (yield* catalog.model.all()).filter((model) => model.providerID === ID16.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(ID16.githubCopilot);
+      if (!item)
+        return;
+      if (loaded.models) {
+        for (const id of item.models.keys()) {
+          if (!loaded.models.has(ID14.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(ID14.make("gpt-5-chat-latest"))) {
+        evt.model.update(item.provider.id, ID14.make("gpt-5-chat-latest"), (model) => {
+          model.enabled = false;
+        });
+      }
+    });
+    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
+    yield* bus.subscribe(Event19.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID13.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 !== ID16.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 !== ID16.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: ID16.githubCopilot });
+    yield* ctx.session.hook("http.request", (evt) => Effect.gen(function* () {
+      if (evt.model.providerID !== ID16.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: ID16.githubCopilot });
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== ID16.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/repository-8gxqpgph.js

@@ -0,0 +1,18 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/runner/index.ts
+var exports_runner = {};
+__export(exports_runner, {
+  DrainResult: () => DrainResult2,
+  Service: () => Service49,
+  SessionRunner: () => exports_runner
+});
+import { Context, Data } from "effect";
+var DrainResult2 = Data.taggedEnum();
+
+class Service49 extends Context.Service()("@opencode/SessionRunner") {
+}
+
+export { DrainResult2, Service49, exports_runner };

package/dist/chunks/repository-8m31s27t.js

@@ -0,0 +1,82 @@
+import {
+  makeWithDefaults2
+} from "./repository-f78hydwg.js";
+import {
+  apply3
+} from "./repository-qfmvv2sm.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/database/database.ts
+var exports_database = {};
+__export(exports_database, {
+  Database: () => exports_database,
+  Options: () => Options11,
+  Service: () => Service79,
+  configured: () => configured13,
+  configuredClient: () => configuredClient2,
+  layer: () => layer26,
+  layerFromClient: () => layerFromClient2,
+  node: () => node84
+});
+import { sqliteLayer, supportsForeignKeyToggle, supportsTuningPragmas } from "#sqlite";
+import { Context, Effect, Layer, Schema, Semaphore } from "effect";
+import { Global } from "@opencode/util/global";
+import { isAbsolute, join } from "path";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+var makeDatabase = makeWithDefaults2();
+var Options11 = Schema.Struct({
+  path: Schema.optional(Schema.String)
+});
+
+class Service79 extends Context.Service()("@opencode/storage/Database") {
+}
+var databaseLayer = (lock) => Layer.effect(Service79, Effect.gen(function* () {
+  const db = yield* makeDatabase;
+  if (supportsTuningPragmas) {
+    yield* db.run("PRAGMA journal_mode = WAL");
+    yield* db.run("PRAGMA synchronous = NORMAL");
+    yield* db.run("PRAGMA busy_timeout = 5000");
+    yield* db.run("PRAGMA cache_size = -64000");
+    yield* db.run("PRAGMA wal_checkpoint(PASSIVE)");
+  }
+  if (supportsForeignKeyToggle)
+    yield* db.run("PRAGMA foreign_keys = ON");
+  const semaphore = yield* lock;
+  yield* semaphore.withPermit(apply3(db));
+  return { db };
+}).pipe(Effect.orDie));
+var locks = new Map;
+function lockFor(filename) {
+  const existing = locks.get(filename);
+  if (existing)
+    return existing;
+  const lock = Semaphore.makeUnsafe(1);
+  locks.set(filename, lock);
+  return lock;
+}
+function layer26(options = { path: ":memory:" }) {
+  return Layer.unwrap(Effect.gen(function* () {
+    const provide = (filename) => databaseLayer(filename === ":memory:" ? Semaphore.make(1) : Effect.succeed(lockFor(filename))).pipe(Layer.provide(sqliteLayer({ filename })));
+    const filename = options.path ?? ":memory:";
+    if (filename === ":memory:" || isAbsolute(filename))
+      return provide(filename);
+    const global = yield* Global.Service;
+    return provide(join(global.data, filename));
+  }));
+}
+var layerFromClient2 = databaseLayer(Semaphore.make(1));
+function configured13(options) {
+  return makeGlobalNode({ service: Service79, layer: layer26(options), deps: [Global.node] });
+}
+function configuredClient2(client) {
+  return makeGlobalNode({
+    service: Service79,
+    layer: layerFromClient2.pipe(Layer.provide(client)),
+    deps: [Global.node]
+  });
+}
+var node84 = configured13({ path: ":memory:" });
+
+export { Options11, Service79, layer26, layerFromClient2, configured13, configuredClient2, node84, exports_database };

package/dist/chunks/repository-8n3pysct.js

@@ -0,0 +1,27 @@
+// src/database/migration/20260611192811_lush_chimera.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260611192811_lush_chimera",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP INDEX IF EXISTS \`credential_connector_active_idx\`;`);
+      yield* tx.run(`DROP TABLE \`credential\`;`);
+      yield* tx.run(`
+        CREATE TABLE \`credential\` (
+          \`id\` text PRIMARY KEY,
+          \`integration_id\` text,
+          \`label\` text NOT NULL,
+          \`value\` text NOT NULL,
+          \`connector_id\` text,
+          \`method_id\` text,
+          \`active\` integer,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+    });
+  }
+};
+var _20260611192811_lush_chimera_default = migration;
+
+export { _20260611192811_lush_chimera_default };

package/dist/chunks/repository-8p4f9s12.js

@@ -0,0 +1,41 @@
+import {
+  absoluteColumn2,
+  absoluteArrayColumn2
+} from "./repository-6msgmcgs.js";
+import {
+  Timestamps2
+} from "./repository-qfa1cgps.js";
+
+// src/project/sql.ts
+import { isNotNull, isNull, ne, or } from "drizzle-orm";
+import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core";
+var ProjectTable2 = sqliteTable("project", {
+  id: text().$type().primaryKey(),
+  worktree: absoluteColumn2().notNull(),
+  vcs: text().$type(),
+  name: text(),
+  icon_url: text(),
+  icon_url_override: text(),
+  icon_color: text(),
+  ...Timestamps2,
+  time_initialized: integer(),
+  sandboxes: absoluteArrayColumn2().notNull(),
+  commands: text({ mode: "json" }).$type()
+});
+var ProjectDirectoryTable2 = sqliteTable("project_directory", {
+  project_id: text().$type().notNull().references(() => ProjectTable2.id, { onDelete: "cascade" }),
+  directory: absoluteColumn2().notNull(),
+  type: text().$type(),
+  strategy: text(),
+  time_created: integer().notNull().$default(() => Date.now())
+}, (table) => [primaryKey({ columns: [table.project_id, table.directory] })]);
+function upsertProject2(db, project) {
+  const vcs = project.vcs?.type;
+  return db.insert(ProjectTable2).values({ id: project.id, worktree: project.canonical, vcs, sandboxes: [] }).onConflictDoUpdate({
+    target: ProjectTable2.id,
+    set: { vcs: vcs ?? null },
+    setWhere: vcs ? or(isNull(ProjectTable2.vcs), ne(ProjectTable2.vcs, vcs)) : isNotNull(ProjectTable2.vcs)
+  }).run();
+}
+
+export { ProjectTable2, ProjectDirectoryTable2, upsertProject2 };