@agent-spaces/server 0.3.63 → 0.3.65

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

@@ -28,7 +28,8 @@ export async function runBotAgent(workspaceId, preset, message) {
     const workingDir = agentService.resolveWorkingDir(workspaceId, preset);
     const workspace = workspaceService.getById(workspaceId);
     try {
-        const result = await runtime.execute(prependPersistentAgentContext(buildBotPrompt(message), {
+        const userPrompt = buildBotPrompt(message);
+        const result = await runtime.execute(prependPersistentAgentContext(userPrompt, {
             workspaceId,
             workingDir,
             boundDirs: workspace?.boundDirs,
@@ -36,6 +37,7 @@ export async function runBotAgent(workspaceId, preset, message) {
             excludeNativeClaudeMd: preset.runtimeKind === 'claude-code',
         }), workingDir, {
             maxTurns: 20,
+            userPrompt,
             mcpServers: agentService.getMcpServers(preset.mcps),
             skills: agentService.getAvailableSkillNames(agentService.getAgentConfigDir(workspaceId, preset), preset.skills),
             configDir: agentService.getAgentConfigDir(workspaceId, preset),

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

@@ -1,4 +1,5 @@
 import * as workspaceService from '../workspace.js';
+import { resolveCredentials } from '../robot-account.js';
 import { adapters } from './types.js';
 import { persistServiceRunning } from './helpers.js';
 import { WeChatNotificationAdapter } from './wechat-adapter.js';
@@ -9,15 +10,24 @@ export async function startWorkspaceNotificationService(workspaceId) {
     if (!workspace || !settings?.enabled)
         return { started: false };
     await stopWorkspaceNotificationService(workspaceId);
+    const credentials = resolveCredentials(settings);
     if (settings.provider === 'lark') {
-        const adapter = new LarkNotificationAdapter(workspace, settings);
+        if (!credentials || credentials.type !== 'lark') {
+            throw new Error('Lark credentials not found. Link a Robot Account or configure appId/appSecret.');
+        }
+        const mergedSettings = { ...settings, lark: { ...settings.lark, appId: credentials.appId, appSecret: credentials.appSecret } };
+        const adapter = new LarkNotificationAdapter(workspace, mergedSettings);
         await adapter.start();
         adapters.set(workspaceId, adapter);
         persistServiceRunning(workspaceId, true);
         return { started: true, provider: 'lark' };
     }
     if (settings.provider === 'wechat') {
-        const adapter = new WeChatNotificationAdapter(workspace, settings);
+        if (!credentials || credentials.type !== 'wechat') {
+            throw new Error('WeChat credentials not found. Link a Robot Account or scan QR code first.');
+        }
+        const mergedSettings = { ...settings, wechat: { ...settings.wechat, token: credentials.token, baseUrl: credentials.baseUrl, accountId: credentials.accountId, userId: credentials.userId } };
+        const adapter = new WeChatNotificationAdapter(workspace, mergedSettings);
         await adapter.start();
         adapters.set(workspaceId, adapter);
         persistServiceRunning(workspaceId, true);

package/dist/services/robot-account.js

@@ -0,0 +1,34 @@
+import { v4 as uuid } from 'uuid';
+import { listRobotAccounts, getRobotAccount, createRobotAccount, updateRobotAccount, deleteRobotAccount } from '../storage/robot-account-store.js';
+export { listRobotAccounts, getRobotAccount, deleteRobotAccount };
+export function createAccount(input) {
+    const now = new Date().toISOString();
+    const account = { id: uuid(), name: input.name, type: input.type, lark: input.lark, wechat: input.wechat, createdAt: now, updatedAt: now };
+    createRobotAccount(account);
+    return account;
+}
+export function updateAccount(id, patch) {
+    return updateRobotAccount(id, patch);
+}
+export function resolveCredentials(settings) {
+    if (settings.robotAccountId) {
+        const account = getRobotAccount(settings.robotAccountId);
+        if (account) {
+            if (account.type === 'lark' && account.lark) {
+                return { type: 'lark', appId: account.lark.appId, appSecret: account.lark.appSecret };
+            }
+            if (account.type === 'wechat' && account.wechat) {
+                return { type: 'wechat', token: account.wechat.token, baseUrl: account.wechat.baseUrl || 'https://qyapi.weixin.qq.com', accountId: account.wechat.accountId, userId: account.wechat.userId };
+            }
+        }
+    }
+    // fallback to inline credentials
+    if (settings.provider === 'lark' && settings.lark?.appId && settings.lark?.appSecret) {
+        return { type: 'lark', appId: settings.lark.appId, appSecret: settings.lark.appSecret };
+    }
+    if (settings.provider === 'wechat' && settings.wechat?.token && settings.wechat?.accountId) {
+        return { type: 'wechat', token: settings.wechat.token, baseUrl: settings.wechat.baseUrl || 'https://qyapi.weixin.qq.com', accountId: settings.wechat.accountId, userId: settings.wechat.userId };
+    }
+    return null;
+}
+//# sourceMappingURL=robot-account.js.map

package/dist/services/workspace.js

@@ -59,6 +59,8 @@ export function update(id, data) {
         allowed.autoProcessIssues = data.autoProcessIssues;
     if (Object.hasOwn(data, 'notificationSettings'))
         allowed.notificationSettings = data.notificationSettings;
+    if (Object.hasOwn(data, 'hooksEnabled'))
+        allowed.hooksEnabled = data.hooksEnabled;
     Object.assign(ws, allowed, { updatedAt: new Date().toISOString() });
     updateWorkspace(ws);
     return ws;

package/dist/storage/database-store.js

@@ -0,0 +1,365 @@
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { createHash } from 'node:crypto';
+import { v4 as uuid } from 'uuid';
+import { getDataDir, ensureDir } from './json-store.js';
+let db = null;
+function openDb() {
+    if (db)
+        return db;
+    const dir = join(getDataDir(), 'database');
+    ensureDir(dir);
+    db = new DatabaseSync(join(dir, 'database.sqlite'));
+    const hasDocNodes = Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'doc_nodes'").get());
+    const hasDatabaseId = hasDocNodes
+        && db.prepare('PRAGMA table_info(doc_nodes)').all()
+            .some((column) => column.name === 'database_id');
+    if (hasDocNodes && !hasDatabaseId) {
+        db.exec('DROP TABLE IF EXISTS doc_nodes; DROP TABLE IF EXISTS databases;');
+    }
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS databases (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      name TEXT NOT NULL DEFAULT '',
+      description TEXT NOT NULL DEFAULT '',
+      embedding_model_id TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS doc_nodes (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      database_id TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT '',
+      icon TEXT NOT NULL DEFAULT '',
+      cover TEXT NOT NULL DEFAULT '',
+      content TEXT NOT NULL DEFAULT '',
+      parent_id TEXT,
+      is_trash INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS database_embeddings (
+      workspace_id TEXT NOT NULL,
+      database_id TEXT NOT NULL,
+      node_id TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT '',
+      path TEXT NOT NULL DEFAULT '',
+      content TEXT NOT NULL DEFAULT '',
+      content_hash TEXT NOT NULL,
+      embedding TEXT NOT NULL,
+      model_id TEXT NOT NULL DEFAULT '',
+      agent_id TEXT NOT NULL DEFAULT '',
+      updated_at INTEGER NOT NULL,
+      PRIMARY KEY (workspace_id, database_id, node_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS doc_node_versions (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      database_id TEXT NOT NULL,
+      node_id TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT '',
+      patch_json TEXT NOT NULL,
+      old_hash TEXT NOT NULL,
+      new_hash TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_databases_workspace ON databases(workspace_id);
+    CREATE INDEX IF NOT EXISTS idx_doc_nodes_workspace ON doc_nodes(workspace_id);
+    CREATE INDEX IF NOT EXISTS idx_doc_nodes_database ON doc_nodes(workspace_id, database_id);
+    CREATE INDEX IF NOT EXISTS idx_doc_nodes_parent ON doc_nodes(workspace_id, database_id, parent_id);
+    CREATE INDEX IF NOT EXISTS idx_database_embeddings_database ON database_embeddings(workspace_id, database_id);
+    CREATE INDEX IF NOT EXISTS idx_doc_node_versions_node ON doc_node_versions(workspace_id, database_id, node_id, created_at DESC);
+  `);
+    ensureColumn('databases', 'embedding_model_id', 'TEXT');
+    migrateEmbeddingModelColumn();
+    return db;
+}
+function ensureColumn(table, column, type) {
+    const database = db;
+    const exists = database.prepare(`PRAGMA table_info(${table})`).all()
+        .some((item) => item.name === column);
+    if (!exists)
+        database.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
+}
+function migrateEmbeddingModelColumn() {
+    const database = db;
+    const columns = database.prepare('PRAGMA table_info(databases)').all();
+    const hasLegacyAgentColumn = columns.some((item) => item.name === 'embedding_agent_id');
+    if (!hasLegacyAgentColumn)
+        return;
+    database.exec(`
+    UPDATE databases
+    SET embedding_model_id = COALESCE(embedding_model_id, embedding_agent_id)
+    WHERE embedding_agent_id IS NOT NULL AND embedding_agent_id != ''
+  `);
+}
+function rowToDatabase(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspace_id,
+        name: row.name,
+        description: row.description,
+        embeddingModelId: row.embedding_model_id || undefined,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function rowToNode(row) {
+    return {
+        id: row.id,
+        databaseId: row.database_id,
+        title: row.title,
+        icon: row.icon,
+        cover: row.cover,
+        content: row.content,
+        parentId: row.parent_id || null,
+        isTrash: !!row.is_trash,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function rowToVersionRow(row) {
+    return {
+        id: row.id,
+        nodeId: row.node_id,
+        databaseId: row.database_id,
+        title: row.title,
+        patch: JSON.parse(row.patch_json),
+        oldHash: row.old_hash,
+        newHash: row.new_hash,
+        createdAt: row.created_at,
+    };
+}
+export function listDatabases(workspaceId) {
+    const database = openDb();
+    const rows = database.prepare('SELECT * FROM databases WHERE workspace_id = ? ORDER BY created_at ASC').all(workspaceId);
+    return rows.map(rowToDatabase);
+}
+export function getDatabase(workspaceId, databaseId) {
+    const database = openDb();
+    const row = database.prepare('SELECT * FROM databases WHERE workspace_id = ? AND id = ?').get(workspaceId, databaseId);
+    return row ? rowToDatabase(row) : null;
+}
+export function getDefaultDatabase(workspaceId) {
+    const existing = listDatabases(workspaceId)[0];
+    if (existing)
+        return existing;
+    return createDatabase(workspaceId, { name: 'Default Database' });
+}
+export function createDatabase(workspaceId, input) {
+    const database = openDb();
+    const id = input.id || uuid();
+    const now = Date.now();
+    database.prepare(`INSERT INTO databases (id, workspace_id, name, description, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?)`).run(id, workspaceId, input.name?.trim() || 'Untitled Database', input.description || '', now, now);
+    return getDatabase(workspaceId, id);
+}
+export function updateDatabase(workspaceId, databaseId, updates) {
+    const existing = getDatabase(workspaceId, databaseId);
+    if (!existing)
+        return null;
+    const database = openDb();
+    const merged = { ...existing, ...updates, updatedAt: Date.now() };
+    database.prepare('UPDATE databases SET name = ?, description = ?, embedding_model_id = ?, updated_at = ? WHERE workspace_id = ? AND id = ?').run(merged.name.trim() || 'Untitled Database', merged.description, merged.embeddingModelId ?? null, merged.updatedAt, workspaceId, databaseId);
+    return getDatabase(workspaceId, databaseId);
+}
+export function deleteDatabase(workspaceId, databaseId) {
+    const database = openDb();
+    database.prepare('DELETE FROM doc_nodes WHERE workspace_id = ? AND database_id = ?').run(workspaceId, databaseId);
+    database.prepare('DELETE FROM database_embeddings WHERE workspace_id = ? AND database_id = ?').run(workspaceId, databaseId);
+    const result = database.prepare('DELETE FROM databases WHERE workspace_id = ? AND id = ?').run(workspaceId, databaseId);
+    if (result.changes > 0 && listDatabases(workspaceId).length === 0)
+        getDefaultDatabase(workspaceId);
+    return result.changes > 0;
+}
+export function listNodes(workspaceId, databaseId) {
+    const database = openDb();
+    const activeDatabaseId = databaseId ?? getDefaultDatabase(workspaceId).id;
+    const rows = database.prepare('SELECT * FROM doc_nodes WHERE workspace_id = ? AND database_id = ? ORDER BY created_at ASC').all(workspaceId, activeDatabaseId);
+    return rows.map(rowToNode);
+}
+export function getNode(workspaceId, nodeId, databaseId) {
+    const database = openDb();
+    const row = databaseId
+        ? database.prepare('SELECT * FROM doc_nodes WHERE workspace_id = ? AND database_id = ? AND id = ?').get(workspaceId, databaseId, nodeId)
+        : database.prepare('SELECT * FROM doc_nodes WHERE workspace_id = ? AND id = ?').get(workspaceId, nodeId);
+    return row ? rowToNode(row) : null;
+}
+export function createNode(workspaceId, node) {
+    const database = openDb();
+    const databaseId = node.databaseId || getDefaultDatabase(workspaceId).id;
+    if (!getDatabase(workspaceId, databaseId))
+        throw new Error(`Database not found: ${databaseId}`);
+    const id = node.id || uuid();
+    const now = Date.now();
+    database.prepare(`INSERT INTO doc_nodes (id, workspace_id, database_id, title, icon, cover, content, parent_id, is_trash, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, workspaceId, databaseId, node.title || 'Untitled Document', node.icon || '\u{1F4DD}', node.cover || '', node.content || '', node.parentId ?? null, node.isTrash ? 1 : 0, node.createdAt || now, node.updatedAt || now);
+    return getNode(workspaceId, id, databaseId);
+}
+export function updateNode(workspaceId, nodeId, updates, databaseId) {
+    const existing = getNode(workspaceId, nodeId, databaseId);
+    if (!existing)
+        return null;
+    const database = openDb();
+    const merged = { ...existing, ...updates, updatedAt: Date.now() };
+    if (Object.hasOwn(updates, 'content') && merged.content !== existing.content) {
+        insertNodeVersion(database, workspaceId, existing, merged.content);
+    }
+    database.prepare(`UPDATE doc_nodes SET title = ?, icon = ?, cover = ?, content = ?, parent_id = ?, is_trash = ?, updated_at = ?
+     WHERE workspace_id = ? AND database_id = ? AND id = ?`).run(merged.title, merged.icon, merged.cover, merged.content, merged.parentId, merged.isTrash ? 1 : 0, merged.updatedAt, workspaceId, existing.databaseId, nodeId);
+    return getNode(workspaceId, nodeId, existing.databaseId);
+}
+export function listNodeVersions(workspaceId, nodeId, databaseId, limit = 50) {
+    const node = getNode(workspaceId, nodeId, databaseId);
+    if (!node)
+        return [];
+    const database = openDb();
+    const normalizedLimit = Number.isFinite(limit) ? Math.max(1, Math.min(100, Math.trunc(limit))) : 50;
+    const rows = database.prepare(`SELECT * FROM doc_node_versions
+     WHERE workspace_id = ? AND database_id = ? AND node_id = ?
+     ORDER BY created_at DESC
+     LIMIT ?`).all(workspaceId, node.databaseId, nodeId, normalizedLimit);
+    const stored = rows.map(rowToVersionRow);
+    let after = node.content;
+    return stored.map((item) => {
+        const before = applyReversePatch(after, item.patch);
+        const version = {
+            id: item.id,
+            nodeId: item.nodeId,
+            databaseId: item.databaseId,
+            title: item.title,
+            patch: item.patch,
+            oldContent: before,
+            newContent: after,
+            createdAt: item.createdAt,
+        };
+        after = before;
+        return version;
+    });
+}
+export function deleteNode(workspaceId, nodeId, databaseId) {
+    const database = openDb();
+    const existing = getNode(workspaceId, nodeId, databaseId);
+    if (!existing)
+        return false;
+    database.prepare('DELETE FROM database_embeddings WHERE workspace_id = ? AND database_id = ? AND node_id = ?')
+        .run(workspaceId, existing.databaseId, nodeId);
+    database.prepare('DELETE FROM doc_node_versions WHERE workspace_id = ? AND database_id = ? AND node_id = ?')
+        .run(workspaceId, existing.databaseId, nodeId);
+    const result = database.prepare('DELETE FROM doc_nodes WHERE workspace_id = ? AND database_id = ? AND id = ?').run(workspaceId, existing.databaseId, nodeId);
+    return result.changes > 0;
+}
+function insertNodeVersion(database, workspaceId, existing, nextContent) {
+    const patch = createContentPatch(existing.content, nextContent);
+    database.prepare(`INSERT INTO doc_node_versions
+      (id, workspace_id, database_id, node_id, title, patch_json, old_hash, new_hash, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(uuid(), workspaceId, existing.databaseId, existing.id, existing.title, JSON.stringify(patch), hashContent(existing.content), hashContent(nextContent), Date.now());
+}
+function createContentPatch(oldContent, newContent) {
+    let start = 0;
+    while (start < oldContent.length
+        && start < newContent.length
+        && oldContent[start] === newContent[start]) {
+        start++;
+    }
+    let oldEnd = oldContent.length;
+    let newEnd = newContent.length;
+    while (oldEnd > start
+        && newEnd > start
+        && oldContent[oldEnd - 1] === newContent[newEnd - 1]) {
+        oldEnd--;
+        newEnd--;
+    }
+    return {
+        start,
+        deleteText: oldContent.slice(start, oldEnd),
+        insertText: newContent.slice(start, newEnd),
+    };
+}
+function applyReversePatch(content, patch) {
+    const insertEnd = patch.start + patch.insertText.length;
+    return `${content.slice(0, patch.start)}${patch.deleteText}${content.slice(insertEnd)}`;
+}
+function hashContent(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+export function moveNode(workspaceId, nodeId, newParentId, databaseId) {
+    return updateNode(workspaceId, nodeId, { parentId: newParentId }, databaseId);
+}
+export function trashNode(workspaceId, nodeId, databaseId) {
+    return updateNode(workspaceId, nodeId, { isTrash: true }, databaseId);
+}
+export function restoreNode(workspaceId, nodeId, databaseId) {
+    const node = getNode(workspaceId, nodeId, databaseId);
+    if (!node)
+        return null;
+    if (node.parentId) {
+        const parent = getNode(workspaceId, node.parentId, node.databaseId);
+        if (parent && parent.isTrash) {
+            return updateNode(workspaceId, nodeId, { isTrash: false, parentId: null }, node.databaseId);
+        }
+    }
+    return updateNode(workspaceId, nodeId, { isTrash: false }, node.databaseId);
+}
+export function getVectorStats(workspaceId, databaseId) {
+    const database = openDb();
+    const meta = getDatabase(workspaceId, databaseId);
+    const indexed = database.prepare('SELECT COUNT(*) AS count, MAX(updated_at) AS last_indexed_at FROM database_embeddings WHERE workspace_id = ? AND database_id = ?').get(workspaceId, databaseId);
+    const nodes = database.prepare('SELECT COUNT(*) AS count FROM doc_nodes WHERE workspace_id = ? AND database_id = ? AND is_trash = 0').get(workspaceId, databaseId);
+    return {
+        databaseId,
+        embeddingModelId: meta?.embeddingModelId ?? null,
+        indexedCount: indexed.count,
+        nodeCount: nodes.count,
+        lastIndexedAt: indexed.last_indexed_at,
+    };
+}
+export function setDatabaseEmbeddingModel(workspaceId, databaseId, embeddingModelId) {
+    return updateDatabase(workspaceId, databaseId, { embeddingModelId: embeddingModelId ?? undefined });
+}
+export function upsertDatabaseEmbedding(workspaceId, databaseId, record) {
+    const database = openDb();
+    database.prepare(`INSERT INTO database_embeddings
+      (workspace_id, database_id, node_id, title, path, content, content_hash, embedding, model_id, agent_id, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(workspace_id, database_id, node_id) DO UPDATE SET
+      title = excluded.title,
+      path = excluded.path,
+      content = excluded.content,
+      content_hash = excluded.content_hash,
+      embedding = excluded.embedding,
+      model_id = excluded.model_id,
+      agent_id = excluded.agent_id,
+      updated_at = excluded.updated_at`).run(workspaceId, databaseId, record.nodeId, record.title, record.path, record.content, record.contentHash, JSON.stringify(record.embedding), record.modelId, record.agentId, Date.now());
+}
+export function deleteStaleDatabaseEmbeddings(workspaceId, databaseId, activeNodeIds) {
+    const database = openDb();
+    if (activeNodeIds.length === 0) {
+        const result = database.prepare('DELETE FROM database_embeddings WHERE workspace_id = ? AND database_id = ?')
+            .run(workspaceId, databaseId);
+        return result.changes;
+    }
+    const placeholders = activeNodeIds.map(() => '?').join(',');
+    const result = database.prepare(`DELETE FROM database_embeddings WHERE workspace_id = ? AND database_id = ? AND node_id NOT IN (${placeholders})`).run(workspaceId, databaseId, ...activeNodeIds);
+    return result.changes;
+}
+export function listDatabaseEmbeddings(workspaceId, databaseId) {
+    const database = openDb();
+    const rows = database.prepare('SELECT node_id, title, path, content, embedding, updated_at FROM database_embeddings WHERE workspace_id = ? AND database_id = ?').all(workspaceId, databaseId);
+    return rows.map((row) => ({
+        nodeId: row.node_id,
+        title: row.title,
+        path: row.path,
+        content: row.content,
+        score: 0,
+        updatedAt: row.updated_at,
+        embedding: JSON.parse(row.embedding),
+    }));
+}
+//# sourceMappingURL=database-store.js.map

package/dist/storage/kanban-store.js

@@ -0,0 +1,142 @@
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { v4 as uuid } from 'uuid';
+import { getDataDir, ensureDir } from './json-store.js';
+let db = null;
+function openDb() {
+    if (db)
+        return db;
+    const dir = join(getDataDir(), 'kanban');
+    ensureDir(dir);
+    db = new DatabaseSync(join(dir, 'kanban.sqlite'));
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS kanban_boards (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT 'Kanban Board',
+      layout_mode TEXT NOT NULL DEFAULT 'horizontal',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_kanban_boards_workspace ON kanban_boards(workspace_id);
+    CREATE TABLE IF NOT EXISTS kanban_columns (
+      id TEXT PRIMARY KEY,
+      board_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      color TEXT NOT NULL DEFAULT 'sky',
+      sort_order INTEGER NOT NULL DEFAULT 0,
+      FOREIGN KEY (board_id) REFERENCES kanban_boards(id) ON DELETE CASCADE
+    );
+    CREATE INDEX IF NOT EXISTS idx_kanban_columns_board ON kanban_columns(board_id);
+    CREATE TABLE IF NOT EXISTS kanban_tasks (
+      id TEXT PRIMARY KEY,
+      board_id TEXT NOT NULL,
+      column_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT NOT NULL DEFAULT '',
+      priority TEXT NOT NULL DEFAULT 'medium',
+      sort_order INTEGER NOT NULL DEFAULT 0,
+      due_date TEXT,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (board_id) REFERENCES kanban_boards(id) ON DELETE CASCADE
+    );
+    CREATE INDEX IF NOT EXISTS idx_kanban_tasks_board ON kanban_tasks(board_id);
+    CREATE INDEX IF NOT EXISTS idx_kanban_tasks_column ON kanban_tasks(column_id);
+  `);
+    return db;
+}
+export function getBoard(workspaceId) {
+    const database = openDb();
+    const row = database.prepare('SELECT * FROM kanban_boards WHERE workspace_id = ? ORDER BY updated_at DESC').get(workspaceId);
+    if (!row)
+        return null;
+    return hydrateBoard(workspaceId, row);
+}
+export function listBoards(workspaceId) {
+    const database = openDb();
+    const rows = database.prepare('SELECT * FROM kanban_boards WHERE workspace_id = ? ORDER BY updated_at DESC').all(workspaceId);
+    return rows.map((row) => hydrateBoard(workspaceId, row));
+}
+function hydrateBoard(workspaceId, row) {
+    const database = openDb();
+    const boardId = row.id;
+    const columns = database.prepare('SELECT * FROM kanban_columns WHERE board_id = ? ORDER BY sort_order ASC').all(boardId).map(r => ({
+        id: r.id,
+        title: r.title,
+        color: r.color,
+        order: r.sort_order,
+    }));
+    const tasks = database.prepare('SELECT * FROM kanban_tasks WHERE board_id = ? ORDER BY sort_order ASC').all(boardId).map(r => ({
+        id: r.id,
+        title: r.title,
+        description: r.description,
+        priority: r.priority,
+        columnId: r.column_id,
+        order: r.sort_order,
+        createdAt: r.created_at,
+        dueDate: r.due_date || undefined,
+    }));
+    return {
+        id: boardId,
+        workspaceId,
+        title: row.title,
+        layoutMode: row.layout_mode || 'horizontal',
+        columns,
+        tasks,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export function createBoard(workspaceId, title) {
+    const database = openDb();
+    const id = uuid();
+    const now = Date.now();
+    database.prepare('INSERT INTO kanban_boards (id, workspace_id, title, layout_mode, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)').run(id, workspaceId, title || 'Kanban Board', 'horizontal', now, now);
+    return { id, workspaceId, title: title || 'Kanban Board', layoutMode: 'horizontal', columns: [], tasks: [], createdAt: now, updatedAt: now };
+}
+export function updateBoard(workspaceId, updates, boardId) {
+    let board = boardId ? listBoards(workspaceId).find((item) => item.id === boardId) ?? null : getBoard(workspaceId);
+    if (!board)
+        return null;
+    const database = openDb();
+    const now = Date.now();
+    if (updates.title !== undefined) {
+        database.prepare('UPDATE kanban_boards SET title = ?, updated_at = ? WHERE workspace_id = ? AND id = ?').run(updates.title, now, workspaceId, board.id);
+    }
+    if (updates.layoutMode !== undefined) {
+        database.prepare('UPDATE kanban_boards SET layout_mode = ?, updated_at = ? WHERE workspace_id = ? AND id = ?').run(updates.layoutMode, now, workspaceId, board.id);
+    }
+    return (boardId ? listBoards(workspaceId).find((item) => item.id === board.id) : getBoard(workspaceId)) ?? null;
+}
+export function deleteBoard(workspaceId, boardId) {
+    const database = openDb();
+    const board = boardId
+        ? database.prepare('SELECT * FROM kanban_boards WHERE workspace_id = ? AND id = ?').get(workspaceId, boardId)
+        : database.prepare('SELECT * FROM kanban_boards WHERE workspace_id = ?').get(workspaceId);
+    if (!board)
+        return false;
+    const id = board.id;
+    database.prepare('DELETE FROM kanban_tasks WHERE board_id = ?').run(id);
+    database.prepare('DELETE FROM kanban_columns WHERE board_id = ?').run(id);
+    database.prepare('DELETE FROM kanban_boards WHERE id = ? AND workspace_id = ?').run(id, workspaceId);
+    return true;
+}
+export function saveColumns(boardId, columns) {
+    const database = openDb();
+    database.prepare('DELETE FROM kanban_columns WHERE board_id = ?').run(boardId);
+    const stmt = database.prepare('INSERT INTO kanban_columns (id, board_id, title, color, sort_order) VALUES (?, ?, ?, ?, ?)');
+    for (const col of columns) {
+        stmt.run(col.id, boardId, col.title, col.color, col.order);
+    }
+    database.prepare('UPDATE kanban_boards SET updated_at = ? WHERE id = ?').run(Date.now(), boardId);
+}
+export function saveTasks(boardId, tasks) {
+    const database = openDb();
+    database.prepare('DELETE FROM kanban_tasks WHERE board_id = ?').run(boardId);
+    const stmt = database.prepare('INSERT INTO kanban_tasks (id, board_id, column_id, title, description, priority, sort_order, due_date, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)');
+    for (const task of tasks) {
+        stmt.run(task.id, boardId, task.columnId, task.title, task.description, task.priority, task.order, task.dueDate || null, task.createdAt);
+    }
+    database.prepare('UPDATE kanban_boards SET updated_at = ? WHERE id = ?').run(Date.now(), boardId);
+}
+//# sourceMappingURL=kanban-store.js.map

package/dist/storage/robot-account-store.js

@@ -0,0 +1,39 @@
+import { join } from 'node:path';
+import { readJsonFile, writeJsonFile, getDataDir } from './json-store.js';
+const FILE = () => join(getDataDir(), 'robot-accounts.json');
+function read() {
+    return readJsonFile(FILE()) ?? { accounts: [] };
+}
+function write(data) {
+    writeJsonFile(FILE(), data);
+}
+export function listRobotAccounts() {
+    return read().accounts;
+}
+export function getRobotAccount(id) {
+    return read().accounts.find((a) => a.id === id);
+}
+export function createRobotAccount(account) {
+    const data = read();
+    data.accounts.push(account);
+    write(data);
+}
+export function updateRobotAccount(id, patch) {
+    const data = read();
+    const idx = data.accounts.findIndex((a) => a.id === id);
+    if (idx === -1)
+        return null;
+    data.accounts[idx] = { ...data.accounts[idx], ...patch, id, updatedAt: new Date().toISOString() };
+    write(data);
+    return data.accounts[idx];
+}
+export function deleteRobotAccount(id) {
+    const data = read();
+    const before = data.accounts.length;
+    data.accounts = data.accounts.filter((a) => a.id !== id);
+    if (data.accounts.length === before)
+        return false;
+    write(data);
+    return true;
+}
+//# sourceMappingURL=robot-account-store.js.map