@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-608jf46e.js

@@ -0,0 +1,462 @@
+import {
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  Service73,
+  node78
+} from "./worktree-7vcja736.js";
+import {
+  Service66,
+  node71
+} from "./worktree-0tg2xvbt.js";
+import {
+  Service65,
+  node70
+} from "./worktree-rjbw5qw4.js";
+import {
+  Service64,
+  node69
+} from "./worktree-g0he3e83.js";
+import {
+  Service63,
+  node68
+} from "./worktree-e3fx731j.js";
+import {
+  Service44,
+  node47
+} from "./worktree-4m55frd1.js";
+import {
+  Service55,
+  node59
+} from "./worktree-ccrec4q8.js";
+import {
+  Service74,
+  node79
+} from "./worktree-z82wee6n.js";
+import {
+  Service58,
+  node62
+} from "./worktree-madgwgkk.js";
+import {
+  Service56,
+  node60
+} from "./worktree-rqsgeg7f.js";
+import {
+  Service54,
+  node58
+} from "./worktree-r82b328h.js";
+import {
+  Plugin19
+} from "./worktree-rn1y5g26.js";
+import {
+  Service37,
+  node40
+} from "./worktree-y5h7afh3.js";
+import {
+  Service70,
+  node75
+} from "./worktree-k56d8zdx.js";
+import {
+  Service78,
+  node83
+} from "./worktree-t2pd0szj.js";
+import {
+  Service52,
+  node55
+} from "./worktree-pr7ch8ks.js";
+import {
+  Service26,
+  node31
+} from "./worktree-146a62k1.js";
+import {
+  Service68,
+  node73
+} from "./worktree-nzwzy72p.js";
+import {
+  Service67,
+  node72
+} from "./worktree-249ffbnn.js";
+import {
+  Service41,
+  node44
+} from "./worktree-q3ac6zk1.js";
+import {
+  Service39,
+  node42
+} from "./worktree-5ycqwtsz.js";
+import {
+  Plugin45
+} from "./worktree-hcaepy0h.js";
+import {
+  Service31,
+  node35
+} from "./worktree-mp9h7a8n.js";
+import {
+  Service48,
+  node51
+} from "./worktree-w55j1d38.js";
+import {
+  Service49,
+  node52
+} from "./worktree-qr42g2ex.js";
+import {
+  Service46,
+  node49
+} from "./worktree-7c3npc5w.js";
+import {
+  Service17,
+  node21
+} from "./worktree-p9690q97.js";
+import {
+  Plugin23
+} from "./worktree-4ph0a4gn.js";
+import {
+  Service9,
+  node12
+} from "./worktree-dvh2p5hy.js";
+import {
+  Plugin26
+} from "./worktree-2hcp0bjx.js";
+import {
+  Service15,
+  node18
+} from "./worktree-8mvsftc3.js";
+import {
+  Plugin18
+} from "./worktree-062zp4xz.js";
+import {
+  Plugin27
+} from "./worktree-nze8c8vz.js";
+import {
+  Plugin30
+} from "./worktree-k65ezx0v.js";
+import {
+  Service8,
+  node11
+} from "./worktree-twy35tz0.js";
+import {
+  Plugin21
+} from "./worktree-1jhga1v4.js";
+import {
+  Plugin31
+} from "./worktree-923hzxn9.js";
+import {
+  Plugin20
+} from "./worktree-6pbkbdfq.js";
+import {
+  Plugin22
+} from "./worktree-85x45c9n.js";
+import {
+  Plugin15
+} from "./worktree-gbzh5ddg.js";
+import {
+  Plugin25
+} from "./worktree-9w3hzb16.js";
+import {
+  Plugin16
+} from "./worktree-d6hfhc31.js";
+import {
+  Service10,
+  node13
+} from "./worktree-6jnybvqn.js";
+import {
+  Plugin28
+} from "./worktree-10fngwpd.js";
+import {
+  Plugin24
+} from "./worktree-80aa9epv.js";
+import {
+  Plugin17
+} from "./worktree-6rrtkcjf.js";
+import {
+  Service59,
+  node64
+} from "./worktree-nrs7ag5n.js";
+import {
+  Plugin29
+} from "./worktree-5xgydngh.js";
+import {
+  Service69,
+  node74
+} from "./worktree-13bmfrpk.js";
+import {
+  Service51,
+  node54
+} from "./worktree-nsx3nvvw.js";
+import {
+  Service45,
+  node48
+} from "./worktree-f8jtvgnz.js";
+import {
+  Service13,
+  node16
+} from "./worktree-neswnnnm.js";
+import {
+  Service57,
+  node61
+} from "./worktree-tvvzt9x6.js";
+import {
+  Service30,
+  node34
+} from "./worktree-2qnjyx3m.js";
+import {
+  Service6,
+  node9
+} from "./worktree-m6vfy410.js";
+import {
+  Plugin13
+} from "./worktree-rp98wqty.js";
+import {
+  Plugin7
+} from "./worktree-xwc0gsaj.js";
+import {
+  Plugin8
+} from "./worktree-zycny061.js";
+import {
+  Plugin9
+} from "./worktree-cnd7bjr1.js";
+import {
+  Plugin3
+} from "./worktree-frwpyczr.js";
+import {
+  Service7,
+  node10
+} from "./worktree-11zk2b76.js";
+import {
+  Plugin10
+} from "./worktree-jjc9qbmx.js";
+import {
+  Plugin4
+} from "./worktree-emzfq4f9.js";
+import {
+  Plugin6
+} from "./worktree-cbmq2pzd.js";
+import {
+  Plugin12
+} from "./worktree-say7pt71.js";
+import {
+  Plugin11
+} from "./worktree-aw84nbjy.js";
+import {
+  Plugin2
+} from "./worktree-v5yv7hbv.js";
+import {
+  Plugin5
+} from "./worktree-18bdr5q6.js";
+import {
+  Plugin38
+} from "./worktree-amn7rrmc.js";
+import {
+  Plugin39
+} from "./worktree-hed2586q.js";
+import {
+  Plugin42
+} from "./worktree-7rtqyxd7.js";
+import {
+  ModelsDevPlugin2
+} from "./worktree-sj6racd4.js";
+import {
+  Plugin40
+} from "./worktree-c5gn303e.js";
+import {
+  ProviderPlugins2
+} from "./worktree-kvezfmw3.js";
+import {
+  WebSearchPlugins2
+} from "./worktree-5jbb3qyd.js";
+import {
+  Plugin41
+} from "./worktree-5g57spxg.js";
+import {
+  Plugin33
+} from "./worktree-n1s6t8b2.js";
+import {
+  Plugins2
+} from "./worktree-wg42tg3h.js";
+import {
+  Plugin44
+} from "./worktree-1cgg357y.js";
+import {
+  Plugin32
+} from "./worktree-ftevhb49.js";
+import {
+  Plugin43
+} from "./worktree-jvt1mp6m.js";
+import {
+  Plugin14
+} from "./worktree-c3w8vk9m.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/plugin/internal.ts
+var exports_internal = {};
+__export(exports_internal, {
+  PluginInternal: () => exports_internal,
+  list: () => list2,
+  requirements: () => requirements2
+});
+import { LayerNode } from "@opencode/util/effect/layer-node";
+import { httpClient } from "@opencode/util/effect/app-node-platform";
+import { AppProcess } from "@opencode/util/process";
+import { Context, Effect } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { Npm } from "@opencode/util/npm";
+import BrowserPlugin from "@opencode/plugin-browser";
+var services = [
+  Service73,
+  AppProcess.Service,
+  Service63,
+  Service44,
+  Service54,
+  Service66,
+  Service79,
+  Service52,
+  Service69,
+  Service51,
+  Service15,
+  Service8,
+  Service13,
+  FSUtil.Service,
+  Global.Service,
+  HttpClient.HttpClient,
+  Service68,
+  Service78,
+  Service64,
+  Service37,
+  Service58,
+  Service74,
+  Service57,
+  Service26,
+  Npm.Service,
+  Service70,
+  Service65,
+  Service7,
+  Service41,
+  Service30,
+  Service45,
+  Service17,
+  Service9,
+  Service6,
+  Service46,
+  Service48,
+  Service31,
+  Service39,
+  Service10,
+  Service67,
+  Service49,
+  Service55,
+  Service56,
+  Service59
+];
+var requirements2 = LayerNode.group([
+  node78,
+  AppProcess.node,
+  node68,
+  node47,
+  node58,
+  node71,
+  node84,
+  node55,
+  node74,
+  node54,
+  node18,
+  node11,
+  node16,
+  FSUtil.node,
+  Global.node,
+  httpClient,
+  node73,
+  node83,
+  node69,
+  node40,
+  node62,
+  node79,
+  node61,
+  node31,
+  Npm.node,
+  node75,
+  node70,
+  node10,
+  node44,
+  node34,
+  node48,
+  node21,
+  node12,
+  node9,
+  node49,
+  node51,
+  node35,
+  node42,
+  node13,
+  node72,
+  node52,
+  node59,
+  node60,
+  node64
+]);
+var pre = [
+  BrowserPlugin,
+  Plugin31,
+  Plugin40,
+  Plugin14,
+  Plugin32,
+  Plugin38,
+  Plugin42,
+  Plugin39,
+  Plugin41,
+  Plugin33,
+  ModelsDevPlugin2,
+  ...ProviderPlugins2,
+  ...WebSearchPlugins2,
+  Plugin13,
+  ...Plugins2,
+  Plugin7,
+  Plugin8,
+  Plugin9,
+  Plugin3,
+  Plugin45,
+  Plugin10,
+  Plugin4,
+  Plugin6,
+  Plugin12,
+  Plugin11,
+  Plugin2,
+  Plugin5,
+  Plugin43
+];
+var post = [
+  Plugin30,
+  Plugin15,
+  Plugin19,
+  Plugin23,
+  Plugin26,
+  Plugin18,
+  Plugin27,
+  Plugin21,
+  Plugin25,
+  Plugin16,
+  Plugin24,
+  Plugin28,
+  Plugin20,
+  Plugin17,
+  Plugin29,
+  Plugin44,
+  Plugin22
+];
+var list2 = Effect.fn("PluginInternal.list")(function* () {
+  const context = Context.pick(...services)(yield* Effect.context());
+  const resolve = (plugins) => plugins.map((plugin) => ({
+    id: plugin.id,
+    effect: (host) => plugin.effect(host).pipe(Effect.provide(context))
+  }));
+  return {
+    pre: resolve(pre),
+    post: resolve(post)
+  };
+});
+
+export { requirements2, list2, exports_internal };

