opencode-muse-auth 0.4.0 → 0.5.0

package/dist/index.js

@@ -1,6 +1,9 @@
 import { Plugin as V2Plugin, Integration } from "@opencode/plugin";
+import { DEFAULT_UPSTREAM, startMuseCodeAdapter } from "./adapter.js";
 import { writeCache, deviceAuthorize, pollToken, mintKey, resolveLoaderKey, } from "./auth.js";
 const TEN_YEARS_MS = 10 * 365 * 24 * 60 * 60 * 1000;
+/** Origin of the real Meta inference endpoint; the adapter forwards to it. */
+const META_ORIGIN = new URL(DEFAULT_UPSTREAM).origin;
 /** Keep diagnostics useful without ever copying a credential into a log line. */
 function describeError(error) {
     const text = error instanceof Error ? error.message : String(error);
@@ -25,6 +28,135 @@ async function logAuthFailure(client, error) {
         // Logging must never break the auth flow.
     }
 }
+/** Start the loopback adapter; `off` keeps the proxy but skips the reshaping. */
+function startLocalAdapter() {
+    return startMuseCodeAdapter({ passthrough: process.env["MUSE_CODE_ADAPTER"] === "off" });
+}
+/**
+ * Rewrite one direct Meta request onto the adapter origin.
+ *
+ * Only the origin changes: path, query, method, headers, body and signal are
+ * preserved. A request already targeting the adapter, or any other host, is
+ * returned untouched.
+ */
+function routeThroughAdapter(request, baseUrl) {
+    const url = new URL(request.url);
+    const target = new URL(baseUrl);
+    if (url.origin === target.origin || url.origin !== META_ORIGIN)
+        return request;
+    url.protocol = target.protocol;
+    url.hostname = target.hostname;
+    url.port = target.port;
+    const init = {
+        method: request.method,
+        headers: request.headers,
+        signal: request.signal,
+        redirect: request.redirect,
+    };
+    if (request.method !== "GET" && request.method !== "HEAD" && request.body !== null) {
+        init.body = request.body;
+        init.duplex = "half";
+    }
+    return new Request(url.toString(), init);
+}
+/**
+ * V2 setup. Returns the cleanup function, which stops the adapter.
+ *
+ * @param options - test seam; production calls setup without options.
+ */
+export async function setupV2(ctx, options = {}) {
+    const methodID = Integration.MethodID.make("muse-code-subscription");
+    await ctx.integration.transform((editor) => {
+        editor.method.update({
+            integrationID: "meta",
+            method: {
+                id: methodID,
+                type: "oauth",
+                label: "Muse Code subscription (Meta device login)",
+            },
+            async authorize() {
+                const device = await deviceAuthorize();
+                const url = device.verification_uri_complete || device.verification_uri;
+                const callback = (async () => {
+                    try {
+                        const access = await pollToken(device.device_code, device.interval, device.expires_in);
+                        const minted = await mintKey(access);
+                        return {
+                            type: "oauth",
+                            methodID,
+                            access: minted.apiKey,
+                            refresh: "",
+                            expires: Date.now() + TEN_YEARS_MS,
+                            metadata: { accountId: minted.accountId, ...(minted.email ? { email: minted.email } : {}) },
+                        };
+                    }
+                    catch (error) {
+                        throw new Error(`Muse Code login failed: ${describeError(error)}`);
+                    }
+                })();
+                // The runtime awaits this promise after displaying the device code.
+                // Attach a handler immediately in case the exchange fails first.
+                void callback.catch(() => { });
+                return {
+                    url,
+                    instructions: `Open ${url}\nEnter code: ${device.user_code}`,
+                    mode: "auto",
+                    expiresAt: Date.now() + device.expires_in * 1000,
+                    callback,
+                };
+            },
+            label: (credential) => typeof credential.metadata?.email === "string"
+                ? credential.metadata.email : "Muse Code subscription",
+        });
+    });
+    // Meta's gate inspects the declared tool names, so subscription inference
+    // goes through a loopback proxy that aliases the colliding names and
+    // restores them in the response. Failures keep the pre-adapter behavior.
+    let started;
+    try {
+        started = await (options.adapter ?? startLocalAdapter)();
+    }
+    catch (error) {
+        console.error(`opencode-muse-auth: the local request adapter could not start; ` +
+            `subscription requests will not be reshaped: ${describeError(error)}`);
+    }
+    const adapter = started;
+    async function subscription() {
+        const connection = await ctx.integration.connection.active("meta");
+        if (!connection)
+            return undefined;
+        const credential = await ctx.integration.connection.resolve(connection);
+        if (credential?.type !== "oauth" || credential.methodID !== methodID)
+            return undefined;
+        return credential;
+    }
+    if (adapter) {
+        // Primary mechanism: the provider uses the adapter's /v1 origin as its
+        // request base URL. Native provider drivers honor this override.
+        const baseUrl = adapter.baseUrl;
+        await ctx.session.hook("model.request", async (event) => {
+            if (await subscription())
+                event.baseURL = baseUrl;
+        }, { providerID: "meta" });
+    }
+    // Meta's native provider expects a bearer inference key, not the
+    // short-lived OAuth token used to mint it. Honor the active connection.
+    // AI SDK routes drop model.request.baseURL (opencode#55984), so this hook
+    // also rewrites the assembled request onto the adapter origin.
+    await ctx.session.hook("http.request", async (event) => {
+        const credential = await subscription();
+        if (!credential)
+            return;
+        event.request.headers.set("Authorization", `Bearer ${credential.access}`);
+        if (adapter)
+            event.request = routeThroughAdapter(event.request, adapter.baseUrl);
+    }, { providerID: "meta" });
+    return async () => {
+        await adapter?.close();
+    };
+}
+// V1 has no adapter: its inference keeps going straight to api.meta.ai and
+// still receives Meta's client-restriction 403.
 const MuseCodeAuth = async ({ client }) => {
     return {
         auth: {
@@ -66,63 +198,7 @@ const MuseCodeAuth = async ({ client }) => {
 export default {
     ...V2Plugin.define({
         id: "muse-code-auth",
-        async setup(ctx) {
-            const methodID = Integration.MethodID.make("muse-code-subscription");
-            await ctx.integration.transform((editor) => {
-                editor.method.update({
-                    integrationID: "meta",
-                    method: {
-                        id: methodID,
-                        type: "oauth",
-                        label: "Muse Code subscription (Meta device login)",
-                    },
-                    async authorize() {
-                        const device = await deviceAuthorize();
-                        const url = device.verification_uri_complete || device.verification_uri;
-                        const callback = (async () => {
-                            try {
-                                const access = await pollToken(device.device_code, device.interval, device.expires_in);
-                                const minted = await mintKey(access);
-                                return {
-                                    type: "oauth",
-                                    methodID,
-                                    access: minted.apiKey,
-                                    refresh: "",
-                                    expires: Date.now() + TEN_YEARS_MS,
-                                    metadata: { accountId: minted.accountId, ...(minted.email ? { email: minted.email } : {}) },
-                                };
-                            }
-                            catch (error) {
-                                throw new Error(`Muse Code login failed: ${describeError(error)}`);
-                            }
-                        })();
-                        // The runtime awaits this promise after displaying the device code.
-                        // Attach a handler immediately in case the exchange fails first.
-                        void callback.catch(() => { });
-                        return {
-                            url,
-                            instructions: `Open ${url}\nEnter code: ${device.user_code}`,
-                            mode: "auto",
-                            expiresAt: Date.now() + device.expires_in * 1000,
-                            callback,
-                        };
-                    },
-                    label: (credential) => typeof credential.metadata?.email === "string"
-                        ? credential.metadata.email : "Muse Code subscription",
-                });
-            });
-            // Meta's native provider expects a bearer inference key, not the
-            // short-lived OAuth token used to mint it. Honor the active connection.
-            await ctx.session.hook("http.request", async (event) => {
-                const connection = await ctx.integration.connection.active("meta");
-                if (!connection)
-                    return;
-                const credential = await ctx.integration.connection.resolve(connection);
-                if (credential?.type === "oauth" && credential.methodID === methodID) {
-                    event.request.headers.set("Authorization", `Bearer ${credential.access}`);
-                }
-            }, { providerID: "meta" });
-        },
+        setup: (ctx) => setupV2(ctx),
     }),
     server: MuseCodeAuth,
 };

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "opencode-muse-auth",
-  "version": "0.4.0",
-  "description": "Unofficial and experimental: Muse Spark in opencode using a Muse Code subscription credential. May conflict with Meta's terms; use at your own risk. See DISCLAIMER.md.",
+  "version": "0.5.0",
+  "description": "Unofficial and experimental: Muse Spark in opencode using a Muse Code subscription credential, with a local loopback adapter for Meta's subscription wire format. May conflict with Meta's terms; use at your own risk. See DISCLAIMER.md.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
   "license": "MIT",
-  "author": "TheStreamCode",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/TheStreamCode/opencode-muse-auth.git"
+  "author": {
+    "name": "Michael Gasperini",
+    "url": "https://mikesoft.it"
   },
-  "homepage": "https://github.com/TheStreamCode/opencode-muse-auth#readme",
+  "repository": "github:TheStreamCode/opencode-muse-auth",
+  "homepage": "https://www.npmjs.com/package/opencode-muse-auth",
   "bugs": {
     "url": "https://github.com/TheStreamCode/opencode-muse-auth/issues"
   },
@@ -33,7 +33,8 @@
     "LICENSE",
     "NOTICE",
     "DISCLAIMER.md",
-    "AUTH_CONTRACT.md"
+    "AUTH_CONTRACT.md",
+    "ADAPTER_CONTRACT.md"
   ],
   "scripts": {
     "build": "tsc",
@@ -42,11 +43,11 @@
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {
-    "@opencode-ai/plugin": "^1.19.0",
-    "@types/node": "^22.20.3",
+    "@opencode-ai/plugin": "^1.19.3",
+    "@types/node": "^26.6.5",
     "typescript": "^7.0.2"
   },
   "dependencies": {
-    "@opencode/plugin": "^2.0.27"
+    "@opencode/plugin": "^2.0.32"
   }
 }