@opencode-ai/core 0.0.0-dev-17471

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

@@ -0,0 +1,83 @@
+import {
+  exports_app
+} from "./location-mutation-50jxp3hw.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/websearch/tavily.ts
+var exports_tavily = {};
+__export(exports_tavily, {
+  endpoint: () => endpoint,
+  WebSearchTavily: () => exports_tavily,
+  Plugin: () => Plugin
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Duration, Effect, Schema } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+var endpoint = "https://api.tavily.com/search";
+var SearchRequest = Schema.Struct({
+  query: Schema.String,
+  search_depth: Schema.Literal("basic"),
+  chunks_per_source: Schema.Number,
+  max_results: Schema.Number
+});
+var SearchResponse = Schema.Struct({
+  results: Schema.Array(Schema.Struct({
+    title: Schema.String,
+    url: Schema.String,
+    content: Schema.String
+  }))
+});
+var Plugin = define({
+  id: "opencode.websearch.tavily",
+  effect: Effect.fn("WebSearchTavily.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient;
+    yield* ctx.integration.transform((draft) => {
+      draft.update("tavily", (integration) => integration.name = "Tavily");
+      draft.method.update({
+        integrationID: "tavily",
+        method: { type: "key" }
+      });
+      draft.method.update({
+        integrationID: "tavily",
+        method: { type: "env", names: ["TAVILY_API_KEY"] }
+      });
+    });
+    yield* ctx.websearch.transform((draft) => {
+      draft.add({
+        id: "tavily",
+        name: "Tavily",
+        execute: (input) => Effect.gen(function* () {
+          const connection = yield* ctx.integration.connection.active("tavily");
+          const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined;
+          const request = yield* HttpClientRequest.post(endpoint).pipe(HttpClientRequest.acceptJson, HttpClientRequest.setHeaders({
+            "User-Agent": exports_app.useragent(ctx.app),
+            "X-Client-Name": "opencode2",
+            ...credential?.type === "key" ? { Authorization: `Bearer ${credential.key}` } : { "X-Tavily-Access-Mode": "keyless" }
+          }), HttpClientRequest.schemaBodyJson(SearchRequest)({
+            query: input.query,
+            search_depth: "basic",
+            chunks_per_source: 3,
+            max_results: 8
+          }));
+          const response = yield* Effect.gen(function* () {
+            const httpResponse = yield* HttpClient.filterStatusOk(http).execute(request);
+            return yield* HttpClientResponse.schemaBodyJson(SearchResponse)(httpResponse);
+          }).pipe(Effect.timeoutOrElse({
+            duration: Duration.seconds(25),
+            orElse: () => Effect.fail(new Error("Tavily web search request timed out"))
+          }));
+          return response.results.map((item) => ({
+            url: item.url,
+            title: item.title,
+            ...item.content ? { content: item.content } : {},
+            time: {}
+          }));
+        })
+      });
+    });
+  })
+});
+
+export { endpoint, Plugin, exports_tavily };

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

