agentic-workflow-manager 2.0.1 → 2.1.1

package/dist/src/ui/picker.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_SENTINEL = void 0;
+exports.parseKey = parseKey;
+exports.pickerReducer = pickerReducer;
+exports.multiselectPicker = multiselectPicker;
+const picker_view_1 = require("./picker-view");
+const registry_view_1 = require("../utils/registry-view");
+// ALL_SENTINEL: single source of truth lives in registry-view.ts — re-exported here.
+exports.ALL_SENTINEL = registry_view_1.ALL_SENTINEL;
+function parseKey(data) {
+    switch (data) {
+        case '\x1b[A': return { action: 'up' };
+        case '\x1b[B': return { action: 'down' };
+        case '\r':
+        case '\n': return { action: 'confirm' };
+        case ' ': return { action: 'toggle' };
+        case '\t': return { action: 'toggleAll' };
+        case '\x7f':
+        case '\b': return { action: 'backspace' };
+        case '\x03': return { action: 'cancel' }; // Ctrl-C
+        case '\x1b': return { action: 'clearOrCancel' }; // Esc
+    }
+    if (data.length === 1 && /[a-zA-Z0-9-]/.test(data))
+        return { action: 'char', char: data };
+    return { action: 'none' };
+}
+function realValues(state) {
+    return state.items.filter((i) => i.value !== exports.ALL_SENTINEL).map((i) => i.value);
+}
+function pickerReducer(state, key) {
+    const vis = (0, picker_view_1.visibleItems)(state);
+    switch (key.type) {
+        case 'up': {
+            if (vis.length === 0)
+                return state;
+            return { ...state, cursor: (state.cursor - 1 + vis.length) % vis.length };
+        }
+        case 'down': {
+            if (vis.length === 0)
+                return state;
+            return { ...state, cursor: (state.cursor + 1) % vis.length };
+        }
+        case 'toggle': {
+            if (vis.length === 0)
+                return state;
+            const item = vis[Math.max(0, Math.min(state.cursor, vis.length - 1))];
+            const selected = new Set(state.selected);
+            if (item.value === exports.ALL_SENTINEL) {
+                const reals = realValues(state);
+                const allSel = reals.every((v) => selected.has(v));
+                if (allSel) {
+                    reals.forEach((v) => selected.delete(v));
+                    selected.delete(exports.ALL_SENTINEL);
+                }
+                else {
+                    reals.forEach((v) => selected.add(v));
+                    selected.add(exports.ALL_SENTINEL);
+                }
+            }
+            else {
+                if (selected.has(item.value)) {
+                    selected.delete(item.value);
+                    selected.delete(exports.ALL_SENTINEL); // no longer all-selected
+                }
+                else {
+                    selected.add(item.value);
+                    // if every real item is now selected, also mark the sentinel
+                    const reals = realValues(state);
+                    if (reals.every((v) => selected.has(v)))
+                        selected.add(exports.ALL_SENTINEL);
+                }
+            }
+            return { ...state, selected };
+        }
+        case 'toggleAll': {
+            const reals = vis.filter((i) => i.value !== exports.ALL_SENTINEL).map((i) => i.value);
+            const selected = new Set(state.selected);
+            const allSel = reals.every((v) => selected.has(v));
+            if (allSel) {
+                reals.forEach((v) => selected.delete(v));
+                selected.delete(exports.ALL_SENTINEL);
+            }
+            else {
+                reals.forEach((v) => selected.add(v));
+                selected.add(exports.ALL_SENTINEL);
+            }
+            return { ...state, selected };
+        }
+        case 'filterChar':
+            return { ...state, filter: state.filter + key.char, cursor: 0 };
+        case 'backspace':
+            return { ...state, filter: state.filter.slice(0, -1), cursor: 0 };
+    }
+}
+function defaultIO() {
+    return { input: process.stdin, output: process.stdout };
+}
+/**
+ * Interactive multiselect. Returns the selected values, or null if cancelled.
+ * Streams are injectable for testing. Always restores terminal state on exit.
+ */
+function multiselectPicker(opts, io = defaultIO()) {
+    return new Promise((resolve) => {
+        let state = {
+            title: opts.title,
+            items: opts.items,
+            selected: new Set(opts.initialSelected ?? []),
+            cursor: 0,
+            filter: '',
+        };
+        let lastLineCount = 0;
+        const size = () => ({
+            columns: io.output.columns ?? 80,
+            rows: io.output.rows ?? 24,
+        });
+        const draw = () => {
+            const lines = (0, picker_view_1.renderPicker)(state, size());
+            // Move up over the previous frame and clear downward.
+            if (lastLineCount > 0)
+                io.output.write(`\x1b[${lastLineCount}A`);
+            io.output.write('\x1b[0J');
+            io.output.write(lines.join('\n') + '\n');
+            lastLineCount = lines.length;
+        };
+        let onSigint;
+        const cleanup = () => {
+            io.input.removeListener('data', onData);
+            if (onSigint)
+                process.removeListener('SIGINT', onSigint);
+            try {
+                io.input.setRawMode?.(false);
+            }
+            catch { /* best-effort: terminal may not support raw mode */ }
+            io.input.pause?.();
+            io.output.write('\x1b[?25h'); // show cursor
+        };
+        const onData = (chunk) => {
+            const key = parseKey(chunk.toString());
+            switch (key.action) {
+                case 'confirm':
+                    cleanup();
+                    resolve(Array.from(state.selected));
+                    return;
+                case 'cancel':
+                    cleanup();
+                    resolve(null);
+                    return;
+                case 'clearOrCancel':
+                    if (state.filter) {
+                        state = { ...state, filter: '', cursor: 0 };
+                        break;
+                    }
+                    cleanup();
+                    resolve(null);
+                    return;
+                case 'up':
+                    state = pickerReducer(state, { type: 'up' });
+                    break;
+                case 'down':
+                    state = pickerReducer(state, { type: 'down' });
+                    break;
+                case 'toggle':
+                    state = pickerReducer(state, { type: 'toggle' });
+                    break;
+                case 'toggleAll':
+                    state = pickerReducer(state, { type: 'toggleAll' });
+                    break;
+                case 'backspace':
+                    state = pickerReducer(state, { type: 'backspace' });
+                    break;
+                case 'char':
+                    state = pickerReducer(state, { type: 'filterChar', char: key.char });
+                    break;
+                case 'none': return; // ignore, no redraw
+            }
+            draw();
+        };
+        onSigint = () => {
+            cleanup();
+            resolve(null);
+        };
+        process.once('SIGINT', onSigint);
+        try {
+            io.input.setRawMode?.(true);
+        }
+        catch { /* best-effort: degrade if raw mode unsupported */ }
+        io.input.resume?.();
+        io.input.setEncoding?.('utf8');
+        io.output.write('\x1b[?25l'); // hide cursor
+        io.input.on('data', onData);
+        draw();
+    });
+}

