@ai-support-agent/cli 0.1.22-beta.4 → 0.1.22

package/dist/cli/service/win32-service.js

@@ -33,32 +33,88 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Win32ServiceStrategy = void 0;
+exports.Win32ServiceStrategy = exports.getNodePath = exports.getCliEntryPoint = void 0;
+exports.getProjectTaskName = getProjectTaskName;
+exports.getAllProjectTasks = getAllProjectTasks;
+exports.generateProjectTaskXml = generateProjectTaskXml;
+exports.generateWin32WrapperScript = generateWin32WrapperScript;
+exports.writeAndRegisterProjectTask = writeAndRegisterProjectTask;
 exports.generateTaskXml = generateTaskXml;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const constants_1 = require("../../constants");
+const config_manager_1 = require("../../config-manager");
+const docker_utils_1 = require("../../docker/docker-utils");
 const i18n_1 = require("../../i18n");
 const logger_1 = require("../../logger");
 const utils_1 = require("../../utils");
+const path_utils_1 = require("../../utils/path-utils");
 const escape_xml_1 = require("./escape-xml");
 const node_paths_1 = require("./node-paths");
-const TASK_NAME = 'AISupportAgent';
-function getLogDir() {
-    const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
-    return path.join(localAppData, 'ai-support-agent', 'logs');
+Object.defineProperty(exports, "getCliEntryPoint", { enumerable: true, get: function () { return node_paths_1.getCliEntryPoint; } });
+Object.defineProperty(exports, "getNodePath", { enumerable: true, get: function () { return node_paths_1.getNodePath; } });
+const wrapper_helpers_1 = require("./wrapper-helpers");
+const TASK_PREFIX = 'AISupportAgent';
+const getLogDir = path_utils_1.getWin32LogDir;
+/** Sanitize a code the same way buildContainerName does (lowercase, [a-z0-9-]). */
+function sanitize(s) {
+    return s.toLowerCase().replace(/[^a-z0-9-]/g, '-');
 }
-function generateTaskXml(options) {
-    const { nodePath, entryPoint, verbose, docker } = options;
-    const args = [entryPoint, 'start'];
-    if (!docker) {
-        args.push(constants_1.CLI_FLAG_NO_DOCKER);
+// ---------------------------------------------------------------------------
+// Per-project task helpers
+// ---------------------------------------------------------------------------
+/**
+ * Returns the scheduled-task name for a given project.
+ * Format: AISupportAgent-{tenantCode}-{projectCode} (sanitized).
+ *
+ * The Windows Task Scheduler accepts backslashes as folder separators in task
+ * names, so any backslash in a code would silently create a nested task folder.
+ * sanitize() already strips it (along with other non `[a-z0-9-]` chars).
+ */
+function getProjectTaskName(tenantCode, projectCode) {
+    return `${TASK_PREFIX}-${sanitize(tenantCode)}-${sanitize(projectCode)}`;
+}
+/**
+ * Lists all per-project scheduled tasks registered by this CLI.
+ *
+ * Queries Task Scheduler for tasks whose name starts with `${TASK_PREFIX}-`.
+ * Returns an empty list when schtasks is unavailable or no task matches.
+ */
+function getAllProjectTasks() {
+    const prefix = `${TASK_PREFIX}-`;
+    const results = [];
+    try {
+        // /FO CSV /NH → bare rows; first column is "\TaskName" (leading backslash
+        // = root folder). Strip the leading backslash and surrounding quotes.
+        const output = (0, child_process_1.execSync)('schtasks /Query /FO CSV /NH', { stdio: 'pipe' }).toString();
+        for (const line of output.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const firstCol = trimmed.split('","')[0].replace(/^"/, '').replace(/"$/, '');
+            const name = firstCol.replace(/^\\/, '');
+            if (name.startsWith(prefix) && !results.some((r) => r.taskName === name)) {
+                results.push({ taskName: name });
+            }
+        }
     }
-    if (verbose) {
-        args.push(constants_1.CLI_FLAG_VERBOSE);
+    catch {
+        // schtasks unavailable / no tasks — return empty list
     }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Task XML + wrapper generation
+// ---------------------------------------------------------------------------
+/**
+ * Generate the scheduled-task XML that runs a per-project wrapper script.
+ * The action invokes cmd.exe on the generated run.cmd so the wrapper can set
+ * env vars and run `docker run` without leaking secrets onto the task's
+ * command line (which is world-readable via `schtasks /Query /XML`).
+ */
+function generateProjectTaskXml(opts) {
     return `<?xml version="1.0" encoding="UTF-16"?>
 <Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
   <Triggers>
@@ -78,140 +134,452 @@ function generateTaskXml(options) {
   </Settings>
   <Actions>
     <Exec>
-      <Command>${(0, escape_xml_1.escapeXml)(nodePath)}</Command>
-      <Arguments>${(0, escape_xml_1.escapeXml)(args.join(' '))}</Arguments>
+      <Command>cmd.exe</Command>
+      <Arguments>/c ${(0, escape_xml_1.escapeXml)(`"${opts.wrapperScriptPath}"`)}</Arguments>
     </Exec>
   </Actions>
 </Task>`;
 }
+/** Convert localhost/127.0.0.1 to host.docker.internal for container use */
+function toContainerApiUrl(apiUrl) {
+    return apiUrl.replace(/^(https?:\/\/)(localhost|127\.0\.0\.1)(:\d+)?/, (_, scheme, _host, port) => `${scheme}host.docker.internal${port ?? ''}`);
+}
+/**
+ * Windows batch (cmd.exe) cannot reliably escape every metacharacter the way a
+ * POSIX shell can with single quotes. Rather than risk a broken or injectable
+ * `set "VAR=value"` line, reject values containing characters that have special
+ * meaning to cmd.exe so the user fixes the bad value instead of silently
+ * generating a broken wrapper. Tokens / URLs / API keys never legitimately
+ * contain these. (No fallback — see the project "no fallback" rule.)
+ */
+// Forbid cmd.exe metacharacters: % (var expansion), ! (delayed expansion),
+// " (quote), CR/LF, ^ (escape/continuation), & (command separator), <>| (redir
+// /pipe), and ()  (block grouping — harmless inside `set "..."` but rejected as
+// defense in depth). A leading/trailing space is rejected separately below
+// because `set " VAR=..."` would create a space-prefixed variable name that the
+// `-e VAR` inherit line could never match.
+const CMD_FORBIDDEN_RE = /[%!"\r\n^&<>|()]/;
+function assertCmdSafe(value, field) {
+    if (CMD_FORBIDDEN_RE.test(value) || value !== value.trim()) {
+        throw new Error((0, i18n_1.t)('service.invalidWin32Value', { field }));
+    }
+}
+/**
+ * Generate a cmd.exe batch wrapper that runs docker for one project.
+ *
+ * Mirrors the Linux/Darwin wrappers: bind-mounts the per-project config dir and
+ * project dir, passes the token / api url / API keys as `-e` env vars, resolves
+ * the installed CLI version at runtime, auto-builds the image if missing, and
+ * removes any stale container before `docker run`.
+ */
+function generateWin32WrapperScript(opts) {
+    const containerHome = '/home/node';
+    const containerConfigDir = `${containerHome}/.ai-support-agent`;
+    const homeDir = os.homedir();
+    const containerApiUrl = toContainerApiUrl(opts.apiUrl);
+    // Reject codes whose characters would break container naming / the dir map.
+    (0, wrapper_helpers_1.assertProjectCodeIsSafe)(opts.projectCode);
+    (0, wrapper_helpers_1.assertProjectCodeIsSafe)(opts.tenantCode);
+    // Reject secret/url values that cmd.exe cannot safely carry.
+    assertCmdSafe(opts.token, 'token');
+    assertCmdSafe(containerApiUrl, 'apiUrl');
+    if (opts.anthropicApiKey)
+        assertCmdSafe(opts.anthropicApiKey, 'anthropicApiKey');
+    if (opts.claudeCodeOauthToken)
+        assertCmdSafe(opts.claudeCodeOauthToken, 'claudeCodeOauthToken');
+    const containerProjectDir = `/workspace/projects/${opts.projectCode}`;
+    // `||` (not `??`) so an empty projectDir falls back to the default; an empty
+    // host path would emit `-v :/workspace/...:rw` which docker rejects.
+    const hostProjectDir = opts.projectDir || path.dirname(opts.projectConfigHostDir);
+    const containerName = `ai-${sanitize(opts.tenantCode)}-${sanitize(opts.projectCode)}`;
+    // docker run argument lines. Host paths are wrapped in double quotes so a
+    // space in the Windows home dir (e.g. C:\Users\First Last) does not split the
+    // -v argument. The values were validated above to contain no `"`.
+    const mountLines = [
+        `  -v "${homeDir}\\.claude:${containerHome}/.claude:rw" ^`,
+        `  -v "${opts.projectConfigHostDir}:${containerConfigDir}:rw" ^`,
+        `  -v "${homeDir}\\.claude.json:${containerHome}/.claude.json:rw" ^`,
+        `  -v "${hostProjectDir}:${containerProjectDir}:rw" ^`,
+    ];
+    const envLines = [
+        `  -e AI_SUPPORT_AGENT_IN_DOCKER=1 ^`,
+        `  -e HOME=${containerHome} ^`,
+        `  -e AI_SUPPORT_AGENT_CONFIG_DIR=${containerConfigDir} ^`,
+        // `-e NAME` (no value) tells docker to inherit the value from the wrapper's
+        // own environment, which we set via `set` below. This keeps secrets off the
+        // `docker run` argument vector.
+        `  -e AI_SUPPORT_AGENT_TOKEN ^`,
+        `  -e AI_SUPPORT_AGENT_API_URL ^`,
+        `  -e AI_SUPPORT_AGENT_PROJECT_DIR_MAP ^`,
+    ];
+    if (opts.anthropicApiKey)
+        envLines.push(`  -e ANTHROPIC_API_KEY ^`);
+    if (opts.claudeCodeOauthToken)
+        envLines.push(`  -e CLAUDE_CODE_OAUTH_TOKEN ^`);
+    const containerArgs = [
+        'ai-support-agent', 'start', constants_1.CLI_FLAG_NO_DOCKER,
+        `--project ${opts.tenantCode}/${opts.projectCode}`,
+    ];
+    if (opts.verbose)
+        containerArgs.push(constants_1.CLI_FLAG_VERBOSE);
+    const setLines = [
+        `set "AI_SUPPORT_AGENT_TOKEN=${opts.token}"`,
+        `set "AI_SUPPORT_AGENT_API_URL=${containerApiUrl}"`,
+        `set "AI_SUPPORT_AGENT_PROJECT_DIR_MAP=${opts.projectCode}=${containerProjectDir}"`,
+    ];
+    if (opts.anthropicApiKey)
+        setLines.push(`set "ANTHROPIC_API_KEY=${opts.anthropicApiKey}"`);
+    if (opts.claudeCodeOauthToken)
+        setLines.push(`set "CLAUDE_CODE_OAUTH_TOKEN=${opts.claudeCodeOauthToken}"`);
+    const dockerRun = [
+        `docker run --rm -i --name "${containerName}" ^`,
+        mountLines.join('\r\n'),
+        envLines.join('\r\n'),
+        `  "%IMAGE_TAG%" ^`,
+        `  ${containerArgs.join(' ')}`,
+    ].join('\r\n');
+    // NOTE: `setlocal` scopes the `set` secrets to this wrapper invocation so
+    // they never leak into the parent environment. EnableExtensions is needed for
+    // the `if` blocks. We deliberately do NOT enable delayed expansion so a `!`
+    // in a value cannot trigger expansion (and `!` is rejected above anyway).
+    const lines = [
+        `@echo off`,
+        `setlocal EnableExtensions`,
+        ``,
+        `rem Resolve the installed CLI version at runtime so the image stays current after npm updates.`,
+        `rem usebackq lets the command be wrapped in backquotes so the inner node -p`,
+        `rem double quotes don't confuse for /f's parser, and a space in the npm root`,
+        `rem path (e.g. C:\\Program Files\\...) stays inside the JS string literal.`,
+        `for /f "usebackq delims=" %%R in (\`npm root -g 2^>nul\`) do set "_NPM_ROOT=%%R"`,
+        `if not defined _NPM_ROOT (`,
+        `  echo ERROR: Could not determine npm global root 1>&2`,
+        `  exit /b 1`,
+        `)`,
+        `for /f "usebackq delims=" %%V in (\`node -p "require('%_NPM_ROOT:\\=/%/@ai-support-agent/cli/package.json').version" 2^>nul\`) do set "_INSTALLED_VERSION=%%V"`,
+        `if not defined _INSTALLED_VERSION (`,
+        `  echo ERROR: Could not determine installed version of @ai-support-agent/cli 1>&2`,
+        `  exit /b 1`,
+        `)`,
+        `set "IMAGE_TAG=${opts.imageName}:%_INSTALLED_VERSION%"`,
+        ``,
+        `rem Auto-build the image if the required version does not exist locally`,
+        `docker image inspect "%IMAGE_TAG%" >nul 2>&1`,
+        `if errorlevel 1 (`,
+        `  echo Docker image %IMAGE_TAG% not found - building... 1>&2`,
+        `  call ai-support-agent docker-build`,
+        `  if errorlevel 1 (`,
+        `    echo ERROR: docker-build failed - cannot start container 1>&2`,
+        `    exit /b 1`,
+        `  )`,
+        `)`,
+        ``,
+        `rem Remove any stale container from a previous crash`,
+        `docker rm -f "${containerName}" >nul 2>&1`,
+        ``,
+        ...setLines,
+        ``,
+        dockerRun,
+        ``,
+        `endlocal`,
+    ];
+    return lines.join('\r\n') + '\r\n';
+}
+// ---------------------------------------------------------------------------
+// Service file writing
+// ---------------------------------------------------------------------------
+/**
+ * Write the run.cmd wrapper and register/refresh the scheduled task for one
+ * project. Idempotent: deletes any existing task with the same name first so
+ * token/config updates take effect.
+ */
+function writeAndRegisterProjectTask(project, options = {}) {
+    const { tenantCode, projectCode } = project;
+    (0, wrapper_helpers_1.assertProjectCodeIsSafe)(projectCode);
+    (0, wrapper_helpers_1.assertProjectCodeIsSafe)(tenantCode);
+    const projectKey = `${tenantCode}-${projectCode.toLowerCase()}`;
+    // mode 0o700 keeps the per-project metadata, services, and logs owner-only.
+    // The run.cmd wrapper written below contains the token in plaintext, so the
+    // service dir must not be world-readable. On Windows the POSIX mode bits are
+    // only partially honored, but we set them for parity with darwin/linux and so
+    // the wrapper is at least not group/other-writable on filesystems that map
+    // them (e.g. WSL/SMB shares).
+    const logDir = getLogDir();
+    const projectLogDir = (0, path_utils_1.getProjectLogDir)(logDir, projectKey);
+    if (!fs.existsSync(projectLogDir)) {
+        fs.mkdirSync(projectLogDir, { recursive: true, mode: 0o700 });
+    }
+    const servicesDir = (0, path_utils_1.getServicesDir)();
+    const projectServiceDir = (0, path_utils_1.getProjectServiceDir)(servicesDir, projectKey);
+    if (!fs.existsSync(projectServiceDir)) {
+        fs.mkdirSync(projectServiceDir, { recursive: true, mode: 0o700 });
+    }
+    const projectConfigHostDir = (0, path_utils_1.getProjectConfigHostDir)(tenantCode, projectCode);
+    if (!fs.existsSync(projectConfigHostDir)) {
+        fs.mkdirSync(projectConfigHostDir, { recursive: true, mode: 0o700 });
+    }
+    const validatedProjectDir = (0, wrapper_helpers_1.validateProjectDirForMount)(project.projectDir);
+    const wrapperScriptPath = (0, path_utils_1.getWin32WrapperScriptPath)(projectServiceDir);
+    const wrapperScript = generateWin32WrapperScript({
+        imageName: docker_utils_1.IMAGE_NAME,
+        tenantCode,
+        projectCode,
+        projectConfigHostDir,
+        projectDir: validatedProjectDir,
+        token: project.token,
+        apiUrl: project.apiUrl,
+        anthropicApiKey: process.env.ANTHROPIC_API_KEY,
+        claudeCodeOauthToken: process.env.CLAUDE_CODE_OAUTH_TOKEN,
+        verbose: options.verbose,
+    });
+    // The wrapper holds the token in plaintext — write it owner-only.
+    fs.writeFileSync(wrapperScriptPath, wrapperScript, { encoding: 'utf-8', mode: 0o700 });
+    const taskName = getProjectTaskName(tenantCode, projectCode);
+    const xml = generateProjectTaskXml({ wrapperScriptPath });
+    const tmpXmlPath = path.join(os.tmpdir(), `${taskName}-task.xml`);
+    try {
+        fs.writeFileSync(tmpXmlPath, xml, 'utf-8');
+        // /F overwrites an existing task so token/config updates take effect.
+        (0, child_process_1.execSync)(`schtasks /Create /TN "${taskName}" /XML "${tmpXmlPath}" /F`, { stdio: 'pipe' });
+    }
+    finally {
+        if (fs.existsSync(tmpXmlPath)) {
+            fs.unlinkSync(tmpXmlPath);
+        }
+    }
+}
 class Win32ServiceStrategy {
     install(options) {
-        const logDir = getLogDir();
-        const nodePath = (0, node_paths_1.getNodePath)();
+        const config = (0, config_manager_1.loadConfig)();
+        const projects = config ? (0, config_manager_1.getProjectList)(config) : [];
+        if (projects.length === 0) {
+            logger_1.logger.error((0, i18n_1.t)('service.noProjectsConfigured'));
+            return;
+        }
         const entryPoint = (0, node_paths_1.getCliEntryPoint)();
         if (!fs.existsSync(entryPoint)) {
             logger_1.logger.error((0, i18n_1.t)('service.entryPointNotFound', { path: entryPoint }));
             return;
         }
+        const logDir = getLogDir();
         if (!fs.existsSync(logDir)) {
             fs.mkdirSync(logDir, { recursive: true });
         }
-        const xml = generateTaskXml({
-            nodePath,
-            entryPoint,
-            logDir,
-            verbose: options.verbose,
-            docker: options.docker,
-        });
-        const tmpXmlPath = path.join(os.tmpdir(), `${TASK_NAME}-task.xml`);
-        try {
-            fs.writeFileSync(tmpXmlPath, xml, 'utf-8');
-            (0, child_process_1.execSync)(`schtasks /Create /TN "${TASK_NAME}" /XML "${tmpXmlPath}" /F`, {
-                stdio: 'pipe',
-            });
-        }
-        catch (error) {
-            const message = (0, utils_1.getErrorMessage)(error);
-            logger_1.logger.error((0, i18n_1.t)('service.schtasksFailed', { message }));
-            return;
-        }
-        finally {
-            if (fs.existsSync(tmpXmlPath)) {
-                fs.unlinkSync(tmpXmlPath);
+        // Detect sanitize() collisions where two valid codes map to the same task
+        // name. Shared helper guarantees identical semantics with linux/darwin.
+        const { collisions } = (0, wrapper_helpers_1.detectInstallCollisions)(projects, getProjectTaskName);
+        const reportedCollisionLabels = new Set();
+        let installedCount = 0;
+        let failedCount = 0;
+        for (const project of projects) {
+            const { projectCode } = project;
+            const fqn = `${project.tenantCode}/${projectCode}`;
+            const collision = collisions.get(fqn);
+            if (collision) {
+                const messageKey = collision.isDuplicate
+                    ? 'service.projectDuplicateEntry'
+                    : 'service.projectUnitNameCollision';
+                const dedupKey = `${collision.name}\x00${messageKey}`;
+                if (!reportedCollisionLabels.has(dedupKey)) {
+                    logger_1.logger.error((0, i18n_1.t)(messageKey, {
+                        projectCode,
+                        unitName: collision.name,
+                        others: collision.others.join(', '),
+                    }));
+                    reportedCollisionLabels.add(dedupKey);
+                }
+                failedCount += 1;
+                continue;
             }
+            try {
+                writeAndRegisterProjectTask(project, { verbose: options.verbose });
+                logger_1.logger.success((0, i18n_1.t)('service.projectInstalled', { projectCode, path: getProjectTaskName(project.tenantCode, projectCode) }));
+                installedCount += 1;
+            }
+            catch (error) {
+                const message = (0, utils_1.getErrorMessage)(error);
+                logger_1.logger.error((0, i18n_1.t)('service.projectInstallFailed', { projectCode, message }));
+                failedCount += 1;
+            }
+        }
+        if (installedCount > 0) {
+            logger_1.logger.info((0, i18n_1.t)('service.loadHintMulti'));
+            logger_1.logger.info((0, i18n_1.t)('service.logDir', { path: logDir }));
+            logger_1.logger.info((0, i18n_1.t)('service.noLogRotation'));
+        }
+        if (failedCount > 0) {
+            logger_1.logger.warn((0, i18n_1.t)('service.partialInstallSummary', {
+                failed: String(failedCount),
+                total: String(projects.length),
+                succeeded: String(installedCount),
+            }));
         }
-        logger_1.logger.success((0, i18n_1.t)('service.installed.win32', { taskName: TASK_NAME }));
-        logger_1.logger.info((0, i18n_1.t)('service.loadHint.win32', { taskName: TASK_NAME }));
-        logger_1.logger.info((0, i18n_1.t)('service.logDir', { path: logDir }));
-        logger_1.logger.info((0, i18n_1.t)('service.noLogRotation'));
     }
     uninstall() {
-        try {
-            (0, child_process_1.execSync)(`schtasks /Query /TN "${TASK_NAME}"`, { stdio: 'pipe' });
-        }
-        catch {
+        const projectTasks = getAllProjectTasks();
+        if (projectTasks.length === 0) {
             logger_1.logger.warn((0, i18n_1.t)('service.notInstalled.win32'));
             return;
         }
-        logger_1.logger.info((0, i18n_1.t)('service.unloadHint.win32', { taskName: TASK_NAME }));
-        try {
-            (0, child_process_1.execSync)(`schtasks /Delete /TN "${TASK_NAME}" /F`, { stdio: 'pipe' });
+        let failed = false;
+        for (const { taskName } of projectTasks) {
+            try {
+                (0, child_process_1.execSync)(`schtasks /Delete /TN "${taskName}" /F`, { stdio: 'pipe' });
+            }
+            catch (error) {
+                const message = (0, utils_1.getErrorMessage)(error);
+                logger_1.logger.error((0, i18n_1.t)('service.schtasksFailed', { message }));
+                failed = true;
+            }
         }
-        catch (error) {
-            const message = (0, utils_1.getErrorMessage)(error);
-            logger_1.logger.error((0, i18n_1.t)('service.schtasksFailed', { message }));
-            return;
+        if (!failed) {
+            logger_1.logger.success((0, i18n_1.t)('service.uninstalled.win32'));
         }
-        logger_1.logger.success((0, i18n_1.t)('service.uninstalled.win32'));
     }
     start() {
-        try {
-            (0, child_process_1.execSync)(`schtasks /Query /TN "${TASK_NAME}"`, { stdio: 'pipe' });
-        }
-        catch {
+        const projectTasks = getAllProjectTasks();
+        if (projectTasks.length === 0) {
             logger_1.logger.error((0, i18n_1.t)('service.notInstalled.win32'));
             return;
         }
-        try {
-            (0, child_process_1.execSync)(`schtasks /Run /TN "${TASK_NAME}"`, { stdio: 'pipe' });
-            logger_1.logger.success((0, i18n_1.t)('service.started'));
+        let failed = false;
+        for (const { taskName } of projectTasks) {
+            try {
+                (0, child_process_1.execSync)(`schtasks /Run /TN "${taskName}"`, { stdio: 'pipe' });
+            }
+            catch (error) {
+                const message = (0, utils_1.getErrorMessage)(error);
+                logger_1.logger.error((0, i18n_1.t)('service.startFailed', { message }));
+                failed = true;
+            }
         }
-        catch (error) {
-            const message = (0, utils_1.getErrorMessage)(error);
-            logger_1.logger.error((0, i18n_1.t)('service.startFailed', { message }));
+        if (!failed) {
+            logger_1.logger.success((0, i18n_1.t)('service.started'));
         }
     }
     stop() {
-        try {
-            (0, child_process_1.execSync)(`schtasks /Query /TN "${TASK_NAME}"`, { stdio: 'pipe' });
-        }
-        catch {
+        const projectTasks = getAllProjectTasks();
+        if (projectTasks.length === 0) {
             logger_1.logger.error((0, i18n_1.t)('service.notInstalled.win32'));
             return;
         }
-        try {
-            (0, child_process_1.execSync)(`schtasks /End /TN "${TASK_NAME}"`, { stdio: 'pipe' });
-            logger_1.logger.success((0, i18n_1.t)('service.stopped'));
+        let failed = false;
+        for (const { taskName } of projectTasks) {
+            try {
+                (0, child_process_1.execSync)(`schtasks /End /TN "${taskName}"`, { stdio: 'pipe' });
+            }
+            catch (error) {
+                const message = (0, utils_1.getErrorMessage)(error);
+                logger_1.logger.error((0, i18n_1.t)('service.stopFailed', { message }));
+                failed = true;
+            }
         }
-        catch (error) {
-            const message = (0, utils_1.getErrorMessage)(error);
-            logger_1.logger.error((0, i18n_1.t)('service.stopFailed', { message }));
+        if (!failed) {
+            logger_1.logger.success((0, i18n_1.t)('service.stopped'));
         }
     }
     restart() {
-        try {
-            (0, child_process_1.execSync)(`schtasks /Query /TN "${TASK_NAME}"`, { stdio: 'pipe' });
-        }
-        catch {
+        const projectTasks = getAllProjectTasks();
+        if (projectTasks.length === 0) {
             logger_1.logger.error((0, i18n_1.t)('service.notInstalled.win32'));
             return;
         }
-        try {
-            (0, child_process_1.execSync)(`schtasks /End /TN "${TASK_NAME}"`, { stdio: 'pipe' });
-        }
-        catch {
-            // Task may not be running — ignore
+        let failed = false;
+        for (const { taskName } of projectTasks) {
+            try {
+                try {
+                    (0, child_process_1.execSync)(`schtasks /End /TN "${taskName}"`, { stdio: 'pipe' });
+                }
+                catch {
+                    // Task may not be running — ignore
+                }
+                (0, child_process_1.execSync)(`schtasks /Run /TN "${taskName}"`, { stdio: 'pipe' });
+            }
+            catch (error) {
+                const message = (0, utils_1.getErrorMessage)(error);
+                logger_1.logger.error((0, i18n_1.t)('service.restartFailed', { message }));
+                failed = true;
+            }
         }
-        try {
-            (0, child_process_1.execSync)(`schtasks /Run /TN "${TASK_NAME}"`, { stdio: 'pipe' });
+        if (!failed) {
             logger_1.logger.success((0, i18n_1.t)('service.restarted'));
         }
-        catch (error) {
-            const message = (0, utils_1.getErrorMessage)(error);
-            logger_1.logger.error((0, i18n_1.t)('service.restartFailed', { message }));
-        }
     }
     status() {
+        const projectTasks = getAllProjectTasks();
         const logDir = getLogDir();
-        try {
-            const output = (0, child_process_1.execSync)(`schtasks /Query /TN "${TASK_NAME}" /FO CSV /NH`, { stdio: 'pipe' }).toString();
-            const running = output.includes('Running');
-            return { installed: true, running, logDir };
-        }
-        catch {
+        if (projectTasks.length === 0) {
             return { installed: false, running: false };
         }
+        // Build a reverse map from task name → original projectCode using config.
+        // sanitize() collapses `_` and other chars to `-`, so splitting the task
+        // name on `-` is lossy when tenant/project codes contain those characters
+        // (and the tenant/project boundary is ambiguous) — config is the source of
+        // truth. Mirrors the Linux strategy.
+        const config = (0, config_manager_1.loadConfig)();
+        const projectByTaskName = new Map();
+        if (config) {
+            for (const project of (0, config_manager_1.getProjectList)(config)) {
+                projectByTaskName.set(getProjectTaskName(project.tenantCode, project.projectCode), project.projectCode);
+            }
+        }
+        const projects = [];
+        let isAnyRunning = false;
+        for (const { taskName } of projectTasks) {
+            // Prefer the canonical projectCode from config. For orphaned tasks no
+            // longer in config, fall back to the task name with the brand prefix
+            // stripped so users still see something close to the original code.
+            const projectCode = projectByTaskName.get(taskName)
+                ?? (taskName.startsWith(`${TASK_PREFIX}-`) ? taskName.slice(TASK_PREFIX.length + 1) : taskName);
+            let running = false;
+            try {
+                const output = (0, child_process_1.execSync)(`schtasks /Query /TN "${taskName}" /FO CSV /NH`, { stdio: 'pipe' }).toString();
+                if (output.includes('Running')) {
+                    running = true;
+                    isAnyRunning = true;
+                }
+            }
+            catch {
+                // Not registered / query failed — running stays false
+            }
+            projects.push({ label: taskName, projectCode, running });
+        }
+        return { installed: true, running: isAnyRunning, logDir, projects };
     }
 }
 exports.Win32ServiceStrategy = Win32ServiceStrategy;
+// Backward-compat: keep generateTaskXml exported for any external callers.
+// Generates a single-task XML (legacy single-project form) — no longer used by
+// the multi-project install path above.
+function generateTaskXml(options) {
+    const { nodePath, entryPoint, verbose, docker } = options;
+    const args = [entryPoint, 'start'];
+    if (!docker)
+        args.push(constants_1.CLI_FLAG_NO_DOCKER);
+    if (verbose)
+        args.push(constants_1.CLI_FLAG_VERBOSE);
+    return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+    </LogonTrigger>
+  </Triggers>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <RestartOnFailure>
+      <Interval>PT1M</Interval>
+      <Count>999</Count>
+    </RestartOnFailure>
+  </Settings>
+  <Actions>
+    <Exec>
+      <Command>${(0, escape_xml_1.escapeXml)(nodePath)}</Command>
+      <Arguments>${(0, escape_xml_1.escapeXml)(args.join(' '))}</Arguments>
+    </Exec>
+  </Actions>
+</Task>`;
+}
 //# sourceMappingURL=win32-service.js.map