@@ -0,0 +1,69 @@
+import {
+  PositiveInt
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/v1/config/mcp.ts
+var exports_mcp = {};
+__export(exports_mcp, {
+  Remote: () => Remote,
+  OAuth: () => OAuth,
+  Local: () => Local,
+  Info: () => Info,
+  ConfigMCPV1: () => exports_mcp
+});
+import { Schema } from "effect";
+var Local = Schema.Struct({
+  type: Schema.Literal("local").annotate({ description: "Type of MCP server connection" }),
+  command: Schema.mutable(Schema.Array(Schema.String)).annotate({
+    description: "Command and arguments to run the MCP server"
+  }),
+  cwd: Schema.optional(Schema.String).annotate({
+    description: "Working directory for the MCP server process. Relative paths resolve from the workspace directory."
+  }),
+  environment: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
+    description: "Environment variables to set when running the MCP server"
+  }),
+  enabled: Schema.optional(Schema.Boolean).annotate({
+    description: "Enable or disable the MCP server on startup"
+  }),
+  timeout: Schema.optional(PositiveInt).annotate({
+    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified."
+  })
+}).annotate({ identifier: "McpLocalConfig" });
+var OAuth = Schema.Struct({
+  clientId: Schema.optional(Schema.String).annotate({
+    description: "OAuth client ID. If not provided, dynamic client registration (RFC 7591) will be attempted."
+  }),
+  clientSecret: Schema.optional(Schema.String).annotate({
+    description: "OAuth client secret (if required by the authorization server)"
+  }),
+  scope: Schema.optional(Schema.String).annotate({ description: "OAuth scopes to request during authorization" }),
+  callbackPort: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65535 }))).annotate({
+    description: "Port for the local OAuth callback server (default: 19876). Shorthand for redirectUri when only the port needs changing. Ignored if redirectUri is set."
+  }),
+  redirectUri: Schema.optional(Schema.String).annotate({
+    description: "OAuth redirect URI (default: http://127.0.0.1:19876/mcp/oauth/callback)."
+  })
+}).annotate({ identifier: "McpOAuthConfig" });
+var Remote = Schema.Struct({
+  type: Schema.Literal("remote").annotate({ description: "Type of MCP server connection" }),
+  url: Schema.String.annotate({ description: "URL of the remote MCP server" }),
+  enabled: Schema.optional(Schema.Boolean).annotate({
+    description: "Enable or disable the MCP server on startup"
+  }),
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
+    description: "Headers to send with the request"
+  }),
+  oauth: Schema.optional(Schema.Union([OAuth, Schema.Literal(false)])).annotate({
+    description: "OAuth authentication configuration for the MCP server. Set to false to disable OAuth auto-detection."
+  }),
+  timeout: Schema.optional(PositiveInt).annotate({
+    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified."
+  })
+}).annotate({ identifier: "McpRemoteConfig" });
+var Info = Schema.Union([Local, Remote]).annotate({ discriminator: "type" });
+
+export { Local, OAuth, Remote, Info, exports_mcp };

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

