@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-11nvngjf.js

@@ -0,0 +1,544 @@
+import {
+  Service80,
+  node85
+} from "./aisdk-native-vfccn5yp.js";
+import {
+  EventSequenceTable2,
+  EventTable2
+} from "./aisdk-native-2710q6r3.js";
+import {
+  makeUnsafe2
+} from "./aisdk-native-y71avatq.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/bus.ts
+var exports_bus = {};
+__export(exports_bus, {
+  Bus: () => exports_bus,
+  InvalidDurableEventError: () => InvalidDurableEventError2,
+  Service: () => Service79,
+  configured: () => configured12,
+  durable: () => durable2,
+  ephemeral: () => ephemeral2,
+  isSynced: () => isSynced2,
+  latestSequence: () => latestSequence2,
+  node: () => node84,
+  reserveSequence: () => reserveSequence2,
+  versionedType: () => versionedType2
+});
+import { Cause, Clock, Context, Effect, Layer, Option, PubSub, Schema, Stream } from "effect";
+import { Event } from "@opencode/schema/event";
+import { and, asc, eq, gt, lte, sql } from "drizzle-orm";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { isDeepStrictEqual } from "node:util";
+import { Durable } from "@opencode/schema/durable-event-manifest";
+import { SessionEvent } from "@opencode/schema/session-event";
+import { AbsolutePath } from "@opencode/schema/schema";
+var latestSequence2 = Effect.fn("Bus.latestSequence")(function* (db, aggregateID) {
+  const row = yield* db.select({ seq: EventSequenceTable2.seq }).from(EventSequenceTable2).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
+  return row?.seq ?? -1;
+});
+var reserveSequence2 = Effect.fn("Bus.reserveSequence")(function* (db, aggregateID, seq) {
+  yield* db.insert(EventSequenceTable2).values([{ aggregate_id: aggregateID, seq }]).onConflictDoUpdate({
+    target: EventSequenceTable2.aggregate_id,
+    set: { seq: sql`max(${EventSequenceTable2.seq}, ${seq})` }
+  }).run().pipe(Effect.orDie);
+});
+
+class InvalidDurableEventError2 extends Schema.TaggedError()("Bus.InvalidDurableEvent", {
+  type: Schema.String,
+  message: Schema.String
+}) {
+}
+var envelope = (aggregateID, seq, version) => ({
+  aggregateID,
+  seq: Event.Seq.make(seq),
+  version: Event.Version.make(version)
+});
+var decodeSerializedEvent = (event) => {
+  const definition = Durable.get(event.type);
+  if (!definition?.durable) {
+    throw new InvalidDurableEventError2({ type: event.type, message: `Unknown durable event type ${event.type}` });
+  }
+  return {
+    id: event.id,
+    created: event.created ?? 0,
+    type: definition.type,
+    durable: envelope(event.aggregateID, event.seq, definition.durable.version),
+    data: Schema.decodeUnknownSync(definition.data)(event.data)
+  };
+};
+var versionedType2 = Event.versionedType;
+var durable2 = Event.durable;
+var ephemeral2 = Event.ephemeral;
+var isSynced2 = (item) => item.type === "log.synced";
+var isDefinition = (input) => !Array.isArray(input);
+
+class Service79 extends Context.Service()("@opencode/Bus") {
+}
+function configured12(options) {
+  return makeGlobalNode({
+    service: Service79,
+    deps: [node85],
+    layer: Layer.effect(Service79, Effect.gen(function* () {
+      const { Location } = yield* Effect.promise(() => import("../location.js"));
+      const { SessionTable } = yield* Effect.promise(() => import("../session/sql.js"));
+      const pubsub = {
+        live: yield* PubSub.unbounded(),
+        durable: new Map,
+        typed: new Map
+      };
+      const projectors = new Map;
+      const listeners = new Array;
+      const durableLocks = makeUnsafe2();
+      const { db } = yield* Service80;
+      const logReadPageSize = options?.logReadPageSize ?? 512;
+      const persist = options?.persist ?? false;
+      const sessions = new Map;
+      const routes = new WeakMap;
+      const isSessionEvent = (event) => Object.hasOwn(SessionEvent.All.cases, event.type);
+      const prepareRoutes = Effect.fnUntraced(function* (events) {
+        const updates = new Map;
+        const resolved = new Map;
+        for (const event of events) {
+          if (!isSessionEvent(event))
+            continue;
+          const id = event.data.sessionID;
+          if (event.type === "session.created") {
+            updates.set(id, event.data.location);
+            resolved.set(event, [event.location ?? event.data.location]);
+            continue;
+          }
+          if (event.location && event.type !== "session.forked" && event.type !== "session.moved") {
+            if (event.type === "session.deleted")
+              updates.set(id, undefined);
+            continue;
+          }
+          const owner = event.type === "session.forked" ? event.data.parentID : id;
+          let ref = updates.has(owner) ? updates.get(owner) : sessions.get(owner);
+          if (!ref && !updates.has(owner)) {
+            const row = yield* db.select({ directory: SessionTable.directory, workspaceID: SessionTable.workspace_id }).from(SessionTable).where(eq(SessionTable.id, owner)).get().pipe(Effect.orDie);
+            ref = row ? { directory: AbsolutePath.make(row.directory), workspaceID: row.workspaceID ?? undefined } : undefined;
+            updates.set(owner, ref);
+          }
+          if (event.type === "session.moved") {
+            updates.set(id, event.data.location);
+            resolved.set(event, ref ? [ref, event.data.location] : [event.data.location]);
+            continue;
+          }
+          if (event.type === "session.forked")
+            updates.set(id, ref);
+          resolved.set(event, event.location ? [event.location] : ref ? [ref] : []);
+          if (event.type === "session.deleted")
+            updates.set(id, undefined);
+        }
+        return () => {
+          for (const [id, ref] of updates) {
+            if (ref)
+              sessions.set(id, ref);
+            else
+              sessions.delete(id);
+          }
+          for (const [event, ref] of resolved)
+            routes.set(event, ref);
+        };
+      });
+      const getOrCreate = (definition) => Effect.gen(function* () {
+        const existing = pubsub.typed.get(definition.type);
+        if (existing)
+          return existing;
+        const created = yield* PubSub.unbounded();
+        pubsub.typed.set(definition.type, created);
+        return created;
+      });
+      yield* Effect.addFinalizer(() => Effect.gen(function* () {
+        yield* PubSub.shutdown(pubsub.live);
+        yield* Effect.forEach(pubsub.durable.values(), (pubsubs) => Effect.forEach(pubsubs, PubSub.shutdown, { discard: true }), { discard: true });
+        yield* Effect.forEach(pubsub.typed.values(), PubSub.shutdown, { discard: true });
+      }));
+      function commitDurableEvent(definition, event, input, commit) {
+        return Effect.gen(function* () {
+          const durable = definition.durable;
+          if (!durable)
+            return yield* Effect.void;
+          const aggregateID = event.data[durable.aggregate];
+          if (typeof aggregateID !== "string")
+            return yield* Effect.die(new InvalidDurableEventError2({
+              type: event.type,
+              message: `Expected string aggregate field ${durable.aggregate}`
+            }));
+          if (input && input.aggregateID !== aggregateID) {
+            yield* Effect.die(new InvalidDurableEventError2({
+              type: event.type,
+              message: `Aggregate mismatch: expected ${input.aggregateID}, got ${aggregateID}`
+            }));
+          }
+          const list = projectors.get(versionedType2(definition.type, durable.version)) ?? [];
+          return yield* Effect.uninterruptible(Effect.gen(function* () {
+            const committed = yield* db.transaction(() => Effect.gen(function* () {
+              const row = yield* db.select({ seq: EventSequenceTable2.seq, ownerID: EventSequenceTable2.owner_id }).from(EventSequenceTable2).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
+              const latest = row?.seq ?? -1;
+              const encoded = Schema.encodeUnknownSync(definition.data)(event.data);
+              if (input?.strictOwner && row?.ownerID && row.ownerID !== input.ownerID) {
+                yield* Effect.die(new InvalidDurableEventError2({
+                  type: event.type,
+                  message: `Replay owner mismatch for aggregate ${aggregateID}: expected ${row.ownerID}, got ${input.ownerID ?? "none"}`
+                }));
+              }
+              if (input && input.seq <= latest) {
+                if (!persist)
+                  return;
+                const stored = yield* db.select().from(EventTable2).where(and(eq(EventTable2.aggregate_id, aggregateID), eq(EventTable2.seq, input.seq))).get().pipe(Effect.orDie);
+                if (stored?.id === event.id && stored.type === versionedType2(definition.type, durable.version) && stored.created === (event.created ?? 0) && isDeepStrictEqual(stored.data, encoded)) {
+                  if (input.ownerID && row?.ownerID == null) {
+                    yield* db.update(EventSequenceTable2).set({ owner_id: input.ownerID }).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).run().pipe(Effect.orDie);
+                  }
+                  return;
+                }
+                yield* Effect.die(new InvalidDurableEventError2({
+                  type: event.type,
+                  message: `Replay diverged at aggregate ${aggregateID} sequence ${input.seq}`
+                }));
+              }
+              if (input && row?.ownerID && row.ownerID !== input.ownerID) {
+                return;
+              }
+              const seq = input?.seq ?? latest + 1;
+              if (input && seq !== latest + 1) {
+                yield* Effect.die(new InvalidDurableEventError2({
+                  type: event.type,
+                  message: `Sequence mismatch for aggregate ${aggregateID}: expected ${latest + 1}, got ${seq}`
+                }));
+              }
+              if (persist) {
+                const stored = yield* db.select({ aggregateID: EventTable2.aggregate_id, seq: EventTable2.seq }).from(EventTable2).where(eq(EventTable2.id, event.id)).get().pipe(Effect.orDie);
+                if (stored)
+                  yield* Effect.die(new InvalidDurableEventError2({
+                    type: event.type,
+                    message: `Event ${event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`
+                  }));
+              }
+              const committed = {
+                ...event,
+                durable: { aggregateID, seq, version: durable.version }
+              };
+              const route = yield* prepareRoutes([committed]);
+              for (const projector of list) {
+                yield* projector(committed);
+              }
+              if (commit)
+                yield* commit(seq);
+              yield* db.insert(EventSequenceTable2).values([{ aggregate_id: aggregateID, seq, owner_id: input?.ownerID }]).onConflictDoUpdate({
+                target: EventSequenceTable2.aggregate_id,
+                set: {
+                  seq: sql`max(${EventSequenceTable2.seq}, ${seq})`,
+                  ...input?.ownerID && row?.ownerID == null ? { owner_id: input.ownerID } : {}
+                }
+              }).run().pipe(Effect.orDie);
+              if (persist)
+                yield* db.insert(EventTable2).values([
+                  {
+                    id: event.id,
+                    aggregate_id: aggregateID,
+                    seq,
+                    created: event.created ?? 0,
+                    type: versionedType2(definition.type, durable.version),
+                    data: encoded
+                  }
+                ]).run().pipe(Effect.orDie);
+              return { aggregateID, seq, event: committed, route };
+            }), { behavior: "immediate" }).pipe(Effect.orDie);
+            if (committed) {
+              committed.route();
+              yield* Effect.forEach(pubsub.durable.get(committed.aggregateID) ?? [], (wake) => PubSub.publish(wake, undefined), { discard: true });
+            }
+            return committed;
+          }));
+        });
+      }
+      function publishEvent(definition, event, commit) {
+        return Effect.gen(function* () {
+          if (!definition.durable && commit)
+            return yield* Effect.die(new InvalidDurableEventError2({
+              type: event.type,
+              message: "Local commit hooks require a durable event"
+            }));
+          if (definition.durable) {
+            const aggregateID = event.data[definition.durable.aggregate];
+            if (typeof aggregateID !== "string")
+              return yield* commitDurableEvent(definition, event, undefined, commit).pipe(Effect.as(event));
+            return yield* durableLocks.withLock(aggregateID)(Effect.gen(function* () {
+              const committed = yield* commitDurableEvent(definition, event, undefined, commit);
+              if (!committed)
+                return event;
+              event = committed.event;
+              yield* notify(event, true);
+              return event;
+            }));
+          }
+          const route = yield* prepareRoutes([event]);
+          route();
+          yield* notify(event, false);
+          return event;
+        });
+      }
+      const observe = (event, observer) => Effect.suspend(() => observer(event)).pipe(Effect.catchCauseIf((cause) => !Cause.hasInterrupts(cause), (cause) => Effect.logError("Event listener failed", { eventID: event.id, eventType: event.type, cause })));
+      function notify(event, isolateListeners) {
+        return Effect.gen(function* () {
+          yield* Effect.forEach(listeners, (listener) => isolateListeners ? observe(event, listener) : listener(event), { discard: true });
+          const typed = pubsub.typed.get(event.type);
+          if (typed)
+            yield* PubSub.publish(typed, event);
+          yield* PubSub.publish(pubsub.live, event);
+        });
+      }
+      function publish(definition, data, options) {
+        return Effect.gen(function* () {
+          const serviceLocation = Option.getOrUndefined(yield* Effect.serviceOption(Location.Service));
+          const location = options?.global ? undefined : options?.location ?? (serviceLocation ? { directory: serviceLocation.directory, workspaceID: serviceLocation.workspaceID } : undefined);
+          return yield* publishEvent(definition, {
+            id: options?.id ?? Event.ID.create(),
+            created: yield* Clock.currentTimeMillis,
+            ...options?.metadata ? { metadata: options.metadata } : {},
+            type: definition.type,
+            ...location ? { location } : {},
+            data
+          }, options?.commit);
+        });
+      }
+      function publishAll(events) {
+        return Effect.gen(function* () {
+          const serviceLocation = Option.getOrUndefined(yield* Effect.serviceOption(Location.Service));
+          const payloads = yield* Effect.forEach(events, ([definition, data, options]) => Effect.gen(function* () {
+            const aggregateID = data[definition.durable.aggregate];
+            if (typeof aggregateID !== "string") {
+              return yield* Effect.die(new InvalidDurableEventError2({
+                type: definition.type,
+                message: `Expected string aggregate field ${definition.durable.aggregate}`
+              }));
+            }
+            const location = options?.global ? undefined : options?.location ?? (serviceLocation ? { directory: serviceLocation.directory, workspaceID: serviceLocation.workspaceID } : undefined);
+            return {
+              definition,
+              aggregateID,
+              commit: options?.commit,
+              event: {
+                id: options?.id ?? Event.ID.create(),
+                created: yield* Clock.currentTimeMillis,
+                ...options?.metadata ? { metadata: options.metadata } : {},
+                type: definition.type,
+                ...location ? { location } : {},
+                data
+              }
+            };
+          }));
+          const aggregateID = payloads[0].aggregateID;
+          if (payloads.some((item) => item.aggregateID !== aggregateID)) {
+            return yield* Effect.die(new InvalidDurableEventError2({
+              type: payloads[0].definition.type,
+              message: "Published events must belong to the same aggregate"
+            }));
+          }
+          return yield* durableLocks.withLock(aggregateID)(Effect.uninterruptible(Effect.gen(function* () {
+            const committed = yield* db.transaction(() => Effect.gen(function* () {
+              const row = yield* db.select({ seq: EventSequenceTable2.seq }).from(EventSequenceTable2).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
+              const firstSeq = (row?.seq ?? -1) + 1;
+              const finalSeq = firstSeq + payloads.length - 1;
+              const queued = payloads.map((item, index) => ({
+                ...item.event,
+                durable: envelope(aggregateID, firstSeq + index, item.definition.durable.version)
+              }));
+              const route = yield* prepareRoutes(queued);
+              const rows = new Array;
+              const ids = new Set;
+              for (const [index, item] of payloads.entries()) {
+                const seq = firstSeq + index;
+                const encoded = Schema.encodeUnknownSync(item.definition.data)(item.event.data);
+                if (persist) {
+                  if (ids.has(item.event.id))
+                    yield* Effect.die(new InvalidDurableEventError2({
+                      type: item.event.type,
+                      message: `Event ${item.event.id} appears more than once in the batch`
+                    }));
+                  ids.add(item.event.id);
+                  const stored = yield* db.select({ aggregateID: EventTable2.aggregate_id, seq: EventTable2.seq }).from(EventTable2).where(eq(EventTable2.id, item.event.id)).get().pipe(Effect.orDie);
+                  if (stored)
+                    yield* Effect.die(new InvalidDurableEventError2({
+                      type: item.event.type,
+                      message: `Event ${item.event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`
+                    }));
+                }
+                const event = queued[index];
+                for (const projector of projectors.get(versionedType2(item.definition.type, item.definition.durable.version)) ?? []) {
+                  yield* projector(event);
+                }
+                if (item.commit)
+                  yield* item.commit(seq);
+                if (persist)
+                  rows.push({
+                    id: event.id,
+                    aggregate_id: aggregateID,
+                    seq,
+                    created: event.created,
+                    type: versionedType2(item.definition.type, item.definition.durable.version),
+                    data: encoded
+                  });
+              }
+              yield* db.insert(EventSequenceTable2).values([{ aggregate_id: aggregateID, seq: finalSeq }]).onConflictDoUpdate({ target: EventSequenceTable2.aggregate_id, set: { seq: finalSeq } }).run().pipe(Effect.orDie);
+              if (persist)
+                yield* db.insert(EventTable2).values(rows).run().pipe(Effect.orDie);
+              return { events: queued, route };
+            }), { behavior: "immediate" }).pipe(Effect.orDie);
+            committed.route();
+            yield* Effect.forEach(pubsub.durable.get(aggregateID) ?? [], (wake) => PubSub.publish(wake, undefined), {
+              discard: true
+            });
+            yield* Effect.forEach(committed.events, (event) => notify(event, true), { discard: true });
+            return committed.events;
+          })));
+        });
+      }
+      function replay(event, options) {
+        return Effect.gen(function* () {
+          const definition = Durable.get(event.type);
+          if (!definition?.durable)
+            return yield* Effect.die(new InvalidDurableEventError2({ type: event.type, message: `Unknown durable event type ${event.type}` }));
+          yield* durableLocks.withLock(event.aggregateID)(Effect.gen(function* () {
+            const payload = {
+              id: event.id,
+              created: event.created ?? 0,
+              type: definition.type,
+              data: Schema.decodeUnknownSync(definition.data)(event.data)
+            };
+            const committed = yield* commitDurableEvent(definition, payload, {
+              seq: event.seq,
+              aggregateID: event.aggregateID,
+              ownerID: options?.ownerID,
+              strictOwner: options?.strictOwner
+            });
+            if (committed && options?.publish) {
+              yield* notify(committed.event, true);
+            }
+          }));
+        });
+      }
+      function remove(aggregateID) {
+        return db.transaction(() => Effect.gen(function* () {
+          yield* db.delete(EventSequenceTable2).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).run();
+          yield* db.delete(EventTable2).where(eq(EventTable2.aggregate_id, aggregateID)).run();
+        })).pipe(Effect.tap(() => Effect.sync(() => sessions.delete(aggregateID))), Effect.orDie);
+      }
+      function claim(aggregateID, ownerID) {
+        return db.update(EventSequenceTable2).set({ owner_id: ownerID }).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).run().pipe(Effect.orDie);
+      }
+      const local = (stream) => Stream.unwrap(Effect.serviceOption(Location.Service).pipe(Effect.map((location) => Option.match(location, {
+        onNone: () => stream,
+        onSome: (location) => {
+          const matches = (ref) => ref.directory === location.directory && ref.workspaceID === location.workspaceID;
+          return stream.pipe(Stream.filter((event) => {
+            const refs = routes.get(event);
+            if (refs)
+              return refs.some(matches);
+            return !event.location || matches(event.location);
+          }));
+        }
+      }))));
+      function subscribe(input) {
+        if (input === undefined)
+          return streamLive();
+        if (isDefinition(input)) {
+          return local(Stream.unwrap(getOrCreate(input).pipe(Effect.map((pubsub) => Stream.fromPubSub(pubsub)))));
+        }
+        const types = new Set(input.map((definition) => definition.type));
+        return streamLive().pipe(Stream.filter((event) => types.has(event.type)));
+      }
+      const streamLive = () => local(Stream.fromPubSub(pubsub.live));
+      const readAfter = (aggregateID, after, input) => (options?.beforeAggregateRead?.(aggregateID) ?? Effect.void).pipe(Effect.andThen(Effect.suspend(() => {
+        const query = db.select().from(EventTable2).where(and(eq(EventTable2.aggregate_id, aggregateID), gt(EventTable2.seq, after), lte(EventTable2.seq, input.through))).orderBy(asc(EventTable2.seq));
+        return query.limit(input.limit).all();
+      })), Effect.orDie, Effect.map((rows) => ({
+        seq: rows.at(-1)?.seq,
+        events: rows.flatMap((event) => {
+          if (!Durable.get(event.type)?.durable)
+            return [];
+          return [
+            decodeSerializedEvent({
+              id: event.id,
+              created: event.created,
+              aggregateID: event.aggregate_id,
+              seq: event.seq,
+              type: event.type,
+              data: event.data
+            })
+          ];
+        })
+      })));
+      const subscribeDurable = (aggregateID) => Effect.gen(function* () {
+        const wake = yield* PubSub.sliding(1);
+        const subscription = yield* PubSub.subscribe(wake);
+        yield* Effect.acquireRelease(Effect.sync(() => {
+          const wakes = pubsub.durable.get(aggregateID) ?? new Set;
+          wakes.add(wake);
+          pubsub.durable.set(aggregateID, wakes);
+        }), () => Effect.sync(() => {
+          const wakes = pubsub.durable.get(aggregateID);
+          wakes?.delete(wake);
+          if (wakes?.size === 0)
+            pubsub.durable.delete(aggregateID);
+        }).pipe(Effect.andThen(PubSub.shutdown(wake))));
+        return subscription;
+      });
+      const log = (input) => Stream.unwrap(Effect.gen(function* () {
+        let sequence = input.after ?? -1;
+        const readThrough = (through) => Stream.paginate(sequence, (cursor) => readAfter(input.aggregateID, cursor, { through, limit: logReadPageSize }).pipe(Effect.tap((page) => Effect.sync(() => {
+          sequence = page.seq ?? sequence;
+        })), Effect.map((page) => [
+          page.events,
+          page.seq !== undefined && page.seq < through ? Option.some(page.seq) : Option.none()
+        ])));
+        const wakes = input.follow ? yield* subscribeDurable(input.aggregateID) : undefined;
+        const target = yield* latestSequence2(db, input.aggregateID);
+        const marker = {
+          type: "log.synced",
+          aggregateID: input.aggregateID,
+          ...target >= 0 ? { seq: Event.Seq.make(target) } : {}
+        };
+        const replay = readThrough(target).pipe(Stream.concat(Stream.make(marker)));
+        if (!wakes)
+          return replay;
+        const live = Stream.fromSubscription(wakes).pipe(Stream.mapEffect(() => latestSequence2(db, input.aggregateID)), Stream.filter((target) => target > sequence), Stream.flatMap((target) => readThrough(target)));
+        return Stream.concat(replay, live);
+      }));
+      const listen = (listener) => Effect.sync(() => {
+        listeners.push(listener);
+        return Effect.sync(() => {
+          const index = listeners.indexOf(listener);
+          if (index >= 0)
+            listeners.splice(index, 1);
+        });
+      });
+      const project = (definition, projector) => Effect.sync(() => {
+        const key = definition.durable ? versionedType2(definition.type, definition.durable.version) : definition.type;
+        const list = projectors.get(key) ?? [];
+        list.push((event) => projector(event));
+        projectors.set(key, list);
+      });
+      return Service79.of({
+        publish,
+        publishAll,
+        subscribe,
+        log,
+        listen,
+        project,
+        replay,
+        remove,
+        claim
+      });
+    }))
+  });
+}
+var node84 = configured12();
+
+export { latestSequence2, reserveSequence2, InvalidDurableEventError2, versionedType2, durable2, ephemeral2, isSynced2, Service79, configured12, node84, exports_bus };

