@agent-spaces/server 0.3.61 → 0.3.63

package/dist/app.js

@@ -5,9 +5,9 @@ import express from 'express';
 import cors from 'cors';
 import { createServer } from 'node:http';
 import { WebSocketServer } from 'ws';
-import { existsSync, mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
-import { join, dirname } from 'node:path';
+import { join, dirname, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import workspaceRouter from './routes/workspace.js';
 import fileRouter from './routes/file.js';
@@ -22,8 +22,10 @@ import authRouter from './routes/auth.js';
 import folderRouter from './routes/folder.js';
 import commandRouter from './routes/command.js';
 import codeFavoritesRouter from './routes/code-favorites.js';
+import hooksRouter from './routes/hooks.js';
 import skillRouter from './routes/skill.js';
 import promptTemplateRouter from './routes/prompt-template.js';
+import outputStyleRouter from './routes/output-style.js';
 import mcpRouter from './routes/mcp.js';
 import subscriptionRouter from './routes/subscription.js';
 import agentSseRouter from './routes/agent-sse.js';
@@ -65,6 +67,73 @@ app.use('/api', authMiddleware);
 // Serve static files from public/
 const publicDir = resolveRuntimeDir('public');
 app.use('/public', express.static(publicDir));
+// Scan public/prompt/ and generate index.json for the prompt store
+function scanPromptStore() {
+    const promptDir = join(publicDir, 'prompt');
+    if (!existsSync(promptDir))
+        return;
+    const files = readdirSync(promptDir).filter((f) => f.endsWith('.md'));
+    const index = files.map((filename) => {
+        const id = basename(filename, '.md');
+        const content = readFileSync(join(promptDir, filename), 'utf-8');
+        const firstHeading = content.split('\n').find((l) => /^#\s+/.test(l));
+        const name = firstHeading ? firstHeading.replace(/^#\s+/, '').trim() : id.replace(/[-_]/g, ' ');
+        return { id, name, filename };
+    });
+    writeFileSync(join(promptDir, 'index.json'), JSON.stringify(index, null, 2), 'utf-8');
+    console.log(`[prompt-store] scanned ${index.length} templates`);
+}
+scanPromptStore();
+// Scan public/output-styles/ and generate index.json
+function scanOutputStyleStore() {
+    const dir = join(publicDir, 'output-styles');
+    if (!existsSync(dir))
+        return;
+    const files = readdirSync(dir).filter((f) => f.endsWith('.md'));
+    const index = files.map((filename) => {
+        const id = basename(filename, '.md');
+        const content = readFileSync(join(dir, filename), 'utf-8');
+        const firstHeading = content.split('\n').find((l) => /^#\s+/.test(l));
+        const name = firstHeading ? firstHeading.replace(/^#\s+/, '').trim() : id.replace(/[-_]/g, ' ');
+        return { id, name, filename };
+    });
+    writeFileSync(join(dir, 'index.json'), JSON.stringify(index, null, 2), 'utf-8');
+    console.log(`[output-style-store] scanned ${index.length} templates`);
+}
+scanOutputStyleStore();
+// Scan public/skills/{group}/{skill-name}/SKILL.md and generate index.json
+function scanSkillStore() {
+    const dir = join(publicDir, 'skills');
+    if (!existsSync(dir))
+        return;
+    const index = [];
+    for (const groupEntry of readdirSync(dir, { withFileTypes: true })) {
+        if (!groupEntry.isDirectory())
+            continue;
+        const group = groupEntry.name;
+        const groupDir = join(dir, group);
+        for (const skillEntry of readdirSync(groupDir, { withFileTypes: true })) {
+            if (!skillEntry.isDirectory())
+                continue;
+            const skillName = skillEntry.name;
+            const skillFile = join(groupDir, skillName, 'SKILL.md');
+            if (!existsSync(skillFile))
+                continue;
+            const content = readFileSync(skillFile, 'utf-8');
+            const fm = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+            let name = skillName;
+            if (fm) {
+                const nameLine = fm[1].split(/\r?\n/).find((l) => /^\s*name\s*:/i.test(l));
+                if (nameLine)
+                    name = nameLine.split(':', 2)[1].trim() || skillName;
+            }
+            index.push({ id: skillName, name, group, path: `${group}/${skillName}` });
+        }
+    }
+    writeFileSync(join(dir, 'index.json'), JSON.stringify(index, null, 2), 'utf-8');
+    console.log(`[skill-store] scanned ${index.length} skills`);
+}
+scanSkillStore();
 app.get('/api/health', (_req, res) => {
     res.json({ status: 'ok', timestamp: new Date().toISOString(), platform: process.platform });
 });
@@ -82,9 +151,7 @@ app.post('/api/upload/avatar', async (req, res) => {
         return;
     }
     const [, mime, base64] = match;
-    const ext = mime === 'image/png' ? 'png' : mime === 'image/webp' ? 'webp' : 'jpg';
-    const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    const name = filename ? `${id}-${filename.replace(/[^a-zA-Z0-9._-]/g, '_')}` : `${id}.${ext}`;
+    const name = 'user.jpg';
     const avatarsDir = join(publicDir, 'avatars');
     if (!existsSync(avatarsDir))
         mkdirSync(avatarsDir, { recursive: true });
@@ -113,6 +180,7 @@ app.use('/api/workspaces/:id/issues', issueRouter);
 app.use('/api/workflows', workflowRouter);
 app.use('/api/workspaces/:id/commands', commandRouter);
 app.use('/api/workspaces/:id/code-favorites', codeFavoritesRouter);
+app.use('/api/workspaces/:id/hooks', hooksRouter);
 app.use('/api/workspaces/:id/agents', agentRouter);
 app.use('/api/workspaces/:id/tasks', taskRouter);
 app.use('/api/workspaces/:id/git', gitRouter);
@@ -144,6 +212,7 @@ app.use('/api', llmRouter);
 app.use('/api/folder', folderRouter);
 app.use('/api/skills', skillRouter);
 app.use('/api/prompt-templates', promptTemplateRouter);
+app.use('/api/output-styles', outputStyleRouter);
 app.use('/api/mcps', mcpRouter);
 app.use('/api/subscriptions', subscriptionRouter);
 app.use('/api/speech-recognition', speechRecognitionRouter);

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-spaces/server",
-  "version": "0.3.5",
+  "version": "0.3.63",
   "type": "module",
   "main": "app.js",
   "packageManager": "pnpm@10.17.1",

package/dist/routes/agent-sse.js

@@ -5,6 +5,7 @@ import * as agentService from '../services/agent.js';
 import * as workspaceService from '../services/workspace.js';
 import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
 import { buildAgentPrompt } from '../ws/agent-prompt.js';
+import { wrapOnEventWithHooks } from '../services/hook-engine.js';
 const router = Router();
 router.post('/run', async (req, res) => {
     const body = req.body;
@@ -78,11 +79,12 @@ router.post('/run', async (req, res) => {
             skills,
             configDir,
             sandboxDirs: preset.sandboxDirs,
-            onEvent: (event) => {
+            outputStyle: body.outputStyle ?? preset.outputStyle,
+            onEvent: wrapOnEventWithHooks((event) => {
                 if (event.type === 'output')
                     output.push(event.line);
                 writeSse(res, event.type, serializeRuntimeEvent(event));
-            },
+            }, workspaceId, workspace?.hooksEnabled),
         });
         completed = true;
         const displayOutput = output.length ? output : result.output;

package/dist/routes/channel.js

@@ -2,7 +2,7 @@ import { Router } from 'express';
 import { listChannels, createChannel, getChannel, updateChannel, deleteChannel } from '../services/channel.js';
 import { listMessages, createMessage, updateMessage, deleteMessage, clearMessages } from '../services/message.js';
 import { broadcastToWorkspace } from '../ws/connection-manager.js';
-import { hasActiveChannelRuns, markInactiveChannelRunsStopped, stopChannelRuns } from '../ws/agent-runner.js';
+import { hasActiveChannelRuns, stopChannelRuns } from '../ws/agent-runner.js';
 import { getToolDetail } from '../services/tool-detail.js';
 import * as issueService from '../services/issue.js';
 const router = Router({ mergeParams: true });
@@ -69,11 +69,28 @@ router.get('/:channelId/messages', (req, res) => {
         res.status(404).json({ error: 'channel not found' });
         return;
     }
-    if (!hasActiveChannelRuns(id, channelId)) {
-        markInactiveChannelRunsStopped(id, channelId);
-    }
     res.json(listMessages(id, channelId, { limit: limit ? Number(limit) : undefined, before: before }));
 });
+// GET /api/workspaces/:id/channels/:channelId/state
+router.get('/:channelId/state', (req, res) => {
+    const { id, channelId } = req.params;
+    if (!getChannel(id, channelId)) {
+        res.status(404).json({ error: 'channel not found' });
+        return;
+    }
+    const messages = listMessages(id, channelId, { limit: 1 });
+    const lastMessage = messages.at(-1);
+    res.json({
+        channelId,
+        active: hasActiveChannelRuns(id, channelId),
+        lastMessage: lastMessage ? {
+            id: lastMessage.id,
+            status: lastMessage.status,
+            metadata: lastMessage.metadata,
+            hasPendingQuestion: Boolean(lastMessage.parts?.some((part) => (part.type === 'ask_user_question' && part.status !== 'answered' && !part.answer))),
+        } : null,
+    });
+});
 // GET /api/workspaces/:id/channels/:channelId/messages/:messageId/tool-details/:detailId
 router.get('/:channelId/messages/:messageId/tool-details/:detailId', (req, res) => {
     const { id, channelId, messageId, detailId } = req.params;

package/dist/routes/file.js

@@ -1,6 +1,7 @@
 import { Router } from 'express';
 import { exec } from 'child_process';
-import { resolve, join } from 'path';
+import { resolve, join, extname } from 'path';
+import { existsSync, createReadStream, statSync } from 'node:fs';
 import * as fileService from '../services/file.js';
 import { getDataDir } from '../storage/json-store.js';
 const EDITOR_STATE_PATH = '.agentspace/editor-state.json';
@@ -16,6 +17,13 @@ router.get('/tree', async (req, res) => {
     const tree = await fileService.readTree(ws, path, depth);
     res.json(tree);
 });
+const MIME_MAP = {
+    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif',
+    '.webp': 'image/webp', '.svg': 'image/svg+xml', '.bmp': 'image/bmp', '.ico': 'image/x-icon',
+    '.mp4': 'video/mp4', '.webm': 'video/webm', '.ogg': 'video/ogg', '.mov': 'video/quicktime',
+    '.mp3': 'audio/mpeg', '.wav': 'audio/wav', '.flac': 'audio/flac', '.aac': 'audio/aac',
+    '.m4a': 'audio/mp4', '.opus': 'audio/opus',
+};
 router.get('/content', async (req, res) => {
     const ws = fileService.getWorkspace(req.params.id);
     if (!ws) {
@@ -27,6 +35,38 @@ router.get('/content', async (req, res) => {
         res.status(400).json({ error: 'path is required' });
         return;
     }
+    const raw = req.query.raw === 'true';
+    if (raw) {
+        const abs = fileService.resolvePath(ws, path);
+        if (!abs || !existsSync(abs)) {
+            res.status(404).json({ error: 'File not found' });
+            return;
+        }
+        const ext = extname(path).toLowerCase();
+        const mime = MIME_MAP[ext] || 'application/octet-stream';
+        const stat = statSync(abs);
+        const fileSize = stat.size;
+        // Handle Range requests for video/audio seeking
+        const range = req.headers.range;
+        if (range) {
+            const parts = range.replace(/bytes=/, '').split('-');
+            const start = parseInt(parts[0], 10);
+            const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1;
+            const chunkSize = end - start + 1;
+            res.status(206);
+            res.setHeader('Content-Range', `bytes ${start}-${end}/${fileSize}`);
+            res.setHeader('Accept-Ranges', 'bytes');
+            res.setHeader('Content-Length', chunkSize);
+            res.setHeader('Content-Type', mime);
+            createReadStream(abs, { start, end }).pipe(res);
+            return;
+        }
+        res.setHeader('Content-Type', mime);
+        res.setHeader('Accept-Ranges', 'bytes');
+        res.setHeader('Content-Length', fileSize);
+        createReadStream(abs).pipe(res);
+        return;
+    }
     const result = await fileService.readFileContent(ws, path);
     if (!result) {
         res.status(404).json({ error: 'File not found' });
@@ -253,5 +293,51 @@ router.post('/upload', async (req, res) => {
     }
     res.json({ ok: true, paths: results });
 });
+router.get('/download', async (req, res) => {
+    const ws = fileService.getWorkspace(req.params.id);
+    if (!ws) {
+        res.status(404).json({ error: 'Workspace not found' });
+        return;
+    }
+    const path = req.query.path;
+    if (!path) {
+        res.status(400).json({ error: 'path is required' });
+        return;
+    }
+    const abs = fileService.resolvePath(ws, path);
+    if (!abs || !existsSync(abs)) {
+        res.status(404).json({ error: 'File not found' });
+        return;
+    }
+    const stat = statSync(abs);
+    if (stat.isDirectory()) {
+        res.status(400).json({ error: 'Cannot download a directory' });
+        return;
+    }
+    const ext = extname(path).toLowerCase();
+    const mime = MIME_MAP[ext] || 'application/octet-stream';
+    const fileName = path.split('/').pop() || 'download';
+    // Handle Range requests for large files
+    const range = req.headers.range;
+    if (range) {
+        const parts = range.replace(/bytes=/, '').split('-');
+        const start = parseInt(parts[0], 10);
+        const end = parts[1] ? parseInt(parts[1], 10) : stat.size - 1;
+        const chunkSize = end - start + 1;
+        res.status(206);
+        res.setHeader('Content-Range', `bytes ${start}-${end}/${stat.size}`);
+        res.setHeader('Accept-Ranges', 'bytes');
+        res.setHeader('Content-Length', chunkSize);
+        res.setHeader('Content-Type', mime);
+        res.setHeader('Content-Disposition', `attachment; filename="${encodeURIComponent(fileName)}"`);
+        createReadStream(abs, { start, end }).pipe(res);
+        return;
+    }
+    res.setHeader('Content-Type', mime);
+    res.setHeader('Content-Length', stat.size);
+    res.setHeader('Content-Disposition', `attachment; filename="${encodeURIComponent(fileName)}"`);
+    res.setHeader('Accept-Ranges', 'bytes');
+    createReadStream(abs).pipe(res);
+});
 export default router;
 //# sourceMappingURL=file.js.map

package/dist/routes/hooks.js

@@ -0,0 +1,88 @@
+import { Router } from 'express';
+import * as store from '../storage/hook-store.js';
+const router = Router({ mergeParams: true });
+router.get('/', (req, res) => {
+    try {
+        res.json(store.listHooks(req.params.id));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.get('/:name', (req, res) => {
+    try {
+        const hook = store.getHook(req.params.id, req.params.name);
+        if (!hook) {
+            res.status(404).json({ error: 'Hook not found' });
+            return;
+        }
+        res.json(hook);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.post('/', (req, res) => {
+    try {
+        const config = req.body;
+        if (!config.name) {
+            res.status(400).json({ error: 'name required' });
+            return;
+        }
+        store.saveHook(req.params.id, config);
+        res.status(201).json(config);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.put('/:name', (req, res) => {
+    try {
+        const config = req.body;
+        config.name = req.params.name;
+        store.saveHook(req.params.id, config);
+        res.json(config);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.delete('/:name', (req, res) => {
+    try {
+        store.deleteHook(req.params.id, req.params.name);
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.post('/upload', (req, res) => {
+    try {
+        const { content } = req.body;
+        if (!content || typeof content !== 'string') {
+            res.status(400).json({ error: 'content (string) required' });
+            return;
+        }
+        const config = store.uploadHook(req.params.id, content);
+        res.status(201).json(config);
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+router.post('/:name/apply', (req, res) => {
+    try {
+        const { targetWorkspaceId } = req.body;
+        if (!targetWorkspaceId) {
+            res.status(400).json({ error: 'targetWorkspaceId required' });
+            return;
+        }
+        store.applyToWorkspace(req.params.id, req.params.name, targetWorkspaceId);
+        res.json({ ok: true });
+    }
+    catch (error) {
+        res.status(400).json({ error: error.message });
+    }
+});
+export default router;
+//# sourceMappingURL=hooks.js.map

package/dist/routes/issue.js

@@ -8,6 +8,7 @@ import * as agentService from '../services/agent.js';
 import * as taskService from '../services/task.js';
 import { retryIssue } from '../services/issue-retry.js';
 import { hasActiveIssueAutomation, runIssueAutomation } from '../agents/issue-agent-runner.js';
+import { continueIssueTaskScheduling, stopIssueAutomation } from '../agents/issue-task-controller.js';
 import * as workflowService from '../services/workflow.js';
 const router = Router({ mergeParams: true });
 router.get('/', (req, res) => {
@@ -48,13 +49,15 @@ router.put('/:issueId', (req, res) => {
         return;
     }
     const previousStatus = issue.status;
-    const { title, description, status, members, workflowId } = req.body;
+    const { title, description, status, members, workflowId, continuousRun } = req.body;
     if (title)
         issue.title = title;
     if (description !== undefined)
         issue.description = description;
     if (workflowId !== undefined)
         issue.workflowId = workflowId || undefined;
+    if (continuousRun !== undefined)
+        issue.continuousRun = continuousRun !== false;
     if (members !== undefined) {
         issue.members = normalizeIssueMembers(req.params.id, mergeWorkflowMembers(members, issue.workflowId));
     }
@@ -142,6 +145,61 @@ router.post('/:issueId/resume', async (req, res) => {
     }
     res.json(result.issue);
 });
+router.post('/:issueId/continue', (req, res) => {
+    const workspaceId = req.params.id;
+    const { issueId } = req.params;
+    const before = issueService.getById(workspaceId, issueId);
+    if (!before) {
+        res.status(404).json({ error: 'issue not found' });
+        return;
+    }
+    const issue = before.status === 'draft' || before.status === 'planned'
+        ? issueService.updateStatus(workspaceId, issueId, 'in_progress')
+        : before;
+    if (!issue) {
+        res.status(404).json({ error: 'issue not found' });
+        return;
+    }
+    if (issue.status !== before.status) {
+        broadcastToWorkspace(workspaceId, 'issue.status_changed', { issueId, from: before.status, to: issue.status });
+    }
+    broadcastToWorkspace(workspaceId, 'issue.updated', issue);
+    res.json(issue);
+    const ctx = {
+        workspaceId,
+        broadcast: (event, data) => broadcastToWorkspace(workspaceId, event, data),
+        getSession: (sessionId) => agentService.getById(workspaceId, sessionId),
+        updateSessionStatus: (sessionId, status, extra) => agentService.updateStatus(workspaceId, sessionId, status, extra),
+    };
+    continueIssueTaskScheduling(workspaceId, issueId, ctx).catch((err) => {
+        console.error(`[issue-continue] scheduling error for issue ${issueId}:`, err);
+    });
+});
+router.post('/:issueId/interrupt', (req, res) => {
+    const workspaceId = req.params.id;
+    const { issueId } = req.params;
+    const before = issueService.getById(workspaceId, issueId);
+    if (!before) {
+        res.status(404).json({ error: 'issue not found' });
+        return;
+    }
+    const reason = 'Interrupted by user';
+    const failedTasks = stopIssueAutomation(workspaceId, issueId, reason);
+    for (const { task, from } of failedTasks) {
+        broadcastToWorkspace(workspaceId, 'task.status_changed', { taskId: task.id, from, to: task.status });
+        broadcastToWorkspace(workspaceId, 'task.updated', task);
+    }
+    if (before.channelId)
+        stopChannelRuns(workspaceId, before.channelId);
+    const issue = issueService.markError(workspaceId, issueId, reason);
+    if (!issue) {
+        res.status(404).json({ error: 'issue not found' });
+        return;
+    }
+    broadcastToWorkspace(workspaceId, 'issue.status_changed', { issueId, from: before.status, to: 'error' });
+    broadcastToWorkspace(workspaceId, 'issue.updated', issue);
+    res.json(issue);
+});
 router.delete('/:issueId', (req, res) => {
     const { id, issueId } = req.params;
     const issue = issueService.getById(id, issueId);

package/dist/routes/output-style.js

@@ -0,0 +1,48 @@
+import { Router } from 'express';
+import { listOutputStyles, createOutputStyle, updateOutputStyle, deleteOutputStyle, applyOutputStyleToAgents, listOutputStyleAgentCandidates, } from '../services/output-style.js';
+const router = Router();
+router.get('/', (_req, res) => {
+    res.json(listOutputStyles());
+});
+router.get('/agents', (_req, res) => {
+    res.json(listOutputStyleAgentCandidates());
+});
+router.post('/', (req, res) => {
+    const { name, content, storeId, description } = req.body;
+    if (!name || !content) {
+        res.status(400).json({ error: 'name and content required' });
+        return;
+    }
+    res.json(createOutputStyle(name, content, storeId, description));
+});
+router.put('/:id', (req, res) => {
+    const id = typeof req.params.id === 'string' ? req.params.id : req.params.id[0];
+    const data = req.body;
+    const tmpl = updateOutputStyle(id, data);
+    if (!tmpl) {
+        res.status(404).json({ error: 'Not found' });
+        return;
+    }
+    res.json(tmpl);
+});
+router.delete('/:id', (req, res) => {
+    const id = typeof req.params.id === 'string' ? req.params.id : req.params.id[0];
+    const ok = deleteOutputStyle(id);
+    if (!ok) {
+        res.status(404).json({ error: 'Not found' });
+        return;
+    }
+    res.json({ success: true });
+});
+router.post('/:id/apply', (req, res) => {
+    const id = typeof req.params.id === 'string' ? req.params.id : req.params.id[0];
+    const { agentIds } = req.body;
+    if (!agentIds?.length) {
+        res.status(400).json({ error: 'agentIds required' });
+        return;
+    }
+    const applied = applyOutputStyleToAgents(id, agentIds);
+    res.json({ applied });
+});
+export default router;
+//# sourceMappingURL=output-style.js.map

package/dist/routes/prompt-template.js

@@ -5,12 +5,12 @@ router.get('/', (_req, res) => {
     res.json(listPromptTemplates());
 });
 router.post('/', (req, res) => {
-    const { name, content } = req.body;
+    const { name, content, storeId } = req.body;
     if (!name || !content) {
         res.status(400).json({ error: 'name and content required' });
         return;
     }
-    res.json(createPromptTemplate(name, content));
+    res.json(createPromptTemplate(name, content, storeId));
 });
 router.put('/:id', (req, res) => {
     const id = typeof req.params.id === 'string' ? req.params.id : req.params.id[0];

package/dist/routes/skill.js

@@ -1,5 +1,9 @@
 import { Router } from 'express';
-import { listSkills, importSkill, toggleFavorite, updateSkillContent, deleteSkill, checkSkillSync, syncSkills } from '../services/skill.js';
+import { exec } from 'node:child_process';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { listSkills, importSkill, importSkillsBatch, importSkillFromStore, toggleFavorite, updateSkillContent, deleteSkill, checkSkillSync, syncSkills, importSkillsFromGit, listSkillFiles, readSkillFile, writeSkillFile } from '../services/skill.js';
+import { getDataDir } from '../storage/json-store.js';
 const router = Router();
 router.get('/', (_req, res) => {
     res.json(listSkills());
@@ -17,14 +21,50 @@ router.post('/sync', (req, res) => {
     res.json({ synced });
 });
 router.post('/import', (req, res) => {
-    const { filename, content } = req.body;
+    const { filename, content, group } = req.body;
     if (!filename || !content) {
         res.status(400).json({ error: 'filename and content required' });
         return;
     }
-    const skill = importSkill(filename, content);
+    const skill = importSkill(filename, content, group);
     res.json(skill);
 });
+router.post('/import-batch', (req, res) => {
+    const { items } = req.body;
+    if (!Array.isArray(items) || items.length === 0) {
+        res.status(400).json({ error: 'items required' });
+        return;
+    }
+    const skills = importSkillsBatch(items);
+    res.json(skills);
+});
+router.post('/import-store', (req, res) => {
+    const { path, group } = req.body;
+    if (!path) {
+        res.status(400).json({ error: 'path required' });
+        return;
+    }
+    const skill = importSkillFromStore(path, group || '');
+    if (!skill) {
+        res.status(404).json({ error: 'Store skill not found' });
+        return;
+    }
+    res.json(skill);
+});
+router.post('/import-git', (req, res) => {
+    const { url } = req.body;
+    if (!url) {
+        res.status(400).json({ error: 'url required' });
+        return;
+    }
+    try {
+        const skills = importSkillsFromGit(url);
+        res.json(skills);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message || 'Git clone failed' });
+    }
+});
 router.post('/:name/favorite', (req, res) => {
     const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
     const favorited = toggleFavorite(name);
@@ -44,6 +84,60 @@ router.put('/:name', (req, res) => {
     }
     res.json({ success: true });
 });
+router.get('/:name/files', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const files = listSkillFiles(name);
+    res.json(files);
+});
+router.get('/:name/files/{*filePath}', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const filePath = Array.isArray(req.params.filePath) ? req.params.filePath.join('/') : req.params.filePath;
+    if (!filePath) {
+        res.status(400).json({ error: 'file path required' });
+        return;
+    }
+    const content = readSkillFile(name, filePath);
+    if (content === null) {
+        res.status(404).json({ error: 'File not found' });
+        return;
+    }
+    res.json({ content });
+});
+router.put('/:name/files/{*filePath}', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const filePath = Array.isArray(req.params.filePath) ? req.params.filePath.join('/') : req.params.filePath;
+    const { content } = req.body;
+    if (!filePath || content === undefined) {
+        res.status(400).json({ error: 'file path and content required' });
+        return;
+    }
+    const ok = writeSkillFile(name, filePath, content);
+    if (!ok) {
+        res.status(400).json({ error: 'Failed to write file' });
+        return;
+    }
+    res.json({ success: true });
+});
+router.post('/:name/reveal', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const skillDir = join(getDataDir(), 'skills', name);
+    if (!existsSync(skillDir)) {
+        res.status(404).json({ error: 'Skill folder not found' });
+        return;
+    }
+    const cmd = process.platform === 'darwin'
+        ? `open "${skillDir}"`
+        : process.platform === 'win32'
+            ? `explorer "${skillDir}"`
+            : `xdg-open "${skillDir}"`;
+    exec(cmd, (err) => {
+        if (err) {
+            res.status(500).json({ error: 'Failed to reveal', detail: err.message });
+            return;
+        }
+        res.json({ ok: true, path: skillDir });
+    });
+});
 router.delete('/:name', (req, res) => {
     const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
     const ok = deleteSkill(name);