dot-studio 0.0.1 → 0.0.2

package/dist/server/lib/model-catalog.js

@@ -1,6 +1,15 @@
 import { getOpencode } from './opencode.js';
 import { readStoredProviderAuthType } from './opencode-auth.js';
 import { normalizeRuntimeVariants, } from '../../shared/model-variants.js';
+function responseData(response) {
+    if (!response || typeof response !== 'object' || !('data' in response)) {
+        return undefined;
+    }
+    return response.data;
+}
+function asRecord(value) {
+    return value && typeof value === 'object' ? value : {};
+}
 const incompatibleModelsByAuthType = {
     openai: {
         // ChatGPT account-backed OpenAI auth rejects these at runtime today.
@@ -11,9 +20,7 @@ const incompatibleModelsByAuthType = {
     },
 };
 function readCapabilityFlag(model, ...keys) {
-    const capabilityRecord = model.capabilities && typeof model.capabilities === 'object'
-        ? model.capabilities
-        : {};
+    const capabilityRecord = asRecord(model.capabilities);
     for (const key of keys) {
         if (typeof capabilityRecord[key] === 'boolean') {
             return capabilityRecord[key];
@@ -25,18 +32,17 @@ function readCapabilityFlag(model, ...keys) {
     return false;
 }
 function readModalities(model) {
-    const capabilityRecord = model.capabilities && typeof model.capabilities === 'object'
-        ? model.capabilities
-        : {};
+    const capabilityRecord = asRecord(model.capabilities);
+    const modalityRecord = asRecord(model.modalities);
     const input = Array.isArray(capabilityRecord.input)
         ? capabilityRecord.input.filter((value) => typeof value === 'string')
-        : Array.isArray(model.modalities?.input)
-            ? model.modalities.input.filter((value) => typeof value === 'string')
+        : Array.isArray(modalityRecord.input)
+            ? modalityRecord.input.filter((value) => typeof value === 'string')
             : ['text'];
     const output = Array.isArray(capabilityRecord.output)
         ? capabilityRecord.output.filter((value) => typeof value === 'string')
-        : Array.isArray(model.modalities?.output)
-            ? model.modalities.output.filter((value) => typeof value === 'string')
+        : Array.isArray(modalityRecord.output)
+            ? modalityRecord.output.filter((value) => typeof value === 'string')
             : ['text'];
     return { input, output };
 }
@@ -50,10 +56,62 @@ function isModelVisibleForAuthType(providerId, modelId, authType) {
     }
     return !blocked.has(modelId);
 }
+// ── Cached provider.list() ──────────────────────────────
+// Both /api/providers and /api/models need the same raw data from
+// oc.provider.list().  We cache for a short window to avoid duplicate
+// round trips when the two routes are hit close together (which is the
+// common case — the client fetches both on Settings open / refresh).
+const CACHE_TTL_MS = 3_000;
+let _cachedPromise = null;
+let _cachedCwd = null;
+let _cacheTs = 0;
+/**
+ * Fetch the raw oc.provider.list() data with a short TTL cache
+ * keyed on the working directory.
+ */
+export async function fetchProviderListData(cwd) {
+    const now = Date.now();
+    if (_cachedPromise && _cachedCwd === cwd && now - _cacheTs < CACHE_TTL_MS) {
+        return _cachedPromise;
+    }
+    _cachedCwd = cwd;
+    _cacheTs = now;
+    _cachedPromise = (async () => {
+        const oc = await getOpencode();
+        const res = await oc.provider.list({ directory: cwd });
+        return responseData(res);
+    })();
+    // On failure, clear the cache so the next call retries immediately.
+    _cachedPromise.catch(() => {
+        _cachedPromise = null;
+    });
+    return _cachedPromise;
+}
+/** Invalidate the cache (e.g. after auth changes). */
+export function invalidateProviderListCache() {
+    _cachedPromise = null;
+    _cachedCwd = null;
+    _cacheTs = 0;
+}
+export async function listProviderSummaries(cwd) {
+    const data = await fetchProviderListData(cwd);
+    if (!data?.all || !Array.isArray(data.all)) {
+        return [];
+    }
+    const connected = new Set((data?.connected || []));
+    return data.all.map((provider) => ({
+        id: typeof provider.id === 'string' ? provider.id : '',
+        name: typeof provider.name === 'string' ? provider.name : (typeof provider.id === 'string' ? provider.id : ''),
+        source: typeof provider.source === 'string' ? provider.source : 'builtin',
+        env: Array.isArray(provider.env) ? provider.env.filter((value) => typeof value === 'string') : [],
+        connected: typeof provider.id === 'string' ? connected.has(provider.id) : false,
+        modelCount: provider.models ? Object.keys(provider.models).length : 0,
+        defaultModel: typeof provider.id === 'string' ? data?.default?.[provider.id] || null : null,
+    }));
+}
+// ── Model catalog (used by /api/models) ─────────────────
 export async function listRuntimeModels(cwd) {
-    const oc = await getOpencode();
-    const res = await oc.provider.list({ directory: cwd });
-    const data = res.data;
+    const data = await fetchProviderListData(cwd);
     if (!data?.all || !Array.isArray(data.all)) {
         return [];
     }
@@ -82,14 +140,15 @@ export async function listRuntimeModels(cwd) {
             if (!isModelVisibleForAuthType(providerId, id, authType)) {
                 continue;
             }
+            const limitRecord = asRecord(record.limit);
             models.push({
                 provider: providerId,
                 providerName,
                 id,
                 name: typeof record.name === 'string' ? record.name : id,
                 connected,
-                context: Number(record.limit?.context || 0),
-                output: Number(record.limit?.output || 0),
+                context: Number(limitRecord.context || 0),
+                output: Number(limitRecord.output || 0),
                 toolCall: readCapabilityFlag(record, 'toolcall', 'toolCall', 'tool_call'),
                 reasoning: readCapabilityFlag(record, 'reasoning'),
                 attachment: readCapabilityFlag(record, 'attachment'),

package/dist/server/lib/opencode-auth.js

@@ -1,6 +1,9 @@
 import fs from 'fs/promises';
 import os from 'os';
 import path from 'path';
+function isErrnoException(error) {
+    return error instanceof Error;
+}
 function authStoreCandidates() {
     const home = os.homedir();
     const candidates = [
@@ -55,7 +58,7 @@ export async function clearStoredProviderAuth(providerId) {
         current = JSON.parse(raw);
     }
     catch (error) {
-        if (error?.code !== 'ENOENT') {
+        if (!isErrnoException(error) || error.code !== 'ENOENT') {
             throw error;
         }
     }

package/dist/server/lib/opencode-errors.js

@@ -1,3 +1,25 @@
+function asRecord(value) {
+    return value && typeof value === 'object' ? value : undefined;
+}
+function readPath(value, ...keys) {
+    let current = value;
+    for (const key of keys) {
+        const record = asRecord(current);
+        if (!record) {
+            return undefined;
+        }
+        current = record[key];
+    }
+    return current;
+}
+function readString(value, ...keys) {
+    const candidate = readPath(value, ...keys);
+    return typeof candidate === 'string' ? candidate : undefined;
+}
+function readNumber(value, ...keys) {
+    const candidate = readPath(value, ...keys);
+    return typeof candidate === 'number' && Number.isFinite(candidate) ? candidate : undefined;
+}
 export class StudioValidationError extends Error {
     action;
     status;
@@ -10,16 +32,16 @@ export class StudioValidationError extends Error {
 }
 function extractStatus(err) {
     const candidates = [
-        err?.status,
-        err?.statusCode,
-        err?.data?.statusCode,
-        err?.response?.status,
-        err?.cause?.status,
-        err?.cause?.statusCode,
-        err?.cause?.response?.status,
+        readNumber(err, 'status'),
+        readNumber(err, 'statusCode'),
+        readNumber(err, 'data', 'statusCode'),
+        readNumber(err, 'response', 'status'),
+        readNumber(err, 'cause', 'status'),
+        readNumber(err, 'cause', 'statusCode'),
+        readNumber(err, 'cause', 'response', 'status'),
     ];
     for (const candidate of candidates) {
-        if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+        if (candidate !== undefined) {
             return candidate;
         }
     }
@@ -31,13 +53,13 @@ function extractBodyMessage(body) {
     }
     try {
         const parsed = JSON.parse(body);
-        if (parsed && typeof parsed === 'object') {
-            if (typeof parsed.error === 'string' && parsed.error.trim()) {
-                return parsed.error.trim();
-            }
-            if (typeof parsed.message === 'string' && parsed.message.trim()) {
-                return parsed.message.trim();
-            }
+        const error = readString(parsed, 'error');
+        if (error?.trim()) {
+            return error.trim();
+        }
+        const message = readString(parsed, 'message');
+        if (message?.trim()) {
+            return message.trim();
         }
     }
     catch {
@@ -47,20 +69,31 @@ function extractBodyMessage(body) {
 }
 function extractMessage(err) {
     const message = [
-        err?.data?.message,
-        err?.message,
-        err?.error?.message,
-        err?.cause?.data?.message,
-        err?.cause?.message,
-        extractBodyMessage(err?.data?.responseBody),
-        extractBodyMessage(err?.responseBody),
+        readString(err, 'data', 'message'),
+        readString(err, 'message'),
+        readString(err, 'error', 'message'),
+        readString(err, 'cause', 'data', 'message'),
+        readString(err, 'cause', 'message'),
+        extractBodyMessage(readPath(err, 'data', 'responseBody')),
+        extractBodyMessage(readPath(err, 'responseBody')),
     ].find((candidate) => typeof candidate === 'string' && candidate.trim().length > 0);
-    return message || 'OpenCode request failed.';
+    if (message) {
+        return message;
+    }
+    // Stringify raw error for debuggability — truncate if huge
+    try {
+        const raw = JSON.stringify(err, null, 2);
+        const truncated = raw.length > 500 ? raw.slice(0, 500) + '…' : raw;
+        return `OpenCode request failed. Raw: ${truncated}`;
+    }
+    catch {
+        return 'OpenCode request failed.';
+    }
 }
 function extractProviderId(err, context) {
     return context.providerId?.trim()
-        || err?.data?.providerID
-        || err?.providerId
+        || readString(err, 'data', 'providerID')
+        || readString(err, 'providerId')
         || context.model?.provider
         || undefined;
 }
@@ -103,17 +136,16 @@ export function normalizeOpencodeError(err, context = {}) {
             status: err.status,
         };
     }
-    const raw = err;
-    const name = typeof raw?.name === 'string'
-        ? raw.name
-        : typeof raw?.error?.name === 'string'
-            ? raw.error.name
+    const name = typeof readString(err, 'name') === 'string'
+        ? readString(err, 'name')
+        : typeof readString(err, 'error', 'name') === 'string'
+            ? readString(err, 'error', 'name')
             : 'UnknownError';
-    const detail = extractMessage(raw);
-    const status = extractStatus(raw);
-    const providerId = extractProviderId(raw, context);
+    const detail = extractMessage(err);
+    const status = extractStatus(err);
+    const providerId = extractProviderId(err, context);
     const modelId = context.model?.modelId;
-    const retryable = raw?.data?.isRetryable === true || (!!status && status >= 500);
+    const retryable = readPath(err, 'data', 'isRetryable') === true || (!!status && status >= 500);
     if (isProviderAuthError(name, detail, status)) {
         return {
             error: `Provider authentication is missing or expired${providerId ? ` for ${providerId}` : ''}. Reconnect it in Settings and try again.`,
@@ -202,14 +234,14 @@ export function jsonOpencodeError(c, err, context = {}) {
     return c.json(payload, payload.status);
 }
 export function unwrapOpencodeResult(result) {
-    const value = result;
-    if (value && typeof value === 'object' && 'error' in value && value.error) {
+    const value = asRecord(result);
+    if (value && 'error' in value && value.error) {
         throw value.error;
     }
-    if (value && typeof value === 'object' && 'data' in value) {
+    if (value && 'data' in value) {
         return value.data;
     }
-    return value;
+    return result;
 }
 export function unwrapPromptResult(result) {
     const data = unwrapOpencodeResult(result);

package/dist/server/lib/opencode-sidecar.js

@@ -1,6 +1,6 @@
 import { spawn } from 'child_process';
 import path from 'path';
-import { DEFAULT_PROJECT_DIR, OPENCODE_MANAGED, OPENCODE_URL } from './config.js';
+import { DEFAULT_PROJECT_DIR, OPENCODE_MANAGED, OPENCODE_URL, STUDIO_DIR } from './config.js';
 import { resolvePackageBin } from './package-bin.js';
 const STARTUP_TIMEOUT_MS = 15_000;
 const HEALTHCHECK_INTERVAL_MS = 250;
@@ -105,7 +105,10 @@ export async function ensureOpencodeSidecar() {
         }
         const opencode = spawn(resolveCommand(), ['--port', String(resolvePort()), path.resolve(DEFAULT_PROJECT_DIR)], {
             cwd: path.resolve(DEFAULT_PROJECT_DIR),
-            env: process.env,
+            env: {
+                ...process.env,
+                OPENCODE_CONFIG_DIR: path.join(STUDIO_DIR, 'opencode'),
+            },
             stdio: 'ignore',
         });
         child = opencode;

package/dist/server/lib/project-config.js

@@ -25,6 +25,9 @@ export function summarizeProjectMcpCatalog(catalog, liveStatus) {
         const config = catalog[name];
         const live = liveStatus[name];
         const status = live?.status || (config ? (projectMcpEntryEnabled(config) ? 'disconnected' : 'disabled') : 'unknown');
+        const oauthConfig = config && 'type' in config && config.type === 'remote'
+            ? config.oauth
+            : undefined;
         return {
             name,
             status,
@@ -34,6 +37,11 @@ export function summarizeProjectMcpCatalog(catalog, liveStatus) {
             defined: !!config,
             configType: projectMcpEntryType(config),
             authStatus: status === 'needs_auth' ? 'needs_auth' : status === 'connected' ? 'ready' : 'n/a',
+            error: typeof live?.error === 'string' ? live.error : undefined,
+            oauthConfigured: !!(oauthConfig
+                && typeof oauthConfig === 'object'
+                && (oauthConfig.clientId || oauthConfig.clientSecret || oauthConfig.scope)),
+            clientRegistrationRequired: status === 'needs_client_registration',
         };
     });
 }

package/dist/server/lib/runtime-tools.js

@@ -4,6 +4,23 @@ import { readProjectMcpCatalog } from './project-config.js';
 function unique(values) {
     return Array.from(new Set(values.filter(Boolean)));
 }
+function responseData(response, fallback) {
+    if (!response || typeof response !== 'object' || !('data' in response)) {
+        return fallback;
+    }
+    return (response.data ?? fallback);
+}
+function errorMessage(error, fallback) {
+    return error instanceof Error && error.message ? error.message : fallback;
+}
+function toolNames(entry) {
+    return (entry?.tools || []).map((tool) => {
+        if (!tool || typeof tool !== 'object' || !('name' in tool) || typeof tool.name !== 'string') {
+            return '';
+        }
+        return tool.name;
+    }).filter(Boolean);
+}
 export function describeUnavailableRuntimeTools(resolution) {
     if (resolution.selectedMcpServers.length === 0 || resolution.unavailableDetails.length === 0) {
         return null;
@@ -15,6 +32,9 @@ export function describeUnavailableRuntimeTools(resolution) {
         if (detail.reason === 'needs_auth') {
             return `${detail.serverName}: authentication required`;
         }
+        if (detail.reason === 'needs_client_registration') {
+            return `${detail.serverName}: OAuth client registration required`;
+        }
         if (detail.reason === 'disabled') {
             return `${detail.serverName}: disabled in project config`;
         }
@@ -47,7 +67,7 @@ function emptyResolution(selectedMcpServers) {
 }
 async function currentMcpStatus(oc, cwd) {
     const res = await oc.mcp.status({ directory: cwd });
-    return (res.data || {});
+    return responseData(res, {});
 }
 async function ensureConnectedServer(oc, cwd, serverName, catalog, statusMap) {
     const config = catalog[serverName];
@@ -88,6 +108,16 @@ async function ensureConnectedServer(oc, cwd, serverName, catalog, statusMap) {
             },
         };
     }
+    if (current?.status === 'needs_client_registration') {
+        return {
+            statusMap,
+            unavailable: {
+                serverName,
+                reason: 'needs_client_registration',
+                detail: current?.error || 'Server requires OAuth client registration before it can connect.',
+            },
+        };
+    }
     try {
         await oc.mcp.connect({
             name: serverName,
@@ -100,7 +130,7 @@ async function ensureConnectedServer(oc, cwd, serverName, catalog, statusMap) {
             unavailable: {
                 serverName,
                 reason: 'connect_failed',
-                detail: error?.message || 'Connection attempt failed.',
+                detail: errorMessage(error, 'Connection attempt failed.'),
             },
         };
     }
@@ -122,6 +152,16 @@ async function ensureConnectedServer(oc, cwd, serverName, catalog, statusMap) {
             },
         };
     }
+    if (next?.status === 'needs_client_registration') {
+        return {
+            statusMap: refreshed,
+            unavailable: {
+                serverName,
+                reason: 'needs_client_registration',
+                detail: next?.error || 'Server requires OAuth client registration before it can connect.',
+            },
+        };
+    }
     return {
         statusMap: refreshed,
         unavailable: {
@@ -147,8 +187,7 @@ export async function resolveRuntimeTools(cwd, model, mcpServerNames) {
             unavailableDetails.push(ensured.unavailable);
         }
     }
-    const requestedTools = unique(selectedMcpServers.flatMap((serverName) => (mcpStatus[serverName]?.tools || [])
-        .map((tool) => tool.name || '')));
+    const requestedTools = unique(selectedMcpServers.flatMap((serverName) => toolNames(mcpStatus[serverName])));
     if (requestedTools.length === 0) {
         return {
             ...emptyResolution(selectedMcpServers),
@@ -162,22 +201,21 @@ export async function resolveRuntimeTools(cwd, model, mcpServerNames) {
             model: model.modelId,
             directory: cwd,
         });
-        const items = (toolListRes.data || []);
+        const items = responseData(toolListRes, []);
         availableTools = unique(items.map((item) => item.id || ''));
     }
     else {
         const toolIdsRes = await oc.tool.ids({
             directory: cwd,
         });
-        availableTools = unique((toolIdsRes.data || []));
+        availableTools = unique(responseData(toolIdsRes, []));
     }
     const availableSet = new Set(availableTools);
     const resolvedTools = requestedTools.filter((toolId) => availableSet.has(toolId));
     const unavailableTools = requestedTools.filter((toolId) => !availableSet.has(toolId));
     const toolServerNames = new Map();
     for (const serverName of selectedMcpServers) {
-        for (const tool of (mcpStatus[serverName]?.tools || [])) {
-            const toolId = tool.name || '';
+        for (const toolId of toolNames(mcpStatus[serverName])) {
             if (!toolId)
                 continue;
             const current = toolServerNames.get(toolId) || [];