@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-6vhc8gnm.js

@@ -0,0 +1,297 @@
+import {
+  exports_provider_options
+} from "./location-mutation-y0x38cee.js";
+import {
+  exports_config
+} from "./location-mutation-fmh1wbpk.js";
+import {
+  exports_integration
+} from "./location-mutation-67ww7a6n.js";
+import {
+  exports_credential
+} from "./location-mutation-xvc235nh.js";
+import {
+  exports_model
+} from "./location-mutation-xfd1xnk3.js";
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+
+// src/plugin/provider/opencode.ts
+import { Duration, Effect, Schema, Semaphore, Stream } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { Money } from "@opencode-ai/schema/money";
+var defaultServer = "https://opencode.ai/console";
+var clientID = "opencode-cli";
+var methodID = exports_integration.MethodID.make("device");
+var RemoteResponse = Schema.Struct({ config: exports_config.Info });
+var Device = Schema.Struct({
+  device_code: Schema.String,
+  user_code: Schema.String,
+  verification_uri_complete: Schema.String,
+  expires_in: Schema.Number,
+  interval: Schema.Number
+});
+var Token = Schema.Struct({
+  access_token: Schema.String,
+  refresh_token: Schema.String,
+  expires_in: Schema.Number
+});
+var TokenPending = Schema.Struct({ error: Schema.String });
+var DeviceToken = Schema.Union([Token, TokenPending]);
+var User = Schema.Struct({ id: Schema.String, email: Schema.String });
+var Org = Schema.Struct({ id: Schema.String, name: Schema.String });
+function oauth(http) {
+  return {
+    integrationID: exports_integration.ID.make("opencode"),
+    method: {
+      id: methodID,
+      type: "oauth",
+      label: "OpenCode Console account"
+    },
+    authorize: (answer) => Effect.gen(function* () {
+      const server = yield* normalizeServer(answer.server ?? defaultServer);
+      const device = yield* post(http, `${server}/auth/device/code`, { client_id: clientID }, Device);
+      const verification = URL.canParse(device.verification_uri_complete) ? new URL(device.verification_uri_complete) : undefined;
+      if (verification && verification.protocol !== "http:" && verification.protocol !== "https:") {
+        return yield* Effect.fail(new Error("Invalid device verification URL: expected HTTP(S)"));
+      }
+      return {
+        mode: "auto",
+        url: verification?.href ?? `${server}/${device.verification_uri_complete.replace(/^\/+/, "")}`,
+        instructions: `Enter code: ${device.user_code}`,
+        callback: poll(http, server, device.device_code, Duration.seconds(device.interval))
+      };
+    }),
+    refresh: (credential) => Effect.gen(function* () {
+      const server = typeof credential.metadata?.server === "string" ? credential.metadata.server : defaultServer;
+      const token = yield* post(http, `${server}/auth/device/token`, { grant_type: "refresh_token", refresh_token: credential.refresh, client_id: clientID }, Token);
+      return {
+        ...credential,
+        access: token.access_token,
+        refresh: token.refresh_token,
+        expires: Date.now() + token.expires_in * 1000
+      };
+    }),
+    label: (credential) => {
+      return typeof credential.metadata?.orgName === "string" ? credential.metadata.orgName : undefined;
+    }
+  };
+}
+var OpencodePlugin = define({
+  id: "opencode.provider.opencode",
+  effect: Effect.fn(function* (ctx) {
+    const bus = yield* exports_bus.Service;
+    const http = yield* HttpClient.HttpClient;
+    const loading = Semaphore.makeUnsafe(1);
+    let connected = false;
+    let providers;
+    const load = Effect.fn("OpencodePlugin.load")(function* () {
+      const connection = yield* ctx.integration.connection.active("opencode");
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.catch(() => Effect.succeed(undefined))) : undefined;
+      connected = connection !== undefined;
+      providers = credential ? yield* fetchProviders(http, credential).pipe(Effect.catch((cause) => Effect.logWarning("failed to load OpenCode provider config", { cause }).pipe(Effect.as(undefined)))) : undefined;
+    });
+    yield* ctx.integration.transform((draft) => {
+      draft.update("opencode", (integration) => {
+        integration.name = "OpenCode";
+      });
+      draft.method.update(oauth(http));
+      draft.method.update({ integrationID: "opencode", method: { type: "key", label: "API key (service account)" } });
+    });
+    yield* load();
+    yield* ctx.catalog.transform((catalog) => {
+      for (const [providerID, item2] of Object.entries(providers ?? {})) {
+        catalog.provider.update(providerID, (provider) => {
+          provider.integrationID = exports_integration.ID.make("opencode");
+          if (item2.name !== undefined)
+            provider.name = item2.name;
+          provider.package = item2.npm ? exports_provider.aisdk(item2.npm) : "";
+          provider.settings = {
+            ...provider.settings,
+            ...withoutCredentials(item2.options),
+            ...item2.api ? { baseURL: item2.api } : {}
+          };
+          provider.headers = { ...provider.headers, ...item2.options?.headers };
+        });
+        for (const [modelID, config] of Object.entries(item2.models ?? {})) {
+          catalog.model.update(providerID, modelID, (model) => {
+            if (config.family !== undefined)
+              model.family = exports_model.Family.make(config.family);
+            if (config.name !== undefined)
+              model.name = config.name;
+            if (config.id !== undefined)
+              model.modelID = exports_model.ID.make(config.id);
+            model.compatibility = exports_model.compatibility(config.interleaved) ?? model.compatibility;
+            if (config.provider !== undefined) {
+              model.package = config.provider.npm ? exports_provider.aisdk(config.provider.npm) : undefined;
+              if (config.provider.api)
+                model.settings = { ...model.settings, baseURL: config.provider.api };
+            }
+            if (config.tool_call !== undefined)
+              model.capabilities.tools = config.tool_call;
+            if (config.modalities?.input !== undefined)
+              model.capabilities.input = [...config.modalities.input];
+            if (config.modalities?.output !== undefined)
+              model.capabilities.output = [...config.modalities.output];
+            model.headers = { ...model.headers, ...config.headers };
+            model.settings = { ...model.settings, ...exports_provider_options.model(withoutCredentials(config.options)) };
+            if (config.variants !== undefined) {
+              model.variants ??= [];
+              for (const [id, options] of Object.entries(config.variants)) {
+                const variantID = exports_model.VariantID.make(id);
+                let existing = model.variants.find((item3) => item3.id === variantID);
+                if (!existing) {
+                  existing = { id: variantID };
+                  model.variants.push(existing);
+                }
+                existing.headers = { ...existing.headers, ...options.headers };
+                existing.settings = {
+                  ...existing.settings,
+                  ...exports_provider_options.model(withoutCredentials(options))
+                };
+              }
+            }
+            if (config.release_date !== undefined) {
+              const released = Date.parse(config.release_date);
+              model.time.released = Number.isFinite(released) ? released : 0;
+            }
+            if (config.cost !== undefined) {
+              model.cost = remoteCost(config.cost);
+            }
+            model.status = config.status ?? "active";
+            model.enabled = config.status !== "deprecated";
+            if (config.limit !== undefined)
+              model.limit = { ...config.limit };
+          });
+        }
+      }
+      const item = catalog.provider.get(exports_provider.ID.opencode);
+      if (!item)
+        return;
+      const hasKey = Boolean(process.env.OPENCODE_API_KEY || connected || item.provider.settings?.apiKey);
+      catalog.provider.update(item.provider.id, (provider) => {
+        if (!hasKey) {
+          provider.activation = "enabled";
+          provider.settings = { ...provider.settings, apiKey: "public" };
+        }
+      });
+      if (hasKey)
+        return;
+      for (const model of item.models.values()) {
+        if (!model.cost.some((cost) => cost.input > 0))
+          continue;
+        catalog.model.update(item.provider.id, model.id, (draft) => {
+          draft.enabled = false;
+        });
+      }
+    });
+    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
+    yield* bus.subscribe(exports_integration.Event.ConnectionUpdated).pipe(Stream.filter((event) => event.data.integrationID === exports_integration.ID.make("opencode")), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+function fetchProviders(http, value) {
+  const metadata = value.metadata;
+  const server = typeof metadata?.server === "string" ? metadata.server : defaultServer;
+  const orgID = typeof metadata?.orgID === "string" ? metadata.orgID : undefined;
+  const token = value.type === "oauth" ? value.access : value.key;
+  return http.execute(HttpClientRequest.get(`${server}/api/config`).pipe(HttpClientRequest.acceptJson, HttpClientRequest.bearerToken(token), HttpClientRequest.setHeaders(orgID ? { "x-org-id": orgID } : {}))).pipe(Effect.flatMap((response) => {
+    if (response.status === 404)
+      return Effect.succeed(undefined);
+    return HttpClientResponse.filterStatusOk(response).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(RemoteResponse)), Effect.map((remote) => remote.config.provider));
+  }));
+}
+function withoutCredentials(body) {
+  return Object.fromEntries(Object.entries(body ?? {}).filter(([key]) => key !== "apiKey" && key !== "headers"));
+}
+function normalizeServer(input) {
+  return Effect.try({
+    try: () => {
+      if (typeof input !== "string")
+        throw new Error("expected string");
+      const url = new URL(input);
+      if (url.protocol !== "http:" && url.protocol !== "https:")
+        throw new Error("expected HTTP(S)");
+      return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+    },
+    catch: (cause) => new Error(`Invalid OpenCode server URL: ${cause instanceof Error ? cause.message : String(cause)}`)
+  });
+}
+function remoteCost(input) {
+  const base = {
+    input: Money.USDPerMillionTokens.make(input.input),
+    output: Money.USDPerMillionTokens.make(input.output),
+    cache: {
+      read: Money.USDPerMillionTokens.make(input.cache_read ?? 0),
+      write: Money.USDPerMillionTokens.make(input.cache_write ?? 0)
+    }
+  };
+  if (!input.context_over_200k)
+    return [base];
+  return [
+    base,
+    {
+      tier: { type: "context", size: 200000 },
+      input: Money.USDPerMillionTokens.make(input.context_over_200k.input),
+      output: Money.USDPerMillionTokens.make(input.context_over_200k.output),
+      cache: {
+        read: Money.USDPerMillionTokens.make(input.context_over_200k.cache_read ?? 0),
+        write: Money.USDPerMillionTokens.make(input.context_over_200k.cache_write ?? 0)
+      }
+    }
+  ];
+}
+function poll(http, server, deviceCode, interval) {
+  const loop = (wait) => Effect.gen(function* () {
+    yield* Effect.sleep(wait);
+    const result = yield* post(http, `${server}/auth/device/token`, {
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      device_code: deviceCode,
+      client_id: clientID
+    }, DeviceToken, false);
+    if ("access_token" in result)
+      return yield* credential(http, server, result);
+    if (result.error === "authorization_pending")
+      return yield* loop(wait);
+    if (result.error === "slow_down") {
+      return yield* loop(Duration.sum(wait, Duration.seconds(5)));
+    }
+    return yield* Effect.fail(new Error(`Device authorization failed: ${result.error}`));
+  });
+  return loop(interval);
+}
+function credential(http, server, token) {
+  return Effect.gen(function* () {
+    const [user, orgs] = yield* Effect.all([
+      get(http, `${server}/api/user`, token.access_token, User),
+      get(http, `${server}/api/orgs`, token.access_token, Schema.Array(Org))
+    ], { concurrency: 2 });
+    const org = orgs.toSorted((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id))[0];
+    return exports_credential.OAuth.make({
+      type: "oauth",
+      methodID,
+      access: token.access_token,
+      refresh: token.refresh_token,
+      expires: Date.now() + token.expires_in * 1000,
+      metadata: {
+        server,
+        accountID: user.id,
+        email: user.email,
+        orgID: org?.id,
+        orgName: org?.name
+      }
+    });
+  });
+}
+function get(http, url, token, schema) {
+  return HttpClient.filterStatusOk(http).execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.bearerToken(token))).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)));
+}
+function post(http, url, body, schema, statusOk = true) {
+  return HttpClientRequest.post(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.schemaBodyJson(Schema.Record(Schema.String, Schema.String))(body), Effect.flatMap((request) => http.execute(request)), Effect.flatMap((response) => statusOk ? HttpClientResponse.filterStatusOk(response) : Effect.succeed(response)), Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)));
+}
+
+export { OpencodePlugin };

