@agent-spaces/server 0.3.61 → 0.3.63

package/dist/services/skill.js

@@ -1,7 +1,11 @@
-import { copyFileSync, existsSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
 import { ensureDir, getDataDir } from '../storage/json-store.js';
 import { listTemplates } from './agent.js';
+const SKILL_FILE = 'SKILL.md';
 function getSkillsDir() {
     return join(getDataDir(), 'skills');
 }
@@ -11,33 +15,65 @@ function getSkillMetaPath() {
 function readMeta() {
     const path = getSkillMetaPath();
     if (!existsSync(path))
-        return { favorites: [] };
+        return { favorites: [], groups: {} };
     try {
-        return JSON.parse(readFileSync(path, 'utf-8'));
+        const raw = JSON.parse(readFileSync(path, 'utf-8'));
+        return {
+            favorites: raw.favorites || [],
+            groups: raw.groups || {},
+        };
     }
     catch {
-        return { favorites: [] };
+        return { favorites: [], groups: {} };
     }
 }
 function writeMeta(meta) {
     ensureDir(getSkillsDir());
     writeFileSync(getSkillMetaPath(), JSON.stringify(meta, null, 2), 'utf-8');
 }
+/** Migrate flat .md files to folder/{SKILL_FILE} format */
+function migrateFlatFiles() {
+    const skillsDir = getSkillsDir();
+    if (!existsSync(skillsDir))
+        return;
+    const entries = readdirSync(skillsDir);
+    for (const entry of entries) {
+        if (!entry.endsWith('.md') || entry.startsWith('_'))
+            continue;
+        const filePath = join(skillsDir, entry);
+        if (!statSync(filePath).isFile())
+            continue;
+        const name = basename(entry, '.md');
+        const folderPath = join(skillsDir, name);
+        if (!existsSync(folderPath)) {
+            mkdirSync(folderPath, { recursive: true });
+            const content = readFileSync(filePath, 'utf-8');
+            writeFileSync(join(folderPath, SKILL_FILE), content, 'utf-8');
+        }
+        unlinkSync(filePath);
+    }
+}
 export function listSkills() {
+    migrateFlatFiles();
     const agents = listTemplates();
     const skillsDir = getSkillsDir();
     const meta = readMeta();
     ensureDir(skillsDir);
-    const skillFiles = readdirSync(skillsDir)
-        .filter((f) => f.endsWith('.md') && !f.startsWith('_'));
-    return skillFiles.map((filename) => {
-        const content = readFileSync(join(skillsDir, filename), 'utf-8');
-        const name = basename(filename, '.md');
+    const folders = readdirSync(skillsDir)
+        .filter((f) => {
+        if (f.startsWith('_'))
+            return false;
+        const p = join(skillsDir, f);
+        return statSync(p).isDirectory();
+    });
+    return folders.map((folderName) => {
+        const skillFile = join(skillsDir, folderName, SKILL_FILE);
+        const content = existsSync(skillFile) ? readFileSync(skillFile, 'utf-8') : '';
         const fm = parseFrontmatter(content);
         const boundAgents = agents
             .filter((a) => (a.skills || []).some((s) => {
             const skillName = s.replace(/\.md$/i, '');
-            return skillName === name;
+            return skillName === folderName;
         }))
             .map((a) => ({
             id: a.id,
@@ -45,11 +81,12 @@ export function listSkills() {
             avatarUrl: a.avatarUrl,
         }));
         return {
-            name,
+            name: folderName,
             description: fm.description || '',
-            filename,
+            filename: `${folderName}/${SKILL_FILE}`,
             content,
-            favorited: meta.favorites.includes(name),
+            favorited: meta.favorites.includes(folderName),
+            group: meta.groups[folderName] || '',
             boundAgents,
         };
     });
@@ -71,24 +108,99 @@ function parseFrontmatter(content) {
     }
     return { name, description };
 }
-function sanitizeFilename(name) {
-    const safe = name.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'skill';
-    return safe.endsWith('.md') ? safe : `${safe}.md`;
+function sanitizeFolderName(name) {
+    return name.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'skill';
 }
-export function importSkill(filename, content) {
+function writeSkillFolder(name, content) {
+    const skillsDir = getSkillsDir();
+    const folderName = sanitizeFolderName(name);
+    const folderPath = join(skillsDir, folderName);
+    ensureDir(folderPath);
+    writeFileSync(join(folderPath, SKILL_FILE), content, 'utf-8');
+    return folderName;
+}
+export function importSkill(filename, content, group) {
     const fm = parseFrontmatter(content);
-    const finalName = fm.name
-        ? sanitizeFilename(fm.name)
-        : sanitizeFilename(filename);
+    const rawName = fm.name || basename(filename, '.md');
+    const folderName = writeSkillFolder(rawName, content);
+    if (group) {
+        const meta = readMeta();
+        meta.groups[folderName] = group;
+        writeMeta(meta);
+    }
+    return {
+        name: folderName,
+        description: fm.description || '',
+        filename: `${folderName}/${SKILL_FILE}`,
+        content,
+        favorited: false,
+        group: group || '',
+        boundAgents: [],
+    };
+}
+export function importSkillsBatch(items) {
+    const meta = readMeta();
+    const results = [];
+    for (const item of items) {
+        const folderName = writeSkillFolder(item.name, item.content);
+        if (item.group) {
+            meta.groups[folderName] = item.group;
+        }
+        const fm = parseFrontmatter(item.content);
+        results.push({
+            name: folderName,
+            description: fm.description || '',
+            filename: `${folderName}/${SKILL_FILE}`,
+            content: item.content,
+            favorited: false,
+            group: item.group || '',
+            boundAgents: [],
+        });
+    }
+    writeMeta(meta);
+    return results;
+}
+export function importSkillFromStore(storePath, group) {
+    // storePath is like "group-name/skill-name", relative to public/skills/
+    const publicSkillsDir = join(getDataDir(), '..', 'public', 'skills');
+    // Try relative to package first
+    let srcDir = null;
+    const candidates = [
+        join(process.cwd(), 'public', 'skills', storePath),
+        join(import.meta.dirname ?? '', '..', 'public', 'skills', storePath),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c) && statSync(c).isDirectory()) {
+            srcDir = c;
+            break;
+        }
+    }
+    if (!srcDir)
+        return null;
+    const skillName = basename(storePath);
     const skillsDir = getSkillsDir();
-    ensureDir(skillsDir);
-    writeFileSync(join(skillsDir, finalName), content, 'utf-8');
+    const destDir = join(skillsDir, skillName);
+    // Copy entire folder
+    if (existsSync(destDir))
+        rmSync(destDir, { recursive: true, force: true });
+    cpSync(srcDir, destDir, { recursive: true, force: true });
+    // Set group in meta
+    if (group) {
+        const meta = readMeta();
+        meta.groups[skillName] = group;
+        writeMeta(meta);
+    }
+    // Read content for return
+    const skillFile = join(destDir, SKILL_FILE);
+    const content = existsSync(skillFile) ? readFileSync(skillFile, 'utf-8') : '';
+    const fm = parseFrontmatter(content);
     return {
-        name: basename(finalName, '.md'),
+        name: skillName,
         description: fm.description || '',
-        filename: finalName,
+        filename: `${skillName}/${SKILL_FILE}`,
         content,
         favorited: false,
+        group,
         boundAgents: [],
     };
 }
@@ -106,8 +218,7 @@ export function toggleFavorite(name) {
 }
 export function updateSkillContent(name, content) {
     const skillsDir = getSkillsDir();
-    const filename = name.endsWith('.md') ? name : `${name}.md`;
-    const filePath = join(skillsDir, filename);
+    const filePath = join(skillsDir, name, SKILL_FILE);
     if (!existsSync(filePath))
         return false;
     writeFileSync(filePath, content, 'utf-8');
@@ -115,14 +226,19 @@ export function updateSkillContent(name, content) {
 }
 export function deleteSkill(name) {
     const skillsDir = getSkillsDir();
-    const filename = name.endsWith('.md') ? name : `${name}.md`;
-    const filePath = join(skillsDir, filename);
-    if (!existsSync(filePath))
+    const folderPath = join(skillsDir, name);
+    if (!existsSync(folderPath) || !statSync(folderPath).isDirectory())
         return false;
-    unlinkSync(filePath);
+    rmSync(folderPath, { recursive: true, force: true });
+    // Clean meta
+    const meta = readMeta();
+    meta.favorites = meta.favorites.filter((n) => n !== name);
+    delete meta.groups[name];
+    writeMeta(meta);
     return true;
 }
 export function checkSkillSync() {
+    migrateFlatFiles();
     const globalSkillsDir = getSkillsDir();
     const agents = listTemplates();
     const result = [];
@@ -132,14 +248,36 @@ export function checkSkillSync() {
             continue;
         const agentSkillsDir = join(getDataDir(), 'agent-templates', agent.id, 'skills');
         for (const skillName of skillNames) {
-            const globalFile = join(globalSkillsDir, `${skillName}.md`);
+            const globalFolder = join(globalSkillsDir, skillName);
+            const globalSkillFile = join(globalFolder, SKILL_FILE);
+            // Agent skill can be a folder or a flat .md
+            const agentFolder = join(agentSkillsDir, skillName);
             const agentFile = join(agentSkillsDir, `${skillName}.md`);
-            if (!existsSync(globalFile))
+            if (!existsSync(globalFolder) || !statSync(globalFolder).isDirectory())
                 continue;
-            if (!existsSync(agentFile))
+            // Use SKILL.md file mtime — directory mtime is unreliable on Windows
+            if (!existsSync(globalSkillFile))
                 continue;
-            const globalStat = statSync(globalFile);
-            const agentStat = statSync(agentFile);
+            const globalStat = statSync(globalSkillFile);
+            const agentExists = existsSync(agentFolder) || existsSync(agentFile);
+            if (!agentExists) {
+                // Agent skill missing — needs sync
+                result.push({
+                    agentId: agent.id,
+                    agentName: agent.name || agent.id,
+                    skillName,
+                    globalMtime: globalStat.mtime.toISOString(),
+                    agentMtime: '',
+                });
+                continue;
+            }
+            // Find the actual agent SKILL.md path
+            const agentSkillFile = existsSync(agentFolder)
+                ? join(agentFolder, SKILL_FILE)
+                : agentFile;
+            if (!existsSync(agentSkillFile))
+                continue;
+            const agentStat = statSync(agentSkillFile);
             if (globalStat.mtimeMs > agentStat.mtimeMs) {
                 result.push({
                     agentId: agent.id,
@@ -157,15 +295,112 @@ export function syncSkills(items) {
     const globalSkillsDir = getSkillsDir();
     let synced = 0;
     for (const item of items) {
-        const globalFile = join(globalSkillsDir, `${item.skillName}.md`);
-        const agentSkillsDir = join(getDataDir(), 'agent-templates', item.agentId, 'skills');
-        const agentFile = join(agentSkillsDir, `${item.skillName}.md`);
-        if (!existsSync(globalFile))
+        const globalFolder = join(globalSkillsDir, item.skillName);
+        if (!existsSync(globalFolder) || !statSync(globalFolder).isDirectory())
             continue;
+        const agentSkillsDir = join(getDataDir(), 'agent-templates', item.agentId, 'skills');
         ensureDir(agentSkillsDir);
-        copyFileSync(globalFile, agentFile);
+        // Remove stale flat .md if it exists
+        const flatFile = join(agentSkillsDir, `${item.skillName}.md`);
+        if (existsSync(flatFile)) {
+            rmSync(flatFile, { force: true });
+        }
+        // Copy entire skill folder
+        const agentFolder = join(agentSkillsDir, item.skillName);
+        if (existsSync(agentFolder)) {
+            rmSync(agentFolder, { recursive: true, force: true });
+        }
+        cpSync(globalFolder, agentFolder, { recursive: true, force: true });
         synced++;
     }
     return synced;
 }
+export function listSkillFiles(name) {
+    const skillsDir = getSkillsDir();
+    const folderPath = join(skillsDir, name);
+    if (!existsSync(folderPath) || !statSync(folderPath).isDirectory())
+        return [];
+    function walk(dir, prefix) {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        const result = [];
+        for (const entry of entries) {
+            if (entry.name.startsWith('_') || entry.name === '.DS_Store')
+                continue;
+            const fullPath = join(dir, entry.name);
+            const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                result.push({ name: entry.name, path: relativePath, isDirectory: true });
+                result.push(...walk(fullPath, relativePath));
+            }
+            else {
+                result.push({ name: entry.name, path: relativePath, isDirectory: false });
+            }
+        }
+        return result;
+    }
+    return walk(folderPath, '');
+}
+export function readSkillFile(name, filePath) {
+    const skillsDir = getSkillsDir();
+    const fullPath = join(skillsDir, name, filePath);
+    // Prevent path traversal
+    if (!fullPath.startsWith(join(skillsDir, name)))
+        return null;
+    if (!existsSync(fullPath) || !statSync(fullPath).isFile())
+        return null;
+    return readFileSync(fullPath, 'utf-8');
+}
+export function writeSkillFile(name, filePath, content) {
+    const skillsDir = getSkillsDir();
+    const fullPath = join(skillsDir, name, filePath);
+    // Prevent path traversal
+    if (!fullPath.startsWith(join(skillsDir, name)))
+        return false;
+    const dir = join(fullPath, '..');
+    ensureDir(dir);
+    writeFileSync(fullPath, content, 'utf-8');
+    return true;
+}
+export function importSkillsFromGit(gitUrl) {
+    const cloneDir = join(tmpdir(), `agent-spaces-git-${randomUUID()}`);
+    try {
+        execFileSync('git', ['clone', '--depth', '1', gitUrl, cloneDir], {
+            timeout: 60_000,
+            stdio: 'pipe',
+        });
+        const results = [];
+        function walk(dir) {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                    continue;
+                const full = join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    walk(full);
+                }
+                else if (entry.name === SKILL_FILE || entry.name.endsWith('.md')) {
+                    const folderName = basename(dir);
+                    if (folderName === basename(cloneDir))
+                        continue; // skip repo root
+                    const existing = results.find((r) => r.name === folderName);
+                    // Prefer SKILL.md over generic .md
+                    if (!existing || (entry.name === SKILL_FILE && existing.content)) {
+                        const content = readFileSync(full, 'utf-8');
+                        if (!existing) {
+                            results.push({ name: folderName, content });
+                        }
+                        else {
+                            existing.content = content;
+                        }
+                    }
+                }
+            }
+        }
+        walk(cloneDir);
+        return results;
+    }
+    finally {
+        rmSync(cloneDir, { recursive: true, force: true });
+    }
+}
 //# sourceMappingURL=skill.js.map

package/dist/storage/hook-store.js

@@ -0,0 +1,55 @@
+import { join } from 'node:path';
+import { readdirSync } from 'node:fs';
+import { getDataDir, ensureDir, readJsonFile, writeJsonFile, deleteFile } from './json-store.js';
+function workspaceDir(id) {
+    return join(getDataDir(), 'workspaces', id);
+}
+function hooksDir(wsId) {
+    return join(workspaceDir(wsId), 'hooks');
+}
+function hookPath(wsId, name) {
+    return join(hooksDir(wsId), `${name}.hook.json`);
+}
+export function listHooks(wsId) {
+    const dir = hooksDir(wsId);
+    try {
+        const files = readdirSync(dir);
+        return files
+            .filter(f => f.endsWith('.hook.json'))
+            .map(f => readJsonFile(join(dir, f)))
+            .filter((h) => h !== null);
+    }
+    catch {
+        return [];
+    }
+}
+export function getHook(wsId, name) {
+    return readJsonFile(hookPath(wsId, name));
+}
+export function saveHook(wsId, config) {
+    ensureDir(hooksDir(wsId));
+    writeJsonFile(hookPath(wsId, config.name), config);
+}
+export function deleteHook(wsId, name) {
+    deleteFile(hookPath(wsId, name));
+}
+export function uploadHook(wsId, jsonString) {
+    const parsed = JSON.parse(jsonString);
+    if (!parsed.name || typeof parsed.name !== 'string') {
+        throw new Error('Hook must have a "name" string field');
+    }
+    if (!parsed.hooks || typeof parsed.hooks !== 'object') {
+        parsed.hooks = { PreToolUse: [], PostToolUse: [] };
+    }
+    if (parsed.enabled === undefined)
+        parsed.enabled = true;
+    saveHook(wsId, parsed);
+    return parsed;
+}
+export function applyToWorkspace(sourceWsId, name, targetWsId) {
+    const config = getHook(sourceWsId, name);
+    if (!config)
+        throw new Error(`Hook "${name}" not found in workspace ${sourceWsId}`);
+    saveHook(targetWsId, config);
+}
+//# sourceMappingURL=hook-store.js.map