@@ -0,0 +1,147 @@
+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 {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/config/plugin/source.ts
+var exports_source = {};
+__export(exports_source, {
+  node: () => node,
+  layer: () => layer,
+  empty: () => empty,
+  Service: () => Service,
+  ConfigPluginSource: () => exports_source
+});
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Option, Predicate, PubSub, Schema, Stream } from "effect";
+import path from "path";
+import { fileURLToPath } from "url";
+class Service extends Context.Service()("@opencode/ConfigPluginSource") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const config = yield* exports_config.Service;
+  const watcher = yield* exports_watcher.Service;
+  const fs = yield* FSUtil.Service;
+  const location = yield* exports_location.Service;
+  const configuredChanges = yield* PubSub.unbounded();
+  const watched = new Set;
+  const watchConfiguredSources = Effect.fn("ConfigPluginSource.watchConfiguredSources")(function* (entries, operations) {
+    for (const operation of operations) {
+      if (operation.type !== "add" || !path.isAbsolute(operation.target))
+        continue;
+      if (watched.has(operation.target))
+        continue;
+      if (isPluginSource(entries, operation.target))
+        continue;
+      if (yield* fs.isDir(operation.target))
+        continue;
+      watched.add(operation.target);
+      const updates = yield* watcher.subscribe({ path: operation.target, type: "file" });
+      yield* updates.pipe(Stream.runForEach(() => PubSub.publish(configuredChanges, undefined)), Effect.catchCause((cause) => Effect.logError("configured plugin watch failed", { target: operation.target, cause })), Effect.forkScoped({ startImmediately: true }));
+    }
+  });
+  return Service.of({
+    operations: Effect.fn("ConfigPluginSource.operations")(function* () {
+      const entries = yield* config.entries();
+      const operations = yield* scan(fs, location, entries);
+      yield* watchConfiguredSources(entries, operations);
+      return operations;
+    }),
+    changes: () => Stream.merge(config.changes().pipe(Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isPluginSource(entries, update.path))), Stream.map(() => {
+      return;
+    })), Stream.fromPubSub(configuredChanges))
+  });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_config.node, FSUtil.node, exports_watcher.node, exports_location.node]
+});
+var empty = makeLocationNode({
+  service: Service,
+  layer: Layer.succeed(Service, Service.of({
+    operations: () => Effect.succeed([]),
+    changes: () => Stream.never
+  })),
+  deps: []
+});
+function parse(input) {
+  if (typeof input !== "string") {
+    return { type: "add", target: input.package, options: input.options ?? {} };
+  }
+  if (!input.startsWith("-"))
+    return { type: "add", target: input, options: {} };
+  if (input.length === 1)
+    throw new Error("Plugin remove operation requires a target");
+  return { type: "remove", target: input.slice(1) };
+}
+var scan = Effect.fn("ConfigPluginSource.scan")(function* (fs, location, entries) {
+  const discovered = yield* Effect.forEach(entries.filter((entry) => entry.type === "directory"), (entry) => discoverDirectory(fs, entry.path)).pipe(Effect.map((items) => items.flat()));
+  const configured = entries.filter((entry) => entry.type === "document").flatMap((entry) => (entry.info.plugins ?? []).map(parse).map((operation) => {
+    if (operation.type === "remove")
+      return operation;
+    const directory = entry.path ? path.dirname(entry.path) : location.directory;
+    const target = operation.target.startsWith("file://") ? fileURLToPath(operation.target) : operation.target.startsWith("./") || operation.target.startsWith("../") ? path.resolve(directory, operation.target) : operation.target;
+    return { ...operation, target };
+  }));
+  return yield* Effect.forEach([...discovered, ...configured], (operation) => {
+    if (operation.type === "remove" || !path.isAbsolute(operation.target))
+      return Effect.succeed(operation);
+    return fs.stat(operation.target).pipe(Effect.map((info) => ({
+      ...operation,
+      mtime: Option.getOrElse(info.mtime, () => new Date(0)).getTime()
+    })), Effect.catch(() => Effect.succeed(operation)));
+  });
+});
+var sourceDirectories = ["plugin", "plugins"];
+var Package = Schema.Struct({
+  exports: Schema.optional(Schema.Unknown),
+  module: Schema.optional(Schema.Unknown),
+  main: Schema.optional(Schema.Unknown)
+});
+var decodePackage = Schema.decodeUnknownOption(Package);
+function discoverDirectory(fs, directory) {
+  return Effect.gen(function* () {
+    const children = (yield* Effect.forEach(sourceDirectories, (source) => fs.readDirectoryEntries(path.join(directory, source)).pipe(Effect.orElseSucceed(() => []), Effect.map((entries) => entries.map((entry) => ({ ...entry, target: path.join(directory, source, entry.name) })))))).flat().sort((a, b) => a.target < b.target ? -1 : a.target > b.target ? 1 : 0);
+    const targets = yield* Effect.forEach(children, (entry) => discoverChild(fs, entry));
+    return targets.flatMap(Option.toArray).map((target) => ({ type: "add", target, options: {} }));
+  });
+}
+function discoverChild(fs, entry) {
+  return Effect.gen(function* () {
+    const source = entry.target.endsWith(".ts") || entry.target.endsWith(".js");
+    if (entry.type === "file" && source)
+      return Option.some(entry.target);
+    if (entry.type === "directory")
+      return yield* discoverPackage(fs, entry.target);
+    if (entry.type !== "symlink")
+      return Option.none();
+    if (source && (yield* fs.isFile(entry.target)))
+      return Option.some(entry.target);
+    if (yield* fs.isDir(entry.target))
+      return yield* discoverPackage(fs, entry.target);
+    return Option.none();
+  });
+}
+function discoverPackage(fs, directory) {
+  return Effect.gen(function* () {
+    const root = yield* fs.resolve(directory);
+    const manifest = yield* fs.readJson(path.join(directory, "package.json")).pipe(Effect.map(decodePackage), Effect.orElseSucceed(Option.none));
+    const configured = Option.isSome(manifest) ? [manifest.value.exports, manifest.value.module, manifest.value.main].filter(Predicate.isString) : [];
+    return yield* Effect.findFirst([...configured, "index.ts", "index.js"].filter((entry) => !path.isAbsolute(entry)).map((entry) => path.resolve(directory, entry)).filter((entry) => FSUtil.contains(directory, entry)), (entry) => fs.isFile(entry).pipe(Effect.flatMap((exists) => exists ? fs.resolve(entry).pipe(Effect.map((resolved) => FSUtil.contains(root, resolved))) : Effect.succeed(false))));
+  });
+}
+function isPluginSource(entries, file) {
+  return entries.some((entry) => entry.type === "directory" && sourceDirectories.some((directory) => FSUtil.contains(path.join(entry.path, directory), file)));
+}
+
+export { Service, layer, node, empty, exports_source };

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

