@askdkc/dsh-cli 0.12.3 → 0.13.1

package/node_modules/@askdkc/dsh-auth/lib/opencode-catalog.js

@@ -0,0 +1,252 @@
+/** Owned OpenCode catalog. Public listings are untrusted; no pi catalog participates. */
+import { mkdir, readFile, rename, writeFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { abortable } from './abortable.js';
+import { randomUUID } from 'node:crypto';
+export const OPEN_CODE_ROUTES = ['opencode', 'opencode-go'];
+export const OPEN_CODE_URLS = {
+    opencode: 'https://opencode.ai/zen/v1', 'opencode-go': 'https://opencode.ai/zen/go/v1',
+};
+const PROTOCOLS = {
+    '@ai-sdk/anthropic': 'messages', '@ai-sdk/openai': 'responses',
+    '@ai-sdk/openai-compatible': 'chat', '@ai-sdk/google': 'google',
+};
+function object(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('catalog expected an object');
+    return value;
+}
+function positive(value) { return typeof value === 'number' && Number.isSafeInteger(value) && value > 0; }
+export function rosterIds(payload) {
+    const data = object(payload).data;
+    if (!Array.isArray(data) || !data.length)
+        throw new Error('catalog has no non-empty model roster');
+    return [...new Set(data.map(row => {
+            const id = object(row).id;
+            if (typeof id !== 'string' || !id.trim() || id.length > 512)
+                throw new Error('catalog has an invalid model id');
+            return id;
+        }))].sort();
+}
+/** Normalize only exact-route metadata; every roster id has an explicit outcome. */
+export function normalizeCatalog(provider, roster, metadata, fetchedAt, previous) {
+    const section = object(metadata);
+    const entries = object(section.models);
+    const models = [];
+    const excluded = [];
+    for (const id of [...new Set(roster)].sort()) {
+        try {
+            if (entries[id] === undefined) {
+                const old = previous?.provider === provider ? previous.models.find(model => model.id === id) : undefined;
+                if (old) {
+                    models.push(structuredClone(old));
+                    continue;
+                }
+                throw new Error('metadata unavailable for this route and id');
+            }
+            const raw = object(entries[id]);
+            const wire = raw.provider === undefined ? section.npm : object(raw.provider).npm;
+            const protocol = typeof wire === 'string' && Object.hasOwn(PROTOCOLS, wire) ? PROTOCOLS[wire] : undefined;
+            const limit = object(raw.limit);
+            const modalities = object(raw.modalities);
+            if (!protocol)
+                throw new Error('unsupported or unknown wire protocol');
+            if (!positive(limit.context) || !positive(limit.output))
+                throw new Error('context or output limit unavailable');
+            if (!Array.isArray(modalities.input) || !modalities.input.includes('text') || !Array.isArray(modalities.output) || !modalities.output.includes('text'))
+                throw new Error('not a verified text-generation model');
+            if (typeof raw.tool_call !== 'boolean' || typeof raw.reasoning !== 'boolean' || typeof raw.temperature !== 'boolean')
+                throw new Error('model capabilities unavailable');
+            const effortOption = Array.isArray(raw.reasoning_options) ? raw.reasoning_options.map(object).find(option => option.type === 'effort') : undefined;
+            const efforts = effortOption?.values ?? [];
+            if (!Array.isArray(efforts) || !efforts.every(value => typeof value === 'string'))
+                throw new Error('invalid reasoning efforts');
+            const cost = Object.fromEntries(Object.entries(raw.cost === undefined ? {} : object(raw.cost)).filter(([, value]) => typeof value === 'number' && Number.isFinite(value) && value >= 0));
+            models.push({ id, name: typeof raw.name === 'string' ? raw.name : id, protocol, contextWindow: limit.context, maxTokens: limit.output,
+                inputModalities: modalities.input.includes('image') ? ['text', 'image'] : ['text'], toolCall: raw.tool_call, reasoning: raw.reasoning,
+                temperature: raw.temperature, efforts: [...efforts], ...(Object.keys(cost).length ? { cost } : {}) });
+        }
+        catch (error) {
+            excluded.push({ id, reason: error instanceof Error ? error.message : 'invalid metadata' });
+        }
+    }
+    return { version: 1, provider, fetchedAt, roster: [...new Set(roster)].sort(), models, excluded };
+}
+/** Validate cache/snapshot data using the same normalizer as fetched metadata. */
+export function parseSnapshot(value, provider) {
+    const raw = object(value);
+    if (raw.version !== 1 || raw.provider !== provider || typeof raw.fetchedAt !== 'number' || !Number.isSafeInteger(raw.fetchedAt) || raw.fetchedAt < 0 || !Array.isArray(raw.roster) || !raw.roster.length || !raw.roster.every(id => typeof id === 'string' && id.trim() && id.length <= 512) || !Array.isArray(raw.models) || !Array.isArray(raw.excluded))
+        throw new Error('invalid catalog snapshot');
+    const roster = raw.roster;
+    if (new Set(roster).size !== roster.length)
+        throw new Error('duplicate snapshot roster id');
+    const models = raw.models.map(value => {
+        const model = object(value);
+        if (typeof model.id !== 'string' || typeof model.protocol !== 'string' || !Object.values(PROTOCOLS).includes(model.protocol) || !positive(model.contextWindow) || !positive(model.maxTokens) || typeof model.name !== 'string' || !model.name || !Array.isArray(model.inputModalities) || !model.inputModalities.includes('text') || model.inputModalities.some(v => v !== 'text' && v !== 'image') || !Array.isArray(model.efforts) || !model.efforts.every(v => typeof v === 'string' && v.length > 0) || [model.toolCall, model.reasoning, model.temperature].some(v => typeof v !== 'boolean'))
+            throw new Error('invalid cached model');
+        const cost = model.cost === undefined ? undefined : object(model.cost);
+        if (cost && Object.values(cost).some(value => typeof value !== 'number' || !Number.isFinite(value) || value < 0))
+            throw new Error('invalid cached cost');
+        return { id: model.id, name: model.name, protocol: model.protocol, contextWindow: model.contextWindow, maxTokens: model.maxTokens,
+            inputModalities: [...new Set(model.inputModalities)], efforts: [...new Set(model.efforts)],
+            toolCall: model.toolCall, reasoning: model.reasoning, temperature: model.temperature,
+            ...(cost ? { cost: { ...cost } } : {}) };
+    });
+    const excluded = raw.excluded.map(value => { const entry = object(value); if (typeof entry.id !== 'string' || typeof entry.reason !== 'string' || !entry.reason)
+        throw new Error('invalid exclusion reason'); return { id: entry.id, reason: entry.reason }; });
+    const ids = [...models, ...excluded].map(model => model.id);
+    if (new Set(ids).size !== ids.length || ids.length !== roster.length || ids.some(id => !roster.includes(id)))
+        throw new Error('incomplete catalog snapshot');
+    return { version: 1, provider, fetchedAt: raw.fetchedAt, roster: [...roster], models, excluded };
+}
+export async function fetchCatalogJson(url, fetcher, signal) {
+    const timeout = AbortSignal.any([AbortSignal.timeout(30_000), ...(signal ? [signal] : [])]);
+    const response = await abortable(fetcher(url, { signal: timeout, headers: { accept: 'application/json' }, redirect: 'error' }), timeout);
+    if (!response.ok)
+        throw new Error(`catalog request failed: HTTP ${response.status}`);
+    if (!response.body)
+        throw new Error('empty catalog response');
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const item = await abortable(reader.read(), timeout);
+            if (item.done)
+                break;
+            size += item.value.byteLength;
+            if (size > 32 * 1024 * 1024)
+                throw new Error('catalog exceeds 32 MiB');
+            chunks.push(item.value);
+        }
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    finally {
+        void reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+}
+export class OpenCodeCatalog {
+    provider;
+    options;
+    snapshot;
+    source = 'bundled';
+    warning;
+    pending;
+    disposed = false;
+    abort = new AbortController();
+    timer;
+    started = false;
+    constructor(provider, bundled, options = {}) {
+        this.provider = provider;
+        this.options = options;
+        this.snapshot = parseSnapshot(bundled, provider);
+    }
+    get path() { return join(this.options.directory ?? join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'dsh-auth', 'catalog-v1'), `${this.provider}.json`); }
+    models() { return structuredClone(this.snapshot.models); }
+    status() { return { provider: this.provider, source: this.source, fetchedAt: this.snapshot.fetchedAt, available: this.snapshot.models.length, excluded: structuredClone(this.snapshot.excluded), ...(this.warning ? { warning: this.warning } : {}) }; }
+    async start() {
+        if (this.started || this.disposed)
+            return;
+        this.started = true;
+        try {
+            const cached = parseSnapshot(JSON.parse(await readFile(this.path, 'utf8')), this.provider);
+            if (!this.disposed && cached.fetchedAt > this.snapshot.fetchedAt) {
+                this.snapshot = cached;
+                this.source = 'cache';
+                this.options.changed?.();
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                this.warning = 'catalog cache unreadable; using bundled information';
+        }
+        if (this.disposed)
+            return;
+        if ((this.options.now?.() ?? Date.now()) - this.snapshot.fetchedAt >= 3_600_000)
+            void this.refresh();
+        this.timer = setInterval(() => { void this.refresh(); }, 3_600_000);
+        this.timer.unref();
+    }
+    refresh() {
+        if (this.disposed)
+            return Promise.reject(new Error('catalog disposed'));
+        if (this.pending)
+            return this.pending;
+        this.pending = this.update().finally(() => { this.pending = undefined; });
+        return this.pending;
+    }
+    async update() {
+        const startedAt = this.options.now?.() ?? Date.now();
+        try {
+            const [listing, details] = await Promise.all([fetchCatalogJson(`${OPEN_CODE_URLS[this.provider]}/models`, this.options.fetcher ?? fetch, this.abort.signal), fetchCatalogJson('https://models.dev/api.json', this.options.fetcher ?? fetch, this.abort.signal).then(value => ({ value, failed: false }), () => ({ value: undefined, failed: true }))]);
+            let section = { models: {} };
+            let detailsUnavailable = details.failed;
+            if (!details.failed) {
+                try {
+                    section = object(details.value)[this.provider] ?? { models: {} };
+                }
+                catch {
+                    detailsUnavailable = true;
+                }
+            }
+            const next = normalizeCatalog(this.provider, rosterIds(listing), section, startedAt, this.snapshot);
+            if (this.disposed || next.fetchedAt < this.snapshot.fetchedAt)
+                return this.status();
+            this.snapshot = next;
+            this.source = 'live';
+            this.warning = detailsUnavailable ? 'model details unavailable; reusing exact-route verified metadata' : undefined;
+            this.options.changed?.();
+            try {
+                await this.save(next);
+            }
+            catch {
+                if (!this.disposed)
+                    this.warning = 'catalog updated in memory; cache save failed';
+            }
+        }
+        catch {
+            if (!this.disposed)
+                this.warning = 'catalog refresh failed; retaining last verified information';
+        }
+        return this.status();
+    }
+    /** Compare and replace under a bounded cross-process lock; failed writes retain the old cache. */
+    async save(next) {
+        await mkdir(join(this.path, '..'), { recursive: true });
+        const lock = `${this.path}.lock`;
+        const deadline = Date.now() + 5000;
+        while (true) {
+            this.abort.signal.throwIfAborted();
+            try {
+                await mkdir(lock);
+                break;
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST' || Date.now() >= deadline)
+                    throw error;
+                await new Promise(resolve => setTimeout(resolve, 25));
+            }
+        }
+        const temp = `${this.path}.${randomUUID()}.tmp`;
+        try {
+            try {
+                const current = parseSnapshot(JSON.parse(await readFile(this.path, 'utf8')), this.provider);
+                if (current.fetchedAt > next.fetchedAt)
+                    return;
+            }
+            catch { /* An invalid cache may be replaced by verified public data. */ }
+            this.abort.signal.throwIfAborted();
+            await writeFile(temp, JSON.stringify(next), { mode: 0o600 });
+            this.abort.signal.throwIfAborted();
+            await rename(temp, this.path);
+        }
+        finally {
+            await rm(temp, { force: true });
+            await rm(lock, { recursive: true });
+        }
+    }
+    dispose() { this.disposed = true; this.abort.abort(); if (this.timer)
+        clearInterval(this.timer); }
+}

package/node_modules/@askdkc/dsh-auth/lib/opencode-codec.d.ts

@@ -0,0 +1,6 @@
+/** Convert DSH conversation blocks into low-level SDK prompts without an agent loop. */
+import { type GenerateOptions } from '@deepseek-ai/dsh-llm';
+import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+import type { LanguageModelV4Prompt } from '@ai-sdk/provider';
+import type { OpenCodeModel } from './opencode-catalog.js';
+export declare function encodePrompt(options: GenerateOptions, model: OpenCodeModel, attachments?: () => AttachmentStore | undefined, warn?: (reason: string) => void): Promise<LanguageModelV4Prompt>;

package/node_modules/@askdkc/dsh-auth/lib/opencode-codec.js

@@ -0,0 +1,93 @@
+/** Convert DSH conversation blocks into low-level SDK prompts without an agent loop. */
+import { LlmError, projectToolUpdates, fileHandleText } from '@deepseek-ai/dsh-llm';
+import { projectReplay, requireReplaySignature } from './opencode-replay.js';
+export async function encodePrompt(options, model, attachments, warn) {
+    const prompt = [];
+    const names = new Map();
+    const callIds = new Map();
+    if (options.system)
+        prompt.push({ role: 'system', content: options.system });
+    const projection = projectToolUpdates(options.messages, options.tools, undefined, options.toolHistory);
+    let imageBytes = 0;
+    const imagePart = async (block) => {
+        if (block.offloaded || !model.inputModalities.includes('image'))
+            return { type: 'text', text: '[image omitted from this request]' };
+        const store = attachments?.();
+        if (!store)
+            throw new LlmError('Image attachment service unavailable', 'ATTACHMENT_UNAVAILABLE');
+        const { requestImageDimensions } = await import('@deepseek-ai/dsh-attachment');
+        const image = await store.readImageRequest(block.attachment, { ...requestImageDimensions(block.attachment.width, block.attachment.height, 4_194_304), maxBytes: 1024 * 1024 }, options.signal);
+        imageBytes += Math.ceil(image.bytes / 3) * 4;
+        if (imageBytes > 20 * 1024 * 1024)
+            throw new LlmError('Image request exceeds 20 MiB', 'IMAGE_OFFLOAD_REQUIRED', { offloadImages: 1 });
+        return { type: 'file', mediaType: image.mediaType, data: { type: 'data', data: image.data } };
+    };
+    for (const message of projection.messages) {
+        if (message.role === 'system') {
+            prompt.push({ role: 'system', content: message.content.filter(block => block.type === 'text').map(block => block.text).join('\n') });
+            continue;
+        }
+        if (message.role === 'developer') {
+            const text = message.content.filter(block => block.type === 'text').map(block => block.text).join('\n');
+            if (text)
+                prompt.push({ role: 'system', content: text });
+            continue;
+        }
+        if (message.role === 'tool') {
+            const toolName = names.get(message.toolCallId);
+            if (!toolName)
+                throw new LlmError('Stored tool result has no matching call', 'INVALID_REPLAY_STATE');
+            const parts = [];
+            for (const block of message.content) {
+                if (block.type === 'text')
+                    parts.push({ type: 'text', text: block.text });
+                else if (block.type === 'file')
+                    parts.push({ type: 'text', text: fileHandleText(block.attachment, attachments?.()?.fileHostPath(block.attachment)) });
+                else if (block.type === 'image')
+                    parts.push(await imagePart(block));
+            }
+            prompt.push({ role: 'tool', content: [{ type: 'tool-result', toolCallId: callIds.get(message.toolCallId) ?? message.toolCallId, toolName,
+                        output: message.isError ? { type: 'error-text', value: parts.map(part => part.type === 'text' ? part.text : '[image]').join('\n') } : { type: 'content', value: parts } }] });
+            continue;
+        }
+        const content = [];
+        const replay = projectReplay('source' in message ? message.source : undefined, message.content, model, options.provider, warn);
+        for (const [original, wire] of replay.callIds)
+            callIds.set(original, wire);
+        for (const [index, block] of message.content.entries()) {
+            const providerOptions = replay.blocks[index];
+            if (block.type === 'text')
+                content.push({ type: 'text', text: block.text, providerOptions });
+            else if (block.type === 'file')
+                content.push({ type: 'text', text: fileHandleText(block.attachment, attachments?.()?.fileHostPath(block.attachment)) });
+            else if (block.type === 'reasoning' && message.role === 'assistant') {
+                requireReplaySignature(block, model.protocol, providerOptions);
+                content.push({ type: 'reasoning', text: block.text, providerOptions });
+            }
+            else if (block.type === 'tool-call' && message.role === 'assistant') {
+                if (model.protocol === 'responses' && block.id.includes('|') && !replay.callIds.has(block.id))
+                    throw new LlmError('Cannot restore legacy Responses tool call pairing', 'INVALID_REPLAY_STATE');
+                if (names.has(block.id))
+                    throw new LlmError('Duplicate stored tool call id', 'INVALID_REPLAY_STATE');
+                if (model.protocol === 'google' && model.reasoning && !providerOptions?.google?.thoughtSignature && !message.content.slice(0, index).some(part => part.type === 'tool-call'))
+                    throw new LlmError('Cannot replay Google tool call without its verified thought signature', 'INVALID_REPLAY_STATE');
+                names.set(block.id, block.name);
+                let input;
+                try {
+                    input = JSON.parse(block.arguments);
+                }
+                catch {
+                    throw new LlmError('Stored tool arguments are not valid JSON', 'INVALID_REPLAY_STATE');
+                }
+                content.push({ type: 'tool-call', toolCallId: callIds.get(block.id) ?? block.id, toolName: block.name, input, providerOptions });
+            }
+            else if (block.type === 'image') {
+                if (message.role === 'assistant')
+                    throw new LlmError('Structured assistant image output is unsupported', 'UNSUPPORTED_CONTENT');
+                content.push(await imagePart(block));
+            }
+        }
+        prompt.push({ role: message.role, content });
+    }
+    return prompt;
+}

package/node_modules/@askdkc/dsh-auth/lib/opencode-owned.generated.d.ts

@@ -0,0 +1,113 @@
+/** Generated from official rosters and exact-route models.dev metadata. */
+export declare const OPEN_CODE_SNAPSHOTS: {
+    opencode: {
+        version: number;
+        provider: string;
+        fetchedAt: number;
+        roster: string[];
+        models: ({
+            id: string;
+            name: string;
+            protocol: string;
+            contextWindow: number;
+            maxTokens: number;
+            inputModalities: string[];
+            toolCall: boolean;
+            reasoning: boolean;
+            temperature: boolean;
+            efforts: string[];
+            cost: {
+                input: number;
+                output: number;
+                cache_read: number;
+                cache_write: number;
+                input_audio?: undefined;
+            };
+        } | {
+            id: string;
+            name: string;
+            protocol: string;
+            contextWindow: number;
+            maxTokens: number;
+            inputModalities: string[];
+            toolCall: boolean;
+            reasoning: boolean;
+            temperature: boolean;
+            efforts: string[];
+            cost: {
+                input: number;
+                output: number;
+                cache_read: number;
+                cache_write?: undefined;
+                input_audio?: undefined;
+            };
+        } | {
+            id: string;
+            name: string;
+            protocol: string;
+            contextWindow: number;
+            maxTokens: number;
+            inputModalities: string[];
+            toolCall: boolean;
+            reasoning: boolean;
+            temperature: boolean;
+            efforts: string[];
+            cost: {
+                input: number;
+                output: number;
+                cache_read: number;
+                input_audio: number;
+                cache_write?: undefined;
+            };
+        })[];
+        excluded: {
+            id: string;
+            reason: string;
+        }[];
+    };
+    "opencode-go": {
+        version: number;
+        provider: string;
+        fetchedAt: number;
+        roster: string[];
+        models: ({
+            id: string;
+            name: string;
+            protocol: string;
+            contextWindow: number;
+            maxTokens: number;
+            inputModalities: string[];
+            toolCall: boolean;
+            reasoning: boolean;
+            temperature: boolean;
+            efforts: string[];
+            cost: {
+                input: number;
+                output: number;
+                cache_read: number;
+                cache_write?: undefined;
+            };
+        } | {
+            id: string;
+            name: string;
+            protocol: string;
+            contextWindow: number;
+            maxTokens: number;
+            inputModalities: string[];
+            toolCall: boolean;
+            reasoning: boolean;
+            temperature: boolean;
+            efforts: string[];
+            cost: {
+                input: number;
+                output: number;
+                cache_read: number;
+                cache_write: number;
+            };
+        })[];
+        excluded: {
+            id: string;
+            reason: string;
+        }[];
+    };
+};