@opencode-ai/core 0.0.0-beta-19086 → 0.0.0-beta-19124

package/dist/chunks/event-logger-aymbgepw.js

@@ -0,0 +1,329 @@
+import {
+  Service80,
+  node85
+} from "./event-logger-4vtp7hga.js";
+import {
+  makeUnsafe2
+} from "./event-logger-y71avatq.js";
+import {
+  Service79,
+  node84
+} from "./event-logger-jbmjz4v3.js";
+import {
+  SessionEvent2
+} from "./event-logger-mntxs535.js";
+import {
+  SessionMessage2
+} from "./event-logger-982e01ww.js";
+import {
+  SessionSchema2
+} from "./event-logger-mq9r6drf.js";
+import {
+  SessionMessageTable2,
+  SessionInboxTable2
+} from "./event-logger-hrvm11jt.js";
+import {
+  __export
+} from "./event-logger-9rqn6x4v.js";
+
+// src/session/inbox.ts
+var exports_inbox = {};
+__export(exports_inbox, {
+  Compaction: () => Compaction2,
+  CompactionPayload: () => CompactionPayload2,
+  Delivery: () => Delivery2,
+  Info: () => Info6,
+  Item: () => Item2,
+  LifecycleConflict: () => LifecycleConflict2,
+  Move: () => Move2,
+  MovePayload: () => MovePayload2,
+  Service: () => Service29,
+  SessionInbox: () => exports_inbox,
+  Synthetic: () => Synthetic2,
+  SyntheticPayload: () => SyntheticPayload2,
+  User: () => User2,
+  UserPayload: () => UserPayload2,
+  find: () => find2,
+  has: () => has2,
+  layer: () => layer12,
+  list: () => list3,
+  make: () => make13,
+  moveIDs: () => moveIDs2,
+  nextPromotable: () => nextPromotable2,
+  node: () => node33,
+  projectAdmitted: () => projectAdmitted2,
+  projectCancelled: () => projectCancelled2,
+  projectDelivered: () => projectDelivered2,
+  projectDeliveryChanged: () => projectDeliveryChanged2,
+  promote: () => promote2,
+  serialized: () => serialized2
+});
+import { and, asc, eq, or } from "drizzle-orm";
+import { Context, DateTime, Effect, Layer, Schema } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import {
+  Compaction as Compaction2,
+  CompactionPayload as CompactionPayload2,
+  Delivery as Delivery2,
+  Info as Info6,
+  Item as Item2,
+  Move as Move2,
+  MovePayload as MovePayload2,
+  Synthetic as Synthetic2,
+  SyntheticPayload as SyntheticPayload2,
+  User as User2,
+  UserPayload as UserPayload2
+} from "@opencode-ai/schema/session-inbox";
+var decodeUser = Schema.decodeUnknownSync(UserPayload2);
+var encodeUser = Schema.encodeSync(UserPayload2);
+var decodeSynthetic = Schema.decodeUnknownSync(SyntheticPayload2);
+var encodeSynthetic = Schema.encodeSync(SyntheticPayload2);
+var decodeCompaction = Schema.decodeUnknownSync(CompactionPayload2);
+var encodeCompaction = Schema.encodeSync(CompactionPayload2);
+var decodeMove = Schema.decodeUnknownSync(MovePayload2);
+var encodeMove = Schema.encodeSync(MovePayload2);
+var decodeMessage = Schema.decodeUnknownSync(SessionMessage2.Info);
+var inboxLocks = makeUnsafe2();
+var serialized2 = (sessionID, effect) => inboxLocks.withLock(sessionID)(effect);
+
+class LifecycleConflict2 extends Schema.TaggedError()("SessionInbox.LifecycleConflict", {
+  id: SessionMessage2.ID
+}) {
+}
+function matches(stored, request) {
+  return stored.sessionID === request.sessionID && stored.type === request.type;
+}
+var fromRow = (row) => {
+  const base = {
+    id: SessionMessage2.ID.make(row.id),
+    sessionID: SessionSchema2.ID.make(row.session_id),
+    timeCreated: DateTime.makeUnsafe(row.time_created)
+  };
+  if (row.type === "compaction")
+    return Compaction2.make({
+      ...base,
+      type: "compaction",
+      payload: decodeCompaction(row.payload),
+      delivery: row.delivery
+    });
+  if (row.type === "move")
+    return Move2.make({ ...base, type: "move", payload: decodeMove(row.payload), delivery: row.delivery });
+  if (row.type === "user")
+    return User2.make({
+      ...base,
+      type: "user",
+      payload: decodeUser(row.payload),
+      delivery: row.delivery
+    });
+  if (row.type === "synthetic")
+    return Synthetic2.make({
+      ...base,
+      type: "synthetic",
+      payload: decodeSynthetic(row.payload),
+      delivery: row.delivery
+    });
+  throw new LifecycleConflict2({ id: base.id });
+};
+var find2 = Effect.fn("SessionInbox.find")(function* (db, id) {
+  const row = yield* db.select().from(SessionInboxTable2).where(eq(SessionInboxTable2.id, id)).get().pipe(Effect.orDie);
+  return row === undefined ? undefined : fromRow(row);
+});
+var promotedFromMessage = Effect.fn("SessionInbox.promotedFromMessage")(function* (db, sessionID, id, delivery) {
+  const row = yield* db.select().from(SessionMessageTable2).where(eq(SessionMessageTable2.id, id)).get().pipe(Effect.orDie);
+  if (row === undefined)
+    return;
+  if (row.session_id !== sessionID || row.type !== "user" && row.type !== "synthetic")
+    return yield* new LifecycleConflict2({ id });
+  const message = decodeMessage({ ...row.data, id: row.id, type: row.type });
+  const base = { id, sessionID, timeCreated: message.time.created, delivery };
+  if (message.type === "user")
+    return User2.make({
+      ...base,
+      type: "user",
+      payload: decodeUser(message)
+    });
+  if (message.type === "synthetic")
+    return Synthetic2.make({
+      ...base,
+      type: "synthetic",
+      payload: decodeSynthetic(message)
+    });
+  return yield* new LifecycleConflict2({ id });
+});
+
+class Service29 extends Context.Service()("@opencode/SessionInbox") {
+}
+var make13 = Effect.fn("SessionInbox.make")(function* () {
+  const database = yield* Service80;
+  const db = database.db;
+  const bus = yield* Service79;
+  const reconcile = Effect.fn("SessionInbox.reconcile")(function* (request) {
+    const existing = (yield* find2(db, request.id)) ?? (yield* promotedFromMessage(db, request.sessionID, request.id, request.delivery));
+    if (existing === undefined)
+      return;
+    if (existing.type === "compaction" || !matches(existing, request))
+      return yield* new LifecycleConflict2({ id: request.id });
+    return existing;
+  });
+  const admit = Effect.fn("SessionInbox.admit")(function* (request) {
+    const existing = yield* reconcile({ ...request, type: request.item.type, delivery: request.item.delivery });
+    if (existing !== undefined)
+      return existing;
+    const admitted = yield* bus.publish(SessionEvent2.InboxEnqueued, {
+      inboxID: request.id,
+      sessionID: request.sessionID,
+      item: request.item
+    }).pipe(Effect.map((event) => Info6.make({
+      id: request.id,
+      sessionID: request.sessionID,
+      timeCreated: DateTime.makeUnsafe(event.created),
+      ...request.item
+    })), Effect.catchDefect((defect) => defect instanceof LifecycleConflict2 ? find2(db, request.id).pipe(Effect.flatMap((stored) => stored === undefined ? Effect.fail(defect) : Effect.succeed(stored))) : Effect.die(defect)));
+    if (!matches(admitted, { ...request, type: request.item.type }))
+      return yield* new LifecycleConflict2({ id: request.id });
+    return admitted;
+  });
+  const admitCompaction = Effect.fn("SessionInbox.admitCompaction")(function* (input) {
+    return yield* serialized2(input.sessionID, Effect.gen(function* () {
+      const exact = yield* find2(db, input.id);
+      if (exact) {
+        if (exact.type === "compaction" && exact.sessionID === input.sessionID)
+          return exact;
+        return yield* new LifecycleConflict2({ id: input.id });
+      }
+      if (yield* promotedFromMessage(db, input.sessionID, input.id, input.delivery))
+        return yield* new LifecycleConflict2({ id: input.id });
+      const pending = (yield* list3(db, input.sessionID)).find((item) => item.type === "compaction");
+      if (pending)
+        return pending;
+      return yield* admit({
+        id: input.id,
+        sessionID: input.sessionID,
+        item: { type: "compaction", payload: {}, delivery: Delivery2.make(input.delivery) }
+      });
+    }));
+  });
+  const cancel = Effect.fn("SessionInbox.cancel")((input) => publishMutation(input, bus.publish(SessionEvent2.InboxCancelled, {
+    sessionID: input.sessionID,
+    inboxID: input.id
+  })));
+  const steer = Effect.fn("SessionInbox.steer")((input) => publishMutation(input, bus.publish(SessionEvent2.InboxDeliveryChanged, {
+    sessionID: input.sessionID,
+    inboxID: input.id,
+    delivery: "steer"
+  })));
+  const queue = Effect.fn("SessionInbox.queue")((input) => publishMutation(input, bus.publish(SessionEvent2.InboxDeliveryChanged, {
+    sessionID: input.sessionID,
+    inboxID: input.id,
+    delivery: "queue"
+  })));
+  return {
+    list: (sessionID) => list3(db, sessionID),
+    reconcile,
+    admit,
+    admitCompaction,
+    cancel,
+    steer,
+    queue
+  };
+});
+var layer12 = Layer.effect(Service29, make13());
+var node33 = makeGlobalNode({ service: Service29, layer: layer12, deps: [node85, node84] });
+var projectAdmitted2 = Effect.fn("SessionInbox.projectAdmitted")(function* (db, request) {
+  const message = yield* db.select({ id: SessionMessageTable2.id }).from(SessionMessageTable2).where(eq(SessionMessageTable2.id, request.id)).get().pipe(Effect.orDie);
+  if (message !== undefined)
+    return yield* Effect.die(new LifecycleConflict2({ id: request.id }));
+  const stored = yield* db.insert(SessionInboxTable2).values({
+    id: request.id,
+    session_id: request.sessionID,
+    type: request.item.type,
+    payload: request.item.type === "user" ? encodeUser(request.item.payload) : request.item.type === "synthetic" ? encodeSynthetic(request.item.payload) : request.item.type === "compaction" ? encodeCompaction(request.item.payload) : encodeMove(request.item.payload),
+    delivery: request.item.delivery,
+    enqueued_seq: request.enqueuedSeq,
+    time_created: request.timeCreated
+  }).onConflictDoNothing().returning({ id: SessionInboxTable2.id }).get().pipe(Effect.orDie);
+  if (!stored)
+    return yield* Effect.die(new LifecycleConflict2({ id: request.id }));
+});
+var projectDelivered2 = Effect.fn("SessionInbox.projectDelivered")(function* (db, input) {
+  const deleted = yield* db.delete(SessionInboxTable2).where(and(eq(SessionInboxTable2.id, input.id), eq(SessionInboxTable2.session_id, input.sessionID))).returning().get().pipe(Effect.orDie);
+  if (!deleted)
+    return yield* Effect.die(new LifecycleConflict2({ id: input.id }));
+  return fromRow(deleted);
+});
+var projectCancelled2 = Effect.fn("SessionInbox.projectCancelled")(function* (db, input) {
+  const deleted = yield* db.delete(SessionInboxTable2).where(and(eq(SessionInboxTable2.id, input.id), eq(SessionInboxTable2.session_id, input.sessionID), or(eq(SessionInboxTable2.delivery, "queue"), eq(SessionInboxTable2.delivery, "steer")))).returning({ id: SessionInboxTable2.id }).get().pipe(Effect.orDie);
+  if (!deleted)
+    return yield* Effect.die(new LifecycleConflict2({ id: input.id }));
+});
+var projectDelivery = Effect.fn("SessionInbox.projectDelivery")(function* (db, input) {
+  const updated = yield* db.update(SessionInboxTable2).set({ delivery: input.to }).where(and(eq(SessionInboxTable2.id, input.id), eq(SessionInboxTable2.session_id, input.sessionID), eq(SessionInboxTable2.delivery, input.from))).returning({ id: SessionInboxTable2.id }).get().pipe(Effect.orDie);
+  if (!updated)
+    return yield* Effect.die(new LifecycleConflict2({ id: input.id }));
+});
+var projectDeliveryChanged2 = Effect.fn("SessionInbox.projectDeliveryChanged")((db, input) => projectDelivery(db, {
+  ...input,
+  from: input.delivery === "steer" ? "queue" : "steer",
+  to: input.delivery
+}));
+var list3 = Effect.fn("SessionInbox.list")(function* (db, sessionID) {
+  const rows = yield* db.select().from(SessionInboxTable2).where(eq(SessionInboxTable2.session_id, sessionID)).orderBy(asc(SessionInboxTable2.enqueued_seq)).all().pipe(Effect.orDie);
+  return rows.map(fromRow);
+});
+var moveIDs2 = Effect.fn("SessionInbox.moveIDs")(function* (db, sessionID) {
+  return yield* db.select({ id: SessionInboxTable2.id }).from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.type, "move"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).all().pipe(Effect.orDie);
+});
+var nextPromotable2 = Effect.fn("SessionInbox.nextPromotable")(function* (db, sessionID, promotable) {
+  const steer = (yield* pendingSteers(db, sessionID))[0];
+  if (steer)
+    return fromRow(steer);
+  if (promotable !== "input")
+    return;
+  const queued = yield* db.select().from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.delivery, "queue"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
+  return queued ? fromRow(queued) : undefined;
+});
+var has2 = Effect.fn("SessionInbox.has")(function* (db, sessionID, scope) {
+  const row = yield* db.select({ id: SessionInboxTable2.id }).from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), scope === "input" ? or(eq(SessionInboxTable2.delivery, "steer"), eq(SessionInboxTable2.delivery, "queue")) : eq(SessionInboxTable2.delivery, scope))).limit(1).get().pipe(Effect.orDie);
+  return row !== undefined;
+});
+var publishMutation = (input, effect) => serialized2(input.sessionID, effect).pipe(Effect.asVoid, Effect.catchDefect((defect) => defect instanceof LifecycleConflict2 ? Effect.fail(defect) : Effect.die(defect)));
+var publish = Effect.fn("SessionInbox.publish")(function* (db, bus, sessionID, rows) {
+  yield* Effect.forEach(rows, (row) => {
+    const entry = fromRow(row);
+    if (entry.type === "compaction")
+      return Effect.die(new LifecycleConflict2({ id: entry.id }));
+    return bus.publish(SessionEvent2.InboxDelivered, {
+      sessionID,
+      inboxID: entry.id
+    }).pipe(Effect.catchDefect((defect) => defect instanceof LifecycleConflict2 ? promotedFromMessage(db, sessionID, entry.id, entry.delivery).pipe(Effect.flatMap((stored) => stored !== undefined ? Effect.void : Effect.die(defect)), Effect.orDie) : Effect.die(defect)));
+  }, { discard: true });
+  return rows.length;
+});
+var promote2 = Effect.fn("SessionInbox.promote")(function* (db, bus, sessionID, scope) {
+  return yield* serialized2(sessionID, Effect.gen(function* () {
+    const steers = yield* pendingSteers(db, sessionID);
+    if (steers.length > 0 || scope === "steer") {
+      const control = steers.findIndex((row) => row.type === "compaction" || row.type === "move");
+      if (control === 0)
+        return;
+      return yield* publish(db, bus, sessionID, control === -1 ? steers : steers.slice(0, control));
+    }
+    const queued = yield* db.select().from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.delivery, "queue"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
+    if (!queued)
+      return 0;
+    if (queued.type === "compaction" || queued.type === "move")
+      return;
+    const promoted = yield* publish(db, bus, sessionID, [queued]);
+    const arrivedSteers = yield* pendingSteers(db, sessionID);
+    const control = arrivedSteers.findIndex((row) => row.type === "compaction" || row.type === "move");
+    return promoted + (yield* publish(db, bus, sessionID, control === -1 ? arrivedSteers : arrivedSteers.slice(0, control)));
+  }));
+});
+var pendingSteers = (db, sessionID) => db.select().from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.delivery, "steer"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).all().pipe(Effect.orDie, Effect.map((rows) => {
+  const control = rows.findIndex((row) => row.type === "compaction" || row.type === "move");
+  if (control > 0 && rows[control].type === "compaction")
+    rows.unshift(...rows.splice(control, 1));
+  return rows;
+}));
+
+export { Compaction2, CompactionPayload2, Delivery2, Info6, Item2, Move2, MovePayload2, Synthetic2, SyntheticPayload2, User2, UserPayload2, serialized2, LifecycleConflict2, find2, Service29, make13, layer12, node33, projectAdmitted2, projectDelivered2, projectCancelled2, projectDeliveryChanged2, list3, moveIDs2, nextPromotable2, has2, promote2, exports_inbox };

