dsh-subscriptions 0.1.5 → 0.2.2

package/lib/providers/minimax-usage.js

@@ -6,7 +6,10 @@ import { parseProviderJson } from './common.js';
  * bar.
  */
 function usedFromCounts(total, count) {
-    return typeof total === 'number' && Number.isFinite(total) && total > 0 && typeof count === 'number'
+    return typeof total === 'number' &&
+        Number.isFinite(total) &&
+        total > 0 &&
+        typeof count === 'number'
         ? (1 - count / total) * 100
         : undefined;
 }
@@ -36,13 +39,18 @@ export async function fetchMiniMaxUsage(key, region, http = fetch, signal) {
     if (key.startsWith('sk-api-'))
         throw new Error('MiniMax requires a subscription key, not a pay-as-you-go key');
     const response = await http(`https://www.minimax.${region === 'cn' ? 'cn' : 'io'}/v1/token_plan/remains`, {
-        headers: { authorization: `Bearer ${key}`, 'content-type': 'application/json' },
+        headers: {
+            authorization: `Bearer ${key}`,
+            'content-type': 'application/json',
+        },
         ...(signal === undefined ? {} : { signal }),
     });
     if (!response.ok)
         throw new Error(`MiniMax usage endpoint returned HTTP ${response.status}`);
-    const body = await parseProviderJson(response, 'MiniMax usage');
-    if ((body?.base_resp?.status_code !== undefined && body.base_resp.status_code !== 0) || !Array.isArray(body?.model_remains)) {
+    const body = (await parseProviderJson(response, 'MiniMax usage'));
+    if ((body?.base_resp?.status_code !== undefined &&
+        body.base_resp.status_code !== 0) ||
+        !Array.isArray(body?.model_remains)) {
         throw new Error('MiniMax usage response failed or has no quota records');
     }
     const windows = [];
@@ -60,22 +68,34 @@ export async function fetchMiniMaxUsage(key, region, http = fetch, signal) {
             if (status === 3)
                 continue; // Unlimited pools cannot have a finite percentage.
             const remaining = row[`${prefix}_remaining_percent`];
-            const boost = prefix === 'current_weekly' ? row.weekly_boost_permille ?? 1000 : 1000;
+            const boost = prefix === 'current_weekly' ? (row.weekly_boost_permille ?? 1000) : 1000;
             if (typeof boost !== 'number' || !Number.isFinite(boost) || boost <= 0)
                 continue;
             // An explicit percentage needs no counts: time-based plans send zero
             // counts beside it. Official CLI compatibility: without a percentage, the
             // legacy counts are the quota remaining.
-            const usedPercent = typeof remaining === 'number' ? 100 - remaining * boost / 1000
+            const usedPercent = typeof remaining === 'number'
+                ? 100 - (remaining * boost) / 1000
                 : usedFromCounts(row[`${prefix}_total_count`], row[`${prefix}_usage_count`]);
-            if (usedPercent === undefined || !Number.isFinite(usedPercent) || usedPercent < 0 || usedPercent > 100)
+            if (usedPercent === undefined ||
+                !Number.isFinite(usedPercent) ||
+                usedPercent < 0 ||
+                usedPercent > 100)
                 continue;
             const start = row[startKey];
             const end = row[endKey];
-            const validBounds = typeof start === 'number' && Number.isFinite(start) && start > 0
-                && typeof end === 'number' && Number.isFinite(end) && end > start;
-            windows.push({ kind: fallback === 'session' && validBounds && end - start !== 18_000_000 ? 'other' : fallback,
-                scope: row.model_name, usedPercent,
+            const validBounds = typeof start === 'number' &&
+                Number.isFinite(start) &&
+                start > 0 &&
+                typeof end === 'number' &&
+                Number.isFinite(end) &&
+                end > start;
+            windows.push({
+                kind: fallback === 'session' && validBounds && end - start !== 18_000_000
+                    ? 'other'
+                    : fallback,
+                scope: row.model_name,
+                usedPercent,
                 ...(validBounds ? { startsAt: start, resetsAt: end } : {}),
             });
         }

package/lib/providers/npm-cli-version.js

@@ -34,13 +34,17 @@ export class NpmCliVersionCache {
         this.timeoutMs = options.timeoutMs ?? 5000;
     }
     /** A manual catalog refresh also checks for a newly released CLI. */
-    invalidate() { this.expiresAt = 0; }
+    invalidate() {
+        this.expiresAt = 0;
+    }
     resolve() {
         if (this.pending !== undefined)
             return this.pending;
         if (this.presented !== undefined && this.now() < this.expiresAt)
             return Promise.resolve(this.presented.version);
-        this.pending = this.refresh().finally(() => { this.pending = undefined; });
+        this.pending = this.refresh().finally(() => {
+            this.pending = undefined;
+        });
         return this.pending;
     }
     /**
@@ -82,7 +86,10 @@ export class NpmCliVersionCache {
                 }, this.timeoutMs);
             });
             // Also bounded when an injected transport ignores cancellation.
-            this.presented = { version: await Promise.race([lookup(), timeout]), source: 'npm' };
+            this.presented = {
+                version: await Promise.race([lookup(), timeout]),
+                source: 'npm',
+            };
             this.expiresAt = this.now() + 6 * 60 * 60_000;
         }
         catch {

package/lib/providers/ollama-settings.d.ts

@@ -0,0 +1,90 @@
+/**
+ * One model the Ollama Cloud route serves. The route ships no catalog of its
+ * own: this list is the catalog, in the order the picker shows it. Adoption
+ * fills the capability fields from the endpoint's `/api/tags` + `/api/show`
+ * reply; every field except `id` is optional so a hand-written row still
+ * works.
+ */
+export interface OllamaModelSetting {
+    /** Wire model id; must be non-empty and unique within the list. */
+    id: string;
+    /** Selector label; defaults to the id. */
+    name?: string;
+    /** Known combined request/response context capacity in tokens. */
+    contextWindow?: number;
+    /**
+     * The user's local context-window choice. Unlike `contextWindow`, which
+     * snapshots what the endpoint advertised, this records only an explicit
+     * edit: absent follows the endpoint. The runtime caps it at the advertised
+     * window and it never widens the API's real capacity.
+     */
+    contextOverride?: number;
+    /** Per-request output cap; defaults to the route's fallback. */
+    maxTokens?: number;
+    /** The endpoint advertised the `vision` capability. */
+    vision?: boolean;
+    /** The endpoint advertised the `thinking` capability. */
+    thinking?: boolean;
+    /** Advertised reasoning efforts, in picker order; empty means non-reasoning. */
+    efforts?: string[];
+    /** Effort preselected when the session picks none; must be one of `efforts`. */
+    defaultEffort?: string;
+}
+/**
+ * Durable, non-secret Ollama Cloud configuration. Every field is optional and
+ * its absence means "no override": the effective value then falls back to the
+ * plugin config and, last, to the built-in default. The API key itself never
+ * appears here; `apiKeyRef` only names a DSH credential.
+ */
+export interface OllamaSettings {
+    /** The route's catalog, in picker order. `[]` hides every model. */
+    models?: OllamaModelSetting[];
+    /** Register the web search/fetch providers; the config value is the default. */
+    web?: boolean;
+    /** Native base URL; the config value is the default. */
+    baseURL?: string;
+    /** Credential reference naming the API key; the config value is the default. */
+    apiKeyRef?: string;
+}
+/**
+ * Accept only an absolute http(s) base URL with no credentials, query, or
+ * fragment, and return its trimmed form. The route appends `/tags`, `/show`,
+ * and `/v1/chat/completions` to this value, so anything else would build a URL
+ * that cannot work — and a non-official host receives the referenced
+ * credential, which the dialog tells the user.
+ * @param value - the candidate URL.
+ * @returns the trimmed URL to store.
+ * @throws when the value is not a usable absolute http(s) URL.
+ */
+export declare function validateOllamaBaseURL(value: unknown): string;
+/**
+ * Validate one settings document, dropping unknown keys and duplicate model
+ * ids (first wins, matching the Cursor store's visible-model handling).
+ * @param input - the parsed store document or an RPC payload.
+ * @throws when a known field has the wrong type or an unusable value.
+ */
+export declare function validateOllamaSettings(input: unknown): OllamaSettings;
+/**
+ * Durable Ollama Cloud configuration under the DSH home directory. Writes are
+ * serialized and atomic (temp file with mode 0600, then rename), so a crash
+ * never leaves a half-written document and a concurrent writer cannot lose an
+ * earlier save.
+ */
+export declare class OllamaSettingsStore {
+    readonly path: string;
+    private readonly onCorrupt?;
+    private current;
+    private writes;
+    /** Set when the stored file existed but was unreadable or invalid. */
+    private corrupt;
+    constructor(path?: string, onCorrupt?: ((message: string) => void) | undefined);
+    /** Why the stored file is ignored, when it is. */
+    corruption(): string | undefined;
+    get(): OllamaSettings;
+    /** The stored catalog, or `undefined` when the store carries no override. */
+    models(): readonly OllamaModelSetting[] | undefined;
+    web(): boolean | undefined;
+    baseURL(): string | undefined;
+    apiKeyRef(): string | undefined;
+    set(input: unknown): Promise<void>;
+}

package/lib/providers/ollama-settings.js

@@ -0,0 +1,213 @@
+import { readFileSync } from 'node:fs';
+import { mkdir, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+function fail(message) {
+    throw new Error(message);
+}
+function readNonEmptyString(value, field) {
+    if (typeof value !== 'string' || value.trim().length === 0)
+        fail(`${field} must be a non-empty string`);
+    return value;
+}
+function readPositiveInteger(value, field) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) {
+        fail(`${field} must be a positive integer`);
+    }
+    return value;
+}
+function readBoolean(value, field) {
+    if (typeof value !== 'boolean')
+        fail(`${field} must be a boolean`);
+    return value;
+}
+/**
+ * Accept only an absolute http(s) base URL with no credentials, query, or
+ * fragment, and return its trimmed form. The route appends `/tags`, `/show`,
+ * and `/v1/chat/completions` to this value, so anything else would build a URL
+ * that cannot work — and a non-official host receives the referenced
+ * credential, which the dialog tells the user.
+ * @param value - the candidate URL.
+ * @returns the trimmed URL to store.
+ * @throws when the value is not a usable absolute http(s) URL.
+ */
+export function validateOllamaBaseURL(value) {
+    const raw = readNonEmptyString(value, 'baseURL');
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        fail('baseURL must be an absolute URL');
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:')
+        fail('baseURL must use http or https');
+    if (url.username !== '' || url.password !== '')
+        fail('baseURL must not carry credentials');
+    if (url.search !== '' || url.hash !== '')
+        fail('baseURL must not carry a query or fragment');
+    return raw.trim();
+}
+/** Credential references are looked up by name, so whitespace is always a typo. */
+function readApiKeyRef(value) {
+    const raw = readNonEmptyString(value, 'apiKeyRef');
+    if (/\s/.test(raw))
+        fail('apiKeyRef must not contain whitespace');
+    return raw;
+}
+function readEfforts(value, field) {
+    if (!Array.isArray(value) || value.length === 0)
+        fail(`${field} must be a non-empty array`);
+    const efforts = [];
+    for (const entry of value) {
+        const effort = readNonEmptyString(entry, `${field} entries`);
+        if (!efforts.includes(effort))
+            efforts.push(effort);
+    }
+    return efforts;
+}
+function readModel(entry, index) {
+    if (entry === null || typeof entry !== 'object' || Array.isArray(entry)) {
+        fail(`models[${index}] must be an object`);
+    }
+    const record = entry;
+    // The id is the wire id, so surrounding whitespace is always a paste
+    // artifact; trim it before the duplicate check sees it.
+    const model = {
+        id: readNonEmptyString(record.id, `models[${index}].id`).trim(),
+    };
+    if (record.name !== undefined)
+        model.name = readNonEmptyString(record.name, `models[${index}].name`);
+    if (record.contextWindow !== undefined) {
+        model.contextWindow = readPositiveInteger(record.contextWindow, `models[${index}].contextWindow`);
+    }
+    if (record.contextOverride !== undefined) {
+        model.contextOverride = readPositiveInteger(record.contextOverride, `models[${index}].contextOverride`);
+    }
+    if (record.maxTokens !== undefined) {
+        model.maxTokens = readPositiveInteger(record.maxTokens, `models[${index}].maxTokens`);
+    }
+    if (record.vision !== undefined)
+        model.vision = readBoolean(record.vision, `models[${index}].vision`);
+    if (record.thinking !== undefined)
+        model.thinking = readBoolean(record.thinking, `models[${index}].thinking`);
+    if (record.efforts !== undefined)
+        model.efforts = readEfforts(record.efforts, `models[${index}].efforts`);
+    if (record.defaultEffort !== undefined) {
+        const effort = readNonEmptyString(record.defaultEffort, `models[${index}].defaultEffort`);
+        // The runtime rejects a default the model does not advertise, so a
+        // mismatch is a store bug rather than something to carry forward.
+        if (model.efforts !== undefined && !model.efforts.includes(effort)) {
+            fail(`models[${index}].defaultEffort must be one of its efforts`);
+        }
+        model.defaultEffort = effort;
+    }
+    return model;
+}
+/**
+ * Validate one settings document, dropping unknown keys and duplicate model
+ * ids (first wins, matching the Cursor store's visible-model handling).
+ * @param input - the parsed store document or an RPC payload.
+ * @throws when a known field has the wrong type or an unusable value.
+ */
+export function validateOllamaSettings(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        fail('Ollama settings must be an object');
+    }
+    const record = input;
+    const settings = {};
+    if (record.models !== undefined) {
+        if (!Array.isArray(record.models))
+            fail('models must be an array');
+        const seen = new Set();
+        const models = [];
+        for (const [index, entry] of record.models.entries()) {
+            const model = readModel(entry, index);
+            if (seen.has(model.id))
+                continue;
+            seen.add(model.id);
+            models.push(model);
+        }
+        settings.models = models;
+    }
+    if (record.web !== undefined)
+        settings.web = readBoolean(record.web, 'web');
+    if (record.baseURL !== undefined)
+        settings.baseURL = validateOllamaBaseURL(record.baseURL);
+    if (record.apiKeyRef !== undefined)
+        settings.apiKeyRef = readApiKeyRef(record.apiKeyRef);
+    return settings;
+}
+/**
+ * Durable Ollama Cloud configuration under the DSH home directory. Writes are
+ * serialized and atomic (temp file with mode 0600, then rename), so a crash
+ * never leaves a half-written document and a concurrent writer cannot lose an
+ * earlier save.
+ */
+export class OllamaSettingsStore {
+    path;
+    onCorrupt;
+    current = {};
+    writes = Promise.resolve();
+    /** Set when the stored file existed but was unreadable or invalid. */
+    corrupt;
+    constructor(path = dshHomePath('plugins', 'subscriptions', 'ollama-settings.json'), onCorrupt) {
+        this.path = path;
+        this.onCorrupt = onCorrupt;
+        try {
+            this.current = validateOllamaSettings(JSON.parse(readFileSync(path, 'utf8')));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                // A broken file must not take the whole plugin down: degrade to
+                // defaults, keep the file untouched for manual recovery, and let
+                // the next save overwrite it.
+                this.corrupt = error instanceof Error ? error.message : String(error);
+                // The raw V8 message quotes the offending bytes; the log keeps a
+                // fixed diagnosis and corruption() carries the detail for callers
+                // that surface it outside log lines.
+                this.onCorrupt?.(`Ollama settings at ${path} are unreadable and ignored; defaults serve until the next save.`);
+            }
+        }
+    }
+    /** Why the stored file is ignored, when it is. */
+    corruption() {
+        return this.corrupt;
+    }
+    get() {
+        return structuredClone(this.current);
+    }
+    /** The stored catalog, or `undefined` when the store carries no override. */
+    models() {
+        return this.current.models;
+    }
+    web() {
+        return this.current.web;
+    }
+    baseURL() {
+        return this.current.baseURL;
+    }
+    apiKeyRef() {
+        return this.current.apiKeyRef;
+    }
+    set(input) {
+        const validated = validateOllamaSettings(input);
+        const run = this.writes.then(async () => {
+            await mkdir(dirname(this.path), { recursive: true });
+            const temporary = `${this.path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+            try {
+                await writeFile(temporary, JSON.stringify(validated, null, 2), {
+                    mode: 0o600,
+                });
+                await rename(temporary, this.path);
+            }
+            finally {
+                await rm(temporary, { force: true });
+            }
+            this.current = validated;
+            this.corrupt = undefined;
+        });
+        this.writes = run.catch(() => undefined);
+        return run;
+    }
+}

package/lib/providers/ollama-web.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Ollama-native web capabilities: search and fetch ride the Cloud
+ * `/api/web_search` + `/api/web_fetch` endpoints independently of the
+ * selected chat model. Both providers share the `ollama-cloud` id because
+ * the seam addresses each capability kind separately.
+ */
+import type { WebFetchProvider, WebFetchRequest, WebFetchResult, WebSearchProvider, WebSearchRequest, WebSearchResult } from '@deepseek-ai/dsh-web';
+import type { FetchFn } from './common.js';
+/** Shared provider id for both web capabilities. */
+export declare const OLLAMA_WEB_PROVIDER_ID = "ollama-cloud";
+/** Per-attempt budget; the seam owns overall cancellation. */
+export declare const OLLAMA_WEB_TIMEOUT_MS = 15000;
+/** Search result cap applied at the request layer. */
+export declare const OLLAMA_WEB_MAX_RESULTS = 10;
+/** Response body bound for web payloads. */
+export declare const OLLAMA_WEB_MAX_BYTES: number;
+export interface OllamaWebOptions {
+    /** Resolve the API key per call; `undefined` means unconfigured. */
+    apiKey: () => Promise<string | undefined>;
+    /**
+     * Native base URL; web endpoints ride it unchanged (no `/v1` mapping). A
+     * function form is read per call so a Settings save applies without a
+     * restart.
+     */
+    baseURL: string | (() => string);
+    /** Local gate; absent counts as enabled. Read on every call. */
+    enabled?: () => boolean;
+    fetchFn?: FetchFn;
+    requestTimeoutMs?: number;
+}
+/** Search provider behind DSH's stock web_search tool. */
+export declare class OllamaWebSearchProvider implements WebSearchProvider {
+    private readonly options;
+    readonly id = "ollama-cloud";
+    constructor(options: OllamaWebOptions);
+    available(): boolean;
+    search(request: WebSearchRequest, signal?: AbortSignal): Promise<WebSearchResult>;
+}
+/** Fetch provider behind DSH's stock web_fetch tool. */
+export declare class OllamaWebFetchProvider implements WebFetchProvider {
+    private readonly options;
+    readonly id = "ollama-cloud";
+    constructor(options: OllamaWebOptions);
+    available(): boolean;
+    fetch(request: WebFetchRequest, signal?: AbortSignal): Promise<WebFetchResult>;
+}