@agent-spaces/server 0.2.9 → 0.3.1

package/dist/agents/issue-task-controller.js

@@ -7,6 +7,7 @@ import * as workspaceService from '../services/workspace.js';
 import { mapWorkflowToTaskDrafts, validateWorkflowForRun } from '../services/workflow.js';
 import { createIssueFunctionTools } from '../services/builtin-tools.js';
 import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
+import { prependPersistentAgentContext } from '../services/persistent-agent-context.js';
 import { completeIssueAgentProgress, createIssueAgentProgress, createIssueAgentProgressTracker } from './issue-agent-progress.js';
 const ACTIVE_TASK_STATUSES = ['running', 'reviewing', 'retrying', 'waiting_review'];
 export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, ctx) {
@@ -45,7 +46,7 @@ export async function syncIssueTasksAfterPlanning(workspaceId, issueId, input, c
         },
     });
     const runtime = createRuntimeForPreset(taskSyncPreset);
-    const result = await runtime.execute(buildTaskSyncPrompt(issue, input, taskSyncWorkingDir), taskSyncWorkingDir, {
+    const result = await runtime.execute(buildIssueAgentPrompt(workspaceId, buildTaskSyncPrompt(issue, input, taskSyncWorkingDir), taskSyncWorkingDir, taskSyncPreset), taskSyncWorkingDir, {
         maxTurns: 20,
         mcpServers: undefined,
         functionTools: createTaskSyncTools(workspaceId, issue, taskSyncPreset, ctx),
@@ -184,7 +185,7 @@ export async function runIssueTask(workspaceId, issueId, taskId, ctx) {
         agentId: taskAgent.id,
         data: `[debug] workflow agentConfigId=${taskAgentPreset.id} role=${taskAgentPreset.role} taskAgentConfigId=${runningTask.agentConfigId || '(fallback)'} runtime=${taskAgentPreset.runtimeKind ?? 'open-agent-sdk'}`,
     });
-    const result = await runtime.execute(buildTaskAgentPrompt(issue, runningTask, taskAgentPreset, agentWorkingDir), agentWorkingDir, {
+    const result = await runtime.execute(buildIssueAgentPrompt(workspaceId, buildTaskAgentPrompt(issue, runningTask, taskAgentPreset, agentWorkingDir), agentWorkingDir, taskAgentPreset), agentWorkingDir, {
         maxTurns: 100,
         mcpServers: agentService.getMcpServers(taskAgentPreset.mcps),
         functionTools: createCurrentIssueTools(workspaceId, issue, taskAgentPreset),
@@ -324,10 +325,10 @@ export function createTasksFromWorkflow(workspaceId, issueId, template, ctx) {
     }
     const drafts = mapWorkflowToTaskDrafts(template);
     issueService.updateStatus(workspaceId, issueId, 'planned');
-    ctx.broadcast('issue.status_changed', { issueId, oldStatus: issue.status, newStatus: 'planned' });
+    ctx.broadcast('issue.status_changed', { issueId, from: issue.status, to: 'planned' });
     replaceIssueTasksFromDrafts(workspaceId, issueId, ctx, drafts);
     issueService.updateStatus(workspaceId, issueId, 'in_progress');
-    ctx.broadcast('issue.status_changed', { issueId, oldStatus: 'planned', newStatus: 'in_progress' });
+    ctx.broadcast('issue.status_changed', { issueId, from: 'planned', to: 'in_progress' });
     ctx.broadcast('issue.updated', issueService.getById(workspaceId, issueId));
     scheduleRunnableIssueTasks(workspaceId, issueId, ctx).catch((err) => {
         console.error(`[workflow] task scheduling failed for issue ${issueId}:`, err);
@@ -435,6 +436,15 @@ function createRuntimeForPreset(preset) {
 function resolveIssueWorkspaceRoot(workspaceId) {
     return workspaceService.getById(workspaceId)?.boundDirs?.[0] || process.cwd();
 }
+function buildIssueAgentPrompt(workspaceId, prompt, workingDir, preset) {
+    return prependPersistentAgentContext(prompt, {
+        workspaceId,
+        workingDir,
+        boundDirs: workspaceService.getById(workspaceId)?.boundDirs,
+        includeWorkspacePrompt: false,
+        excludeNativeClaudeMd: preset.runtimeKind === 'claude-code',
+    });
+}
 function buildTaskSyncPrompt(issue, input, workingDir) {
     return [
         'You are the issue task synchronization controller.',

package/dist/app.js

@@ -27,6 +27,8 @@ import subscriptionRouter from './routes/subscription.js';
 import agentSseRouter from './routes/agent-sse.js';
 import searchRouter from './routes/search.js';
 import notificationRouter from './routes/notification.js';
+import iframeBookmarksRouter from './routes/iframe-bookmarks.js';
+import speechRecognitionRouter, { handleSpeechStream } from './routes/speech-recognition.js';
 import { getUserSettings, setUserAvatarUrl, removeUserAvatarUrl } from './storage/user-settings-store.js';
 import { authMiddleware, verifyToken } from './middleware/auth.js';
 import { handleConnection } from './ws/handler.js';
@@ -100,6 +102,27 @@ app.use('/api/workspaces/:id/commands', commandRouter);
 app.use('/api/workspaces/:id/agents', agentRouter);
 app.use('/api/workspaces/:id/tasks', taskRouter);
 app.use('/api/workspaces/:id/git', gitRouter);
+// Global git config (no workspace context needed)
+import { gitGetConfig as _gitGetConfig, gitSetConfig as _gitSetConfig } from './adapters/git.js';
+app.get('/api/git-config', async (_req, res) => {
+    try {
+        const config = await _gitGetConfig('global');
+        res.json(config);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+app.post('/api/git-config', async (req, res) => {
+    try {
+        const { name, email, proxy } = req.body;
+        await _gitSetConfig('global', { name, email, proxy });
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
 app.use('/api/workspaces/:id/search', searchRouter);
 app.use('/api/workspaces/:id/notifications', notificationRouter);
 app.use('/api/agents', agentRouter);
@@ -108,6 +131,8 @@ app.use('/api/folder', folderRouter);
 app.use('/api/skills', skillRouter);
 app.use('/api/mcps', mcpRouter);
 app.use('/api/subscriptions', subscriptionRouter);
+app.use('/api/speech-recognition', speechRecognitionRouter);
+app.use('/api/iframe-bookmarks', iframeBookmarksRouter);
 // Serve static web frontend in production (after API routes, before catch-all)
 const webDir = resolveRuntimeDir('web');
 if (existsSync(webDir)) {
@@ -134,7 +159,18 @@ else {
     console.warn('[server] web frontend not found at', webDir, '- run \`pnpm build\` first');
 }
 const server = createServer(app);
-const wss = new WebSocketServer({ server, path: '/ws' });
+const wss = new WebSocketServer({ noServer: true });
+// Speech recognition WebSocket on /ws/speech
+const speechWss = new WebSocketServer({ noServer: true });
+speechWss.on('connection', (ws, req) => {
+    const token = new URL(req.url || '', `http://localhost:${PORT}`).searchParams.get('token');
+    if (!verifyToken(token)) {
+        ws.close(4003, 'Unauthorized');
+        return;
+    }
+    const configId = new URL(req.url || '', `http://localhost:${PORT}`).searchParams.get('configId') || undefined;
+    handleSpeechStream(ws, configId);
+});
 wss.on('connection', (ws, req) => {
     const url = new URL(req.url || '', `http://localhost:${PORT}`);
     const workspaceId = url.searchParams.get('workspaceId');
@@ -149,6 +185,22 @@ wss.on('connection', (ws, req) => {
     }
     handleConnection(ws, workspaceId);
 });
+server.on('upgrade', (req, socket, head) => {
+    const { pathname } = new URL(req.url || '/', `http://localhost:${PORT}`);
+    if (pathname === '/ws') {
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            wss.emit('connection', ws, req);
+        });
+        return;
+    }
+    if (pathname === '/ws/speech') {
+        speechWss.handleUpgrade(req, socket, head, (ws) => {
+            speechWss.emit('connection', ws, req);
+        });
+        return;
+    }
+    socket.destroy();
+});
 const HOST = process.env.HOST || '0.0.0.0';
 server.listen(PORT, HOST, () => {
     console.log(`[server] listening on http://${HOST}:${PORT}`);

package/dist/package.json

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

package/dist/routes/agent-sse.js

@@ -45,6 +45,7 @@ router.post('/run', async (req, res) => {
     const configDir = agentService.getAgentConfigDir(workspaceId, { ...preset, skills: requestedSkills });
     const skills = agentService.getAvailableSkillNames(configDir, requestedSkills);
     const output = [];
+    const workingDir = agentService.resolveWorkingDir(workspaceId, preset);
     let completed = false;
     prepareSse(res);
     writeSse(res, 'session', { session, workspaceId });
@@ -68,8 +69,10 @@ router.post('/run', async (req, res) => {
             mcpServers: Object.keys(mcpServers ?? {}),
             skills,
             boundDirs: workspace.boundDirs,
+            workingDir,
+            excludeNativeClaudeMd: preset.runtimeKind === 'claude-code',
             builtInTools: [],
-        }), agentService.resolveWorkingDir(workspaceId, preset), {
+        }), workingDir, {
             maxTurns: normalizeMaxTurns(body.maxTurns),
             mcpServers,
             skills,

package/dist/routes/agent.js

@@ -1,5 +1,6 @@
 import { Router } from 'express';
 import * as agentService from '../services/agent.js';
+import { generateAgentDesign } from '../agents/agent-designer.js';
 const router = Router({ mergeParams: true });
 router.get('/usage/dashboard', (req, res) => {
     const days = Number(req.query.days ?? 30);
@@ -21,6 +22,20 @@ router.post('/presets', (req, res) => {
     const preset = agentService.createPreset(req.params.id, body);
     res.status(201).json(preset);
 });
+router.post('/presets/generate', async (req, res) => {
+    const { prompt } = req.body;
+    if (!prompt?.trim()) {
+        res.status(400).json({ error: 'prompt is required' });
+        return;
+    }
+    try {
+        res.json(await generateAgentDesign(prompt));
+    }
+    catch (err) {
+        console.error('[agent-designer] generate failed', err);
+        res.status(400).json({ error: err instanceof Error ? err.message : 'agent generation failed' });
+    }
+});
 router.post('/presets/test-connection', async (req, res) => {
     const workspaceId = req.params.id;
     const data = req.body;

package/dist/routes/channel.js

@@ -24,7 +24,7 @@ router.post('/', (req, res) => {
 router.put('/:channelId', (req, res) => {
     const { id, channelId } = req.params;
     const patch = {};
-    for (const key of ['name', 'type', 'issueId', 'members', 'pinnedMentionId', 'draft', 'todos']) {
+    for (const key of ['name', 'type', 'issueId', 'members', 'pinnedMentionId', 'draft', 'todos', 'archived']) {
         if (Object.hasOwn(req.body, key))
             patch[key] = req.body[key];
     }

package/dist/routes/file.js

@@ -12,7 +12,8 @@ router.get('/tree', async (req, res) => {
         return;
     }
     const path = req.query.path || '';
-    const tree = await fileService.readTree(ws, path);
+    const depth = parseInt(req.query.depth) || undefined;
+    const tree = await fileService.readTree(ws, path, depth);
     res.json(tree);
 });
 router.get('/content', async (req, res) => {
@@ -144,5 +145,100 @@ router.post('/reveal', async (req, res) => {
         res.json({ ok: true, path: fullPath });
     });
 });
+router.post('/rename', async (req, res) => {
+    const ws = fileService.getWorkspace(req.params.id);
+    if (!ws) {
+        res.status(404).json({ error: 'Workspace not found' });
+        return;
+    }
+    const { oldPath, newPath } = req.body;
+    if (!oldPath || !newPath) {
+        res.status(400).json({ error: 'oldPath and newPath are required' });
+        return;
+    }
+    const ok = await fileService.renamePath(ws, oldPath, newPath);
+    if (!ok) {
+        res.status(500).json({ error: 'Failed to rename' });
+        return;
+    }
+    res.json({ ok: true });
+});
+router.post('/copy', async (req, res) => {
+    const ws = fileService.getWorkspace(req.params.id);
+    if (!ws) {
+        res.status(404).json({ error: 'Workspace not found' });
+        return;
+    }
+    const { srcPath, destPath } = req.body;
+    if (!srcPath || !destPath) {
+        res.status(400).json({ error: 'srcPath and destPath are required' });
+        return;
+    }
+    const ok = await fileService.copyPath(ws, srcPath, destPath);
+    if (!ok) {
+        res.status(500).json({ error: 'Failed to copy' });
+        return;
+    }
+    res.json({ ok: true });
+});
+router.post('/import-url', async (req, res) => {
+    const ws = fileService.getWorkspace(req.params.id);
+    if (!ws) {
+        res.status(404).json({ error: 'Workspace not found' });
+        return;
+    }
+    const { url, targetDir } = req.body;
+    if (!url) {
+        res.status(400).json({ error: 'url is required' });
+        return;
+    }
+    const result = await fileService.importFromUrl(ws, url, targetDir || '');
+    if (!result) {
+        res.status(500).json({ error: 'Failed to import from URL' });
+        return;
+    }
+    res.json({ ok: true, path: result });
+});
+router.post('/import-path', async (req, res) => {
+    const ws = fileService.getWorkspace(req.params.id);
+    if (!ws) {
+        res.status(404).json({ error: 'Workspace not found' });
+        return;
+    }
+    const { absPath, targetDir } = req.body;
+    if (!absPath) {
+        res.status(400).json({ error: 'absPath is required' });
+        return;
+    }
+    const result = await fileService.importFromAbsPath(ws, absPath, targetDir || '');
+    if (!result) {
+        res.status(500).json({ error: 'Failed to import file' });
+        return;
+    }
+    res.json({ ok: true, path: result });
+});
+router.post('/upload', async (req, res) => {
+    const ws = fileService.getWorkspace(req.params.id);
+    if (!ws) {
+        res.status(404).json({ error: 'Workspace not found' });
+        return;
+    }
+    const { targetDir, files } = req.body;
+    if (!Array.isArray(files) || files.length === 0) {
+        res.status(400).json({ error: 'files are required' });
+        return;
+    }
+    const results = [];
+    for (const f of files) {
+        if (!f.name || !f.content)
+            continue;
+        const buffer = Buffer.from(f.content, 'base64');
+        const relPath = targetDir ? `${targetDir}/${f.name}` : f.name;
+        const ok = await fileService.writeFileBinary(ws, relPath, buffer);
+        if (ok)
+            results.push(relPath);
+    }
+    res.json({ ok: true, paths: results });
+});
 export default router;
 //# sourceMappingURL=file.js.map

package/dist/routes/git.js

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { gitStatus, gitDiff, gitLog, gitCommit, gitDiscard, gitDiscardAll, gitBranches, gitCheckout, gitInit, gitGenerateCommitMsg, gitPush, gitPull, gitGetRemotes, gitAddRemote } from '../adapters/git.js';
+import { gitStatus, gitDiff, gitLog, gitCommit, gitDiscard, gitDiscardAll, gitBranches, gitCheckout, gitInit, gitGenerateCommitMsg, gitPush, gitPull, gitGetRemotes, gitAddRemote, gitCheckoutDetached, gitCherryPick, gitCreateBranch, gitDeleteBranch, gitCreateTag, gitCommitDiff, gitGetRemoteUrl, gitMergeBase, gitGetConfig, gitSetConfig } from '../adapters/git.js';
 const router = Router({ mergeParams: true });
 router.get('/status', async (req, res) => {
     try {
@@ -149,5 +149,126 @@ router.post('/remotes', async (req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
+router.post('/checkout-detached', async (req, res) => {
+    try {
+        const { commitHash } = req.body;
+        if (!commitHash) {
+            res.status(400).json({ error: 'commitHash is required' });
+            return;
+        }
+        await gitCheckoutDetached(req.params.id, commitHash);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.post('/cherry-pick', async (req, res) => {
+    try {
+        const { commitHash } = req.body;
+        if (!commitHash) {
+            res.status(400).json({ error: 'commitHash is required' });
+            return;
+        }
+        await gitCherryPick(req.params.id, commitHash);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.post('/create-branch', async (req, res) => {
+    try {
+        const { name, startPoint } = req.body;
+        if (!name) {
+            res.status(400).json({ error: 'name is required' });
+            return;
+        }
+        await gitCreateBranch(req.params.id, name, startPoint);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.post('/delete-branch', async (req, res) => {
+    try {
+        const { name, force } = req.body;
+        if (!name) {
+            res.status(400).json({ error: 'name is required' });
+            return;
+        }
+        await gitDeleteBranch(req.params.id, name, force);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.post('/create-tag', async (req, res) => {
+    try {
+        const { name, commitHash } = req.body;
+        if (!name) {
+            res.status(400).json({ error: 'name is required' });
+            return;
+        }
+        await gitCreateTag(req.params.id, name, commitHash);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.get('/commit-diff', async (req, res) => {
+    try {
+        const hash = req.query.hash;
+        if (!hash) {
+            res.status(400).json({ error: 'hash is required' });
+            return;
+        }
+        const diffs = await gitCommitDiff(req.params.id, hash);
+        res.json(diffs);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.get('/remote-url', async (req, res) => {
+    try {
+        const url = await gitGetRemoteUrl(req.params.id);
+        res.json({ url });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.get('/merge-base', async (req, res) => {
+    try {
+        const hash = await gitMergeBase(req.params.id);
+        res.json({ hash });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.get('/config', async (req, res) => {
+    try {
+        const config = await gitGetConfig('local', req.params.id);
+        res.json(config);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+router.post('/config', async (req, res) => {
+    try {
+        const { name, email, proxy } = req.body;
+        await gitSetConfig('local', { name, email, proxy }, req.params.id);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
 export default router;
 //# sourceMappingURL=git.js.map

package/dist/routes/iframe-bookmarks.js

@@ -0,0 +1,33 @@
+import { Router } from 'express';
+import * as store from '../storage/iframe-bookmarks-store.js';
+const router = Router();
+router.get('/', (_req, res) => {
+    res.json(store.listBookmarks());
+});
+router.post('/', (req, res) => {
+    const { title, url, size } = req.body;
+    if (!title || !url) {
+        res.status(400).json({ error: 'title and url are required' });
+        return;
+    }
+    res.status(201).json(store.addBookmark({ title, url, size }));
+});
+router.put('/:id', (req, res) => {
+    const { title, url, size } = req.body;
+    const updated = store.updateBookmark(req.params.id, { title, url, size });
+    if (!updated) {
+        res.status(404).json({ error: 'bookmark not found' });
+        return;
+    }
+    res.json(updated);
+});
+router.delete('/:id', (req, res) => {
+    const ok = store.removeBookmark(req.params.id);
+    if (!ok) {
+        res.status(404).json({ error: 'bookmark not found' });
+        return;
+    }
+    res.json({ ok: true });
+});
+export default router;
+//# sourceMappingURL=iframe-bookmarks.js.map

package/dist/routes/speech-recognition.js

@@ -0,0 +1,80 @@
+import { Router } from 'express';
+import * as store from '../storage/speech-recognition-store.js';
+import { createSpeechSession } from '../services/speech-recognition/index.js';
+const router = Router();
+// REST: CRUD for speech recognition configs
+router.get('/', (_req, res) => {
+    res.json(store.listSpeechConfigs());
+});
+router.post('/', (req, res) => {
+    const { provider, label, credentials } = req.body;
+    if (!provider || !credentials) {
+        res.status(400).json({ error: 'provider and credentials are required' });
+        return;
+    }
+    const item = store.createSpeechConfig({ provider, label: label || provider, credentials });
+    res.status(201).json(item);
+});
+router.put('/:id', (req, res) => {
+    const { label, credentials } = req.body;
+    const updated = store.updateSpeechConfig(req.params.id, { label, credentials });
+    if (!updated) {
+        res.status(404).json({ error: 'Config not found' });
+        return;
+    }
+    res.json(updated);
+});
+router.delete('/:id', (req, res) => {
+    if (!store.deleteSpeechConfig(req.params.id)) {
+        res.status(404).json({ error: 'Config not found' });
+        return;
+    }
+    res.status(204).end();
+});
+// Export a handler for WebSocket upgrade (speech streaming)
+export async function handleSpeechStream(clientWs, configId) {
+    const config = configId
+        ? store.getSpeechConfig(configId)
+        : store.getDefaultSpeechConfig();
+    if (!config) {
+        clientWs.close(4004, 'No speech recognition config found');
+        return;
+    }
+    try {
+        const session = await createSpeechSession(config);
+        session.onResult((result) => {
+            if (clientWs.readyState === 1) {
+                clientWs.send(JSON.stringify(result));
+            }
+        });
+        session.onError((err) => {
+            if (clientWs.readyState === 1) {
+                clientWs.send(JSON.stringify({ error: err.message }));
+            }
+        });
+        session.onClose(() => {
+            if (clientWs.readyState === 1) {
+                clientWs.close(1000, 'Session ended');
+            }
+        });
+        clientWs.on('message', (data) => {
+            if (Buffer.isBuffer(data)) {
+                session.sendAudio(data);
+            }
+            else {
+                const msg = data.toString();
+                if (msg === '{"type":"end"}' || msg === '{"type":"end"}') {
+                    session.end();
+                }
+            }
+        });
+        clientWs.on('close', () => {
+            session.end();
+        });
+    }
+    catch (err) {
+        clientWs.close(1011, err.message || 'Failed to create speech session');
+    }
+}
+export default router;
+//# sourceMappingURL=speech-recognition.js.map

package/dist/services/agent.js

@@ -9,6 +9,7 @@ import { listChannels, updateChannel } from './channel.js';
 import { ensureDir, getDataDir } from '../storage/json-store.js';
 import { extractUsageFromOutput } from '../storage/usage.js';
 const DEFAULT_AGENT_ROLE = 'agent';
+export const AGENT_GENERATOR_PRESET_ID = 'agent-generator';
 const VALID_RUNTIME_KINDS = ['open-agent-sdk', 'claude-code', 'codex', 'langchain'];
 const VALID_TOOL_NAMES = new Set(BUILT_IN_AGENT_TOOLS.map((tool) => tool.name));
 const ANTHROPIC_BRIDGE_PROVIDERS = [
@@ -24,11 +25,15 @@ export function isValidRole(role) {
 export function listTemplates() {
     const root = getGlobalAgentTemplatesDir();
     if (!existsSync(root))
-        return [];
-    return readdirSync(root, { withFileTypes: true })
+        return [getDefaultAgentGeneratorPreset()];
+    const templates = readdirSync(root, { withFileTypes: true })
         .filter((entry) => entry.isDirectory())
         .map((entry) => readAgentTemplate(entry.name))
         .filter((template) => Boolean(template));
+    if (!templates.some((template) => template.id === AGENT_GENERATOR_PRESET_ID)) {
+        templates.unshift(getDefaultAgentGeneratorPreset());
+    }
+    return templates;
 }
 export async function testConnection(workspaceId, data) {
     if (workspaceId) {
@@ -509,21 +514,57 @@ function ensureWorkspaceAgentCopy(preset, agentspaceDir) {
 }
 export function readAgentTemplate(agentId) {
     const filePath = join(getGlobalAgentTemplateDir(agentId), 'agent.json');
-    if (!existsSync(filePath))
-        return null;
+    if (!existsSync(filePath)) {
+        return agentId === AGENT_GENERATOR_PRESET_ID ? getDefaultAgentGeneratorPreset() : null;
+    }
     try {
         return JSON.parse(readFileSync(filePath, 'utf-8'));
     }
     catch {
-        return null;
+        return agentId === AGENT_GENERATOR_PRESET_ID ? getDefaultAgentGeneratorPreset() : null;
     }
 }
+function getDefaultAgentGeneratorPreset() {
+    return {
+        id: AGENT_GENERATOR_PRESET_ID,
+        name: 'Agent Generator',
+        role: 'agent',
+        description: '根据提示词生成其他 Agent 的名称、描述和 Markdown 系统提示。',
+        runtimeKind: 'claude-code',
+        modelProvider: undefined,
+        modelId: '',
+        apiBase: '',
+        apiKey: '',
+        workingDir: '',
+        mcps: {},
+        skills: [],
+        tools: [],
+        systemPrompt: [
+            '# Role',
+            'You are an Agent Spaces agent designer.',
+            '',
+            '# Responsibilities',
+            '- Convert user requirements into production-ready Agent preset metadata.',
+            '- Return only valid JSON with name, description, and systemPrompt.',
+            '- Write the systemPrompt in clear Markdown with role, responsibilities, workflow, constraints, and output expectations.',
+            '',
+            '# Constraints',
+            '- Do not include Markdown code fences around JSON.',
+            '- Keep names concise and descriptions practical.',
+        ].join('\n'),
+        temperature: 0.2,
+        maxTokens: 4096,
+        enabled: true,
+    };
+}
 function sanitizeMarkdownFilename(name) {
     const raw = basename(name).replace(/\.md$/i, '');
     const safe = raw.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'skill';
     return `${safe}.md`;
 }
 export function deletePreset(workspaceId, presetId) {
+    if (presetId === AGENT_GENERATOR_PRESET_ID)
+        return false;
     const ws = getWorkspace(workspaceId);
     if (!ws)
         return null;
@@ -611,6 +652,8 @@ export function updateGlobalPreset(presetId, data) {
     return updated;
 }
 export function deleteGlobalPreset(presetId) {
+    if (presetId === AGENT_GENERATOR_PRESET_ID)
+        return false;
     const templateDir = getGlobalAgentTemplateDir(presetId);
     if (!existsSync(templateDir))
         return false;