dot-studio 0.0.1 → 0.0.3

package/dist/server/services/opencode-service.js

@@ -0,0 +1,338 @@
+/**
+ * opencode-service.ts – Shared helpers for OpenCode SDK route handlers.
+ *
+ * Extracted from `routes/opencode.ts` to keep route handlers thin.
+ * Contains: response unwrapping, config merging, MCP mutation runner,
+ * MCP auth validation, and health meta.
+ */
+import { getOpencode } from '../lib/opencode.js';
+import { invalidate } from '../lib/cache.js';
+import { OPENCODE_URL } from '../lib/config.js';
+import { isManagedOpencode, canRestartOpencodeSidecar, restartOpencodeSidecar } from '../lib/opencode-sidecar.js';
+import { StudioValidationError, unwrapOpencodeResult } from '../lib/opencode-errors.js';
+import { readProjectConfigFile, readProjectMcpCatalog, summarizeProjectMcpCatalog } from '../lib/project-config.js';
+import { projectMcpEntryEnabled } from '../../shared/project-mcp.js';
+import { invalidateProviderListCache } from '../lib/model-catalog.js';
+import { clearStoredProviderAuth } from '../lib/opencode-auth.js';
+function extractResponseData(response) {
+    if (!response || typeof response !== 'object' || !('data' in response)) {
+        return undefined;
+    }
+    return response.data ?? undefined;
+}
+// ── Response helpers ────────────────────────────────────
+export function opencodeModeMeta() {
+    return {
+        managed: isManagedOpencode(),
+        mode: isManagedOpencode() ? 'managed' : 'external',
+        restartAvailable: canRestartOpencodeSidecar(),
+    };
+}
+export function responseData(response, fallback) {
+    const data = extractResponseData(response);
+    return (data || fallback);
+}
+function isProviderAuthInput(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const auth = value;
+    if (auth.type === 'oauth') {
+        return typeof auth.refresh === 'string' && typeof auth.access === 'string' && typeof auth.expires === 'number';
+    }
+    if (auth.type === 'api') {
+        return typeof auth.key === 'string';
+    }
+    if (auth.type === 'wellknown') {
+        return typeof auth.key === 'string' && typeof auth.token === 'string';
+    }
+    return false;
+}
+function normalizeMcpServerConfig(config) {
+    if ('url' in config) {
+        return {
+            type: 'remote',
+            url: config.url,
+            enabled: true,
+        };
+    }
+    return {
+        type: 'local',
+        command: [config.command, ...(config.args || [])],
+        environment: config.env,
+        enabled: true,
+    };
+}
+// ── Read-only OpenCode queries ─────────────────────────
+export async function getOpenCodeHealth(directory) {
+    const oc = await getOpencode();
+    const res = await oc.project.current({ directory });
+    const data = responseData(res, null);
+    return {
+        connected: true,
+        url: OPENCODE_URL,
+        project: data,
+        ...opencodeModeMeta(),
+    };
+}
+export function getOpenCodeUnavailableHealth(error) {
+    return {
+        connected: false,
+        error: error.message,
+        url: OPENCODE_URL,
+        ...opencodeModeMeta(),
+    };
+}
+export async function listOpenCodeAgents(directory) {
+    const oc = await getOpencode();
+    const res = await oc.app.agents({ directory });
+    return responseData(res, []);
+}
+export async function listOpenCodeToolIds(directory) {
+    const oc = await getOpencode();
+    const res = await oc.tool.ids({ directory });
+    return responseData(res, []);
+}
+export async function listOpenCodeToolsForModel(directory, provider, model) {
+    const oc = await getOpencode();
+    const res = await oc.tool.list({
+        directory,
+        provider,
+        model,
+    });
+    return responseData(res, []);
+}
+export async function getOpenCodeConfig(directory) {
+    const oc = await getOpencode();
+    const res = await oc.config.get({ directory });
+    return responseData(res, {});
+}
+export async function getProviderAuthStatus(directory) {
+    const oc = await getOpencode();
+    return unwrapOpencodeResult(await oc.provider.auth({ directory })) || {};
+}
+export async function getLspStatus(directory) {
+    const oc = await getOpencode();
+    const res = await oc.lsp.status({ directory });
+    return responseData(res, []);
+}
+export async function listFiles(directory, targetPath) {
+    const oc = await getOpencode();
+    const res = await oc.file.list({ directory, path: targetPath });
+    return responseData(res, []);
+}
+export async function readFile(directory, targetPath) {
+    const oc = await getOpencode();
+    const res = await oc.file.read({ directory, path: targetPath });
+    return responseData(res, {});
+}
+export async function getFileStatus(directory) {
+    const oc = await getOpencode();
+    const res = await oc.file.status({ directory });
+    return responseData(res, []);
+}
+export async function findTextInProject(directory, pattern) {
+    const oc = await getOpencode();
+    const res = await oc.find.text({ directory, pattern });
+    return responseData(res, []);
+}
+export async function findFilesInProject(directory, pattern) {
+    const oc = await getOpencode();
+    const res = await oc.find.files({ directory, query: pattern });
+    return responseData(res, []);
+}
+export async function findSymbolsInProject(directory, pattern) {
+    const oc = await getOpencode();
+    const res = await oc.find.symbols({ directory, query: pattern });
+    return responseData(res, []);
+}
+export async function getVcsStatus(directory) {
+    const oc = await getOpencode();
+    const res = await oc.vcs.get({ directory });
+    return responseData(res, {});
+}
+// ── Mutations ──────────────────────────────────────────
+export async function restartManagedOpenCode() {
+    await restartOpencodeSidecar();
+    return {
+        ok: true,
+        managed: isManagedOpencode(),
+        mode: isManagedOpencode() ? 'managed' : 'external',
+    };
+}
+export async function updateOpenCodeConfig(directory, patch) {
+    const oc = await getOpencode();
+    const current = await readProjectConfigFile(directory);
+    const nextConfig = mergeProjectConfig(current, patch && typeof patch === 'object' ? patch : {});
+    const res = await oc.config.update({ directory, config: nextConfig });
+    invalidate('mcp-servers');
+    return responseData(res, {});
+}
+export async function authorizeProviderOauth(directory, providerId, method) {
+    const oc = await getOpencode();
+    return unwrapOpencodeResult(await oc.provider.oauth.authorize({
+        providerID: providerId,
+        directory,
+        method,
+    }));
+}
+export async function completeProviderOauth(directory, providerId, method, code) {
+    const oc = await getOpencode();
+    const data = unwrapOpencodeResult(await oc.provider.oauth.callback({
+        providerID: providerId,
+        directory,
+        method,
+        ...(code ? { code } : {}),
+    }));
+    await oc.global.dispose();
+    invalidateProviderListCache();
+    return data;
+}
+export async function updateProviderAuth(_directory, providerId, auth) {
+    if (!isProviderAuthInput(auth)) {
+        throw new StudioValidationError('Invalid provider auth payload.');
+    }
+    const oc = await getOpencode();
+    const data = unwrapOpencodeResult(await oc.auth.set({
+        providerID: providerId,
+        auth,
+    }));
+    await oc.global.dispose();
+    invalidateProviderListCache();
+    return data;
+}
+export async function deleteProviderAuth(_directory, providerId) {
+    const oc = await getOpencode();
+    await clearStoredProviderAuth(providerId);
+    await oc.global.dispose();
+    invalidateProviderListCache();
+    return { ok: true };
+}
+export async function listMcpServers(directory) {
+    return cachedMcpServers(directory);
+}
+async function cachedMcpServers(cwd) {
+    const oc = await getOpencode();
+    const res = await oc.mcp.status({ directory: cwd });
+    const data = responseData(res, {});
+    const catalog = await readProjectMcpCatalog(cwd);
+    return summarizeProjectMcpCatalog(catalog, data);
+}
+export async function startMcpAuth(directory, name) {
+    await validateMcpAuthRequest(directory, name);
+    const oc = await getOpencode();
+    const data = unwrapOpencodeResult(await oc.mcp.auth.start({
+        name,
+        directory,
+    }));
+    invalidate('mcp-servers');
+    return data;
+}
+export async function completeMcpAuth(directory, name, code) {
+    const oc = await getOpencode();
+    const data = unwrapOpencodeResult(await oc.mcp.auth.callback({
+        name,
+        directory,
+        code,
+    }));
+    invalidate('mcp-servers');
+    return data;
+}
+export async function authenticateMcp(directory, name) {
+    await validateMcpAuthRequest(directory, name);
+    const oc = await getOpencode();
+    const data = unwrapOpencodeResult(await oc.mcp.auth.authenticate({
+        name,
+        directory,
+    }));
+    invalidate('mcp-servers');
+    return data;
+}
+export async function removeMcpAuth(directory, name) {
+    const oc = await getOpencode();
+    const data = unwrapOpencodeResult(await oc.mcp.auth.remove({
+        name,
+        directory,
+    }));
+    invalidate('mcp-servers');
+    return data;
+}
+// ── Config ──────────────────────────────────────────────
+export async function readProjectConfigFromOpencode(directory) {
+    const oc = await getOpencode();
+    const res = await oc.file.read({
+        directory,
+        path: 'config.json',
+    });
+    const data = responseData(res, {});
+    const raw = typeof data?.content === 'string' ? data.content : '{}';
+    return {
+        cwd: directory,
+        config: JSON.parse(raw),
+    };
+}
+export async function readProjectConfigSnapshot(directory) {
+    try {
+        const { cwd, config } = await readProjectConfigFromOpencode(directory);
+        return {
+            exists: true,
+            path: `${cwd}/config.json`,
+            config,
+        };
+    }
+    catch {
+        return {
+            exists: false,
+            path: `${directory}/config.json`,
+            config: {},
+        };
+    }
+}
+export function mergeProjectConfig(current, patch) {
+    return {
+        ...current,
+        ...patch,
+        ...(patch.mcp && typeof patch.mcp === 'object' ? { mcp: patch.mcp } : {}),
+    };
+}
+// ── MCP ─────────────────────────────────────────────────
+export async function runMcpMutation(_directory, action) {
+    const oc = await getOpencode();
+    const result = await action(oc);
+    invalidate('mcp-servers');
+    return responseData(result, {});
+}
+export async function addMcpServer(directory, input) {
+    return runMcpMutation(directory, (oc) => oc.mcp.add({
+        directory,
+        name: input.name,
+        config: normalizeMcpServerConfig(input.config),
+    }));
+}
+export async function connectMcpServer(directory, name) {
+    return runMcpMutation(directory, (oc) => oc.mcp.connect({
+        name,
+        directory,
+    }));
+}
+export async function disconnectMcpServer(directory, name) {
+    return runMcpMutation(directory, (oc) => oc.mcp.disconnect({
+        name,
+        directory,
+    }));
+}
+export async function validateMcpAuthRequest(directory, name) {
+    const catalog = await readProjectMcpCatalog(directory);
+    const config = catalog[name];
+    if (!config) {
+        throw new StudioValidationError(`MCP server '${name}' is not defined in this project.`, 'fix_input', 404);
+    }
+    if (!projectMcpEntryEnabled(config)) {
+        throw new StudioValidationError(`MCP server '${name}' is disabled in this project.`, 'fix_input', 400);
+    }
+    if (!('type' in config) || config.type !== 'remote') {
+        throw new StudioValidationError(`MCP server '${name}' does not support OAuth authentication.`, 'fix_input', 400);
+    }
+    if (config.oauth === false) {
+        throw new StudioValidationError(`MCP server '${name}' does not support OAuth authentication.`, 'fix_input', 400);
+    }
+}