@@ -0,0 +1,21 @@
+import {
+  exports_config
+} from "./location-mutation-qvf5nvg0.js";
+import {
+  exports_catalog
+} from "./location-mutation-5gvndtda.js";
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.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 entries.filter((entry) => entry.type === "document").reduce((settings, entry) => exports_provider.mergeOverlay(settings, entry.info.providers?.[id]?.settings), current);
+});
+
+export { configuredSettings };

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

@@ -0,0 +1,258 @@
+// src/database/schema.gen.ts
+import { Effect } from "effect";
+var schema = {
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`account_state\` (
+          \`id\` integer PRIMARY KEY,
+          \`active_account_id\` text,
+          \`active_org_id\` text,
+          CONSTRAINT \`fk_account_state_active_account_id_account_id_fk\` FOREIGN KEY (\`active_account_id\`) REFERENCES \`account\`(\`id\`) ON DELETE SET NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`account\` (
+          \`id\` text PRIMARY KEY,
+          \`email\` text NOT NULL,
+          \`url\` text NOT NULL,
+          \`access_token\` text NOT NULL,
+          \`refresh_token\` text NOT NULL,
+          \`token_expiry\` integer,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`control_account\` (
+          \`email\` text NOT NULL,
+          \`url\` text NOT NULL,
+          \`access_token\` text NOT NULL,
+          \`refresh_token\` text NOT NULL,
+          \`token_expiry\` integer,
+          \`active\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          CONSTRAINT \`control_account_pk\` PRIMARY KEY(\`email\`, \`url\`)
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`credential\` (
+          \`id\` text PRIMARY KEY,
+          \`integration_id\` text,
+          \`label\` text NOT NULL,
+          \`value\` text NOT NULL,
+          \`connector_id\` text,
+          \`method_id\` text,
+          \`active\` integer,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`event_sequence\` (
+          \`aggregate_id\` text PRIMARY KEY,
+          \`seq\` integer NOT NULL,
+          \`owner_id\` text
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`event\` (
+          \`id\` text PRIMARY KEY,
+          \`aggregate_id\` text NOT NULL,
+          \`seq\` integer NOT NULL,
+          \`created\` integer DEFAULT 0 NOT NULL,
+          \`type\` text NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_event_aggregate_id_event_sequence_aggregate_id_fk\` FOREIGN KEY (\`aggregate_id\`) REFERENCES \`event_sequence\`(\`aggregate_id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`kv\` (
+          \`key\` text PRIMARY KEY,
+          \`value\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+      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 TABLE \`project_directory\` (
+          \`project_id\` text NOT NULL,
+          \`directory\` text NOT NULL,
+          \`type\` text,
+          \`strategy\` text,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`project_directory_pk\` PRIMARY KEY(\`project_id\`, \`directory\`),
+          CONSTRAINT \`fk_project_directory_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`project\` (
+          \`id\` text PRIMARY KEY,
+          \`worktree\` text NOT NULL,
+          \`vcs\` text,
+          \`name\` text,
+          \`icon_url\` text,
+          \`icon_url_override\` text,
+          \`icon_color\` text,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`time_initialized\` integer,
+          \`sandboxes\` text NOT NULL,
+          \`commands\` text
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`instruction_blob\` (
+          \`hash\` text PRIMARY KEY,
+          \`value\` text
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`instruction_entry\` (
+          \`session_id\` text NOT NULL,
+          \`key\` text NOT NULL,
+          \`value\` text,
+          \`removed\` integer DEFAULT false NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          CONSTRAINT \`instruction_entry_pk\` PRIMARY KEY(\`session_id\`, \`key\`),
+          CONSTRAINT \`fk_instruction_entry_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`instruction_state\` (
+          \`session_id\` text PRIMARY KEY,
+          \`epoch_start\` integer NOT NULL,
+          \`through_seq\` integer NOT NULL,
+          \`initial_values\` text NOT NULL,
+          \`current_values\` text NOT NULL,
+          CONSTRAINT \`fk_instruction_state_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`session_inbox\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`payload\` text NOT NULL,
+          \`delivery\` text NOT NULL,
+          \`enqueued_seq\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_inbox_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`session_message\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`seq\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_session_message_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`session_pending\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`data\` text NOT NULL,
+          \`delivery\` text,
+          \`admitted_seq\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_pending_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`session_v2\` (
+          \`id\` text PRIMARY KEY,
+          \`project_id\` text NOT NULL,
+          \`workspace_id\` text,
+          \`parent_id\` text,
+          \`fork_session_id\` text,
+          \`fork_boundary\` text,
+          \`slug\` text NOT NULL,
+          \`directory\` text NOT NULL,
+          \`path\` text,
+          \`title\` text,
+          \`version\` text NOT NULL,
+          \`share_url\` text,
+          \`summary_additions\` integer,
+          \`summary_deletions\` integer,
+          \`summary_files\` integer,
+          \`summary_diffs\` text,
+          \`metadata\` text,
+          \`cost\` real DEFAULT 0 NOT NULL,
+          \`tokens_input\` integer DEFAULT 0 NOT NULL,
+          \`tokens_output\` integer DEFAULT 0 NOT NULL,
+          \`tokens_reasoning\` integer DEFAULT 0 NOT NULL,
+          \`tokens_cache_read\` integer DEFAULT 0 NOT NULL,
+          \`tokens_cache_write\` integer DEFAULT 0 NOT NULL,
+          \`revert\` text,
+          \`permission\` text,
+          \`agent\` text,
+          \`model\` text,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`time_compacting\` integer,
+          \`time_archived\` integer,
+          \`time_suspended\` integer,
+          \`resume_attempts\` integer DEFAULT 0 NOT NULL,
+          CONSTRAINT \`fk_session_v2_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`workspace\` (
+          \`id\` text PRIMARY KEY,
+          \`provider\` text NOT NULL,
+          \`binding\` text NOT NULL,
+          \`created_at\` integer NOT NULL,
+          \`last_used_at\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`worktree\` (
+          \`project_id\` text NOT NULL,
+          \`directory\` text NOT NULL,
+          \`strategy\` text,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`worktree_pk\` PRIMARY KEY(\`project_id\`, \`directory\`),
+          CONSTRAINT \`fk_worktree_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`CREATE UNIQUE INDEX \`event_aggregate_seq_idx\` ON \`event\` (\`aggregate_id\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX \`event_aggregate_type_seq_idx\` ON \`event\` (\`aggregate_id\`,\`type\`,\`seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`permission_project_action_resource_idx\` ON \`permission\` (\`project_id\`,\`action\`,\`resource\`);`);
+      yield* tx.run(`CREATE INDEX \`session_inbox_session_delivery_seq_idx\` ON \`session_inbox\` (\`session_id\`,\`delivery\`,\`enqueued_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_inbox_session_enqueued_seq_idx\` ON \`session_inbox\` (\`session_id\`,\`enqueued_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_message_session_seq_idx\` ON \`session_message\` (\`session_id\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_type_seq_idx\` ON \`session_message\` (\`session_id\`,\`type\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_time_created_id_idx\` ON \`session_message\` (\`session_id\`,\`time_created\`,\`id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_time_created_idx\` ON \`session_message\` (\`time_created\`);`);
+      yield* tx.run(`CREATE INDEX \`session_pending_session_delivery_seq_idx\` ON \`session_pending\` (\`session_id\`,\`delivery\`,\`admitted_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_pending_session_compaction_idx\` ON \`session_pending\` (\`session_id\`) WHERE "session_pending"."type" = 'compaction';`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_pending_session_admitted_seq_idx\` ON \`session_pending\` (\`session_id\`,\`admitted_seq\`);`);
+      yield* tx.run(`CREATE INDEX \`session_v2_project_idx\` ON \`session_v2\` (\`project_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_v2_workspace_idx\` ON \`session_v2\` (\`workspace_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_v2_parent_idx\` ON \`session_v2\` (\`parent_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_v2_time_suspended_idx\` ON \`session_v2\` (\`time_suspended\`) WHERE "session_v2"."time_suspended" is not null;`);
+    });
+  }
+};
+var schema_gen_default = schema;
+
+export { schema_gen_default };