@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-m9w0rfyh.js

@@ -0,0 +1,123 @@
+import {
+  getTableColumnsRuntime2,
+  getViewSelectedFieldsRuntime2,
+  orderSelectedFields2,
+  mapUpdateSet2,
+  getTableLikeName2
+} from "./repository-emrn6kk6.js";
+
+// src/database/drizzle/sqlite-core/effect/update.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind, is } from "drizzle-orm/entity";
+import { SelectionProxyHandler } from "drizzle-orm/selection-proxy";
+import { SQLiteTable } from "drizzle-orm/sqlite-core/table";
+import { extractUsedTable } from "drizzle-orm/sqlite-core/utils";
+import { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base";
+import { Subquery } from "drizzle-orm/subquery";
+class SQLiteEffectUpdateBuilder2 {
+  table;
+  session;
+  dialect;
+  withList;
+  static [entityKind] = "SQLiteEffectUpdateBuilder";
+  constructor(table, session, dialect, withList) {
+    this.table = table;
+    this.session = session;
+    this.dialect = dialect;
+    this.withList = withList;
+  }
+  set(values) {
+    return new SQLiteEffectUpdateBase2(this.table, mapUpdateSet2(this.table, values), this.session, this.dialect, this.withList);
+  }
+}
+
+class SQLiteEffectUpdateBase2 {
+  effectSession;
+  effectDialect;
+  static [entityKind] = "SQLiteEffectUpdate";
+  config;
+  constructor(table, set, effectSession, effectDialect, withList) {
+    this.effectSession = effectSession;
+    this.effectDialect = effectDialect;
+    this.config = { set, table, withList, joins: [] };
+  }
+  from(source) {
+    this.config.from = source;
+    return this;
+  }
+  createJoin(joinType) {
+    return (table, on) => {
+      const tableName = getTableLikeName2(table);
+      if (typeof tableName === "string" && this.config.joins.some((join) => join.alias === tableName)) {
+        throw new Error(`Alias "${tableName}" is already used in this query`);
+      }
+      if (typeof on === "function") {
+        const from = this.config.from ? is(table, SQLiteTable) ? getTableColumnsRuntime2(table) : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? getViewSelectedFieldsRuntime2(table).selectedFields : undefined : undefined;
+        on = on(new Proxy(getTableColumnsRuntime2(this.config.table), new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })), from && new Proxy(from, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })));
+      }
+      this.config.joins.push({ on, table, joinType, alias: tableName });
+      return this;
+    };
+  }
+  leftJoin = this.createJoin("left");
+  rightJoin = this.createJoin("right");
+  innerJoin = this.createJoin("inner");
+  fullJoin = this.createJoin("full");
+  where(where) {
+    this.config.where = where;
+    return this;
+  }
+  orderBy(...columns) {
+    if (typeof columns[0] === "function") {
+      const orderBy = columns[0](new Proxy(getTableColumnsRuntime2(this.config.table), new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })));
+      this.config.orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
+      return this;
+    }
+    this.config.orderBy = columns;
+    return this;
+  }
+  limit(limit) {
+    this.config.limit = limit;
+    return this;
+  }
+  returning(fields = getTableColumnsRuntime2(this.config.table)) {
+    this.config.returning = orderSelectedFields2(fields);
+    return this;
+  }
+  getSQL() {
+    return this.effectDialect.buildUpdateQuery(this.config);
+  }
+  toSQL() {
+    return this.effectDialect.sqlToQuery(this.getSQL());
+  }
+  _prepare(isOneTimeQuery = true) {
+    return this.effectSession[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.effectDialect.sqlToQuery(this.getSQL()), this.config.returning, this.config.returning ? "all" : "run", undefined, {
+      type: "update",
+      tables: extractUsedTable(this.config.table)
+    });
+  }
+  prepare() {
+    return this._prepare(false);
+  }
+  run = (placeholderValues) => {
+    return this._prepare().run(placeholderValues);
+  };
+  all = (placeholderValues) => {
+    return this._prepare().all(placeholderValues);
+  };
+  get = (placeholderValues) => {
+    return this._prepare().get(placeholderValues);
+  };
+  values = (placeholderValues) => {
+    return this._prepare().values(placeholderValues);
+  };
+  execute = (placeholderValues) => {
+    return this._prepare().execute(placeholderValues);
+  };
+  $dynamic() {
+    return this;
+  }
+}
+applyEffectWrapper(SQLiteEffectUpdateBase2);
+
+export { SQLiteEffectUpdateBuilder2, SQLiteEffectUpdateBase2 };

