@mrpatronz/nexusflow 2.2.0 → 2.3.0

package/dist/server.test.js

@@ -2,12 +2,15 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { execa } from 'execa';
-import { AgentTurnGate, app, dispatchAgentInput, isAllowedUpdateUrl } from './server.js';
+import { AgentTurnGate, app, canOfferClaudeDesktopTransfer, dispatchAgentInput, isAllowedUpdateUrl } from './server.js';
 import * as workspace from './core/workspace.js';
 import * as config from './core/config.js';
 import * as analyzers from './analyzers/index.js';
 import * as generators from './generators/index.js';
 import * as workflows from './utils/workflows.js';
+import * as skillsCatalog from './utils/skills-catalog.js';
+import * as agentsCatalog from './resources/agents-catalog.js';
+import * as resourceService from './resources/service.js';
 import * as detectAi from './utils/detect-ai.js';
 import * as newRepo from './core/new-repo.js';
 import * as orchestration from './orchestration/index.js';
@@ -23,6 +26,16 @@ vi.mock('./utils/update-check.js');
 vi.mock('./analyzers/index.js');
 vi.mock('./generators/index.js');
 vi.mock('./utils/workflows.js');
+vi.mock('./utils/skills-catalog.js');
+vi.mock('./resources/agents-catalog.js');
+vi.mock('./resources/service.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        withResourceAdministrationLock: vi.fn((operation) => operation()),
+        validateResourceSelections: vi.fn().mockResolvedValue(undefined),
+    };
+});
 vi.mock('./utils/detect-ai.js', () => ({
     detectAIAssistants: vi.fn().mockResolvedValue([])
 }));
