@andoai/opencode 0.1.0

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2026 Ando
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,30 @@
+# @andoai/opencode
+
+Official Ando Wallet integration for [OpenCode](https://opencode.ai/).
+
+## Install
+
+```sh
+opencode plugin --global @andoai/opencode
+```
+
+Then run `/connect` in OpenCode, choose **Ando**, and select **Connect Ando Wallet**. Your browser opens
+`wallet.andoai.xyz`, where you choose an existing open, funded OpenCode session or open a new one.
+
+The selected MPP session credential is returned directly to the OpenCode process over a one-time IPv4
+loopback callback. It is sent in a form POST body, never in the callback URL. OpenCode stores the credential
+in its local authentication store; this plugin does not add it to `opencode.json`.
+
+## Provider
+
+The plugin configures the `ando` provider against the OpenAI-compatible Ando MPP endpoint:
+
+```text
+https://inference.andoai.xyz/v1/mpp
+```
+
+No inference content, bearer credential, or private wallet material is published onchain by this plugin.
+
+## License
+
+Apache-2.0

package/dist/callback.d.ts

@@ -0,0 +1,9 @@
+export type CredentialCallback = {
+    callbackUrl: string;
+    close: () => Promise<void>;
+    state: string;
+    waitForCredential: () => Promise<string>;
+};
+export declare function startCredentialCallback(options?: Readonly<{
+    timeoutMs?: number;
+}>): Promise<CredentialCallback>;

package/dist/callback.js

@@ -0,0 +1,145 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+export async function startCredentialCallback(options = {}) {
+    const timeoutMs = options.timeoutMs ?? 5 * 60 * 1_000;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) {
+        throw new Error("OpenCode callback timeout must be a positive integer");
+    }
+    const state = randomBytes(32).toString("base64url");
+    let settled = false;
+    let resolveCredential = () => undefined;
+    let rejectCredential = () => undefined;
+    const credential = new Promise((resolve, reject) => {
+        resolveCredential = resolve;
+        rejectCredential = reject;
+    });
+    void credential.catch(() => undefined);
+    const server = createServer((request, response) => {
+        void handleRequest(request, response, state, (token) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            resolveCredential(token);
+            setImmediate(() => server.close());
+        });
+    });
+    server.on("clientError", (_error, socket) => {
+        socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        server.close();
+        throw new Error("OpenCode callback server did not bind to a loopback port");
+    }
+    const callbackUrl = `http://127.0.0.1:${address.port}/ando/opencode/callback`;
+    const timeout = setTimeout(() => {
+        if (settled)
+            return;
+        settled = true;
+        rejectCredential(new Error("Ando Wallet approval timed out"));
+        server.close();
+    }, timeoutMs);
+    timeout.unref();
+    return {
+        callbackUrl,
+        state,
+        waitForCredential: () => credential,
+        close: async () => {
+            clearTimeout(timeout);
+            if (!settled) {
+                settled = true;
+                rejectCredential(new Error("Ando Wallet approval was cancelled"));
+            }
+            await closeServer(server);
+        }
+    };
+}
+const CALLBACK_PATH = "/ando/opencode/callback";
+const MAX_BODY_BYTES = 8_192;
+const MAX_TOKEN_LENGTH = 6_144;
+async function handleRequest(request, response, expectedState, accept) {
+    if (request.method !== "POST") {
+        send(response, 405, "This callback accepts POST requests only.", { allow: "POST" });
+        request.resume();
+        return;
+    }
+    if (request.url !== CALLBACK_PATH) {
+        send(response, 404, "Callback not found.");
+        request.resume();
+        return;
+    }
+    const contentType = request.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase();
+    if (contentType !== "application/x-www-form-urlencoded") {
+        send(response, 415, "Unsupported callback content type.");
+        request.resume();
+        return;
+    }
+    const body = await readBody(request);
+    if (body === undefined) {
+        send(response, 413, "Callback request is too large.");
+        return;
+    }
+    const form = new URLSearchParams(body);
+    const state = form.get("state") ?? "";
+    if (!safeEqual(state, expectedState)) {
+        send(response, 403, "The wallet approval state did not match.");
+        return;
+    }
+    const credential = form.get("credential") ?? "";
+    if (!credential.startsWith("mpp_session_v1_") ||
+        credential.length <= "mpp_session_v1_".length ||
+        credential.length > MAX_TOKEN_LENGTH ||
+        !/^mpp_session_v1_[A-Za-z0-9_-]+$/u.test(credential)) {
+        send(response, 400, "The selected Ando session credential is invalid.");
+        return;
+    }
+    send(response, 200, "Ando Wallet connected. You can close this window and return to OpenCode.", {}, true);
+    accept(credential);
+}
+async function readBody(request) {
+    const chunks = [];
+    let length = 0;
+    let tooLarge = false;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        length += buffer.length;
+        if (length > MAX_BODY_BYTES) {
+            tooLarge = true;
+            continue;
+        }
+        chunks.push(buffer);
+    }
+    return tooLarge ? undefined : Buffer.concat(chunks).toString("utf8");
+}
+function safeEqual(actual, expected) {
+    const actualBytes = Buffer.from(actual);
+    const expectedBytes = Buffer.from(expected);
+    return actualBytes.length === expectedBytes.length && timingSafeEqual(actualBytes, expectedBytes);
+}
+function send(response, status, message, extraHeaders = {}, success = false) {
+    const body = `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width"><title>Ando Wallet</title></head><body><main><h1>${success ? "Connected" : "Connection not completed"}</h1><p>${message}</p></main></body></html>`;
+    response.writeHead(status, {
+        "cache-control": "no-store",
+        "content-security-policy": "default-src 'none'; base-uri 'none'; frame-ancestors 'none'",
+        "content-type": "text/html; charset=utf-8",
+        "referrer-policy": "no-referrer",
+        "x-content-type-options": "nosniff",
+        ...extraHeaders
+    });
+    response.end(body);
+}
+function closeServer(server) {
+    if (!server.listening)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        server.close((error) => (error ? reject(error) : resolve()));
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import { type CredentialCallback } from "./callback.js";
+type StartCallback = (options?: Readonly<{
+    timeoutMs?: number;
+}>) => Promise<CredentialCallback>;
+export declare function createAndoOpenCodePlugin(runtime?: Readonly<{
+    startCallback?: StartCallback;
+}>): Plugin;
+declare const AndoOpenCodePlugin: Plugin;
+export default AndoOpenCodePlugin;

package/dist/index.js

@@ -0,0 +1,79 @@
+import { startCredentialCallback } from "./callback.js";
+const WALLET_ORIGIN = "https://wallet.andoai.xyz";
+const INFERENCE_BASE_URL = "https://inference.andoai.xyz/v1/mpp";
+const MODELS = {
+    "Ando/Kimi-k2.6": { name: "Kimi K2.6" },
+    "Ando/gpt-oss-120b": { name: "GPT OSS 120B" },
+    "ando/nemotron-3-ultra-550b-a55b": { name: "Nemotron 3 Ultra 550B" }
+};
+export function createAndoOpenCodePlugin(runtime = {}) {
+    const startCallback = runtime.startCallback ?? startCredentialCallback;
+    return async () => {
+        const pending = new Set();
+        return {
+            config: async (config) => configureAndoProvider(config),
+            auth: {
+                provider: "ando",
+                methods: [
+                    {
+                        type: "oauth",
+                        label: "Connect Ando Wallet",
+                        authorize: async () => {
+                            const callback = await startCallback();
+                            pending.add(callback);
+                            const authorizationUrl = new URL("/integrations/opencode/authorize", WALLET_ORIGIN);
+                            authorizationUrl.searchParams.set("redirect_uri", callback.callbackUrl);
+                            authorizationUrl.searchParams.set("state", callback.state);
+                            return {
+                                method: "auto",
+                                url: authorizationUrl.toString(),
+                                instructions: "Choose an open, funded OpenCode session in Ando Wallet.",
+                                callback: async () => {
+                                    try {
+                                        return {
+                                            type: "success",
+                                            provider: "ando",
+                                            key: await callback.waitForCredential()
+                                        };
+                                    }
+                                    catch {
+                                        return { type: "failed" };
+                                    }
+                                    finally {
+                                        pending.delete(callback);
+                                        await callback.close();
+                                    }
+                                }
+                            };
+                        }
+                    }
+                ]
+            },
+            dispose: async () => {
+                const callbacks = Array.from(pending);
+                pending.clear();
+                await Promise.all(callbacks.map((callback) => callback.close()));
+            }
+        };
+    };
+}
+function configureAndoProvider(config) {
+    const providers = config.provider ?? {};
+    const current = providers.ando;
+    providers.ando = {
+        ...current,
+        name: current?.name ?? "Ando",
+        npm: current?.npm ?? "@ai-sdk/openai-compatible",
+        models: {
+            ...MODELS,
+            ...current?.models
+        },
+        options: {
+            baseURL: INFERENCE_BASE_URL,
+            ...current?.options
+        }
+    };
+    config.provider = providers;
+}
+const AndoOpenCodePlugin = createAndoOpenCodePlugin();
+export default AndoOpenCodePlugin;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@andoai/opencode",
+  "version": "0.1.0",
+  "description": "Official Ando Wallet integration for OpenCode",
+  "license": "Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "1.18.10"
+  }
+}