package/dist/chunks/worktree-669tq793.js

@@ -0,0 +1,15 @@
+import {
+  createProviderPlugin2
+} from "./worktree-ym463w8f.js";
+
+// src/plugin/provider/gateway.ts
+var GatewayPlugin2 = createProviderPlugin2({
+  id: "opencode.provider.gateway",
+  package: "@ai-sdk/gateway",
+  load: async (options) => {
+    const { createGateway } = await import("@ai-sdk/gateway");
+    return createGateway(options);
+  }
+});
+
+export { GatewayPlugin2 };

package/dist/chunks/worktree-6jnybvqn.js

@@ -0,0 +1,155 @@
+import {
+  AbsolutePath2
+} from "./worktree-922hggd3.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/skill/discovery.ts
+var exports_discovery = {};
+__export(exports_discovery, {
+  Service: () => Service10,
+  SkillDiscovery: () => exports_discovery,
+  node: () => node13
+});
+import path from "path";
+import { Context, Effect, Layer, Schedule, Schema } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { httpClient } from "@opencode/util/effect/app-node-platform";
+import { Hash } from "@opencode/util/hash";
+var skillConcurrency = 4;
+var fileConcurrency = 8;
+function isSafeSegment(value) {
+  return value.length > 0 && value !== "." && value !== ".." && !value.includes("/") && !value.includes("\\") && !value.includes("\x00");
+}
+function isSafeRelativePath(value) {
+  const segments = value.split("/");
+  return value.length > 0 && !value.includes("\\") && !value.includes("\x00") && !value.includes("?") && !value.includes("#") && !URL.canParse(value) && !path.posix.isAbsolute(value) && !path.win32.isAbsolute(value) && segments.every((segment) => {
+    try {
+      return isSafeSegment(decodeURIComponent(segment));
+    } catch {
+      return false;
+    }
+  });
+}
+
+class IndexSkill extends Schema.Class("SkillDiscovery.IndexSkill")({
+  name: Schema.String,
+  version: Schema.optional(Schema.String),
+  files: Schema.Array(Schema.String)
+}) {
+}
+
+class Index extends Schema.Class("SkillDiscovery.Index")({
+  skills: Schema.Array(IndexSkill)
+}) {
+}
+
+class Service10 extends Context.Service()("@opencode/SkillDiscovery") {
+}
+var layer = Layer.effect(Service10, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const http = (yield* HttpClient.HttpClient).pipe(HttpClient.retryTransient({
+    retryOn: "errors-and-responses",
+    times: 2,
+    schedule: Schedule.exponential(200).pipe(Schedule.jittered)
+  }), HttpClient.filterStatusOk);
+  const download = Effect.fn("SkillDiscovery.download")(function* (url, destination) {
+    if (yield* fs.exists(destination).pipe(Effect.orDie))
+      return true;
+    return yield* HttpClientRequest.get(url).pipe(http.execute, Effect.flatMap((response) => response.arrayBuffer), Effect.flatMap((body) => fs.writeWithDirs(destination, new Uint8Array(body))), Effect.as(true), Effect.catch((error) => Effect.logError("failed to download skill file", { url, error }).pipe(Effect.as(false))));
+  });
+  return Service10.of({
+    pull: Effect.fn("SkillDiscovery.pull")(function* (url) {
+      const base = url.endsWith("/") ? url : `${url}/`;
+      const source = new URL(base);
+      const index = new URL("index.json", source).href;
+      const data = yield* HttpClientRequest.get(index).pipe(HttpClientRequest.acceptJson, http.execute, Effect.flatMap(HttpClientResponse.schemaBodyJson(Index)), Effect.catch((error) => Effect.logError("failed to fetch skill index", { url: index, error }).pipe(Effect.as(undefined))));
+      if (!data)
+        return [];
+      const sourceRoot = path.resolve(global.cache, "skills", Hash.fast(base));
+      return yield* Effect.forEach(data.skills.flatMap((skill) => {
+        if (!isSafeSegment(skill.name)) {
+          return [];
+        }
+        if (!skill.files.includes("SKILL.md") && !skill.files.includes(`${skill.name}.md`)) {
+          return [];
+        }
+        const root = path.resolve(sourceRoot, skill.name);
+        if (!FSUtil.contains(sourceRoot, root) || root === sourceRoot) {
+          return [];
+        }
+        const skillUrl = new URL(`${encodeURIComponent(skill.name)}/`, source);
+        const versionFile = path.join(root, ".opencode-version");
+        const files = skill.files.map((file) => {
+          if (!isSafeRelativePath(file))
+            return;
+          let resource;
+          try {
+            resource = new URL(file, skillUrl);
+          } catch {
+            return;
+          }
+          if (resource.origin !== source.origin)
+            return;
+          const destination = path.resolve(root, file);
+          if (!FSUtil.contains(root, destination) || destination === root)
+            return;
+          return {
+            url: resource.href,
+            destination,
+            file
+          };
+        });
+        if (!files.every((file) => file !== undefined))
+          return [];
+        return [{ skill, root, versionFile, files }];
+      }), ({ skill, root, versionFile, files }) => Effect.gen(function* () {
+        const version = skill.version;
+        const current = version === undefined ? undefined : yield* fs.readFileStringSafe(versionFile).pipe(Effect.orElseSucceed(() => {
+          return;
+        }));
+        if (version === undefined || current === version) {
+          yield* Effect.forEach(files, (file) => download(file.url, file.destination), {
+            concurrency: fileConcurrency,
+            discard: true
+          });
+        } else {
+          const token = crypto.randomUUID();
+          const staging = `${root}.tmp-${token}`;
+          const backup = `${root}.old-${token}`;
+          yield* Effect.gen(function* () {
+            const downloaded = yield* Effect.forEach(files, (file) => download(file.url, path.resolve(staging, file.file)), { concurrency: fileConcurrency });
+            if (!downloaded.every(Boolean))
+              return;
+            const exists = (yield* fs.exists(path.join(staging, "SKILL.md")).pipe(Effect.orDie)) || (yield* fs.exists(path.join(staging, `${skill.name}.md`)).pipe(Effect.orDie));
+            if (!exists)
+              return;
+            yield* fs.writeFileString(path.join(staging, ".opencode-version"), version);
+            yield* Effect.uninterruptible(Effect.gen(function* () {
+              const cached = yield* fs.exists(root).pipe(Effect.orDie);
+              if (cached)
+                yield* fs.rename(root, backup);
+              yield* fs.rename(staging, root).pipe(Effect.catch((error) => Effect.gen(function* () {
+                if (cached)
+                  yield* fs.rename(backup, root).pipe(Effect.ignore);
+                return yield* Effect.fail(error);
+              })));
+              if (cached)
+                yield* fs.remove(backup, { recursive: true, force: true }).pipe(Effect.ignore);
+            }));
+          }).pipe(Effect.catch((error) => Effect.logError("failed to refresh skill", { skill: skill.name, error })), Effect.ensuring(fs.remove(staging, { recursive: true, force: true }).pipe(Effect.ignore)));
+        }
+        const exists = (yield* fs.exists(path.join(root, "SKILL.md")).pipe(Effect.orDie)) || (yield* fs.exists(path.join(root, `${skill.name}.md`)).pipe(Effect.orDie));
+        return exists ? [AbsolutePath2.make(root)] : [];
+      }), { concurrency: skillConcurrency }).pipe(Effect.map((directories) => directories.flat()));
+    })
+  });
+}));
+var node13 = makeGlobalNode({ service: Service10, layer, deps: [httpClient, FSUtil.node, Global.node] });
+
+export { Service10, node13, exports_discovery };