package/dist/server/services/safe-service.js

@@ -0,0 +1,33 @@
+import { applySafeOwnerChanges, discardAllSafeOwnerChanges, discardSafeOwnerFile, getSafeOwnerSummary, undoLastSafeOwnerApply, } from '../lib/safe-mode.js';
+const applyQueues = new Map();
+export function parseSafeOwnerKind(value) {
+    return value === 'performer' || value === 'act' ? value : null;
+}
+async function runQueued(workingDir, task) {
+    const current = applyQueues.get(workingDir) || Promise.resolve();
+    const next = current.catch(() => undefined).then(task);
+    applyQueues.set(workingDir, next);
+    try {
+        return await next;
+    }
+    finally {
+        if (applyQueues.get(workingDir) === next) {
+            applyQueues.delete(workingDir);
+        }
+    }
+}
+export async function readSafeOwnerSummary(workingDir, ownerKind, ownerId) {
+    return getSafeOwnerSummary(workingDir, ownerKind, ownerId);
+}
+export async function applySafeOwnerSummary(workingDir, ownerKind, ownerId) {
+    return runQueued(workingDir, () => applySafeOwnerChanges(workingDir, ownerKind, ownerId));
+}
+export async function discardSafeOwnerSummaryFile(workingDir, ownerKind, ownerId, filePath) {
+    return discardSafeOwnerFile(workingDir, ownerKind, ownerId, filePath);
+}
+export async function discardAllSafeOwnerSummaryChanges(workingDir, ownerKind, ownerId) {
+    return discardAllSafeOwnerChanges(workingDir, ownerKind, ownerId);
+}
+export async function undoLastSafeOwnerSummaryApply(workingDir, ownerKind, ownerId) {
+    return runQueued(workingDir, () => undoLastSafeOwnerApply(workingDir, ownerKind, ownerId));
+}

