wind-agent-cli 1.37.2 → 1.38.0

package/server/modules/taskmaster/taskmaster.service.ts

@@ -1,132 +1,132 @@
-import path from 'node:path';
-
-type TaskmasterServiceDependencies = {
-    readTextFile(filePath: string): Promise<string>;
-    getHomeDirectory(): string;
-};
-
-/**
- * Creates TaskMaster status workflows for the TaskMaster composition root.
- * The returned service is consumed by TaskMaster routes so filesystem and
- * environment access remain explicit production dependencies.
- */
-export function createTaskmasterService(dependencies: TaskmasterServiceDependencies) {
-    return {
-        /** Detects TaskMaster in the user's Claude MCP configuration without exposing secret values. */
-        async detectMcpServer() {
-            const homeDirectory = dependencies.getHomeDirectory();
-            const configurationPaths = [
-                path.join(homeDirectory, '.claude.json'),
-                path.join(homeDirectory, '.claude', 'settings.json'),
-            ];
-            let configuration: Record<string, unknown> | null = null;
-            let configurationPath: string | null = null;
-
-            for (const candidatePath of configurationPaths) {
-                try {
-                    const parsedConfiguration = JSON.parse(
-                        await dependencies.readTextFile(candidatePath),
-                    ) as unknown;
-                    if (typeof parsedConfiguration === 'object' && parsedConfiguration !== null) {
-                        configuration = parsedConfiguration as Record<string, unknown>;
-                        configurationPath = candidatePath;
-                        break;
-                    }
-                } catch {
-                    // A missing or malformed candidate must not prevent checking the fallback file.
-                }
-            }
-
-            if (!configuration) {
-                return {
-                    hasMCPServer: false,
-                    reason: 'No Claude configuration file found',
-                    hasConfig: false,
-                };
-            }
-
-            const serverGroups: Array<{
-                scope: string;
-                projectPath?: string;
-                servers: Record<string, unknown>;
-            }> = [];
-
-            if (typeof configuration.mcpServers === 'object' && configuration.mcpServers !== null) {
-                serverGroups.push({
-                    scope: 'user',
-                    servers: configuration.mcpServers as Record<string, unknown>,
-                });
-            }
-
-            if (typeof configuration.projects === 'object' && configuration.projects !== null) {
-                for (const [projectPath, projectValue] of Object.entries(configuration.projects)) {
-                    const projectConfiguration = typeof projectValue === 'object' && projectValue !== null
-                        ? projectValue as Record<string, unknown>
-                        : {};
-
-                    if (
-                        typeof projectConfiguration.mcpServers === 'object'
-                        && projectConfiguration.mcpServers !== null
-                    ) {
-                        serverGroups.push({
-                            scope: 'local',
-                            projectPath,
-                            servers: projectConfiguration.mcpServers as Record<string, unknown>,
-                        });
-                    }
-                }
-            }
-
-            for (const serverGroup of serverGroups) {
-                for (const [serverName, serverValue] of Object.entries(serverGroup.servers)) {
-                    const serverConfiguration = typeof serverValue === 'object' && serverValue !== null
-                        ? serverValue as Record<string, unknown>
-                        : {};
-                    const command = typeof serverConfiguration.command === 'string'
-                        ? serverConfiguration.command
-                        : null;
-                    const url = typeof serverConfiguration.url === 'string'
-                        ? serverConfiguration.url
-                        : null;
-                    const isTaskmasterServer = serverName === 'task-master-ai'
-                        || serverName.includes('task-master')
-                        || command?.includes('task-master');
-
-                    if (!isTaskmasterServer) {
-                        continue;
-                    }
-
-                    const environmentVariables = (
-                        typeof serverConfiguration.env === 'object'
-                        && serverConfiguration.env !== null
-                    )
-                        ? serverConfiguration.env as Record<string, unknown>
-                        : {};
-
-                    return {
-                        hasMCPServer: true,
-                        isConfigured: Boolean(command || url),
-                        hasApiKeys: Object.keys(environmentVariables).length > 0,
-                        scope: serverGroup.scope,
-                        ...(serverGroup.projectPath ? { projectPath: serverGroup.projectPath } : {}),
-                        config: {
-                            command,
-                            args: Array.isArray(serverConfiguration.args) ? serverConfiguration.args : [],
-                            url,
-                            envVars: Object.keys(environmentVariables),
-                            type: command ? 'stdio' : url ? 'http' : 'unknown',
-                        },
-                    };
-                }
-            }
-
-            return {
-                hasMCPServer: false,
-                reason: 'task-master-ai not found in configured MCP servers',
-                hasConfig: true,
-                configPath: configurationPath,
-                availableServers: serverGroups.flatMap((serverGroup) => Object.keys(serverGroup.servers)),
-            };
-        },
-    };
-}
+import path from 'node:path';
+
+type TaskmasterServiceDependencies = {
+    readTextFile(filePath: string): Promise<string>;
+    getHomeDirectory(): string;
+};
+
+/**
+ * Creates TaskMaster status workflows for the TaskMaster composition root.
+ * The returned service is consumed by TaskMaster routes so filesystem and
+ * environment access remain explicit production dependencies.
+ */
+export function createTaskmasterService(dependencies: TaskmasterServiceDependencies) {
+    return {
+        /** Detects TaskMaster in the user's Claude MCP configuration without exposing secret values. */
+        async detectMcpServer() {
+            const homeDirectory = dependencies.getHomeDirectory();
+            const configurationPaths = [
+                path.join(homeDirectory, '.claude.json'),
+                path.join(homeDirectory, '.claude', 'settings.json'),
+            ];
+            let configuration: Record<string, unknown> | null = null;
+            let configurationPath: string | null = null;
+
+            for (const candidatePath of configurationPaths) {
+                try {
+                    const parsedConfiguration = JSON.parse(
+                        await dependencies.readTextFile(candidatePath),
+                    ) as unknown;
+                    if (typeof parsedConfiguration === 'object' && parsedConfiguration !== null) {
+                        configuration = parsedConfiguration as Record<string, unknown>;
+                        configurationPath = candidatePath;
+                        break;
+                    }
+                } catch {
+                    // A missing or malformed candidate must not prevent checking the fallback file.
+                }
+            }
+
+            if (!configuration) {
+                return {
+                    hasMCPServer: false,
+                    reason: 'No Claude configuration file found',
+                    hasConfig: false,
+                };
+            }
+
+            const serverGroups: Array<{
+                scope: string;
+                projectPath?: string;
+                servers: Record<string, unknown>;
+            }> = [];
+
+            if (typeof configuration.mcpServers === 'object' && configuration.mcpServers !== null) {
+                serverGroups.push({
+                    scope: 'user',
+                    servers: configuration.mcpServers as Record<string, unknown>,
+                });
+            }
+
+            if (typeof configuration.projects === 'object' && configuration.projects !== null) {
+                for (const [projectPath, projectValue] of Object.entries(configuration.projects)) {
+                    const projectConfiguration = typeof projectValue === 'object' && projectValue !== null
+                        ? projectValue as Record<string, unknown>
+                        : {};
+
+                    if (
+                        typeof projectConfiguration.mcpServers === 'object'
+                        && projectConfiguration.mcpServers !== null
+                    ) {
+                        serverGroups.push({
+                            scope: 'local',
+                            projectPath,
+                            servers: projectConfiguration.mcpServers as Record<string, unknown>,
+                        });
+                    }
+                }
+            }
+
+            for (const serverGroup of serverGroups) {
+                for (const [serverName, serverValue] of Object.entries(serverGroup.servers)) {
+                    const serverConfiguration = typeof serverValue === 'object' && serverValue !== null
+                        ? serverValue as Record<string, unknown>
+                        : {};
+                    const command = typeof serverConfiguration.command === 'string'
+                        ? serverConfiguration.command
+                        : null;
+                    const url = typeof serverConfiguration.url === 'string'
+                        ? serverConfiguration.url
+                        : null;
+                    const isTaskmasterServer = serverName === 'task-master-ai'
+                        || serverName.includes('task-master')
+                        || command?.includes('task-master');
+
+                    if (!isTaskmasterServer) {
+                        continue;
+                    }
+
+                    const environmentVariables = (
+                        typeof serverConfiguration.env === 'object'
+                        && serverConfiguration.env !== null
+                    )
+                        ? serverConfiguration.env as Record<string, unknown>
+                        : {};
+
+                    return {
+                        hasMCPServer: true,
+                        isConfigured: Boolean(command || url),
+                        hasApiKeys: Object.keys(environmentVariables).length > 0,
+                        scope: serverGroup.scope,
+                        ...(serverGroup.projectPath ? { projectPath: serverGroup.projectPath } : {}),
+                        config: {
+                            command,
+                            args: Array.isArray(serverConfiguration.args) ? serverConfiguration.args : [],
+                            url,
+                            envVars: Object.keys(environmentVariables),
+                            type: command ? 'stdio' : url ? 'http' : 'unknown',
+                        },
+                    };
+                }
+            }
+
+            return {
+                hasMCPServer: false,
+                reason: 'task-master-ai not found in configured MCP servers',
+                hasConfig: true,
+                configPath: configurationPath,
+                availableServers: serverGroups.flatMap((serverGroup) => Object.keys(serverGroup.servers)),
+            };
+        },
+    };
+}

