@agent-spaces/server 0.2.7 → 0.2.9

package/dist/agents/agent-message-parts.js

@@ -218,7 +218,7 @@ function buildChainItems(lines, finalTextRange, finalText, workspaceRoot, toolDe
         }
     }
     flushMessageBuffer();
-    return items.slice(0, 40);
+    return items;
 }
 function buildToolTodo(line, index, workspaceRoot, toolDetails, toolDetailMatchCounts) {
     const summary = summarizeToolLine(line, workspaceRoot);

package/dist/app.js

@@ -27,6 +27,7 @@ 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 { getUserSettings, setUserAvatarUrl, removeUserAvatarUrl } from './storage/user-settings-store.js';
 import { authMiddleware, verifyToken } from './middleware/auth.js';
 import { handleConnection } from './ws/handler.js';
 import { startScheduler, stopScheduler } from './agents/scheduler-agent.js';
@@ -50,7 +51,7 @@ app.use('/api', authMiddleware);
 const publicDir = resolveRuntimeDir('public');
 app.use('/public', express.static(publicDir));
 app.get('/api/health', (_req, res) => {
-    res.json({ status: 'ok', timestamp: new Date().toISOString() });
+    res.json({ status: 'ok', timestamp: new Date().toISOString(), platform: process.platform });
 });
 app.use('/api/auth', authRouter);
 // Avatar upload
@@ -75,6 +76,21 @@ app.post('/api/upload/avatar', async (req, res) => {
     await writeFile(join(avatarsDir, name), Buffer.from(base64, 'base64'));
     res.json({ url: `/static/avatars/${name}` });
 });
+// User settings
+app.get('/api/user/settings', (_req, res) => {
+    const settings = getUserSettings();
+    res.json({ avatarUrl: settings.avatarUrl ?? null });
+});
+app.put('/api/user/settings', (req, res) => {
+    const { avatarUrl } = req.body;
+    if (avatarUrl === null || avatarUrl === undefined) {
+        removeUserAvatarUrl();
+    }
+    else if (typeof avatarUrl === 'string') {
+        setUserAvatarUrl(avatarUrl);
+    }
+    res.json({ ok: true });
+});
 app.use('/api/workspaces', workspaceRouter);
 app.use('/api/workspaces/:id/files', fileRouter);
 app.use('/api/workspaces/:id/channels', channelRouter);

package/dist/routes/file.js

@@ -3,6 +3,7 @@ import { exec } from 'child_process';
 import { resolve, join } from 'path';
 import * as fileService from '../services/file.js';
 import { getDataDir } from '../storage/json-store.js';
+const EDITOR_STATE_PATH = '.agentspace/editor-state.json';
 const router = Router({ mergeParams: true });
 router.get('/tree', async (req, res) => {
     const ws = fileService.getWorkspace(req.params.id);
@@ -68,6 +69,43 @@ router.delete('/', async (req, res) => {
     }
     res.json({ ok: true });
 });
+router.get('/editor-state', async (req, res) => {
+    const ws = fileService.getWorkspace(req.params.id);
+    if (!ws) {
+        res.status(404).json({ error: 'Workspace not found' });
+        return;
+    }
+    const result = await fileService.readFileContent(ws, EDITOR_STATE_PATH);
+    if (!result) {
+        res.json({ openFilePaths: [], activeFilePath: null });
+        return;
+    }
+    try {
+        const state = JSON.parse(result.content);
+        res.json(state);
+    }
+    catch {
+        res.json({ openFilePaths: [], activeFilePath: null });
+    }
+});
+router.put('/editor-state', async (req, res) => {
+    const ws = fileService.getWorkspace(req.params.id);
+    if (!ws) {
+        res.status(404).json({ error: 'Workspace not found' });
+        return;
+    }
+    const { openFilePaths, activeFilePath } = req.body;
+    if (!Array.isArray(openFilePaths)) {
+        res.status(400).json({ error: 'openFilePaths is required' });
+        return;
+    }
+    const ok = await fileService.writeFileContent(ws, EDITOR_STATE_PATH, JSON.stringify({ openFilePaths, activeFilePath }, null, 2));
+    if (!ok) {
+        res.status(500).json({ error: 'Failed to save editor state' });
+        return;
+    }
+    res.json({ ok: true });
+});
 router.post('/reveal', async (req, res) => {
     const ws = fileService.getWorkspace(req.params.id);
     if (!ws) {

package/dist/services/message.js

@@ -49,6 +49,31 @@ export function updateMessage(workspaceId, channelId, messageId, data) {
     writeJsonFile(path, messages);
     return updated;
 }
+export function appendMessageReply(workspaceId, channelId, messageId, data) {
+    const path = messageFilePath(workspaceId, channelId);
+    const messages = readJsonFile(path) || [];
+    const index = messages.findIndex((message) => message.id === messageId);
+    if (index === -1)
+        return null;
+    const reply = {
+        id: uuid(),
+        senderId: data.senderId,
+        senderRole: data.senderRole,
+        content: data.content,
+        status: data.status,
+        attachments: data.attachments,
+        parts: data.parts,
+        metadata: data.metadata,
+        createdAt: new Date().toISOString(),
+    };
+    const updated = {
+        ...messages[index],
+        replies: [...(messages[index].replies ?? []), reply],
+    };
+    messages[index] = updated;
+    writeJsonFile(path, messages);
+    return updated;
+}
 export function deleteMessage(workspaceId, channelId, messageId) {
     const path = messageFilePath(workspaceId, channelId);
     const messages = readJsonFile(path) || [];

package/dist/services/pty.js

@@ -1,5 +1,6 @@
 import pty from 'node-pty';
 import { v4 as uuid } from 'uuid';
+const MAX_BUFFER_LINES = 100;
 const sessions = new Map();
 export function createSession(workspaceId, cwd, onOutput, onExit, shell, env) {
     const id = uuid();
@@ -18,9 +19,16 @@ export function createSession(workspaceId, cwd, onOutput, onExit, shell, env) {
         cwd,
         env: ptyEnv,
     });
-    ptyProcess.onData((data) => onOutput(id, data));
+    const session = { id, pty: ptyProcess, workspaceId, cwd, buffer: [] };
+    ptyProcess.onData((data) => {
+        session.buffer.push(data);
+        if (session.buffer.length > MAX_BUFFER_LINES) {
+            session.buffer = session.buffer.slice(-MAX_BUFFER_LINES);
+        }
+        onOutput(id, data);
+    });
     ptyProcess.onExit(({ exitCode }) => onExit(id, exitCode ?? 0));
-    sessions.set(id, { id, pty: ptyProcess, workspaceId, cwd });
+    sessions.set(id, session);
     return id;
 }
 export function write(sessionId, data) {

package/dist/services/workflow.js

@@ -179,7 +179,7 @@ export function mapWorkflowToTaskDrafts(template) {
     }
     return template.nodes.map(node => ({
         key: node.id,
-        title: node.data.taskTitleTemplate || `Execute ${node.data.label}`,
+        title: node.data.taskTitleTemplate || node.data.label,
         description: node.data.taskDescriptionTemplate || `Task assigned to ${node.data.label} (${node.data.role})`,
         agentConfigId: node.data.agentConfigId,
         dependsOnKeys: dependsOn.get(node.id)?.length ? dependsOn.get(node.id) : undefined,

package/dist/storage/user-settings-store.js

@@ -0,0 +1,17 @@
+import { join } from 'node:path';
+import { readJsonFile, writeJsonFile, getDataDir } from './json-store.js';
+const FILE = () => join(getDataDir(), 'user-settings.json');
+export function getUserSettings() {
+    return readJsonFile(FILE()) ?? {};
+}
+export function setUserAvatarUrl(url) {
+    const settings = getUserSettings();
+    settings.avatarUrl = url;
+    writeJsonFile(FILE(), settings);
+}
+export function removeUserAvatarUrl() {
+    const settings = getUserSettings();
+    delete settings.avatarUrl;
+    writeJsonFile(FILE(), settings);
+}
+//# sourceMappingURL=user-settings-store.js.map

package/dist/ws/agent-prompt.js

@@ -42,6 +42,12 @@ function formatConversationHistory(history) {
         if (!text.trim())
             continue;
         lines.push(`[${role}]: ${text}`);
+        for (const reply of msg.replies ?? []) {
+            const replyRole = reply.senderId === 'user' ? 'User' : (reply.senderRole || 'Agent');
+            const replyText = reply.senderId === 'user' ? stripHtml(reply.content) : getReplyFinalMessage(reply);
+            if (replyText.trim())
+                lines.push(`[${replyRole} reply]: ${replyText}`);
+        }
     }
     return lines;
 }
@@ -58,6 +64,19 @@ function getAgentFinalMessage(message) {
         return '';
     return stripToolLikeHistoryLines(stripHtml(message.content));
 }
+function getReplyFinalMessage(reply) {
+    const finalTextParts = reply.parts
+        ?.filter((part) => part.type === 'text')
+        .map((part) => part.text.trim())
+        .filter(Boolean);
+    if (finalTextParts?.length)
+        return finalTextParts.join('\n\n');
+    if (reply.parts?.length)
+        return '';
+    if (reply.status && reply.status !== 'completed')
+        return '';
+    return stripToolLikeHistoryLines(stripHtml(reply.content));
+}
 function stripToolLikeHistoryLines(content) {
     const kept = content.split(/\r?\n/).filter((line) => {
         const trimmed = line.trim();

package/dist/ws/agent-runner.js

@@ -239,13 +239,14 @@ export async function runMentionedAgent(workspaceId, channelId, agentConfigId, p
                 askUserQuestions,
                 success: true,
             });
-            if (parts.length === 0)
+            const displayParts = buildContinuationParts(existingMessage?.parts, session.id, options.appendUserMessage, parts);
+            if (displayParts.length === 0)
                 return;
             const status = askUserQuestions.some((question) => !question.answer) ? 'waiting_for_user' : 'streaming';
             const live = updateMessage(workspaceId, channelId, pending.id, {
                 content: liveOutput.join('\n') || pending.content,
                 status,
-                parts,
+                parts: displayParts,
                 metadata: {
                     ...pending.metadata,
                     duration: Date.now() - startTime,
@@ -354,6 +355,21 @@ export async function runMentionedAgent(workspaceId, channelId, agentConfigId, p
         const displayOutput = mergeRuntimeOutput(liveOutput, result.output);
         if (shouldWaitForUserAnswer(askUserQuestions, result.summary, result.error, displayOutput)) {
             const waitingOutput = stripAskUserQuestionErrorLines(liveOutput);
+            const waitingParts = buildContinuationParts(existingMessage?.parts, session.id, options.appendUserMessage, buildAgentMessageParts({
+                sessionId: session.id,
+                workspaceRoot: workspace?.boundDirs?.[0],
+                presetName: preset.name || preset.role,
+                role: preset.role,
+                model: preset.modelId,
+                systemPrompt: preset.systemPrompt,
+                mcpServers: Object.keys(mcpServers ?? {}),
+                skills,
+                output: waitingOutput,
+                reasoning: liveReasoning,
+                toolDetails,
+                askUserQuestions,
+                success: true,
+            }));
             const waiting = updateMessage(workspaceId, channelId, pending.id, {
                 content: waitingOutput.join('\n') || pending.content,
                 type: 'text',
@@ -365,21 +381,7 @@ export async function runMentionedAgent(workspaceId, channelId, agentConfigId, p
                     summary: 'Waiting for user answer',
                     duration: Date.now() - startTime,
                 },
-                parts: buildAgentMessageParts({
-                    sessionId: session.id,
-                    workspaceRoot: workspace?.boundDirs?.[0],
-                    presetName: preset.name || preset.role,
-                    role: preset.role,
-                    model: preset.modelId,
-                    systemPrompt: preset.systemPrompt,
-                    mcpServers: Object.keys(mcpServers ?? {}),
-                    skills,
-                    output: waitingOutput,
-                    reasoning: liveReasoning,
-                    toolDetails,
-                    askUserQuestions,
-                    success: true,
-                }),
+                parts: waitingParts,
             });
             if (waiting)
                 broadcastToWorkspace(workspaceId, 'channel.message.updated', waiting);
@@ -415,6 +417,24 @@ export async function runMentionedAgent(workspaceId, channelId, agentConfigId, p
             },
             error: result.error,
         });
+        const replyParts = buildContinuationParts(existingMessage?.parts, session.id, options.appendUserMessage, buildAgentMessageParts({
+            sessionId: session.id,
+            workspaceRoot: workspace?.boundDirs?.[0],
+            presetName: preset.name || preset.role,
+            role: preset.role,
+            model: preset.modelId,
+            usage: result.usage,
+            systemPrompt: preset.systemPrompt,
+            mcpServers: Object.keys(mcpServers ?? {}),
+            skills,
+            builtInTools: buildBuiltInTools(functionTools, channel, issue),
+            output: displayOutput,
+            reasoning: liveReasoning,
+            toolDetails,
+            askUserQuestions,
+            success: result.success,
+            error: result.error,
+        }));
         const reply = updateMessage(workspaceId, channelId, pending.id, {
             content: result.success ? displayOutput.join('\n') : result.error || displayOutput.join('\n'),
             type: 'text',
@@ -426,24 +446,7 @@ export async function runMentionedAgent(workspaceId, channelId, agentConfigId, p
                 summary: result.summary,
                 duration: Date.now() - startTime,
             },
-            parts: buildAgentMessageParts({
-                sessionId: session.id,
-                workspaceRoot: workspace?.boundDirs?.[0],
-                presetName: preset.name || preset.role,
-                role: preset.role,
-                model: preset.modelId,
-                usage: result.usage,
-                systemPrompt: preset.systemPrompt,
-                mcpServers: Object.keys(mcpServers ?? {}),
-                skills,
-                builtInTools: buildBuiltInTools(functionTools, channel, issue),
-                output: displayOutput,
-                reasoning: liveReasoning,
-                toolDetails,
-                askUserQuestions,
-                success: result.success,
-                error: result.error,
-            }),
+            parts: replyParts,
         });
         if (reply)
             broadcastToWorkspace(workspaceId, 'channel.message.updated', reply);
@@ -460,6 +463,23 @@ export async function runMentionedAgent(workspaceId, channelId, agentConfigId, p
             durationMs: Date.now() - startTime,
         });
         broadcastToWorkspace(workspaceId, 'agent.error', { agentId: session.id, error });
+        const errorParts = buildContinuationParts(existingMessage?.parts, session.id, options.appendUserMessage, buildAgentMessageParts({
+            sessionId: session.id,
+            workspaceRoot: workspace?.boundDirs?.[0],
+            presetName: preset.name || preset.role,
+            role: preset.role,
+            model: preset.modelId,
+            systemPrompt: preset.systemPrompt,
+            mcpServers: Object.keys(mcpServers ?? {}),
+            skills,
+            builtInTools: buildBuiltInTools(functionTools, channel, issue),
+            output: [error],
+            reasoning: liveReasoning,
+            toolDetails: new Map(),
+            askUserQuestions: [],
+            success: false,
+            error,
+        }));
         const reply = updateMessage(workspaceId, channelId, pending.id, {
             content: error,
             type: 'text',
@@ -470,23 +490,7 @@ export async function runMentionedAgent(workspaceId, channelId, agentConfigId, p
                 model: preset.modelId,
                 duration: Date.now() - startTime,
             },
-            parts: buildAgentMessageParts({
-                sessionId: session.id,
-                workspaceRoot: workspace?.boundDirs?.[0],
-                presetName: preset.name || preset.role,
-                role: preset.role,
-                model: preset.modelId,
-                systemPrompt: preset.systemPrompt,
-                mcpServers: Object.keys(mcpServers ?? {}),
-                skills,
-                builtInTools: buildBuiltInTools(functionTools, channel, issue),
-                output: [error],
-                reasoning: liveReasoning,
-                toolDetails: new Map(),
-                askUserQuestions: [],
-                success: false,
-                error,
-            }),
+            parts: errorParts,
         });
         if (reply)
             broadcastToWorkspace(workspaceId, 'channel.message.updated', reply);
@@ -535,6 +539,17 @@ function untrackChannelRun(workspaceId, channelId, agentId) {
     if (runs.size === 0)
         activeChannelRuns.delete(key);
 }
+function buildContinuationParts(previousParts, sessionId, userMessage, nextParts) {
+    if (!userMessage)
+        return nextParts;
+    const appended = [{
+            id: `user-message-${sessionId}`,
+            type: 'user_message',
+            text: userMessage,
+            senderName: '用户',
+        }, ...nextParts];
+    return [...(previousParts ?? []), ...appended];
+}
 function questionRunKey(workspaceId, channelId, messageId, questionId) {
     return `${workspaceId}:${channelId}:${messageId}:${questionId}`;
 }

package/dist/ws/handler.js

@@ -1,6 +1,7 @@
 import { addConnection, broadcastToWorkspace } from './connection-manager.js';
 import { handleTerminalEvent } from './terminal-handler.js';
-import { createMessage } from '../services/message.js';
+import * as ptyService from '../services/pty.js';
+import { appendMessageReply, createMessage } from '../services/message.js';
 import { getChannel } from '../services/channel.js';
 import * as agentService from '../services/agent.js';
 import { runMentionedAgent, stopChannelRuns, handleAnswerQuestion, ensureScheduler, makeContext } from './agent-runner.js';
@@ -19,6 +20,16 @@ export function handleConnection(ws, workspaceId) {
         timestamp: new Date().toISOString(),
         data: { workspaceId },
     }));
+    // Send existing terminal sessions for reconnection
+    const existingSessions = ptyService.getSessionsByWorkspace(workspaceId);
+    ws.send(JSON.stringify({
+        event: 'terminal.sessions',
+        workspaceId,
+        timestamp: new Date().toISOString(),
+        data: {
+            sessions: existingSessions.map(s => ({ sessionId: s.id, cwd: s.cwd, buffer: s.buffer.join('') })),
+        },
+    }));
     ws.on('message', (raw) => {
         try {
             const msg = JSON.parse(raw.toString());
@@ -49,11 +60,29 @@ for (const evt of terminalEvents) {
 }
 // Register channel handlers
 registerHandler('channel.message', (_ws, workspaceId, data) => {
-    const { channelId, content, type, mentions, attachments } = data;
+    const { channelId, content, type, mentions, attachments, replyToMessageId } = data;
     if (!channelId || (!content && !attachments?.length))
         return;
     if (!getChannel(workspaceId, channelId))
         return;
+    if (replyToMessageId) {
+        const updated = appendMessageReply(workspaceId, channelId, replyToMessageId, {
+            senderId: 'user',
+            content,
+            attachments,
+        });
+        if (!updated)
+            return;
+        broadcastToWorkspace(workspaceId, 'channel.message.updated', updated);
+        const agentId = updated.senderId !== 'user' ? updated.senderId : undefined;
+        if (agentId) {
+            void runMentionedAgent(workspaceId, channelId, agentId, stripHtml(content), {
+                messageId: updated.id,
+                appendUserMessage: stripHtml(content),
+            });
+        }
+        return;
+    }
     const message = createMessage(workspaceId, channelId, {
         senderId: 'user',
         content,

package/dist/ws/message-parts.js

@@ -254,7 +254,7 @@ function buildChainItems(lines, finalTextRange, finalText, workspaceRoot, toolDe
         }
     }
     flushMessageBuffer();
-    return items.slice(0, 40);
+    return items;
 }
 function buildToolTodo(line, index, workspaceRoot, toolDetails, toolDetailMatchCounts) {
     const summary = summarizeToolLine(line, workspaceRoot);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-spaces/server",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "type": "module",
   "bin": {
     "agent-spaces-server": "./dist/app.js"
@@ -14,15 +14,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "dev": "tsx watch src/app.ts",
-    "build": "tsc",
-    "start": "node dist/app.js",
-    "prepublishOnly": "pnpm build",
-    "postinstall": "node -e \"try{require('node-pty')}catch(e){if(!require('fs').existsSync('node_modules/node-pty/prebuilds')){process.exit(1)}}\""
-  },
   "dependencies": {
-    "@agent-spaces/shared": "workspace:*",
     "@anthropic-ai/claude-agent-sdk": "^0.2.126",
     "@codeany/open-agent-sdk": "^0.2.1",
     "@langchain/anthropic": "^1.3.29",
@@ -38,7 +30,8 @@
     "simple-git": "^3.36.0",
     "uuid": "^11.1.0",
     "ws": "^8.18.2",
-    "zod": "^4.0.0"
+    "zod": "^4.0.0",
+    "@agent-spaces/shared": "0.2.1"
   },
   "devDependencies": {
     "@types/cors": "^2.8.17",
@@ -48,5 +41,11 @@
     "@types/ws": "^8.18.1",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "dev": "tsx watch src/app.ts",
+    "build": "tsc",
+    "start": "node dist/app.js",
+    "postinstall": "node -e \"try{require('node-pty')}catch(e){if(!require('fs').existsSync('node_modules/node-pty/prebuilds')){process.exit(1)}}\""
   }
-}
+}