@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-kv6vp4m3.js

@@ -0,0 +1,72 @@
+import {
+  exports_config
+} from "./location-mutation-qvf5nvg0.js";
+import {
+  exports_watcher
+} from "./location-mutation-k6vwd7kr.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  exports_git
+} from "./location-mutation-kcwh27nh.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/filesystem/location-watcher.ts
+var exports_location_watcher = {};
+__export(exports_location_watcher, {
+  node: () => node,
+  Service: () => Service,
+  LocationWatcher: () => exports_location_watcher
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Stream } from "effect";
+import { FileSystem } from "@opencode-ai/schema/filesystem";
+import path from "path";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+class Service extends Context.Service()("@opencode/LocationWatcher") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const location = yield* exports_location.Service;
+  const watcher = yield* exports_watcher.Service;
+  const bus = yield* exports_bus.Service;
+  const fs = yield* FSUtil.Service;
+  const git = yield* exports_git.Service;
+  const configService = yield* exports_config.Service;
+  const publish = (update) => bus.publish(FileSystem.Event.Changed, {
+    file: update.path,
+    event: update.type === "create" ? "add" : update.type === "update" ? "change" : "unlink"
+  });
+  yield* Effect.gen(function* () {
+    const config = (yield* configService.entries()).filter((entry) => entry.type === "document").flatMap((item) => item.info.watcher?.ignore ?? []);
+    if (location.vcs?.type === "git") {
+      const resolved = (yield* git.repo.discover(location.directory))?.gitDirectory;
+      const vcs = resolved ? yield* fs.realPath(resolved).pipe(Effect.catch(() => Effect.succeed(resolved))) : undefined;
+      if (vcs && !config.includes(".git") && !config.includes(vcs) && (!resolved || !config.includes(resolved))) {
+        const updates = yield* watcher.subscribe({ path: path.join(vcs, "HEAD"), type: "file" });
+        yield* updates.pipe(Stream.runForEach(publish), Effect.forkScoped);
+      }
+    }
+    if (location.vcs?.type === "hg") {
+      const store = location.vcs.store;
+      const vcs = yield* fs.realPath(store).pipe(Effect.catch(() => Effect.succeed(store)));
+      if (!config.includes(".hg") && !config.includes(vcs)) {
+        const updates = yield* watcher.subscribe({ path: path.join(vcs, "branch"), type: "file" });
+        yield* updates.pipe(Stream.runForEach(publish), Effect.forkScoped);
+      }
+    }
+  }).pipe(Effect.withSpan("LocationWatcher.start", { attributes: { directory: location.directory } }), Effect.catchCause((cause) => Effect.logError("failed to init location watcher service", { cause })), Effect.forkScoped);
+  return Service.of({});
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_watcher.node, FSUtil.node, exports_location.node, exports_config.node, exports_git.node, exports_bus.node]
+});
+
+export { Service, node, exports_location_watcher };

package/dist/chunks/location-mutation-kxy11nzk.js

@@ -0,0 +1,24 @@
+// src/database/migration/20260602002951_lowly_union_jack.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260602002951_lowly_union_jack",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`permission\` (
+          \`id\` text PRIMARY KEY,
+          \`project_id\` text NOT NULL,
+          \`action\` text NOT NULL,
+          \`resource\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          CONSTRAINT \`fk_permission_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`CREATE UNIQUE INDEX \`permission_project_action_resource_idx\` ON \`permission\` (\`project_id\`,\`action\`,\`resource\`);`);
+    });
+  }
+};
+var _20260602002951_lowly_union_jack_default = migration;
+
+export { _20260602002951_lowly_union_jack_default };

package/dist/chunks/location-mutation-ky3veh2c.js

