@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-x5r76fqd.js

@@ -0,0 +1,290 @@
+import {
+  exports_saved
+} from "./ripgrep-bqtt5yh9.js";
+import {
+  exports_wildcard
+} from "./ripgrep-y67x6rf6.js";
+import {
+  exports_store
+} from "./ripgrep-3kbfazvv.js";
+import {
+  exports_error
+} from "./ripgrep-s6by3cc4.js";
+import {
+  exports_agent
+} from "./ripgrep-4ffc1teg.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/permission.ts
+var exports_permission = {};
+__export(exports_permission, {
+  node: () => node,
+  merge: () => merge,
+  evaluate: () => evaluate,
+  Source: () => Source,
+  Service: () => Service,
+  Ruleset: () => Ruleset,
+  Rule: () => Rule,
+  Request: () => Request,
+  ReplyInput: () => ReplyInput,
+  Reply: () => Reply,
+  Permission: () => exports_permission,
+  NotFoundError: () => NotFoundError,
+  ID: () => ID,
+  Event: () => Event,
+  Effect: () => PermissionEffect,
+  DeclinedError: () => DeclinedError,
+  CorrectedError: () => CorrectedError,
+  BlockedError: () => BlockedError,
+  AssertInput: () => AssertInput,
+  AskResult: () => AskResult
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Deferred, Effect, Layer, Schema } from "effect";
+import { Permission } from "@opencode-ai/schema/permission";
+import { Rule, Ruleset } from "@opencode-ai/schema/permission";
+import { Event } from "@opencode-ai/schema/permission";
+var PermissionEffect = Permission.Effect;
+var missingAgentPermissions = [{ action: "*", resource: "*", effect: "deny" }];
+var ID = Permission.ID;
+var Source = Permission.Source;
+var RequestFields = {
+  sessionID: Permission.Request.fields.sessionID,
+  action: Permission.Request.fields.action,
+  resources: Permission.Request.fields.resources,
+  save: Permission.Request.fields.save,
+  metadata: Permission.Request.fields.metadata,
+  source: Permission.Request.fields.source
+};
+var Request = Permission.Request;
+var Reply = Permission.Reply;
+var AssertInput = Schema.Struct({
+  id: ID.pipe(Schema.optional),
+  ...RequestFields,
+  agent: exports_agent.ID.pipe(Schema.optional)
+}).annotate({ identifier: "Permission.AssertInput" });
+var ReplyInput = Schema.Struct({
+  requestID: ID,
+  reply: Reply,
+  message: Schema.String.pipe(Schema.optional)
+}).annotate({ identifier: "Permission.ReplyInput" });
+var AskResult = Schema.Struct({
+  id: ID,
+  effect: Permission.Effect
+}).annotate({ identifier: "Permission.AskResult" });
+
+class DeclinedError extends Schema.TaggedErrorClass()("Permission.DeclinedError", {}) {
+}
+
+class CorrectedError extends Schema.TaggedErrorClass()("Permission.CorrectedError", {
+  feedback: Schema.String
+}) {
+}
+
+class BlockedError extends Schema.TaggedErrorClass()("Permission.BlockedError", {
+  rules: Permission.Ruleset,
+  permission: Schema.String,
+  resources: Schema.Array(Schema.String)
+}) {
+  get message() {
+    return `Permission denied: ${this.permission}`;
+  }
+}
+
+class NotFoundError extends Schema.TaggedErrorClass()("Permission.NotFoundError", {
+  requestID: ID
+}) {
+}
+function evaluate(action, resource, ...rulesets) {
+  return rulesets.flat().findLast((rule) => exports_wildcard.match(action, rule.action) && exports_wildcard.match(resource, rule.resource)) ?? {
+    action,
+    resource: "*",
+    effect: "ask"
+  };
+}
+function merge(...rulesets) {
+  return rulesets.flat();
+}
+
+class Service extends Context.Service()("@opencode/Permission") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const location = yield* exports_location.Service;
+  const agents = yield* exports_agent.Service;
+  const sessions = yield* exports_store.Service;
+  const saved = yield* exports_saved.Service;
+  const pending = new Map;
+  yield* Effect.addFinalizer(() => Effect.forEach(pending.values(), (item) => Deferred.fail(item.deferred, new DeclinedError), {
+    discard: true
+  }).pipe(Effect.ensuring(Effect.sync(() => {
+    pending.clear();
+  }))));
+  const savedRules = Effect.fnUntraced(function* () {
+    return (yield* saved.list({ projectID: location.project.id })).map((item) => ({
+      action: item.action,
+      resource: item.resource,
+      effect: "allow"
+    }));
+  });
+  const configured = Effect.fn("Permission.configured")(function* (sessionID, agentID) {
+    const session = yield* sessions.get(sessionID);
+    if (!session)
+      return yield* new exports_error.NotFoundError({ sessionID });
+    const agent = yield* agents.resolve(agentID ?? session.agent);
+    return agent?.permissions ?? missingAgentPermissions;
+  });
+  const allowsAll = Effect.fn("Permission.allowsAll")(function* (input) {
+    const rules = yield* configured(input.sessionID, input.agent);
+    const relevant2 = rules.filter((rule) => exports_wildcard.match(input.action, rule.action));
+    for (let index = relevant2.length - 1;index >= 0; index--) {
+      const rule = relevant2[index];
+      if (rule.resource !== "*") {
+        if (rule.effect !== "allow")
+          return false;
+        continue;
+      }
+      return rule.effect === "allow";
+    }
+    return false;
+  });
+  function denied(input, rules) {
+    return input.resources.some((resource) => evaluate(input.action, resource, rules).effect === "deny");
+  }
+  function relevant(input, rules) {
+    return rules.filter((rule) => exports_wildcard.match(input.action, rule.action));
+  }
+  const evaluateInput = Effect.fnUntraced(function* (input) {
+    const rules = yield* configured(input.sessionID, input.agent);
+    if (denied(input, rules))
+      return { effect: "deny", rules };
+    const all = [...rules, ...yield* savedRules()];
+    const effects = input.resources.map((resource) => evaluate(input.action, resource, all).effect);
+    const effect = effects.includes("deny") ? "deny" : effects.includes("ask") ? "ask" : "allow";
+    return { effect, rules: all };
+  });
+  function request(input) {
+    return {
+      id: input.id ?? ID.create(),
+      sessionID: input.sessionID,
+      action: input.action,
+      resources: input.resources,
+      save: input.save,
+      metadata: input.metadata,
+      source: input.source
+    };
+  }
+  const create = (request2, agent) => Effect.uninterruptible(Effect.gen(function* () {
+    const deferred = yield* Deferred.make();
+    const item = { request: request2, agent, deferred };
+    if (pending.has(request2.id))
+      return yield* Effect.die(new Error(`Duplicate pending permission ID: ${request2.id}`));
+    pending.set(request2.id, item);
+    yield* bus.publish(Permission.Event.Asked, request2).pipe(Effect.onError(() => Effect.sync(() => pending.delete(request2.id))));
+    return item;
+  }));
+  const ask = Effect.fn("Permission.ask")(function* (input) {
+    const result = yield* evaluateInput(input);
+    const value = request(input);
+    if (result.effect === "ask")
+      yield* create(value, input.agent);
+    return { id: value.id, effect: result.effect };
+  });
+  const assert = Effect.fn("Permission.assert")((input) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+    const result = yield* evaluateInput(input);
+    if (result.effect === "deny") {
+      return yield* new BlockedError({
+        rules: relevant(input, result.rules),
+        permission: input.action,
+        resources: input.resources
+      });
+    }
+    if (result.effect === "allow")
+      return;
+    const item = yield* create(request(input), input.agent);
+    return yield* restore(Deferred.await(item.deferred)).pipe(Effect.catchTag("Permission.DeclinedError", (error) => Effect.die(error)), Effect.ensuring(Effect.sync(() => {
+      pending.delete(item.request.id);
+    })));
+  })));
+  const reply = Effect.fn("Permission.reply")((input) => Effect.uninterruptible(Effect.gen(function* () {
+    const existing = pending.get(input.requestID);
+    if (!existing)
+      return yield* new NotFoundError({ requestID: input.requestID });
+    yield* bus.publish(Permission.Event.Replied, {
+      sessionID: existing.request.sessionID,
+      requestID: existing.request.id,
+      reply: input.reply
+    });
+    if (input.reply === "reject") {
+      yield* Deferred.fail(existing.deferred, input.message ? new CorrectedError({ feedback: input.message }) : new DeclinedError);
+      pending.delete(input.requestID);
+      for (const [id, item] of pending) {
+        if (item.request.sessionID !== existing.request.sessionID)
+          continue;
+        yield* bus.publish(Permission.Event.Replied, {
+          sessionID: item.request.sessionID,
+          requestID: item.request.id,
+          reply: "reject"
+        });
+        yield* Deferred.fail(item.deferred, new DeclinedError);
+        pending.delete(id);
+      }
+      return;
+    }
+    if (input.reply === "always" && existing.request.save?.length) {
+      yield* saved.add({
+        projectID: location.project.id,
+        action: existing.request.action,
+        resources: existing.request.save
+      });
+    }
+    yield* Deferred.succeed(existing.deferred, undefined);
+    pending.delete(input.requestID);
+    if (input.reply !== "always" || !existing.request.save?.length)
+      return;
+    const rememberedRules = yield* savedRules();
+    for (const [id, item] of pending) {
+      const input2 = { ...item.request };
+      const rules = yield* configured(item.request.sessionID, item.agent).pipe(Effect.catchTag("Session.NotFoundError", () => Effect.succeed(undefined)));
+      if (!rules)
+        continue;
+      if (denied(input2, rules))
+        continue;
+      const effective = [...rules, ...rememberedRules];
+      if (!item.request.resources.every((resource) => evaluate(item.request.action, resource, effective).effect === "allow"))
+        continue;
+      yield* bus.publish(Permission.Event.Replied, {
+        sessionID: item.request.sessionID,
+        requestID: item.request.id,
+        reply: "always"
+      });
+      yield* Deferred.succeed(item.deferred, undefined);
+      pending.delete(id);
+    }
+  })));
+  const list = Effect.fn("Permission.list")(function* () {
+    return Array.from(pending.values(), (item) => item.request);
+  });
+  const get = Effect.fn("Permission.get")(function* (id) {
+    return pending.get(id)?.request;
+  });
+  const forSession = Effect.fn("Permission.forSession")(function* (sessionID) {
+    return Array.from(pending.values(), (item) => item.request).filter((request2) => request2.sessionID === sessionID);
+  });
+  return Service.of({ allowsAll, ask, assert, reply, get, forSession, list });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_bus.node, exports_location.node, exports_agent.node, exports_store.node, exports_saved.node]
+});
+
+export { PermissionEffect, ID, Source, Request, Reply, AssertInput, ReplyInput, AskResult, DeclinedError, CorrectedError, BlockedError, NotFoundError, evaluate, merge, Service, node, exports_permission, Rule, Ruleset, Event };