package/dist/chunks/location-mutation-6x67034y.js

@@ -0,0 +1,220 @@
+import {
+  exports_llm
+} from "./location-mutation-c5ta3mhh.js";
+import {
+  exports_title
+} from "./location-mutation-781q1skv.js";
+import {
+  exports_compaction
+} from "./location-mutation-ydx7v2v0.js";
+import {
+  exports_generate_node
+} from "./location-mutation-hqew6wwe.js";
+import {
+  exports_supervisor
+} from "./location-mutation-hqdypqbx.js";
+import {
+  exports_read_filesystem
+} from "./location-mutation-7xwrfrqq.js";
+import {
+  exports_builtins
+} from "./location-mutation-rvf4ppxh.js";
+import {
+  exports_instructions as exports_instructions2
+} from "./location-mutation-f4n7jts7.js";
+import {
+  exports_instructions
+} from "./location-mutation-9xe9cxt1.js";
+import {
+  exports_instruction_entry
+} from "./location-mutation-r9xhgjkd.js";
+import {
+  exports_instructions as exports_instructions3
+} from "./location-mutation-530z90jy.js";
+import {
+  exports_mcp as exports_mcp2
+} from "./location-mutation-m5sbqbmy.js";
+import {
+  exports_location_watcher
+} from "./location-mutation-kv6vp4m3.js";
+import {
+  exports_formatter
+} from "./location-mutation-nhg32cj8.js";
+import {
+  exports_plugin
+} from "./location-mutation-trcj3z49.js";
+import {
+  exports_model_transport
+} from "./location-mutation-42q4drvy.js";
+import {
+  exports_model
+} from "./location-mutation-0mqwymb3.js";
+import {
+  exports_snapshot
+} from "./location-mutation-a6xxb9cb.js";
+import {
+  exports_skill
+} from "./location-mutation-js0qxxzx.js";
+import {
+  exports_tool
+} from "./location-mutation-yyhat9md.js";
+import {
+  exports_image
+} from "./location-mutation-ffvt207n.js";
+import {
+  exports_vcs
+} from "./location-mutation-ky3veh2c.js";
+import {
+  exports_reference
+} from "./location-mutation-rzy4xjjz.js";
+import {
+  exports_generate
+} from "./location-mutation-hqvsy57f.js";
+import {
+  exports_pty
+} from "./location-mutation-1kedsd2h.js";
+import {
+  exports_command
+} from "./location-mutation-apjvmrx3.js";
+import {
+  exports_mcp
+} from "./location-mutation-ztvvzzvv.js";
+import {
+  exports_worktree
+} from "./location-mutation-jgw081v5.js";
+import {
+  exports_model_resolver
+} from "./location-mutation-rkgk5nqx.js";
+import {
+  exports_aisdk
+} from "./location-mutation-wqhtb879.js";
+import {
+  exports_permission
+} from "./location-mutation-gjaba53s.js";
+import {
+  exports_instruction_discovery
+} from "./location-mutation-q9z9bptr.js";
+import {
+  exports_agent
+} from "./location-mutation-0ms0v4tv.js";
+import {
+  exports_location_service_map
+} from "./location-mutation-zdkg1k91.js";
+import {
+  exports_file_mutation
+} from "./location-mutation-61tdevqj.js";
+import {
+  exports_websearch
+} from "./location-mutation-9m1tawx7.js";
+import {
+  exports_location_mutation
+} from "./location-mutation-z17t3kn2.js";
+import {
+  exports_tool_output
+} from "./location-mutation-6d38mye6.js";
+import {
+  exports_shell
+} from "./location-mutation-087amx3w.js";
+import {
+  exports_config
+} from "./location-mutation-qvf5nvg0.js";
+import {
+  exports_catalog
+} from "./location-mutation-5gvndtda.js";
+import {
+  exports_integration
+} from "./location-mutation-67ww7a6n.js";
+import {
+  exports_form
+} from "./location-mutation-w6yb7hdq.js";
+import {
+  exports_filesystem,
+  exports_search
+} from "./location-mutation-mgwgz9qe.js";
+import {
+  exports_environment1 as exports_environment
+} from "./location-mutation-pysc8t9c.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  AbsolutePath
+} from "./location-mutation-j07kk359.js";
+
+// src/location-services.ts
+import { Effect, Layer, LayerMap } from "effect";
+import path from "path";
+import { LayerNode } from "@opencode-ai/util/effect/layer-node";
+import { Node } from "@opencode-ai/util/effect/app-node";
+var locationServiceNodes = [
+  exports_location.node,
+  exports_environment.node,
+  exports_config.node,
+  exports_agent.node,
+  exports_command.node,
+  exports_reference.node,
+  exports_websearch.node,
+  exports_integration.node,
+  exports_catalog.node,
+  exports_model_resolver.node,
+  exports_aisdk.node,
+  exports_plugin.node,
+  exports_supervisor.node,
+  exports_worktree.refreshNode,
+  exports_search.node,
+  exports_filesystem.node,
+  exports_pty.node,
+  exports_shell.node,
+  exports_skill.node,
+  exports_builtins.node,
+  exports_instruction_discovery.node,
+  exports_location_mutation.node,
+  exports_file_mutation.node,
+  exports_formatter.node,
+  exports_mcp.node,
+  exports_permission.node,
+  exports_tool.node,
+  exports_tool_output.node,
+  exports_image.node,
+  exports_instructions3.node,
+  exports_instructions2.node,
+  exports_instruction_entry.node,
+  exports_form.node,
+  exports_generate.node,
+  exports_generate_node.node,
+  exports_read_filesystem.node,
+  exports_mcp2.node,
+  exports_instructions.node,
+  exports_model.node,
+  exports_model_transport.node,
+  exports_compaction.node,
+  exports_title.node,
+  exports_snapshot.node,
+  exports_llm.node,
+  exports_vcs.node,
+  exports_location_watcher.node
+];
+var locationServices = LayerNode.group(locationServiceNodes);
+function buildLocationServiceMap(replacements = []) {
+  const canonical = (ref) => exports_location.Ref.make({
+    directory: AbsolutePath.make(process.platform === "win32" ? path.normalize(ref.directory) : ref.directory),
+    workspaceID: ref.workspaceID
+  });
+  return Layer.effect(exports_location_service_map.Service, Effect.map(LayerMap.make((ref) => {
+    const startedAt = performance.now();
+    const allReplacements = replacements.concat([[exports_location.node, exports_location.boundNode(ref)]]);
+    const location = LayerNode.hoist(locationServices, Node.tags.values.global, allReplacements);
+    return LayerNode.compile(location.node).pipe(Layer.fresh, Layer.tap(() => Effect.logInfo("location services booted", {
+      directory: ref.directory,
+      workspaceID: ref.workspaceID,
+      durationMs: Math.round(performance.now() - startedAt)
+    })), Layer.provide(LayerNode.compile(location.hoisted)));
+  }, { idleTimeToLive: "60 minutes" }), (inner) => ({
+    ...inner,
+    get: (ref) => inner.get(canonical(ref)),
+    contextEffect: (ref) => inner.contextEffect(canonical(ref)),
+    invalidate: (ref) => inner.invalidate(canonical(ref))
+  })));
+}
+
+export { locationServices, buildLocationServiceMap };