@@ -0,0 +1,86 @@
+import {
+  exports_git
+} from "./location-mutation-rt6yg6j2.js";
+import {
+  exports_hg
+} from "./location-mutation-ph1me6ah.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/vcs.ts
+var exports_vcs = {};
+__export(exports_vcs, {
+  node: () => node,
+  Vcs: () => exports_vcs,
+  Service: () => Service,
+  Mode: () => Mode,
+  Info: () => Info,
+  FileStatus: () => FileStatus
+});
+import path from "path";
+import { Context, Effect, Layer, Stream } from "effect";
+import { FileSystem } from "@opencode-ai/schema/filesystem";
+import { FileStatus, Info, Mode } from "@opencode-ai/schema/vcs";
+import { VcsEvent } from "@opencode-ai/schema/vcs-event";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { AppProcess } from "@opencode-ai/util/process";
+class Service extends Context.Service()("@opencode/Vcs") {
+}
+var adapter = (proc, fs, location) => {
+  const scope = { directory: location.directory, worktree: location.project.directory };
+  if (location.vcs?.type === "git")
+    return exports_git.make(proc, scope);
+  if (location.vcs?.type === "hg")
+    return exports_hg.make(proc, fs, scope);
+};
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const proc = yield* AppProcess.Service;
+  const fs = yield* FSUtil.Service;
+  const location = yield* exports_location.Service;
+  const bus = yield* exports_bus.Service;
+  const impl = adapter(proc, fs, location);
+  const vcs = location.vcs;
+  const state = { info: impl ? yield* impl.info() : { branch: {} } };
+  if (vcs && impl) {
+    const store = yield* fs.realPath(vcs.store).pipe(Effect.catch(() => Effect.succeed(vcs.store)));
+    const isBranchMetadata = vcs.type === "git" ? (file) => path.basename(file) === "HEAD" && FSUtil.contains(store, file) : (file) => path.resolve(file) === path.join(store, "branch");
+    yield* bus.subscribe(FileSystem.Event.Changed).pipe(Stream.filter((event) => isBranchMetadata(event.data.file)), Stream.runForEach((event) => Effect.gen(function* () {
+      const next = yield* impl.info();
+      const changed = state.info.branch.current !== next.branch.current;
+      state.info = next;
+      if (!changed)
+        return;
+      yield* bus.publish(VcsEvent.BranchUpdated, { branch: next.branch.current });
+    }).pipe(Effect.withSpan("Vcs.refreshBranch", { attributes: { file: event.data.file } }))), Effect.forkScoped({ startImmediately: true }));
+  }
+  return Service.of({
+    info: Effect.fn("Vcs.info")(function* () {
+      return state.info;
+    }),
+    status: Effect.fn("Vcs.status")(function* () {
+      if (!impl)
+        return [];
+      return yield* impl.status();
+    }),
+    diff: Effect.fn("Vcs.diff")(function* (mode, options) {
+      if (!impl)
+        return [];
+      return yield* impl.diff(mode, options);
+    })
+  });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [AppProcess.node, FSUtil.node, exports_location.node, exports_bus.node]
+});
+
+export { FileStatus, Info, Mode, Service, node, exports_vcs };

package/dist/chunks/location-mutation-kyyqvx4s.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260811161259_execution_claim_attempts.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260811161259_execution_claim_attempts",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session_v2\` ADD \`resume_attempts\` integer DEFAULT 0 NOT NULL;`);
+    });
+  }
+};
+var _20260811161259_execution_claim_attempts_default = migration;
+
+export { _20260811161259_execution_claim_attempts_default };

package/dist/chunks/location-mutation-m5sbqbmy.js

