@clwnd/opencode 0.1.0

package/README.md

@@ -0,0 +1,5 @@
+```
+curl -fsSL https://raw.githubusercontent.com/adiled/clwnd/main/install | bash
+```
+
+clwnd.

package/dist/index.js

@@ -0,0 +1,649 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.bun/secure-json-parse@2.7.0/node_modules/secure-json-parse/index.js
+var require_secure_json_parse = __commonJS({
+  "../../node_modules/.bun/secure-json-parse@2.7.0/node_modules/secure-json-parse/index.js"(exports, module) {
+    "use strict";
+    var hasBuffer = typeof Buffer !== "undefined";
+    var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+    var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+    function _parse(text, reviver, options) {
+      if (options == null) {
+        if (reviver !== null && typeof reviver === "object") {
+          options = reviver;
+          reviver = void 0;
+        }
+      }
+      if (hasBuffer && Buffer.isBuffer(text)) {
+        text = text.toString();
+      }
+      if (text && text.charCodeAt(0) === 65279) {
+        text = text.slice(1);
+      }
+      const obj = JSON.parse(text, reviver);
+      if (obj === null || typeof obj !== "object") {
+        return obj;
+      }
+      const protoAction = options && options.protoAction || "error";
+      const constructorAction = options && options.constructorAction || "error";
+      if (protoAction === "ignore" && constructorAction === "ignore") {
+        return obj;
+      }
+      if (protoAction !== "ignore" && constructorAction !== "ignore") {
+        if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
+          return obj;
+        }
+      } else if (protoAction !== "ignore" && constructorAction === "ignore") {
+        if (suspectProtoRx.test(text) === false) {
+          return obj;
+        }
+      } else {
+        if (suspectConstructorRx.test(text) === false) {
+          return obj;
+        }
+      }
+      return filter(obj, { protoAction, constructorAction, safe: options && options.safe });
+    }
+    function filter(obj, { protoAction = "error", constructorAction = "error", safe } = {}) {
+      let next = [obj];
+      while (next.length) {
+        const nodes = next;
+        next = [];
+        for (const node of nodes) {
+          if (protoAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "__proto__")) {
+            if (safe === true) {
+              return null;
+            } else if (protoAction === "error") {
+              throw new SyntaxError("Object contains forbidden prototype property");
+            }
+            delete node.__proto__;
+          }
+          if (constructorAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+            if (safe === true) {
+              return null;
+            } else if (constructorAction === "error") {
+              throw new SyntaxError("Object contains forbidden prototype property");
+            }
+            delete node.constructor;
+          }
+          for (const key in node) {
+            const value = node[key];
+            if (value && typeof value === "object") {
+              next.push(value);
+            }
+          }
+        }
+      }
+      return obj;
+    }
+    function parse(text, reviver, options) {
+      const stackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = 0;
+      try {
+        return _parse(text, reviver, options);
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit;
+      }
+    }
+    function safeParse(text, reviver) {
+      const stackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = 0;
+      try {
+        return _parse(text, reviver, { safe: true });
+      } catch (_e) {
+        return null;
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit;
+      }
+    }
+    module.exports = parse;
+    module.exports.default = parse;
+    module.exports.parse = parse;
+    module.exports.safeParse = safeParse;
+    module.exports.scan = filter;
+  }
+});
+
+// ../../node_modules/.bun/@ai-sdk+provider@1.1.3/node_modules/@ai-sdk/provider/dist/index.mjs
+var marker = "vercel.ai.error";
+var symbol = Symbol.for(marker);
+var _a;
+var _AISDKError = class _AISDKError2 extends Error {
+  /**
+   * Creates an AI SDK Error.
+   *
+   * @param {Object} params - The parameters for creating the error.
+   * @param {string} params.name - The name of the error.
+   * @param {string} params.message - The error message.
+   * @param {unknown} [params.cause] - The underlying cause of the error.
+   */
+  constructor({
+    name: name14,
+    message,
+    cause
+  }) {
+    super(message);
+    this[_a] = true;
+    this.name = name14;
+    this.cause = cause;
+  }
+  /**
+   * Checks if the given error is an AI SDK Error.
+   * @param {unknown} error - The error to check.
+   * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
+   */
+  static isInstance(error) {
+    return _AISDKError2.hasMarker(error, marker);
+  }
+  static hasMarker(error, marker15) {
+    const markerSymbol = Symbol.for(marker15);
+    return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
+  }
+};
+_a = symbol;
+var AISDKError = _AISDKError;
+var name = "AI_APICallError";
+var marker2 = `vercel.ai.error.${name}`;
+var symbol2 = Symbol.for(marker2);
+var _a2;
+_a2 = symbol2;
+var name2 = "AI_EmptyResponseBodyError";
+var marker3 = `vercel.ai.error.${name2}`;
+var symbol3 = Symbol.for(marker3);
+var _a3;
+_a3 = symbol3;
+var name3 = "AI_InvalidArgumentError";
+var marker4 = `vercel.ai.error.${name3}`;
+var symbol4 = Symbol.for(marker4);
+var _a4;
+var InvalidArgumentError = class extends AISDKError {
+  constructor({
+    message,
+    cause,
+    argument
+  }) {
+    super({ name: name3, message, cause });
+    this[_a4] = true;
+    this.argument = argument;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker4);
+  }
+};
+_a4 = symbol4;
+var name4 = "AI_InvalidPromptError";
+var marker5 = `vercel.ai.error.${name4}`;
+var symbol5 = Symbol.for(marker5);
+var _a5;
+_a5 = symbol5;
+var name5 = "AI_InvalidResponseDataError";
+var marker6 = `vercel.ai.error.${name5}`;
+var symbol6 = Symbol.for(marker6);
+var _a6;
+_a6 = symbol6;
+var name6 = "AI_JSONParseError";
+var marker7 = `vercel.ai.error.${name6}`;
+var symbol7 = Symbol.for(marker7);
+var _a7;
+_a7 = symbol7;
+var name7 = "AI_LoadAPIKeyError";
+var marker8 = `vercel.ai.error.${name7}`;
+var symbol8 = Symbol.for(marker8);
+var _a8;
+_a8 = symbol8;
+var name8 = "AI_LoadSettingError";
+var marker9 = `vercel.ai.error.${name8}`;
+var symbol9 = Symbol.for(marker9);
+var _a9;
+_a9 = symbol9;
+var name9 = "AI_NoContentGeneratedError";
+var marker10 = `vercel.ai.error.${name9}`;
+var symbol10 = Symbol.for(marker10);
+var _a10;
+_a10 = symbol10;
+var name10 = "AI_NoSuchModelError";
+var marker11 = `vercel.ai.error.${name10}`;
+var symbol11 = Symbol.for(marker11);
+var _a11;
+_a11 = symbol11;
+var name11 = "AI_TooManyEmbeddingValuesForCallError";
+var marker12 = `vercel.ai.error.${name11}`;
+var symbol12 = Symbol.for(marker12);
+var _a12;
+_a12 = symbol12;
+var name12 = "AI_TypeValidationError";
+var marker13 = `vercel.ai.error.${name12}`;
+var symbol13 = Symbol.for(marker13);
+var _a13;
+_a13 = symbol13;
+var name13 = "AI_UnsupportedFunctionalityError";
+var marker14 = `vercel.ai.error.${name13}`;
+var symbol14 = Symbol.for(marker14);
+var _a14;
+_a14 = symbol14;
+
+// ../../node_modules/.bun/nanoid@3.3.11/node_modules/nanoid/non-secure/index.js
+var customAlphabet = (alphabet, defaultSize = 21) => {
+  return (size = defaultSize) => {
+    let id = "";
+    let i = size | 0;
+    while (i--) {
+      id += alphabet[Math.random() * alphabet.length | 0];
+    }
+    return id;
+  };
+};
+
+// ../../node_modules/.bun/@ai-sdk+provider-utils@2.2.8+d6123d32214422cb/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+var import_secure_json_parse = __toESM(require_secure_json_parse(), 1);
+var createIdGenerator = ({
+  prefix,
+  size: defaultSize = 16,
+  alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  separator = "-"
+} = {}) => {
+  const generator = customAlphabet(alphabet, defaultSize);
+  if (prefix == null) {
+    return generator;
+  }
+  if (alphabet.includes(separator)) {
+    throw new InvalidArgumentError({
+      argument: "separator",
+      message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
+    });
+  }
+  return (size) => `${prefix}${separator}${generator(size)}`;
+};
+var generateId = createIdGenerator();
+var { btoa, atob } = globalThis;
+
+// provider.ts
+function defaultSocketPath() {
+  const runtime = process.env.XDG_RUNTIME_DIR;
+  if (runtime) return `${runtime}/clwnd/clwnd.sock`;
+  return "/tmp/clwnd.sock";
+}
+var SOCK_PATH = (process.env.CLWND_SOCKET ?? defaultSocketPath()) + ".http";
+function streamCall(msg) {
+  return fetch("http://localhost/stream", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(msg),
+    unix: SOCK_PATH
+  });
+}
+async function ipcCall(msg) {
+  const r = await fetch("http://localhost/", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(msg),
+    unix: SOCK_PATH
+  });
+  if (!r.ok) throw new Error(`clwnd IPC ${r.status}`);
+}
+function extractText(prompt) {
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    const m = prompt[i];
+    if (m.role === "user") {
+      if (typeof m.content === "string") return m.content;
+      if (Array.isArray(m.content)) {
+        for (const p of m.content) {
+          if (p.type === "text" && p.text) return p.text;
+        }
+      }
+    }
+  }
+  return "";
+}
+function parseNDJSON(buffer, sessionId) {
+  const messages = [];
+  const lines = buffer.split("\n");
+  const remaining = lines.pop() ?? "";
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const msg = JSON.parse(line);
+      messages.push(msg);
+    } catch {
+    }
+  }
+  return { messages, remaining };
+}
+var ClwndModel = class {
+  constructor(modelId, config = {}) {
+    this.config = config;
+    this.modelId = modelId;
+  }
+  specificationVersion = "v2";
+  modelId;
+  provider = "clwnd";
+  supportedUrls = {};
+  async doGenerate(opts) {
+    const sid = opts.headers?.["x-opencode-session"] ?? generateId();
+    const text = extractText(opts.prompt);
+    const warnings = [];
+    const cwd = this.config.cwd ?? process.cwd();
+    let reasoning = "";
+    let responseText = "";
+    const toolCalls = [];
+    const toolInputAccum = /* @__PURE__ */ new Map();
+    let resolved = false;
+    const result = await new Promise((resolve, reject) => {
+      const abort = () => {
+        if (resolved) return;
+        resolved = true;
+        ipcCall({ action: "destroy", opencodeSessionId: sid }).catch(() => {
+        });
+        reject(new Error("aborted"));
+      };
+      opts.abortSignal?.addEventListener("abort", abort);
+      streamCall({
+        action: "stream",
+        opencodeSessionId: sid,
+        cwd,
+        modelId: this.modelId,
+        text
+      }).then(async (resp) => {
+        if (!resp.body) {
+          abort();
+          return;
+        }
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const { messages, remaining } = parseNDJSON(buffer, sid);
+            buffer = remaining;
+            for (const msg of messages) {
+              if (msg.action === "chunk") {
+                const ct = msg.chunkType;
+                if (ct === "reasoning_delta" && typeof msg.delta === "string") reasoning += msg.delta;
+                if (ct === "text_delta" && typeof msg.delta === "string") responseText += msg.delta;
+                if (ct === "tool_input_start" && msg.toolCallId) toolInputAccum.set(msg.toolCallId, "");
+                if (ct === "tool_input_delta" && msg.toolCallId && msg.partialJson) {
+                  const prev = toolInputAccum.get(msg.toolCallId) ?? "";
+                  toolInputAccum.set(msg.toolCallId, prev + msg.partialJson);
+                }
+                if (ct === "tool_call" && msg.toolCallId && msg.toolName) {
+                  const accumulated = toolInputAccum.get(msg.toolCallId) ?? "{}";
+                  let input = {};
+                  try {
+                    input = JSON.parse(accumulated);
+                  } catch {
+                    input = {};
+                  }
+                  toolCalls.push({
+                    type: "tool-call",
+                    toolCallId: msg.toolCallId,
+                    toolName: msg.toolName,
+                    input
+                  });
+                }
+              }
+              if (msg.action === "finish") {
+                if (resolved) return;
+                resolved = true;
+                const finishReason = msg.finishReason ?? "stop";
+                const usage = msg.usage ?? { inputTokens: void 0, outputTokens: void 0, totalTokens: void 0 };
+                const providerMetadata = msg.providerMetadata ?? {};
+                const content = [];
+                if (reasoning) content.push({ type: "reasoning", text: reasoning });
+                if (responseText) content.push({ type: "text", text: responseText });
+                content.push(...toolCalls);
+                opts.abortSignal?.removeEventListener("abort", abort);
+                reader.releaseLock();
+                resolve({ content, finishReason, usage, providerMetadata });
+                return;
+              }
+              if (msg.action === "error") {
+                if (resolved) return;
+                resolved = true;
+                opts.abortSignal?.removeEventListener("abort", abort);
+                reader.releaseLock();
+                reject(new Error(msg.message));
+                return;
+              }
+            }
+          }
+        } finally {
+          try {
+            reader.releaseLock();
+          } catch {
+          }
+        }
+        if (!resolved) {
+          resolved = true;
+          reject(new Error("stream ended without finish"));
+        }
+      }).catch((e) => {
+        if (!resolved) {
+          resolved = true;
+          reject(e);
+        }
+      });
+      setTimeout(() => {
+        if (!resolved) abort();
+      }, 12e4);
+    });
+    return {
+      ...result,
+      warnings,
+      request: { body: { text } },
+      response: { id: sid, timestamp: /* @__PURE__ */ new Date(), modelId: this.modelId }
+    };
+  }
+  async doStream(opts) {
+    const sid = opts.headers?.["x-opencode-session"] ?? generateId();
+    const text = extractText(opts.prompt);
+    const warnings = [];
+    const cwd = this.config.cwd ?? process.cwd();
+    const self = this;
+    const toolInputAccum = /* @__PURE__ */ new Map();
+    const stream = new ReadableStream({
+      async start(controller) {
+        const textId = generateId();
+        const reasoningId = generateId();
+        let done = false;
+        let reader = null;
+        let textStarted = false;
+        let reasoningStarted = false;
+        function emit(part) {
+          if (done) return;
+          try {
+            controller.enqueue(part);
+          } catch {
+            done = true;
+          }
+        }
+        function close() {
+          if (done) return;
+          done = true;
+          try {
+            reader?.releaseLock();
+          } catch {
+          }
+          try {
+            controller.close();
+          } catch {
+          }
+        }
+        opts.abortSignal?.addEventListener("abort", () => {
+          ipcCall({ action: "destroy", opencodeSessionId: sid }).catch(() => {
+          });
+          close();
+        });
+        let resp;
+        try {
+          resp = await streamCall({
+            action: "stream",
+            opencodeSessionId: sid,
+            cwd,
+            modelId: self.modelId,
+            text
+          });
+        } catch (e) {
+          emit({ type: "error", error: new Error(String(e)) });
+          close();
+          return;
+        }
+        if (!resp.body) {
+          close();
+          return;
+        }
+        reader = resp.body.getReader();
+        emit({ type: "stream-start", warnings });
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+          while (!done) {
+            const { done: rd, value } = await reader.read();
+            if (rd) {
+              close();
+              break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const { messages, remaining } = parseNDJSON(buffer, sid);
+            buffer = remaining;
+            for (const msg of messages) {
+              if (msg.action === "chunk") {
+                const ct = msg.chunkType;
+                if (ct === "text_start" || ct === "text_delta" && !textStarted) {
+                  if (!textStarted) {
+                    textStarted = true;
+                    emit({ type: "text-start", id: textId });
+                  }
+                }
+                if (ct === "text_delta" && msg.delta) {
+                  emit({ type: "text-delta", id: textId, delta: msg.delta });
+                }
+                if (ct === "reasoning_start" || ct === "reasoning_delta" && !reasoningStarted) {
+                  if (!reasoningStarted) {
+                    reasoningStarted = true;
+                    emit({ type: "reasoning-start", id: reasoningId });
+                  }
+                }
+                if (ct === "reasoning_delta" && msg.delta) {
+                  emit({ type: "reasoning-delta", id: reasoningId, delta: msg.delta });
+                }
+                if (ct === "reasoning_end") {
+                  emit({ type: "reasoning-end", id: reasoningId });
+                  reasoningStarted = false;
+                }
+                if (ct === "tool_input_start" && msg.toolCallId && msg.toolName) {
+                  toolInputAccum.set(msg.toolCallId, "");
+                  emit({ type: "tool-input-start", id: msg.toolCallId, toolName: msg.toolName });
+                }
+                if (ct === "tool_input_delta" && msg.toolCallId && msg.partialJson) {
+                  const prev = toolInputAccum.get(msg.toolCallId) ?? "";
+                  toolInputAccum.set(msg.toolCallId, prev + msg.partialJson);
+                  emit({ type: "tool-input-delta", id: msg.toolCallId, delta: msg.partialJson });
+                }
+                if (ct === "tool_call" && msg.toolCallId && msg.toolName) {
+                  const accumulated = toolInputAccum.get(msg.toolCallId) ?? "{}";
+                  emit({
+                    type: "tool-call",
+                    toolCallId: msg.toolCallId,
+                    toolName: msg.toolName,
+                    input: accumulated,
+                    providerExecuted: true
+                  });
+                }
+                if (ct === "tool_result" && msg.toolCallId) {
+                  emit({
+                    type: "tool-result",
+                    toolCallId: msg.toolCallId,
+                    result: { output: msg.result ?? "", title: "", metadata: {} },
+                    providerExecuted: true
+                  });
+                }
+              }
+              if (msg.action === "finish") {
+                if (textStarted) {
+                  emit({ type: "text-end", id: textId });
+                }
+                if (reasoningStarted) {
+                  emit({ type: "reasoning-end", id: reasoningId });
+                }
+                const u = msg.usage;
+                emit({
+                  type: "finish",
+                  finishReason: msg.finishReason ?? "stop",
+                  usage: {
+                    inputTokens: u?.input_tokens ?? u?.inputTokens,
+                    outputTokens: u?.output_tokens ?? u?.outputTokens,
+                    totalTokens: void 0
+                  },
+                  providerMetadata: msg.providerMetadata ?? {}
+                });
+                close();
+                return;
+              }
+              if (msg.action === "error") {
+                emit({ type: "error", error: new Error(msg.message) });
+                close();
+                return;
+              }
+            }
+          }
+        } catch (e) {
+          emit({ type: "error", error: new Error(String(e)) });
+          close();
+        }
+      },
+      cancel() {
+        ipcCall({ action: "destroy", opencodeSessionId: sid }).catch(() => {
+        });
+      }
+    });
+    return {
+      stream,
+      rawCall: { raw: { text }, rawHeaders: {} },
+      warnings
+    };
+  }
+};
+function createClwnd(config = {}) {
+  const fn = (modelId) => new ClwndModel(modelId, config);
+  fn.languageModel = (modelId) => new ClwndModel(modelId, config);
+  return fn;
+}
+
+// index.ts
+var clwndPlugin = async () => ({
+  models: {
+    clwnd: createClwnd()
+  }
+});
+export {
+  ClwndModel,
+  clwndPlugin,
+  createClwnd
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@clwnd/opencode",
+  "version": "0.1.0",
+  "description": "clwnd for opencode",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "opencode",
+    "claude",
+    "clwnd",
+    "plugin",
+    "ai"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/adiled/clwnd.git",
+    "directory": "plugins/opencode"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@ai-sdk/provider": "^2.0.0",
+    "@ai-sdk/provider-utils": "^2.0.0"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.2.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.2.27",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0"
+  }
+}