package/dist/chunks/repository-me4pxbk2.js

@@ -0,0 +1,156 @@
+import {
+  Service79,
+  node84
+} from "./repository-8m31s27t.js";
+import {
+  latestSequence2,
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  llmClient2
+} from "./repository-5t3nmthw.js";
+import {
+  SessionEvent2
+} from "./repository-ec1grn59.js";
+import {
+  firstUserMessage2
+} from "./repository-j8g7a3j8.js";
+import {
+  Service60,
+  node64
+} from "./repository-1n274c67.js";
+import {
+  Service28,
+  node33
+} from "./repository-h1rn3ct5.js";
+import {
+  record2,
+  add2
+} from "./repository-tdstcens.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/title.ts
+var exports_title = {};
+__export(exports_title, {
+  Service: () => Service8,
+  SessionTitle: () => exports_title,
+  isUntitled: () => isUntitled2,
+  layer: () => layer6,
+  node: () => node11
+});
+import { isDeepStrictEqual } from "node:util";
+import { LLMClient, LLMEvent, Message, SystemPart } from "@opencode/ai";
+import { Context, DateTime, Effect, Layer, Stream } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { isExactRootFallback } from "@opencode/util/session-title-fallback";
+var MAX_LENGTH = 100;
+var MAX_CONTEXT_LENGTH = 8000;
+var MAX_FIRST_MESSAGE_LENGTH = 2000;
+var titleChanged = Symbol("Session title changed");
+
+class Service8 extends Context.Service()("@opencode/SessionTitle") {
+}
+var truncate = (value) => value.length <= MAX_LENGTH ? value : `${value.slice(0, MAX_LENGTH - 3)}...`;
+var isUntitled2 = (session) => isExactRootFallback({
+  title: session.title,
+  time: { created: DateTime.toEpochMillis(session.time.created) }
+});
+var layer6 = Layer.effect(Service8, Effect.gen(function* () {
+  const bus = yield* Service78;
+  const llm = yield* LLMClient.Service;
+  const context = yield* Service28;
+  const store = yield* Service60;
+  const db = (yield* Service79).db;
+  const attempt = Effect.fn("SessionTitle.attempt")(function* (input) {
+    const chunks = [];
+    let failed = false;
+    let usage;
+    const recordUsage = Effect.suspend(() => usage ? bus.publish(SessionEvent2.UsageRecorded, {
+      sessionID: input.session.id,
+      source: "title",
+      ...usage
+    }) : Effect.void);
+    const prepared = yield* context.request.title({
+      session: input.session,
+      agent: input.agent.id,
+      model: input.model,
+      system: input.agent.system ? [SystemPart.make(input.agent.system)] : [],
+      messages: [Message.user(input.text)]
+    });
+    if (prepared.event.result !== undefined)
+      return prepared.event.result;
+    yield* llm.stream(prepared.request, prepared.options).pipe(Stream.runForEach((event) => {
+      if (LLMEvent.is.providerError(event))
+        failed = true;
+      if (LLMEvent.is.textDelta(event))
+        chunks.push(event.text);
+      if (LLMEvent.is.stepFinish(event)) {
+        const step = record2(event.usage, input.model.cost);
+        usage = usage ? add2(usage, step) : step;
+      }
+      return Effect.void;
+    }), Effect.catchTag("AI.Error", () => Effect.sync(() => {
+      failed = true;
+    })), Effect.onInterrupt(() => recordUsage.pipe(Effect.asVoid)));
+    yield* recordUsage;
+    if (failed)
+      return;
+    return chunks.join("").split(`
+`).map((line) => line.trim()).find((line) => line.length > 0);
+  });
+  const generate = Effect.fn("SessionTitle.generate")(function* (sessionID) {
+    const session = yield* store.get(sessionID);
+    if (!session)
+      return;
+    const firstUser = yield* firstUserMessage2(db, session.id);
+    if (!firstUser)
+      return;
+    const text = !isUntitled2(session) ? yield* store.context(session.id).pipe(Effect.map((messages) => {
+      const original = `Original request:
+${firstUser.text.slice(0, MAX_FIRST_MESSAGE_LENGTH)}`;
+      const recent = messages.flatMap((message) => {
+        if (message.type === "user" && message.id !== firstUser.id)
+          return [`User: ${message.text.trim()}`];
+        if (message.type !== "assistant")
+          return [];
+        const text = message.content.flatMap((part) => part.type === "text" ? [part.text.trim()] : []).filter(Boolean).join(`
+`);
+        return text ? [`Assistant: ${text}`] : [];
+      }).join(`
+
+`);
+      if (!recent)
+        return original;
+      const prefix = `${original}
+
+Recent conversation:
+`;
+      return `${prefix}${recent.slice(-(MAX_CONTEXT_LENGTH - prefix.length))}`;
+    }), Effect.orElseSucceed(() => firstUser.text)) : firstUser.text;
+    const selection = yield* context.selectTitle(session);
+    if (!selection)
+      return;
+    const title = (yield* attempt({ session, agent: selection.agent, text, model: selection.selected })) ?? (selection.primary && !isDeepStrictEqual(selection.selected.ref, selection.primary.ref) ? yield* attempt({ session, agent: selection.agent, text, model: selection.primary }) : undefined);
+    if (!title)
+      return;
+    const expectedSequence = (yield* latestSequence2(db, sessionID)) + 1;
+    const current = yield* store.get(sessionID);
+    if (!current || current.title !== session.title || current.title === truncate(title))
+      return;
+    yield* bus.publish(SessionEvent2.Renamed, {
+      sessionID: session.id,
+      title: truncate(title)
+    }, { commit: (sequence) => sequence === expectedSequence ? Effect.void : Effect.die(titleChanged) }).pipe(Effect.catchDefect((defect) => defect === titleChanged ? Effect.void : Effect.die(defect)));
+  });
+  return Service8.of({ generate });
+}));
+var node11 = makeLocationNode({
+  service: Service8,
+  layer: layer6,
+  deps: [node83, llmClient2, node33, node64, node84]
+});
+
+export { Service8, isUntitled2, layer6, node11, exports_title };

