@agent-spaces/server 0.3.67 → 0.4.0

package/dist/services/skill.js

@@ -168,6 +168,8 @@ export function importSkillFromStore(storePath, group) {
     const candidates = [
         join(process.cwd(), 'public', 'skills', storePath),
         join(import.meta.dirname ?? '', '..', 'public', 'skills', storePath),
+        join(process.cwd(), 'packages', 'agents', 'skills', storePath),
+        join(import.meta.dirname ?? '', '..', '..', '..', 'agents', 'skills', storePath),
     ];
     for (const c of candidates) {
         if (existsSync(c) && statSync(c).isDirectory()) {

package/dist/services/version.js

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -8,13 +8,23 @@ const CACHE_TTL = 3600_000; // 1 hour
 export function getLocalVersion() {
     if (localVersion !== '')
         return localVersion;
-    try {
-        const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
-        localVersion = pkg.version || '0.0.0';
-    }
-    catch {
-        localVersion = '0.0.0';
+    const packageJsonPaths = [
+        join(__dirname, '..', '..', 'package.json'),
+        join(__dirname, '..', 'package.json'),
+    ];
+    for (const packageJsonPath of packageJsonPaths) {
+        if (!existsSync(packageJsonPath))
+            continue;
+        try {
+            const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+            localVersion = pkg.version || '0.0.0';
+            return localVersion;
+        }
+        catch {
+            // Try the next package.json candidate before falling back.
+        }
     }
+    localVersion = '0.0.0';
     return localVersion;
 }
 export function getCachedLatest() {

package/dist/services/workflow-command-runner.js

@@ -2,12 +2,13 @@ import { exec } from 'child_process';
 import { getWorkspace } from '../storage/workspace-store.js';
 export async function executeCommandNode(workspaceId, node) {
     const workspace = getWorkspace(workspaceId);
-    const cwd = node.data.cwd || workspace?.boundDirs?.[0] || process.cwd();
+    const data = node.data;
+    const cwd = data.cwd || workspace?.boundDirs?.[0] || process.cwd();
     return new Promise((resolve) => {
-        exec(node.data.script, {
+        exec(data.script, {
             cwd,
-            env: { ...process.env, ...node.data.env },
-            shell: node.data.shell || undefined,
+            env: { ...process.env, ...data.env },
+            shell: data.shell || undefined,
             timeout: 300_000,
             maxBuffer: 10 * 1024 * 1024,
         }, (error, stdout, stderr) => {

package/dist/services/workflow-trigger-service.js

@@ -0,0 +1,137 @@
+import * as store from '../storage/workflow-store.js';
+export class WorkflowTriggerService {
+    port;
+    cronJobs = new Map();
+    hookIndex = new Map();
+    nodeCron = null;
+    executionManager = null;
+    constructor(port = 3100) {
+        this.port = port;
+        try {
+            this.nodeCron = require('node-cron');
+        }
+        catch {
+            // node-cron not available
+        }
+    }
+    setExecutionManager(em) {
+        this.executionManager = em;
+    }
+    async start() {
+        const workflows = store.listWorkflows();
+        for (const wf of workflows) {
+            this.registerTriggers(wf);
+        }
+        console.log(`[TriggerService] Started. ${this.cronJobs.size} cron jobs, ${this.hookIndex.size} hooks registered`);
+    }
+    reloadWorkflow(workflowId) {
+        this.clearTriggersForWorkflow(workflowId);
+        const wf = store.getWorkflow(workflowId);
+        if (wf)
+            this.registerTriggers(wf);
+    }
+    removeWorkflow(workflowId) {
+        this.clearTriggersForWorkflow(workflowId);
+    }
+    getHookBindings(hookName) {
+        return Array.from(this.hookIndex.get(hookName) ?? []);
+    }
+    getHookConflicts(hookName, excludeWorkflowId) {
+        const bindings = this.hookIndex.get(hookName) ?? new Set();
+        const ids = Array.from(bindings)
+            .map(b => b.workflowId)
+            .filter(id => id !== excludeWorkflowId);
+        return { conflictWorkflowIds: [...new Set(ids)] };
+    }
+    getHookUrl(hookName) {
+        return `http://localhost:${this.port}/api/workflows/hook/${hookName}`;
+    }
+    validateCron(cronExpr) {
+        if (!this.nodeCron)
+            return { valid: false, nextRuns: [], error: 'node-cron not available' };
+        if (!this.nodeCron.validate(cronExpr)) {
+            return { valid: false, nextRuns: [], error: 'Invalid cron expression' };
+        }
+        try {
+            const CronExpressionParser = require('cron-parser');
+            const interval = CronExpressionParser.parse(cronExpr);
+            const nextRuns = [];
+            for (let i = 0; i < 5; i++) {
+                const iso = interval.next().toISOString();
+                if (iso)
+                    nextRuns.push(iso);
+            }
+            return { valid: true, nextRuns };
+        }
+        catch (err) {
+            return { valid: false, nextRuns: [], error: err.message };
+        }
+    }
+    stop() {
+        for (const [, task] of this.cronJobs) {
+            task.stop();
+        }
+        this.cronJobs.clear();
+        this.hookIndex.clear();
+    }
+    registerTriggers(wf) {
+        if (!wf.triggers)
+            return;
+        for (const trigger of wf.triggers) {
+            if (!trigger.enabled)
+                continue;
+            if (trigger.type === 'cron') {
+                this.registerCronJob(wf.id, trigger);
+            }
+            else if (trigger.type === 'hook') {
+                this.registerHookBinding(wf.id, trigger);
+            }
+        }
+    }
+    registerCronJob(workflowId, trigger) {
+        if (!this.nodeCron)
+            return;
+        const key = `${workflowId}:${trigger.id}`;
+        try {
+            const task = this.nodeCron.schedule(trigger.cron, () => {
+                console.log(`[TriggerService] Cron fired for workflow ${workflowId}`);
+                if (this.executionManager) {
+                    this.executionManager.execute({ workflowId }, '__cron__').catch((err) => {
+                        console.error(`[TriggerService] Cron execution failed for ${workflowId}: ${err.message}`);
+                    });
+                }
+            }, { timezone: trigger.timezone });
+            this.cronJobs.set(key, task);
+        }
+        catch (err) {
+            console.error(`[TriggerService] Invalid cron "${trigger.cron}" for workflow ${workflowId}: ${err.message}`);
+        }
+    }
+    registerHookBinding(workflowId, trigger) {
+        let bindings = this.hookIndex.get(trigger.hookName);
+        if (!bindings) {
+            bindings = new Set();
+            this.hookIndex.set(trigger.hookName, bindings);
+        }
+        bindings.add({ workflowId, triggerId: trigger.id });
+    }
+    clearTriggersForWorkflow(workflowId) {
+        for (const [key, task] of this.cronJobs) {
+            if (key.startsWith(`${workflowId}:`)) {
+                task.stop();
+                this.cronJobs.delete(key);
+            }
+        }
+        for (const [hookName, bindings] of this.hookIndex) {
+            for (const binding of bindings) {
+                if (binding.workflowId === workflowId) {
+                    bindings.delete(binding);
+                }
+            }
+            if (bindings.size === 0) {
+                this.hookIndex.delete(hookName);
+            }
+        }
+    }
+}
+//# sourceMappingURL=workflow-trigger-service.js.map

package/dist/services/workflow.js

@@ -1,11 +1,16 @@
 // packages/server/src/services/workflow.ts
-// NOTE: All storage functions are synchronous (matching json-store pattern).
-//       Service functions are also synchronous where they only call sync storage.
-//       Route handlers wrap in async for Express compatibility.
 import { v4 as uuid } from 'uuid';
-import * as workflowStore from '../storage/workflow-store.js';
+import * as store from '../storage/workflow-store.js';
 import { listTemplates } from './agent.js';
-// --- DAG Validation ---
+function getAgentData(node) {
+    if (node.type !== 'agent')
+        return null;
+    return node.data;
+}
+function getLabel(node) {
+    return node.data.label || node.label;
+}
+// ---- DAG Validation ----
 function topologicalSort(nodes, edges) {
     const adj = new Map();
     const inDegree = new Map();
@@ -14,8 +19,10 @@ function topologicalSort(nodes, edges) {
         inDegree.set(node.id, 0);
     }
     for (const edge of edges) {
-        adj.get(edge.source).push(edge.target);
-        inDegree.set(edge.target, (inDegree.get(edge.target) ?? 0) + 1);
+        const source = edge.source;
+        const target = edge.target;
+        adj.get(source).push(target);
+        inDegree.set(target, (inDegree.get(target) ?? 0) + 1);
     }
     const queue = [];
     for (const [id, deg] of inDegree) {
@@ -67,14 +74,17 @@ export function validateDAG(template) {
     }
     return null;
 }
-// --- Role Staleness Resolution ---
+// ---- Role Staleness Resolution ----
 function resolveStaleRoles(nodes) {
     const agentMap = new Map(listTemplates().map(a => [a.id, a]));
     const invalidIds = [];
     const resolved = nodes.map(node => {
         if (node.type === 'command')
             return node;
-        const agent = agentMap.get(node.data.agentConfigId);
+        const agentData = getAgentData(node);
+        if (!agentData)
+            return node;
+        const agent = agentMap.get(agentData.agentConfigId);
         if (!agent) {
             invalidIds.push(node.id);
             return node;
@@ -91,39 +101,43 @@ function resolveStaleRoles(nodes) {
     });
     return { nodes: resolved, invalidIds };
 }
-// --- CRUD (synchronous) ---
-export function listWorkflows() {
-    return workflowStore.listWorkflows();
+// ---- Workflow CRUD ----
+export function listWorkflows(folderId) {
+    return store.listWorkflows(folderId);
 }
 export function getWorkflow(workflowId) {
-    return workflowStore.getWorkflow(workflowId);
+    return store.getWorkflow(workflowId);
 }
 export function createWorkflow(input) {
-    const now = new Date().toISOString();
+    const now = Date.now();
     const nodes = input.nodes ?? [];
     const edges = input.edges ?? [];
     const { nodes: resolvedNodes, invalidIds } = resolveStaleRoles(nodes);
     if (invalidIds.length > 0) {
         throw new Error(`Invalid agent references in nodes: ${invalidIds.join(', ')}`);
     }
-    const template = {
+    const workflow = {
         id: uuid(),
         name: input.name,
+        folderId: input.folderId ?? null,
+        icon: input.icon,
         description: input.description,
+        tags: input.tags,
         nodes: resolvedNodes,
         edges,
-        viewport: input.viewport,
         createdAt: now,
         updatedAt: now,
+        triggers: input.triggers,
+        groups: input.groups,
     };
-    const error = validateDAG(template);
+    const error = validateDAG(workflow);
     if (error)
         throw new Error(error);
-    workflowStore.createWorkflow(template);
-    return template;
+    store.createWorkflow(workflow);
+    return workflow;
 }
 export function updateWorkflow(workflowId, updates) {
-    const existing = workflowStore.getWorkflow(workflowId);
+    const existing = store.getWorkflow(workflowId);
     if (!existing)
         throw new Error('Workflow not found');
     let nodes = updates.nodes ?? existing.nodes;
@@ -140,27 +154,27 @@ export function updateWorkflow(workflowId, updates) {
         nodes,
         id: existing.id,
         createdAt: existing.createdAt,
-        updatedAt: new Date().toISOString(),
+        updatedAt: Date.now(),
     };
     if (updates.nodes || updates.edges) {
         const error = validateDAG(updated);
         if (error)
             throw new Error(error);
     }
-    workflowStore.updateWorkflow(updated);
+    store.updateWorkflow(updated);
     return updated;
 }
 export function deleteWorkflow(workflowId) {
-    const existing = workflowStore.getWorkflow(workflowId);
+    const existing = store.getWorkflow(workflowId);
     if (!existing)
         throw new Error('Workflow not found');
-    workflowStore.deleteWorkflow(workflowId);
+    store.deleteWorkflow(workflowId);
 }
 export function duplicateWorkflow(workflowId) {
-    const existing = workflowStore.getWorkflow(workflowId);
+    const existing = store.getWorkflow(workflowId);
     if (!existing)
         throw new Error('Workflow not found');
-    const now = new Date().toISOString();
+    const now = Date.now();
     const duplicated = {
         ...existing,
         id: uuid(),
@@ -168,9 +182,124 @@ export function duplicateWorkflow(workflowId) {
         createdAt: now,
         updatedAt: now,
     };
-    workflowStore.createWorkflow(duplicated);
+    store.createWorkflow(duplicated);
     return duplicated;
 }
+// ---- Folder CRUD ----
+export function listFolders() {
+    return store.listWorkflowFolders();
+}
+export function createFolder(input) {
+    const folders = store.listWorkflowFolders();
+    const siblings = folders.filter(f => f.parentId === (input.parentId ?? null));
+    const folder = {
+        id: uuid(),
+        name: input.name,
+        parentId: input.parentId ?? null,
+        order: siblings.length > 0 ? Math.max(...siblings.map(f => f.order)) + 1 : 0,
+        createdAt: Date.now(),
+    };
+    store.createWorkflowFolder(folder);
+    return folder;
+}
+export function updateFolder(id, updates) {
+    store.updateWorkflowFolder(id, updates);
+}
+export function deleteFolder(id) {
+    store.deleteWorkflowFolder(id);
+}
+// ---- Version CRUD ----
+export function listVersions(workflowId) {
+    return store.listVersions(workflowId);
+}
+export function createVersion(workflowId, name) {
+    const workflow = store.getWorkflow(workflowId);
+    if (!workflow)
+        throw new Error('Workflow not found');
+    const version = {
+        id: uuid(),
+        workflowId,
+        name: name || `v${store.listVersions(workflowId).length + 1}`,
+        snapshot: {
+            nodes: JSON.parse(JSON.stringify(workflow.nodes)),
+            edges: JSON.parse(JSON.stringify(workflow.edges)),
+        },
+        createdAt: Date.now(),
+    };
+    store.addVersion(workflowId, version);
+    return version;
+}
+export function getVersion(workflowId, versionId) {
+    return store.getVersion(workflowId, versionId);
+}
+export function deleteVersion(workflowId, versionId) {
+    store.deleteVersion(workflowId, versionId);
+}
+export function clearVersions(workflowId) {
+    store.clearVersions(workflowId);
+}
+// ---- Execution Log CRUD ----
+export function listExecutionLogs(workflowId) {
+    return store.listExecutionLogs(workflowId);
+}
+export function listAllExecutionLogs(limit) {
+    return store.listAllExecutionLogs(limit);
+}
+export function getExecutionLog(workflowId, logId) {
+    return store.getExecutionLog(workflowId, logId);
+}
+export function deleteExecutionLog(workflowId, logId) {
+    store.deleteExecutionLog(workflowId, logId);
+}
+export function clearExecutionLogs(workflowId) {
+    store.clearExecutionLogs(workflowId);
+}
+// ---- Staging ----
+export function loadStaging(workflowId) {
+    return store.loadStaging(workflowId);
+}
+export function saveStaging(workflowId, nodes) {
+    store.saveStaging(workflowId, nodes);
+}
+export function clearStaging(workflowId) {
+    store.clearStaging(workflowId);
+}
+// ---- Operation History ----
+export function loadOperationHistory(workflowId) {
+    return store.loadOperationHistory(workflowId);
+}
+export function saveOperationHistory(workflowId, entries) {
+    store.saveOperationHistory(workflowId, entries);
+}
+export function clearOperationHistory(workflowId) {
+    store.clearOperationHistory(workflowId);
+}
+// ---- Workflow Agent Chat ----
+export function loadChat(workflowId) {
+    return store.loadChat(workflowId);
+}
+export function saveChat(workflowId, messages) {
+    store.saveChat(workflowId, messages);
+}
+export function clearChat(workflowId) {
+    store.clearChat(workflowId);
+}
+// ---- Plugin Config Schemes ----
+export function listPluginSchemes(workflowId, pluginId) {
+    return store.listPluginSchemes(workflowId, pluginId);
+}
+export function readPluginScheme(workflowId, pluginId, schemeName) {
+    return store.readPluginScheme(workflowId, pluginId, schemeName);
+}
+export function createPluginScheme(workflowId, pluginId, schemeName) {
+    store.savePluginScheme(workflowId, pluginId, schemeName, {});
+}
+export function savePluginScheme(workflowId, pluginId, schemeName, data) {
+    store.savePluginScheme(workflowId, pluginId, schemeName, data);
+}
+export function deletePluginScheme(workflowId, pluginId, schemeName) {
+    store.deletePluginScheme(workflowId, pluginId, schemeName);
+}
 export function mapWorkflowToTaskDrafts(template) {
     const dependsOn = new Map();
     for (const node of template.nodes) {
@@ -180,41 +309,75 @@ export function mapWorkflowToTaskDrafts(template) {
         dependsOn.get(edge.target)?.push(edge.source);
     }
     return template.nodes.map(node => {
+        const label = getLabel(node);
         if (node.type === 'command') {
             return {
                 key: node.id,
-                title: node.data.label,
-                description: `Run command: ${node.data.label}`,
+                title: label,
+                description: `Run command: ${label}`,
                 agentConfigId: undefined,
                 dependsOnKeys: dependsOn.get(node.id)?.length ? dependsOn.get(node.id) : undefined,
                 sandboxDirs: undefined,
                 commandNode: node,
             };
         }
+        const agentData = getAgentData(node);
+        const taskTitle = (agentData?.taskTitleTemplate || label);
+        const taskDesc = agentData?.taskDescriptionTemplate || `Task assigned to ${label} (${agentData?.role || 'unknown'})`;
         return {
             key: node.id,
-            title: node.data.taskTitleTemplate || node.data.label,
-            description: node.data.taskDescriptionTemplate || `Task assigned to ${node.data.label} (${node.data.role})`,
-            agentConfigId: node.data.agentConfigId,
+            title: taskTitle,
+            description: taskDesc,
+            agentConfigId: agentData?.agentConfigId,
             dependsOnKeys: dependsOn.get(node.id)?.length ? dependsOn.get(node.id) : undefined,
             sandboxDirs: undefined,
         };
     });
 }
-// --- Run-time Validation ---
+// ---- Run-time Validation ----
 export function validateWorkflowForRun(_workspaceId, template, memberAgentIds) {
     const agentMap = new Map(listTemplates().map((a) => [a.id, a]));
     for (const node of template.nodes) {
         if (node.type === 'command')
             continue;
-        const agent = agentMap.get(node.data.agentConfigId);
+        const agentData = getAgentData(node);
+        if (!agentData)
+            continue;
+        const label = getLabel(node);
+        const agent = agentMap.get(agentData.agentConfigId);
         if (!agent)
-            return `Agent "${node.data.label}" (${node.data.agentConfigId}) no longer exists`;
+            return `Agent "${label}" (${agentData.agentConfigId}) no longer exists`;
         if (!agent.enabled)
             return `Agent "${agent.name}" is disabled`;
-        if (!memberAgentIds.has(node.data.agentConfigId))
+        if (!memberAgentIds.has(agentData.agentConfigId))
             return `Agent "${agent.name}" is not in the issue channel members`;
     }
     return null;
 }
+// ---- Cron Validation ----
+export function validateCron(cronExpr) {
+    try {
+        const { validate } = require('node-cron');
+        if (!validate(cronExpr)) {
+            return { valid: false, nextRuns: [], error: 'Invalid cron expression' };
+        }
+    }
+    catch {
+        // If node-cron validate fails to load, continue with cron-parser
+    }
+    try {
+        const CronExpressionParser = require('cron-parser');
+        const interval = CronExpressionParser.parse(cronExpr);
+        const nextRuns = [];
+        for (let i = 0; i < 5; i++) {
+            const iso = interval.next().toISOString();
+            if (iso)
+                nextRuns.push(iso);
+        }
+        return { valid: true, nextRuns };
+    }
+    catch (err) {
+        return { valid: false, nextRuns: [], error: err.message };
+    }
+}
 //# sourceMappingURL=workflow.js.map

package/dist/storage/agent-store.js

@@ -149,6 +149,7 @@ export function getAgentUsageDashboard(days = 30) {
         dailyMap.set(key, {
             date: key,
             label: date.toLocaleDateString('en-US', { weekday: 'short' }),
+            requests: 0,
             inputTokens: 0,
             outputTokens: 0,
             totalTokens: 0,
@@ -161,6 +162,7 @@ export function getAgentUsageDashboard(days = 30) {
     for (const record of records) {
         const day = dailyMap.get(record.completedAt.slice(0, 10));
         if (day) {
+            day.requests += 1;
             day.inputTokens += record.inputTokens + record.cachedInputTokens;
             day.outputTokens += record.outputTokens + record.reasoningTokens;
             day.totalTokens += record.totalTokens;
@@ -323,4 +325,10 @@ function findConfiguredModelCost(model) {
         outputPerMillion: toMoney(configured.cost.outputPerMillion),
     };
 }
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}
 //# sourceMappingURL=agent-store.js.map