package/server/modules/taskmaster/tests/taskmaster.routes.test.ts

@@ -1,144 +1,144 @@
-import assert from 'node:assert/strict';
-import { EventEmitter, once } from 'node:events';
-import type { AddressInfo } from 'node:net';
-import { PassThrough } from 'node:stream';
-import test from 'node:test';
-
-import express from 'express';
-
-import { createTaskmasterRouter } from '../taskmaster.routes.js';
-
-test('tasks route resolves project ids through the injected project adapter', async () => {
-  const resolvedIds: string[] = [];
-  const router = createTaskmasterRouter({
-    fileSystem: {} as typeof import('node:fs'),
-    fileSystemPromises: {} as typeof import('node:fs/promises'),
-    spawnProcess: (() => { throw new Error('spawn should not run'); }) as unknown as
-      Parameters<typeof createTaskmasterRouter>[0]['spawnProcess'],
-    resolveProjectPathById: (projectId) => { resolvedIds.push(projectId); return null; },
-    taskmasterService: {
-      detectMcpServer: async () => ({
-        hasMCPServer: false,
-        reason: 'Not configured',
-        hasConfig: false,
-      }),
-    },
-  });
-  const app = express().use('/api/taskmaster', router);
-  const server = app.listen(0, '127.0.0.1');
-  await once(server, 'listening');
-  try {
-    const address = server.address() as AddressInfo;
-    const response = await fetch(`http://127.0.0.1:${address.port}/api/taskmaster/tasks/project-1`);
-    assert.equal(response.status, 404);
-  } finally {
-    await new Promise<void>((resolve) => server.close(() => resolve()));
-  }
-  assert.deepEqual(resolvedIds, ['project-1']);
-});
-
-test('MCP status route delegates detection to the injected TaskMaster service', async () => {
-  let detectionCount = 0;
-  const router = createTaskmasterRouter({
-    fileSystem: {} as typeof import('node:fs'),
-    fileSystemPromises: {} as typeof import('node:fs/promises'),
-    spawnProcess: (() => { throw new Error('spawn should not run'); }) as unknown as
-      Parameters<typeof createTaskmasterRouter>[0]['spawnProcess'],
-    resolveProjectPathById: () => null,
-    taskmasterService: {
-      detectMcpServer: async () => {
-        detectionCount += 1;
-        return {
-          hasMCPServer: true,
-          isConfigured: true,
-          hasApiKeys: false,
-          scope: 'user',
-          config: {
-            command: 'npx',
-            args: ['-y', 'task-master-ai'],
-            url: null,
-            envVars: [],
-            type: 'stdio',
-          },
-        };
-      },
-    },
-  });
-  const app = express().use('/api/taskmaster', router);
-  const server = app.listen(0, '127.0.0.1');
-  await once(server, 'listening');
-
-  try {
-    const address = server.address() as AddressInfo;
-    const response = await fetch(`http://127.0.0.1:${address.port}/api/taskmaster/mcp-status`);
-    assert.equal(response.status, 200);
-    assert.deepEqual(await response.json(), {
-      hasMCPServer: true,
-      isConfigured: true,
-      hasApiKeys: false,
-      scope: 'user',
-      config: {
-        command: 'npx',
-        args: ['-y', 'task-master-ai'],
-        url: null,
-        envVars: [],
-        type: 'stdio',
-      },
-    });
-  } finally {
-    await new Promise<void>((resolve) => server.close(() => resolve()));
-  }
-
-  assert.equal(detectionCount, 1);
-});
-
-test('TaskMaster process errors use the endpoint failure response and settle once', async () => {
-  const child = new EventEmitter() as EventEmitter & {
-    stdin: PassThrough;
-    stdout: PassThrough;
-    stderr: PassThrough;
-  };
-  child.stdin = new PassThrough();
-  child.stdout = new PassThrough();
-  child.stderr = new PassThrough();
-
-  const router = createTaskmasterRouter({
-    fileSystem: { constants: { F_OK: 0 } } as typeof import('node:fs'),
-    fileSystemPromises: {
-      access: async () => { throw new Error('not initialized'); },
-    } as unknown as typeof import('node:fs/promises'),
-    spawnProcess: (() => {
-      process.nextTick(() => {
-        child.emit('error', new Error('spawn failed'));
-        child.emit('close', 1);
-      });
-      return child;
-    }) as unknown as Parameters<typeof createTaskmasterRouter>[0]['spawnProcess'],
-    resolveProjectPathById: () => '/workspace/project',
-    taskmasterService: {
-      detectMcpServer: async () => ({
-        hasMCPServer: false,
-        reason: 'Not configured',
-        hasConfig: false,
-      }),
-    },
-  });
-  const app = express().use('/api/taskmaster', router);
-  const server = app.listen(0, '127.0.0.1');
-  await once(server, 'listening');
-
-  try {
-    const address = server.address() as AddressInfo;
-    const response = await fetch(`http://127.0.0.1:${address.port}/api/taskmaster/init/project-1`, {
-      method: 'POST',
-    });
-    assert.equal(response.status, 500);
-    assert.deepEqual(await response.json(), {
-      error: 'Failed to initialize TaskMaster',
-      message: 'spawn failed',
-      code: null,
-    });
-  } finally {
-    await new Promise<void>((resolve) => server.close(() => resolve()));
-  }
-});
+import assert from 'node:assert/strict';
+import { EventEmitter, once } from 'node:events';
+import type { AddressInfo } from 'node:net';
+import { PassThrough } from 'node:stream';
+import test from 'node:test';
+
+import express from 'express';
+
+import { createTaskmasterRouter } from '../taskmaster.routes.js';
+
+test('tasks route resolves project ids through the injected project adapter', async () => {
+  const resolvedIds: string[] = [];
+  const router = createTaskmasterRouter({
+    fileSystem: {} as typeof import('node:fs'),
+    fileSystemPromises: {} as typeof import('node:fs/promises'),
+    spawnProcess: (() => { throw new Error('spawn should not run'); }) as unknown as
+      Parameters<typeof createTaskmasterRouter>[0]['spawnProcess'],
+    resolveProjectPathById: (projectId) => { resolvedIds.push(projectId); return null; },
+    taskmasterService: {
+      detectMcpServer: async () => ({
+        hasMCPServer: false,
+        reason: 'Not configured',
+        hasConfig: false,
+      }),
+    },
+  });
+  const app = express().use('/api/taskmaster', router);
+  const server = app.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+  try {
+    const address = server.address() as AddressInfo;
+    const response = await fetch(`http://127.0.0.1:${address.port}/api/taskmaster/tasks/project-1`);
+    assert.equal(response.status, 404);
+  } finally {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+  }
+  assert.deepEqual(resolvedIds, ['project-1']);
+});
+
+test('MCP status route delegates detection to the injected TaskMaster service', async () => {
+  let detectionCount = 0;
+  const router = createTaskmasterRouter({
+    fileSystem: {} as typeof import('node:fs'),
+    fileSystemPromises: {} as typeof import('node:fs/promises'),
+    spawnProcess: (() => { throw new Error('spawn should not run'); }) as unknown as
+      Parameters<typeof createTaskmasterRouter>[0]['spawnProcess'],
+    resolveProjectPathById: () => null,
+    taskmasterService: {
+      detectMcpServer: async () => {
+        detectionCount += 1;
+        return {
+          hasMCPServer: true,
+          isConfigured: true,
+          hasApiKeys: false,
+          scope: 'user',
+          config: {
+            command: 'npx',
+            args: ['-y', 'task-master-ai'],
+            url: null,
+            envVars: [],
+            type: 'stdio',
+          },
+        };
+      },
+    },
+  });
+  const app = express().use('/api/taskmaster', router);
+  const server = app.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+
+  try {
+    const address = server.address() as AddressInfo;
+    const response = await fetch(`http://127.0.0.1:${address.port}/api/taskmaster/mcp-status`);
+    assert.equal(response.status, 200);
+    assert.deepEqual(await response.json(), {
+      hasMCPServer: true,
+      isConfigured: true,
+      hasApiKeys: false,
+      scope: 'user',
+      config: {
+        command: 'npx',
+        args: ['-y', 'task-master-ai'],
+        url: null,
+        envVars: [],
+        type: 'stdio',
+      },
+    });
+  } finally {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+  }
+
+  assert.equal(detectionCount, 1);
+});
+
+test('TaskMaster process errors use the endpoint failure response and settle once', async () => {
+  const child = new EventEmitter() as EventEmitter & {
+    stdin: PassThrough;
+    stdout: PassThrough;
+    stderr: PassThrough;
+  };
+  child.stdin = new PassThrough();
+  child.stdout = new PassThrough();
+  child.stderr = new PassThrough();
+
+  const router = createTaskmasterRouter({
+    fileSystem: { constants: { F_OK: 0 } } as typeof import('node:fs'),
+    fileSystemPromises: {
+      access: async () => { throw new Error('not initialized'); },
+    } as unknown as typeof import('node:fs/promises'),
+    spawnProcess: (() => {
+      process.nextTick(() => {
+        child.emit('error', new Error('spawn failed'));
+        child.emit('close', 1);
+      });
+      return child;
+    }) as unknown as Parameters<typeof createTaskmasterRouter>[0]['spawnProcess'],
+    resolveProjectPathById: () => '/workspace/project',
+    taskmasterService: {
+      detectMcpServer: async () => ({
+        hasMCPServer: false,
+        reason: 'Not configured',
+        hasConfig: false,
+      }),
+    },
+  });
+  const app = express().use('/api/taskmaster', router);
+  const server = app.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+
+  try {
+    const address = server.address() as AddressInfo;
+    const response = await fetch(`http://127.0.0.1:${address.port}/api/taskmaster/init/project-1`, {
+      method: 'POST',
+    });
+    assert.equal(response.status, 500);
+    assert.deepEqual(await response.json(), {
+      error: 'Failed to initialize TaskMaster',
+      message: 'spawn failed',
+      code: null,
+    });
+  } finally {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+  }
+});