@agent-spaces/server 0.3.63 → 0.3.65

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/git-operation-log.js

@@ -0,0 +1,40 @@
+const MAX_ENTRIES = 1000;
+const store = new Map();
+function getList(workspaceId) {
+    let list = store.get(workspaceId);
+    if (!list) {
+        list = [];
+        store.set(workspaceId, list);
+    }
+    return list;
+}
+let counter = 0;
+export function logGitOperation(workspaceId, operation, input, result, error, duration = 0) {
+    const list = getList(workspaceId);
+    const entry = {
+        id: `${Date.now()}-${++counter}`,
+        operation,
+        input,
+        output: truncateOutput(result),
+        error,
+        timestamp: new Date().toISOString(),
+        duration,
+    };
+    list.unshift(entry);
+    if (list.length > MAX_ENTRIES)
+        list.length = MAX_ENTRIES;
+}
+export function getGitOperations(workspaceId) {
+    return getList(workspaceId);
+}
+function truncateOutput(value) {
+    if (value === undefined || value === null)
+        return value;
+    if (typeof value === 'string')
+        return value.length > 5000 ? value.slice(0, 5000) + '...(truncated)' : value;
+    const s = JSON.stringify(value);
+    if (s && s.length > 5000)
+        return JSON.parse(s.slice(0, 5000) + '...(truncated)');
+    return value;
+}
+//# sourceMappingURL=git-operation-log.js.map

package/dist/services/global-wechat-qr.js

