agentic-workflow-manager 3.1.0 → 3.2.1

package/dist/src/providers/index.js

@@ -3,61 +3,165 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROVIDERS = void 0;
+exports.UnsupportedRendererError = exports.AGENT_TARGETS = void 0;
+exports.isAgentTarget = isAgentTarget;
+exports.requireAgentTarget = requireAgentTarget;
+exports.providers = providers;
+exports.providerFor = providerFor;
 exports.getTargetPath = getTargetPath;
 exports.getHookConfig = getHookConfig;
+exports.getSettingsMergeHookConfig = getSettingsMergeHookConfig;
+exports.assertLinkRenderer = assertLinkRenderer;
 exports.getInjection = getInjection;
 // src/providers/index.ts
 const path_1 = __importDefault(require("path"));
 const paths_1 = require("../core/paths");
-const homedir = (0, paths_1.homeDir)();
-const awmHomeDir = (0, paths_1.awmHome)();
-exports.PROVIDERS = {
-    antigravity: {
-        label: 'Antigravity',
-        skill: { global: path_1.default.join(homedir, '.gemini/antigravity/skills'), local: '.agent/skills' },
-        workflow: { global: path_1.default.join(homedir, '.gemini/antigravity/global_workflows'), local: '.agent/workflows' },
-        agent: null
-    },
-    opencode: {
-        label: 'OpenCode',
-        skill: { global: path_1.default.join(homedir, '.agents/skills'), local: '.agents/skills' },
-        workflow: null,
-        agent: { global: path_1.default.join(homedir, '.config/opencode/agents'), local: '.agents/profiles' },
-        injection: {
-            type: 'config-instructions',
-            configPath: path_1.default.join(homedir, '.config/opencode/opencode.json'),
-            field: 'instructions',
+exports.AGENT_TARGETS = ['antigravity', 'opencode', 'claude-code', 'codex'];
+function isAgentTarget(value) {
+    return typeof value === 'string' &&
+        exports.AGENT_TARGETS.includes(value);
+}
+/** Assertion form of `isAgentTarget` — narrows or throws a clear, user-facing error. */
+function requireAgentTarget(value) {
+    if (!isAgentTarget(value)) {
+        throw new Error(`Invalid agent target: ${String(value)}. Use: ${exports.AGENT_TARGETS.join(', ')}.`);
+    }
+    return value;
+}
+class UnsupportedRendererError extends Error {
+}
+exports.UnsupportedRendererError = UnsupportedRendererError;
+function providers() {
+    const home = (0, paths_1.homeDir)();
+    const awm = (0, paths_1.awmHome)();
+    return {
+        antigravity: {
+            label: 'Antigravity',
+            skill: {
+                global: path_1.default.join(home, '.gemini/antigravity/skills'),
+                local: '.agent/skills',
+                renderer: 'link',
+            },
+            workflow: {
+                global: path_1.default.join(home, '.gemini/antigravity/global_workflows'),
+                local: '.agent/workflows',
+                renderer: 'link',
+            },
+            agent: null,
+        },
+        opencode: {
+            label: 'OpenCode',
+            skill: {
+                global: path_1.default.join(home, '.agents/skills'),
+                local: '.agents/skills',
+                renderer: 'link',
+            },
+            workflow: null,
+            agent: {
+                global: path_1.default.join(home, '.config/opencode/agents'),
+                local: '.agents/profiles',
+                renderer: 'link',
+            },
+            injection: {
+                type: 'config-instructions',
+                configPath: path_1.default.join(home, '.config/opencode/opencode.json'),
+                field: 'instructions',
+            },
         },
-    },
-    'claude-code': {
-        label: 'Claude Code',
-        skill: { global: path_1.default.join(homedir, '.claude/skills'), local: '.claude/skills' },
-        workflow: null,
-        agent: { global: path_1.default.join(homedir, '.claude/agents'), local: '.claude/agents' },
-        hooks: {
-            type: 'cc-settings-merge',
-            settingsPath: path_1.default.join(homedir, '.claude/settings.json'),
-            scriptsDir: path_1.default.join(awmHomeDir, 'hooks'),
-            matcher: 'startup|clear|compact',
-            eventName: 'SessionStart'
+        'claude-code': {
+            label: 'Claude Code',
+            skill: {
+                global: path_1.default.join(home, '.claude/skills'),
+                local: '.claude/skills',
+                renderer: 'link',
+            },
+            workflow: null,
+            agent: {
+                global: path_1.default.join(home, '.claude/agents'),
+                local: '.claude/agents',
+                renderer: 'link',
+            },
+            hooks: {
+                type: 'cc-settings-merge',
+                settingsPath: path_1.default.join(home, '.claude/settings.json'),
+                scriptsDir: path_1.default.join(awm, 'hooks'),
+                matcher: 'startup|clear|compact',
+                eventName: 'SessionStart',
+            },
+            injection: { type: 'cc-settings-merge' },
         },
-        injection: { type: 'cc-settings-merge' }
+        codex: {
+            label: 'Codex',
+            minimumVersion: '0.145.0',
+            versionCommand: { command: 'codex', args: ['--version'] },
+            skill: {
+                global: path_1.default.join(home, '.agents/skills'),
+                local: '.agents/skills',
+                renderer: 'link',
+            },
+            workflow: null,
+            agent: {
+                global: path_1.default.join(home, '.codex/agents'),
+                local: '.codex/agents',
+                renderer: 'codex-agent-toml',
+            },
+            hooks: {
+                type: 'codex-hooks-json',
+                settingsPath: path_1.default.join(home, '.codex/hooks.json'),
+                scriptsDir: path_1.default.join(awm, 'hooks/codex'),
+                matcher: 'startup|resume|clear|compact',
+                eventName: 'SessionStart',
+            },
+            injection: {
+                type: 'managed-agents-md',
+                globalPath: path_1.default.join(home, '.codex/AGENTS.md'),
+                localFile: 'AGENTS.md',
+            },
+        },
+    };
+}
+function providerFor(agent) {
+    if (!isAgentTarget(agent)) {
+        throw new Error(`Unknown agent target: ${String(agent)}`);
     }
-};
+    return providers()[agent];
+}
 function getTargetPath(type, agent, scope) {
-    const provider = exports.PROVIDERS[agent];
-    if (!provider)
-        throw new Error(`Unknown agent target: ${agent}`);
+    if (!['skill', 'workflow', 'agent'].includes(type)) {
+        throw new Error(`Unknown artifact type: ${String(type)}`);
+    }
+    if (!['global', 'local'].includes(scope)) {
+        throw new Error(`Unknown scope: ${String(scope)}`);
+    }
+    const provider = providerFor(agent);
     const config = provider[type];
     if (!config)
         throw new Error(`${type}s are not supported by ${provider.label}.`);
     return config[scope];
 }
 function getHookConfig(agent) {
-    const provider = exports.PROVIDERS[agent];
-    return provider?.hooks;
+    return providerFor(agent).hooks;
+}
+function getSettingsMergeHookConfig(agent) {
+    const config = getHookConfig(agent);
+    if (!config) {
+        throw new Error(`hooks not supported for agent target: ${agent}`);
+    }
+    if (config.type !== 'cc-settings-merge') {
+        throw new Error(`${providerFor(agent).label} hook strategy is not implemented yet`);
+    }
+    return config;
+}
+function assertLinkRenderer(type, agent) {
+    if (!['skill', 'workflow', 'agent'].includes(type)) {
+        throw new Error(`Unknown artifact type: ${String(type)}`);
+    }
+    const config = providerFor(agent)[type];
+    if (config && config.renderer !== 'link') {
+        throw new UnsupportedRendererError(`Renderer '${config.renderer}' for ${agent} ${type} artifacts is not implemented yet`);
+    }
+    return config;
 }
 function getInjection(agent) {
-    return exports.PROVIDERS[agent]?.injection;
+    return providerFor(agent).injection;
 }

package/dist/src/ui/provider-preflight.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preflightLinkArtifactsForCli = preflightLinkArtifactsForCli;
+const picocolors_1 = __importDefault(require("picocolors"));
+const provider_artifacts_1 = require("../core/provider-artifacts");
+function defaultIO() {
+    return {
+        error: (message) => { console.error(message); },
+        exit: (code) => { process.exit(code); },
+    };
+}
+function preflightLinkArtifactsForCli(pairs, io = defaultIO()) {
+    try {
+        (0, provider_artifacts_1.preflightLinkArtifactPairs)(pairs);
+        return true;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        io.error(picocolors_1.default.red(message));
+        io.exit(1);
+        return false;
+    }
+}

package/dist/src/utils/config.js

@@ -5,16 +5,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferencesExist = preferencesExist;
 exports.getPreferences = getPreferences;
+exports.loadPreferences = loadPreferences;
 exports.savePreferences = savePreferences;
+exports.enableAgent = enableAgent;
 // src/utils/config.ts
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const providers_1 = require("../providers");
 const paths_1 = require("../core/paths");
 const DEFAULT_PREFS = {
     // claude-code matches `awm init`'s own documented default (see init.ts / `awm init --help`).
     // Previously 'antigravity', which silently mis-installed bundles in claude-code
     // environments when `awm add` (the first getPreferences caller) stamped it to disk (#7).
     defaultAgent: 'claude-code',
+    enabledAgents: ['claude-code'],
     installMethod: 'symlink',
     defaultScope: 'local'
 };
@@ -28,19 +32,107 @@ function prefsFile() {
 function preferencesExist() {
     return fs_1.default.existsSync(prefsFile());
 }
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function isPlainObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function normalizePreferences(value, allowEnabledAgentsMigration = true) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('preferences.json must contain a JSON object');
+    }
+    const raw = value;
+    if (!(0, providers_1.isAgentTarget)(raw.defaultAgent)) {
+        throw new Error('preferences.json has an invalid defaultAgent');
+    }
+    if (raw.installMethod !== 'symlink' && raw.installMethod !== 'copy') {
+        throw new Error('preferences.json has an invalid installMethod');
+    }
+    if (raw.defaultScope !== 'global' && raw.defaultScope !== 'local') {
+        throw new Error('preferences.json has an invalid defaultScope');
+    }
+    if (raw.baseRemote !== undefined && !isNonEmptyString(raw.baseRemote)) {
+        throw new Error('preferences.json has an invalid baseRemote');
+    }
+    if (raw.channel !== undefined && raw.channel !== 'stable' && raw.channel !== 'dev') {
+        throw new Error('preferences.json has an invalid channel');
+    }
+    if (raw.pins !== undefined && (!isPlainObject(raw.pins) ||
+        !Object.entries(raw.pins).every(([name, version]) => isNonEmptyString(name) && isNonEmptyString(version)))) {
+        throw new Error('preferences.json has invalid pins');
+    }
+    if (raw.enabledAgents === undefined && !allowEnabledAgentsMigration) {
+        throw new Error('preferences.json has an invalid enabledAgents');
+    }
+    const source = raw.enabledAgents === undefined ? [raw.defaultAgent] : raw.enabledAgents;
+    if (!Array.isArray(source) || !source.every(providers_1.isAgentTarget)) {
+        throw new Error('preferences.json has an invalid enabledAgents');
+    }
+    const enabledAgents = Array.from(new Set(source));
+    if (!enabledAgents.includes(raw.defaultAgent)) {
+        throw new Error('preferences.json defaultAgent must be included in enabledAgents');
+    }
+    const prefs = { ...raw, enabledAgents };
+    return {
+        prefs,
+        changed: raw.enabledAgents === undefined ||
+            JSON.stringify(source) !== JSON.stringify(enabledAgents),
+    };
+}
 function getPreferences() {
-    const file = path_1.default.join(prefsDir(), 'preferences.json');
-    if (!fs_1.default.existsSync(file)) {
+    const loaded = loadPreferences();
+    if (!loaded.exists) {
         savePreferences(DEFAULT_PREFS);
-        return DEFAULT_PREFS;
+        return { ...DEFAULT_PREFS, enabledAgents: [...DEFAULT_PREFS.enabledAgents] };
+    }
+    if (loaded.migrationRequired)
+        savePreferences(loaded.prefs);
+    return loaded.prefs;
+}
+function loadPreferences(initialAgent = 'claude-code') {
+    if (!(0, providers_1.isAgentTarget)(initialAgent)) {
+        throw new Error('initialAgent must be a valid agent target');
     }
-    const raw = fs_1.default.readFileSync(file, 'utf-8');
-    return JSON.parse(raw);
+    const file = prefsFile();
+    if (!fs_1.default.existsSync(file)) {
+        const prefs = {
+            ...DEFAULT_PREFS,
+            defaultAgent: initialAgent,
+            enabledAgents: [initialAgent],
+        };
+        return { prefs, exists: false, migrationRequired: true };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
+    }
+    catch {
+        throw new Error(`${file} is not valid JSON. Fix it manually, then re-run.`);
+    }
+    const result = normalizePreferences(parsed);
+    return { prefs: result.prefs, exists: true, migrationRequired: result.changed };
 }
 function savePreferences(prefs) {
-    const dir = prefsDir();
-    if (!fs_1.default.existsSync(dir)) {
-        fs_1.default.mkdirSync(dir, { recursive: true });
+    const normalized = normalizePreferences(prefs, false).prefs;
+    const file = prefsFile();
+    fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+    const temp = `${file}.${process.pid}.tmp`;
+    fs_1.default.writeFileSync(temp, JSON.stringify(normalized, null, 2) + '\n', {
+        encoding: 'utf8',
+        mode: 0o600,
+    });
+    fs_1.default.renameSync(temp, file);
+}
+function enableAgent(prefs, agent) {
+    normalizePreferences(prefs);
+    if (!(0, providers_1.isAgentTarget)(agent)) {
+        throw new Error('agent must be a valid agent target');
     }
-    fs_1.default.writeFileSync(path_1.default.join(dir, 'preferences.json'), JSON.stringify(prefs, null, 2), 'utf-8');
+    return prefs.enabledAgents.includes(agent)
+        ? prefs
+        : { ...prefs, enabledAgents: [...prefs.enabledAgents, agent] };
 }

package/dist/tests/commands/agent.test.js

@@ -0,0 +1,103 @@
+"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 os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+describe('agent command — listAgents / disableAgent', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-agentcmd-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    function prefsWith(enabledAgents, defaultAgent) {
+        const { savePreferences } = require('../../src/utils/config');
+        savePreferences({
+            defaultAgent,
+            enabledAgents,
+            installMethod: 'symlink',
+            defaultScope: 'local',
+        });
+    }
+    function writePrefs(enabledAgents, defaultAgent) {
+        prefsWith(enabledAgents, defaultAgent);
+    }
+    function readPrefs() {
+        const file = path_1.default.join(process.env.AWM_HOME, 'preferences.json');
+        return JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
+    }
+    it('lists supported, enabled and default state', () => {
+        writePrefs(['claude-code', 'codex'], 'claude-code');
+        const { listAgents } = require('../../src/commands/agent');
+        expect(listAgents()).toEqual(expect.arrayContaining([
+            { id: 'claude-code', label: 'Claude Code', enabled: true, default: true },
+            { id: 'codex', label: 'Codex', enabled: true, default: false },
+            { id: 'opencode', label: 'OpenCode', enabled: false, default: false },
+        ]));
+    });
+    it('refuses to disable the default without a replacement', () => {
+        writePrefs(['claude-code', 'codex'], 'claude-code');
+        const { disableAgent } = require('../../src/commands/agent');
+        expect(() => disableAgent('claude-code')).toThrow('--default <agent>');
+    });
+    it('disables management state without deleting provider files', () => {
+        const marker = path_1.default.join(tmpHome, '.codex/AGENTS.md');
+        fs_1.default.mkdirSync(path_1.default.dirname(marker), { recursive: true });
+        fs_1.default.writeFileSync(marker, 'keep');
+        writePrefs(['claude-code', 'codex'], 'claude-code');
+        const { disableAgent } = require('../../src/commands/agent');
+        disableAgent('codex');
+        expect(readPrefs().enabledAgents).toEqual(['claude-code']);
+        expect(fs_1.default.readFileSync(marker, 'utf8')).toBe('keep');
+    });
+    it('disabling the default WITH a valid replacement succeeds and switches the default', () => {
+        writePrefs(['claude-code', 'codex'], 'claude-code');
+        const { disableAgent } = require('../../src/commands/agent');
+        disableAgent('claude-code', 'codex');
+        expect(readPrefs()).toEqual({
+            defaultAgent: 'codex',
+            enabledAgents: ['codex'],
+            installMethod: 'symlink',
+            defaultScope: 'local',
+        });
+    });
+    it('rejects a replacement default that is not itself enabled', () => {
+        writePrefs(['claude-code', 'codex'], 'claude-code');
+        const { disableAgent } = require('../../src/commands/agent');
+        expect(() => disableAgent('claude-code', 'opencode')).toThrow('must remain enabled');
+    });
+    it('rejects disabling an agent that is not enabled', () => {
+        writePrefs(['claude-code'], 'claude-code');
+        const { disableAgent } = require('../../src/commands/agent');
+        expect(() => disableAgent('codex')).toThrow('is not enabled');
+    });
+    it('registers `agent list` and `agent disable` subcommands', () => {
+        const { Command } = require('commander');
+        const { registerAgentCommand } = require('../../src/commands/agent');
+        const program = new Command();
+        registerAgentCommand(program);
+        const agent = program.commands.find((c) => c.name() === 'agent');
+        expect(agent).toBeDefined();
+        const subNames = agent.commands.map((c) => c.name());
+        expect(subNames).toEqual(expect.arrayContaining(['list', 'disable']));
+    });
+});

package/dist/tests/commands/backup.test.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// tests/commands/backup.test.ts
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const commander_1 = require("commander");
+const install_transaction_1 = require("../../src/core/install-transaction");
+const backup_1 = require("../../src/commands/backup");
+let tmpHome;
+let tmpWork;
+let originalHome;
+let originalAwmHome;
+beforeEach(() => {
+    tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-backupcmd-home-'));
+    tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-backupcmd-work-'));
+    originalHome = process.env.HOME;
+    originalAwmHome = process.env.AWM_HOME;
+    process.env.HOME = tmpHome;
+    process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+});
+afterEach(() => {
+    fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+    fs_1.default.rmSync(tmpWork, { recursive: true, force: true });
+    if (originalHome === undefined)
+        delete process.env.HOME;
+    else
+        process.env.HOME = originalHome;
+    if (originalAwmHome === undefined)
+        delete process.env.AWM_HOME;
+    else
+        process.env.AWM_HOME = originalAwmHome;
+});
+describe('restoreBackup', () => {
+    it('restores only manifest targets and rejects path traversal ids', () => {
+        const codexAgentsFile = path_1.default.join(tmpWork, 'AGENTS.md');
+        const preferencesFile = path_1.default.join(tmpWork, 'preferences.json');
+        const unrelatedFile = path_1.default.join(tmpWork, 'unrelated.txt');
+        fs_1.default.writeFileSync(codexAgentsFile, 'codex-before');
+        fs_1.default.writeFileSync(preferencesFile, 'prefs-before');
+        fs_1.default.writeFileSync(unrelatedFile, 'keep');
+        const session = (0, install_transaction_1.beginBackupSession)([codexAgentsFile, preferencesFile]);
+        fs_1.default.writeFileSync(codexAgentsFile, 'codex-after');
+        fs_1.default.writeFileSync(preferencesFile, 'prefs-after');
+        expect(() => (0, install_transaction_1.restoreBackup)('../outside')).toThrow('invalid backup transaction id');
+        const validTransactionId = session.transactionId;
+        const result = (0, install_transaction_1.restoreBackup)(validTransactionId);
+        expect(result.restored).toEqual([codexAgentsFile, preferencesFile]);
+        expect(fs_1.default.readFileSync(unrelatedFile, 'utf8')).toBe('keep'); // verifies R25
+        expect(fs_1.default.readFileSync(codexAgentsFile, 'utf8')).toBe('codex-before');
+        expect(fs_1.default.readFileSync(preferencesFile, 'utf8')).toBe('prefs-before');
+    });
+    it('rejects ids that embed a path separator even when digit-prefixed', () => {
+        expect(() => (0, install_transaction_1.restoreBackup)('2024-01-01T00-00-00-000Z/../../etc')).toThrow('invalid backup transaction id');
+    });
+    it('rejects a well-formed but nonexistent transaction id', () => {
+        expect(() => (0, install_transaction_1.restoreBackup)('2020-01-01T00-00-00-000Z')).toThrow();
+    });
+});
+describe('listBackups', () => {
+    it('lists recorded transactions newest first, without leaking file contents', () => {
+        const fileA = path_1.default.join(tmpWork, 'a.txt');
+        fs_1.default.writeFileSync(fileA, 'secret-value');
+        const session = (0, install_transaction_1.beginBackupSession)([fileA]);
+        const backups = (0, install_transaction_1.listBackups)();
+        expect(backups.length).toBe(1);
+        expect(backups[0].id).toBe(session.transactionId);
+        expect(backups[0].targets).toEqual([fileA]);
+        expect(backups[0].committed).toBe(false);
+        expect(JSON.stringify(backups)).not.toContain('secret-value');
+    });
+    it('returns an empty list when no backups exist yet', () => {
+        expect((0, install_transaction_1.listBackups)()).toEqual([]);
+    });
+});
+describe('registerBackupCommand', () => {
+    it('registers `backup list` and `backup restore` subcommands', () => {
+        const program = new commander_1.Command();
+        (0, backup_1.registerBackupCommand)(program);
+        const backup = program.commands.find((c) => c.name() === 'backup');
+        expect(backup).toBeDefined();
+        const subNames = backup.commands.map((c) => c.name());
+        expect(subNames).toEqual(expect.arrayContaining(['list', 'restore']));
+    });
+    it('`backup list --json` prints the same data as listBackups()', () => {
+        const fileA = path_1.default.join(tmpWork, 'b.txt');
+        fs_1.default.writeFileSync(fileA, 'v');
+        (0, install_transaction_1.beginBackupSession)([fileA]);
+        const program = new commander_1.Command();
+        program.exitOverride();
+        (0, backup_1.registerBackupCommand)(program);
+        let output = '';
+        const write = jest.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+            output += chunk.toString();
+            return true;
+        });
+        try {
+            program.parse(['node', 'awm', 'backup', 'list', '--json']);
+        }
+        finally {
+            write.mockRestore();
+        }
+        const parsed = JSON.parse(output);
+        expect(parsed).toEqual((0, install_transaction_1.listBackups)());
+    });
+});