dot-studio 0.0.1 → 0.0.2

package/dist/server/routes/health.js

@@ -1,56 +1,41 @@
 // Health, Studio Config & Activation Routes
 import { Hono } from 'hono';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import fs from 'fs/promises';
-import path from 'path';
-import { getActiveProjectDir, setActiveProjectDir, readStudioConfig, writeStudioConfig, } from '../lib/config.js';
-import { invalidateAll } from '../lib/cache.js';
-import { resolveRequestWorkingDir } from '../lib/request-context.js';
-const execAsync = promisify(exec);
+import { activateStudioProject, getStudioConfig, openStudioPath, pickWorkingDirectory, updateStudioConfig, } from '../services/studio-service.js';
+import { jsonError, jsonServiceFailure, requestWorkingDir } from './route-errors.js';
 const health = new Hono();
 // ── Health ───────────────────────────────────────────────
-health.get('/api/health', (c) => c.json({ ok: true, project: resolveRequestWorkingDir(c) }));
+health.get('/api/health', (c) => c.json({ ok: true, project: requestWorkingDir(c) }));
 // ── Pick Directory (macOS) ──────────────────────────────
 health.get('/api/studio/pick-directory', async (c) => {
     try {
-        const { stdout } = await execAsync(`osascript -e 'POSIX path of (choose folder with prompt "Select Working Directory for Stage")'`);
-        return c.json({ path: stdout.trim() });
+        return c.json(await pickWorkingDirectory());
     }
     catch {
-        return c.json({ error: 'Selection cancelled or failed' }, 400);
+        return jsonError(c, 'Selection cancelled or failed', 400);
     }
 });
 // ── Studio Config ───────────────────────────────────────
 health.get('/api/studio/config', async (c) => {
-    const config = await readStudioConfig();
-    return c.json({ ...config, projectDir: resolveRequestWorkingDir(c) });
+    return c.json(await getStudioConfig(requestWorkingDir(c)));
 });
 health.put('/api/studio/config', async (c) => {
     const body = await c.req.json();
-    const merged = await writeStudioConfig(body);
-    return c.json(merged);
+    return c.json(await updateStudioConfig(body));
 });
 health.post('/api/studio/activate', async (c) => {
     const { workingDir } = await c.req.json();
-    if (!workingDir) {
-        return c.json({ error: 'workingDir is required' }, 400);
+    const result = await activateStudioProject(workingDir);
+    if (!result.ok) {
+        return jsonServiceFailure(c, result);
     }
-    // Normalize: resolve, trim trailing slashes
-    const resolved = path.resolve(workingDir.replace(/\/+$/, ''));
-    // Verify directory exists
-    try {
-        const stat = await fs.stat(resolved);
-        if (!stat.isDirectory()) {
-            return c.json({ error: 'workingDir is not a directory' }, 400);
-        }
-    }
-    catch {
-        return c.json({ error: `Directory not found: ${resolved}` }, 400);
+    return c.json(result);
+});
+health.post('/api/studio/open-path', async (c) => {
+    const { path } = await c.req.json();
+    const result = await openStudioPath(path);
+    if (!result.ok) {
+        return jsonServiceFailure(c, result);
     }
-    setActiveProjectDir(resolved);
-    invalidateAll(); // flush all caches — assets, models, MCP are project-scoped
-    console.log(`🎯 Active project dir switched to: ${getActiveProjectDir()}`);
-    return c.json({ ok: true, activeProjectDir: getActiveProjectDir() });
+    return c.json(result);
 });
 export default health;

package/dist/server/routes/opencode-core.js

@@ -0,0 +1,120 @@
+import { Hono } from 'hono';
+import { resolveRuntimeTools } from '../lib/runtime-tools.js';
+import { jsonOpencodeError } from '../lib/opencode-errors.js';
+import { listRuntimeModels, listProviderSummaries } from '../lib/model-catalog.js';
+import { getLspStatus, getOpenCodeConfig, getOpenCodeHealth, getOpenCodeUnavailableHealth, getProviderAuthStatus, getVcsStatus, listOpenCodeAgents, listOpenCodeToolIds, listOpenCodeToolsForModel, readProjectConfigSnapshot, restartManagedOpenCode, updateOpenCodeConfig, } from '../services/opencode-service.js';
+import { requestWorkingDir } from './route-errors.js';
+const opencodeCore = new Hono();
+function toError(error) {
+    return error instanceof Error ? error : new Error('OpenCode is unavailable');
+}
+opencodeCore.get('/api/opencode/health', async (c) => {
+    try {
+        return c.json(await getOpenCodeHealth(requestWorkingDir(c)));
+    }
+    catch (error) {
+        return c.json(getOpenCodeUnavailableHealth(toError(error)), 503);
+    }
+});
+opencodeCore.post('/api/opencode/restart', async (c) => {
+    try {
+        return c.json(await restartManagedOpenCode());
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err, { defaultStatus: 400 });
+    }
+});
+opencodeCore.get('/api/models', async (c) => {
+    try {
+        return c.json(await listRuntimeModels(requestWorkingDir(c)));
+    }
+    catch {
+        return c.json([]);
+    }
+});
+opencodeCore.get('/api/providers', async (c) => {
+    try {
+        return c.json(await listProviderSummaries(requestWorkingDir(c)));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err, { defaultStatus: 503 });
+    }
+});
+opencodeCore.get('/api/agents', async (c) => {
+    try {
+        return c.json(await listOpenCodeAgents(requestWorkingDir(c)));
+    }
+    catch {
+        return c.json([]);
+    }
+});
+opencodeCore.get('/api/tools', async (c) => {
+    try {
+        return c.json(await listOpenCodeToolIds(requestWorkingDir(c)));
+    }
+    catch {
+        return c.json([]);
+    }
+});
+opencodeCore.get('/api/tools/:provider/:model', async (c) => {
+    try {
+        return c.json(await listOpenCodeToolsForModel(requestWorkingDir(c), c.req.param('provider'), c.req.param('model')));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+opencodeCore.post('/api/runtime/tools', async (c) => {
+    const { model = null, mcpServerNames = [] } = await c.req.json();
+    try {
+        return c.json(await resolveRuntimeTools(requestWorkingDir(c), model, mcpServerNames));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+opencodeCore.get('/api/config', async (c) => {
+    try {
+        return c.json(await getOpenCodeConfig(requestWorkingDir(c)));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+opencodeCore.get('/api/config/project', async (c) => {
+    return c.json(await readProjectConfigSnapshot(requestWorkingDir(c)));
+});
+opencodeCore.put('/api/config', async (c) => {
+    const body = await c.req.json();
+    try {
+        return c.json(await updateOpenCodeConfig(requestWorkingDir(c), body));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+opencodeCore.get('/api/provider/auth', async (c) => {
+    try {
+        return c.json(await getProviderAuthStatus(requestWorkingDir(c)));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err, { defaultStatus: 503 });
+    }
+});
+opencodeCore.get('/api/lsp/status', async (c) => {
+    try {
+        return c.json(await getLspStatus(requestWorkingDir(c)));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+opencodeCore.get('/api/vcs', async (c) => {
+    try {
+        return c.json(await getVcsStatus(requestWorkingDir(c)));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+export default opencodeCore;

package/dist/server/routes/opencode-file.js

@@ -0,0 +1,67 @@
+import { Hono } from 'hono';
+import { jsonOpencodeError } from '../lib/opencode-errors.js';
+import { findFilesInProject, findSymbolsInProject, findTextInProject, getFileStatus, listFiles, readFile, } from '../services/opencode-service.js';
+import { jsonError, requestWorkingDir } from './route-errors.js';
+const opencodeFile = new Hono();
+opencodeFile.get('/api/file/list', async (c) => {
+    const dirPath = c.req.query('path') || '.';
+    try {
+        return c.json(await listFiles(requestWorkingDir(c), dirPath));
+    }
+    catch {
+        return c.json([]);
+    }
+});
+opencodeFile.get('/api/file/read', async (c) => {
+    const filePath = c.req.query('path');
+    if (!filePath)
+        return jsonError(c, 'path required', 400);
+    try {
+        return c.json(await readFile(requestWorkingDir(c), filePath));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+opencodeFile.get('/api/file/status', async (c) => {
+    try {
+        return c.json(await getFileStatus(requestWorkingDir(c)));
+    }
+    catch {
+        return c.json([]);
+    }
+});
+opencodeFile.get('/api/find/text', async (c) => {
+    const pattern = c.req.query('pattern');
+    if (!pattern)
+        return jsonError(c, 'pattern required', 400);
+    try {
+        return c.json(await findTextInProject(requestWorkingDir(c), pattern));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+opencodeFile.get('/api/find/files', async (c) => {
+    const pattern = c.req.query('pattern');
+    if (!pattern)
+        return jsonError(c, 'pattern required', 400);
+    try {
+        return c.json(await findFilesInProject(requestWorkingDir(c), pattern));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+opencodeFile.get('/api/find/symbols', async (c) => {
+    const pattern = c.req.query('pattern');
+    if (!pattern)
+        return jsonError(c, 'pattern required', 400);
+    try {
+        return c.json(await findSymbolsInProject(requestWorkingDir(c), pattern));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+export default opencodeFile;

package/dist/server/routes/opencode-mcp.js

@@ -0,0 +1,74 @@
+import { Hono } from 'hono';
+import { cached, TTL } from '../lib/cache.js';
+import { jsonOpencodeError } from '../lib/opencode-errors.js';
+import { addMcpServer, authenticateMcp, completeMcpAuth, connectMcpServer, disconnectMcpServer, listMcpServers, removeMcpAuth, startMcpAuth, } from '../services/opencode-service.js';
+import { requestWorkingDir } from './route-errors.js';
+const opencodeMcp = new Hono();
+opencodeMcp.get('/api/mcp/servers', async (c) => {
+    try {
+        const cwd = requestWorkingDir(c);
+        return c.json(await cached(`mcp-servers-${cwd}`, TTL.MCP_SERVERS, async () => listMcpServers(cwd)));
+    }
+    catch {
+        return c.json([]);
+    }
+});
+opencodeMcp.post('/api/mcp/add', async (c) => {
+    const { name, config } = await c.req.json();
+    try {
+        return c.json(await addMcpServer(requestWorkingDir(c), { name, config }));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+opencodeMcp.post('/api/mcp/:name/connect', async (c) => {
+    try {
+        return c.json(await connectMcpServer(requestWorkingDir(c), c.req.param('name')));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+opencodeMcp.post('/api/mcp/:name/auth/start', async (c) => {
+    try {
+        return c.json(await startMcpAuth(requestWorkingDir(c), c.req.param('name')));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err, { defaultStatus: 500 });
+    }
+});
+opencodeMcp.post('/api/mcp/:name/auth/callback', async (c) => {
+    const { code } = await c.req.json().catch(() => ({ code: '' }));
+    try {
+        return c.json(await completeMcpAuth(requestWorkingDir(c), c.req.param('name'), code));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err, { defaultStatus: 500 });
+    }
+});
+opencodeMcp.post('/api/mcp/:name/auth/authenticate', async (c) => {
+    try {
+        return c.json(await authenticateMcp(requestWorkingDir(c), c.req.param('name')));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err, { defaultStatus: 500 });
+    }
+});
+opencodeMcp.delete('/api/mcp/:name/auth', async (c) => {
+    try {
+        return c.json(await removeMcpAuth(requestWorkingDir(c), c.req.param('name')));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err, { defaultStatus: 500 });
+    }
+});
+opencodeMcp.post('/api/mcp/:name/disconnect', async (c) => {
+    try {
+        return c.json(await disconnectMcpServer(requestWorkingDir(c), c.req.param('name')));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+export default opencodeMcp;

package/dist/server/routes/opencode-provider.js

@@ -0,0 +1,41 @@
+import { Hono } from 'hono';
+import { jsonOpencodeError } from '../lib/opencode-errors.js';
+import { authorizeProviderOauth, completeProviderOauth, deleteProviderAuth, updateProviderAuth, } from '../services/opencode-service.js';
+import { requestWorkingDir } from './route-errors.js';
+const opencodeProvider = new Hono();
+opencodeProvider.post('/api/provider/:id/oauth/authorize', async (c) => {
+    const { method } = await c.req.json();
+    try {
+        return c.json(await authorizeProviderOauth(requestWorkingDir(c), c.req.param('id'), method));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err, { providerId: c.req.param('id'), defaultStatus: 500 });
+    }
+});
+opencodeProvider.post('/api/provider/:id/oauth/callback', async (c) => {
+    const { method, code } = await c.req.json();
+    try {
+        return c.json(await completeProviderOauth(requestWorkingDir(c), c.req.param('id'), method, code));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err, { providerId: c.req.param('id'), defaultStatus: 500 });
+    }
+});
+opencodeProvider.put('/api/provider/:id/auth', async (c) => {
+    const auth = await c.req.json();
+    try {
+        return c.json(await updateProviderAuth(requestWorkingDir(c), c.req.param('id'), auth));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err, { providerId: c.req.param('id'), defaultStatus: 500 });
+    }
+});
+opencodeProvider.delete('/api/provider/:id/auth', async (c) => {
+    try {
+        return c.json(await deleteProviderAuth(requestWorkingDir(c), c.req.param('id')));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err, { providerId: c.req.param('id'), defaultStatus: 500 });
+    }
+});
+export default opencodeProvider;