@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-qnk5fbz4.js

@@ -0,0 +1,183 @@
+import {
+  exports_app
+} from "./permission-50jxp3hw.js";
+import {
+  exports_integration
+} from "./permission-zxzx89zt.js";
+import {
+  exports_credential
+} from "./permission-d5t1sv80.js";
+
+// src/plugin/provider/xai.ts
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Clock, Effect, Option, Schema } from "effect";
+var clientID = "b1a00492-073a-47ea-816f-4c329264a828";
+var issuer = "https://auth.x.ai/oauth2";
+var deviceGrant = "urn:ietf:params:oauth:grant-type:device_code";
+var scope = "openid profile email offline_access grok-cli:access api:access";
+var pollingSafetyMargin = 3000;
+var browserMethodID = exports_integration.MethodID.make("browser");
+var deviceMethodID = exports_integration.MethodID.make("device");
+var Token = Schema.Struct({
+  access_token: Schema.String,
+  refresh_token: Schema.optional(Schema.String),
+  expires_in: Schema.optional(Schema.Number)
+});
+var Device = Schema.Struct({
+  device_code: Schema.String,
+  user_code: Schema.String,
+  verification_uri: Schema.String,
+  verification_uri_complete: Schema.optional(Schema.String),
+  expires_in: Schema.optional(Schema.Number),
+  interval: Schema.optional(Schema.Number)
+});
+var DeviceError = Schema.Struct({
+  error: Schema.optional(Schema.String),
+  error_description: Schema.optional(Schema.String)
+});
+var decodeDeviceError = Schema.decodeUnknownOption(Schema.fromJsonString(DeviceError));
+var device = (app) => ({
+  integrationID: exports_integration.ID.make("xai"),
+  method: {
+    id: deviceMethodID,
+    type: "oauth",
+    label: "SuperGrok Subscription"
+  },
+  authorize: () => request(`${issuer}/device/code`, {
+    method: "POST",
+    headers: headers(app),
+    body: new URLSearchParams({ client_id: clientID, scope, referrer: "opencode" }).toString()
+  }, Device).pipe(Effect.flatMap((value) => Clock.currentTimeMillis.pipe(Effect.map((created) => {
+    const lifetime = positiveSeconds(value.expires_in, 0);
+    return {
+      mode: "auto",
+      url: value.verification_uri_complete ?? value.verification_uri,
+      instructions: `Open ${value.verification_uri} on any device and enter code: ${value.user_code}`,
+      ...lifetime ? { expiresAt: created + lifetime * 1000 } : {},
+      callback: poll(value, app).pipe(Effect.flatMap((tokens) => credential(deviceMethodID, tokens)))
+    };
+  })))),
+  refresh: (value) => refresh(deviceMethodID, exports_credential.OAuth.make({ ...value, methodID: deviceMethodID }), app)
+});
+var XAIPlugin = define({
+  id: "opencode.provider.xai",
+  effect: Effect.fn(function* (ctx) {
+    const credentials = yield* exports_credential.Service;
+    yield* Effect.forEach(yield* credentials.list(exports_integration.ID.make("xai")), (credential) => {
+      if (credential.value.type !== "oauth" || credential.value.methodID !== browserMethodID)
+        return Effect.void;
+      return credentials.update(credential.id, {
+        value: exports_credential.OAuth.make({ ...credential.value, methodID: deviceMethodID })
+      });
+    }, { discard: true });
+    yield* ctx.integration.transform((draft) => {
+      draft.update("xai", (integration) => {
+        integration.name = "xAI";
+      });
+      draft.method.update(device(ctx.app));
+      draft.method.update({ integrationID: "xai", method: { type: "key", label: "Manually enter API Key" } });
+    });
+  })
+});
+function refresh(methodID, value, app) {
+  return request(`${issuer}/token`, {
+    method: "POST",
+    headers: headers(app),
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: value.refresh,
+      client_id: clientID
+    }).toString()
+  }, Token).pipe(Effect.flatMap((tokens) => credential(methodID, tokens, value.refresh, value.metadata)));
+}
+function poll(device2, app) {
+  return Effect.gen(function* () {
+    const started = yield* Clock.currentTimeMillis;
+    const expires = started + positiveSeconds(device2.expires_in, 300) * 1000;
+    const loop = (interval) => Effect.gen(function* () {
+      if ((yield* Clock.currentTimeMillis) >= expires) {
+        return yield* Effect.fail(new Error("xAI device authorization timed out"));
+      }
+      const response = yield* send(`${issuer}/token`, {
+        method: "POST",
+        headers: headers(app),
+        body: new URLSearchParams({
+          grant_type: deviceGrant,
+          client_id: clientID,
+          device_code: device2.device_code
+        }).toString()
+      });
+      if (response.ok)
+        return yield* decode(response, Token);
+      const error = yield* Effect.promise(() => response.text()).pipe(Effect.map((body) => Option.getOrUndefined(decodeDeviceError(body))), Effect.catch(() => Effect.succeed(undefined)));
+      if (error?.error === "authorization_pending") {
+        return yield* Effect.sleep(interval + pollingSafetyMargin).pipe(Effect.andThen(loop(interval)));
+      }
+      if (error?.error === "slow_down") {
+        const next = interval + 5000;
+        return yield* Effect.sleep(next + pollingSafetyMargin).pipe(Effect.andThen(loop(next)));
+      }
+      if (error?.error === "access_denied" || error?.error === "authorization_denied") {
+        return yield* Effect.fail(new Error("xAI device authorization was denied"));
+      }
+      if (error?.error === "expired_token") {
+        return yield* Effect.fail(new Error("xAI device code expired - please re-run login"));
+      }
+      const detail = error?.error_description ?? error?.error;
+      return yield* Effect.fail(new Error(`xAI device token exchange failed (${response.status})${detail ? `: ${detail}` : ""}`));
+    });
+    return yield* loop(Math.max(positiveSeconds(device2.interval, 5) * 1000, 1000));
+  });
+}
+function request(url, init, schema) {
+  return send(url, init).pipe(Effect.flatMap((response) => {
+    if (response.ok)
+      return decode(response, schema);
+    return Effect.promise(() => response.text()).pipe(Effect.flatMap((detail) => Effect.fail(new Error(`xAI request failed (${response.status})${detail ? `: ${detail}` : ""}`))));
+  }));
+}
+function send(url, init) {
+  return Effect.tryPromise({
+    try: (signal) => fetch(url, { ...init, signal }),
+    catch: (cause) => cause
+  });
+}
+function decode(response, schema) {
+  return Effect.promise(() => response.json()).pipe(Effect.map(Schema.decodeUnknownSync(schema)));
+}
+function credential(methodID, tokens, currentRefresh, metadata) {
+  const refresh2 = tokens.refresh_token ?? currentRefresh;
+  if (!refresh2)
+    return Effect.fail(new Error("xAI token response is missing refresh_token"));
+  return Effect.succeed(exports_credential.OAuth.make({
+    type: "oauth",
+    methodID,
+    refresh: refresh2,
+    access: tokens.access_token,
+    expires: tokenExpiration(tokens),
+    metadata
+  }));
+}
+function tokenExpiration(tokens) {
+  if (tokens.expires_in)
+    return Date.now() + positiveSeconds(tokens.expires_in, 3600) * 1000;
+  const payload = tokens.access_token.split(".")[1];
+  if (!payload)
+    return Date.now() + 3600 * 1000;
+  const claims = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Struct({ exp: Schema.optional(Schema.Number) })))(Buffer.from(payload, "base64url").toString());
+  const expiration = Option.getOrUndefined(claims)?.exp;
+  return expiration ? expiration * 1000 : Date.now() + 3600 * 1000;
+}
+function headers(app) {
+  return {
+    "Content-Type": "application/x-www-form-urlencoded",
+    Accept: "application/json",
+    "User-Agent": exports_app.useragent(app)
+  };
+}
+function positiveSeconds(value, fallback) {
+  const seconds = Number(value);
+  return Number.isFinite(seconds) && seconds > 0 ? seconds : fallback;
+}
+
+export { XAIPlugin };

