@opencode-ai/core 0.0.0-dev-19092 → 0.0.0-dev-19094

package/dist/chunks/integration-c8ya26sa.js

@@ -1,41 +0,0 @@
-import {
-  absoluteArrayColumn,
-  absoluteColumn
-} from "./integration-zbqqnp0n.js";
-import {
-  Timestamps
-} from "./integration-sem2g21k.js";
-
-// src/project/sql.ts
-import { isNotNull, isNull, ne, or } from "drizzle-orm";
-import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core";
-var ProjectTable = sqliteTable("project", {
-  id: text().$type().primaryKey(),
-  worktree: absoluteColumn().notNull(),
-  vcs: text().$type(),
-  name: text(),
-  icon_url: text(),
-  icon_url_override: text(),
-  icon_color: text(),
-  ...Timestamps,
-  time_initialized: integer(),
-  sandboxes: absoluteArrayColumn().notNull(),
-  commands: text({ mode: "json" }).$type()
-});
-var ProjectDirectoryTable = sqliteTable("project_directory", {
-  project_id: text().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
-  directory: absoluteColumn().notNull(),
-  type: text().$type(),
-  strategy: text(),
-  time_created: integer().notNull().$default(() => Date.now())
-}, (table) => [primaryKey({ columns: [table.project_id, table.directory] })]);
-function upsertProject(db, project) {
-  const vcs = project.vcs?.type;
-  return db.insert(ProjectTable).values({ id: project.id, worktree: project.canonical, vcs, sandboxes: [] }).onConflictDoUpdate({
-    target: ProjectTable.id,
-    set: { vcs: vcs ?? null },
-    setWhere: vcs ? or(isNull(ProjectTable.vcs), ne(ProjectTable.vcs, vcs)) : isNotNull(ProjectTable.vcs)
-  }).run();
-}
-
-export { ProjectTable, ProjectDirectoryTable, upsertProject };

package/dist/chunks/integration-ca1srhmr.js