package/dist/chunks/location-mutation-6yt963b8.js

@@ -0,0 +1,29 @@
+// src/database/migration/20260410174513_workspace-name.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260410174513_workspace-name",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`PRAGMA foreign_keys=OFF;`);
+      yield* tx.run(`
+        CREATE TABLE \`__new_workspace\` (
+          \`id\` text PRIMARY KEY,
+          \`type\` text NOT NULL,
+          \`name\` text DEFAULT '' NOT NULL,
+          \`branch\` text,
+          \`directory\` text,
+          \`extra\` text,
+          \`project_id\` text NOT NULL,
+          CONSTRAINT \`fk_workspace_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`INSERT INTO \`__new_workspace\`(\`id\`, \`type\`, \`branch\`, \`name\`, \`directory\`, \`extra\`, \`project_id\`) SELECT \`id\`, \`type\`, \`branch\`, \`name\`, \`directory\`, \`extra\`, \`project_id\` FROM \`workspace\`;`);
+      yield* tx.run(`DROP TABLE \`workspace\`;`);
+      yield* tx.run(`ALTER TABLE \`__new_workspace\` RENAME TO \`workspace\`;`);
+      yield* tx.run(`PRAGMA foreign_keys=ON;`);
+    });
+  }
+};
+var _20260410174513_workspace_name_default = migration;
+
+export { _20260410174513_workspace_name_default };