package/dist/chunks/permission-qp95y4jb.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260605042240_add_context_epoch_agent.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260605042240_add_context_epoch_agent",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session_context_epoch\` ADD \`agent\` text DEFAULT 'build' NOT NULL;`);
+    });
+  }
+};
+var _20260605042240_add_context_epoch_agent_default = migration;
+
+export { _20260605042240_add_context_epoch_agent_default };

package/dist/chunks/permission-qyfd1tbv.js

@@ -0,0 +1,295 @@
+import {
+  exports_integration
+} from "./permission-zxzx89zt.js";
+import {
+  exports_provider_options
+} from "./permission-y0x38cee.js";
+import {
+  exports_config
+} from "./permission-47rh966y.js";
+import {
+  exports_credential
+} from "./permission-d5t1sv80.js";
+import {
+  exports_model
+} from "./permission-xfd1xnk3.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  exports_provider
+} from "./permission-d6vvk673.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://console.opencode.ai";
+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.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/permission-r3k9abhd.js

@@ -0,0 +1,34 @@
+import {
+  PositiveInt
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/v1/config/attachment.ts
+var exports_attachment = {};
+__export(exports_attachment, {
+  Info: () => Info,
+  Image: () => Image,
+  ConfigAttachmentV1: () => exports_attachment
+});
+import { Schema } from "effect";
+var Image = Schema.Struct({
+  auto_resize: Schema.optional(Schema.Boolean).annotate({
+    description: "Resize images before sending them to the model when they exceed configured limits (default: true)"
+  }),
+  max_width: Schema.optional(PositiveInt).annotate({
+    description: "Maximum image width before resizing or rejecting the attachment (default: 2000)"
+  }),
+  max_height: Schema.optional(PositiveInt).annotate({
+    description: "Maximum image height before resizing or rejecting the attachment (default: 2000)"
+  }),
+  max_base64_bytes: Schema.optional(PositiveInt).annotate({
+    description: "Maximum base64 payload bytes for an image attachment (default: 5242880)"
+  })
+}).annotate({ identifier: "ImageAttachmentConfig" });
+var Info = Schema.Struct({
+  image: Schema.optional(Image).annotate({ description: "Image attachment configuration" })
+}).annotate({ identifier: "AttachmentConfig" });
+
+export { Image, Info, exports_attachment };