package/dist/server/services/studio-assistant/assistant-service.js

@@ -0,0 +1,172 @@
+/**
+ * assistant-service.ts — Agent + skill projection for Studio Assistant.
+ *
+ * Produces:
+ *   .opencode/agents/dot-studio/studio-assistant.md          (agent file)
+ *   .opencode/skills/dot-studio/studio-assistant-<name>/SKILL.md  (one per builtin dance)
+ *
+ * Tool files are NOT written here — they are injected at send-time via
+ * chat-service.ts extraTools to avoid polluting the shared .opencode/tools/ dir.
+ *
+ * Called eagerly at stage save / project activate — NOT per-send.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { getOpencode } from '../../lib/opencode.js';
+export const ASSISTANT_PERFORMER_ID = 'studio-assistant';
+const AGENT_FILENAME = 'studio-assistant.md';
+// ── Source paths ───────────────────────────────────────
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TAL_PATH = path.join(__dirname, 'tal', 'studio-assistant.md');
+const DANCES_DIR = path.join(__dirname, 'dances');
+// ── Target paths ──────────────────────────────────────
+function agentFilePath(executionDir) {
+    return path.join(executionDir, '.opencode', 'agents', 'dot-studio', AGENT_FILENAME);
+}
+function skillDir(executionDir, skillName) {
+    return path.join(executionDir, '.opencode', 'skills', 'dot-studio', skillName);
+}
+function skillFilePath(executionDir, skillName) {
+    return path.join(skillDir(executionDir, skillName), 'SKILL.md');
+}
+// ── Read source assets ────────────────────────────────
+async function readTal() {
+    return fs.readFile(TAL_PATH, 'utf-8');
+}
+async function readBuiltinSkills() {
+    const entries = await fs.readdir(DANCES_DIR, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith('.md')) {
+            const body = await fs.readFile(path.join(DANCES_DIR, entry.name), 'utf-8');
+            const baseName = entry.name.replace(/\.md$/, '');
+            const skillName = `studio-assistant-${baseName}`;
+            // Extract first heading as description, fallback to file name
+            const firstLine = body.trim().split('\n')[0] || '';
+            const description = firstLine.startsWith('#')
+                ? firstLine.replace(/^#+\s*/, '').trim()
+                : baseName.replace(/-/g, ' ');
+            skills.push({ name: skillName, description, content: body.trim() });
+        }
+    }
+    return skills;
+}
+async function removeStaleBuiltinSkills(executionDir, expectedSkillNames) {
+    const skillsRoot = path.join(executionDir, '.opencode', 'skills', 'dot-studio');
+    const expected = new Set(expectedSkillNames);
+    let changed = false;
+    const entries = await fs.readdir(skillsRoot, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (!entry.name.startsWith('studio-assistant-'))
+            continue;
+        if (expected.has(entry.name))
+            continue;
+        await fs.rm(path.join(skillsRoot, entry.name), { recursive: true, force: true });
+        changed = true;
+    }
+    return changed;
+}
+// ── Frontmatter ───────────────────────────────────────
+function buildFrontmatter(skillNames) {
+    const lines = ['---'];
+    lines.push('description: "Studio Assistant"');
+    lines.push('mode: primary');
+    // Model is NOT specified here — passed via promptAsync() to avoid staleness.
+    // Permission-based tool/skill access (tools field is deprecated)
+    lines.push('permission:');
+    lines.push('  edit:');
+    lines.push('    "*": "allow"');
+    lines.push('  bash:');
+    lines.push('    "*": "allow"');
+    // Skill permissions: deny-by-default, allow only our builtin skills
+    lines.push('  skill:');
+    lines.push('    "*": "deny"');
+    for (const name of skillNames) {
+        lines.push(`    ${JSON.stringify(name)}: "allow"`);
+    }
+    lines.push('---');
+    return lines.join('\n');
+}
+// ── Agent body ────────────────────────────────────────
+function buildAgentBody(talContent) {
+    return talContent.trim();
+}
+// ── SKILL.md assembly ─────────────────────────────────
+function buildSkillFile(skill) {
+    const frontmatter = [
+        '---',
+        `name: ${JSON.stringify(skill.name)}`,
+        `description: ${JSON.stringify(skill.description)}`,
+        '---',
+    ].join('\n');
+    return `${frontmatter}\n\n${skill.content}`;
+}
+export function buildAssistantActionPrompt(context) {
+    const snapshot = JSON.stringify(context || { workingDir: '', performers: [], acts: [], drafts: [], availableModels: [] }, null, 2);
+    return [
+        'Current Workspace Snapshot:',
+        '```json',
+        snapshot,
+        '```',
+        'If you want to mutate the stage, append exactly one action block at the end of your reply.',
+        'Use this exact format with raw JSON only:',
+        '<assistant-actions>{"version":1,"actions":[...]}</assistant-actions>',
+        'Rules:',
+        '- Keep your user-facing explanation outside the action block.',
+        '- Omit the action block when no canvas mutation is needed.',
+        '- Valid action types:',
+        '  Tal/Dance draft:  createTalDraft, updateTalDraft, deleteTalDraft, createDanceDraft, updateDanceDraft, deleteDanceDraft',
+        '  Performer:        createPerformer (inline Tal/Dance/model/MCP), updatePerformer, deletePerformer',
+        '  Act:              createAct (inline participants/relations), updateAct, deleteAct',
+        '  Participants:     attachPerformerToAct, detachParticipantFromAct',
+        '  Relations:        connectPerformers, updateRelation, removeRelation',
+        '- Use exactly one assistant-actions block and place it at the end of the reply.',
+        '- The JSON inside the block must be valid and must not contain comments or trailing commas.',
+        '- Make the smallest correct set of mutations for the user request.',
+        '- Reuse performers, acts, drafts, and relations already present in the Workspace snapshot whenever possible.',
+        '- If you create something and refer to it later in the same block, assign a ref on the create action and use performerRef, actRef, or draftRef in later actions.',
+        '- Prefer explicit ids from the snapshot when available. If you do not know an id, you may use exact names.',
+        '- For models, use values from availableModels in the snapshot. Do not invent provider ids or model ids.',
+        '- Tal and Dance can only be created or updated as local drafts (not registry assets).',
+        '- Do not wrap the assistant-actions block in Markdown fences.',
+        '- If the request is ambiguous and you cannot produce a valid mutation safely, ask a short clarifying question instead of guessing.',
+    ].join('\n');
+}
+// ── Write helper ──────────────────────────────────────
+async function writeIfChanged(filePath, content) {
+    const current = await fs.readFile(filePath, 'utf-8').catch(() => null);
+    if (current === content)
+        return false;
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, 'utf-8');
+    return true;
+}
+/**
+ * Ensure the assistant agent and builtin skill files exist.
+ * Returns the agent name for use with oc.session.promptAsync().
+ *
+ * Called at stage save / project activate time.
+ */
+export async function ensureAssistantAgent(executionDir) {
+    const talContent = await readTal();
+    const skills = await readBuiltinSkills();
+    let changed = false;
+    // 1. Agent file
+    const frontmatter = buildFrontmatter(skills.map((s) => s.name));
+    const body = buildAgentBody(talContent);
+    const agentContent = `${frontmatter}\n\n${body}`;
+    changed = (await writeIfChanged(agentFilePath(executionDir), agentContent)) || changed;
+    // 2. Skill files (one SKILL.md per builtin dance)
+    for (const skill of skills) {
+        changed = (await writeIfChanged(skillFilePath(executionDir, skill.name), buildSkillFile(skill))) || changed;
+    }
+    changed = (await removeStaleBuiltinSkills(executionDir, skills.map((skill) => skill.name))) || changed;
+    if (changed) {
+        const oc = await getOpencode();
+        await oc.instance.dispose({ directory: executionDir }).catch(() => { });
+    }
+    return `dot-studio/${AGENT_FILENAME.replace(/\.md$/, '')}`;
+}

