@agent-spaces/server 0.3.65 → 0.3.67

package/dist/agents/pull-request-agent.js

@@ -0,0 +1,115 @@
+import * as agentService from '../services/agent.js';
+import { AGENT_GENERATOR_PRESET_ID } from '../services/agent.js';
+import { createAgentRuntime } from '../adapters/agent-runtime.js';
+import { getWorkspace } from '../storage/workspace-store.js';
+import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
+import { prependPersistentAgentContext } from '../services/persistent-agent-context.js';
+const DEFAULT_SYSTEM_PROMPT = [
+    'You are a pull request description generator.',
+    'Return a concise, useful PR body based only on the provided commits and diff.',
+    'Use Markdown with these sections: Summary and Changes.',
+    'Keep it short. Do not greet, explain your process, ask questions, provide options, or wrap the response in code fences.',
+    'Output only the final PR body text.',
+].join(' ');
+export async function runPullRequestAgent(workspaceId, input) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    if (!input.diff.trim() && input.commits.length === 0)
+        throw new Error('No changes found');
+    const agent = findPullRequestAgent(workspaceId);
+    const session = agentService.getOrCreateSessionForConfig(workspaceId, agent);
+    agentService.updateStatus(workspaceId, session.id, 'active');
+    const runtime = createAgentRuntime({
+        kind: agent.runtimeKind,
+        provider: agent.modelProvider,
+        model: agent.modelId,
+        apiKey: agent.apiKey,
+        baseURL: agent.apiBase,
+        ...getThinkingRuntimeConfig(agent),
+    });
+    const workingDir = agentService.resolveWorkingDir(workspaceId, agent);
+    const systemPrompt = DEFAULT_SYSTEM_PROMPT;
+    const truncatedDiff = input.diff.length > 12000
+        ? `${input.diff.substring(0, 12000)}\n... (truncated)`
+        : input.diff;
+    const userPrompt = [
+        `Generate a pull request body for branch ${input.worktree.branch} targeting ${input.baseBranch}.`,
+        '',
+        'Commits:',
+        input.commits.length > 0 ? input.commits.map((commit) => `- ${commit}`).join('\n') : '- No commit messages available',
+        '',
+        'Diff:',
+        truncatedDiff,
+    ].join('\n');
+    const result = await runtime.execute(prependPersistentAgentContext(userPrompt, {
+        workspaceId,
+        workingDir,
+        boundDirs: ws.boundDirs,
+        includeWorkspacePrompt: false,
+        excludeNativeClaudeMd: agent.runtimeKind === 'claude-code',
+    }), workingDir, {
+        maxTurns: 1,
+        userPrompt,
+        systemPrompt,
+        outputStyle: agent.outputStyle,
+    });
+    agentService.complete(workspaceId, session.id, result.success ? undefined : result.error, {
+        runtime: agent.runtimeKind,
+        model: agent.modelId,
+        summary: result.summary,
+        output: result.output,
+        usage: result.usage,
+        costUsd: result.costUsd,
+    });
+    if (!result.success) {
+        throw new Error(result.error || 'Pull request agent failed');
+    }
+    const body = sanitizePullRequestBody(result.output);
+    if (!body)
+        throw new Error('Empty response from pull request agent');
+    return body;
+}
+function findPullRequestAgent(workspaceId) {
+    const presets = agentService.listPresets(workspaceId);
+    const preset = presets?.find((a) => a.id === AGENT_GENERATOR_PRESET_ID);
+    if (preset)
+        return preset;
+    const template = agentService.readAgentTemplate(AGENT_GENERATOR_PRESET_ID);
+    if (template)
+        return template;
+    return agentService.listTemplates().find((a) => a.id === AGENT_GENERATOR_PRESET_ID) ?? agentService.listTemplates()[0];
+}
+function sanitizePullRequestBody(output) {
+    const chunks = (Array.isArray(output) ? output : [output])
+        .map((chunk) => cleanOutputChunk(chunk))
+        .filter(Boolean);
+    const uniqueChunks = dedupeAdjacentChunks(chunks);
+    return (uniqueChunks.at(-1) || uniqueChunks.join('\n\n')).trim();
+}
+function cleanOutputChunk(chunk) {
+    return chunk
+        .split('\n')
+        .filter((line) => !isRuntimeNoise(line))
+        .join('\n')
+        .replace(/```(?:\w+)?\n([\s\S]*?)```/g, '$1')
+        .trim();
+}
+function dedupeAdjacentChunks(chunks) {
+    const result = [];
+    for (const chunk of chunks) {
+        if (result.at(-1)?.trim() === chunk.trim())
+            continue;
+        result.push(chunk);
+    }
+    return result;
+}
+function isRuntimeNoise(line) {
+    const trimmed = line.trim();
+    return /^\[Usage\]/.test(trimmed)
+        || /^Claude Code initialized\b/i.test(trimmed)
+        || /^Codex initialized\b/i.test(trimmed)
+        || /^Tool:/i.test(trimmed)
+        || /^Todo:/i.test(trimmed);
+}
+//# sourceMappingURL=pull-request-agent.js.map

