@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-pf0ndnmr.js

@@ -0,0 +1,183 @@
+import {
+  collectBoundedResponseBody
+} from "./permission-jve7t217.js";
+import {
+  exports_permission
+} from "./permission-qa8qg9jd.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/tool/plugin/webfetch.ts
+var exports_webfetch = {};
+__export(exports_webfetch, {
+  name: () => name,
+  extractTextFromHTML: () => extractTextFromHTML,
+  description: () => description,
+  convertHTMLToMarkdown: () => convertHTMLToMarkdown,
+  WebFetchTool: () => exports_webfetch,
+  Plugin: () => Plugin,
+  MAX_TIMEOUT_SECONDS: () => MAX_TIMEOUT_SECONDS,
+  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES,
+  Input: () => Input,
+  DEFAULT_TIMEOUT_SECONDS: () => DEFAULT_TIMEOUT_SECONDS
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { Duration, Effect, Schema } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { Parser } from "htmlparser2";
+import TurndownService from "turndown";
+var name = "webfetch";
+var MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
+var DEFAULT_TIMEOUT_SECONDS = 30;
+var MAX_TIMEOUT_SECONDS = 120;
+var description = `Fetch content from an HTTP or HTTPS URL and return it as text, markdown, or HTML. Markdown is the default.
+
+Use a more targeted tool when one is available. This tool is read-only. Large text results may be replaced with a preview while the complete output is retained in managed storage.`;
+var Timeout = Schema.Finite.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(MAX_TIMEOUT_SECONDS));
+var Input = Schema.Struct({
+  url: Schema.String.annotate({ description: "The HTTP or HTTPS URL to fetch content from" }),
+  format: Schema.Literals(["text", "markdown", "html"]).annotate({ description: "The format to return the content in. Defaults to markdown." }).pipe(Schema.withDecodingDefaultKey(Effect.succeed("markdown"))),
+  timeout: Schema.optionalKey(Timeout).annotate({
+    description: `Optional timeout in seconds (maximum: ${MAX_TIMEOUT_SECONDS})`
+  })
+});
+var Output = Schema.Struct({
+  url: Schema.String,
+  contentType: Schema.String,
+  format: Input.fields.format,
+  output: Schema.String
+});
+var acceptHeader = (format) => {
+  switch (format) {
+    case "markdown":
+      return "text/markdown;q=1.0, text/x-markdown;q=0.9, text/plain;q=0.8, text/html;q=0.7, */*;q=0.1";
+    case "text":
+      return "text/plain;q=1.0, text/markdown;q=0.9, text/html;q=0.8, */*;q=0.1";
+    case "html":
+      return "text/html;q=1.0, application/xhtml+xml;q=0.9, text/plain;q=0.8, text/markdown;q=0.7, */*;q=0.1";
+  }
+  return "*/*";
+};
+var headers = (format, userAgent) => ({
+  "User-Agent": userAgent,
+  Accept: acceptHeader(format),
+  "Accept-Language": "en-US,en;q=0.9"
+});
+var browserUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36";
+var isCloudflareChallenge = (error) => {
+  if (!error || typeof error !== "object" || !("reason" in error))
+    return false;
+  const reason = error.reason;
+  if (!reason || typeof reason !== "object" || !("_tag" in reason) || reason._tag !== "StatusCodeError" || !("response" in reason))
+    return false;
+  const response = reason.response;
+  return response.status === 403 && response.headers["cf-mitigated"] === "challenge";
+};
+var request = (url, format, userAgent = browserUserAgent) => HttpClientRequest.get(url).pipe(HttpClientRequest.setHeaders(headers(format, userAgent)));
+var assertHttpUrl = (url) => {
+  if (url.protocol !== "http:" && url.protocol !== "https:")
+    throw new Error("URL must use http:// or https://");
+};
+var execute = (http, url, format, userAgent = browserUserAgent) => http.execute(request(url, format, userAgent)).pipe(Effect.flatMap(HttpClientResponse.filterStatusOk));
+var collectBody = (response) => collectBoundedResponseBody(response, MAX_RESPONSE_BYTES, () => new Error(`Response too large (exceeds ${MAX_RESPONSE_BYTES} byte limit)`));
+var mimeFrom = (contentType) => contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+var isImageAttachment = (mime) => mime.startsWith("image/") && mime !== "image/svg+xml" && mime !== "image/vnd.fastbidsheet";
+var isTextualMime = (mime) => !mime || mime.startsWith("text/") || mime === "application/json" || mime.endsWith("+json") || mime === "application/xml" || mime.endsWith("+xml") || mime === "application/javascript" || mime === "application/x-javascript";
+var convert = (content, contentType, format) => {
+  if (!contentType.includes("text/html"))
+    return content;
+  if (format === "markdown")
+    return convertHTMLToMarkdown(content);
+  if (format === "text")
+    return extractTextFromHTML(content);
+  return content;
+};
+var Plugin = {
+  id: "opencode.tool.webfetch",
+  effect: Effect.fn("WebFetchTool.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient;
+    const permission = yield* exports_permission.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description,
+      input: Input,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        yield* Effect.try({
+          try: () => assertHttpUrl(new URL(input.url)),
+          catch: (error) => error
+        });
+        yield* permission.assert({
+          action: name,
+          resources: [input.url],
+          save: ["*"],
+          metadata: input,
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source: { type: "tool", messageID: context.messageID, id: context.id }
+        });
+        const { body, contentType } = yield* Effect.gen(function* () {
+          const response = yield* execute(http, input.url, input.format).pipe(Effect.catchIf(isCloudflareChallenge, () => execute(http, input.url, input.format, "opencode")));
+          const contentType2 = response.headers["content-type"] || "";
+          const mime = mimeFrom(contentType2);
+          if (isImageAttachment(mime))
+            return yield* Effect.fail(new Error(`Unsupported fetched image content type: ${mime}`));
+          if (!isTextualMime(mime))
+            return yield* Effect.fail(new Error(`Unsupported fetched file content type: ${mime}`));
+          return { body: yield* collectBody(response), contentType: contentType2 };
+        }).pipe(Effect.timeoutOrElse({
+          duration: Duration.seconds(input.timeout ?? DEFAULT_TIMEOUT_SECONDS),
+          orElse: () => Effect.fail(new Error("Request timed out"))
+        }));
+        const content = new TextDecoder().decode(body);
+        const output = yield* Effect.try({
+          try: () => convert(content, contentType, input.format),
+          catch: (error) => error
+        });
+        const result = {
+          url: input.url,
+          contentType,
+          format: input.format,
+          output
+        };
+        return { output: result, content: result.output, metadata: { contentType: result.contentType } };
+      }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Unable to fetch ${input.url}`, error })))
+    })).pipe(Effect.orDie);
+  })
+};
+function extractTextFromHTML(html) {
+  let text = "";
+  let skipDepth = 0;
+  const parser = new Parser({
+    onopentag(name2) {
+      if (skipDepth > 0 || ["script", "style", "noscript", "iframe", "object", "embed"].includes(name2))
+        skipDepth++;
+    },
+    ontext(input) {
+      if (skipDepth === 0)
+        text += input;
+    },
+    onclosetag() {
+      if (skipDepth > 0)
+        skipDepth--;
+    }
+  });
+  parser.write(html);
+  parser.end();
+  return text.trim();
+}
+function convertHTMLToMarkdown(html) {
+  const turndown = new TurndownService({
+    headingStyle: "atx",
+    hr: "---",
+    bulletListMarker: "-",
+    codeBlockStyle: "fenced",
+    emDelimiter: "*"
+  });
+  turndown.remove(["script", "style", "meta", "link"]);
+  return turndown.turndown(html);
+}
+
+export { name, MAX_RESPONSE_BYTES, DEFAULT_TIMEOUT_SECONDS, MAX_TIMEOUT_SECONDS, description, Input, Plugin, extractTextFromHTML, convertHTMLToMarkdown, exports_webfetch };

package/dist/chunks/permission-pfqehjmy.js

@@ -0,0 +1,18 @@
+import {
+  createProviderPlugin
+} from "./permission-0zz82cjq.js";
+import {
+  __require
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/provider/deepinfra.ts
+var DeepInfraPlugin = createProviderPlugin({
+  id: "opencode.provider.deepinfra",
+  package: "@ai-sdk/deepinfra",
+  load: async (options) => {
+    const { createDeepInfra } = await import("@ai-sdk/deepinfra");
+    return createDeepInfra(options);
+  }
+});
+
+export { DeepInfraPlugin };

package/dist/chunks/permission-ph1me6ah.js

@@ -0,0 +1,156 @@
+import {
+  MAX_PATCH_BYTES,
+  MAX_TOTAL_PATCH_BYTES,
+  PATCH_CONTEXT_LINES,
+  addPatch,
+  chunksByFile,
+  countPatch,
+  deletePatch,
+  emptyPatch
+} from "./permission-vz89hfgr.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/vcs/hg.ts
+var exports_hg = {};
+__export(exports_hg, {
+  make: () => make,
+  VcsHg: () => exports_hg
+});
+import path from "path";
+import { Effect } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+function make(proc, fs, input) {
+  const hg = makeHg(proc, input.worktree);
+  const scope = path.relative(input.worktree, input.directory) || ".";
+  const patchFor = Effect.fnUntraced(function* (item, rev, chunk) {
+    if (chunk !== undefined)
+      return chunk;
+    if (item.code === "?") {
+      const content = yield* fs.readFileString(path.join(input.worktree, item.file)).pipe(Effect.catch(() => Effect.succeed(undefined)));
+      if (content === undefined || Buffer.byteLength(content) > MAX_PATCH_BYTES)
+        return emptyPatch(item.file);
+      return addPatch(item.file, content);
+    }
+    if (item.code === "!") {
+      const content = yield* hg.cat(rev ?? ".", item.file);
+      if (content === undefined || Buffer.byteLength(content) > MAX_PATCH_BYTES)
+        return emptyPatch(item.file);
+      return deletePatch(item.file, content);
+    }
+    return emptyPatch(item.file);
+  });
+  const diffAgainst = Effect.fnUntraced(function* (rev, options) {
+    const [items, batch] = yield* Effect.all([hg.status(rev, scope), hg.diff(rev, scope, { context: options?.context ?? PATCH_CONTEXT_LINES })], { concurrency: 2 });
+    const chunks = chunksByFile(batch, () => {
+      return;
+    });
+    const list = [];
+    for (const item of items.toSorted((a, b) => a.file.localeCompare(b.file))) {
+      const patch = yield* patchFor(item, rev, chunks.get(item.file));
+      const counts = countPatch(patch);
+      list.push({
+        file: item.file,
+        patch,
+        additions: counts.additions,
+        deletions: counts.deletions,
+        status: item.status
+      });
+    }
+    return list;
+  });
+  return {
+    info: Effect.fn("VcsHg.info")(function* () {
+      return { branch: { current: yield* hg.branch(), default: "default" } };
+    }),
+    status: Effect.fn("VcsHg.status")(function* () {
+      const [items, batch] = yield* Effect.all([hg.status(undefined, scope), hg.diff(undefined, scope, { context: 0 })], { concurrency: 2 });
+      const chunks = chunksByFile(batch, () => {
+        return;
+      });
+      return yield* Effect.forEach(items.toSorted((a, b) => a.file.localeCompare(b.file)), (item) => Effect.gen(function* () {
+        const patch = yield* patchFor(item, undefined, chunks.get(item.file));
+        const counts = countPatch(patch);
+        return {
+          file: item.file,
+          additions: counts.additions,
+          deletions: counts.deletions,
+          status: item.status
+        };
+      }));
+    }),
+    diff: Effect.fn("VcsHg.diff")(function* (mode, options) {
+      if (mode === "working")
+        return yield* diffAgainst(undefined, options);
+      const branch = yield* hg.branch();
+      if (!branch || branch === "default")
+        return [];
+      const ancestor = yield* hg.ancestor();
+      if (!ancestor)
+        return [];
+      return yield* diffAgainst(ancestor, options);
+    })
+  };
+}
+var kind = (code) => {
+  if (code === "A" || code === "?")
+    return "added";
+  if (code === "R" || code === "!")
+    return "deleted";
+  return "modified";
+};
+function makeHg(proc, worktree) {
+  const run = Effect.fnUntraced(function* (args, opts) {
+    const result = yield* proc.run(ChildProcess.make("hg", args, {
+      cwd: worktree,
+      env: { HGPLAIN: "1" },
+      extendEnv: true,
+      stdin: "ignore"
+    }), { maxOutputBytes: opts?.maxOutputBytes });
+    return {
+      exitCode: result.exitCode,
+      text: () => result.stdout.toString("utf8"),
+      truncated: result.stdoutTruncated || result.stderrTruncated
+    };
+  }, Effect.catch(() => Effect.succeed({ exitCode: 1, text: () => "", truncated: false })));
+  const status = Effect.fn("VcsHg.statusNames")(function* (rev, scope) {
+    const result = yield* run(["status", "-0", ...rev ? ["--rev", rev] : [], scope]);
+    if (result.exitCode !== 0)
+      return [];
+    return result.text().split("\x00").filter(Boolean).flatMap((entry) => {
+      const code = entry.slice(0, 1);
+      const file = entry.slice(2);
+      if (!file)
+        return [];
+      return [{ file, code, status: kind(code) }];
+    });
+  });
+  const diff = Effect.fn("VcsHg.diffPatch")(function* (rev, scope, options) {
+    const result = yield* run(["diff", "--git", "--unified", String(options.context), ...rev ? ["-r", rev] : [], scope], { maxOutputBytes: MAX_TOTAL_PATCH_BYTES });
+    if (result.exitCode !== 0)
+      return { text: "", truncated: false };
+    return { text: result.text(), truncated: result.truncated };
+  });
+  const branch = Effect.fn("VcsHg.branch")(function* () {
+    const result = yield* run(["branch"]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const ancestor = Effect.fn("VcsHg.ancestor")(function* () {
+    const result = yield* run(["log", "-r", "ancestor(., default)", "-T", "{node}"]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const cat = Effect.fn("VcsHg.cat")(function* (rev, file) {
+    const result = yield* run(["cat", "-r", rev, "--", file], { maxOutputBytes: MAX_PATCH_BYTES });
+    if (result.exitCode !== 0 || result.truncated)
+      return;
+    return result.text();
+  });
+  return { status, diff, branch, ancestor, cat };
+}
+
+export { make, exports_hg };

package/dist/chunks/permission-pq4b4pqk.js

@@ -0,0 +1,29 @@
+import {
+  PositiveInt
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/v1/config/server.ts
+var exports_server = {};
+__export(exports_server, {
+  Server: () => Server,
+  ConfigServerV1: () => exports_server
+});
+import { Schema } from "effect";
+var Server = Schema.Struct({
+  port: Schema.optional(PositiveInt).annotate({
+    description: "Port to listen on"
+  }),
+  hostname: Schema.optional(Schema.String).annotate({ description: "Hostname to listen on" }),
+  mdns: Schema.optional(Schema.Boolean).annotate({ description: "Enable mDNS service discovery" }),
+  mdnsDomain: Schema.optional(Schema.String).annotate({
+    description: "Custom domain name for mDNS service (default: opencode.local)"
+  }),
+  cors: Schema.optional(Schema.mutable(Schema.Array(Schema.String))).annotate({
+    description: "Additional domains to allow for CORS"
+  })
+}).annotate({ identifier: "ServerConfig" });
+
+export { Server, exports_server };

package/dist/chunks/permission-prf9bavk.js

@@ -0,0 +1,96 @@
+import {
+  exports_mcp
+} from "./permission-1c00jchy.js";
+import {
+  exports_app
+} from "./permission-50jxp3hw.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/websearch/parallel.ts
+var exports_parallel = {};
+__export(exports_parallel, {
+  endpoint: () => endpoint,
+  WebSearchParallel: () => exports_parallel,
+  Plugin: () => Plugin
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+var endpoint = "https://search.parallel.ai/mcp";
+var McpInput = Schema.Struct({
+  objective: Schema.String,
+  search_queries: Schema.Array(Schema.String),
+  model_name: Schema.String.check(Schema.isMaxLength(100)).pipe(Schema.optional)
+});
+var SearchResponse = Schema.Struct({
+  search_id: Schema.String,
+  results: Schema.Array(Schema.Struct({
+    url: Schema.String,
+    title: Schema.NullOr(Schema.String).pipe(Schema.optional),
+    publish_date: Schema.NullOr(Schema.String).pipe(Schema.optional),
+    excerpts: Schema.Array(Schema.String)
+  })),
+  warnings: Schema.NullOr(Schema.Array(Schema.Struct({
+    type: Schema.Literals(["spec_validation_warning", "input_validation_warning", "warning"]),
+    message: Schema.String,
+    detail: Schema.NullOr(Schema.Record(Schema.String, Schema.Json)).pipe(Schema.optional)
+  }))).pipe(Schema.optional),
+  usage: Schema.NullOr(Schema.Array(Schema.Struct({
+    name: Schema.String,
+    count: Schema.Int
+  }))).pipe(Schema.optional),
+  session_id: Schema.String
+});
+var McpOutput = Schema.Struct({
+  content: Schema.Array(Schema.Struct({ type: Schema.Literal("text"), text: Schema.String })),
+  structuredContent: SearchResponse
+});
+var Plugin = define({
+  id: "opencode.websearch.parallel",
+  effect: Effect.fn("WebSearchParallel.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient;
+    yield* ctx.integration.transform((draft) => {
+      draft.update("parallel", (integration) => integration.name = "Parallel");
+      draft.method.update({
+        integrationID: "parallel",
+        method: { type: "key" }
+      });
+      draft.method.update({
+        integrationID: "parallel",
+        method: { type: "env", names: ["PARALLEL_API_KEY"] }
+      });
+    });
+    yield* ctx.websearch.transform((draft) => {
+      draft.add({
+        id: "parallel",
+        name: "Parallel",
+        execute: (input) => Effect.gen(function* () {
+          const connection = yield* ctx.integration.connection.active("parallel");
+          const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined;
+          const result = yield* exports_mcp.call(http, endpoint, "web_search", { input: McpInput, output: McpOutput }, {
+            objective: input.query,
+            search_queries: [input.query]
+          }, {
+            "User-Agent": exports_app.useragent(ctx.app),
+            ...credential?.type === "key" ? { Authorization: `Bearer ${credential.key}` } : {}
+          });
+          return result?.structuredContent.results.map((item) => {
+            const published = item.publish_date ? Date.parse(item.publish_date) : undefined;
+            return {
+              url: item.url,
+              ...item.title ? { title: item.title } : {},
+              ...item.excerpts.length ? { content: item.excerpts.join(`
+
+`) } : {},
+              time: { ...published !== undefined && Number.isFinite(published) ? { published } : {} }
+            };
+          }) ?? [];
+        })
+      });
+    });
+  })
+});
+
+export { endpoint, Plugin, exports_parallel };

package/dist/chunks/permission-prg6vhnf.js

@@ -0,0 +1,41 @@
+import {
+  exports_integration
+} from "./permission-zxzx89zt.js";
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+
+// src/plugin/provider/llmgateway.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var LLMGatewayPlugin = define({
+  id: "opencode.provider.llmgateway",
+  effect: Effect.fn(function* (ctx) {
+    const integrations = yield* exports_integration.Service;
+    const configured = new Set((yield* integrations.list()).map((integration) => integration.id));
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (item.provider.disabled)
+          continue;
+        if (!exports_provider.isAISDK(item.provider.package))
+          continue;
+        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/openai-compatible")
+          continue;
+        if (item.provider.settings?.baseURL !== "https://api.llmgateway.io/v1")
+          continue;
+        if (!configured.has(exports_integration.ID.make(item.provider.id)))
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = {
+            ...provider.headers,
+            "HTTP-Referer": "https://opencode.ai/",
+            "X-Title": "opencode",
+            "X-Source": "opencode"
+          };
+        });
+      }
+    });
+  })
+});
+
+export { LLMGatewayPlugin };