@@ -0,0 +1,72 @@
+import { WECHAT_BASE_URL, WECHAT_BOT_TYPE, WECHAT_QR_STATUS_TIMEOUT_MS, } from './notification-hub/types.js';
+import { createAccount } from './robot-account.js';
+const globalSessions = new Map();
+export async function getGlobalWeChatQRCode() {
+    // cleanup old sessions
+    const now = Date.now();
+    for (const [key, s] of globalSessions) {
+        if (now - s.createdAt > 5 * 60_000)
+            globalSessions.delete(key);
+    }
+    const res = await fetch(`${WECHAT_BASE_URL}/ilink/bot/get_bot_qrcode?bot_type=${WECHAT_BOT_TYPE}`);
+    if (!res.ok)
+        throw new Error(`Failed to get WeChat QR code: ${res.status}`);
+    const qr = await res.json();
+    const sessionId = `global-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    globalSessions.set(sessionId, {
+        qrcode: qr.qrcode,
+        qrcodeImgContent: qr.qrcode_img_content,
+        createdAt: now,
+    });
+    return { status: 'wait', qrcodeImgContent: qr.qrcode_img_content, sessionId };
+}
+export async function pollGlobalWeChatQRCode(sessionId) {
+    if (!sessionId)
+        throw new Error('sessionId is required');
+    const session = globalSessions.get(sessionId);
+    if (!session)
+        throw new Error('Session not found or expired');
+    const status = await fetchQRStatus(session.qrcode);
+    if (status.status === 'confirmed') {
+        if (!status.bot_token || !status.ilink_bot_id) {
+            throw new Error('WeChat login confirmed but token or bot id is missing');
+        }
+        globalSessions.delete(sessionId);
+        const account = createAccount({
+            name: `微信 ${status.ilink_bot_id}`,
+            type: 'wechat',
+            wechat: {
+                token: status.bot_token,
+                baseUrl: status.baseurl || WECHAT_BASE_URL,
+                accountId: status.ilink_bot_id,
+                userId: status.ilink_user_id,
+            },
+        });
+        return { status: 'confirmed', account };
+    }
+    if (status.status === 'expired') {
+        globalSessions.delete(sessionId);
+    }
+    return { status: status.status, qrcodeImgContent: session.qrcodeImgContent, sessionId };
+}
+async function fetchQRStatus(qrcode) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), WECHAT_QR_STATUS_TIMEOUT_MS);
+    try {
+        const res = await fetch(`${WECHAT_BASE_URL}/ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`, {
+            headers: { 'iLink-App-ClientVersion': '1' },
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (!res.ok)
+            throw new Error(`Failed to poll QR status: ${res.status}`);
+        return await res.json();
+    }
+    catch (err) {
+        clearTimeout(timer);
+        if (err instanceof Error && err.name === 'AbortError')
+            return { status: 'wait' };
+        throw err;
+    }
+}
+//# sourceMappingURL=global-wechat-qr.js.map

package/dist/services/hook-engine.js

@@ -1,5 +1,12 @@
 import { exec } from 'node:child_process';
 import { listHooks } from '../storage/hook-store.js';
+function logDebug(message, details) {
+    if (details) {
+        console.debug(`[HookEngine] ${message}`, details);
+        return;
+    }
+    console.debug(`[HookEngine] ${message}`);
+}
 function matchToolName(matcher, toolName) {
     if (matcher === '*')
         return true;
@@ -8,7 +15,12 @@ function matchToolName(matcher, toolName) {
             const regex = new RegExp(matcher.slice(1, -1));
             return regex.test(toolName);
         }
-        catch {
+        catch (error) {
+            console.warn(`[HookEngine] invalid matcher regex, falling back to exact match`, {
+                matcher,
+                toolName,
+                error: error.message,
+            });
             return matcher === toolName;
         }
     }
@@ -16,7 +28,8 @@ function matchToolName(matcher, toolName) {
 }
 function executeCommand(command, env, timeout) {
     return new Promise((resolve) => {
-        exec(command, { env: { ...process.env, ...env }, timeout: Math.min(timeout, 30000) }, (error) => {
+        const cappedTimeout = Math.min(timeout, 30000);
+        exec(command, { env: { ...process.env, ...env }, timeout: cappedTimeout }, (error) => {
             if (error)
                 console.warn(`[HookEngine] command error: ${error.message}`);
             resolve();
@@ -26,43 +39,101 @@ function executeCommand(command, env, timeout) {
 async function executeWebhook(url, body, timeout) {
     try {
         const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), Math.min(timeout, 30000));
-        await fetch(url, {
+        const cappedTimeout = Math.min(timeout, 30000);
+        const timer = setTimeout(() => controller.abort(), cappedTimeout);
+        const response = await fetch(url, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify(body),
             signal: controller.signal,
         });
         clearTimeout(timer);
+        if (!response.ok) {
+            console.warn(`[HookEngine] webhook non-2xx response`, {
+                url,
+                status: response.status,
+                statusText: response.statusText,
+            });
+        }
     }
     catch (error) {
         console.warn(`[HookEngine] webhook error: ${error.message}`);
     }
 }
-async function executeRule(rule, phase, toolName, workspaceId, context) {
+async function executeRule(rule, phase, matcherValue, workspaceId, context, hookName) {
     const timeout = rule.timeout ?? 10000;
+    const startedAt = Date.now();
+    logDebug('rule start', {
+        workspaceId,
+        phase,
+        hookName,
+        matcherValue,
+        matcher: rule.matcher,
+        type: rule.type,
+        timeout,
+    });
     if (rule.type === 'command' && rule.command) {
         await executeCommand(rule.command, {
-            HOOK_TOOL_NAME: toolName,
+            HOOK_NAME: hookName ?? '',
+            HOOK_RULE_MATCHER: rule.matcher,
+            HOOK_RULE_TYPE: rule.type,
+            HOOK_RULE_TIMEOUT: String(timeout),
+            HOOK_EVENT_NAME: context.eventName ?? phase,
+            HOOK_EVENT_PAYLOAD: JSON.stringify(context.eventPayload ?? {}),
+            HOOK_MATCHER_VALUE: matcherValue,
+            HOOK_TOOL_NAME: matcherValue,
+            HOOK_TOOL_USE_ID: context.toolUseId ?? '',
             HOOK_TOOL_INPUT: JSON.stringify(context.toolInput ?? {}),
             HOOK_TOOL_RESULT: JSON.stringify(context.toolResult ?? ''),
             HOOK_WORKSPACE_ID: workspaceId,
             HOOK_PHASE: phase,
+            HOOK_TRIGGER_CHECKED_RULES: String(context.checkedRules ?? ''),
+            HOOK_TRIGGER_MATCHED_RULES: String(context.matchedRules ?? ''),
+            HOOK_TRIGGERED_AT: new Date().toISOString(),
         }, timeout);
     }
     else if (rule.type === 'webhook' && rule.url) {
         await executeWebhook(rule.url, {
             event: phase,
-            toolName,
+            toolName: matcherValue,
+            matcherValue,
             toolInput: context.toolInput,
             toolResult: context.toolResult ?? undefined,
+            payload: context.eventPayload,
             timestamp: new Date().toISOString(),
             workspaceId,
         }, timeout);
     }
     else if (rule.type === 'script') {
-        console.warn(`[HookEngine] script type not implemented, skipping rule in ${phase}`);
+        console.warn(`[HookEngine] script type not implemented, skipping rule`, {
+            workspaceId,
+            phase,
+            hookName,
+            matcherValue,
+            matcher: rule.matcher,
+        });
     }
+    else {
+        console.warn(`[HookEngine] invalid rule configuration, skipping rule`, {
+            workspaceId,
+            phase,
+            hookName,
+            matcherValue,
+            matcher: rule.matcher,
+            type: rule.type,
+            hasCommand: Boolean(rule.command),
+            hasUrl: Boolean(rule.url),
+        });
+    }
+    logDebug('rule finished', {
+        workspaceId,
+        phase,
+        hookName,
+        matcherValue,
+        matcher: rule.matcher,
+        type: rule.type,
+        durationMs: Date.now() - startedAt,
+    });
 }
 export class HookEngine {
     hooks = [];
@@ -72,6 +143,12 @@ export class HookEngine {
     }
     load() {
         this.hooks = listHooks(this.workspaceId);
+        logDebug('loaded hooks', {
+            workspaceId: this.workspaceId,
+            totalHooks: this.hooks.length,
+            enabledHooks: this.hooks.filter(h => h.enabled).length,
+            hookNames: this.hooks.map(h => h.name),
+        });
     }
     reload() {
         this.load();
@@ -79,40 +156,121 @@ export class HookEngine {
     getHooks() {
         return this.hooks;
     }
-    async executeHooks(phase, toolName, context) {
+    async executeHooks(phase, matcherValue, context) {
         const enabledHooks = this.hooks.filter(h => h.enabled);
         const promises = [];
+        const matchedRuleEntries = [];
+        let checkedRules = 0;
+        let matchedRules = 0;
+        logDebug('trigger received', {
+            workspaceId: this.workspaceId,
+            phase,
+            matcherValue,
+            totalHooks: this.hooks.length,
+            enabledHooks: enabledHooks.length,
+            hasToolInput: context.toolInput !== undefined,
+            hasToolResult: context.toolResult !== undefined,
+        });
         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));
+                checkedRules += 1;
+                if (matchToolName(rule.matcher, matcherValue)) {
+                    matchedRules += 1;
+                    logDebug('rule matched', {
+                        workspaceId: this.workspaceId,
+                        phase,
+                        hookName: hook.name,
+                        matcherValue,
+                        matcher: rule.matcher,
+                        type: rule.type,
+                    });
+                    matchedRuleEntries.push({ hookName: hook.name, rule });
                 }
             }
         }
-        await Promise.allSettled(promises);
+        for (const { hookName, rule } of matchedRuleEntries) {
+            promises.push(executeRule(rule, phase, matcherValue, this.workspaceId, {
+                ...context,
+                checkedRules,
+                matchedRules,
+            }, hookName));
+        }
+        const results = await Promise.allSettled(promises);
+        const rejectedRules = results.filter(result => result.status === 'rejected').length;
+        logDebug('trigger finished', {
+            workspaceId: this.workspaceId,
+            phase,
+            matcherValue,
+            checkedRules,
+            matchedRules,
+            rejectedRules,
+        });
     }
 }
 export function wrapOnEventWithHooks(onEvent, workspaceId, hooksEnabled) {
-    if (!hooksEnabled)
+    if (!hooksEnabled) {
+        logDebug('hooks disabled for workspace', { workspaceId });
         return onEvent;
+    }
     const engine = new HookEngine(workspaceId);
     engine.load();
     const toolNameById = new Map();
+    let lastToolUse = null;
     return (event) => {
-        onEvent(event);
+        if (event.type !== 'hook_event')
+            onEvent(event);
         if (event.type === 'tool_use') {
             toolNameById.set(event.id, event.name);
-            engine.executeHooks('PreToolUse', event.name, { toolInput: event.input });
+            lastToolUse = { id: event.id, name: event.name };
+            logDebug('tool_use event mapped', {
+                workspaceId,
+                toolUseId: event.id,
+                toolName: event.name,
+            });
+            engine.executeHooks('PreToolUse', event.name, { toolInput: event.input, toolUseId: event.id });
         }
         if (event.type === 'tool_result') {
-            const toolName = event.toolUseId ? (toolNameById.get(event.toolUseId) ?? '') : '';
+            const resolvedToolUseId = event.toolUseId || lastToolUse?.id;
+            const toolName = resolvedToolUseId ? (toolNameById.get(resolvedToolUseId) ?? '') : '';
             if (toolName) {
-                engine.executeHooks('PostToolUse', toolName, { toolResult: event.result });
+                logDebug('tool_result event resolved', {
+                    workspaceId,
+                    toolUseId: resolvedToolUseId,
+                    originalToolUseId: event.toolUseId,
+                    toolName,
+                });
+                engine.executeHooks('PostToolUse', toolName, { toolResult: event.result, toolUseId: resolvedToolUseId });
+                if (isToolFailureResult(event.result)) {
+                    engine.executeHooks('PostToolUseFailure', toolName, { toolResult: event.result, toolUseId: resolvedToolUseId });
+                }
+            }
+            else {
+                logDebug('tool_result event skipped without matching tool_use', {
+                    workspaceId,
+                    toolUseId: event.toolUseId,
+                });
             }
         }
+        if (event.type === 'hook_event') {
+            logDebug('hook_event received', {
+                workspaceId,
+                event: event.event,
+                matcher: event.matcher ?? '*',
+            });
+            engine.executeHooks(event.event, event.matcher ?? '*', {
+                eventName: event.event,
+                eventPayload: event.payload,
+            });
+        }
     };
 }
+function isToolFailureResult(result) {
+    if (!result || typeof result !== 'object')
+        return false;
+    const record = result;
+    return record.error !== undefined || record.is_error === true || record.success === false;
+}
 //# sourceMappingURL=hook-engine.js.map

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