package/dist/chunks/ripgrep-x7d24xgg.js

@@ -0,0 +1,36 @@
+import {
+  exports_config
+} from "./ripgrep-rz9mfttk.js";
+import {
+  exports_wildcard
+} from "./ripgrep-y67x6rf6.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/config/plugin/policy.ts
+var exports_policy = {};
+__export(exports_policy, {
+  Plugin: () => Plugin,
+  ConfigPolicyPlugin: () => exports_policy
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Stream } from "effect";
+var Plugin = define({
+  id: "opencode.config.policy",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* exports_config.Service;
+    const loaded = { entries: yield* config.entries() };
+    yield* ctx.catalog.transform((catalog) => {
+      const policies = loaded.entries.filter((entry) => entry.type === "document").toReversed().flatMap((entry) => entry.info.experimental?.policies ?? []);
+      for (const record of catalog.provider.list()) {
+        const policy = policies.findLast((policy2) => exports_wildcard.match(record.provider.id, policy2.resource));
+        if (policy?.effect === "deny")
+          catalog.provider.remove(record.provider.id);
+      }
+    });
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(ctx.catalog.reload()))), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+
+export { Plugin, exports_policy };

package/dist/chunks/ripgrep-x7kx8910.js

@@ -0,0 +1,72 @@
+import {
+  exports_drizzle
+} from "./ripgrep-4xwayb0j.js";
+import {
+  exports_migration
+} from "./ripgrep-vp7n0g03.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/database/database.ts
+var exports_database = {};
+__export(exports_database, {
+  node: () => node,
+  layerFromClient: () => layerFromClient,
+  layer: () => layer,
+  configuredClient: () => configuredClient,
+  configured: () => configured,
+  Service: () => Service,
+  Options: () => Options,
+  Database: () => exports_database
+});
+import { sqliteLayer, supportsForeignKeyToggle, supportsTuningPragmas } from "#sqlite";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Global } from "@opencode-ai/util/global";
+import { isAbsolute, join } from "path";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+var makeDatabase = exports_drizzle.makeWithDefaults();
+var Options = Schema.Struct({
+  path: Schema.optional(Schema.String)
+});
+
+class Service extends Context.Service()("@opencode/storage/Database") {
+}
+var databaseLayer = Layer.effect(Service, Effect.gen(function* () {
+  const db = yield* makeDatabase;
+  if (supportsTuningPragmas) {
+    yield* db.run("PRAGMA journal_mode = WAL");
+    yield* db.run("PRAGMA synchronous = NORMAL");
+    yield* db.run("PRAGMA busy_timeout = 5000");
+    yield* db.run("PRAGMA cache_size = -64000");
+    yield* db.run("PRAGMA wal_checkpoint(PASSIVE)");
+  }
+  if (supportsForeignKeyToggle)
+    yield* db.run("PRAGMA foreign_keys = ON");
+  yield* exports_migration.apply(db);
+  return { db };
+}).pipe(Effect.orDie));
+function layer(options = { path: ":memory:" }) {
+  return Layer.unwrap(Effect.gen(function* () {
+    const provide = (filename2) => layerFromClient.pipe(Layer.provide(sqliteLayer({ filename: filename2 })));
+    const filename = options.path ?? ":memory:";
+    if (filename === ":memory:" || isAbsolute(filename))
+      return provide(filename);
+    const global = yield* Global.Service;
+    return provide(join(global.data, filename));
+  }));
+}
+var layerFromClient = databaseLayer;
+function configured(options) {
+  return makeGlobalNode({ service: Service, layer: layer(options), deps: [Global.node] });
+}
+function configuredClient(client) {
+  return makeGlobalNode({
+    service: Service,
+    layer: layerFromClient.pipe(Layer.provide(client)),
+    deps: [Global.node]
+  });
+}
+var node = configured({ path: ":memory:" });
+
+export { Options, Service, layer, layerFromClient, configured, configuredClient, node, exports_database };