package/dist/agents/scheduler-agent.js

@@ -16,7 +16,7 @@ export function startScheduler(workspaceId, ctx) {
     const tick = async () => {
         // 检查 workspace 是否关闭了自动处理
         const workspace = workspaceService.getById(workspaceId);
-        if (workspace && workspace.autoProcessIssues === false) {
+        if (workspace && workspace.autoProcessIssues !== true) {
             console.log(`[scheduler:${workspaceId}] auto-processing disabled for this workspace, skip`);
             return;
         }

package/dist/app.js

@@ -33,16 +33,18 @@ import searchRouter from './routes/search.js';
 import notificationRouter from './routes/notification.js';
 import databaseRouter from './routes/database.js';
 import kanbanRouter from './routes/kanban.js';
+import { worktreeRouter } from './routes/worktree.js';
 import speechRecognitionRouter, { handleSpeechStream } from './routes/speech-recognition.js';
 import agentCommandsRouter from './routes/agent-commands.js';
 import robotAccountRouter from './routes/robot-account.js';
+import versionRouter from './routes/version.js';
 import { getUserSettings, setUserAvatarUrl, removeUserAvatarUrl } from './storage/user-settings-store.js';
 import { authMiddleware, verifyToken } from './middleware/auth.js';
 import { handleConnection } from './ws/handler.js';
 import { handleTypeScriptLspConnection } from './ws/typescript-lsp.js';
 import { broadcastToAll } from './ws/connection-manager.js';
 import { startScheduler, stopScheduler } from './agents/scheduler-agent.js';
-import { recoverRunningWorkOnStartup } from './services/issue-retry.js';
+// import { recoverRunningWorkOnStartup } from './services/issue-retry.js';
 import { startPersistedNotificationServices } from './services/notification-hub/index.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PORT = parseInt(process.env.PORT || '3100', 10);
@@ -191,6 +193,7 @@ app.post('/api/git-config', async (req, res) => {
 app.use('/api/workspaces/:id/search', searchRouter);
 app.use('/api/workspaces/:id/database', databaseRouter);
 app.use('/api/workspaces/:id/kanban', kanbanRouter);
+app.use('/api/workspaces/:id/worktrees', worktreeRouter);
 app.use('/api/workspaces/:id/notifications', notificationRouter);
 app.use('/api/agents', agentRouter);
 app.use('/api', llmRouter);
@@ -203,6 +206,7 @@ app.use('/api/subscriptions', subscriptionRouter);
 app.use('/api/speech-recognition', speechRecognitionRouter);
 app.use('/api/agent-commands', agentCommandsRouter);
 app.use('/api/robot-accounts', robotAccountRouter);
+app.use('/api', versionRouter);
 // Serve static web frontend in production (after API routes, before catch-all)
 const webDir = resolveRuntimeDir('web');
 if (existsSync(webDir)) {
@@ -296,7 +300,7 @@ const HOST = process.env.HOST || '0.0.0.0';
 server.listen(PORT, HOST, () => {
     console.log(`[server] listening on http://${HOST}:${PORT}`);
     console.log(`[server] websocket on ws://${HOST}:${PORT}/ws?workspaceId=...`);
-    recoverRunningWorkOnStartup();
+    // recoverRunningWorkOnStartup();
     startPersistedNotificationServices().catch((err) => {
         console.error('[notification] failed to restore persisted services:', err);
     });

package/dist/middleware/auth.js

@@ -1,7 +1,7 @@
 import { getSecret } from '../services/auth-store.js';
 export function authMiddleware(req, res, next) {
     const secret = getSecret();
-    const openPaths = ['/api/health', '/api/auth/login', '/api/auth/check'];
+    const openPaths = ['/api/health', '/api/auth/login', '/api/auth/check', '/api/version', '/api/version/check'];
     if (openPaths.includes(req.path))
         return next();
     const auth = req.headers.authorization;

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-spaces/server",
-  "version": "0.3.64",
+  "version": "0.3.66",
   "type": "module",
   "main": "app.js",
   "packageManager": "pnpm@10.17.1",
@@ -16,6 +16,7 @@
     "@langchain/google-genai": "^2.1.30",
     "@langchain/openai": "^1.4.5",
     "@larksuiteoapi/node-sdk": "^1.62.1",
+    "@modelcontextprotocol/sdk": "1.29.0",
     "@openai/codex-sdk": "^0.128.0",
     "cors": "^2.8.5",
     "dotenv": "^17.4.2",

package/dist/routes/agent-sse.js

@@ -67,6 +67,7 @@ router.post('/run', async (req, res) => {
         agentService.updateStatus(workspaceId, session.id, 'active');
         writeSse(res, 'status', { agentId: session.id, status: 'active' });
         const result = await runtime.execute(buildAgentPrompt(workspaceId, body.systemPrompt ?? preset.systemPrompt, userPrompt, normalizeMessages(body.messages), {
+            runtimeKind: preset.runtimeKind,
             mcpServers: Object.keys(mcpServers ?? {}),
             skills,
             boundDirs: workspace.boundDirs,

package/dist/routes/issue.js

@@ -313,7 +313,7 @@ function mergeWorkflowMembers(members, workflowId) {
         return base;
     return Array.from(new Set([
         ...base,
-        ...workflow.nodes.map((node) => node.data.agentConfigId).filter(Boolean),
+        ...workflow.nodes.filter((n) => n.type === 'agent').map((node) => node.data.agentConfigId).filter(Boolean),
     ]));
 }
 //# sourceMappingURL=issue.js.map

package/dist/routes/notification.js

@@ -27,5 +27,15 @@ router.delete('/', (req, res) => {
     nc.clearAll(workspaceId);
     res.json({ ok: true });
 });
+router.delete('/:notificationId', (req, res) => {
+    const workspaceId = req.params.id;
+    const notificationId = req.params.notificationId;
+    const removed = nc.removeNotification(workspaceId, notificationId);
+    if (!removed) {
+        res.status(404).json({ error: 'Not found' });
+        return;
+    }
+    res.json({ ok: true });
+});
 export default router;
 //# sourceMappingURL=notification.js.map

package/dist/routes/version.js

@@ -0,0 +1,94 @@
+import { Router } from 'express';
+import { spawn } from 'node:child_process';
+import { writeFileSync, unlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { getLocalVersion, getCachedLatest, fetchLatestVersion, isNewerVersion } from '../services/version.js';
+const router = Router();
+const isDev = !process.env.NODE_ENV || process.env.NODE_ENV === 'development';
+let isUpdating = false;
+// GET /version — cached version info (openPaths in auth.ts)
+router.get('/version', async (_req, res) => {
+    const local = getLocalVersion();
+    if (isDev) {
+        res.json({ local, latest: null, updateAvailable: false, dev: true });
+        return;
+    }
+    let latest = getCachedLatest();
+    if (!latest) {
+        latest = await fetchLatestVersion(false);
+    }
+    res.json({ local, latest, updateAvailable: latest ? isNewerVersion(latest, local) : false });
+});
+// GET /version/check — force npm lookup (openPaths in auth.ts)
+router.get('/version/check', async (_req, res) => {
+    const local = getLocalVersion();
+    if (isDev) {
+        res.json({ local, latest: null, updateAvailable: false, dev: true });
+        return;
+    }
+    const latest = await fetchLatestVersion(true);
+    res.json({
+        local,
+        latest,
+        updateAvailable: latest ? isNewerVersion(latest, local) : false,
+    });
+});
+// POST /version/update — trigger self-update (requires auth)
+router.post('/version/update', (_req, res) => {
+    if (isDev) {
+        res.status(403).json({ error: 'Updates are disabled in development mode' });
+        return;
+    }
+    if (isUpdating) {
+        res.status(409).json({ error: 'Update already in progress' });
+        return;
+    }
+    isUpdating = true;
+    const pid = process.pid;
+    const ppid = process.ppid;
+    const projectRoot = join(import.meta.dirname, '..', '..');
+    const isWin = process.platform === 'win32';
+    let scriptPath;
+    if (isWin) {
+        scriptPath = join(tmpdir(), `agent-spaces-update-${pid}.cmd`);
+        const cmd = [
+            '@echo off',
+            'timeout /t 2 /nobreak >nul',
+            `taskkill /pid ${ppid} /f /t >nul 2>&1`,
+            `taskkill /pid ${pid} /f /t >nul 2>&1`,
+            `cd /d "${projectRoot}"`,
+            'call pnpm install',
+            'call pnpm start',
+        ].join('\r\n');
+        writeFileSync(scriptPath, cmd, 'utf-8');
+    }
+    else {
+        scriptPath = join(tmpdir(), `agent-spaces-update-${pid}.sh`);
+        const sh = [
+            '#!/bin/sh',
+            'sleep 2',
+            `kill -9 ${ppid} 2>/dev/null || true`,
+            `kill -9 ${pid} 2>/dev/null || true`,
+            `cd "${projectRoot}"`,
+            'pnpm install',
+            'pnpm start',
+        ].join('\n');
+        writeFileSync(scriptPath, sh, 'utf-8');
+    }
+    const child = spawn(isWin ? 'cmd' : '/bin/sh', isWin ? ['/c', scriptPath] : [scriptPath], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    child.unref();
+    setTimeout(() => {
+        try {
+            unlinkSync(scriptPath);
+        }
+        catch { }
+    }, 10_000);
+    res.json({ ok: true });
+});
+export default router;
+//# sourceMappingURL=version.js.map

package/dist/routes/worktree.js

@@ -0,0 +1,93 @@
+import { Router } from 'express';
+import { z } from 'zod';
+import { listWorkspaceWorktrees, getWorkspaceWorktree, createWorkspaceWorktree, deleteWorkspaceWorktree, getWorktreeDiff, createWorktreePR, mergeWorktreePR, getWorktreePRDraft, } from '../services/worktree.js';
+export const worktreeRouter = Router({ mergeParams: true });
+const createSchema = z.object({
+    name: z.string().min(1),
+    branch: z.string().optional(),
+    agentId: z.string().optional(),
+    issueId: z.string().optional(),
+    taskId: z.string().optional(),
+});
+const prSchema = z.object({
+    title: z.string().optional(),
+    body: z.string().optional(),
+});
+const prDraftSchema = z.object({
+    title: z.string().optional(),
+});
+worktreeRouter.get('/', (req, res) => {
+    const { id } = req.params;
+    res.json(listWorkspaceWorktrees(id));
+});
+worktreeRouter.post('/', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const input = createSchema.parse(req.body);
+        const info = await createWorkspaceWorktree(id, input);
+        res.status(201).json(info);
+    }
+    catch (err) {
+        res.status(400).json({ error: err.message });
+    }
+});
+worktreeRouter.get('/:wtId', (req, res) => {
+    const { id, wtId } = req.params;
+    const info = getWorkspaceWorktree(id, wtId);
+    if (!info)
+        return res.status(404).json({ error: 'Worktree not found' });
+    res.json(info);
+});
+worktreeRouter.delete('/:wtId', async (req, res) => {
+    try {
+        const { id, wtId } = req.params;
+        await deleteWorkspaceWorktree(id, wtId);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(400).json({ error: err.message });
+    }
+});
+worktreeRouter.get('/:wtId/diff', async (req, res) => {
+    try {
+        const { id, wtId } = req.params;
+        const diffs = await getWorktreeDiff(id, wtId);
+        res.json(diffs);
+    }
+    catch (err) {
+        res.status(400).json({ error: err.message });
+    }
+});
+worktreeRouter.post('/:wtId/pr', async (req, res) => {
+    try {
+        const { id, wtId } = req.params;
+        const { title, body } = prSchema.parse(req.body);
+        const prUrl = await createWorktreePR(id, wtId, title, body);
+        res.json({ prUrl });
+    }
+    catch (err) {
+        res.status(400).json({ error: err.message });
+    }
+});
+worktreeRouter.post('/:wtId/pr/draft', async (req, res) => {
+    try {
+        const { id, wtId } = req.params;
+        const { title } = prDraftSchema.parse(req.body);
+        const draft = await getWorktreePRDraft(id, wtId, title);
+        res.json(draft);
+    }
+    catch (err) {
+        res.status(400).json({ error: err.message });
+    }
+});
+worktreeRouter.post('/:wtId/merge', async (req, res) => {
+    try {
+        const { id, wtId } = req.params;
+        await mergeWorktreePR(id, wtId);
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(400).json({ error: err.message });
+    }
+});
+//# sourceMappingURL=worktree.js.map

package/dist/services/agent.js

@@ -11,7 +11,7 @@ import { extractUsageFromOutput } from '../storage/usage.js';
 const DEFAULT_AGENT_ROLE = 'agent';
 export const AGENT_GENERATOR_PRESET_ID = 'agent-generator';
 export const AGENT_COMMIT_PRESET_ID = 'commit-agent';
-const VALID_RUNTIME_KINDS = ['open-agent-sdk', 'claude-code', 'codex', 'langchain'];
+const VALID_RUNTIME_KINDS = ['open-agent-sdk', 'claude-code', 'codex', 'langchain', 'hermes'];
 const VALID_TOOL_NAMES = new Set(BUILT_IN_AGENT_TOOLS.map((tool) => tool.name));
 const CLAUDE_BUILT_IN_DIRS = ['agents', 'commands'];
 const ANTHROPIC_BRIDGE_PROVIDERS = [

package/dist/services/notification-center.js

@@ -46,6 +46,15 @@ export function clearAll(workspaceId) {
     writeAll(workspaceId, []);
     broadcastToWorkspace(workspaceId, 'notification.cleared', null);
 }
+export function removeNotification(workspaceId, notificationId) {
+    const all = readAll(workspaceId);
+    const idx = all.findIndex((n) => n.id === notificationId);
+    if (idx === -1)
+        return null;
+    const [removed] = all.splice(idx, 1);
+    writeAll(workspaceId, all);
+    return removed;
+}
 export function unreadCount(workspaceId) {
     return readAll(workspaceId).filter((n) => !n.read).length;
 }

package/dist/services/version.js

@@ -0,0 +1,59 @@
+import { 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;
+    try {
+        const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+        localVersion = pkg.version || '0.0.0';
+    }
+    catch {
+        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,23 @@
+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();
+    return new Promise((resolve) => {
+        exec(node.data.script, {
+            cwd,
+            env: { ...process.env, ...node.data.env },
+            shell: node.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.js

@@ -72,6 +72,8 @@ 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);
         if (!agent) {
             invalidIds.push(node.id);
@@ -177,19 +179,34 @@ 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 => {
+        if (node.type === 'command') {
+            return {
+                key: node.id,
+                title: node.data.label,
+                description: `Run command: ${node.data.label}`,
+                agentConfigId: undefined,
+                dependsOnKeys: dependsOn.get(node.id)?.length ? dependsOn.get(node.id) : undefined,
+                sandboxDirs: undefined,
+                commandNode: node,
+            };
+        }
+        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,
+            dependsOnKeys: dependsOn.get(node.id)?.length ? dependsOn.get(node.id) : undefined,
+            sandboxDirs: undefined,
+        };
+    });
 }
 // --- 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);
         if (!agent)
             return `Agent "${node.data.label}" (${node.data.agentConfigId}) no longer exists`;

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