@@ -1,151 +0,0 @@
-import {
-  CredentialTable
-} from "./integration-mf0hyk7z.js";
-import {
-  exports_bus
-} from "./integration-hf9h67zk.js";
-import {
-  exports_database
-} from "./integration-3dyzk5zr.js";
-import {
-  __export
-} from "./integration-vpjkya7h.js";
-
-// src/credential.ts
-var exports_credential = {};
-__export(exports_credential, {
-  Credential: () => exports_credential,
-  Event: () => Event,
-  ID: () => ID,
-  Info: () => Info,
-  Key: () => Key,
-  OAuth: () => OAuth,
-  Service: () => Service,
-  Value: () => Value,
-  node: () => node
-});
-import { asc, desc, eq } from "drizzle-orm";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Credential } from "@opencode-ai/schema/credential";
-import { Integration } from "@opencode-ai/schema/integration";
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
-var ID = Credential.ID;
-var OAuth = Credential.OAuth;
-var Key = Credential.Key;
-var Value = Credential.Value;
-var Event = Credential.Event;
-
-class Info extends Schema.Class("Credential.Info")({
-  id: ID,
-  integrationID: Integration.ID,
-  label: Schema.String,
-  value: Value
-}) {
-}
-
-class Service extends Context.Service()("@opencode/Credential") {
-}
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const db = (yield* exports_database.Service).db;
-  const bus = yield* exports_bus.Service;
-  const decode = Schema.decodeUnknownSync(Value);
-  const stored = (row) => {
-    if (!row.integration_id)
-      return;
-    return new Info({
-      id: row.id,
-      integrationID: row.integration_id,
-      label: row.label,
-      value: decode(row.value)
-    });
-  };
-  const storedRows = (rows) => rows.flatMap((row) => {
-    const credential = stored(row);
-    return credential ? [credential] : [];
-  });
-  return Service.of({
-    all: Effect.fn("Credential.all")(() => db.select().from(CredentialTable).orderBy(asc(CredentialTable.active), asc(CredentialTable.time_created), asc(CredentialTable.id)).all().pipe(Effect.orDie, Effect.map(storedRows))),
-    list: Effect.fn("Credential.list")((integrationID) => db.select().from(CredentialTable).where(eq(CredentialTable.integration_id, integrationID)).orderBy(asc(CredentialTable.active), asc(CredentialTable.time_created), asc(CredentialTable.id)).all().pipe(Effect.orDie, Effect.map(storedRows))),
-    get: Effect.fn("Credential.get")(function* (id) {
-      const row = yield* db.select().from(CredentialTable).where(eq(CredentialTable.id, id)).get().pipe(Effect.orDie);
-      return row ? stored(row) : undefined;
-    }),
-    create: Effect.fn("Credential.create")(function* (input) {
-      const credential = new Info({
-        id: ID.create(),
-        integrationID: input.integrationID,
-        label: input.label ?? "default",
-        value: input.value
-      });
-      yield* db.transaction((tx) => Effect.gen(function* () {
-        yield* tx.update(CredentialTable).set({ active: false }).where(eq(CredentialTable.integration_id, credential.integrationID)).run();
-        yield* tx.insert(CredentialTable).values({
-          id: credential.id,
-          integration_id: credential.integrationID,
-          label: credential.label,
-          value: credential.value,
-          active: true
-        }).run();
-      })).pipe(Effect.orDie);
-      yield* bus.publish(Event.Updated, {}, { global: true });
-      yield* bus.publish(Event.Switched, { integrationID: credential.integrationID, credentialID: credential.id }, { global: true });
-      return credential;
-    }),
-    activate: Effect.fn("Credential.activate")(function* (id) {
-      const integrationID = yield* db.transaction((tx) => Effect.gen(function* () {
-        const credential = yield* tx.select().from(CredentialTable).where(eq(CredentialTable.id, id)).get();
-        if (!credential?.integration_id)
-          return;
-        const active = yield* tx.select({ id: CredentialTable.id }).from(CredentialTable).where(eq(CredentialTable.integration_id, credential.integration_id)).orderBy(desc(CredentialTable.active), desc(CredentialTable.time_created), desc(CredentialTable.id)).get();
-        if (active?.id === id)
-          return;
-        yield* tx.update(CredentialTable).set({ active: false }).where(eq(CredentialTable.integration_id, credential.integration_id)).run();
-        yield* tx.update(CredentialTable).set({ active: true }).where(eq(CredentialTable.id, id)).run();
-        return credential.integration_id;
-      })).pipe(Effect.orDie);
-      if (integrationID)
-        yield* bus.publish(Event.Switched, { integrationID, credentialID: id }, { global: true });
-    }),
-    update: Effect.fn("Credential.update")(function* (id, updates) {
-      if (updates.label === undefined && updates.value === undefined)
-        return;
-      const credential = yield* db.select({ integrationID: CredentialTable.integration_id, label: CredentialTable.label }).from(CredentialTable).where(eq(CredentialTable.id, id)).get().pipe(Effect.orDie);
-      if (!credential?.integrationID)
-        return;
-      if (updates.label === credential.label && updates.value === undefined)
-        return;
-      yield* db.update(CredentialTable).set({ label: updates.label, value: updates.value }).where(eq(CredentialTable.id, id)).run().pipe(Effect.orDie);
-      if (updates.label !== undefined && updates.label !== credential.label)
-        yield* bus.publish(Event.Updated, {}, { global: true });
-    }),
-    remove: Effect.fn("Credential.remove")(function* (id) {
-      const removed = yield* db.transaction((tx) => Effect.gen(function* () {
-        const credential = yield* tx.select().from(CredentialTable).where(eq(CredentialTable.id, id)).get();
-        if (!credential)
-          return;
-        const active = credential.integration_id ? yield* tx.select({ id: CredentialTable.id }).from(CredentialTable).where(eq(CredentialTable.integration_id, credential.integration_id)).orderBy(desc(CredentialTable.active), desc(CredentialTable.time_created), desc(CredentialTable.id)).get() : undefined;
-        yield* tx.delete(CredentialTable).where(eq(CredentialTable.id, id)).run();
-        if (!credential.integration_id || active?.id !== id)
-          return { switched: false };
-        const replacement = yield* tx.select({ id: CredentialTable.id }).from(CredentialTable).where(eq(CredentialTable.integration_id, credential.integration_id)).orderBy(desc(CredentialTable.time_created), desc(CredentialTable.id)).get();
-        if (replacement) {
-          yield* tx.update(CredentialTable).set({ active: false }).where(eq(CredentialTable.integration_id, credential.integration_id)).run();
-          yield* tx.update(CredentialTable).set({ active: true }).where(eq(CredentialTable.id, replacement.id)).run();
-        }
-        return {
-          switched: true,
-          integrationID: credential.integration_id,
-          credentialID: replacement?.id ?? null
-        };
-      })).pipe(Effect.orDie);
-      if (!removed)
-        return;
-      yield* bus.publish(Event.Updated, {}, { global: true });
-      if (removed.switched)
-        yield* bus.publish(Event.Switched, { integrationID: removed.integrationID, credentialID: removed.credentialID }, { global: true });
-    })
-  });
-}));
-var node = makeGlobalNode({ service: Service, layer, deps: [exports_database.node, exports_bus.node] });
-
-export { ID, OAuth, Key, Value, Event, Info, Service, node, exports_credential };