package/dist/src/ui/text.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripAnsi = stripAnsi;
+exports.displayWidth = displayWidth;
+exports.truncate = truncate;
+exports.wrap = wrap;
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+function stripAnsi(s) {
+    return s.replace(ANSI_RE, '');
+}
+function isWide(cp) {
+    return ((cp >= 0x1100 && cp <= 0x115f) || // Hangul Jamo
+        (cp >= 0x2300 && cp <= 0x23ff) || // misc technical (⏎ etc.)
+        (cp >= 0x2600 && cp <= 0x27bf) || // misc symbols / dingbats
+        (cp >= 0x4e00 && cp <= 0x9fff) || // CJK Unified Ideographs
+        (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul Syllables
+        (cp >= 0xff00 && cp <= 0xffef) || // Fullwidth Latin/symbols
+        (cp >= 0x1f000 && cp <= 0x1faff) // emoji
+    );
+}
+/** Visible terminal cells, ignoring ANSI color and treating known wide glyphs as 2. */
+function displayWidth(s) {
+    const plain = stripAnsi(s);
+    let w = 0;
+    for (const ch of plain) {
+        const cp = ch.codePointAt(0);
+        if (cp === 0xfe0f)
+            continue; // variation selector — zero width
+        w += isWide(cp) ? 2 : 1;
+    }
+    return w;
+}
+/** Truncate plain text to `width` cells, appending '…'. Strips ANSI — color AFTER truncating. */
+function truncate(s, width) {
+    if (width <= 0)
+        return '';
+    const plain = stripAnsi(s);
+    if (displayWidth(plain) <= width)
+        return plain;
+    if (width === 1)
+        return '…';
+    let out = '';
+    let w = 0;
+    for (const ch of plain) {
+        const cw = displayWidth(ch);
+        if (w + cw > width - 1)
+            break;
+        out += ch;
+        w += cw;
+    }
+    return out + '…';
+}
+/** Word-wrap plain text to `width` cells. Long single words are not split (acceptable). */
+function wrap(s, width) {
+    if (width <= 0)
+        return [s];
+    const words = stripAnsi(s).split(/\s+/).filter(Boolean);
+    const lines = [];
+    let cur = '';
+    for (const word of words) {
+        if (cur === '') {
+            cur = word;
+            continue;
+        }
+        if (displayWidth(cur) + 1 + displayWidth(word) <= width)
+            cur += ' ' + word;
+        else {
+            lines.push(cur);
+            cur = word;
+        }
+    }
+    if (cur)
+        lines.push(cur);
+    return lines.length ? lines : [''];
+}

package/dist/src/ui/tty.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInteractive = isInteractive;
+exports.terminalSize = terminalSize;
+/** True only when both ends are TTYs — the precondition for the interactive picker. */
+function isInteractive() {
+    return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
+/** Current terminal size, with a safe 80x24 fallback when undefined (non-TTY). */
+function terminalSize() {
+    return {
+        columns: process.stdout.columns ?? 80,
+        rows: process.stdout.rows ?? 24,
+    };
+}

package/dist/src/utils/config.js

@@ -8,14 +8,14 @@ exports.savePreferences = savePreferences;
 // src/utils/config.ts
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
+const paths_1 = require("../core/paths");
 const DEFAULT_PREFS = {
     defaultAgent: 'antigravity',
     installMethod: 'symlink',
     defaultScope: 'local'
 };
 function prefsDir() {
-    return process.env.AWM_HOME || path_1.default.join(process.env.HOME || os_1.default.homedir(), '.awm');
+    return (0, paths_1.awmHome)();
 }
 function getPreferences() {
     const file = path_1.default.join(prefsDir(), 'preferences.json');

package/dist/src/utils/registry-view.js

@@ -10,11 +10,12 @@ exports.packageSummaryLines = packageSummaryLines;
 exports.packageDetailLines = packageDetailLines;
 exports.findPackage = findPackage;
 exports.artifactValue = artifactValue;
-exports.buildLevel1Options = buildLevel1Options;
-exports.buildLevel2Options = buildLevel2Options;
+exports.packagePickerItems = packagePickerItems;
+exports.artifactPickerItems = artifactPickerItems;
 exports.resolveLevel2Selection = resolveLevel2Selection;
 const picocolors_1 = __importDefault(require("picocolors"));
 const registries_1 = require("../core/registries");
+const text_1 = require("../ui/text");
 exports.STANDALONE_NAME = 'standalone';
 function makePackage(name, description, isStandalone, visibility, artifacts) {
     return {
@@ -73,7 +74,7 @@ function artifactCountLabel(counts) {
 function packageIcon(pkg) {
     return pkg.isStandalone ? '🔹' : '📦';
 }
-function packageSummaryLines(packages) {
+function packageSummaryLines(packages, width) {
     const uniqueSkillNames = new Set(packages.flatMap((p) => p.artifacts.filter((a) => a.type === 'skill').map((a) => a.name)));
     const totalSkills = uniqueSkillNames.size;
     const lines = [`AWM Registry — ${plural(packages.length, 'package')}, ${plural(totalSkills, 'skill')}`, ''];
@@ -83,12 +84,17 @@ function packageSummaryLines(packages) {
     packages.forEach((p, i) => {
         const name = p.name.padEnd(nameWidth);
         const count = countLabels[i].padEnd(countWidth);
-        const desc = p.isStandalone ? '' : p.description;
+        let desc = p.isStandalone ? '' : p.description;
+        if (width && desc) {
+            const used = 3 + nameWidth + 3 + countWidth + 3; // icon(2)+space(1), name, gap, count, gap
+            const avail = width - used;
+            desc = avail > 1 ? (0, text_1.truncate)(desc, avail) : '';
+        }
         lines.push(`${packageIcon(p)} ${name}   ${count}   ${desc}`.trimEnd());
     });
     return lines;
 }
-function packageDetailLines(pkg) {
+function packageDetailLines(pkg, width) {
     const lines = [];
     const header = pkg.isStandalone
         ? `${packageIcon(pkg)} ${pkg.name} — ${plural(pkg.artifacts.length, 'artifact')}`
@@ -99,8 +105,10 @@ function packageDetailLines(pkg) {
             ? picocolors_1.default.yellow(`  ← ${(0, registries_1.registryNameForPath)(a.sourcePath) ?? 'unknown'} (override)`)
             : '';
         lines.push(`  ${TYPE_ICON[a.type]}${a.name}${mark}`);
-        if (a.description)
-            lines.push(`     ${a.description}`);
+        if (a.description) {
+            const desc = width ? (0, text_1.truncate)(a.description, width - 5) : a.description;
+            lines.push(`     ${desc}`);
+        }
     });
     return lines;
 }
@@ -130,21 +138,27 @@ exports.ALL_SENTINEL = '__ALL__';
 function artifactValue(a) {
     return `${a.type}:${a.name}`;
 }
-function buildLevel1Options(packages) {
-    return packages.map((p) => {
-        const count = p.isStandalone ? plural(p.artifacts.length, 'artifact') : artifactCountLabel(p.counts);
-        const desc = p.isStandalone ? '' : ` · ${p.description}`;
-        return { value: p.name, label: `${packageIcon(p)} ${p.name}  ${picocolors_1.default.dim(`${count}${desc}`)}` };
-    });
+function packagePickerItems(packages) {
+    return packages.map((p) => ({
+        value: p.name,
+        label: `${packageIcon(p)} ${p.name}`,
+        description: p.isStandalone
+            ? plural(p.artifacts.length, 'artifact')
+            : `${artifactCountLabel(p.counts)} · ${p.description}`,
+    }));
 }
-function buildLevel2Options(pkg) {
-    const installAll = { value: exports.ALL_SENTINEL, label: `✨ Install entire package (${pkg.artifacts.length})` };
-    const rest = pkg.artifacts.map((a) => {
-        const title = `${TYPE_ICON[a.type]}${a.name}`;
-        const label = a.description ? `${title}\n     ${picocolors_1.default.dim(a.description)}` : title;
-        return { value: artifactValue(a), label };
-    });
-    return [installAll, ...rest];
+function artifactPickerItems(pkg) {
+    const all = {
+        value: exports.ALL_SENTINEL,
+        label: `✨ Install entire package (${pkg.artifacts.length})`,
+        description: 'Select every artifact in this package.',
+    };
+    const rest = pkg.artifacts.map((a) => ({
+        value: artifactValue(a),
+        label: `${TYPE_ICON[a.type]}${a.name}`,
+        description: a.description || '',
+    }));
+    return [all, ...rest];
 }
 function resolveLevel2Selection(pkg, selectedValues) {
     if (selectedValues.includes(exports.ALL_SENTINEL))

package/dist/tests/commands/doctor-platform.test.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const doctor_1 = require("../../src/commands/doctor");
+describe('doctor renderReport — platform line', () => {
+    const realPlatform = process.platform;
+    afterEach(() => {
+        Object.defineProperty(process, 'platform', { value: realPlatform, configurable: true });
+    });
+    function emptyReport() {
+        return { overall: 'healthy', hasProject: false, projectName: undefined, results: [] };
+    }
+    it('renders the platform label under the Machine header', () => {
+        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+        const out = (0, doctor_1.renderReport)(emptyReport());
+        expect(out).toContain('platform: Linux');
+    });
+    it('flags native Windows with a WSL hint', () => {
+        Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+        const out = (0, doctor_1.renderReport)(emptyReport());
+        expect(out).toContain('WSL');
+    });
+});

package/dist/tests/commands/hooks/install-symlink-fallback.test.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+describe('hooks/install — skill symlink fallback to copy', () => {
+    let tmpHome;
+    let origHome;
+    let origAwmHome;
+    let symlinkSpy;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-symlink-fb-'));
+        origHome = process.env.HOME;
+        origAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        symlinkSpy?.mockRestore();
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        if (origHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = origHome;
+        if (origAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = origAwmHome;
+    });
+    function seedRegistry(root) {
+        const hooksDir = path_1.default.join(root, 'hooks');
+        const skillDir = path_1.default.join(root, 'skills', 'using-awm');
+        fs_1.default.mkdirSync(hooksDir, { recursive: true });
+        fs_1.default.mkdirSync(skillDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(hooksDir, 'session-start'), '#!/bin/sh\n');
+        fs_1.default.writeFileSync(path_1.default.join(hooksDir, 'run-hook.cmd'), '#!/bin/sh\n');
+        fs_1.default.writeFileSync(path_1.default.join(skillDir, 'SKILL.md'), '# using-awm\n');
+    }
+    it('copies the skill when symlink throws (EPERM), preserving content', () => {
+        const registryRoot = path_1.default.join(tmpHome, 'registry');
+        seedRegistry(registryRoot);
+        // Force symlinkSync to fail like a platform without symlink permission.
+        symlinkSpy = jest.spyOn(fs_1.default, 'symlinkSync').mockImplementation(() => {
+            const err = new Error('EPERM: operation not permitted, symlink');
+            err.code = 'EPERM';
+            throw err;
+        });
+        const { installHook } = require('../../../src/commands/hooks/install');
+        const result = installHook({ agent: 'claude-code', registryRoot, installMethod: 'copy' });
+        const skillDest = path_1.default.join(result.scriptsDir, 'using-awm.md');
+        expect(fs_1.default.existsSync(skillDest)).toBe(true);
+        expect(fs_1.default.lstatSync(skillDest).isSymbolicLink()).toBe(false); // it was copied, not linked
+        expect(fs_1.default.readFileSync(skillDest, 'utf-8')).toContain('using-awm');
+    });
+});

package/dist/tests/commands/sensors/eslint-formatter.test.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const eslint_1 = require("../../../src/commands/sensors/formatters/eslint");
+describe('parseEslintOutput — relative path normalization', () => {
+    it('produces a cwd-relative path using the OS separator', () => {
+        const cwd = process.cwd();
+        const abs = path_1.default.join(cwd, 'src', 'foo.ts');
+        const raw = JSON.stringify([
+            { filePath: abs, messages: [{ ruleId: 'no-eval', severity: 2, message: 'no eval', line: 3, column: 1 }] },
+        ]);
+        const errors = (0, eslint_1.parseEslintOutput)(raw);
+        expect(errors).toHaveLength(1);
+        const first = errors[0];
+        if (!first)
+            throw new Error('Expected at least one error');
+        // path.join('src','foo.ts') uses the OS separator; on POSIX this is 'src/foo.ts'
+        expect(first.file).toBe(path_1.default.join('src', 'foo.ts'));
+        const file = first.file ?? '';
+        expect(file.startsWith(path_1.default.sep)).toBe(false); // genuinely relative
+    });
+    it('preserves the absolute path for files outside cwd', () => {
+        const abs = '/some/other/project/file.ts';
+        const raw = JSON.stringify([
+            { filePath: abs, messages: [{ ruleId: 'no-eval', severity: 2, message: 'no eval', line: 1, column: 1 }] },
+        ]);
+        const errors = (0, eslint_1.parseEslintOutput)(raw);
+        expect(errors).toHaveLength(1);
+        expect(errors[0]?.file).toBe(abs); // absolute path preserved, no traversal strings
+    });
+});

package/dist/tests/core/paths.test.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../../src/core/paths");
+describe('core/paths', () => {
+    let origHome;
+    let origAwmHome;
+    const realPlatform = process.platform;
+    beforeEach(() => {
+        origHome = process.env.HOME;
+        origAwmHome = process.env.AWM_HOME;
+    });
+    afterEach(() => {
+        if (origHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = origHome;
+        if (origAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = origAwmHome;
+        Object.defineProperty(process, 'platform', { value: realPlatform, configurable: true });
+    });
+    function setPlatform(p) {
+        Object.defineProperty(process, 'platform', { value: p, configurable: true });
+    }
+    it('homeDir uses process.env.HOME when set', () => {
+        process.env.HOME = '/tmp/fake-home';
+        expect((0, paths_1.homeDir)()).toBe('/tmp/fake-home');
+    });
+    it('homeDir falls back to os.homedir() when HOME is unset', () => {
+        delete process.env.HOME;
+        expect((0, paths_1.homeDir)()).toBe(os_1.default.homedir());
+    });
+    it('awmHome honors AWM_HOME override', () => {
+        process.env.AWM_HOME = '/tmp/custom-awm';
+        expect((0, paths_1.awmHome)()).toBe('/tmp/custom-awm');
+    });
+    it('awmHome defaults to <home>/.awm when AWM_HOME is unset', () => {
+        delete process.env.AWM_HOME;
+        process.env.HOME = '/tmp/fake-home';
+        expect((0, paths_1.awmHome)()).toBe(path_1.default.join('/tmp/fake-home', '.awm'));
+    });
+    it('platform reflects process.platform', () => {
+        setPlatform('linux');
+        expect((0, paths_1.platform)()).toBe('linux');
+    });
+    it('isWindowsNative is true only on win32', () => {
+        setPlatform('win32');
+        expect((0, paths_1.isWindowsNative)()).toBe(true);
+        setPlatform('linux');
+        expect((0, paths_1.isWindowsNative)()).toBe(false);
+        setPlatform('darwin');
+        expect((0, paths_1.isWindowsNative)()).toBe(false);
+    });
+    it('platformLabel describes each known platform', () => {
+        setPlatform('linux');
+        expect((0, paths_1.platformLabel)()).toBe('Linux');
+        setPlatform('darwin');
+        expect((0, paths_1.platformLabel)()).toBe('macOS');
+        setPlatform('win32');
+        expect((0, paths_1.platformLabel)()).toContain('WSL');
+    });
+    it('warnIfUnsupportedPlatform calls the logger only on win32', () => {
+        const calls = [];
+        const log = (m) => calls.push(m);
+        setPlatform('linux');
+        (0, paths_1.warnIfUnsupportedPlatform)(log);
+        expect(calls).toHaveLength(0);
+        setPlatform('win32');
+        (0, paths_1.warnIfUnsupportedPlatform)(log);
+        expect(calls).toEqual([paths_1.WINDOWS_NATIVE_WARNING]);
+    });
+});