dot-studio 0.0.1 → 0.0.2

package/dist/server/services/dance-bundle-service.js

@@ -0,0 +1,222 @@
+/**
+ * dance-bundle-service.ts — CRUD operations for Dance skill bundles.
+ *
+ * A Dance bundle is a directory-backed draft that stores:
+ *   .dance-of-tal/drafts/dance/<draftId>/
+ *       ├── draft.json     (metadata)
+ *       ├── SKILL.md       (main skill content)
+ *       ├── scripts/       (helper scripts)
+ *       ├── references/    (reference docs)
+ *       └── assets/        (assets/media)
+ *
+ * This module handles bundle-specific file operations.
+ * Generic draft CRUD (create/read/update/delete/list) lives in draft-service.ts.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { getDotDir } from '../lib/dot-source.js';
+// ── Path resolution ─────────────────────────────────────
+const BUNDLE_SCAFFOLD_DIRS = ['scripts', 'references', 'assets'];
+export function danceBundleDir(cwd, draftId) {
+    return path.join(getDotDir(cwd), 'drafts', 'dance', draftId);
+}
+export async function isDanceBundleDraft(cwd, draftId) {
+    const bundlePath = path.join(danceBundleDir(cwd, draftId), 'draft.json');
+    try {
+        await fs.access(bundlePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ── Path sanitization ───────────────────────────────────
+/**
+ * Ensures a relative path is safe and sandboxed within the bundle root.
+ * Rejects absolute paths, `..` traversal, null bytes, and empty paths.
+ */
+export function sanitizeBundlePath(filePath) {
+    if (!filePath || typeof filePath !== 'string') {
+        throw new Error('File path is required.');
+    }
+    // Reject null bytes
+    if (filePath.includes('\0')) {
+        throw new Error('Invalid file path: contains null bytes.');
+    }
+    // Normalize and resolve
+    const normalized = path.normalize(filePath);
+    // Reject absolute paths
+    if (path.isAbsolute(normalized)) {
+        throw new Error('Absolute paths are not allowed.');
+    }
+    // Reject path traversal
+    if (normalized.startsWith('..') || normalized.includes(`${path.sep}..`)) {
+        throw new Error('Path traversal is not allowed.');
+    }
+    // Reject paths that try to escape via leading slash after normalize
+    if (normalized.startsWith(path.sep)) {
+        throw new Error('Invalid path.');
+    }
+    return normalized;
+}
+// ── Bundle scaffold ─────────────────────────────────────
+/**
+ * Create the initial directory structure for a Dance bundle.
+ */
+export async function scaffoldDanceBundle(cwd, draftId, skillContent) {
+    const bundleRoot = danceBundleDir(cwd, draftId);
+    await fs.mkdir(bundleRoot, { recursive: true });
+    // Create scaffold directories
+    for (const dir of BUNDLE_SCAFFOLD_DIRS) {
+        await fs.mkdir(path.join(bundleRoot, dir), { recursive: true });
+    }
+    // Write SKILL.md
+    await fs.writeFile(path.join(bundleRoot, 'SKILL.md'), skillContent, 'utf-8');
+}
+// ── Bundle tree ─────────────────────────────────────────
+async function buildTree(dirPath, basePath) {
+    const entries = [];
+    let dirEntries;
+    try {
+        dirEntries = await fs.readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return entries;
+    }
+    // Sort: directories first, then files, alphabetical within each group
+    dirEntries.sort((a, b) => {
+        const aIsDir = a.isDirectory() ? 0 : 1;
+        const bIsDir = b.isDirectory() ? 0 : 1;
+        if (aIsDir !== bIsDir)
+            return aIsDir - bIsDir;
+        return a.name.localeCompare(b.name);
+    });
+    for (const entry of dirEntries) {
+        // Skip draft.json from the tree view — it's internal metadata
+        if (entry.name === 'draft.json' && basePath === '')
+            continue;
+        const relativePath = basePath ? `${basePath}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            const children = await buildTree(path.join(dirPath, entry.name), relativePath);
+            entries.push({
+                name: entry.name,
+                type: 'directory',
+                path: relativePath,
+                children,
+            });
+        }
+        else if (entry.isFile()) {
+            entries.push({
+                name: entry.name,
+                type: 'file',
+                path: relativePath,
+            });
+        }
+    }
+    return entries;
+}
+export async function getDanceBundleTree(cwd, draftId) {
+    const bundleRoot = danceBundleDir(cwd, draftId);
+    return buildTree(bundleRoot, '');
+}
+// ── File read/write ─────────────────────────────────────
+export async function readDanceBundleFile(cwd, draftId, filePath) {
+    const safePath = sanitizeBundlePath(filePath);
+    const fullPath = path.join(danceBundleDir(cwd, draftId), safePath);
+    try {
+        return await fs.readFile(fullPath, 'utf-8');
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            throw new Error(`File not found: ${safePath}`);
+        }
+        throw error;
+    }
+}
+export async function writeDanceBundleFile(cwd, draftId, filePath, content) {
+    const safePath = sanitizeBundlePath(filePath);
+    const fullPath = path.join(danceBundleDir(cwd, draftId), safePath);
+    // Ensure parent directory exists
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, content, 'utf-8');
+}
+// ── File/directory creation ─────────────────────────────
+export async function createDanceBundleFile(cwd, draftId, filePath, isDirectory = false) {
+    const safePath = sanitizeBundlePath(filePath);
+    const fullPath = path.join(danceBundleDir(cwd, draftId), safePath);
+    if (isDirectory) {
+        await fs.mkdir(fullPath, { recursive: true });
+    }
+    else {
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        // Only create if doesn't exist
+        try {
+            await fs.access(fullPath);
+            throw new Error(`File already exists: ${safePath}`);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.startsWith('File already exists'))
+                throw error;
+            await fs.writeFile(fullPath, '', 'utf-8');
+        }
+    }
+}
+// ── File deletion ───────────────────────────────────────
+export async function deleteDanceBundleFile(cwd, draftId, filePath) {
+    const safePath = sanitizeBundlePath(filePath);
+    // Protect critical files
+    if (safePath === 'SKILL.md') {
+        throw new Error('Cannot delete SKILL.md — it is the primary skill file.');
+    }
+    const fullPath = path.join(danceBundleDir(cwd, draftId), safePath);
+    await fs.rm(fullPath, { recursive: true, force: true });
+}
+// ── Bundle content helpers ──────────────────────────────
+/**
+ * Read the SKILL.md content from a bundle draft.
+ * Returns null if the file doesn't exist.
+ */
+export async function readBundleSkillContent(cwd, draftId) {
+    try {
+        return await fs.readFile(path.join(danceBundleDir(cwd, draftId), 'SKILL.md'), 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write the SKILL.md content to a bundle draft.
+ */
+export async function writeBundleSkillContent(cwd, draftId, content) {
+    await fs.writeFile(path.join(danceBundleDir(cwd, draftId), 'SKILL.md'), content, 'utf-8');
+}
+/**
+ * Get all file paths in a bundle for projection purposes.
+ * Returns absolute paths.
+ */
+export async function listBundleFilePaths(cwd, draftId) {
+    const bundleRoot = danceBundleDir(cwd, draftId);
+    const files = [];
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.name === 'draft.json')
+                continue; // skip metadata
+            if (entry.isFile()) {
+                files.push(fullPath);
+            }
+            else if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+        }
+    }
+    await walk(bundleRoot);
+    return files;
+}

package/dist/server/services/dot-add-service.js

@@ -0,0 +1,59 @@
+// dot add service — installs Dance skills from a GitHub repo
+import path from 'path';
+import { parseSource, getOwnerRepo, shallowClone, discoverSkills, copySkillDir, upsertSkillLockEntry, readPluginManifest, ensureDotDir, danceAssetDir, getGlobalCwd, reportInstall, } from '../lib/dot-source.js';
+import { invalidate } from '../lib/cache.js';
+export async function addDanceFromGitHub(cwd, source, scope) {
+    const parsed = parseSource(source);
+    const { tempDir, cleanup } = await shallowClone({ url: parsed.url, ref: parsed.ref });
+    try {
+        const searchDir = parsed.subpath ? path.join(tempDir, parsed.subpath) : tempDir;
+        let skills = await discoverSkills(searchDir);
+        // Check plugin manifest for additional skill paths
+        const manifest = await readPluginManifest(tempDir);
+        if (manifest && manifest.skills.length > 0) {
+            const existingNames = new Set(skills.map((s) => s.name));
+            for (const entry of manifest.skills) {
+                if (existingNames.has(entry.name))
+                    continue;
+                const skillDir = path.join(tempDir, entry.path);
+                const discovered = await discoverSkills(skillDir);
+                skills.push(...discovered.filter((s) => !existingNames.has(s.name)));
+            }
+        }
+        // Apply skill filter from @skill shorthand
+        if (parsed.skillFilter) {
+            skills = skills.filter((s) => s.name === parsed.skillFilter);
+            if (skills.length === 0) {
+                throw new Error(`Skill '${parsed.skillFilter}' not found in ${parsed.url}`);
+            }
+        }
+        if (skills.length === 0) {
+            throw new Error(`No SKILL.md files found in ${source}`);
+        }
+        // Install each skill — use global cwd when scope is 'global'
+        const targetCwd = scope === 'global' ? getGlobalCwd() : cwd;
+        const owner = parsed.owner;
+        const stage = parsed.repo;
+        const ownerRepo = getOwnerRepo(parsed.url);
+        const installed = [];
+        await ensureDotDir(targetCwd);
+        for (const skill of skills) {
+            const urn = `dance/@${owner}/${stage}/${skill.name}`;
+            const destDir = danceAssetDir(targetCwd, urn);
+            const srcDir = path.dirname(skill.skillMdPath);
+            copySkillDir(srcDir, destDir);
+            await upsertSkillLockEntry(targetCwd, urn, {
+                source: 'github',
+                sourceUrl: parsed.url.replace(/\.git$/, ''),
+                skillPath: skill.relativePath,
+            });
+            reportInstall(urn).catch(() => { });
+            installed.push({ urn, name: skill.name, description: skill.description });
+        }
+        invalidate('assets');
+        return { installed, source: parsed.url };
+    }
+    finally {
+        await cleanup();
+    }
+}

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

@@ -0,0 +1,178 @@
+import fs from 'fs/promises';
+import { ensureDotDir, getDotDir, getGlobalCwd, getGlobalDotDir, initRegistry, installActWithDependencies, installAsset, installPerformerWithDeps, readAsset, reportInstall, searchRegistry, parsePerformerAsset } from '../lib/dot-source.js';
+import { clearDotAuthUser, publishStudioAsset, readDotAuthUser, saveLocalStudioAsset, uninstallStudioAsset } from '../lib/dot-authoring.js';
+import { startDotLogin } from '../lib/dot-login.js';
+import { invalidate } from '../lib/cache.js';
+import { findInstalledDependents } from './asset-service.js';
+export function resolveDotCwd(cwd, scope) {
+    if (scope === 'global') {
+        return getGlobalCwd();
+    }
+    return cwd;
+}
+export async function getDotStatus(cwd) {
+    const dotDir = getDotDir(cwd);
+    const globalDotDir = getGlobalDotDir();
+    const [stageExists, globalExists] = await Promise.all([
+        fs.access(dotDir).then(() => true).catch(() => false),
+        fs.access(globalDotDir).then(() => true).catch(() => false),
+    ]);
+    return {
+        initialized: stageExists || globalExists,
+        stageInitialized: stageExists,
+        globalInitialized: globalExists,
+        dotDir,
+        globalDotDir,
+        projectDir: cwd,
+    };
+}
+export async function getDotStatusSnapshot(cwd) {
+    try {
+        return await getDotStatus(cwd);
+    }
+    catch {
+        return {
+            initialized: false,
+            stageInitialized: false,
+            globalInitialized: false,
+            dotDir: '',
+            globalDotDir: '',
+            projectDir: cwd,
+        };
+    }
+}
+export async function getDotPerformer(cwd, urn) {
+    const raw = await readAsset(cwd, urn);
+    if (!raw)
+        return null;
+    try {
+        return parsePerformerAsset(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function searchDotRegistry(query, options) {
+    return searchRegistry(query, {
+        kind: options.kind || undefined,
+        limit: options.limit,
+    });
+}
+/** Validates that performer URNs follow the 3-part format: kind/@author/name */
+export function validateDotPerformer(performer) {
+    // Canonical assets are already validated by parsePerformerAsset,
+    // but we can add extra runtime checks if needed.
+    if (!performer.payload.tal && (!performer.payload.dances || performer.payload.dances.length === 0)) {
+        throw new Error("Invalid performer: at least one of 'tal' or 'dances' must be present.");
+    }
+}
+export async function initDotRegistry(cwd, scope) {
+    const targetCwd = resolveDotCwd(cwd, scope);
+    await initRegistry(targetCwd);
+    return {
+        ok: true,
+        dotDir: getDotDir(targetCwd),
+        scope: scope || 'stage',
+    };
+}
+export async function installDotAsset(cwd, input) {
+    const targetCwd = resolveDotCwd(cwd, input.scope);
+    await ensureDotDir(targetCwd);
+    if (input.urn.startsWith('performer/')) {
+        const result = await installPerformerWithDeps(targetCwd, input.urn, input.force);
+        // Report installs for non-skipped assets (best-effort)
+        for (const asset of result.installedAssets) {
+            if (!asset.skipped)
+                reportInstall(asset.urn).catch(() => { });
+        }
+        invalidate('assets');
+        return { ...result, scope: input.scope || 'stage' };
+    }
+    if (input.urn.startsWith('act/')) {
+        const result = await installActWithDependencies(targetCwd, input.urn, input.force);
+        for (const asset of result.installedAssets) {
+            if (!asset.skipped)
+                reportInstall(asset.urn).catch(() => { });
+        }
+        invalidate('assets');
+        return { ...result, scope: input.scope || 'stage' };
+    }
+    const result = await installAsset(targetCwd, input.urn, input.force);
+    if (!result.skipped)
+        reportInstall(input.urn).catch(() => { });
+    invalidate('assets');
+    return { ...result, scope: input.scope || 'stage' };
+}
+export async function getDotAuthUser() {
+    const auth = await readDotAuthUser();
+    return {
+        authenticated: !!auth,
+        username: auth?.username || null,
+    };
+}
+export async function loginToDot() {
+    const result = await startDotLogin();
+    return { ok: true, ...result };
+}
+export async function logoutFromDot() {
+    await clearDotAuthUser();
+    return { ok: true };
+}
+export async function saveDotLocalAsset(cwd, input) {
+    const auth = await readDotAuthUser();
+    const author = input.author || auth?.username;
+    if (!author) {
+        throw new Error('No author available. Sign in with `dot login` first.');
+    }
+    const saved = await saveLocalStudioAsset({
+        cwd,
+        kind: input.kind,
+        author,
+        slug: input.slug,
+        payload: input.payload,
+    });
+    invalidate('assets');
+    return { ok: true, ...saved };
+}
+export async function publishDotAsset(cwd, input) {
+    const auth = await readDotAuthUser();
+    if (!auth) {
+        const error = Object.assign(new Error('You are not logged in. Run `dot login` first.'), { status: 401 });
+        throw error;
+    }
+    const result = await publishStudioAsset({
+        cwd,
+        kind: input.kind,
+        slug: input.slug,
+        payload: input.payload,
+        tags: input.tags,
+        auth,
+    });
+    invalidate('assets');
+    return { ok: true, ...result };
+}
+export async function uninstallDotAsset(cwd, input) {
+    const deletedUrns = [];
+    if (input.cascade) {
+        const plan = await findInstalledDependents(cwd, input.urn);
+        // Delete dependents first (bottom-up: acts before performers)
+        const sortedDependents = [...plan.dependents].sort((a, b) => {
+            const order = { act: 0, performer: 1, dance: 2, tal: 3 };
+            return (order[a.kind] ?? 9) - (order[b.kind] ?? 9);
+        });
+        for (const dep of sortedDependents) {
+            try {
+                await uninstallStudioAsset(cwd, dep.urn);
+                deletedUrns.push(dep.urn);
+            }
+            catch { /* skip already-deleted */ }
+        }
+    }
+    const result = await uninstallStudioAsset(cwd, input.urn);
+    deletedUrns.push(input.urn);
+    invalidate('assets');
+    return { ok: true, ...result, deletedUrns };
+}
+export async function previewUninstallDotAsset(cwd, input) {
+    return findInstalledDependents(cwd, input.urn);
+}