@thestreamcode/dsh-muse-code 0.0.0-stage → 0.1.1

package/AUTH_CONTRACT.md

@@ -0,0 +1,33 @@
+# Muse auth contract (v1)
+
+This bundle implements the same Meta device-code flow as the other Muse Code
+plugins. Change this file and the pinned constants/tests together:
+
+- `opencode-muse-auth`
+- `hermes-muse-code`
+- `openclaw-muse-code`
+- `dsh-muse-code`
+
+## Wire contract
+
+| Item | Value |
+|---|---|
+| `CLIENT_ID` | `1031625952748946` |
+| Device authorization | `https://auth.meta.com/oidc/device/authorization/` |
+| Device token | `https://auth.meta.com/oidc/device/token/` |
+| Key mint | `https://api.meta.ai/muse-code/key` |
+| API version header | `x-api-version: 1.0.0` |
+| Credential reference | `MUSE_CODE_SUB_TOKEN` |
+| Inference base URL | `https://api.meta.ai/v1` |
+
+## Behaviour
+
+- Device flow: request a device code, poll the token endpoint, accept
+  `authorization_pending`, increase the interval on `slow_down`, stop on a
+  terminal error or at `expires_in`.
+- Key mint: exchange the OAuth access token for the account-bound inference
+  key; reject an inactive subscription or a pending payment.
+- Persistence: the key is stored through the DSH credential seam under
+  `MUSE_CODE_SUB_TOKEN`; the OAuth access token stays in memory.
+- Any change to this contract bumps `AUTH_CONTRACT_VERSION` in the code and
+  requires updating the pinned tests in all four repositories.

package/DISCLAIMER.md