@@ -329,7 +342,7 @@ describe('Server API Endpoints Unit Tests', () => {
         it('launches Codex with a once-encoded validated workspace path', async () => {
             const platform = vi.spyOn(process, 'platform', 'get').mockReturnValue('win32');
             vi.mocked(execa).mockImplementation((async (command) => ({
-                exitCode: command === 'reg.exe' || command === 'explorer.exe' ? 0 : 1,
+                exitCode: command === 'reg.exe' || command === 'cmd.exe' ? 0 : 1,
             })));
             try {
                 const response = await app.request('/api/workspace/safe-workspace/launch', {
@@ -339,7 +352,14 @@ describe('Server API Endpoints Unit Tests', () => {
                 });
                 expect(response.status).toBe(200);
                 const prompt = 'Read the workspace instructions and implementation plan, inspect the repository state, then begin the task described for this workspace. Ask before making a decision that materially changes scope.\n\nWorkspace task: Improve the local Desktop handoff';
-                expect(execa).toHaveBeenCalledWith('explorer.exe', [`codex://threads/new?path=${encodeURIComponent(workspacePath)}&prompt=${encodeURIComponent(prompt)}`], { shell: false });
+                expect(execa).toHaveBeenCalledWith('cmd.exe', ['/d', '/v:off', '/s', '/c', 'start "" "%NEXUSFLOW_DESKTOP_URI%"'], {
+                    env: {
+                        NEXUSFLOW_DESKTOP_URI: `codex://threads/new?path=${encodeURIComponent(workspacePath)}&prompt=${encodeURIComponent(prompt)}`,
+                    },
+                    shell: false,
+                    windowsHide: true,
+                    windowsVerbatimArguments: true,
+                });
             }
             finally {
                 platform.mockRestore();
@@ -358,7 +378,12 @@ describe('Server API Endpoints Unit Tests', () => {
                     body: JSON.stringify({ targetId: 'codex-desktop', action: 'resume', sessionId }),
                 });
                 expect(response.status).toBe(200);
-                expect(execa).toHaveBeenCalledWith('explorer.exe', [`codex://threads/${sessionId}`], { shell: false });
+                expect(execa).toHaveBeenCalledWith('cmd.exe', ['/d', '/v:off', '/s', '/c', 'start "" "%NEXUSFLOW_DESKTOP_URI%"'], {
+                    env: { NEXUSFLOW_DESKTOP_URI: `codex://threads/${sessionId}` },
+                    shell: false,
+                    windowsHide: true,
+                    windowsVerbatimArguments: true,
+                });
             }
             finally {
                 authorizeSession.mockRestore();
@@ -384,7 +409,7 @@ describe('Server API Endpoints Unit Tests', () => {
                 await expect(response.json()).resolves.toEqual({
                     error: 'Codex session not found in this workspace.',
                 });
-                expect(execa).not.toHaveBeenCalledWith('explorer.exe', expect.anything(), expect.anything());
+                expect(execa).not.toHaveBeenCalledWith('cmd.exe', expect.anything(), expect.anything());
             }
             finally {
                 authorizeSession.mockRestore();
@@ -392,6 +417,117 @@ describe('Server API Endpoints Unit Tests', () => {
             }
         });
     });
+    describe('workspace recent session handoffs', () => {
+        const workspacesDir = path.resolve('session-workspaces');
+        const workspacePath = path.join(workspacesDir, 'safe-workspace');
+        const codexId = '0199a213-81c0-7800-8aa1-bbab2a035a53';
+        const claudeId = '0199a213-81c0-7800-8aa1-bbab2a035a54';
+        const unauthorizedCodexId = '0199a213-81c0-7800-8aa1-bbab2a035a55';
+        it('returns only server-authorized Desktop handoff capabilities', async () => {
+            vi.spyOn(config, 'loadConfig').mockResolvedValue({ workspacesDir });
+            vi.mocked(fs.realpath).mockImplementation(async (candidate) => path.resolve(String(candidate)));
+            vi.mocked(workspace.loadWorkspaceManifest).mockResolvedValue({
+                id: 'safe-workspace',
+                repos: [path.join(workspacePath, 'repo')],
+                workspacePath,
+            });
+            const find = vi.spyOn(sessionFinder, 'findSessions').mockResolvedValue([
+                {
+                    id: 'copilot-session', assistant: 'copilot', title: 'Newer Copilot task',
+                    createdAt: '2026-08-16T03:00:00.000Z', updatedAt: '2026-08-16T03:00:00.000Z',
+                    messageCount: 2, workspacePath,
+                },
+                {
+                    id: 'antigravity-session', assistant: 'antigravity', title: 'Newer Antigravity task',
+                    createdAt: '2026-08-16T02:00:00.000Z', updatedAt: '2026-08-16T02:00:00.000Z',
+                    messageCount: 2, workspacePath,
+                },
+                {
+                    id: unauthorizedCodexId, assistant: 'codex', title: 'Fuzzy Codex task',
+                    createdAt: '2026-08-16T01:00:00.000Z', updatedAt: '2026-08-16T01:00:00.000Z',
+                    messageCount: 2, workspacePath,
+                },
+                {
+                    id: codexId, assistant: 'codex', title: 'Codex task',
+                    createdAt: '2026-08-15T00:00:00.000Z', updatedAt: '2026-08-16T00:00:00.000Z',
+                    messageCount: 4, workspacePath,
+                },
+                {
+                    id: claudeId, assistant: 'claude', title: 'Claude task',
+                    createdAt: '2026-08-14T00:00:00.000Z', updatedAt: '2026-08-15T00:00:00.000Z',
+                    messageCount: 2, workspacePath,
+                },
+            ]);
+            const codexAuth = vi.spyOn(sessionFinder, 'canOpenCodexSessionInWorkspace')
+                .mockImplementation(async (_workspace, _repos, sessionId) => sessionId === codexId);
+            const claudeAuth = vi.spyOn(sessionFinder, 'canTransferClaudeSessionInWorkspace').mockResolvedValue(true);
+            const platform = vi.spyOn(process, 'platform', 'get').mockReturnValue('win32');
+            const architecture = vi.spyOn(process, 'arch', 'get').mockReturnValue('x64');
+            vi.stubEnv('ANTHROPIC_API_KEY', '');
+            vi.stubEnv('ANTHROPIC_AUTH_TOKEN', '');
+            vi.stubEnv('CLAUDE_CODE_USE_BEDROCK', '');
+            vi.stubEnv('CLAUDE_CODE_USE_VERTEX', '');
+            vi.stubEnv('CLAUDE_CODE_USE_FOUNDRY', '');
+            const provider = vi.spyOn(ProviderRegistry, 'getProvider').mockReturnValue({
+                isConfigured: () => true,
+            });
+            try {
+                const response = await app.request('/api/workspace/safe-workspace/sessions?limit=2&desktopHandoffOnly=true');
+                const body = await response.json();
+                expect(response.status).toBe(200);
+                expect(body.sessions).toHaveLength(2);
+                expect(body.sessions[0].desktopHandoff).toEqual({ targetId: 'codex-desktop', method: 'direct' });
+                expect(body.sessions[1].desktopHandoff).toEqual({ targetId: 'claude-desktop', method: 'guided' });
+                expect(codexAuth).toHaveBeenCalledWith(workspacePath, [path.join(workspacePath, 'repo')], codexId);
+                expect(claudeAuth).toHaveBeenCalledWith(workspacePath, [path.join(workspacePath, 'repo')], claudeId);
+            }
+            finally {
+                find.mockRestore();
+                codexAuth.mockRestore();
+                claudeAuth.mockRestore();
+                provider.mockRestore();
+                platform.mockRestore();
+                architecture.mockRestore();
+                vi.unstubAllEnvs();
+            }
+        });
+        it('omits a discovered session when strong authorization fails', async () => {
+            vi.spyOn(config, 'loadConfig').mockResolvedValue({ workspacesDir });
+            vi.mocked(fs.realpath).mockImplementation(async (candidate) => path.resolve(String(candidate)));
+            vi.mocked(workspace.loadWorkspaceManifest).mockResolvedValue({
+                id: 'safe-workspace', repos: [], workspacePath,
+            });
+            const find = vi.spyOn(sessionFinder, 'findSessions').mockResolvedValue([{
+                    id: codexId, assistant: 'codex', title: 'Fuzzy match only',
+                    createdAt: '2026-08-15T00:00:00.000Z', updatedAt: '2026-08-16T00:00:00.000Z',
+                    messageCount: 2, workspacePath,
+                }]);
+            const codexAuth = vi.spyOn(sessionFinder, 'canOpenCodexSessionInWorkspace').mockResolvedValue(false);
+            try {
+                const response = await app.request('/api/workspace/safe-workspace/sessions?limit=3&desktopHandoffOnly=true');
+                expect(response.status).toBe(200);
+                await expect(response.json()).resolves.toEqual({ sessions: [] });
+            }
+            finally {
+                find.mockRestore();
+                codexAuth.mockRestore();
+            }
+        });
+        it('rejects an excessive recent-session limit', async () => {
+            const response = await app.request('/api/workspace/safe-workspace/sessions?limit=200');
+            expect(response.status).toBe(400);
+            await expect(response.json()).resolves.toEqual({ error: 'Session limit must be an integer from 1 to 20.' });
+        });
+        it('gates Claude Desktop transfer to supported subscription CLI environments', () => {
+            const configured = () => true;
+            expect(canOfferClaudeDesktopTransfer('win32', 'x64', {}, configured)).toBe(true);
+            expect(canOfferClaudeDesktopTransfer('darwin', 'arm64', {}, configured)).toBe(true);
+            expect(canOfferClaudeDesktopTransfer('linux', 'x64', {}, configured)).toBe(false);
+            expect(canOfferClaudeDesktopTransfer('win32', 'arm64', {}, configured)).toBe(false);
+            expect(canOfferClaudeDesktopTransfer('win32', 'x64', { ANTHROPIC_API_KEY: 'configured' }, configured)).toBe(false);
+            expect(canOfferClaudeDesktopTransfer('win32', 'x64', {}, () => false)).toBe(false);
+        });
+    });
     describe('POST /api/workspace/:id/resume', () => {
         it('should fail with 400 if command is forbidden', async () => {
             vi.spyOn(config, 'loadConfig').mockResolvedValue({
@@ -1030,5 +1166,229 @@ describe('Server API Endpoints Unit Tests', () => {
             expect(response.status).toBe(400);
         });
     });
+    describe('Skills & Categories Endpoints', () => {
+        it('GET /api/skills/categories returns default categories', async () => {
+            vi.mocked(skillsCatalog.getSkillCategories).mockResolvedValue([
+                {
+                    id: 'pull-requests',
+                    name: 'Pull Requests & Review',
+                    description: 'PR review skills',
+                    icon: 'git-pull-request',
+                    color: '#3b82f6',
+                    custom: false,
+                    isTemplate: true,
+                },
+            ]);
+            const response = await app.request('/api/skills/categories');
+            expect(response.status).toBe(200);
+            const data = await response.json();
+            expect(data.categories).toBeDefined();
+            expect(data.categories.length).toBe(1);
+            expect(data.categories[0].id).toBe('pull-requests');
+            expect(data.categories[0].isTemplate).toBe(true);
+        });
+        it('POST /api/skills/categories creates a custom category', async () => {
+            vi.mocked(skillsCatalog.saveSkillCategory).mockResolvedValue({
+                id: 'serverless-workflows',
+                name: 'Serverless Workflows',
+                description: 'AWS Lambda and Cloudflare workers',
+                icon: 'zap',
+                color: '#ec4899',
+                custom: true,
+                isTemplate: false,
+            });
+            const response = await app.request('/api/skills/categories', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    name: 'Serverless Workflows',
+                    description: 'AWS Lambda and Cloudflare workers',
+                    icon: 'zap',
+                    color: '#ec4899',
+                }),
+            });
+            expect(response.status).toBe(200);
+            const data = await response.json();
+            expect(data.success).toBe(true);
+            expect(data.category.id).toBe('serverless-workflows');
+            expect(data.category.custom).toBe(true);
+        });
+        it('GET /api/skills returns all skills', async () => {
+            vi.mocked(skillsCatalog.getAllSkills).mockResolvedValue([
+                {
+                    id: 'pr-review-toolkit',
+                    name: 'pr-review-toolkit',
+                    title: 'PR Review Toolkit',
+                    category: 'pull-requests',
+                    description: 'Review pull requests',
+                    custom: false,
+                    content: '# PR Review',
+                },
+            ]);
+            const response = await app.request('/api/skills');
+            expect(response.status).toBe(200);
+            const data = await response.json();
+            expect(data.skills).toBeDefined();
+            expect(data.skills.length).toBe(1);
+            expect(data.skills[0].id).toBe('pr-review-toolkit');
+        });
+        it('POST /api/skills creates a new skill package', async () => {
+            vi.mocked(skillsCatalog.saveSkill).mockResolvedValue({
+                id: 'graphql-linter',
+                name: 'graphql-linter',
+                title: 'GraphQL Schema Linter',
+                category: 'database-migrations',
+                description: 'Validates GraphQL schemas for deprecated fields',
+                custom: true,
+                content: '# GraphQL Schema Linter\n\nRun graphql-inspector validate.',
+            });
+            const response = await app.request('/api/skills', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    name: 'graphql-linter',
+                    title: 'GraphQL Schema Linter',
+                    category: 'database-migrations',
+                    description: 'Validates GraphQL schemas for deprecated fields',
+                    content: '# GraphQL Schema Linter\n\nRun graphql-inspector validate.',
+                }),
+            });
+            expect(response.status).toBe(200);
+            const data = await response.json();
+            expect(data.success).toBe(true);
+            expect(data.skill.id).toBe('graphql-linter');
+            expect(data.skill.custom).toBe(true);
+        });
+        it('GET and POST /api/agents administer Codex-native agents', async () => {
+            const agent = {
+                id: 'reviewer',
+                name: 'reviewer',
+                category: 'general',
+                description: 'Review a fixed diff.',
+                developerInstructions: 'Review correctness and security.',
+                sandboxMode: 'read-only',
+                custom: true,
+            };
+            vi.mocked(agentsCatalog.getAllAgents).mockResolvedValue([agent]);
+            vi.mocked(agentsCatalog.saveAgent).mockResolvedValue(agent);
+            const listResponse = await app.request('/api/agents');
+            expect(listResponse.status).toBe(200);
+            await expect(listResponse.json()).resolves.toEqual({ agents: [agent] });
+            const saveResponse = await app.request('/api/agents', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(agent),
+            });
+            expect(saveResponse.status).toBe(200);
+            expect(agentsCatalog.saveAgent).toHaveBeenCalledWith(agent);
+        });
+        it('blocks deleting resources that are still assigned to a workspace', async () => {
+            const workspacePath = path.resolve('/workspaces/example');
+            vi.mocked(config.loadConfig).mockResolvedValue({ workspacesDir: path.resolve('/workspaces') });
+            vi.mocked(workspace.listWorkspaces).mockResolvedValue([{ id: 'example', workspacePath }]);
+            vi.mocked(fs.realpath).mockImplementation(async (candidate) => path.resolve(String(candidate)));
+            vi.mocked(workspace.loadWorkspaceManifest).mockResolvedValue({ workspacePath });
+            vi.mocked(skillsCatalog.getWorkspaceSkillsConfig).mockResolvedValue({
+                schemaVersion: 1,
+                revision: 1,
+                enabledSkills: ['pr-review-toolkit'],
+                enabledAgents: ['reviewer'],
+                enabledCategories: [],
+            });
+            const skillResponse = await app.request('/api/skills/pr-review-toolkit', { method: 'DELETE' });
+            expect(skillResponse.status).toBe(409);
+            await expect(skillResponse.json()).resolves.toMatchObject({ workspaces: ['example'] });
+            expect(skillsCatalog.deleteSkill).not.toHaveBeenCalled();
+            const agentResponse = await app.request('/api/agents/reviewer', { method: 'DELETE' });
+            expect(agentResponse.status).toBe(409);
+            await expect(agentResponse.json()).resolves.toMatchObject({ workspaces: ['example'] });
+            expect(agentsCatalog.deleteAgent).not.toHaveBeenCalled();
+        });
+        it('requires an exact existing workspace before reading resource assignments', async () => {
+            vi.mocked(config.loadConfig).mockResolvedValue({ workspacesDir: '/workspaces' });
+            vi.mocked(fs.realpath).mockImplementation(async (candidate) => {
+                if (String(candidate).endsWith('missing')) {
+                    throw Object.assign(new Error('missing'), { code: 'ENOENT' });
+                }
+                return String(candidate);
+            });
+            const response = await app.request('/api/skills/workspace/missing');
+            expect(response.status).toBe(404);
+            expect(skillsCatalog.getWorkspaceSkillsConfig).not.toHaveBeenCalled();
+        });
+        it('saves versioned skill and agent assignments for an exact workspace', async () => {
+            const workspacePath = path.resolve('/workspaces/example');
+            vi.mocked(config.loadConfig).mockResolvedValue({ workspacesDir: path.resolve('/workspaces') });
+            vi.mocked(fs.realpath).mockImplementation(async (candidate) => path.resolve(String(candidate)));
+            vi.mocked(workspace.loadWorkspaceManifest).mockResolvedValue({ workspacePath });
+            vi.mocked(skillsCatalog.saveWorkspaceSkillsConfig).mockResolvedValue({
+                schemaVersion: 1,
+                revision: 4,
+                enabledSkills: ['pr-review-toolkit'],
+                enabledAgents: ['reviewer'],
+                enabledCategories: [],
+            });
+            const response = await app.request('/api/skills/workspace/example/assign', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    expectedRevision: 3,
+                    enabledSkills: ['pr-review-toolkit'],
+                    enabledAgents: ['reviewer'],
+                    enabledCategories: [],
+                }),
+            });
+            expect(response.status).toBe(200);
+            expect(skillsCatalog.saveWorkspaceSkillsConfig).toHaveBeenCalledWith(workspacePath, expect.objectContaining({ enabledSkills: ['pr-review-toolkit'], enabledAgents: ['reviewer'] }), 3);
+        });
+        it('rejects workspace assignments that reference missing catalog resources', async () => {
+            const workspacePath = path.resolve('/workspaces/example');
+            vi.mocked(config.loadConfig).mockResolvedValue({ workspacesDir: path.resolve('/workspaces') });
+            vi.mocked(fs.realpath).mockImplementation(async (candidate) => path.resolve(String(candidate)));
+            vi.mocked(workspace.loadWorkspaceManifest).mockResolvedValue({ workspacePath });
+            vi.mocked(resourceService.validateResourceSelections).mockRejectedValueOnce(new resourceService.ResourceSelectionError(['missing-skill'], ['missing_agent']));
+            const response = await app.request('/api/skills/workspace/example/assign', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    expectedRevision: 0,
+                    enabledSkills: ['missing-skill'],
+                    enabledAgents: ['missing_agent'],
+                    enabledCategories: [],
+                }),
+            });
+            expect(response.status).toBe(400);
+            await expect(response.json()).resolves.toMatchObject({
+                missingSkills: ['missing-skill'],
+                missingAgents: ['missing_agent'],
+            });
+            expect(skillsCatalog.saveWorkspaceSkillsConfig).not.toHaveBeenCalled();
+        });
+        it('requires an assignment revision and maps stale revisions to a conflict', async () => {
+            const missingRevision = await app.request('/api/skills/workspace/example/assign', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ enabledSkills: [], enabledAgents: [] }),
+            });
+            expect(missingRevision.status).toBe(400);
+            expect(config.loadConfig).not.toHaveBeenCalled();
+            const workspacePath = path.resolve('/workspaces/example');
+            vi.mocked(config.loadConfig).mockResolvedValue({ workspacesDir: path.resolve('/workspaces') });
+            vi.mocked(fs.realpath).mockImplementation(async (candidate) => path.resolve(String(candidate)));
+            vi.mocked(workspace.loadWorkspaceManifest).mockResolvedValue({ workspacePath });
+            const revisionError = new skillsCatalog.WorkspaceResourceRevisionError(2, 3);
+            revisionError.message = 'Workspace resource configuration changed (expected revision 2, current 3).';
+            vi.mocked(skillsCatalog.saveWorkspaceSkillsConfig).mockRejectedValueOnce(revisionError);
+            const staleRevision = await app.request('/api/skills/workspace/example/assign', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ expectedRevision: 2, enabledSkills: [], enabledAgents: [] }),
+            });
+            expect(staleRevision.status).toBe(409);
+            await expect(staleRevision.json()).resolves.toMatchObject({
+                error: expect.stringContaining('expected revision 2, current 3'),
+            });
+        });
+    });
 });
 //# sourceMappingURL=server.test.js.map