package/dist/chunks/repository-mgx963cj.js

@@ -0,0 +1,61 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/plugin/hooks.ts
+var exports_hooks = {};
+__export(exports_hooks, {
+  PluginHooks: () => exports_hooks,
+  Service: () => Service62,
+  node: () => node66
+});
+import { Context, Effect, Layer, Scope } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+var eventProviderID = (event) => {
+  if (typeof event !== "object" || event === null || !("model" in event))
+    return;
+  const model = event.model;
+  if (typeof model !== "object" || model === null || !("providerID" in model))
+    return;
+  return typeof model.providerID === "string" ? model.providerID : undefined;
+};
+
+class Service62 extends Context.Service()("@opencode/PluginHooks") {
+}
+var layer = Layer.effect(Service62, Effect.gen(function* () {
+  const callbacks = new Map;
+  const key = (domain, name) => `${domain}.${String(name)}`;
+  const register = Effect.fn("PluginHooks.register")(function* (domain, name, callback, options) {
+    const scope = yield* Scope.Scope;
+    const id = key(domain, name);
+    let active = true;
+    const entry = { callback, options };
+    callbacks.set(id, [...callbacks.get(id) ?? [], entry]);
+    const dispose = Effect.sync(() => {
+      if (!active)
+        return;
+      active = false;
+      const next = (callbacks.get(id) ?? []).filter((item) => item !== entry);
+      if (next.length === 0)
+        callbacks.delete(id);
+      else
+        callbacks.set(id, next);
+    });
+    yield* Scope.addFinalizer(scope, dispose);
+    return { dispose };
+  });
+  const trigger = Effect.fnUntraced(function* (domain, name, event) {
+    for (const entry of callbacks.get(key(domain, name)) ?? []) {
+      if (entry.options?.providerID !== undefined && entry.options.providerID !== eventProviderID(event))
+        continue;
+      const result = Reflect.apply(entry.callback, undefined, [event]);
+      yield* result;
+    }
+    return event;
+  });
+  const has = (domain, name, providerID) => Effect.sync(() => (callbacks.get(key(domain, name)) ?? []).some((entry) => entry.options?.providerID === undefined || entry.options.providerID === providerID));
+  return Service62.of({ has, register, trigger });
+}));
+var node66 = makeLocationNode({ service: Service62, layer, deps: [] });
+
+export { Service62, node66, exports_hooks };