package/dist/chunks/worktree-6msgmcgs.js

@@ -0,0 +1,75 @@
+import {
+  AbsolutePath2
+} from "./worktree-922hggd3.js";
+
+// src/database/path.ts
+import nodePath from "path";
+import { customType } from "drizzle-orm/sqlite-core";
+import { Schema } from "effect";
+function storagePath(input) {
+  if (process.platform !== "win32")
+    return input;
+  return input.replaceAll("\\", "/");
+}
+function isWindowsStoragePath(input) {
+  return /^[A-Za-z]:\//.test(input) || input.startsWith("//");
+}
+function absolute(input) {
+  const result = storagePath(input);
+  if (!nodePath.posix.isAbsolute(result) && !isWindowsStoragePath(result)) {
+    throw new Error(`Path is not absolute: ${input}`);
+  }
+  return result;
+}
+function toPlatform(input) {
+  if (process.platform !== "win32" || !isWindowsStoragePath(input))
+    return input;
+  return input.replaceAll("/", "\\");
+}
+var absoluteColumn2 = customType({
+  dataType() {
+    return "text";
+  },
+  toDriver(input) {
+    return absolute(input);
+  },
+  fromDriver(input) {
+    return AbsolutePath2.make(toPlatform(absolute(input)));
+  }
+});
+var directoryColumn2 = customType({
+  dataType() {
+    return "text";
+  },
+  toDriver(input) {
+    return input ? absolute(input) : input;
+  },
+  fromDriver(input) {
+    return input ? toPlatform(absolute(input)) : input;
+  }
+});
+var pathColumn2 = customType({
+  dataType() {
+    return "text";
+  },
+  toDriver(input) {
+    return storagePath(input);
+  },
+  fromDriver(input) {
+    return storagePath(input);
+  }
+});
+var decodeAbsoluteArray = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Array(Schema.String)));
+var absoluteArrayColumn2 = customType({
+  dataType() {
+    return "text";
+  },
+  toDriver(input) {
+    return JSON.stringify(input.map(absolute));
+  },
+  fromDriver(input) {
+    return decodeAbsoluteArray(input).map((item) => AbsolutePath2.make(toPlatform(absolute(item))));
+  }
+});
+
+export { absoluteColumn2, directoryColumn2, pathColumn2, absoluteArrayColumn2 };