@agent-spaces/server 0.3.62 → 0.3.64

package/dist/services/database-vector.js

@@ -0,0 +1,244 @@
+import { createHash } from 'node:crypto';
+import * as databaseStore from '../storage/database-store.js';
+import * as llmStore from '../storage/llm-store.js';
+const INDEX_BATCH_SIZE = 16;
+const MAX_INDEX_TEXT_LENGTH = 24_000;
+export class DatabaseVectorError extends Error {
+    debug;
+    constructor(message, debug) {
+        super(message);
+        this.name = 'DatabaseVectorError';
+        this.debug = debug;
+    }
+}
+export async function indexDatabaseVectors(workspaceId, databaseId) {
+    const database = databaseStore.getDatabase(workspaceId, databaseId);
+    if (!database)
+        throw new Error(`Database not found: ${databaseId}`);
+    if (!database.embeddingModelId)
+        throw new Error('Embedding model is not bound to this database.');
+    const config = requireEmbeddingModelConfig(database.embeddingModelId);
+    const nodes = databaseStore.listNodes(workspaceId, databaseId).filter((node) => !node.isTrash);
+    const records = nodes
+        .map((node) => ({
+        node,
+        path: buildDatabaseNodePath(node, nodes),
+        text: normalizeIndexText(`${node.title}\n${stripHtml(node.content)}`),
+    }))
+        .filter((item) => item.text.length > 0);
+    let indexedCount = 0;
+    for (let index = 0; index < records.length; index += INDEX_BATCH_SIZE) {
+        const batch = records.slice(index, index + INDEX_BATCH_SIZE);
+        const batchDebug = {
+            batchStart: index,
+            batchSize: batch.length,
+            indexedCount,
+        };
+        console.info('[database-vector:index] embedding batch', {
+            workspaceId,
+            databaseId,
+            modelId: config.model.modelId,
+            providerName: config.provider.name,
+            ...batchDebug,
+            inputLengths: batch.map((item) => item.text.length),
+        });
+        const embeddings = await embedTexts(config, batch.map((item) => item.text), batchDebug);
+        embeddings.forEach((embedding, offset) => {
+            const item = batch[offset];
+            databaseStore.upsertDatabaseEmbedding(workspaceId, databaseId, {
+                nodeId: item.node.id,
+                title: item.node.title,
+                path: item.path,
+                content: item.text,
+                contentHash: hashText(item.text),
+                embedding,
+                modelId: config.model.modelId,
+                agentId: config.model.id,
+            });
+            indexedCount++;
+        });
+    }
+    databaseStore.deleteStaleDatabaseEmbeddings(workspaceId, databaseId, records.map((item) => item.node.id));
+    return {
+        ...databaseStore.getVectorStats(workspaceId, databaseId),
+        indexedCount,
+        skippedCount: nodes.length - records.length,
+    };
+}
+export async function searchDatabaseVectors(workspaceId, databaseId, query, limit = 5) {
+    const database = databaseStore.getDatabase(workspaceId, databaseId);
+    if (!database)
+        throw new Error(`Database not found: ${databaseId}`);
+    if (!database.embeddingModelId)
+        throw new Error('Embedding model is not bound to this database.');
+    const cleanQuery = normalizeIndexText(query);
+    if (!cleanQuery)
+        throw new Error('query is required.');
+    const config = requireEmbeddingModelConfig(database.embeddingModelId);
+    const [queryEmbedding] = await embedTexts(config, [cleanQuery]);
+    return databaseStore.listDatabaseEmbeddings(workspaceId, databaseId)
+        .map((row) => ({
+        nodeId: row.nodeId,
+        title: row.title,
+        path: row.path,
+        content: row.content,
+        updatedAt: row.updatedAt,
+        score: cosineSimilarity(queryEmbedding, row.embedding),
+    }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, Math.max(1, Math.min(limit, 20)));
+}
+function requireEmbeddingModelConfig(modelId) {
+    const model = llmStore.getModel(modelId);
+    if (!model)
+        throw new Error(`Embedding model not found: ${modelId}`);
+    if (!model.embedding)
+        throw new Error(`Selected model is not marked as an embedding model: ${model.name}`);
+    const provider = llmStore.listProviders().find((item) => item.name === model.provider);
+    if (!provider)
+        throw new Error(`Provider not found for embedding model: ${model.provider}`);
+    if (!provider.apiBase || !provider.apiKey || !model.modelId) {
+        throw new Error(`Embedding provider is missing apiBase, apiKey, or modelId: ${provider.name}`);
+    }
+    return { model, provider };
+}
+async function embedTexts(config, input, extraDebug = {}) {
+    const requestUrl = getEmbeddingsUrl(config.provider.apiBase);
+    const requestDebug = {
+        stage: 'embedding_request',
+        providerName: config.provider.name,
+        modelId: config.model.modelId,
+        requestUrl,
+        inputCount: input.length,
+        inputLengths: input.map((item) => item.length),
+        ...extraDebug,
+    };
+    console.info('[database-vector:embed] request', requestDebug);
+    const response = await fetch(requestUrl, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${config.provider.apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            model: config.model.modelId,
+            input,
+        }),
+    });
+    const responseText = await response.text();
+    const responseDebugBase = {
+        ...requestDebug,
+        stage: 'embedding_response',
+        status: response.status,
+        responseContentType: response.headers.get('content-type'),
+    };
+    if (!response.ok) {
+        const debug = {
+            ...responseDebugBase,
+            responsePreview: responseText.slice(0, 1000),
+        };
+        console.warn('[database-vector:embed] failed response', debug);
+        throw new DatabaseVectorError(`Embedding request failed with status ${response.status}`, debug);
+    }
+    let data;
+    try {
+        data = JSON.parse(responseText);
+    }
+    catch {
+        const debug = {
+            ...responseDebugBase,
+            stage: 'embedding_parse_json',
+            responsePreview: responseText.slice(0, 1000),
+        };
+        console.warn('[database-vector:embed] invalid json', debug);
+        throw new DatabaseVectorError('Embedding response is not valid JSON.', debug);
+    }
+    const responseData = isRecord(data) && Array.isArray(data.data) ? data.data : undefined;
+    const embeddings = responseData
+        ?.map((item) => isRecord(item) ? item.embedding : undefined)
+        .filter((item) => Array.isArray(item) && item.every((value) => typeof value === 'number'));
+    const debug = {
+        ...responseDebugBase,
+        responseDataCount: responseData?.length,
+        validEmbeddingCount: embeddings?.length ?? 0,
+        embeddingDimensions: embeddings?.map((embedding) => embedding.length).slice(0, 10),
+        responseKeys: isRecord(data) ? Object.keys(data) : undefined,
+        responsePreview: previewEmbeddingResponse(data),
+    };
+    console.info('[database-vector:embed] parsed response', debug);
+    if (!embeddings || embeddings.length !== input.length) {
+        throw new DatabaseVectorError(`Embedding response does not match input length. expected=${input.length}, data=${responseData?.length ?? 0}, validEmbeddings=${embeddings?.length ?? 0}`, debug);
+    }
+    return embeddings;
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function previewEmbeddingResponse(value) {
+    if (!isRecord(value))
+        return value;
+    const data = Array.isArray(value.data)
+        ? value.data.slice(0, 3).map((item) => {
+            if (!isRecord(item))
+                return item;
+            const embedding = Array.isArray(item.embedding) ? item.embedding : undefined;
+            return {
+                ...item,
+                embedding: embedding ? `[number[${embedding.length}]]` : item.embedding,
+            };
+        })
+        : value.data;
+    return {
+        ...value,
+        data,
+    };
+}
+function getEmbeddingsUrl(apiBase) {
+    const base = apiBase.replace(/\/+$/, '');
+    if (base.endsWith('/embeddings'))
+        return base;
+    return `${base}/embeddings`;
+}
+function normalizeIndexText(text) {
+    return text.replace(/\s+/g, ' ').trim().slice(0, MAX_INDEX_TEXT_LENGTH);
+}
+function stripHtml(content) {
+    return content
+        .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<[^>]+>/g, ' ');
+}
+function hashText(text) {
+    return createHash('sha256').update(text).digest('hex');
+}
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length || a.length === 0)
+        return 0;
+    let dot = 0;
+    let ma = 0;
+    let mb = 0;
+    for (let index = 0; index < a.length; index++) {
+        dot += a[index] * b[index];
+        ma += a[index] * a[index];
+        mb += b[index] * b[index];
+    }
+    if (!ma || !mb)
+        return 0;
+    return dot / (Math.sqrt(ma) * Math.sqrt(mb));
+}
+function buildDatabaseNodePath(node, nodes) {
+    const byId = new Map(nodes.map((item) => [item.id, item]));
+    const parts = [node.title || node.id];
+    let parentId = node.parentId;
+    let guard = 0;
+    while (parentId && guard < 100) {
+        const parent = byId.get(parentId);
+        if (!parent)
+            break;
+        parts.unshift(parent.title || parent.id);
+        parentId = parent.parentId;
+        guard++;
+    }
+    return `/${parts.join('/')}`;
+}
+//# sourceMappingURL=database-vector.js.map