package/dist/chunks/repository-mhbk2b8a.js

@@ -0,0 +1,176 @@
+import {
+  useragent2
+} from "./repository-j4z2qnee.js";
+import {
+  Service78
+} from "./repository-x6rcf4cj.js";
+import {
+  OAuth3,
+  Event19
+} from "./repository-sztg2hv4.js";
+import {
+  ID13,
+  MethodID2
+} from "./repository-0zkv00cg.js";
+import {
+  ID16
+} from "./repository-pye8sh6e.js";
+import {
+  Family2
+} from "./repository-nxamnhdf.js";
+import {
+  bootstrap2
+} from "./repository-pjvnvgmy.js";
+
+// src/plugin/provider/digitalocean.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Clock, Deferred, Effect, Option, Schedule, Schema, Semaphore, Stream } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+var providerID = ID16.make("digitalocean");
+var integrationID = ID13.make("digitalocean");
+var methodID = MethodID2.make("browser");
+var clientID = "b1a6c5158156caac821fd1b30253ca8acb52454a48fa744420e41889cb589f82";
+var authorizeEndpoint = "https://cloud.digitalocean.com/v1/oauth/authorize";
+var routersEndpoint = "https://api.digitalocean.com/v2/gen-ai/models/routers";
+var callbackPort = 1456;
+var callbackPath = "/auth/callback";
+var tokenPath = "/auth/token";
+var RoutersResponse = Schema.Struct({
+  model_routers: Schema.Array(Schema.Struct({ name: Schema.NonEmptyString }))
+});
+var decodeCallback = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Struct({
+  access_token: Schema.optional(Schema.String),
+  expires_in: Schema.optional(Schema.String),
+  state: Schema.optional(Schema.String),
+  error: Schema.optional(Schema.String),
+  error_description: Schema.optional(Schema.String)
+})));
+var oauth = {
+  integrationID,
+  method: {
+    id: methodID,
+    type: "oauth",
+    label: "Login with DigitalOcean"
+  },
+  authorize: () => Effect.gen(function* () {
+    const state = Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString("base64url");
+    const token = yield* Deferred.make();
+    const { createServer } = yield* Effect.promise(() => import("node:http"));
+    const server = createServer((request, response) => {
+      const url = new URL(request.url ?? "/", "http://localhost");
+      if (request.method === "GET" && url.pathname === callbackPath) {
+        response.writeHead(200, { "Content-Type": "text/html" }).end(bootstrap2({ tokenPath, provider: "DigitalOcean" }));
+        return;
+      }
+      if (request.method === "POST" && url.pathname === tokenPath) {
+        const chunks = [];
+        request.on("data", (chunk) => chunks.push(chunk));
+        request.on("end", () => {
+          const body = Option.getOrUndefined(decodeCallback(Buffer.concat(chunks).toString("utf8")));
+          const error = body?.error_description || body?.error;
+          const access = body?.access_token;
+          if (error || !access || body?.state !== state) {
+            const message = error || (access ? "Invalid OAuth state" : "Missing access token");
+            Effect.runFork(Deferred.fail(token, new Error(message)));
+            response.writeHead(400, { "Content-Type": "application/json" }).end(JSON.stringify({ error: message }));
+            return;
+          }
+          const expires = Number.parseInt(body.expires_in ?? "0", 10);
+          Effect.runFork(Deferred.succeed(token, {
+            access,
+            expiresIn: Number.isFinite(expires) && expires > 0 ? expires : 60 * 60 * 24 * 30
+          }));
+          response.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({ ok: true }));
+        });
+        return;
+      }
+      response.writeHead(404).end("Not found");
+    });
+    const port = yield* listen(server);
+    yield* Effect.addFinalizer(() => Effect.sync(() => server.close()));
+    const redirect = `http://localhost:${port}${callbackPath}`;
+    return {
+      mode: "auto",
+      url: `${authorizeEndpoint}?${new URLSearchParams({
+        response_type: "token",
+        client_id: clientID,
+        redirect_uri: redirect,
+        scope: "genai:read inference:query",
+        state
+      })}`,
+      instructions: "Complete authorization in your browser. This window will close automatically.",
+      callback: Effect.gen(function* () {
+        const payload = yield* Deferred.await(token);
+        return OAuth3.make({
+          type: "oauth",
+          methodID,
+          access: payload.access,
+          refresh: "",
+          expires: (yield* Clock.currentTimeMillis) + payload.expiresIn * 1000
+        });
+      })
+    };
+  })
+};
+var DigitalOceanPlugin2 = define({
+  id: "opencode.provider.digitalocean",
+  effect: Effect.fn(function* (ctx) {
+    const bus = yield* Service78;
+    const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+    const loading = Semaphore.makeUnsafe(1);
+    const loaded = { routers: [] };
+    const load = Effect.fn("DigitalOceanPlugin.load")(function* () {
+      const connection = yield* ctx.integration.connection.active(integrationID);
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
+        return;
+      })) : undefined;
+      if (credential?.type !== "oauth" || credential.methodID !== methodID) {
+        loaded.access = undefined;
+        loaded.routers = [];
+        return;
+      }
+      if (loaded.access !== credential.access) {
+        loaded.access = credential.access;
+        loaded.routers = [];
+      }
+      if (credential.expires !== 0 && credential.expires <= (yield* Clock.currentTimeMillis))
+        return;
+      const result = yield* http.execute(HttpClientRequest.get(routersEndpoint).pipe(HttpClientRequest.bearerToken(credential.access), HttpClientRequest.acceptJson, HttpClientRequest.setHeader("User-Agent", useragent2(ctx.app)))).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(RoutersResponse)), Effect.timeout("10 seconds"), Effect.catch((cause) => Effect.logWarning("failed to sync DigitalOcean routers", { cause }).pipe(Effect.as(undefined))));
+      if (result)
+        loaded.routers = result.model_routers;
+    });
+    yield* ctx.integration.transform((draft) => {
+      draft.method.update(oauth);
+    });
+    yield* ctx.catalog.transform((evt) => {
+      if (!evt.provider.get(providerID))
+        return;
+      for (const router of loaded.routers) {
+        const id = `router:${router.name}`;
+        if (evt.model.get(providerID, id))
+          continue;
+        evt.model.update(providerID, id, (draft) => {
+          draft.name = router.name;
+          draft.family = Family2.make("digitalocean-inference-routers");
+          draft.capabilities = { tools: true, input: ["text"], output: ["text"] };
+          draft.limit = { context: 128000, output: 8192 };
+        });
+      }
+    });
+    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
+    yield* bus.subscribe(Event19.Switched).pipe(Stream.filter((event) => event.data.integrationID === integrationID), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
+    yield* refresh().pipe(Effect.repeat(Schedule.spaced("5 minutes")), Effect.forkScoped);
+  })
+});
+function listen(server) {
+  return Effect.callback((resume) => {
+    const onError = (error) => resume(Effect.fail(error));
+    server.once("error", onError);
+    server.listen(callbackPort, "localhost", () => {
+      server.off("error", onError);
+      resume(Effect.succeed(callbackPort));
+    });
+  }).pipe(Effect.mapError((cause) => ("code" in cause) && cause.code === "EADDRINUSE" ? new Error(`DigitalOcean login needs local port ${callbackPort}, but it is already in use. Stop the process using that port and try again.`) : cause));
+}
+
+export { DigitalOceanPlugin2 };

package/dist/chunks/repository-mp448xyj.js

@@ -0,0 +1,23 @@
+// src/database/migration/20260605003541_add_session_context_snapshot.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260605003541_add_session_context_snapshot",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_context_epoch\` (
+          \`session_id\` text PRIMARY KEY,
+          \`baseline\` text NOT NULL,
+          \`snapshot\` text NOT NULL,
+          \`baseline_seq\` integer NOT NULL,
+          \`replacement_seq\` integer,
+          \`revision\` integer DEFAULT 0 NOT NULL,
+          CONSTRAINT \`fk_session_context_epoch_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+    });
+  }
+};
+var _20260605003541_add_session_context_snapshot_default = migration;
+
+export { _20260605003541_add_session_context_snapshot_default };