package/dist/chunks/aisdk-native-15rsv8cs.js

@@ -0,0 +1,123 @@
+import {
+  OAuth3
+} from "./aisdk-native-111hscse.js";
+import {
+  ID11,
+  MethodID2
+} from "./aisdk-native-tpbhnsa4.js";
+import {
+  success2,
+  error2
+} from "./aisdk-native-pjvnvgmy.js";
+
+// src/plugin/provider/poe.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Clock, Deferred, Effect, Option, Schema } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+var integrationID = ID11.make("poe");
+var methodID = MethodID2.make("browser");
+var clientID = "client_728290227fc048cc9262091a1ea197ea";
+var issuer = "https://poe.com";
+var maxExpiry = 8640000000000000;
+var Token = Schema.Struct({
+  api_key: Schema.Trim.check(Schema.isNonEmpty(), Schema.isPattern(/^\S+$/)),
+  api_key_expires_in: Schema.optional(Schema.NullOr(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))))
+});
+var decodeError = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Struct({ error: Schema.optional(Schema.String), error_description: Schema.optional(Schema.String) })));
+var PoePlugin2 = define({
+  id: "opencode.provider.poe",
+  effect: Effect.fn(function* (ctx) {
+    const http = yield* HttpClient.HttpClient;
+    yield* ctx.integration.transform((editor) => {
+      editor.method.update({
+        integrationID,
+        method: { id: methodID, type: "oauth", label: "Login with Poe (browser)" },
+        refresh: (value) => Clock.currentTimeMillis.pipe(Effect.flatMap((now) => value.expires > now ? Effect.succeed(value) : Effect.fail(new Error("Poe API key expired. Log in with Poe again.")))),
+        authorize: () => Effect.gen(function* () {
+          const verifier = Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString("base64url");
+          const challenge = Buffer.from(yield* Effect.promise(() => crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)))).toString("base64url");
+          const state = Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString("base64url");
+          const callback = yield* Deferred.make();
+          const { createServer } = yield* Effect.promise(() => import("node:http"));
+          const { EventEmitter } = yield* Effect.promise(() => import("node:events"));
+          const server = createServer((request, response) => {
+            const url = new URL(request.url ?? "/", "http://127.0.0.1");
+            if (request.method !== "GET" || url.pathname !== "/callback") {
+              response.writeHead(404).end();
+              return;
+            }
+            const error = callbackError(url.searchParams, state);
+            if (error) {
+              response.writeHead(400, { "Content-Type": "text/html" }).end(error2(error, { provider: "Poe" }));
+              Effect.runSync(Deferred.fail(callback, new Error(error)));
+              return;
+            }
+            if (!Effect.runSync(Deferred.succeed(callback, { code: url.searchParams.get("code") ?? "", response })))
+              response.writeHead(409).end("OAuth callback already received");
+          });
+          yield* Effect.addFinalizer(() => Effect.sync(() => {
+            server.close();
+            server.closeAllConnections();
+          }));
+          yield* Effect.tryPromise(() => EventEmitter.once(server.listen(0, "127.0.0.1"), "listening"));
+          const address = server.address();
+          if (!address || typeof address === "string")
+            return yield* Effect.fail(new Error("Missing OAuth callback port"));
+          const redirect = `http://127.0.0.1:${address.port}/callback`;
+          return {
+            mode: "auto",
+            url: `${issuer}/oauth/authorize?${new URLSearchParams({
+              response_type: "code",
+              client_id: clientID,
+              redirect_uri: redirect,
+              scope: "apikey:create",
+              code_challenge: challenge,
+              code_challenge_method: "S256",
+              state
+            }).toString()}`,
+            instructions: "Complete authorization in your browser. This window will close automatically.",
+            callback: Effect.gen(function* () {
+              const request = yield* Deferred.await(callback);
+              const respond = (error) => Effect.sync(() => request.response.writeHead(error ? 400 : 200, { "Content-Type": "text/html" }).end(error ? error2(error, { provider: "Poe" }) : success2({ provider: "Poe" })));
+              return yield* exchangeCode(http, { code: request.code, redirect, verifier }).pipe(Effect.tap(() => respond()), Effect.tapError((error) => respond(error.message)), Effect.onInterrupt(() => Effect.sync(() => request.response.destroy())));
+            })
+          };
+        })
+      });
+    });
+  })
+});
+function callbackError(params, state) {
+  if (params.get("state") !== state)
+    return "Invalid OAuth state";
+  if (params.has("iss") && params.get("iss") !== issuer)
+    return "Invalid OAuth issuer";
+  if (params.has("error")) {
+    const detail = params.get("error_description") || params.get("error") || "Authorization denied";
+    return detail.includes(state) ? "Poe authorization failed" : detail;
+  }
+  return params.get("code")?.trim() ? undefined : "Missing authorization code";
+}
+function exchangeCode(http, input) {
+  return Effect.gen(function* () {
+    const response = yield* http.execute(HttpClientRequest.post("https://api.poe.com/token").pipe(HttpClientRequest.bodyUrlParams({
+      grant_type: "authorization_code",
+      client_id: clientID,
+      code: input.code,
+      redirect_uri: input.redirect,
+      code_verifier: input.verifier
+    }))).pipe(Effect.mapError(() => new Error("Poe token exchange request failed")));
+    if (response.status < 200 || response.status >= 300) {
+      const error = Option.getOrUndefined(decodeError(yield* response.text.pipe(Effect.orElseSucceed(() => ""))));
+      const detail = error?.error_description || error?.error;
+      return yield* Effect.fail(new Error(detail && ![input.code, input.verifier].some((secret) => detail.includes(secret)) ? `Poe token exchange failed: ${detail}` : `Poe token exchange failed (${response.status})`));
+    }
+    const token = yield* HttpClientResponse.schemaBodyJson(Token)(response).pipe(Effect.mapError(() => new Error("Invalid Poe token response")));
+    const expires = token.api_key_expires_in == null ? maxExpiry : (yield* Clock.currentTimeMillis) + token.api_key_expires_in * 1000;
+    if (!Number.isSafeInteger(expires) || expires > maxExpiry)
+      return yield* Effect.fail(new Error("Invalid Poe API key expiry"));
+    return OAuth3.make({ type: "oauth", methodID, access: token.api_key, refresh: "", expires });
+  });
+}
+
+export { PoePlugin2 };