package/dist/services/hook-engine.js

@@ -0,0 +1,118 @@
+import { exec } from 'node:child_process';
+import { listHooks } from '../storage/hook-store.js';
+function matchToolName(matcher, toolName) {
+    if (matcher === '*')
+        return true;
+    if (matcher.startsWith('/') && matcher.endsWith('/')) {
+        try {
+            const regex = new RegExp(matcher.slice(1, -1));
+            return regex.test(toolName);
+        }
+        catch {
+            return matcher === toolName;
+        }
+    }
+    return matcher === toolName;
+}
+function executeCommand(command, env, timeout) {
+    return new Promise((resolve) => {
+        exec(command, { env: { ...process.env, ...env }, timeout: Math.min(timeout, 30000) }, (error) => {
+            if (error)
+                console.warn(`[HookEngine] command error: ${error.message}`);
+            resolve();
+        });
+    });
+}
+async function executeWebhook(url, body, timeout) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), Math.min(timeout, 30000));
+        await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+    }
+    catch (error) {
+        console.warn(`[HookEngine] webhook error: ${error.message}`);
+    }
+}
+async function executeRule(rule, phase, toolName, workspaceId, context) {
+    const timeout = rule.timeout ?? 10000;
+    if (rule.type === 'command' && rule.command) {
+        await executeCommand(rule.command, {
+            HOOK_TOOL_NAME: toolName,
+            HOOK_TOOL_INPUT: JSON.stringify(context.toolInput ?? {}),
+            HOOK_TOOL_RESULT: JSON.stringify(context.toolResult ?? ''),
+            HOOK_WORKSPACE_ID: workspaceId,
+            HOOK_PHASE: phase,
+        }, timeout);
+    }
+    else if (rule.type === 'webhook' && rule.url) {
+        await executeWebhook(rule.url, {
+            event: phase,
+            toolName,
+            toolInput: context.toolInput,
+            toolResult: context.toolResult ?? undefined,
+            timestamp: new Date().toISOString(),
+            workspaceId,
+        }, timeout);
+    }
+    else if (rule.type === 'script') {
+        console.warn(`[HookEngine] script type not implemented, skipping rule in ${phase}`);
+    }
+}
+export class HookEngine {
+    hooks = [];
+    workspaceId;
+    constructor(workspaceId) {
+        this.workspaceId = workspaceId;
+    }
+    load() {
+        this.hooks = listHooks(this.workspaceId);
+    }
+    reload() {
+        this.load();
+    }
+    getHooks() {
+        return this.hooks;
+    }
+    async executeHooks(phase, toolName, context) {
+        const enabledHooks = this.hooks.filter(h => h.enabled);
+        const promises = [];
+        for (const hook of enabledHooks) {
+            const rules = hook.hooks[phase];
+            if (!rules)
+                continue;
+            for (const rule of rules) {
+                if (matchToolName(rule.matcher, toolName)) {
+                    promises.push(executeRule(rule, phase, toolName, this.workspaceId, context));
+                }
+            }
+        }
+        await Promise.allSettled(promises);
+    }
+}
+export function wrapOnEventWithHooks(onEvent, workspaceId, hooksEnabled) {
+    if (!hooksEnabled)
+        return onEvent;
+    const engine = new HookEngine(workspaceId);
+    engine.load();
+    const toolNameById = new Map();
+    return (event) => {
+        onEvent(event);
+        if (event.type === 'tool_use') {
+            toolNameById.set(event.id, event.name);
+            engine.executeHooks('PreToolUse', event.name, { toolInput: event.input });
+        }
+        if (event.type === 'tool_result') {
+            const toolName = event.toolUseId ? (toolNameById.get(event.toolUseId) ?? '') : '';
+            if (toolName) {
+                engine.executeHooks('PostToolUse', toolName, { toolResult: event.result });
+            }
+        }
+    };
+}
+//# sourceMappingURL=hook-engine.js.map