package/dist/chunks/ripgrep-xfd1xnk3.js

@@ -0,0 +1,49 @@
+import {
+  exports_provider
+} from "./ripgrep-d6vvk673.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/model.ts
+var exports_model = {};
+__export(exports_model, {
+  parse: () => parse,
+  compatibility: () => compatibility,
+  VariantID: () => VariantID,
+  Ref: () => Ref,
+  ReasoningField: () => ReasoningField,
+  Model: () => exports_model,
+  Info: () => Info,
+  ID: () => ID,
+  Family: () => Family,
+  Cost: () => Cost,
+  Compatibility: () => Compatibility,
+  Capabilities: () => Capabilities
+});
+import { Model } from "@opencode-ai/schema/model";
+var ID = Model.ID;
+var VariantID = Model.VariantID;
+var Family = Model.Family;
+var ReasoningField = Model.ReasoningField;
+var Compatibility = Model.Compatibility;
+var Capabilities = Model.Capabilities;
+var Cost = Model.Cost;
+var Ref = Model.Ref;
+var Info = Model.Info;
+function compatibility(input) {
+  if (typeof input === "string")
+    return { reasoningField: input };
+  if (typeof input !== "object" || input === null || Array.isArray(input) || !("field" in input))
+    return;
+  return typeof input.field === "string" ? { reasoningField: input.field } : undefined;
+}
+function parse(input) {
+  const [providerID, ...modelID] = input.split("/");
+  return {
+    providerID: exports_provider.ID.make(providerID),
+    modelID: ID.make(modelID.join("/"))
+  };
+}
+
+export { ID, VariantID, Family, ReasoningField, Compatibility, Capabilities, Cost, Ref, Info, compatibility, parse, exports_model };

package/dist/chunks/ripgrep-xgv25zxy.js

@@ -0,0 +1,16 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/session/generate.ts
+var exports_generate = {};
+__export(exports_generate, {
+  SessionGenerate: () => exports_generate,
+  Service: () => Service
+});
+import { Context } from "effect";
+
+class Service extends Context.Service()("@opencode/SessionGenerate") {
+}
+
+export { Service, exports_generate };