package/dist/chunks/{schema-ntev5d3k.js → event-logger-b1najej0.js}

@@ -1,24 +1,24 @@
 import {
-  exports_mcp
-} from "./schema-etbnsc4s.js";
+  useragent2
+} from "./event-logger-fd84j5ds.js";
 import {
-  exports_app
-} from "./schema-hs51b0fc.js";
+  call2
+} from "./event-logger-6z5bwd8g.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/plugin/websearch/parallel.ts
 var exports_parallel = {};
 __export(exports_parallel, {
-  Plugin: () => Plugin,
+  Plugin: () => Plugin5,
   WebSearchParallel: () => exports_parallel,
-  endpoint: () => endpoint
+  endpoint: () => endpoint4
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect, Schema } from "effect";
 import { HttpClient } from "effect/unstable/http";
-var endpoint = "https://search.parallel.ai/mcp";
+var endpoint4 = "https://search.parallel.ai/mcp";
 var McpInput = Schema.Struct({
   objective: Schema.String,
   search_queries: Schema.Array(Schema.String),
@@ -47,7 +47,7 @@ var McpOutput = Schema.Struct({
   content: Schema.Array(Schema.Struct({ type: Schema.Literal("text"), text: Schema.String })),
   structuredContent: SearchResponse
 });
-var Plugin = define({
+var Plugin5 = define({
   id: "opencode.websearch.parallel",
   effect: Effect.fn("WebSearchParallel.Plugin")(function* (ctx) {
     const http = yield* HttpClient.HttpClient;
@@ -69,11 +69,11 @@ var Plugin = define({
         execute: (input) => Effect.gen(function* () {
           const connection = yield* ctx.integration.connection.active("parallel");
           const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined;
-          const result = yield* exports_mcp.call(http, endpoint, "web_search", { input: McpInput, output: McpOutput }, {
+          const result = yield* call2(http, endpoint4, "web_search", { input: McpInput, output: McpOutput }, {
             objective: input.query,
             search_queries: [input.query]
           }, {
-            "User-Agent": exports_app.useragent(ctx.app),
+            "User-Agent": useragent2(ctx.app),
             ...credential?.type === "key" ? { Authorization: `Bearer ${credential.key}` } : {}
           });
           return result?.structuredContent.results.map((item) => {
@@ -93,4 +93,4 @@ var Plugin = define({
   })
 });
 
-export { endpoint, Plugin, exports_parallel };
+export { endpoint4, Plugin5, exports_parallel };

package/dist/chunks/{schema-6wsfy4sp.js → event-logger-b6gygkdw.js}

@@ -1,30 +1,30 @@
 import {
-  Failed,
-  NotFound,
-  WrongKind
-} from "./schema-vynk8zbr.js";
+  NotFound2,
+  WrongKind2,
+  Failed2
+} from "./event-logger-2a5m3afh.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/environment/local.ts
 var exports_local = {};
 __export(exports_local, {
   EnvironmentLocal: () => exports_local,
-  makeLocalDriver: () => makeLocalDriver
+  makeLocalDriver: () => makeLocalDriver2
 });
 import fs from "node:fs/promises";
 import path from "node:path";
 import { Effect } from "effect";
-var makeLocalDriver = (spawner) => {
+var makeLocalDriver2 = (spawner) => {
   const overrides = {
     read: (value, range) => Effect.gen(function* () {
       const info = yield* stat(value, true);
       if (info.type !== "file")
-        return yield* new WrongKind({ path: value, actual: info.type });
+        return yield* new WrongKind2({ path: value, actual: info.type });
       if (range === undefined) {
-        const bytes2 = yield* attempt(value, () => fs.readFile(value), true);
-        return { info, bytes: bytes2 };
+        const bytes = yield* attempt(value, () => fs.readFile(value), true);
+        return { info, bytes };
       }
       const bytes = yield* attempt(value, async () => {
         const handle = await fs.open(value, "r");
@@ -42,7 +42,7 @@ var makeLocalDriver = (spawner) => {
     list: (value) => Effect.gen(function* () {
       const info = yield* stat(value, true);
       if (info.type !== "directory")
-        return yield* new WrongKind({ path: value, actual: info.type });
+        return yield* new WrongKind2({ path: value, actual: info.type });
       const entries = yield* attempt(value, () => fs.readdir(value, { withFileTypes: true }), true);
       return entries.map((entry) => ({ name: entry.name, type: fileType(entry) }));
     }),
@@ -53,7 +53,7 @@ var makeLocalDriver = (spawner) => {
     remove: (value) => attempt(value, () => fs.rm(value, { recursive: true, force: true })),
     move: (from, to) => Effect.gen(function* () {
       yield* stat(from, false);
-      const destination = yield* stat(to, false).pipe(Effect.map((info) => info.type === "directory" ? path.join(to, path.basename(from)) : to), Effect.catchIf((error) => error instanceof NotFound, () => Effect.succeed(to)));
+      const destination = yield* stat(to, false).pipe(Effect.map((info) => info.type === "directory" ? path.join(to, path.basename(from)) : to), Effect.catchIf((error) => error instanceof NotFound2, () => Effect.succeed(to)));
       yield* attempt(from, () => fs.rename(from, destination));
     }),
     mkdir: (value) => attempt(value, () => fs.mkdir(value, { recursive: true }).then(() => {
@@ -75,9 +75,9 @@ var fileType = (entry) => {
 function attempt(value, run, missing = false) {
   return Effect.tryPromise({
     try: run,
-    catch: (cause) => missing && isMissing(cause) ? new NotFound({ path: value }) : new Failed({ path: value, cause })
+    catch: (cause) => missing && isMissing(cause) ? new NotFound2({ path: value }) : new Failed2({ path: value, cause })
   });
 }
 var isMissing = (cause) => cause !== null && typeof cause === "object" && ("code" in cause) && (cause.code === "ENOENT" || cause.code === "ENOTDIR");
 
-export { makeLocalDriver, exports_local };
+export { makeLocalDriver2, exports_local };