package/dist/services/issue.js

@@ -35,6 +35,10 @@ function ensureRetryDefaults(workspaceId, issue) {
         issue.maxRetries = 3;
         changed = true;
     }
+    if (issue.continuousRun === undefined) {
+        issue.continuousRun = true;
+        changed = true;
+    }
     if (changed)
         updateIssue({ ...issue, workspaceId });
 }
@@ -70,6 +74,7 @@ export function create(workspaceId, input) {
         tasks: [],
         members: input.members || [],
         workflowId: input.workflowId,
+        continuousRun: true,
         retryCount: 0,
         maxRetries: 3,
         createdAt: now,
@@ -94,6 +99,7 @@ export function createForChannel(workspaceId, channelId, input) {
         status: input.status ?? 'draft',
         tasks: [],
         members: [...issueMembers],
+        continuousRun: true,
         retryCount: 0,
         maxRetries: 3,
         createdAt: now,

package/dist/services/kanban.js

@@ -0,0 +1,50 @@
+import * as store from '../storage/kanban-store.js';
+export function getBoard(workspaceId) {
+    return store.getBoard(workspaceId);
+}
+export function ensureBoard(workspaceId) {
+    let board = store.getBoard(workspaceId);
+    if (!board) {
+        board = store.createBoard(workspaceId);
+        const defaultColumns = [
+            { id: 'todo', title: 'To Do', color: 'sky', order: 0 },
+            { id: 'progress', title: 'In Progress', color: 'amber', order: 1 },
+            { id: 'done', title: 'Done', color: 'emerald', order: 2 },
+            { id: 'archive', title: 'Archive', color: 'slate', order: 3 },
+        ];
+        store.saveColumns(board.id, defaultColumns);
+        board = store.getBoard(workspaceId);
+    }
+    return board;
+}
+export function updateBoard(workspaceId, updates) {
+    return store.updateBoard(workspaceId, updates);
+}
+export function saveColumns(workspaceId, columns) {
+    const board = store.getBoard(workspaceId);
+    if (!board)
+        return null;
+    store.saveColumns(board.id, columns);
+    return store.getBoard(workspaceId);
+}
+export function saveTasks(workspaceId, tasks) {
+    const board = store.getBoard(workspaceId);
+    if (!board)
+        return null;
+    store.saveTasks(board.id, tasks);
+    return store.getBoard(workspaceId);
+}
+export function saveBoard(workspaceId, data) {
+    let board = store.getBoard(workspaceId);
+    if (!board)
+        board = store.createBoard(workspaceId);
+    if (data.title || data.layoutMode) {
+        store.updateBoard(workspaceId, { title: data.title, layoutMode: data.layoutMode });
+    }
+    if (data.columns)
+        store.saveColumns(board.id, data.columns);
+    if (data.tasks)
+        store.saveTasks(board.id, data.tasks);
+    return store.getBoard(workspaceId);
+}
+//# sourceMappingURL=kanban.js.map

package/dist/services/notification-hub/bot-agent.js

@@ -41,6 +41,7 @@ export async function runBotAgent(workspaceId, preset, message) {
             configDir: agentService.getAgentConfigDir(workspaceId, preset),
             sandboxDirs: preset.sandboxDirs,
             systemPrompt: preset.systemPrompt,
+            outputStyle: preset.outputStyle,
         });
         agentService.complete(workspaceId, session.id, result.success ? undefined : result.error || result.summary, {
             runtime: preset.runtimeKind,

package/dist/services/output-style.js

@@ -0,0 +1,134 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { ensureDir, getDataDir } from '../storage/json-store.js';
+import { listTemplates } from './agent.js';
+function getDir() {
+    return join(getDataDir(), 'output-styles');
+}
+function getMetaPath() {
+    return join(getDir(), 'meta.json');
+}
+function readMeta() {
+    const path = getMetaPath();
+    if (!existsSync(path))
+        return { templates: [] };
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return { templates: [] };
+    }
+}
+function writeMeta(meta) {
+    ensureDir(getDir());
+    writeFileSync(getMetaPath(), JSON.stringify(meta, null, 2), 'utf-8');
+}
+export function listOutputStyles() {
+    return readMeta().templates;
+}
+export function resolveOutputStyleTemplate(ref) {
+    const needle = sanitizeOutputStyleName(ref);
+    if (!needle)
+        return null;
+    return listOutputStyles().find((template) => template.id === ref?.trim()
+        || template.name === ref?.trim()
+        || sanitizeOutputStyleName(template.name) === needle) ?? null;
+}
+export function resolveOutputStyleContent(ref) {
+    const raw = ref?.trim();
+    if (!raw)
+        return undefined;
+    return resolveOutputStyleTemplate(raw)?.content ?? raw;
+}
+export function prepareClaudeOutputStyleFile(configDir, ref) {
+    const raw = ref?.trim();
+    if (!raw)
+        return undefined;
+    const template = resolveOutputStyleTemplate(raw);
+    const content = template?.content ?? raw;
+    const fileStem = sanitizeOutputStyleName(template?.name) || `output-style-${shortHash(content)}`;
+    if (!fileStem)
+        return undefined;
+    const dir = join(configDir, 'output_styles');
+    rmSync(dir, { recursive: true, force: true });
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, `${fileStem}.md`), `${content.trimEnd()}\n`, 'utf-8');
+    return fileStem;
+}
+export function createOutputStyle(name, content, storeId, description) {
+    const meta = readMeta();
+    const now = new Date().toISOString();
+    const id = `os-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const tmpl = { id, name, description, content, storeId, createdAt: now, updatedAt: now };
+    meta.templates.push(tmpl);
+    writeMeta(meta);
+    return tmpl;
+}
+export function updateOutputStyle(id, data) {
+    const meta = readMeta();
+    const tmpl = meta.templates.find((t) => t.id === id);
+    if (!tmpl)
+        return null;
+    if (data.name !== undefined)
+        tmpl.name = data.name;
+    if (data.description !== undefined)
+        tmpl.description = data.description;
+    if (data.content !== undefined)
+        tmpl.content = data.content;
+    tmpl.updatedAt = new Date().toISOString();
+    writeMeta(meta);
+    return tmpl;
+}
+export function deleteOutputStyle(id) {
+    const meta = readMeta();
+    const idx = meta.templates.findIndex((t) => t.id === id);
+    if (idx < 0)
+        return false;
+    meta.templates.splice(idx, 1);
+    writeMeta(meta);
+    return true;
+}
+export function applyOutputStyleToAgents(styleId, agentIds) {
+    const meta = readMeta();
+    const tmpl = meta.templates.find((t) => t.id === styleId);
+    if (!tmpl)
+        return 0;
+    const agents = listTemplates();
+    let applied = 0;
+    for (const agentId of agentIds) {
+        const agent = agents.find((a) => a.id === agentId);
+        if (!agent)
+            continue;
+        const agentDir = join(getDataDir(), 'agent-templates', agent.id);
+        const agentPath = join(agentDir, 'agent.json');
+        if (!existsSync(agentPath))
+            continue;
+        const config = JSON.parse(readFileSync(agentPath, 'utf-8'));
+        config.outputStyle = tmpl.name;
+        writeFileSync(agentPath, JSON.stringify(config, null, 2), 'utf-8');
+        applied++;
+    }
+    return applied;
+}
+export function listOutputStyleAgentCandidates() {
+    return listTemplates()
+        .filter((a) => a.id !== 'agent-generator')
+        .map((a) => ({
+        id: a.id,
+        name: a.name || a.id,
+        avatarUrl: a.avatarUrl,
+        description: a.description,
+        hasOutputStyle: !!a.outputStyle,
+    }));
+}
+function sanitizeOutputStyleName(name) {
+    const raw = name?.trim();
+    if (!raw)
+        return '';
+    return basename(raw).replace(/\.md$/i, '').replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+}
+function shortHash(text) {
+    return createHash('sha1').update(text).digest('hex').slice(0, 8);
+}
+//# sourceMappingURL=output-style.js.map

package/dist/services/prompt-template.js

@@ -26,11 +26,11 @@ function writeMeta(meta) {
 export function listPromptTemplates() {
     return readMeta().templates;
 }
-export function createPromptTemplate(name, content) {
+export function createPromptTemplate(name, content, storeId) {
     const meta = readMeta();
     const now = new Date().toISOString();
     const id = `prompt-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    const tmpl = { id, name, content, createdAt: now, updatedAt: now };
+    const tmpl = { id, name, content, storeId, createdAt: now, updatedAt: now };
     meta.templates.push(tmpl);
     writeMeta(meta);
     return tmpl;