@@ -0,0 +1,117 @@
+import {
+  exports_tool
+} from "./location-mutation-yyhat9md.js";
+import {
+  exports_mcp
+} from "./location-mutation-ztvvzzvv.js";
+import {
+  exports_permission
+} from "./location-mutation-gjaba53s.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/tool/mcp.ts
+var exports_mcp2 = {};
+__export(exports_mcp2, {
+  node: () => node,
+  namespace: () => namespace,
+  name: () => name,
+  layer: () => layer,
+  Service: () => Service,
+  McpTool: () => exports_mcp2
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { McpEvent } from "@opencode-ai/schema/mcp-event";
+import { Context, Effect, Exit, Fiber, Layer, Scope, Semaphore, Stream } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+var namespace = (server) => server.replace(/[^a-zA-Z0-9_-]/g, "_");
+var name = (server, tool) => `${namespace(server)}_${tool.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+
+class Service extends Context.Service()("@opencode/McpTool") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const mcp = yield* exports_mcp.Service;
+  const tools = yield* exports_tool.Service;
+  const bus = yield* exports_bus.Service;
+  const permission = yield* exports_permission.Service;
+  const scope = yield* Scope.Scope;
+  const lock = Semaphore.makeUnsafe(1);
+  let current;
+  const reconcile = lock.withPermit(Effect.gen(function* () {
+    const discovered = yield* mcp.tools();
+    const next = yield* Scope.fork(scope);
+    yield* tools.transform((draft) => {
+      for (const tool of discovered) {
+        const schema = tool.inputSchema ?? {};
+        draft.add({
+          name: tool.name,
+          options: { namespace: namespace(tool.server), codemode: tool.codemode !== false },
+          description: tool.description ?? "",
+          input: {
+            ...schema,
+            type: "object",
+            properties: schema.properties ?? {},
+            additionalProperties: false
+          },
+          output: tool.outputSchema ?? {},
+          execute: (input, context) => Effect.gen(function* () {
+            yield* permission.assert({
+              action: name(tool.server, tool.name),
+              resources: ["*"],
+              save: ["*"],
+              metadata: {},
+              sessionID: context.sessionID,
+              agent: context.agent,
+              source: {
+                type: "tool",
+                messageID: context.messageID,
+                id: context.id
+              }
+            });
+            const result = yield* mcp.callTool({
+              server: tool.server,
+              name: tool.name,
+              args: input ?? {}
+            }).pipe(Effect.catchTags({
+              "MCP.NotFoundError": (error) => new ToolFailure({ message: `MCP server "${error.server}" is not available` }),
+              "MCP.ToolCallError": (error) => new ToolFailure({ message: error.message })
+            }));
+            if (result.isError)
+              return yield* new ToolFailure({
+                message: result.content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+`).trim() || "MCP tool returned an error"
+              });
+            const content = result.content.map((part) => part.type === "text" ? { type: "text", text: part.text } : {
+              type: "file",
+              uri: `data:${part.mimeType};base64,${part.data}`,
+              mime: part.mimeType
+            });
+            const text = content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+`);
+            return {
+              output: result.structured ?? (text === "" ? null : text),
+              ...content.length === 0 ? {} : { content }
+            };
+          }).pipe(Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to execute ${name(tool.server, tool.name)}` })))
+        });
+      }
+    }).pipe(Scope.provide(next), Effect.orDie);
+    if (current)
+      yield* Scope.close(current, Exit.void);
+    current = next;
+  }));
+  const initial = yield* reconcile.pipe(Effect.forkScoped);
+  yield* bus.subscribe(McpEvent.ToolsChanged).pipe(Stream.runForEach(() => reconcile), Effect.forkScoped({ startImmediately: true }));
+  return Service.of({ flush: Effect.asVoid(Fiber.await(initial)) });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_tool.node, exports_mcp.node, exports_bus.node, exports_permission.node]
+});
+
+export { namespace, name, Service, layer, node, exports_mcp2 as exports_mcp };

package/dist/chunks/location-mutation-m8cbvarh.js

@@ -0,0 +1,19 @@
+// src/github-copilot/responses/map-openai-responses-finish-reason.ts
+function mapOpenAIResponseFinishReason({
+  finishReason,
+  hasFunctionCall
+}) {
+  switch (finishReason) {
+    case undefined:
+    case null:
+      return hasFunctionCall ? "tool-calls" : "stop";
+    case "max_output_tokens":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    default:
+      return hasFunctionCall ? "tool-calls" : "other";
+  }
+}
+
+export { mapOpenAIResponseFinishReason };

package/dist/chunks/location-mutation-ma07p6tt.js

