dot-studio 0.0.1 → 0.0.2

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

@@ -0,0 +1,224 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { createHash } from 'crypto';
+import { getOpencode } from '../lib/opencode.js';
+import { unwrapOpencodeResult } from '../lib/opencode-errors.js';
+import { deleteSafeOwnerWorkspace } from '../lib/safe-mode.js';
+import { listSessionExecutionContextsForWorkingDir, unregisterSessionExecutionContext, } from '../lib/session-execution.js';
+import { workspacesDir, workspaceDir } from '../lib/config.js';
+function isAllowedWorkspaceCharacter(char) {
+    const code = char.charCodeAt(0);
+    return !('/\\:*?"<>|'.includes(char) || code < 32);
+}
+function sanitizeWorkspaceId(id) {
+    return id
+        .replace(/\.\./g, '')
+        .split('')
+        .filter((char) => isAllowedWorkspaceCharacter(char))
+        .join('')
+        .trim();
+}
+function validateWorkspaceId(id) {
+    const clean = sanitizeWorkspaceId(id);
+    if (!clean || clean.length === 0)
+        return null;
+    if (clean.length > 128)
+        return null;
+    return clean;
+}
+function normalizeWorkingDir(input) {
+    const trimmed = input.trim().replace(/\/+$/, '');
+    if (!trimmed)
+        return null;
+    return path.resolve(trimmed);
+}
+function workspaceIdForWorkingDir(workingDir) {
+    return createHash('sha1').update(workingDir).digest('hex').slice(0, 16);
+}
+function workspacePathForId(id) {
+    return path.join(workspaceDir(id), 'workspace.json');
+}
+async function purgeLinkedOpencodeData(workspace) {
+    const workingDir = normalizeWorkingDir(workspace?.workingDir || '');
+    if (!workingDir) {
+        return;
+    }
+    const executionContexts = await listSessionExecutionContextsForWorkingDir(workingDir);
+    const directories = Array.from(new Set([
+        workingDir,
+        ...executionContexts.map((context) => context.executionDir),
+    ]));
+    const sessionDirectories = new Map(executionContexts.map((context) => [context.sessionId, context.executionDir]));
+    try {
+        const oc = await getOpencode();
+        for (const directory of directories) {
+            try {
+                const sessions = unwrapOpencodeResult(await oc.session.list({ directory })) || [];
+                for (const session of sessions) {
+                    if (session?.id && !sessionDirectories.has(session.id)) {
+                        sessionDirectories.set(session.id, directory);
+                    }
+                }
+            }
+            catch (error) {
+                console.warn('[workspace-service] Failed to list OpenCode sessions for workspace delete', { workingDir, directory, error });
+            }
+        }
+        for (const [sessionId, directory] of Array.from(sessionDirectories.entries())) {
+            try {
+                unwrapOpencodeResult(await oc.session.delete({
+                    sessionID: sessionId,
+                    directory,
+                }));
+            }
+            catch (error) {
+                console.warn('[workspace-service] Failed to delete OpenCode session for workspace delete', { sessionId, directory, error });
+            }
+            await unregisterSessionExecutionContext(sessionId).catch(() => { });
+        }
+    }
+    catch (error) {
+        console.warn('[workspace-service] Failed to purge OpenCode data for workspace delete', { workingDir, error });
+    }
+    const ownerTargets = new Map();
+    for (const context of executionContexts) {
+        ownerTargets.set(`${context.ownerKind}:${context.ownerId}`, {
+            ownerKind: context.ownerKind,
+            ownerId: context.ownerId,
+        });
+    }
+    for (const performer of Array.isArray(workspace?.performers) ? workspace.performers : []) {
+        if (typeof performer?.id === 'string' && performer.id) {
+            ownerTargets.set(`performer:${performer.id}`, { ownerKind: 'performer', ownerId: performer.id });
+        }
+    }
+    for (const act of Array.isArray(workspace?.acts) ? workspace.acts : []) {
+        if (typeof act?.id === 'string' && act.id) {
+            ownerTargets.set(`act:${act.id}`, { ownerKind: 'act', ownerId: act.id });
+            await fs.rm(path.join(workspaceDir(workspaceIdForWorkingDir(workingDir)), 'act-runtime', act.id), { recursive: true, force: true }).catch(() => { });
+        }
+    }
+    for (const { ownerKind, ownerId } of Array.from(ownerTargets.values())) {
+        await deleteSafeOwnerWorkspace(workingDir, ownerKind, ownerId).catch(() => { });
+    }
+}
+export async function listSavedWorkspaces(includeHidden = false) {
+    const dir = workspacesDir();
+    await fs.mkdir(dir, { recursive: true });
+    const entries = [];
+    let items;
+    try {
+        items = await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    await Promise.all(items.map(async (item) => {
+        const itemDir = path.join(dir, item);
+        try {
+            const itemStat = await fs.stat(itemDir);
+            if (!itemStat.isDirectory())
+                return;
+            const filePath = path.join(itemDir, 'workspace.json');
+            const raw = await fs.readFile(filePath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            const wd = normalizeWorkingDir(parsed.workingDir || '') || '';
+            if (!wd)
+                return;
+            if (!includeHidden && parsed.hiddenFromList === true)
+                return;
+            const stat = await fs.stat(filePath);
+            entries.push({
+                id: item,
+                workingDir: wd,
+                updatedAt: stat.mtimeMs,
+            });
+        }
+        catch {
+            // skip invalid entries
+        }
+    }));
+    return entries.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+export async function getSavedWorkspace(rawId) {
+    const id = validateWorkspaceId(rawId);
+    if (!id) {
+        return { ok: false, status: 400, error: 'Invalid workspace id' };
+    }
+    const filePath = workspacePathForId(id);
+    if (!filePath.startsWith(workspacesDir())) {
+        return { ok: false, status: 400, error: 'Invalid workspace id' };
+    }
+    try {
+        const raw = await fs.readFile(filePath, 'utf-8');
+        return { ok: true, workspace: JSON.parse(raw) };
+    }
+    catch {
+        return { ok: false, status: 404, error: 'Workspace not found' };
+    }
+}
+export async function saveWorkspaceSnapshot(body) {
+    const workingDir = normalizeWorkingDir(body.workingDir || '');
+    if (!workingDir) {
+        return { ok: false, status: 400, error: 'workingDir is required' };
+    }
+    const id = workspaceIdForWorkingDir(workingDir);
+    const workspace = {
+        ...body,
+        workingDir,
+        hiddenFromList: body.hiddenFromList === true,
+    };
+    const wsDir = workspaceDir(id);
+    await fs.mkdir(wsDir, { recursive: true });
+    const filePath = workspacePathForId(id);
+    if (!filePath.startsWith(workspacesDir())) {
+        return { ok: false, status: 400, error: 'Invalid workspace id' };
+    }
+    await fs.writeFile(filePath, JSON.stringify(workspace, null, 2), 'utf-8');
+    const stat = await fs.stat(filePath);
+    import('./studio-assistant/assistant-service.js').then(({ ensureAssistantAgent }) => ensureAssistantAgent(workingDir).catch(() => { }));
+    return {
+        ok: true,
+        id,
+        workingDir,
+        updatedAt: stat.mtimeMs,
+    };
+}
+export async function setSavedWorkspaceHidden(rawId, hiddenFromList) {
+    const id = validateWorkspaceId(rawId);
+    if (!id) {
+        return { ok: false, status: 400, error: 'Invalid workspace id' };
+    }
+    const filePath = workspacePathForId(id);
+    if (!filePath.startsWith(workspacesDir())) {
+        return { ok: false, status: 400, error: 'Invalid workspace id' };
+    }
+    try {
+        const raw = await fs.readFile(filePath, 'utf-8');
+        const workspace = JSON.parse(raw);
+        workspace.hiddenFromList = hiddenFromList === true;
+        await fs.writeFile(filePath, JSON.stringify(workspace, null, 2), 'utf-8');
+        return { ok: true, id, hiddenFromList: workspace.hiddenFromList };
+    }
+    catch {
+        return { ok: false, status: 404, error: 'Workspace not found' };
+    }
+}
+export async function deleteSavedWorkspace(rawId) {
+    const id = validateWorkspaceId(rawId);
+    if (!id) {
+        return { ok: false, status: 400, error: 'Invalid workspace id' };
+    }
+    try {
+        const filePath = workspacePathForId(id);
+        const raw = await fs.readFile(filePath, 'utf-8');
+        const workspace = JSON.parse(raw);
+        await purgeLinkedOpencodeData(workspace);
+        // Delete entire workspace directory (includes act-runtime data)
+        await fs.rm(workspaceDir(id), { recursive: true, force: true });
+        return { ok: true };
+    }
+    catch {
+        return { ok: false, status: 404, error: 'Workspace not found' };
+    }
+}

package/dist/server/terminal.js

@@ -4,6 +4,56 @@ import { OPENCODE_URL } from './lib/config.js';
 const MAX_BUFFER = 500;
 const sessions = new Map();
 let sessionCounter = 0;
+function errorMessage(error, fallback = 'Unknown error') {
+    return error instanceof Error && error.message ? error.message : fallback;
+}
+function stripTerminalNoise(input) {
+    let result = '';
+    for (let index = 0; index < input.length; index += 1) {
+        const char = input[index];
+        const code = char.charCodeAt(0);
+        if (code === 27) {
+            const next = input[index + 1];
+            if (next === ']') {
+                index += 2;
+                while (index < input.length) {
+                    const oscChar = input[index];
+                    const oscCode = oscChar.charCodeAt(0);
+                    if (oscCode === 7) {
+                        break;
+                    }
+                    if (oscCode === 27 && input[index + 1] === '\\') {
+                        index += 1;
+                        break;
+                    }
+                    index += 1;
+                }
+                continue;
+            }
+            if (next === '[') {
+                index += 2;
+                while (index < input.length) {
+                    const csiCode = input[index].charCodeAt(0);
+                    const isLetter = (csiCode >= 65 && csiCode <= 90) || (csiCode >= 97 && csiCode <= 122);
+                    if (isLetter) {
+                        break;
+                    }
+                    index += 1;
+                }
+                continue;
+            }
+            if (next) {
+                index += 1;
+            }
+            continue;
+        }
+        if (char === '\r' || char === '\n') {
+            continue;
+        }
+        result += char;
+    }
+    return result.trim();
+}
 async function opencodePtyRequest(path, init, directory) {
     const url = new URL(path, OPENCODE_URL);
     if (directory) {
@@ -87,9 +137,10 @@ export function setupTerminalWs(server, defaultCwd) {
             setupWsHandlers(ws, session);
             broadcastSessionList(session.cwd);
         }
-        catch (err) {
-            console.error('Failed to create PTY via OpenCode:', err.message);
-            ws.send(JSON.stringify({ type: 'error', message: `Failed: ${err.message}` }));
+        catch (error) {
+            const message = errorMessage(error);
+            console.error('Failed to create PTY via OpenCode:', message);
+            ws.send(JSON.stringify({ type: 'error', message: `Failed: ${message}` }));
             ws.close();
         }
     }
@@ -109,12 +160,7 @@ export function setupTerminalWs(server, defaultCwd) {
             // The data may arrive in multiple small chunks with ANSI sequences mixed in.
             if (!session.initialized) {
                 // Strip ALL ANSI escape sequences (CSI, OSC, etc.)
-                const stripped = data
-                    .replace(/\x1b\][^\x07]*(\x07|\x1b\\)/g, '') // OSC sequences
-                    .replace(/\x1b\[[^a-zA-Z]*[a-zA-Z]/g, '') // CSI sequences
-                    .replace(/\x1b[^[\]].?/g, '') // Other escapes
-                    .replace(/[\r\n]/g, '')
-                    .trim();
+                const stripped = stripTerminalNoise(data);
                 // Skip if it's cursor control noise, percent signs, or empty after stripping
                 if (!stripped || /\{"cursor":\d+\}/.test(stripped) || /^%+$/.test(stripped)) {
                     return;
@@ -208,8 +254,8 @@ export function setupTerminalWs(server, defaultCwd) {
                                 }),
                             }, session.cwd);
                         }
-                        catch (e) {
-                            console.error('PTY resize failed:', e.message);
+                        catch (error) {
+                            console.error('PTY resize failed:', errorMessage(error));
                         }
                         break;
                     case 'create':

package/dist/shared/act-types.js

@@ -0,0 +1,4 @@
+// Choreography Act — Shared Types (PRD-005)
+// dot contract types are Source of Truth for the serialization schema.
+// Studio extends them with runtime-only fields (id, performerRef, mailbox, etc.)
+export {};

package/dist/shared/adapter-view.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/asset-contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/assistant-actions.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/chat-contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/dot-contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/dot-types.js

@@ -0,0 +1,4 @@
+// dot Contract Types — Single Source of Truth for all dot type imports
+// This is the ONLY file that imports types directly from 'dance-of-tal'.
+// Both shared/ and server/ code should import dot types from here.
+export {};

package/dist/shared/draft-contracts.js

@@ -0,0 +1,2 @@
+// Draft CRUD — Shared contracts between client and server
+export {};

package/dist/shared/model-types.js

@@ -0,0 +1,2 @@
+// Canonical ModelSelection type shared by client and server.
+export {};

package/dist/shared/performer-mcp-portability.js

@@ -0,0 +1,10 @@
+import { extractMcpServerNamesFromConfig } from './mcp-config.js';
+export function resolvePerformerMcpPortability(mcpConfig, projectMcpServerNames) {
+    const declaredMcpServerNames = extractMcpServerNamesFromConfig(mcpConfig);
+    const available = new Set(projectMcpServerNames.filter(Boolean));
+    return {
+        declaredMcpServerNames,
+        projectMcpMatches: declaredMcpServerNames.filter((name) => available.has(name)),
+        projectMcpMissing: declaredMcpServerNames.filter((name) => !available.has(name)),
+    };
+}

package/dist/shared/safe-mode.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/session-metadata.js

@@ -1,7 +1,8 @@
 const SESSION_TITLE_PREFIX = 'DOT Studio:';
-const SESSION_METADATA_PATTERN = /^DOT Studio:\s*(.*?)\s*\[studio:([^:\]]+):([^\]]+)\]\s*$/;
-export function buildStudioSessionTitle(performerId, performerName, configHash) {
-    return `${SESSION_TITLE_PREFIX} ${performerName} [studio:${performerId}:${configHash}]`;
+const SESSION_METADATA_PATTERN = /^DOT Studio:\s*(.*?)\s*\[studio:([^:\]]+):(.*)\]\s*$/;
+export function buildStudioSessionTitle(performerId, performerName, configHash, executionMode) {
+    const safeLabel = executionMode === 'safe' ? '[SAFE] ' : '';
+    return `${SESSION_TITLE_PREFIX} ${safeLabel}${performerName} [studio:${performerId}:${configHash}]`;
 }
 export function parseStudioSessionTitle(title) {
     if (!title || !title.startsWith(SESSION_TITLE_PREFIX)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dot-studio",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "DOT Studio visual workspace for composing and running Dance of Tal performers and acts on top of OpenCode.",
   "license": "MIT",
   "author": "monarchjuno",
@@ -31,7 +31,7 @@
     "start": "tsx server/start.ts",
     "dev": "vite",
     "kill-ports": "lsof -ti:5173,3001,4096 | xargs kill -9 2>/dev/null || true",
-    "dev:all": "npm run kill-ports && concurrently -k -n vite,server,opencode -c cyan,yellow,magenta \"vite\" \"tsx --watch server/index.ts\" \"opencode --port 4096 .\"",
+    "dev:all": "npm run kill-ports && concurrently -k -n opencode,server,vite -c magenta,yellow,cyan \"opencode --port 4096 .\" \"tsx --watch server/index.ts\" \"vite\"",
     "server": "tsx server/index.ts",
     "server:dev": "tsx --watch server/index.ts",
     "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true }); require('fs').rmSync('client', { recursive: true, force: true })\"",
@@ -41,6 +41,7 @@
     "build:all": "npm run clean && npm run build:client && npm run build:server",
     "pack:check": "npm run build:all && npm pack --dry-run",
     "type-check": "tsc -b --noEmit && tsc -p tsconfig.server.json --noEmit",
+    "test": "vitest run",
     "lint": "eslint .",
     "preview": "vite preview",
     "opencode": "opencode --port 4096 .",
@@ -66,7 +67,7 @@
     "@xterm/addon-webgl": "^0.19.0",
     "@xterm/xterm": "^6.0.0",
     "@xyflow/react": "^12.10.1",
-    "dance-of-tal": "^3.2.3",
+    "dance-of-tal": "4.0.1",
     "elkjs": "^0.11.1",
     "highlight.js": "^11.11.1",
     "hono": "^4.12.5",
@@ -98,6 +99,7 @@
     "globals": "^16.5.0",
     "typescript": "~5.9.3",
     "typescript-eslint": "^8.48.0",
-    "vite": "^6.4.1"
+    "vite": "^6.4.1",
+    "vitest": "^4.1.0"
   }
 }