@agent-spaces/server 0.2.5 → 0.2.7

package/dist/adapters/agent-runtime.js

@@ -3,9 +3,11 @@
  */
 import { ClaudeCodeRuntime } from './claude-code-runtime/index.js';
 import { CodexRuntime } from './codex-runtime.js';
+import { LangChainRuntime } from './langchain-runtime.js';
 import { OpenAgentSdkRuntime } from './open-agent-sdk-runtime.js';
 export { ClaudeCodeRuntime } from './claude-code-runtime/index.js';
 export { CodexRuntime } from './codex-runtime.js';
+export { LangChainRuntime } from './langchain-runtime.js';
 export { OpenAgentSdkRuntime } from './open-agent-sdk-runtime.js';
 export function createAgentRuntime(configOrProvider = {}, model) {
     const config = typeof configOrProvider === 'string'
@@ -18,6 +20,8 @@ export function createAgentRuntime(configOrProvider = {}, model) {
             return new ClaudeCodeRuntime(config);
         case 'codex':
             return new CodexRuntime(config);
+        case 'langchain':
+            return new LangChainRuntime(config);
     }
 }
 //# sourceMappingURL=agent-runtime.js.map

package/dist/adapters/langchain-runtime.js

@@ -0,0 +1,207 @@
+import { createAgent, initChatModel, tool } from 'langchain';
+import { z } from 'zod';
+import { summarizeResult } from './agent-runtime-types.js';
+/**
+ * Runtime backed by LangChain.js.
+ * Uses LangChain's provider-neutral createAgent API and adapts Agent Spaces tools.
+ */
+export class LangChainRuntime {
+    config;
+    abortController = null;
+    constructor(config = {}) {
+        this.config = config;
+    }
+    async execute(prompt, workingDir, options) {
+        this.abortController = new AbortController();
+        const output = [];
+        const cwd = workingDir || process.cwd();
+        const startTime = Date.now();
+        const d = (msg) => console.log(`[langchain] ${msg}`);
+        const model = buildModelIdentifier(this.config);
+        d(`starting | cwd=${cwd} provider=${this.config.provider ?? 'auto'} model=${model} baseURL=${this.config.baseURL ?? 'default'} maxTurns=${options?.maxTurns ?? '∞'} tools=${options?.functionTools?.map((runtimeTool) => runtimeTool.name).join(',') || '-'} sandboxDirs=${options?.sandboxDirs?.join(',') ?? '-'}`);
+        d(`prompt: ${prompt.slice(0, 300)}${prompt.length > 300 ? '...' : ''}`);
+        try {
+            const chatModel = await withTemporaryEnv(buildProviderEnv(this.config), () => initChatModel(model, buildModelConfig(this.config)));
+            const agent = createAgent({
+                model: chatModel,
+                tools: buildLangChainTools(options?.functionTools, output, options),
+                systemPrompt: options?.systemPrompt,
+            });
+            const result = await agent.invoke({ messages: [{ role: 'user', content: prompt }] }, {
+                signal: this.abortController?.signal,
+                recursionLimit: options?.maxTurns ? Math.max(2, options.maxTurns * 2 + 1) : undefined,
+            });
+            const text = extractFinalText(result);
+            const usage = extractUsage(result);
+            if (text) {
+                output.push(text);
+                options?.onEvent?.({ type: 'output', line: text });
+            }
+            if (usage?.totalTokens || usage?.inputTokens || usage?.outputTokens) {
+                const usageLine = `[Usage] tokens=${usage.totalTokens ?? '-'} input=${usage.inputTokens ?? '-'} output=${usage.outputTokens ?? '-'}`;
+                output.push(usageLine);
+                options?.onEvent?.({ type: 'output', line: usageLine });
+            }
+            const elapsed = Date.now() - startTime;
+            d(`done ${elapsed}ms | tokens=${usage?.totalTokens ?? 'unknown'}`);
+            return {
+                success: true,
+                summary: summarizeResult(text),
+                artifacts: [],
+                output,
+                usage,
+            };
+        }
+        catch (err) {
+            const elapsed = Date.now() - startTime;
+            const message = err instanceof Error ? err.message : String(err);
+            d(`failed ${elapsed}ms | ${message}`);
+            if (err instanceof Error && err.stack)
+                console.error(err.stack);
+            return { success: false, summary: 'LangChain execution failed', artifacts: [], error: message, output };
+        }
+        finally {
+            this.abortController = null;
+        }
+    }
+    stop() {
+        this.abortController?.abort();
+    }
+}
+function buildLangChainTools(functionTools, output, options) {
+    if (!functionTools?.length)
+        return [];
+    return functionTools.map((runtimeTool) => tool(async (input) => {
+        const line = `Tool: ${runtimeTool.name} input=${JSON.stringify(input)}`;
+        output.push(line);
+        options?.onEvent?.({ type: 'tool_use', id: runtimeTool.name, name: runtimeTool.name, input, line });
+        const result = await runtimeTool.execute(input);
+        options?.onEvent?.({ type: 'tool_result', toolUseId: runtimeTool.name, result });
+        return result;
+    }, {
+        name: runtimeTool.name,
+        description: runtimeTool.description,
+        schema: z.object({}).passthrough(),
+    }));
+}
+function buildModelIdentifier(config) {
+    const model = config.model || 'gpt-4o-mini';
+    const provider = normalizeLangChainProvider(config.provider);
+    if (!provider || model.includes(':'))
+        return model;
+    return `${provider}:${model}`;
+}
+function normalizeLangChainProvider(provider) {
+    switch (provider) {
+        case 'anthropic-messages':
+            return 'anthropic';
+        case 'openai-chat-completions':
+        case 'openai-responses':
+            return 'openai';
+        case 'gemini-generate-content':
+            return 'google-genai';
+        default:
+            return undefined;
+    }
+}
+function buildModelConfig(config) {
+    return removeUndefined({
+        apiKey: config.apiKey,
+        api_key: config.apiKey,
+        baseURL: config.baseURL,
+        baseUrl: config.baseURL,
+        configuration: config.baseURL ? { baseURL: config.baseURL } : undefined,
+    });
+}
+function buildProviderEnv(config) {
+    const provider = normalizeLangChainProvider(config.provider);
+    return {
+        OPENAI_API_KEY: provider === 'openai' ? config.apiKey : undefined,
+        OPENAI_BASE_URL: provider === 'openai' ? config.baseURL : undefined,
+        ANTHROPIC_API_KEY: provider === 'anthropic' ? config.apiKey : undefined,
+        ANTHROPIC_BASE_URL: provider === 'anthropic' ? config.baseURL : undefined,
+        GOOGLE_API_KEY: provider === 'google-genai' ? config.apiKey : undefined,
+        GEMINI_API_KEY: provider === 'google-genai' ? config.apiKey : undefined,
+    };
+}
+async function withTemporaryEnv(env, fn) {
+    const previous = new Map();
+    for (const [key, value] of Object.entries(env)) {
+        if (!value)
+            continue;
+        previous.set(key, process.env[key]);
+        process.env[key] = value;
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        for (const [key, value] of previous) {
+            if (value === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = value;
+            }
+        }
+    }
+}
+function extractFinalText(result) {
+    const messages = isRecord(result) && Array.isArray(result.messages) ? result.messages : [];
+    const last = [...messages].reverse().find((message) => isRecord(message) && getMessageType(message) === 'ai')
+        ?? messages.at(-1);
+    return stringifyMessageContent(isRecord(last) ? last.content : undefined);
+}
+function getMessageType(message) {
+    const getType = message._getType;
+    return typeof getType === 'function' ? getType.call(message) : undefined;
+}
+function stringifyMessageContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return content == null ? '' : JSON.stringify(content);
+    return content
+        .map((part) => {
+        if (typeof part === 'string')
+            return part;
+        if (!isRecord(part))
+            return '';
+        if (typeof part.text === 'string')
+            return part.text;
+        if (typeof part.content === 'string')
+            return part.content;
+        return '';
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+function extractUsage(result) {
+    const messages = isRecord(result) && Array.isArray(result.messages) ? result.messages : [];
+    for (const message of [...messages].reverse()) {
+        if (!isRecord(message))
+            continue;
+        const usage = isRecord(message.usage_metadata)
+            ? message.usage_metadata
+            : isRecord(message.response_metadata) && isRecord(message.response_metadata.tokenUsage)
+                ? message.response_metadata.tokenUsage
+                : undefined;
+        if (!usage)
+            continue;
+        const inputTokens = numberFrom(usage.input_tokens ?? usage.promptTokens ?? usage.prompt_tokens);
+        const outputTokens = numberFrom(usage.output_tokens ?? usage.completionTokens ?? usage.completion_tokens);
+        const totalTokens = numberFrom(usage.total_tokens ?? usage.totalTokens) ?? (inputTokens !== undefined || outputTokens !== undefined ? (inputTokens ?? 0) + (outputTokens ?? 0) : undefined);
+        return removeUndefined({ inputTokens, outputTokens, totalTokens });
+    }
+    return undefined;
+}
+function numberFrom(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object');
+}
+function removeUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+//# sourceMappingURL=langchain-runtime.js.map

package/dist/app.js

@@ -24,6 +24,9 @@ import commandRouter from './routes/command.js';
 import skillRouter from './routes/skill.js';
 import mcpRouter from './routes/mcp.js';
 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 { authMiddleware, verifyToken } from './middleware/auth.js';
 import { handleConnection } from './ws/handler.js';
 import { startScheduler, stopScheduler } from './agents/scheduler-agent.js';
@@ -41,6 +44,7 @@ const app = express();
 const CORS_ORIGIN = process.env.CORS_ORIGIN || '*';
 app.use(cors({ origin: CORS_ORIGIN }));
 app.use(express.json({ limit: '50mb' }));
+app.use('/api/agent-sse', agentSseRouter);
 app.use('/api', authMiddleware);
 // Serve static files from public/
 const publicDir = resolveRuntimeDir('public');
@@ -80,6 +84,8 @@ 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);
+app.use('/api/workspaces/:id/search', searchRouter);
+app.use('/api/workspaces/:id/notifications', notificationRouter);
 app.use('/api/agents', agentRouter);
 app.use('/api', llmRouter);
 app.use('/api/folder', folderRouter);

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-spaces/server",
-  "version": "0.2.4",
+  "version": "0.2.7",
   "type": "module",
   "main": "app.js",
   "packageManager": "pnpm@10.17.1",
@@ -12,11 +12,15 @@
     "@agent-spaces/shared": "file:./shared",
     "@anthropic-ai/claude-agent-sdk": "^0.2.126",
     "@codeany/open-agent-sdk": "^0.2.1",
+    "@langchain/anthropic": "^1.3.29",
+    "@langchain/google-genai": "^2.1.30",
+    "@langchain/openai": "^1.4.5",
     "@larksuiteoapi/node-sdk": "^1.62.1",
     "@openai/codex-sdk": "^0.128.0",
     "cors": "^2.8.5",
     "dotenv": "^17.4.2",
     "express": "^5.1.0",
+    "langchain": "^1.4.0",
     "node-pty": "^1.1.0",
     "simple-git": "^3.36.0",
     "uuid": "^11.1.0",

package/dist/routes/agent-sse.js

@@ -0,0 +1,201 @@
+import { Router } from 'express';
+import { createAgentRuntime } from '../adapters/agent-runtime.js';
+import { verifyToken } from '../middleware/auth.js';
+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';
+const router = Router();
+router.post('/run', async (req, res) => {
+    const body = req.body;
+    if (!verifyRequestKey(req, body)) {
+        res.status(401).json({ error: 'Unauthorized' });
+        return;
+    }
+    const workspaceId = resolveWorkspaceId(body.workspaceId);
+    if (!workspaceId) {
+        res.status(400).json({ error: 'workspaceId is required when no workspace exists' });
+        return;
+    }
+    const workspace = workspaceService.getById(workspaceId);
+    if (!workspace) {
+        res.status(404).json({ error: 'workspace not found' });
+        return;
+    }
+    const agentConfigId = (body.agentId ?? body.agentid)?.trim();
+    if (!agentConfigId) {
+        res.status(400).json({ error: 'agentid is required' });
+        return;
+    }
+    const preset = agentService.listPresets(workspaceId).find((agent) => agent.id === agentConfigId);
+    if (!preset || preset.enabled === false) {
+        res.status(404).json({ error: 'agent preset not found' });
+        return;
+    }
+    const userPrompt = resolveUserPrompt(body);
+    if (!userPrompt) {
+        res.status(400).json({ error: 'message, prompt, or messages is required' });
+        return;
+    }
+    const session = agentService.create(workspaceId, preset.role, preset.id);
+    const startTime = Date.now();
+    const mcpConfig = body.mcps ?? body.mcp ?? preset.mcps;
+    const mcpServers = agentService.getMcpServers(mcpConfig);
+    const requestedSkills = normalizeSkills(body.skills ?? body.skill) ?? preset.skills;
+    const configDir = agentService.getAgentConfigDir(workspaceId, { ...preset, skills: requestedSkills });
+    const skills = agentService.getAvailableSkillNames(configDir, requestedSkills);
+    const output = [];
+    let completed = false;
+    prepareSse(res);
+    writeSse(res, 'session', { session, workspaceId });
+    const runtime = createAgentRuntime({
+        kind: preset.runtimeKind,
+        provider: preset.modelProvider,
+        model: preset.modelId,
+        apiKey: preset.apiKey,
+        baseURL: getRuntimeBaseURL(preset.modelProvider, preset.apiBase),
+        adapterBaseURL: preset.apiBase,
+        ...getThinkingRuntimeConfig(preset),
+    });
+    res.on('close', () => {
+        if (!completed && !res.writableEnded)
+            runtime.stop();
+    });
+    try {
+        agentService.updateStatus(workspaceId, session.id, 'active');
+        writeSse(res, 'status', { agentId: session.id, status: 'active' });
+        const result = await runtime.execute(buildAgentPrompt(workspaceId, body.systemPrompt ?? preset.systemPrompt, userPrompt, normalizeMessages(body.messages), {
+            mcpServers: Object.keys(mcpServers ?? {}),
+            skills,
+            boundDirs: workspace.boundDirs,
+            builtInTools: [],
+        }), agentService.resolveWorkingDir(workspaceId, preset), {
+            maxTurns: normalizeMaxTurns(body.maxTurns),
+            mcpServers,
+            skills,
+            configDir,
+            sandboxDirs: preset.sandboxDirs,
+            onEvent: (event) => {
+                if (event.type === 'output')
+                    output.push(event.line);
+                writeSse(res, event.type, serializeRuntimeEvent(event));
+            },
+        });
+        completed = true;
+        const displayOutput = output.length ? output : result.output;
+        agentService.complete(workspaceId, session.id, result.success ? undefined : result.error, {
+            runtime: preset.runtimeKind,
+            model: preset.modelId,
+            summary: result.summary,
+            output: displayOutput,
+            durationMs: Date.now() - startTime,
+            usage: result.usage,
+            costUsd: result.costUsd,
+        });
+        writeSse(res, 'done', {
+            agentId: session.id,
+            success: result.success,
+            summary: result.summary,
+            artifacts: result.artifacts,
+            error: result.error,
+            output: displayOutput,
+            usage: result.usage,
+            costUsd: result.costUsd,
+            durationMs: Date.now() - startTime,
+        });
+        res.end();
+    }
+    catch (err) {
+        completed = true;
+        const error = err instanceof Error ? err.message : String(err);
+        agentService.complete(workspaceId, session.id, error, {
+            runtime: preset.runtimeKind,
+            model: preset.modelId,
+            summary: error,
+            output: output.length ? output : [error],
+            durationMs: Date.now() - startTime,
+        });
+        writeSse(res, 'error', { agentId: session.id, error });
+        res.end();
+    }
+});
+function verifyRequestKey(req, body) {
+    const auth = req.headers.authorization;
+    const bearer = auth?.startsWith('Bearer ') ? auth.slice(7) : undefined;
+    const headerKey = typeof req.headers['x-agent-spaces-key'] === 'string'
+        ? req.headers['x-agent-spaces-key']
+        : undefined;
+    return verifyToken(body.key ?? bearer ?? headerKey ?? null);
+}
+function resolveWorkspaceId(workspaceId) {
+    const explicit = workspaceId?.trim();
+    if (explicit)
+        return explicit;
+    return workspaceService.getAll()[0]?.id;
+}
+function prepareSse(res) {
+    res.status(200);
+    res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.flushHeaders?.();
+}
+function writeSse(res, event, data) {
+    res.write(`event: ${event}\n`);
+    res.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+function resolveUserPrompt(body) {
+    const direct = body.prompt ?? body.message;
+    if (typeof direct === 'string' && direct.trim())
+        return direct.trim();
+    const messages = normalizeMessages(body.messages);
+    const lastUserMessage = [...messages].reverse().find((message) => message.senderId === 'user');
+    return lastUserMessage?.content?.trim() ?? '';
+}
+function normalizeMessages(messages) {
+    if (!Array.isArray(messages))
+        return [];
+    return messages
+        .filter((message) => message && typeof message.content === 'string')
+        .map((message, index) => ({
+        id: `sse-message-${index}`,
+        channelId: 'sse',
+        senderId: message.senderId ?? 'user',
+        senderRole: message.senderRole,
+        content: message.content,
+        type: 'text',
+        status: message.status ?? 'completed',
+        createdAt: new Date(0).toISOString(),
+        updatedAt: new Date(0).toISOString(),
+        parts: message.parts,
+    }));
+}
+function normalizeSkills(input) {
+    if (!input)
+        return undefined;
+    const values = Array.isArray(input) ? input : [input];
+    return values.map((item) => String(item).trim()).filter(Boolean);
+}
+function normalizeMaxTurns(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.floor(value) : 100;
+}
+function serializeRuntimeEvent(event) {
+    if (event.type === 'tool_use') {
+        return {
+            type: event.type,
+            id: event.id,
+            name: event.name,
+            input: event.input,
+            line: event.line,
+        };
+    }
+    return event;
+}
+function getRuntimeBaseURL(provider, apiBase) {
+    if (provider === 'openai-responses-to-anthropic-messages'
+        || provider === 'openai-chat-completions-to-anthropic-messages')
+        return undefined;
+    return apiBase;
+}
+export default router;
+//# sourceMappingURL=agent-sse.js.map

package/dist/routes/notification.js

@@ -0,0 +1,31 @@
+import { Router } from 'express';
+import * as nc from '../services/notification-center.js';
+const router = Router({ mergeParams: true });
+router.get('/', (req, res) => {
+    const workspaceId = req.params.id;
+    res.json(nc.listNotifications(workspaceId));
+});
+router.put('/:notificationId/read', (req, res) => {
+    const workspaceId = req.params.id;
+    const notificationId = req.params.notificationId;
+    const n = nc.markRead(workspaceId, notificationId);
+    if (!n) {
+        res.status(404).json({ error: 'Not found' });
+        return;
+    }
+    res.json(n);
+});
+router.put('/read-all', (req, res) => {
+    const workspaceId = req.params.id;
+    const notifications = nc.listNotifications(workspaceId);
+    for (const n of notifications)
+        nc.markRead(workspaceId, n.id);
+    res.json({ ok: true });
+});
+router.delete('/', (req, res) => {
+    const workspaceId = req.params.id;
+    nc.clearAll(workspaceId);
+    res.json({ ok: true });
+});
+export default router;
+//# sourceMappingURL=notification.js.map

package/dist/routes/search.js

@@ -0,0 +1,40 @@
+import { Router } from 'express';
+import * as searchService from '../services/search.js';
+import * as fileService from '../services/file.js';
+const router = Router({ mergeParams: true });
+router.get('/code', async (req, res) => {
+    const ws = fileService.getWorkspace(req.params.id);
+    if (!ws) {
+        res.status(404).json({ error: 'Workspace not found' });
+        return;
+    }
+    const q = req.query.q;
+    if (!q) {
+        res.status(400).json({ error: 'q is required' });
+        return;
+    }
+    const results = await searchService.searchCode(ws, {
+        query: q,
+        regex: req.query.regex === 'true',
+        caseSensitive: req.query.caseSensitive === 'true',
+        filePattern: req.query.filePattern || undefined,
+        maxResults: parseInt(req.query.maxResults) || 200,
+    });
+    res.json({ results, total: results.length });
+});
+router.get('/files', async (req, res) => {
+    const ws = fileService.getWorkspace(req.params.id);
+    if (!ws) {
+        res.status(404).json({ error: 'Workspace not found' });
+        return;
+    }
+    const q = req.query.q;
+    if (!q) {
+        res.status(400).json({ error: 'q is required' });
+        return;
+    }
+    const results = await searchService.searchFiles(ws, q);
+    res.json({ results, total: results.length });
+});
+export default router;
+//# sourceMappingURL=search.js.map

package/dist/services/agent.js

@@ -9,7 +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';
-const VALID_RUNTIME_KINDS = ['open-agent-sdk', 'claude-code', 'codex'];
+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 = [
     'openai-responses-to-anthropic-messages',

package/dist/services/notification-center.js

@@ -0,0 +1,52 @@
+import { randomUUID } from 'node:crypto';
+import { readJsonFile, writeJsonFile, ensureDir } from '../storage/json-store.js';
+import { join } from 'node:path';
+import { broadcastToWorkspace } from '../ws/connection-manager.js';
+function notificationsPath(workspaceId) {
+    const dir = join(process.env.AGENT_SPACES_DATA_DIR || join(process.env.HOME || '~', '.agent-spaces-data'), 'workspaces', workspaceId);
+    ensureDir(dir);
+    return join(dir, 'notifications.json');
+}
+function readAll(workspaceId) {
+    return readJsonFile(notificationsPath(workspaceId)) ?? [];
+}
+function writeAll(workspaceId, notifications) {
+    writeJsonFile(notificationsPath(workspaceId), notifications);
+}
+export function listNotifications(workspaceId) {
+    return readAll(workspaceId).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+}
+export function createNotification(workspaceId, type, title, description, data) {
+    const notifications = readAll(workspaceId);
+    const notification = {
+        id: randomUUID(),
+        workspaceId,
+        type,
+        title,
+        description,
+        data,
+        read: false,
+        createdAt: new Date().toISOString(),
+    };
+    notifications.push(notification);
+    writeAll(workspaceId, notifications);
+    broadcastToWorkspace(workspaceId, 'notification.created', notification);
+    return notification;
+}
+export function markRead(workspaceId, notificationId) {
+    const notifications = readAll(workspaceId);
+    const n = notifications.find((n) => n.id === notificationId);
+    if (!n)
+        return null;
+    n.read = true;
+    writeAll(workspaceId, notifications);
+    return n;
+}
+export function clearAll(workspaceId) {
+    writeAll(workspaceId, []);
+    broadcastToWorkspace(workspaceId, 'notification.cleared', null);
+}
+export function unreadCount(workspaceId) {
+    return readAll(workspaceId).filter((n) => !n.read).length;
+}
+//# sourceMappingURL=notification-center.js.map

package/dist/services/notification-hub/events.js

@@ -1,8 +1,10 @@
 import * as issueService from '../issue.js';
 import * as taskService from '../task.js';
+import * as notificationCenter from '../notification-center.js';
 import { adapters } from './types.js';
 import { shouldNotify, isIssueStartStatus, isTaskDoneStatus } from './helpers.js';
 export function publishWorkspaceEvent(workspaceId, wsEvent, data) {
+    persistInAppNotification(workspaceId, wsEvent, data);
     const envelope = buildNotificationEnvelope(workspaceId, wsEvent, data);
     if (!envelope)
         return;
@@ -93,4 +95,34 @@ function buildNotificationEnvelope(workspaceId, wsEvent, data) {
     }
     return null;
 }
+function persistInAppNotification(workspaceId, wsEvent, data) {
+    if (wsEvent === 'issue.status_changed') {
+        const payload = data;
+        if (!payload.issueId)
+            return;
+        const issue = issueService.getById(workspaceId, payload.issueId);
+        if (!issue)
+            return;
+        if (payload.to === 'completed') {
+            notificationCenter.createNotification(workspaceId, 'issue_completed', `议题完成: ${issue.title}`, issue.description || undefined, { issueId: issue.id, status: 'completed' });
+        }
+        else if (payload.to === 'error') {
+            notificationCenter.createNotification(workspaceId, 'issue_failed', `议题失败: ${issue.title}`, issue.description || undefined, { issueId: issue.id, status: 'error' });
+        }
+    }
+    if (wsEvent === 'task.status_changed') {
+        const payload = data;
+        if (!payload.taskId)
+            return;
+        const task = taskService.getById(workspaceId, payload.taskId);
+        if (!task)
+            return;
+        if (payload.to === 'done') {
+            notificationCenter.createNotification(workspaceId, 'task_completed', `任务完成: ${task.title}`, task.description || undefined, { taskId: task.id, issueId: task.issueId, status: 'done' });
+        }
+        else if (payload.to === 'failed') {
+            notificationCenter.createNotification(workspaceId, 'task_failed', `任务失败: ${task.title}`, task.description || undefined, { taskId: task.id, issueId: task.issueId, status: 'failed' });
+        }
+    }
+}
 //# sourceMappingURL=events.js.map