@@ -0,0 +1,83 @@
+// src/database/drizzle/internal/drizzle-utils.ts
+import { Column, getColumnTable } from "drizzle-orm/column";
+import { is } from "drizzle-orm/entity";
+import { Param, SQL } from "drizzle-orm/sql/sql";
+import { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base";
+import { Subquery } from "drizzle-orm/subquery";
+import { Table, getTableName } from "drizzle-orm/table";
+import { ViewBaseConfig } from "drizzle-orm/view-common";
+var TableSymbol = Table.Symbol;
+function getTableColumnsRuntime(table) {
+  return table[TableSymbol.Columns];
+}
+function getViewSelectedFieldsRuntime(view) {
+  return view[ViewBaseConfig];
+}
+function jitCompatCheck(isEnabled) {
+  if (!isEnabled)
+    return false;
+  try {
+    return new Function("input", '"use strict"; return input;')(true) === true;
+  } catch {
+    return false;
+  }
+}
+function orderSelectedFields(fields, pathPrefix) {
+  return Object.entries(fields).flatMap(([name, field]) => {
+    const path = pathPrefix ? [...pathPrefix, name] : [name];
+    if (is(field, Column) || is(field, SQL) || is(field, SQL.Aliased) || is(field, Subquery)) {
+      return [{ path, field }];
+    }
+    if (is(field, Table))
+      return orderSelectedFields(getTableColumnsRuntime(field), path);
+    return orderSelectedFields(field, path);
+  });
+}
+function mapUpdateSet(table, values) {
+  const entries = Object.entries(values).filter(([, value]) => value !== undefined);
+  if (entries.length === 0)
+    throw new Error("No values to set");
+  return Object.fromEntries(entries.map(([key, value]) => [
+    key,
+    is(value, SQL) || is(value, Column) ? value : new Param(value, getTableColumnsRuntime(table)[key])
+  ]));
+}
+function mapResultRow(columns, row, joinsNotNullableMap) {
+  const nullifyMap = {};
+  const result = {};
+  columns.forEach((column, columnIndex) => {
+    const decoder = is(column.field, Column) ? column.field : is(column.field, SQL) ? column.field.decoder : is(column.field, Subquery) ? column.field._.sql.decoder : column.field.sql.decoder;
+    const rawValue = row[columnIndex];
+    const value = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
+    const objectName = column.path[0];
+    let node = result;
+    column.path.forEach((pathChunk, pathChunkIndex) => {
+      if (pathChunkIndex === column.path.length - 1) {
+        node[pathChunk] = value;
+        return;
+      }
+      node[pathChunk] = node[pathChunk] ?? {};
+      node = node[pathChunk];
+    });
+    if (joinsNotNullableMap && is(column.field, Column) && column.path.length === 2 && objectName) {
+      const tableName = getTableName(getColumnTable(column.field));
+      nullifyMap[objectName] = !(objectName in nullifyMap) && value === null ? tableName : typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== tableName ? false : nullifyMap[objectName];
+    }
+  });
+  Object.entries(nullifyMap).forEach(([objectName, tableName]) => {
+    if (typeof tableName === "string" && !joinsNotNullableMap?.[tableName])
+      result[objectName] = null;
+  });
+  return result;
+}
+function getTableLikeName(table) {
+  if (is(table, Subquery))
+    return table._.alias;
+  if (is(table, SQLiteViewBase))
+    return getViewSelectedFieldsRuntime(table).name;
+  if (is(table, SQL))
+    return;
+  return table[table[TableSymbol.IsAlias] ? TableSymbol.Name : TableSymbol.BaseName];
+}
+
+export { getTableColumnsRuntime, getViewSelectedFieldsRuntime, jitCompatCheck, orderSelectedFields, mapUpdateSet, mapResultRow, getTableLikeName };

package/dist/chunks/location-mutation-ma60vzgv.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260504145000_add_sync_owner.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260504145000_add_sync_owner",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`event_sequence\` ADD \`owner_id\` text;`);
+    });
+  }
+};
+var _20260504145000_add_sync_owner_default = migration;
+
+export { _20260504145000_add_sync_owner_default };

package/dist/chunks/location-mutation-mf0hyk7z.js

@@ -0,0 +1,18 @@
+import {
+  Timestamps
+} from "./location-mutation-sem2g21k.js";
+
+// src/credential/sql.ts
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+var CredentialTable = sqliteTable("credential", {
+  id: text().$type().primaryKey(),
+  integration_id: text().$type(),
+  label: text().notNull(),
+  value: text({ mode: "json" }).$type().notNull(),
+  connector_id: text(),
+  method_id: text(),
+  active: integer({ mode: "boolean" }),
+  ...Timestamps
+});
+
+export { CredentialTable };