@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-jve7t217.js

@@ -0,0 +1,28 @@
+// src/tool/http-body.ts
+import { Effect, Stream } from "effect";
+var collectBoundedResponseBody = (response, maximumBytes, tooLarge) => Effect.gen(function* () {
+  const contentLength = response.headers["content-length"];
+  const parsedSize = contentLength ? Number.parseInt(contentLength, 10) : undefined;
+  const declaredSize = parsedSize !== undefined && Number.isSafeInteger(parsedSize) && parsedSize >= 0 ? parsedSize : undefined;
+  if (declaredSize !== undefined && declaredSize > maximumBytes)
+    return yield* Effect.fail(tooLarge());
+  let body = Buffer.allocUnsafe(Math.min(maximumBytes, declaredSize || 64 * 1024));
+  let size = 0;
+  yield* Stream.runForEach(response.stream, (chunk) => {
+    if (chunk.byteLength === 0)
+      return Effect.void;
+    if (size + chunk.byteLength > maximumBytes)
+      return Effect.fail(tooLarge());
+    if (size + chunk.byteLength > body.byteLength) {
+      const grown = Buffer.allocUnsafe(Math.min(maximumBytes, Math.max(size + chunk.byteLength, body.byteLength * 2)));
+      body.copy(grown, 0, 0, size);
+      body = grown;
+    }
+    body.set(chunk, size);
+    size += chunk.byteLength;
+    return Effect.void;
+  });
+  return body.subarray(0, size);
+});
+
+export { collectBoundedResponseBody };

package/dist/chunks/permission-k59zb4v2.js