package/dist/chunks/integration-d0etdfwn.js

@@ -1,24 +0,0 @@
-import {
-  exports_catalog
-} from "./integration-vdx3d7hy.js";
-import {
-  exports_config
-} from "./integration-q3j0tvwr.js";
-import {
-  exports_provider
-} from "./integration-68yag814.js";
-
-// src/plugin/provider/configured.ts
-import { Effect, Option } from "effect";
-var configuredSettings = Effect.fn("ProviderPlugin.configuredSettings")(function* (id) {
-  const catalog = yield* exports_catalog.Service;
-  const current = (yield* catalog.provider.get(id))?.settings;
-  const service = yield* Effect.serviceOption(exports_config.Service);
-  const entries = Option.isSome(service) ? yield* service.value.entries() : [];
-  return foldSettings(entries, id, current);
-});
-function foldSettings(entries, id, initial) {
-  return entries.filter((entry) => entry.type === "document").reduce((settings, entry) => exports_provider.mergeOverlay(settings, entry.info.providers?.[id]?.settings), initial);
-}
-
-export { configuredSettings, foldSettings };

package/dist/chunks/integration-d6yxznb3.js

@@ -1,173 +0,0 @@
-import {
-  exports_projector
-} from "./integration-a2y4sq9c.js";
-import {
-  exports_execution
-} from "./integration-nh84sznz.js";
-import {
-  exports_runner
-} from "./integration-0rz7yd7x.js";
-import {
-  exports_inbox
-} from "./integration-d9nzfyee.js";
-import {
-  exports_service
-} from "./integration-6bxzghb6.js";
-import {
-  exports_store
-} from "./integration-jwp0b78z.js";
-import {
-  NotFoundError
-} from "./integration-2sqw2jjm.js";
-import {
-  SessionMessage
-} from "./integration-8rpfd2h6.js";
-import {
-  SessionEvent
-} from "./integration-a83yvq99.js";
-import {
-  exports_location_service_map
-} from "./integration-nr60j8n8.js";
-import {
-  exports_location
-} from "./integration-gpa7n6yh.js";
-import {
-  exports_project
-} from "./integration-a7rjzrqs.js";
-import {
-  AbsolutePath,
-  RelativePath
-} from "./integration-j07kk359.js";
-import {
-  exports_bus
-} from "./integration-hf9h67zk.js";
-import {
-  exports_database
-} from "./integration-3dyzk5zr.js";
-import {
-  __export
-} from "./integration-vpjkya7h.js";
-
-// src/session/move.ts
-var exports_move = {};
-__export(exports_move, {
-  DestinationNotDirectoryError: () => DestinationNotDirectoryError,
-  DestinationNotFoundError: () => DestinationNotFoundError,
-  DestinationUnavailableError: () => DestinationUnavailableError,
-  Service: () => Service,
-  SessionMove: () => exports_move,
-  node: () => node
-});
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
-import { FSUtil } from "@opencode-ai/util/fs-util";
-import { Global } from "@opencode-ai/util/global";
-import { Cause, Context, Effect, Layer, Schema } from "effect";
-import path from "path";
-class DestinationNotFoundError extends Schema.TaggedError()("Session.DestinationNotFoundError", { directory: AbsolutePath }) {
-}
-
-class DestinationNotDirectoryError extends Schema.TaggedError()("Session.DestinationNotDirectoryError", { directory: AbsolutePath }) {
-}
-
-class DestinationUnavailableError extends Schema.TaggedError()("Session.DestinationUnavailableError", { directory: AbsolutePath }) {
-}
-
-class Service extends Context.Service()("@opencode/SessionMove") {
-}
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const fs = yield* FSUtil.Service;
-  const global = yield* Global.Service;
-  const projects = yield* exports_project.Service;
-  const locations = yield* exports_location_service_map.Service;
-  const store = yield* exports_store.Service;
-  const execution = yield* exports_execution.Service;
-  const instances = yield* exports_service.Service;
-  const admission = yield* exports_inbox.Service;
-  const database = yield* exports_database.Service;
-  const bus = yield* exports_bus.Service;
-  const get = Effect.fn("SessionMove.get")(function* (sessionID) {
-    const session = yield* store.get(sessionID);
-    if (!session)
-      return yield* new NotFoundError({ sessionID });
-    return session;
-  });
-  const resolveDestination = Effect.fn("SessionMove.resolveDestination")(function* (session, input) {
-    const value = input.directory.trim();
-    const expanded = value === "~" ? global.home : value.startsWith("~/") ? path.join(global.home, value.slice(2)) : value;
-    const directory = AbsolutePath.make(path.resolve(session.location.directory, expanded));
-    const info = yield* fs.stat(directory).pipe(Effect.orElseSucceed(() => {
-      return;
-    }));
-    if (!info)
-      return yield* new DestinationNotFoundError({ directory });
-    if (info.type !== "Directory")
-      return yield* new DestinationNotDirectoryError({ directory });
-    const project = yield* projects.resolve(directory);
-    const destination = {
-      location: exports_location.Ref.make({ directory, workspaceID: input.workspaceID }),
-      projectID: project.id,
-      subpath: RelativePath.make(path.relative(project.directory, directory).replaceAll("\\", "/"))
-    };
-    yield* locations.contextEffect(destination.location).pipe(Effect.scoped, Effect.catchCause((cause) => {
-      if (Cause.hasInterruptsOnly(cause))
-        return Effect.failCause(cause);
-      return Effect.logWarning("session move destination unavailable", { directory, cause }).pipe(Effect.andThen(Effect.fail(new DestinationUnavailableError({ directory }))));
-    }));
-    return destination;
-  });
-  const sourceUnavailable = Effect.fn("SessionMove.sourceUnavailable")(function* (session) {
-    if (yield* execution.isActive(session.id))
-      return false;
-    if (!(yield* fs.isDir(session.location.directory)))
-      return true;
-    return yield* exports_runner.Service.pipe(instances.provide(session), Effect.as(false), Effect.catchCause((cause) => Cause.hasInterrupts(cause) ? Effect.failCause(cause) : Effect.succeed(true)));
-  });
-  return Service.of({
-    move: Effect.fn("SessionMove.move")(function* (input) {
-      const session = yield* get(input.sessionID);
-      const destination = yield* resolveDestination(session, input);
-      const unavailable = yield* sourceUnavailable(session);
-      const item = exports_inbox.Item.make({
-        type: "move",
-        payload: destination,
-        delivery: input.delivery ?? "steer"
-      });
-      yield* exports_inbox.serialized(input.sessionID, Effect.gen(function* () {
-        const latest = yield* get(input.sessionID);
-        if (unavailable && latest.location.directory === session.location.directory && latest.location.workspaceID === session.location.workspaceID && !(yield* execution.isActive(input.sessionID))) {
-          const cancellations = (yield* exports_inbox.moveIDs(database.db, input.sessionID)).map((item2) => [SessionEvent.InboxCancelled, { sessionID: input.sessionID, inboxID: item2.id }]);
-          const moved = [SessionEvent.Moved, { sessionID: input.sessionID, ...destination }];
-          const first = cancellations[0];
-          if (!first)
-            return yield* bus.publish(...moved).pipe(Effect.asVoid);
-          return yield* bus.publishAll([first, ...cancellations.slice(1), moved]);
-        }
-        yield* admission.admit({
-          id: SessionMessage.ID.create(),
-          sessionID: input.sessionID,
-          item
-        }).pipe(Effect.orDie);
-      }));
-      yield* execution.wake(input.sessionID);
-    })
-  });
-}));
-var node = makeGlobalNode({
-  service: Service,
-  layer,
-  deps: [
-    FSUtil.node,
-    Global.node,
-    exports_project.node,
-    exports_location_service_map.node,
-    exports_store.node,
-    exports_execution.node,
-    exports_service.node,
-    exports_inbox.node,
-    exports_database.node,
-    exports_bus.node,
-    exports_projector.node
-  ]
-});
-
-export { DestinationNotFoundError, DestinationNotDirectoryError, DestinationUnavailableError, Service, node, exports_move };