@agent-spaces/server 0.3.65 → 0.4.0

package/dist/services/search.js

@@ -1,7 +1,7 @@
 // packages/server/src/services/search.ts
-import { execSync } from 'node:child_process';
+import { execFileSync } from 'node:child_process';
 import { readdir, stat, readFile } from 'node:fs/promises';
-import { join, relative } from 'node:path';
+import { isAbsolute, join, relative, resolve } from 'node:path';
 import { minimatch } from 'minimatch';
 import { resolvePath } from './file.js';
 import { createGitignoreFilter } from './gitignore.js';
@@ -13,8 +13,15 @@ function isBinaryPath(path) {
     const ext = path.split('.').pop()?.toLowerCase() || '';
     return BINARY_EXTENSIONS.has(`.${ext}`) || ext === path;
 }
+function toWorkspaceRelativePath(basePath, path) {
+    const absPath = isAbsolute(path) ? resolve(path) : resolve(basePath, path);
+    const relPath = relative(basePath, absPath);
+    if (relPath.startsWith('..') || isAbsolute(relPath))
+        return null;
+    return relPath;
+}
 function searchWithRipgrep(basePath, options) {
-    const args = ['rg', '--json', '--max-count', String(options.maxResults || 200)];
+    const args = ['--json', '--max-count', String(options.maxResults || 200)];
     if (!options.caseSensitive)
         args.push('-i');
     if (options.regex) {
@@ -25,9 +32,10 @@ function searchWithRipgrep(basePath, options) {
     }
     if (options.filePattern)
         args.push('--glob', options.filePattern);
-    args.push('--', '.', basePath);
+    args.push('--', '.');
     try {
-        const output = execSync(args.join(' '), {
+        const output = execFileSync('rg', args, {
+            cwd: basePath,
             encoding: 'utf-8',
             maxBuffer: 50 * 1024 * 1024,
             timeout: 30000,
@@ -40,7 +48,9 @@ function searchWithRipgrep(basePath, options) {
                 const parsed = JSON.parse(line);
                 if (parsed.type !== 'match')
                     continue;
-                const filePath = relative(basePath, parsed.data.path.text);
+                const filePath = toWorkspaceRelativePath(basePath, parsed.data.path.text);
+                if (!filePath)
+                    continue;
                 const text = parsed.data.lines.text.trimEnd();
                 const sub = parsed.data.submatches[0];
                 if (!sub)

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

@@ -0,0 +1,69 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+let localVersion = '';
+let cachedLatest = null;
+const CACHE_TTL = 3600_000; // 1 hour
+export function getLocalVersion() {
+    if (localVersion !== '')
+        return localVersion;
+    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() {
+    if (cachedLatest && Date.now() - cachedLatest.ts < CACHE_TTL) {
+        return cachedLatest.version;
+    }
+    return null;
+}
+export async function fetchLatestVersion(forceRefresh = false) {
+    if (!forceRefresh && cachedLatest && Date.now() - cachedLatest.ts < CACHE_TTL) {
+        return cachedLatest.version;
+    }
+    try {
+        const res = await fetch('https://registry.npmjs.org/@agent-spaces/server', {
+            signal: AbortSignal.timeout(8000),
+        });
+        if (!res.ok)
+            return cachedLatest?.version ?? null;
+        const data = await res.json();
+        const latest = data?.['dist-tags']?.latest;
+        if (latest) {
+            cachedLatest = { version: latest, ts: Date.now() };
+        }
+        return latest ?? cachedLatest?.version ?? null;
+    }
+    catch {
+        return cachedLatest?.version ?? null;
+    }
+}
+export function isNewerVersion(latest, local) {
+    const parse = (v) => v.replace(/^v/, '').split('.').map(Number);
+    const a = parse(latest);
+    const b = parse(local);
+    for (let i = 0; i < 3; i++) {
+        if ((a[i] || 0) > (b[i] || 0))
+            return true;
+        if ((a[i] || 0) < (b[i] || 0))
+            return false;
+    }
+    return false;
+}
+//# sourceMappingURL=version.js.map

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

@@ -0,0 +1,24 @@
+import { exec } from 'child_process';
+import { getWorkspace } from '../storage/workspace-store.js';
+export async function executeCommandNode(workspaceId, node) {
+    const workspace = getWorkspace(workspaceId);
+    const data = node.data;
+    const cwd = data.cwd || workspace?.boundDirs?.[0] || process.cwd();
+    return new Promise((resolve) => {
+        exec(data.script, {
+            cwd,
+            env: { ...process.env, ...data.env },
+            shell: data.shell || undefined,
+            timeout: 300_000,
+            maxBuffer: 10 * 1024 * 1024,
+        }, (error, stdout, stderr) => {
+            resolve({
+                success: !error,
+                exitCode: error ? (typeof error.code === 'number' ? error.code : 1) : 0,
+                stdout: stdout || '',
+                stderr: stderr || '',
+            });
+        });
+    });
+}
+//# sourceMappingURL=workflow-command-runner.js.map

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,12 +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 => {
-        const agent = agentMap.get(node.data.agentConfigId);
+        if (node.type === 'command')
+            return node;
+        const agentData = getAgentData(node);
+        if (!agentData)
+            return node;
+        const agent = agentMap.get(agentData.agentConfigId);
         if (!agent) {
             invalidIds.push(node.id);
             return node;
@@ -89,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;
@@ -138,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(),
@@ -166,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) {
@@ -177,27 +308,76 @@ export function mapWorkflowToTaskDrafts(template) {
     for (const edge of template.edges) {
         dependsOn.get(edge.target)?.push(edge.source);
     }
-    return template.nodes.map(node => ({
-        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,
-        dependsOnKeys: dependsOn.get(node.id)?.length ? dependsOn.get(node.id) : undefined,
-        sandboxDirs: undefined,
-    }));
+    return template.nodes.map(node => {
+        const label = getLabel(node);
+        if (node.type === 'command') {
+            return {
+                key: node.id,
+                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: 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) {
-        const agent = agentMap.get(node.data.agentConfigId);
+        if (node.type === 'command')
+            continue;
+        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/services/workspace.js

@@ -1,5 +1,6 @@
 import { v4 as uuid } from 'uuid';
 import { listWorkspaces, getWorkspace, createWorkspace, updateWorkspace, deleteWorkspace } from '../storage/workspace-store.js';
+import { listWorktrees } from '../storage/worktree-store.js';
 import { ensureDir } from '../storage/json-store.js';
 import { join } from 'node:path';
 import { existsSync, writeFileSync } from 'node:fs';
@@ -21,7 +22,14 @@ function initAgentspace(agentspaceDir) {
     }
 }
 export function getAll() {
-    return listWorkspaces();
+    const workspaces = listWorkspaces();
+    const workspaceIds = new Set(workspaces.map((workspace) => workspace.id));
+    const worktreeWorkspaces = workspaces
+        .filter((workspace) => !workspace.isWorktree)
+        .flatMap((workspace) => listWorktrees(workspace.id)
+        .filter((worktree) => worktree.status === 'active' && !workspaceIds.has(worktree.id))
+        .map(worktreeToWorkspace));
+    return [...workspaces, ...worktreeWorkspaces];
 }
 export function getById(id) {
     return getWorkspace(id);
@@ -72,4 +80,18 @@ export function remove(id) {
     deleteWorkspace(id);
     return true;
 }
+function worktreeToWorkspace(worktree) {
+    return {
+        id: worktree.id,
+        name: `${worktree.name} (Worktree)`,
+        boundDirs: [worktree.path],
+        agentspaceDir: join(worktree.path, '.agentspace'),
+        isWorktree: true,
+        parentWorkspaceId: worktree.workspaceId,
+        createdAt: worktree.createdAt,
+        updatedAt: worktree.updatedAt,
+        activeChannels: [],
+        activeIssues: [],
+    };
+}
 //# sourceMappingURL=workspace.js.map