@@ -0,0 +1,274 @@
+import {
+  exports_variable
+} from "./permission-eyk9wdct.js";
+import {
+  exports_normalize
+} from "./permission-2806rrqb.js";
+import {
+  exports_watcher
+} from "./permission-a3xgesk5.js";
+import {
+  exports_wellknown
+} from "./permission-5m82aax9.js";
+import {
+  exports_credential
+} from "./permission-d5t1sv80.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  AbsolutePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/config.ts
+var exports_config = {};
+__export(exports_config, {
+  testLayer: () => testLayer,
+  node: () => node,
+  layer: () => layer,
+  latest: () => latest,
+  configured: () => configured,
+  Test: () => Test,
+  Service: () => Service,
+  Options: () => Options,
+  Config: () => exports_config
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import path from "path";
+import { isDeepStrictEqual } from "node:util";
+import { parse } from "jsonc-parser";
+import { Context, Effect, Layer, Option, PubSub, Ref, Schema, Semaphore, Stream } from "effect";
+import {
+  AgentsDirectory,
+  ClaudeDirectory,
+  Directory,
+  Document,
+  File,
+  Info,
+  Event
+} from "@opencode-ai/schema/config";
+import { Integration } from "@opencode-ai/schema/integration";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+function latest(entries, key) {
+  return entries.filter((entry) => entry.type === "document").findLast((entry) => entry.info[key] !== undefined)?.info[key];
+}
+var Options = Schema.Struct({
+  project: Schema.optional(Schema.Boolean),
+  file: Schema.optional(Schema.String),
+  content: Schema.optional(Schema.String)
+});
+
+class Service extends Context.Service()("@opencode/Config") {
+}
+
+class Test extends Context.Service()("@opencode/Config/Test") {
+}
+var testLayer = (initial = []) => Layer.effectContext(Effect.gen(function* () {
+  const entries = yield* Ref.make(initial);
+  const updates = yield* PubSub.unbounded();
+  const service = Test.of({
+    entries: () => Ref.get(entries),
+    changes: () => Stream.fromPubSub(updates),
+    setEntries: (next) => Ref.set(entries, next),
+    emitChange: (update) => PubSub.publish(updates, update).pipe(Effect.asVoid)
+  });
+  return Context.empty().pipe(Context.add(Service, service), Context.add(Test, service));
+}));
+var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const location = yield* exports_location.Service;
+  const watcher = yield* exports_watcher.Service;
+  const bus = yield* exports_bus.Service;
+  const credentials = yield* exports_credential.Service;
+  const wellknown = yield* exports_wellknown.Service;
+  const names = ["opencode.json", "opencode.jsonc"];
+  const reloadLock = Semaphore.makeUnsafe(1);
+  const decodeOptions = { errors: "all", onExcessProperty: "ignore", propertyOrder: "original" };
+  const decodeInfo = Schema.decodeUnknownOption(Info, decodeOptions);
+  const parseInfo = Effect.fn("Config.parseInfo")(function* (text, source) {
+    const errors = [];
+    const input = parse(text, errors, { allowTrailingComma: true });
+    if (errors.length) {
+      yield* Effect.logWarning("configuration normalization diagnostic", {
+        source,
+        path: "$",
+        kind: "invalid",
+        action: "rejected malformed JSON or JSONC document"
+      });
+      return;
+    }
+    const result = exports_normalize.normalize(input);
+    yield* Effect.forEach(result.diagnostics, (diagnostic) => Effect.logWarning("configuration normalization diagnostic", {
+      source,
+      path: diagnostic.path[0] === "$" ? "$" : `$.${diagnostic.path.join(".")}`,
+      kind: diagnostic.kind,
+      action: diagnostic.message
+    }));
+    if (result.type === "rejected")
+      return;
+    const info = Option.getOrUndefined(decodeInfo(result.encoded));
+    if (info)
+      return info;
+    yield* Effect.logWarning("configuration normalization diagnostic", {
+      source,
+      path: "$",
+      kind: "invalid",
+      action: "rejected canonical configuration after final validation"
+    });
+  });
+  const loadFile = Effect.fnUntraced(function* (filepath) {
+    const text = yield* fs.readFileStringSafe(filepath);
+    if (text === undefined)
+      return;
+    const substituted = yield* exports_variable.substitute({ type: "path", path: filepath, text });
+    const info = yield* parseInfo(substituted, filepath);
+    if (!info)
+      return;
+    return new Document({ type: "document", path: filepath, info });
+  });
+  const loadWellknown = Effect.fn("Config.loadWellknown")(function* () {
+    const entries = yield* wellknown.entries().pipe(Effect.catch((error) => Effect.logWarning("failed to discover wellknown config", { error }).pipe(Effect.as([]))));
+    return yield* Effect.forEach(entries, (entry) => Effect.gen(function* () {
+      const auth = entry.manifest.auth;
+      if (!auth)
+        return [];
+      const credential = (yield* credentials.list(entry.integrationID)).findLast((credential2) => credential2.value.type === "key");
+      if (!credential || credential.value.type !== "key")
+        return [];
+      const variables = { [auth.env]: credential.value.key };
+      const configs2 = yield* wellknown.resolve(entry, variables).pipe(Effect.catch(() => Effect.logWarning("failed to load wellknown config", { source: entry.origin }).pipe(Effect.as([]))));
+      return yield* Effect.forEach(configs2, (config) => exports_variable.substitute({
+        type: "virtual",
+        source: entry.origin,
+        dir: entry.origin,
+        text: JSON.stringify(config),
+        env: variables
+      }).pipe(Effect.flatMap((text) => parseInfo(text, entry.origin)), Effect.map((info) => info ? new Document({ type: "document", info }) : undefined))).pipe(Effect.map((documents) => documents.filter((document) => document !== undefined)));
+    })).pipe(Effect.map((documents) => documents.flat()));
+  });
+  const loadDirectory = Effect.fnUntraced(function* (directory) {
+    return [
+      ...yield* Effect.forEach(names, (file) => loadFile(path.join(directory, file))).pipe(Effect.map((configs2) => configs2.filter((config) => config !== undefined))),
+      new Directory({ type: "directory", path: directory })
+    ];
+  });
+  const discover = Effect.fn("Config.discover")(function* () {
+    const globalDirectory = AbsolutePath.make(global.config);
+    const globalAgentsDirectory = AbsolutePath.make(path.join(global.home, ".agents"));
+    const globalClaudeDirectory = AbsolutePath.make(path.join(global.home, ".claude"));
+    const locationIsGlobal = path.resolve(location.directory) === path.resolve(global.config);
+    const discovered = locationIsGlobal || options?.project === false ? [] : yield* fs.up({
+      targets: [".opencode", ".claude", ".agents", ...names.toReversed()],
+      start: location.directory
+    }).pipe(Effect.orDie);
+    const claude = [
+      ...new Set([
+        ...(yield* fs.isDir(globalClaudeDirectory)) ? [globalClaudeDirectory] : [],
+        ...discovered.filter((item) => path.basename(item) === ".claude").toReversed()
+      ])
+    ].map((directory) => new ClaudeDirectory({ type: "claude", path: AbsolutePath.make(directory) }));
+    const agents = [
+      ...new Set([
+        ...(yield* fs.isDir(globalAgentsDirectory)) ? [globalAgentsDirectory] : [],
+        ...discovered.filter((item) => path.basename(item) === ".agents").toReversed()
+      ])
+    ].map((directory) => new AgentsDirectory({ type: "agents", path: AbsolutePath.make(directory) }));
+    const directories = [
+      globalDirectory,
+      ...discovered.filter((item) => path.basename(item) === ".opencode").toReversed().map((directory) => AbsolutePath.make(directory))
+    ];
+    const directPaths = discovered.filter((item) => ![".agents", ".claude", ".opencode"].includes(path.basename(item))).toReversed();
+    const direct = yield* Effect.forEach(directPaths, (filepath) => loadFile(filepath).pipe(Effect.map((config) => [
+      ...config ? [config] : [],
+      new File({ type: "file", path: AbsolutePath.make(filepath) })
+    ]))).pipe(Effect.orDie, Effect.map((entries) => entries.flat()));
+    const file = options?.file;
+    const explicit = file ? yield* loadFile(path.resolve(file)).pipe(Effect.map((config) => [
+      ...config ? [config] : [],
+      new File({ type: "file", path: AbsolutePath.make(path.resolve(file)) })
+    ]), Effect.orDie) : [];
+    const content = options?.content !== undefined ? yield* exports_variable.substitute({
+      type: "virtual",
+      source: "OPENCODE_CONFIG_CONTENT",
+      dir: location.directory,
+      text: options.content
+    }).pipe(Effect.flatMap((text) => parseInfo(text, "OPENCODE_CONFIG_CONTENT")), Effect.map((info) => info ? [new Document({ type: "document", info })] : []), Effect.orDie) : [];
+    const supplementary = yield* Effect.forEach(directories, loadDirectory).pipe(Effect.orDie);
+    return [
+      ...yield* loadWellknown().pipe(Effect.orDie),
+      ...claude,
+      ...agents,
+      ...supplementary[0] ?? [],
+      ...explicit,
+      ...direct,
+      ...supplementary.slice(1).flat(),
+      ...content
+    ];
+  });
+  const initial = yield* discover();
+  let configs = initial;
+  const updates = yield* PubSub.unbounded();
+  const ignore = ["node_modules", ".git", "**/{node_modules,.git}/**"];
+  const watched = new Set;
+  const reconcile = Effect.fn("Config.reconcileWatches")(function* (entries) {
+    const directories = entries.flatMap((entry) => entry.type === "directory" ? [entry.path] : []);
+    const files = entries.flatMap((entry) => entry.type === "file" ? [entry.path] : []);
+    const targets = [
+      ...directories.map((path2) => ({ path: path2, type: "directory", ignore })),
+      ...files.filter((file) => !directories.some((directory) => FSUtil.contains(directory, file))).map((path2) => ({ path: path2, type: "file" }))
+    ];
+    for (const target of targets) {
+      const key = JSON.stringify(target);
+      if (watched.has(key))
+        continue;
+      watched.add(key);
+      const stream = yield* watcher.subscribe(target);
+      yield* stream.pipe(Stream.runForEach((update) => PubSub.publish(updates, update)), Effect.forkScoped({ startImmediately: true }));
+    }
+  });
+  const reload = Effect.fn("Config.reload")(() => reloadLock.withPermit(Effect.gen(function* () {
+    const next = yield* discover();
+    if (isDeepStrictEqual(configs, next))
+      return;
+    configs = next;
+    yield* reconcile(next);
+    yield* bus.publish(Event.Updated, {});
+  })));
+  yield* Stream.fromPubSub(updates).pipe(Stream.debounce("100 millis"), Stream.runForEach((update) => reload().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload config", { path: update.path, cause })))), Effect.forkScoped({ startImmediately: true }));
+  yield* bus.subscribe(Integration.Event.ConnectionUpdated).pipe(Stream.filterEffect((event) => wellknown.entries().pipe(Effect.map((entries) => entries.some((entry) => entry.integrationID === event.data.integrationID)), Effect.catch(() => Effect.succeed(false)))), Stream.runForEach(() => reload().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload wellknown config", { cause })))), Effect.forkScoped({ startImmediately: true }));
+  yield* bus.subscribe(exports_wellknown.Event.Updated).pipe(Stream.runForEach(() => reload().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload wellknown sources", { cause })))), Effect.forkScoped({ startImmediately: true }));
+  yield* Effect.sleep("10 minutes").pipe(Effect.andThen(Effect.suspend(() => {
+    if (!wellknown.snapshot().length)
+      return Effect.void;
+    return Effect.gen(function* () {
+      const changed = yield* wellknown.refresh().pipe(Effect.catch((error) => Effect.logWarning("failed to refresh wellknown manifests", { error }).pipe(Effect.as(false))));
+      if (!changed)
+        yield* reload();
+    }).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to refresh wellknown config", { cause })));
+  })), Effect.forever, Effect.forkScoped({ startImmediately: true }));
+  yield* reconcile(initial);
+  return Service.of({
+    entries: Effect.fn("Config.entries")(function* () {
+      return configs;
+    }),
+    changes: () => Stream.fromPubSub(updates)
+  });
+}));
+function configured(options) {
+  return makeLocationNode({
+    service: Service,
+    layer: layer(options),
+    deps: [exports_watcher.node, exports_bus.node, FSUtil.node, Global.node, exports_location.node, exports_credential.node, exports_wellknown.node]
+  });
+}
+var node = configured();
+
+export { latest, Options, Service, Test, testLayer, layer, configured, node, exports_config };

package/dist/chunks/permission-kg1345f7.js

@@ -0,0 +1,63 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/filesystem/protected.ts
+var exports_protected = {};
+__export(exports_protected, {
+  paths: () => paths,
+  names: () => names,
+  isHome: () => isHome,
+  Protected: () => exports_protected
+});
+import os from "os";
+import path from "path";
+var home = os.homedir();
+function isHome(directory) {
+  return path.resolve(directory) === path.resolve(home);
+}
+var DARWIN_HOME = [
+  "Music",
+  "Pictures",
+  "Movies",
+  "Downloads",
+  "Desktop",
+  "Documents",
+  "Public",
+  "Applications",
+  "Library"
+];
+var DARWIN_LIBRARY = [
+  "Application Support/AddressBook",
+  "Calendars",
+  "Mail",
+  "Messages",
+  "Safari",
+  "Cookies",
+  "Application Support/com.apple.TCC",
+  "PersonalizationPortrait",
+  "Metadata/CoreSpotlight",
+  "Suggestions"
+];
+var DARWIN_ROOT = ["/.DocumentRevisions-V100", "/.Spotlight-V100", "/.Trashes", "/.fseventsd"];
+var WIN32_HOME = ["AppData", "Downloads", "Desktop", "Documents", "Pictures", "Music", "Videos", "OneDrive"];
+function names() {
+  if (process.platform === "darwin")
+    return new Set(DARWIN_HOME);
+  if (process.platform === "win32")
+    return new Set(WIN32_HOME);
+  return new Set;
+}
+function paths() {
+  if (process.platform === "darwin")
+    return [
+      ...DARWIN_HOME.map((name) => path.join(home, name)),
+      ...DARWIN_LIBRARY.map((name) => path.join(home, "Library", name)),
+      ...DARWIN_ROOT
+    ];
+  if (process.platform === "win32")
+    return WIN32_HOME.map((name) => path.join(home, name));
+  return [];
+}
+
+export { isHome, names, paths, exports_protected };

package/dist/chunks/permission-khnqrbwa.js

@@ -0,0 +1,179 @@
+import {
+  exports_skill_file
+} from "./permission-d0n9nbkk.js";
+import {
+  exports_discovery
+} from "./permission-a65h300v.js";
+import {
+  exports_config
+} from "./permission-k59zb4v2.js";
+import {
+  exports_watcher
+} from "./permission-a3xgesk5.js";
+import {
+  exports_skill
+} from "./permission-zr271bqv.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  AbsolutePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/config/plugin/skill.ts
+var exports_skill2 = {};
+__export(exports_skill2, {
+  Plugin: () => Plugin,
+  ConfigSkillPlugin: () => exports_skill2
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+import path from "path";
+import { Effect, FiberMap, PubSub, Semaphore, Stream } from "effect";
+var Plugin = define({
+  id: "opencode.config.skill",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* exports_config.Service;
+    const discovery = yield* exports_discovery.Service;
+    const fs = yield* FSUtil.Service;
+    const global = yield* Global.Service;
+    const location = yield* exports_location.Service;
+    const watcher = yield* exports_watcher.Service;
+    const loaded = {
+      entries: yield* config.entries(),
+      skills: []
+    };
+    const watches = yield* FiberMap.make();
+    const changes = yield* PubSub.sliding(1);
+    const lock = Semaphore.makeUnsafe(1);
+    const watch = Effect.fn("ConfigSkillPlugin.watch")(function* (directory, type) {
+      const target = path.resolve(directory);
+      const updates = yield* watcher.subscribe({ path: target, type });
+      yield* FiberMap.run(watches, `${type}:${target}`, updates.pipe(Stream.runForEach((update) => PubSub.publish(changes, update.path).pipe(Effect.asVoid))), { onlyIfMissing: true, startImmediately: true });
+    });
+    function firstMissing(target) {
+      const parent = path.dirname(target);
+      if (parent === target)
+        return Effect.succeed(undefined);
+      return fs.isDir(parent).pipe(Effect.flatMap((exists) => exists ? Effect.succeed(target) : firstMissing(parent)));
+    }
+    const watchDirectory = Effect.fn("ConfigSkillPlugin.watchDirectory")(function* (directory) {
+      const target = path.resolve(directory);
+      const resolved = yield* fs.realPath(directory).pipe(Effect.catch(() => Effect.succeed(undefined)));
+      if (resolved) {
+        yield* watch(resolved, "directory");
+        if (resolved !== target)
+          yield* watch(target, "file");
+        return resolved === target ? [target] : [target, resolved];
+      }
+      const missing = yield* firstMissing(target);
+      if (missing)
+        yield* watch(missing, "file");
+      if (yield* fs.realPath(directory).pipe(Effect.as(true), Effect.catch(() => Effect.succeed(false)))) {
+        if (missing)
+          yield* FiberMap.remove(watches, `file:${path.resolve(missing)}`);
+        return yield* watchDirectory(directory);
+      }
+      return [target];
+    });
+    const sources = () => {
+      const result = [];
+      const add = (source) => {
+        if (result.some((item) => exports_skill.Source.equals(item, source)))
+          return;
+        result.push(source);
+      };
+      const claude = loaded.entries.flatMap((entry) => entry.type === "claude" ? [entry.path] : []);
+      const agents = loaded.entries.flatMap((entry) => entry.type === "agents" ? [entry.path] : []);
+      const directories = loaded.entries.flatMap((entry) => entry.type === "directory" ? [entry.path] : []);
+      const items = loaded.entries.flatMap((entry) => entry.type === "document" ? entry.info.skills ?? [] : []);
+      for (const directory of [...claude, ...agents]) {
+        add(exports_skill.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skills")) }));
+      }
+      for (const directory of directories) {
+        add(exports_skill.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skill")) }));
+        add(exports_skill.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skills")) }));
+      }
+      for (const item of items) {
+        if (URL.canParse(item) && /^(https?:)$/.test(new URL(item).protocol)) {
+          add(exports_skill.UrlSource.make({ type: "url", url: item }));
+          continue;
+        }
+        const expanded = item.startsWith("~/") ? path.join(global.home, item.slice(2)) : item;
+        add(exports_skill.DirectorySource.make({
+          type: "directory",
+          path: AbsolutePath.make(path.isAbsolute(expanded) ? expanded : path.join(location.directory, expanded))
+        }));
+      }
+      return result;
+    };
+    const load = Effect.fn("ConfigSkillPlugin.load")(function* (source) {
+      const directories = source.type === "directory" ? [source.path] : yield* discovery.pull(source.url).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to load skill source", {
+        source: exports_skill.Source.key(source),
+        cause
+      }).pipe(Effect.as([]))));
+      const roots = (yield* Effect.forEach(directories, watchDirectory)).flat();
+      const skills = [];
+      for (const directory of directories) {
+        const files = yield* fs.scan("{*.md,**/SKILL.md}", { cwd: directory, absolute: true, include: "file", symlink: true, dot: true }).pipe(Effect.catch(() => Effect.succeed([])));
+        for (const filepath of files.toSorted()) {
+          const resolved = yield* fs.realPath(filepath).pipe(Effect.catch(() => Effect.succeed(filepath)));
+          if (!roots.some((root) => FSUtil.contains(root, resolved)))
+            yield* watch(path.dirname(resolved), "directory");
+          const content = yield* fs.readFileStringSafe(filepath).pipe(Effect.catch(() => Effect.succeed(undefined)));
+          if (!content)
+            continue;
+          const parsed = exports_skill_file.parse(directory, filepath, content);
+          if (parsed._tag === "Skipped") {
+            yield* Effect.logDebug("skill file skipped", {
+              filepath,
+              reason: parsed.reason,
+              ...parsed.reason === "frontmatter" ? { issue: parsed.issue } : {}
+            });
+            continue;
+          }
+          skills.push(parsed.skill);
+        }
+      }
+      yield* Effect.logDebug("skill source loaded", {
+        source: exports_skill.Source.key(source),
+        type: source.type,
+        directories,
+        skills: skills.map((skill) => skill.id)
+      });
+      return skills;
+    });
+    const refresh = Effect.fn("ConfigSkillPlugin.refresh")(function* (file) {
+      yield* lock.withPermit(Effect.gen(function* () {
+        yield* FiberMap.clear(watches);
+        const skills = new Map;
+        const current = sources();
+        for (const source of current) {
+          for (const skill of yield* load(source))
+            skills.set(skill.id, skill);
+        }
+        loaded.skills = Array.from(skills.values());
+        if (file) {
+          yield* Effect.logInfo("skills rescanned", {
+            file,
+            sources: current.map(exports_skill.Source.key),
+            skills: loaded.skills.map((skill) => skill.id)
+          });
+        }
+      }));
+    });
+    yield* Stream.fromPubSub(changes).pipe(Stream.runForEach((file) => refresh(file).pipe(Effect.andThen(ctx.skill.reload()))), Effect.forkScoped({ startImmediately: true }));
+    yield* refresh();
+    yield* ctx.skill.transform((draft) => {
+      for (const skill of loaded.skills)
+        draft.add(skill);
+    });
+    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(refresh()), Effect.andThen(ctx.skill.reload()))), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+
+export { Plugin, exports_skill2 as exports_skill };

package/dist/chunks/permission-kpdbz7gn.js

@@ -0,0 +1,16 @@
+// src/database/migration/20260423070820_add_icon_url_override.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260423070820_add_icon_url_override",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        ALTER TABLE \`project\` ADD \`icon_url_override\` text;
+        UPDATE \`project\` SET \`icon_url_override\` = \`icon_url\` WHERE \`icon_url\` IS NOT NULL;
+      `);
+    });
+  }
+};
+var _20260423070820_add_icon_url_override_default = migration;
+
+export { _20260423070820_add_icon_url_override_default };

package/dist/chunks/permission-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/permission-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/permission-m01ryvbe.js

@@ -0,0 +1,22 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/effect/app-node-platform.ts
+var exports_app_node_platform = {};
+__export(exports_app_node_platform, {
+  requestExecutor: () => requestExecutor,
+  llmClient: () => llmClient,
+  LayerNodePlatform: () => exports_app_node_platform
+});
+import { LLMClient, RequestExecutor } from "@opencode-ai/ai/route";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { httpClient } from "@opencode-ai/util/effect/app-node-platform";
+var requestExecutor = makeGlobalNode({
+  service: RequestExecutor.Service,
+  layer: RequestExecutor.layer,
+  deps: [httpClient]
+});
+var llmClient = makeGlobalNode({ service: LLMClient.Service, layer: LLMClient.layer, deps: [requestExecutor] });
+
+export { requestExecutor, llmClient, exports_app_node_platform };

package/dist/chunks/permission-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 };