package/dist/server/services/studio-service.js

@@ -0,0 +1,69 @@
+import { exec } from 'child_process';
+import fs from 'fs/promises';
+import open from 'open';
+import path from 'path';
+import { promisify } from 'util';
+import { ensureDotDir } from '../lib/dot-source.js';
+import { getActiveProjectDir, setActiveProjectDir, readStudioConfig, writeStudioConfig, } from '../lib/config.js';
+import { invalidateAll } from '../lib/cache.js';
+const execAsync = promisify(exec);
+export async function pickWorkingDirectory() {
+    const { stdout } = await execAsync(`osascript -e 'POSIX path of (choose folder with prompt "Select Working Directory for Workspace")'`);
+    return { path: stdout.trim() };
+}
+export async function getStudioConfig(projectDir) {
+    const config = await readStudioConfig();
+    return { ...config, projectDir };
+}
+export async function updateStudioConfig(patch) {
+    return writeStudioConfig(patch);
+}
+export async function activateStudioProject(workingDir) {
+    if (!workingDir) {
+        return { ok: false, status: 400, error: 'workingDir is required' };
+    }
+    const resolved = path.resolve(workingDir.replace(/\/+$/, ''));
+    try {
+        const stat = await fs.stat(resolved);
+        if (!stat.isDirectory()) {
+            return { ok: false, status: 400, error: 'workingDir is not a directory' };
+        }
+    }
+    catch {
+        return { ok: false, status: 400, error: `Directory not found: ${resolved}` };
+    }
+    await ensureDotDir(resolved);
+    setActiveProjectDir(resolved);
+    invalidateAll();
+    import('./studio-assistant/assistant-service.js').then(({ ensureAssistantAgent }) => ensureAssistantAgent(resolved).catch(() => { }));
+    return {
+        ok: true,
+        activeProjectDir: getActiveProjectDir(),
+    };
+}
+export async function openStudioPath(targetPath) {
+    if (!targetPath) {
+        return { ok: false, status: 400, error: 'path is required' };
+    }
+    const resolved = path.resolve(targetPath.replace(/\/+$/, ''));
+    try {
+        await fs.stat(resolved);
+    }
+    catch {
+        return { ok: false, status: 404, error: `Path not found: ${resolved}` };
+    }
+    try {
+        await open(resolved);
+        return {
+            ok: true,
+            path: resolved,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            status: 500,
+            error: error instanceof Error ? error.message : 'Failed to open path',
+        };
+    }
+}