dot-studio 0.0.1

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

@@ -0,0 +1,69 @@
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+function authStoreCandidates() {
+    const home = os.homedir();
+    const candidates = [
+        process.env.OPENCODE_AUTH_PATH,
+        process.env.XDG_DATA_HOME ? path.join(process.env.XDG_DATA_HOME, 'opencode', 'auth.json') : null,
+        path.join(home, '.local', 'share', 'opencode', 'auth.json'),
+        path.join(home, 'Library', 'Application Support', 'opencode', 'auth.json'),
+        path.join(home, 'AppData', 'Local', 'opencode', 'auth.json'),
+    ];
+    return candidates.filter((candidate) => Boolean(candidate));
+}
+async function resolveAuthStorePath() {
+    for (const candidate of authStoreCandidates()) {
+        try {
+            await fs.access(candidate);
+            return candidate;
+        }
+        catch {
+            continue;
+        }
+    }
+    return authStoreCandidates()[0];
+}
+export async function readStoredProviderAuthType(providerId) {
+    const authPath = await resolveAuthStorePath();
+    if (!authPath) {
+        return null;
+    }
+    try {
+        const raw = await fs.readFile(authPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        const normalized = providerId.replace(/\/+$/, '');
+        const entry = parsed[providerId] || parsed[normalized] || parsed[`${normalized}/`];
+        if (!entry || typeof entry !== 'object') {
+            return null;
+        }
+        const type = entry.type;
+        return typeof type === 'string' && type.trim() ? type.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function clearStoredProviderAuth(providerId) {
+    const authPath = await resolveAuthStorePath();
+    if (!authPath) {
+        return false;
+    }
+    let current = {};
+    try {
+        const raw = await fs.readFile(authPath, 'utf-8');
+        current = JSON.parse(raw);
+    }
+    catch (error) {
+        if (error?.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    const normalized = providerId.replace(/\/+$/, '');
+    delete current[providerId];
+    delete current[normalized];
+    delete current[`${normalized}/`];
+    await fs.mkdir(path.dirname(authPath), { recursive: true });
+    await fs.writeFile(authPath, `${JSON.stringify(current, null, 2)}\n`, { mode: 0o600 });
+    return true;
+}

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

@@ -0,0 +1,220 @@
+export class StudioValidationError extends Error {
+    action;
+    status;
+    constructor(message, action = 'fix_input', status = 400) {
+        super(message);
+        this.name = 'StudioValidationError';
+        this.action = action;
+        this.status = status;
+    }
+}
+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,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function extractBodyMessage(body) {
+    if (typeof body !== 'string' || !body.trim()) {
+        return null;
+    }
+    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();
+            }
+        }
+    }
+    catch {
+        return body.trim();
+    }
+    return body.trim();
+}
+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),
+    ].find((candidate) => typeof candidate === 'string' && candidate.trim().length > 0);
+    return message || 'OpenCode request failed.';
+}
+function extractProviderId(err, context) {
+    return context.providerId?.trim()
+        || err?.data?.providerID
+        || err?.providerId
+        || context.model?.provider
+        || undefined;
+}
+function isProviderAuthError(name, message, status) {
+    return name === 'ProviderAuthError'
+        || status === 401
+        || status === 403
+        || /\b(unauthorized|forbidden|authentication|auth\b|api key|credentials?|token expired|provider auth)\b/i.test(message);
+}
+function isModelUnavailableError(message) {
+    return /\b(model|provider\/model)\b/i.test(message)
+        && /\b(not found|not available|unavailable|unsupported|unknown|invalid|does not exist|missing)\b/i.test(message);
+}
+function isRuntimeUnavailableError(message, status) {
+    return status === 502
+        || status === 503
+        || status === 504
+        || /\b(ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENOTFOUND|socket hang up|failed to fetch|network error|connection refused|service unavailable|gateway timeout)\b/i.test(message);
+}
+function isStructuredOutputError(name, message) {
+    return name === 'StructuredOutputError'
+        || /\b(structured output|json schema|output schema|format validation)\b/i.test(message);
+}
+function isContextOverflowError(name, message) {
+    return name === 'ContextOverflowError'
+        || /\b(context overflow|context window|prompt is too long|too many tokens|maximum context|exceeds context)\b/i.test(message);
+}
+function isSdkContractError(message, status) {
+    return status === 404
+        || /\b(no body in sse response|unexpected response|response validation|invalid response|failed to parse|cannot read properties of undefined|not implemented)\b/i.test(message);
+}
+export function normalizeOpencodeError(err, context = {}) {
+    if (err instanceof StudioValidationError) {
+        return {
+            error: err.message,
+            detail: err.message,
+            code: 'validation',
+            action: err.action,
+            retryable: false,
+            status: err.status,
+        };
+    }
+    const raw = err;
+    const name = typeof raw?.name === 'string'
+        ? raw.name
+        : typeof raw?.error?.name === 'string'
+            ? raw.error.name
+            : 'UnknownError';
+    const detail = extractMessage(raw);
+    const status = extractStatus(raw);
+    const providerId = extractProviderId(raw, context);
+    const modelId = context.model?.modelId;
+    const retryable = raw?.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.`,
+            detail,
+            code: 'provider_auth',
+            action: 'reconnect_provider',
+            retryable: false,
+            status: status || 401,
+            ...(providerId ? { providerId } : {}),
+            ...(modelId ? { modelId } : {}),
+        };
+    }
+    if (isModelUnavailableError(detail)) {
+        return {
+            error: `The selected model${modelId ? ` (${modelId})` : ''} is unavailable. Choose another model for this performer and try again.`,
+            detail,
+            code: 'model_unavailable',
+            action: 'choose_model',
+            retryable: false,
+            status: status || 404,
+            ...(providerId ? { providerId } : {}),
+            ...(modelId ? { modelId } : {}),
+        };
+    }
+    if (isContextOverflowError(name, detail)) {
+        return {
+            error: 'The current context is too large for the selected model. Reduce context, switch variants, or choose a model with a larger window.',
+            detail,
+            code: 'context_overflow',
+            action: 'reduce_context',
+            retryable: false,
+            status: status || 400,
+            ...(providerId ? { providerId } : {}),
+            ...(modelId ? { modelId } : {}),
+        };
+    }
+    if (isStructuredOutputError(name, detail)) {
+        return {
+            error: 'OpenCode could not satisfy the required structured output format. Retry, simplify the task, or adjust the current act node.',
+            detail,
+            code: 'structured_output',
+            action: 'retry',
+            retryable: true,
+            status: status || 422,
+            ...(providerId ? { providerId } : {}),
+            ...(modelId ? { modelId } : {}),
+        };
+    }
+    if (isRuntimeUnavailableError(detail, status)) {
+        return {
+            error: 'OpenCode is unavailable right now. Retry in a moment or restart OpenCode from Settings.',
+            detail,
+            code: 'runtime_unavailable',
+            action: 'restart_opencode',
+            retryable: true,
+            status: status || 503,
+            ...(providerId ? { providerId } : {}),
+            ...(modelId ? { modelId } : {}),
+        };
+    }
+    if (isSdkContractError(detail, status)) {
+        return {
+            error: 'Studio could not complete this request because the OpenCode API contract looks incompatible. Refresh Studio or restart OpenCode.',
+            detail,
+            code: 'sdk_contract',
+            action: 'refresh_studio',
+            retryable: false,
+            status: status || 502,
+            ...(providerId ? { providerId } : {}),
+            ...(modelId ? { modelId } : {}),
+        };
+    }
+    return {
+        error: detail,
+        detail,
+        code: 'unknown',
+        action: retryable ? 'retry' : 'fix_input',
+        retryable,
+        status: status || context.defaultStatus || 500,
+        ...(providerId ? { providerId } : {}),
+        ...(modelId ? { modelId } : {}),
+    };
+}
+export function jsonOpencodeError(c, err, context = {}) {
+    const payload = normalizeOpencodeError(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) {
+        throw value.error;
+    }
+    if (value && typeof value === 'object' && 'data' in value) {
+        return value.data;
+    }
+    return value;
+}
+export function unwrapPromptResult(result) {
+    const data = unwrapOpencodeResult(result);
+    if (data?.info?.error) {
+        throw data.info.error;
+    }
+    return data;
+}

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

@@ -0,0 +1,144 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import { DEFAULT_PROJECT_DIR, OPENCODE_MANAGED, OPENCODE_URL } from './config.js';
+import { resolvePackageBin } from './package-bin.js';
+const STARTUP_TIMEOUT_MS = 15_000;
+const HEALTHCHECK_INTERVAL_MS = 250;
+const REACHABILITY_CACHE_MS = 1_000;
+let child = null;
+let startupPromise = null;
+let reachabilityCache = null;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function resolvePort() {
+    try {
+        const url = new URL(OPENCODE_URL);
+        if (url.port) {
+            return Number(url.port);
+        }
+        return url.protocol === 'https:' ? 443 : 80;
+    }
+    catch {
+        return 4096;
+    }
+}
+function resolveCommand() {
+    return process.env.OPENCODE_BIN || resolvePackageBin('opencode-ai', 'opencode') || 'opencode';
+}
+export function isManagedOpencode() {
+    return OPENCODE_MANAGED;
+}
+export function canRestartOpencodeSidecar() {
+    return !!child;
+}
+export async function isOpencodeReachable() {
+    try {
+        const url = new URL('/project', OPENCODE_URL);
+        url.searchParams.set('directory', path.resolve(DEFAULT_PROJECT_DIR));
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 1_500);
+        try {
+            const response = await fetch(url.toString(), { signal: controller.signal });
+            return response.ok;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    catch {
+        return false;
+    }
+}
+async function getReachability(force = false) {
+    if (!force && reachabilityCache && Date.now() - reachabilityCache.checkedAt < REACHABILITY_CACHE_MS) {
+        return reachabilityCache.ok;
+    }
+    const ok = await isOpencodeReachable();
+    reachabilityCache = { ok, checkedAt: Date.now() };
+    return ok;
+}
+async function waitForReady() {
+    const deadline = Date.now() + STARTUP_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (await isOpencodeReachable()) {
+            return;
+        }
+        if (child && child.exitCode !== null) {
+            break;
+        }
+        await sleep(HEALTHCHECK_INTERVAL_MS);
+    }
+    throw new Error('OpenCode sidecar did not become ready in time.');
+}
+async function waitForShutdown() {
+    const deadline = Date.now() + STARTUP_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (!(await isOpencodeReachable())) {
+            return;
+        }
+        await sleep(HEALTHCHECK_INTERVAL_MS);
+    }
+    throw new Error('OpenCode sidecar did not stop in time.');
+}
+export async function ensureOpencodeSidecar() {
+    if (!isManagedOpencode()) {
+        return;
+    }
+    if (startupPromise) {
+        return startupPromise;
+    }
+    if (child && child.exitCode === null) {
+        if (reachabilityCache?.ok) {
+            return;
+        }
+        if (await getReachability()) {
+            return;
+        }
+    }
+    if (await getReachability()) {
+        return;
+    }
+    startupPromise = (async () => {
+        if (await getReachability()) {
+            return;
+        }
+        const opencode = spawn(resolveCommand(), ['--port', String(resolvePort()), path.resolve(DEFAULT_PROJECT_DIR)], {
+            cwd: path.resolve(DEFAULT_PROJECT_DIR),
+            env: process.env,
+            stdio: 'ignore',
+        });
+        child = opencode;
+        opencode.once('exit', () => {
+            if (child === opencode) {
+                child = null;
+            }
+            reachabilityCache = null;
+        });
+        await waitForReady();
+        reachabilityCache = { ok: true, checkedAt: Date.now() };
+    })().finally(() => {
+        startupPromise = null;
+    });
+    return startupPromise;
+}
+export async function restartOpencodeSidecar() {
+    if (!isManagedOpencode()) {
+        throw new Error('OpenCode restart is only available in managed mode.');
+    }
+    if (!child) {
+        if (await getReachability(true)) {
+            throw new Error('Managed OpenCode restart is unavailable because the current daemon was not started by Studio.');
+        }
+        return ensureOpencodeSidecar();
+    }
+    const currentChild = child;
+    currentChild.kill('SIGTERM');
+    await waitForShutdown().catch(async () => {
+        currentChild.kill('SIGKILL');
+        await waitForShutdown();
+    });
+    child = null;
+    reachabilityCache = null;
+    return ensureOpencodeSidecar();
+}

package/dist/server/lib/opencode.js

@@ -0,0 +1,12 @@
+// OpenCode SDK Client Singleton
+import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { OPENCODE_URL } from './config.js';
+import { ensureOpencodeSidecar } from './opencode-sidecar.js';
+let opencode = null;
+export async function getOpencode() {
+    await ensureOpencodeSidecar();
+    if (!opencode) {
+        opencode = createOpencodeClient({ baseUrl: OPENCODE_URL });
+    }
+    return opencode;
+}

package/dist/server/lib/package-bin.js

@@ -0,0 +1,63 @@
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+function readJson(pathname) {
+    try {
+        return JSON.parse(fs.readFileSync(pathname, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function findPackageJsonFromEntry(packageName, entryPath) {
+    let currentDir = path.dirname(entryPath);
+    while (true) {
+        const packageJsonPath = path.join(currentDir, 'package.json');
+        const packageJson = readJson(packageJsonPath);
+        if (packageJson?.name === packageName) {
+            return packageJsonPath;
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}
+function resolvePackageJsonPath(packageName) {
+    try {
+        return require.resolve(`${packageName}/package.json`);
+    }
+    catch {
+        try {
+            const entryPath = require.resolve(packageName);
+            return findPackageJsonFromEntry(packageName, entryPath);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+function resolveBinPath(packageJsonPath, binName) {
+    const packageJson = readJson(packageJsonPath);
+    const binField = packageJson?.bin;
+    if (!binField) {
+        return null;
+    }
+    if (typeof binField === 'string') {
+        return path.resolve(path.dirname(packageJsonPath), binField);
+    }
+    if (typeof binField[binName] === 'string') {
+        return path.resolve(path.dirname(packageJsonPath), binField[binName]);
+    }
+    const firstBin = Object.values(binField).find((value) => typeof value === 'string');
+    return firstBin ? path.resolve(path.dirname(packageJsonPath), firstBin) : null;
+}
+export function resolvePackageBin(packageName, binName) {
+    const packageJsonPath = resolvePackageJsonPath(packageName);
+    if (!packageJsonPath) {
+        return null;
+    }
+    return resolveBinPath(packageJsonPath, binName);
+}

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

@@ -0,0 +1,39 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { extractProjectMcpCatalog, projectMcpEntryEnabled, projectMcpEntryType, } from '../../shared/project-mcp.js';
+export async function readProjectConfigFile(cwd) {
+    try {
+        const raw = await fs.readFile(path.join(cwd, 'config.json'), 'utf-8');
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export async function readProjectMcpCatalog(cwd) {
+    const config = await readProjectConfigFile(cwd);
+    return extractProjectMcpCatalog(config);
+}
+export function summarizeProjectMcpCatalog(catalog, liveStatus) {
+    return Object.keys({
+        ...catalog,
+        ...liveStatus,
+    })
+        .sort((left, right) => left.localeCompare(right))
+        .map((name) => {
+        const config = catalog[name];
+        const live = liveStatus[name];
+        const status = live?.status || (config ? (projectMcpEntryEnabled(config) ? 'disconnected' : 'disabled') : 'unknown');
+        return {
+            name,
+            status,
+            tools: live?.tools || [],
+            resources: live?.resources || [],
+            enabled: config ? projectMcpEntryEnabled(config) : false,
+            defined: !!config,
+            configType: projectMcpEntryType(config),
+            authStatus: status === 'needs_auth' ? 'needs_auth' : status === 'connected' ? 'ready' : 'n/a',
+        };
+    });
+}