@@ -0,0 +1,62 @@
+# Disclaimer and risk notice
+
+This project is an unofficial, community-built integration. It is not affiliated
+with, endorsed by, or supported by Meta Platforms, Inc. or its affiliates
+("Meta"), or by DeepSeek. "Meta", "Muse", "Muse Code", "Muse Spark" and related
+names are trademarks of Meta.
+
+## Why this notice exists
+
+This plugin signs in with a Meta account that has an active Muse Code
+subscription and uses the subscription-linked credential to send inference
+requests from DeepSeek Harness, a third-party coding client.
+
+Meta's [Meta Model API Terms of Service](https://dev.meta.ai/legal/terms-of-service),
+Section 3.2, states that a credential connected for a Coding Harness
+Subscription "is for use only with the coding harness under your Coding Harness
+Subscription" and "may not be used to access the Services outside the coding
+harness or to circumvent your subscription's usage limits or billing". Meta's
+[Muse Code subscription documentation](https://dev.meta.ai/docs/muse-code/subscriptions)
+likewise states that the subscription credential "is for use with Muse Code
+only".
+
+This project therefore relies on a use that Meta does not document as supported.
+Meta may change, restrict or enforce its terms at any time, and may suspend,
+restrict or terminate accounts, subscriptions or credentials involved. The
+authors cannot prevent, predict or reverse that outcome.
+
+## No warranty, no guarantee
+
+- The integration is provided "as is"; there is no guarantee that it is
+  permitted by Meta's terms, that it will keep working, or that the subscription
+  will remain available.
+- The authors cannot restore an account, subscription, credential or data after
+  Meta takes action, and cannot intervene with Meta on your behalf.
+- This notice is informational and is not legal advice.
+
+## Your responsibility
+
+By installing or using this software you acknowledge that:
+
+1. you are responsible for complying with Meta's terms, including Section 3.2;
+2. you use your own account and credentials and accept the risk of account or
+   subscription action by Meta;
+3. you will not use this software where losing access would be unacceptable, and
+   you will not share credential caches or exported keys;
+4. you will delete stored credentials when you stop using the software.
+
+## Limitation of liability
+
+To the maximum extent permitted by applicable law, the authors and contributors
+are not liable for any loss or damage arising out of or related to this software
+or its use, including account suspension, subscription termination, credential
+revocation, loss of data, or service interruption. Nothing in this notice
+excludes or limits liability that cannot be excluded or limited by applicable
+law. The [MIT License](LICENSE) contains the warranty disclaimer and liability
+limitation that govern the software; this notice does not modify it.
+
+## Clearly supported alternatives
+
+If you need an integration that is unambiguously within Meta's terms, use a Meta
+Model API key billed pay-as-you-go, or drive Muse Code through its official
+`muse serve` session interface.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michael Gasperini (Mikesoft)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,160 @@
-# Temporary Holding Version
+# dsh-muse-code
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Muse Code subscription models and device-code sign-in for DeepSeek Harness
+
+[![CI](https://github.com/TheStreamCode/dsh-muse-code/actions/workflows/ci.yml/badge.svg)](https://github.com/TheStreamCode/dsh-muse-code/actions/workflows/ci.yml)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Release](https://img.shields.io/github/v/release/TheStreamCode/dsh-muse-code)](https://github.com/TheStreamCode/dsh-muse-code/releases/latest)
+
+DeepSeek Harness (DSH) bundle that serves Meta Muse Code models through a Muse Code
+subscription and adds a native device-code login flow. No API key is copied by hand: the
+plugin runs Meta's device login, mints the account-bound inference key, and stores it in the
+DSH credential store.
+
+> **Unofficial and experimental.** This plugin uses a Muse Code subscription credential from
+> DeepSeek Harness. Meta's terms limit that credential to Muse Code, so this use may not be
+> supported and Meta may suspend or revoke accounts or credentials. Use it at your own risk;
+> the authors cannot recover an account. Read [DISCLAIMER.md](DISCLAIMER.md) before installing.
+
+## Install
+
+From the npm registry:
+
+```bash
+dsh plugin --profile desktop add @thestreamcode/dsh-muse-code
+```
+
+From the public GitHub repository:
+
+```bash
+dsh plugin --profile desktop add github:TheStreamCode/dsh-muse-code
+```
+
+From a local checkout:
+
+```bash
+dsh plugin --profile desktop add link:C:\path\to\dsh-muse-code
+```
+
+The bundle inserts its route and auth plugin through `cordis.patch.yml`; no manual profile
+edit is required. Restart DSH if the profile does not pick up the bundle immediately.
+
+## Quick start
+
+1. Install the bundle with the command above.
+2. Open **Settings**, select **Authorization** (the credential and sign-in surface), then
+   **Muse Code (subscription)**.
+3. Open the printed Meta URL, enter the printed code, and approve the login.
+4. Select the `muse-code` provider and a Muse model in the DSH model picker, for example
+   `muse-code/muse-spark-1.3`.
+
+The plugin commits the minted key as the `MUSE_CODE_SUB_TOKEN` credential, and the route
+reads it per request, so the key never appears in a configuration file.
+
+## Features
+
+- Adds a `muse-code` model route through a second `@deepseek-ai/dsh-llm-pi-ai` instance
+  (`api: openai-responses`, `baseURL: https://api.meta.ai/v1`), so the existing `llm-pi-ai`
+  configuration is not replaced.
+- Registers the **Muse Code (subscription)** authorization flow: Meta device login, key
+  mint, and credential commit.
+- Stores the key in the DSH credential store under `MUSE_CODE_SUB_TOKEN` and reads it through
+  `apiKeyEnv`.
+- Serves `muse-spark-1.3`, `muse-spark-1.2`, `muse-wonder-1.0`, and `muse-wonder-full-1.0`
+  with text and image input, a 1,048,576-token context window, and reasoning-effort mapping
+  from `minimal` to `max`.
+- Accepts an explicit `MUSE_CODE_SUB_TOKEN` environment variable instead of the stored
+  credential.
+
+## Requirements
+
+- DeepSeek Harness `0.2.1-rc.2` or newer.
+- Node.js 20 or newer on the DSH host; CI runs Node.js 20, 22, and 24.
+- A Meta account with an active Muse Code subscription.
+- The plugin needs no separate service and no third-party CLI.
+
+## Configuration
+
+| Setting | Purpose | Default |
+| --- | --- | --- |
+| `MUSE_CODE_SUB_TOKEN` | Inference key read by the `muse-code` route through `apiKeyEnv`. An explicit value wins over the stored credential. | from the authorization flow |
+| `muse-code` provider | Provider entry added by `cordis.patch.yml`; select it in the DSH model picker. | enabled after install |
+| Model id | Model served by the route; availability depends on the subscription plan. | `muse-spark-1.3` |
+| Reasoning effort | Maps DSH effort levels to Meta's wire vocabulary. | provider default |
+
+## Privacy and security
+
+The subscription key is stored only in the DSH credential store under `MUSE_CODE_SUB_TOKEN`;
+it is never written to a configuration file, and the OAuth access token stays in memory. The
+plugin talks only to `auth.meta.com` for the device login and `api.meta.ai` for key minting and
+inference. Do not share credential caches or exported keys.
+
+To remove access, delete the `MUSE_CODE_SUB_TOKEN` credential from the DSH credential store or
+sign out of the authorization record, then remove the bundle:
+
+```bash
+dsh plugin --profile desktop remove @thestreamcode/dsh-muse-code
+```
+
+See [SECURITY.md](SECURITY.md) for vulnerability reporting and
+[AUTH_CONTRACT.md](AUTH_CONTRACT.md) for the pinned login contract.
+
+## Troubleshooting
+
+### The provider does not appear in the model picker
+
+The bundle was not loaded by the active profile. Re-run the install command with the same
+profile, restart DSH, and check that `cordis.patch.yml` is part of the installed bundle.
+
+### Muse Code subscription is inactive for this account
+
+The signed-in account has no active Muse Code subscription, or the subscription lapsed.
+Renew it, or sign in with the account that holds the subscription.
+
+### The device login expires or is denied
+
+Start the authorization flow again and approve the printed code before the expiry printed by
+the flow. The login completes in your own browser on Meta's authorization page.
+
+### Requests fail with 401 after a subscription change
+
+The stored key was revoked or rotated. Remove the `MUSE_CODE_SUB_TOKEN` credential, run the
+authorization flow again, and restart DSH if a running process cached the old value.
+
+## Development
+
+Requirements: Node.js 20 or newer and npm.
+
+```bash
+git clone https://github.com/TheStreamCode/dsh-muse-code.git
+cd dsh-muse-code
+npm install
+npm run typecheck
+npm test
+```
+
+`npm test` builds `lib/` and runs the `node:test` suite. `lib/` is committed because DSH
+bundle installs from Git may not run a build; regenerate it with `npm run build` after any
+source change. The offline tests cover the device flow, the credential wiring, and the plugin
+manifest; no Meta account is needed.
+
+## Support
+
+Usage questions and workflows belong in GitHub Discussions; reproducible defects belong in
+GitHub Issues using the bug report form. See [SUPPORT.md](SUPPORT.md). The plugin cannot
+obtain, restore, or protect a Meta account, subscription, or credential.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Pull requests must pass the required CI checks.
+
+## License
+
+MIT — see [`LICENSE`](LICENSE). The software is provided "as is"; see
+[DISCLAIMER.md](DISCLAIMER.md) for the risk notice and liability terms.
+
+---
+
+Maintained by [Michael Gasperini (Mikesoft)](https://mikesoft.it).
+If this project is useful to you, consider
+[sponsoring its maintenance](https://github.com/sponsors/TheStreamCode).

package/cordis.patch.yml

@@ -0,0 +1,68 @@
+# Muse Code subscription provider for DeepSeek Harness.
+#
+# A second pi-ai adapter instance serves the `muse-code` route, so the
+# existing `llm-pi-ai` provider configuration is not replaced. The auth
+# plugin registers the device-code flow and stores the minted key under the
+# MUSE_CODE_SUB_TOKEN credential reference used by apiKeyEnv.
+- insert:
+    - id: muse-code-llm
+      name: '@deepseek-ai/dsh-llm-pi-ai'
+      config:
+        providers:
+          muse-code:
+            displayName: Muse Code (subscription)
+            apiKeyEnv: MUSE_CODE_SUB_TOKEN
+            api: openai-responses
+            baseURL: https://api.meta.ai/v1
+            models:
+              - id: muse-spark-1.3
+                name: Muse Spark 1.3
+                contextWindow: 1048576
+                maxTokens: 131072
+                input: [text, image]
+                reasoningEfforts:
+                  minimal: minimal
+                  low: low
+                  medium: medium
+                  high: high
+                  xhigh: xhigh
+                  max: max
+              - id: muse-spark-1.2
+                name: Muse Spark 1.2
+                contextWindow: 1048576
+                maxTokens: 131072
+                input: [text, image]
+                reasoningEfforts:
+                  minimal: minimal
+                  low: low
+                  medium: medium
+                  high: high
+                  xhigh: xhigh
+                  max: max
+              - id: muse-wonder-1.0
+                name: Muse Wonder 1.0
+                contextWindow: 1048576
+                maxTokens: 131072
+                input: [text, image]
+                reasoningEfforts:
+                  minimal: minimal
+                  low: low
+                  medium: medium
+                  high: high
+                  xhigh: xhigh
+                  max: max
+              - id: muse-wonder-full-1.0
+                name: Muse Wonder Full 1.0
+                contextWindow: 1048576
+                maxTokens: 131072
+                input: [text, image]
+                reasoningEfforts:
+                  minimal: minimal
+                  low: low
+                  medium: medium
+                  high: high
+                  xhigh: xhigh
+                  max: max
+    - id: muse-code-auth
+      name: '@thestreamcode/dsh-muse-code'
+      config: {}

package/lib/auth.d.ts

@@ -0,0 +1,22 @@
+export declare const CLIENT_ID = "1031625952748946";
+export declare const DEVICE_URL = "https://auth.meta.com/oidc/device/authorization/";
+export declare const TOKEN_URL = "https://auth.meta.com/oidc/device/token/";
+export declare const KEY_URL = "https://api.meta.ai/muse-code/key";
+export declare const API_VERSION = "1.0.0";
+export declare const AUTH_CONTRACT_VERSION = 1;
+export interface DeviceAuthorization {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete?: string;
+    interval: number;
+    expires_in: number;
+}
+export interface MintedCredential {
+    apiKey: string;
+    accountId: string;
+    email?: string;
+}
+export declare function deviceAuthorize(signal?: AbortSignal): Promise<DeviceAuthorization>;
+export declare function pollToken(deviceCode: string, intervalS: number, expiresInS: number, signal?: AbortSignal): Promise<string>;
+export declare function mintKey(accessToken: string, signal?: AbortSignal): Promise<MintedCredential>;

package/lib/auth.js

@@ -0,0 +1,157 @@
+// Meta device-code login and subscription-key minting for Muse Code.
+// The wire contract is shared with the other Muse Code plugins; see
+// AUTH_CONTRACT.md before changing any constant here.
+export const CLIENT_ID = "1031625952748946";
+export const DEVICE_URL = "https://auth.meta.com/oidc/device/authorization/";
+export const TOKEN_URL = "https://auth.meta.com/oidc/device/token/";
+export const KEY_URL = "https://api.meta.ai/muse-code/key";
+export const API_VERSION = "1.0.0";
+export const AUTH_CONTRACT_VERSION = 1;
+const HEADERS = {
+    Accept: "application/json",
+    "x-api-version": API_VERSION,
+};
+const REQUEST_TIMEOUT_MS = 25_000;
+const MIN_INTERVAL_S = 1;
+const SLOW_DOWN_STEP_S = 5;
+function combinedSignal(signal) {
+    const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+    return signal ? AbortSignal.any([timeout, signal]) : timeout;
+}
+async function postForm(url, params, signal) {
+    const res = await fetch(url, {
+        method: "POST",
+        headers: { ...HEADERS, "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams(params).toString(),
+        signal: combinedSignal(signal),
+    });
+    const text = await res.text();
+    if (!res.ok)
+        throw new Error(`HTTP ${res.status} ${text.slice(0, 200)}`.trim());
+    return JSON.parse(text);
+}
+function delay(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, ms);
+        if (!signal)
+            return;
+        if (signal.aborted) {
+            clearTimeout(timer);
+            reject(new Error("authorization cancelled"));
+            return;
+        }
+        signal.addEventListener("abort", () => {
+            clearTimeout(timer);
+            reject(new Error("authorization cancelled"));
+        }, { once: true });
+    });
+}
+export async function deviceAuthorize(signal) {
+    const body = (await postForm(DEVICE_URL, { client_id: CLIENT_ID }, signal));
+    const { device_code, user_code, verification_uri, interval, expires_in } = body;
+    if (typeof device_code !== "string" ||
+        !device_code ||
+        typeof user_code !== "string" ||
+        !user_code ||
+        typeof verification_uri !== "string" ||
+        !verification_uri ||
+        typeof interval !== "number" ||
+        typeof expires_in !== "number") {
+        throw new Error("device authorization response is missing fields");
+    }
+    const complete = body.verification_uri_complete;
+    return {
+        device_code,
+        user_code,
+        verification_uri,
+        ...(typeof complete === "string" && complete ? { verification_uri_complete: complete } : {}),
+        interval,
+        expires_in,
+    };
+}
+export async function pollToken(deviceCode, intervalS, expiresInS, signal) {
+    let interval = Math.max(MIN_INTERVAL_S, Number(intervalS) || 5);
+    const deadline = Date.now() + Number(expiresInS || 600) * 1000;
+    let slowDowns = 0;
+    while (Date.now() < deadline) {
+        if (signal?.aborted)
+            throw new Error("authorization cancelled");
+        // The token endpoint answers pending/slow_down polls with HTTP errors as
+        // part of the normal flow: classify the body instead of throwing.
+        let body = null;
+        try {
+            const res = await fetch(TOKEN_URL, {
+                method: "POST",
+                headers: { ...HEADERS, "Content-Type": "application/x-www-form-urlencoded" },
+                body: new URLSearchParams({
+                    grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+                    client_id: CLIENT_ID,
+                    device_code: deviceCode,
+                }).toString(),
+                signal: combinedSignal(signal),
+            });
+            try {
+                body = (await res.json());
+            }
+            catch {
+                body = null;
+            }
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw new Error("authorization cancelled");
+            if (error instanceof Error && error.name === "AbortError")
+                throw error;
+            body = null;
+        }
+        if (body && !body.error) {
+            if (typeof body.access_token !== "string" || !body.access_token) {
+                throw new Error("token response has no access_token");
+            }
+            return body.access_token;
+        }
+        if (body?.error === "slow_down") {
+            slowDowns += 1;
+            interval = Math.max(MIN_INTERVAL_S, interval + SLOW_DOWN_STEP_S);
+        }
+        else if (body?.error !== "authorization_pending") {
+            throw new Error(`login failed: ${String(body?.error || "unreadable token response")}`);
+        }
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            break;
+        await delay(Math.min(interval, remaining) * 1000, signal);
+    }
+    throw new Error(slowDowns ? "login timed out after slow_down responses" : "login timed out waiting for approval");
+}
+export async function mintKey(accessToken, signal) {
+    const res = await fetch(KEY_URL, {
+        method: "POST",
+        headers: {
+            ...HEADERS,
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${accessToken}`,
+        },
+        body: JSON.stringify({ onboard: true }),
+        signal: combinedSignal(signal),
+    });
+    const text = await res.text();
+    if (!res.ok)
+        throw new Error(`key exchange failed: HTTP ${res.status} ${text.slice(0, 200)}`.trim());
+    const body = JSON.parse(text);
+    if (body.is_subs_active === false) {
+        throw new Error("Muse Code subscription is inactive for this account");
+    }
+    if (typeof body.api_key !== "string" || !body.api_key.trim()) {
+        const action = String(body.action_url || body.require_payment_action_url || "").trim();
+        if (body.require_payment === true || action) {
+            throw new Error(`Muse Code subscription is required${action ? ": " + action : ""}`);
+        }
+        throw new Error("key response is missing api_key");
+    }
+    const email = String(body.user_email || "").trim().toLowerCase() || undefined;
+    const accountId = String(body.user_id || "").trim() || email;
+    if (!accountId)
+        throw new Error("key response is missing account identity");
+    return { apiKey: body.api_key.trim(), accountId, ...(email ? { email } : {}) };
+}

package/lib/index.d.ts

@@ -0,0 +1,31 @@
+type CredentialStore = {
+    set(reference: string, value: string): Promise<void>;
+    modifyRecord(key: string, update: () => Promise<unknown>): Promise<unknown>;
+};
+type AuthorizationSession = {
+    signal?: AbortSignal;
+    notify(input: {
+        message: string;
+        url?: string;
+    }): void;
+};
+type AuthorizationFlow = {
+    key: string;
+    label: string;
+    methods: Array<{
+        id: string;
+        label: string;
+    }>;
+    run(session: AuthorizationSession): Promise<void>;
+};
+type HostContext = {
+    credentials: CredentialStore;
+    authorization: {
+        registerFlow(flow: AuthorizationFlow): () => void;
+    };
+    effect?(callback: () => (() => void) | void): () => void;
+};
+export declare const name = "dsh-muse-code";
+export declare const inject: string[];
+export declare function apply(ctx: HostContext): void;
+export {};

package/lib/index.js

@@ -0,0 +1,40 @@
+// DeepSeek Harness bundle: Muse Code subscription route + login flow.
+//
+// The route is declared by cordis.patch.yml through a second pi-ai adapter
+// instance. This plugin owns the human sign-in: it runs Meta's device flow,
+// mints the account-bound inference key, stores it under the
+// MUSE_CODE_SUB_TOKEN credential reference, and commits the authorization
+// record the seam requires.
+import { deviceAuthorize, mintKey, pollToken } from "./auth.js";
+export const name = "dsh-muse-code";
+export const inject = ["credentials", "authorization"];
+const FLOW_KEY = "dsh-muse-code/subscription";
+const CREDENTIAL_REF = "MUSE_CODE_SUB_TOKEN";
+export function apply(ctx) {
+    const flow = {
+        key: FLOW_KEY,
+        label: "Muse Code (subscription)",
+        methods: [{ id: "device", label: "Sign in with Meta device code" }],
+        async run(session) {
+            const device = await deviceAuthorize(session.signal);
+            const url = device.verification_uri_complete || device.verification_uri;
+            session.notify({ message: `Open ${url} and enter code ${device.user_code}`, url });
+            const accessToken = await pollToken(device.device_code, device.interval, device.expires_in, session.signal);
+            const minted = await mintKey(accessToken, session.signal);
+            await ctx.credentials.set(CREDENTIAL_REF, minted.apiKey);
+            await ctx.credentials.modifyRecord(FLOW_KEY, async () => ({
+                kind: "grant",
+                payload: {
+                    accountId: minted.accountId,
+                    ...(minted.email ? { email: minted.email } : {}),
+                },
+            }));
+            session.notify({ message: `Signed in as ${minted.email || minted.accountId}` });
+        },
+    };
+    const register = () => ctx.authorization.registerFlow(flow);
+    if (ctx.effect)
+        ctx.effect(register);
+    else
+        register();
+}

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@thestreamcode/dsh-muse-code",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Muse Code subscription model provider and credential login for DeepSeek Harness.",
+  "license": "MIT",
+  "author": {
+    "name": "Michael Gasperini",
+    "url": "https://mikesoft.it"
+  },
+  "homepage": "https://github.com/TheStreamCode/dsh-muse-code",
+  "repository": "github:TheStreamCode/dsh-muse-code",
+  "bugs": {
+    "url": "https://github.com/TheStreamCode/dsh-muse-code/issues"
+  },
+  "type": "module",
+  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "DISCLAIMER.md",
+    "AUTH_CONTRACT.md",
+    "LICENSE"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "prepack": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.5",
+    "typescript": "^5.9.3"
+  }
+}