@reximo/cli 0.1.0-alpha.4 → 0.1.0-alpha.6

package/src/lib/run-cli.js

@@ -4,7 +4,9 @@ exports.runCli = runCli;
 const tslib_1 = require("tslib");
 const node_process_1 = tslib_1.__importDefault(require("node:process"));
 const commander_1 = require("commander");
+const command_inputs_1 = require("./command-inputs");
 const config_1 = require("./config");
+const formatters_1 = require("./formatters");
 const output_1 = require("./output");
 const prompts_1 = require("./prompts");
 const package_json_1 = tslib_1.__importDefault(require("../../package.json"));
@@ -84,6 +86,14 @@ function createAuthenticatedContext(dependencies, configOptions) {
         organizationId: requireConfiguredOrganization(config)
     };
 }
+async function withAuthenticatedContext(dependencies, configOptions, run) {
+    const context = createAuthenticatedContext(dependencies, configOptions);
+    return run(context);
+}
+async function runAuthenticatedCommand(params) {
+    const result = await withAuthenticatedContext(params.dependencies, params.configOptions, params.operation);
+    writeResult(params.command, params.dependencies, params.text(result), params.json(result));
+}
 async function resolveRequiredValue(currentValue, label, prompt) {
     if (currentValue?.trim()) {
         return currentValue.trim();
@@ -139,107 +149,66 @@ async function resolveOrganizationContext(promptAdapter, organizations, organiza
     const selectedOrganizationId = await promptAdapter.select('Select organization', choices);
     return (activeOrganizations.find((organization) => organization.organizationId === selectedOrganizationId) ?? null);
 }
-function formatIssueIdentifier(issue) {
-    if (issue.project?.key) {
-        return `${issue.project.key}-${issue.issueNumber}`;
-    }
-    return `#${issue.issueNumber}`;
-}
-function formatIssueLines(result) {
-    if (result.data.length === 0) {
-        return ['No issues found.'];
-    }
-    const lines = [
-        `Issues: ${result.metadata.pagination.total} total (page ${result.metadata.pagination.page}/${Math.max(result.metadata.pagination.totalPages, 1)})`
-    ];
-    for (const issue of result.data) {
-        lines.push(`${formatIssueIdentifier(issue)} [id:${issue.id}] ${issue.title} (${issue.status}, ${issue.priority})`);
-    }
-    return lines;
-}
-function formatIssueDetailLines(issue) {
-    return [
-        `Issue: ${formatIssueIdentifier(issue)} [id:${issue.id}]`,
-        `Title: ${issue.title}`,
-        `Status: ${issue.status}`,
-        `Priority: ${issue.priority}`,
-        `Project: ${issue.project?.name ?? '(none)'}`,
-        `Updated: ${issue.updatedAt}`
-    ];
-}
-function formatProjectAccess(project) {
-    if (project.visibility === 'public') {
-        return 'public';
-    }
-    return project.isMember ? 'private member' : 'private';
-}
-function formatProjectLines(result) {
-    if (result.data.length === 0) {
-        return ['No projects found.'];
-    }
-    const lines = [
-        `Projects: ${result.metadata.pagination.total} total (page ${result.metadata.pagination.page}/${Math.max(result.metadata.pagination.totalPages, 1)})`
-    ];
-    for (const project of result.data) {
-        lines.push(`${project.key} [id:${project.id}] ${project.name} (${formatProjectAccess(project)})`);
-    }
-    return lines;
-}
-function buildUpdateIssuePayload(options) {
-    const payload = {};
-    if (options.title !== undefined) {
-        payload['title'] = options.title;
-    }
-    if (options.descriptionMarkdown !== undefined) {
-        payload['descriptionMarkdown'] = options.descriptionMarkdown;
-    }
-    if (options.status !== undefined) {
-        payload['status'] = options.status;
-    }
-    if (options.statusDefinitionId !== undefined) {
-        payload['statusDefinitionId'] = options.statusDefinitionId;
-    }
-    if (options.priority !== undefined) {
-        payload['priority'] = options.priority;
-    }
-    if (options.position !== undefined) {
-        payload['position'] = options.position;
-    }
-    if (options.baseRevision !== undefined) {
-        payload['baseRevision'] = options.baseRevision;
-    }
-    if (options.clearParentIssue) {
-        payload['parentIssueId'] = null;
-    }
-    else if (options.parentIssueId !== undefined) {
-        payload['parentIssueId'] = options.parentIssueId;
-    }
-    if (options.clearEstimate) {
-        payload['estimate'] = null;
-    }
-    else if (options.estimate !== undefined) {
-        payload['estimate'] = options.estimate;
-    }
-    if (options.clearDueAt) {
-        payload['dueAt'] = null;
-    }
-    else if (options.dueAt !== undefined) {
-        payload['dueAt'] = options.dueAt;
-    }
-    if (Object.keys(payload).length === 0) {
-        throw new Error('At least one update field is required.');
-    }
-    return payload;
+function buildAuthStatus(config, client) {
+    const target = client.describeTarget();
+    return {
+        profile: config.profile,
+        configPath: config.configPath,
+        configFileFound: config.configFileFound,
+        apiBaseUrl: config.apiBaseUrl ?? config_1.DEFAULT_API_BASE_URL,
+        isConfigured: client.isConfigured(),
+        hasAccessToken: target.hasAccessToken,
+        hasRefreshToken: target.hasRefreshToken,
+        organizationId: target.organizationId
+    };
 }
-function buildIssuesSearchInput(options) {
-    if (options.status !== undefined || options.statuses !== undefined) {
-        return options;
-    }
+function buildDoctorReport(config, client) {
+    const auth = buildAuthStatus(config, client);
     return {
-        ...options,
-        statuses: ["backlog" /* IssueStatusOption.Backlog */, "in_progress" /* IssueStatusOption.InProgress */, "blocked" /* IssueStatusOption.Blocked */]
+        command: 'doctor',
+        auth,
+        checks: {
+            apiBaseUrlConfigured: auth.isConfigured,
+            accessTokenConfigured: auth.hasAccessToken,
+            refreshTokenConfigured: auth.hasRefreshToken,
+            organizationConfigured: Boolean(auth.organizationId),
+            readyForAuthenticatedCommands: auth.isConfigured && auth.hasAccessToken && Boolean(auth.organizationId)
+        },
+        capabilities: {
+            issues: {
+                search: true,
+                list: true,
+                get: true,
+                create: true,
+                update: true,
+                delete: true,
+                comment: true,
+                transition: true,
+                link: true
+            },
+            projects: {
+                list: true
+            },
+            content: {
+                list: true,
+                get: true,
+                create: true,
+                update: true,
+                delete: true,
+                publish: false,
+                attach: false
+            }
+        },
+        notes: [
+            'Issue search, get, create, update, delete, comment, transition, and link are currently supported.',
+            'Project listing and content list, get, create, update, and delete are currently supported.',
+            'The current API surface does not expose a separate content publish endpoint.'
+        ]
     };
 }
+function unsupportedContentError(subcommand) {
+    return new Error(`Content command "${subcommand}" is not yet supported by the installed Reximo CLI/API surface. Run \`reximo doctor --json\` to inspect current capabilities.`);
+}
 function createProgram(dependencies) {
     const configOptions = {
         env: dependencies.env,
@@ -260,6 +229,17 @@ function createProgram(dependencies) {
             dependencies.stderr.write(message);
         }
     });
+    registerInfoCommand(program, dependencies, configOptions);
+    registerAuthCommands(program, dependencies, configOptions);
+    registerDoctorCommand(program, dependencies, configOptions);
+    registerIssueCommands(program, dependencies, configOptions);
+    registerProjectCommands(program, dependencies, configOptions);
+    registerContentCommands(program, dependencies, configOptions);
+    registerConfigCommands(program, dependencies, configOptions);
+    registerSessionCommands(program, dependencies, configOptions);
+    return program;
+}
+function registerInfoCommand(program, dependencies, configOptions) {
     program
         .command('info')
         .description('Show package and runtime information for diagnostics.')
@@ -296,6 +276,53 @@ function createProgram(dependencies) {
             }
         });
     });
+}
+function registerAuthCommands(program, dependencies, configOptions) {
+    const authCommand = program.command('auth').description('Inspect Reximo authentication state.');
+    authCommand
+        .command('status')
+        .description('Show whether the current CLI profile is ready for authenticated API commands.')
+        .action(function action() {
+        const config = (0, config_1.loadResolvedConfig)(configOptions);
+        const client = dependencies.clientFactory(config);
+        const status = buildAuthStatus(config, client);
+        writeResult(this, dependencies, [
+            `Profile: ${status.profile}`,
+            `Config path: ${status.configPath}`,
+            `Config file found: ${status.configFileFound ? 'yes' : 'no'}`,
+            `API base URL: ${status.apiBaseUrl}`,
+            `Configured for API: ${status.isConfigured ? 'yes' : 'no'}`,
+            `Access token configured: ${status.hasAccessToken ? 'yes' : 'no'}`,
+            `Refresh token configured: ${status.hasRefreshToken ? 'yes' : 'no'}`,
+            `Organization: ${status.organizationId ?? '(not configured)'}`
+        ], {
+            command: 'auth.status',
+            status
+        });
+    });
+}
+function registerDoctorCommand(program, dependencies, configOptions) {
+    program
+        .command('doctor')
+        .description('Report Reximo CLI readiness and command-surface capabilities for automation.')
+        .action(function action() {
+        const config = (0, config_1.loadResolvedConfig)(configOptions);
+        const client = dependencies.clientFactory(config);
+        const report = buildDoctorReport(config, client);
+        writeResult(this, dependencies, [
+            `Profile: ${report.auth.profile}`,
+            `Configured for API: ${report.auth.isConfigured ? 'yes' : 'no'}`,
+            `Access token configured: ${report.auth.hasAccessToken ? 'yes' : 'no'}`,
+            `Refresh token configured: ${report.auth.hasRefreshToken ? 'yes' : 'no'}`,
+            `Organization: ${report.auth.organizationId ?? '(not configured)'}`,
+            `Ready for authenticated commands: ${report.auth.isConfigured && report.auth.hasAccessToken && Boolean(report.auth.organizationId) ? 'yes' : 'no'}`,
+            `Issue commands: search, list, get, create, update, delete, comment, transition, link`,
+            `Content commands: list, get, create, update, delete`,
+            `Unsupported content commands: publish, attach`
+        ], report);
+    });
+}
+function registerIssueCommands(program, dependencies, configOptions) {
     const issuesCommand = program.command('issues').description('Manage issues.');
     issuesCommand
         .command('search')
@@ -315,15 +342,41 @@ function createProgram(dependencies) {
         .option('--sort-by <sortBy>', 'Sort field')
         .option('--sort-order <sortOrder>', 'Sort direction')
         .action(async function action(options) {
-        const { client, accessToken, organizationId } = createAuthenticatedContext(dependencies, configOptions);
-        const result = await client.listIssues({
-            accessToken,
-            organizationId,
-            ...buildIssuesSearchInput(options)
+        await runAuthenticatedCommand({
+            command: this,
+            dependencies,
+            configOptions,
+            operation: ({ client, accessToken, organizationId }) => client.listIssues({
+                accessToken,
+                organizationId,
+                ...(0, command_inputs_1.buildIssuesSearchInput)(options)
+            }),
+            text: (result) => (0, formatters_1.formatIssueLines)(result),
+            json: (result) => ({
+                command: 'issues.search',
+                result
+            })
         });
-        writeResult(this, dependencies, formatIssueLines(result), {
-            command: 'issues.search',
-            result
+    });
+    issuesCommand
+        .command('get <issueId>')
+        .alias('show')
+        .description('Get one issue by id in the configured organization.')
+        .action(async function action(issueId) {
+        await runAuthenticatedCommand({
+            command: this,
+            dependencies,
+            configOptions,
+            operation: ({ client, accessToken, organizationId }) => client.getIssue({
+                accessToken,
+                organizationId,
+                issueId
+            }),
+            text: (issue) => (0, formatters_1.formatIssueDetailLines)(issue),
+            json: (issue) => ({
+                command: 'issues.get',
+                issue
+            })
         });
     });
     issuesCommand
@@ -340,21 +393,27 @@ function createProgram(dependencies) {
         .option('--estimate <estimate>', 'Issue estimate', Number)
         .option('--due-at <dueAt>', 'Issue due date as an ISO-8601 string')
         .action(async function action(options) {
-        const { client, accessToken, organizationId } = createAuthenticatedContext(dependencies, configOptions);
         if (!options.title?.trim()) {
             throw new Error('Title is required');
         }
-        const issue = await client.createIssue({
-            accessToken,
-            organizationId,
-            issue: {
-                ...options,
-                title: options.title.trim()
-            }
-        });
-        writeResult(this, dependencies, formatIssueDetailLines(issue), {
-            command: 'issues.create',
-            issue
+        const title = options.title.trim();
+        await runAuthenticatedCommand({
+            command: this,
+            dependencies,
+            configOptions,
+            operation: ({ client, accessToken, organizationId }) => client.createIssue({
+                accessToken,
+                organizationId,
+                issue: {
+                    ...options,
+                    title
+                }
+            }),
+            text: (issue) => (0, formatters_1.formatIssueDetailLines)(issue),
+            json: (issue) => ({
+                command: 'issues.create',
+                issue
+            })
         });
     });
     issuesCommand
@@ -374,34 +433,145 @@ function createProgram(dependencies) {
         .option('--clear-due-at', 'Clear the current due date')
         .option('--base-revision <baseRevision>', 'Optimistic concurrency token from the last issue read')
         .action(async function action(issueId, options) {
-        const { client, accessToken, organizationId } = createAuthenticatedContext(dependencies, configOptions);
-        const issue = await client.updateIssue({
-            accessToken,
-            organizationId,
-            issueId,
-            issue: buildUpdateIssuePayload(options)
+        await runAuthenticatedCommand({
+            command: this,
+            dependencies,
+            configOptions,
+            operation: ({ client, accessToken, organizationId }) => client.updateIssue({
+                accessToken,
+                organizationId,
+                issueId,
+                issue: (0, command_inputs_1.buildUpdateIssuePayload)(options)
+            }),
+            text: (issue) => (0, formatters_1.formatIssueDetailLines)(issue),
+            json: (issue) => ({
+                command: 'issues.update',
+                issue
+            })
         });
-        writeResult(this, dependencies, formatIssueDetailLines(issue), {
-            command: 'issues.update',
-            issue
+    });
+    issuesCommand
+        .command('transition <issueId>')
+        .description('Transition one issue by updating its status or status definition.')
+        .option('--status <status>', 'Issue status')
+        .option('--status-definition-id <statusDefinitionId>', 'Issue status definition id', Number)
+        .option('--base-revision <baseRevision>', 'Optimistic concurrency token from the last issue read')
+        .action(async function action(issueId, options) {
+        if (options.status === undefined && options.statusDefinitionId === undefined) {
+            throw new Error('Either --status or --status-definition-id is required.');
+        }
+        await runAuthenticatedCommand({
+            command: this,
+            dependencies,
+            configOptions,
+            operation: ({ client, accessToken, organizationId }) => client.updateIssue({
+                accessToken,
+                organizationId,
+                issueId,
+                issue: {
+                    ...(options.status !== undefined ? { status: options.status } : {}),
+                    ...(options.statusDefinitionId !== undefined
+                        ? { statusDefinitionId: options.statusDefinitionId }
+                        : {}),
+                    ...(options.baseRevision !== undefined ? { baseRevision: options.baseRevision } : {})
+                }
+            }),
+            text: (issue) => (0, formatters_1.formatIssueDetailLines)(issue),
+            json: (issue) => ({
+                command: 'issues.transition',
+                issue
+            })
+        });
+    });
+    issuesCommand
+        .command('comment <issueId>')
+        .description('Create one issue comment in the configured organization.')
+        .option('--body-markdown <bodyMarkdown>', 'Issue comment body in markdown')
+        .option('--parent-comment-id <parentCommentId>', 'Optional parent comment id', Number)
+        .action(async function action(issueId, options) {
+        if (!options.bodyMarkdown?.trim()) {
+            throw new Error('Comment body is required');
+        }
+        const bodyMarkdown = options.bodyMarkdown.trim();
+        await runAuthenticatedCommand({
+            command: this,
+            dependencies,
+            configOptions,
+            operation: ({ client, accessToken, organizationId }) => client.createIssueComment({
+                accessToken,
+                organizationId,
+                issueId,
+                comment: {
+                    bodyMarkdown,
+                    ...(options.parentCommentId !== undefined
+                        ? { parentCommentId: options.parentCommentId }
+                        : {})
+                }
+            }),
+            text: (issue) => (0, formatters_1.formatIssueDetailLines)(issue),
+            json: (issue) => ({
+                command: 'issues.comment',
+                issue
+            })
+        });
+    });
+    issuesCommand
+        .command('link <issueId>')
+        .description('Create one issue relation from the selected issue to another issue.')
+        .option('--target-issue-id <targetIssueId>', 'Target issue id', Number)
+        .option('--relation-type <relationType>', 'Relation type key')
+        .action(async function action(issueId, options) {
+        if (options.targetIssueId === undefined) {
+            throw new Error('Target issue id is required');
+        }
+        if (!options.relationType?.trim()) {
+            throw new Error('Relation type is required');
+        }
+        const targetIssueId = options.targetIssueId;
+        const relationType = options.relationType;
+        await runAuthenticatedCommand({
+            command: this,
+            dependencies,
+            configOptions,
+            operation: ({ client, accessToken, organizationId }) => client.createIssueRelation({
+                accessToken,
+                organizationId,
+                issueId,
+                relation: {
+                    targetIssueId,
+                    relationType
+                }
+            }),
+            text: (issue) => (0, formatters_1.formatIssueDetailLines)(issue),
+            json: (issue) => ({
+                command: 'issues.link',
+                issue
+            })
         });
     });
     issuesCommand
         .command('delete <issueId>')
         .description('Delete one issue by id in the configured organization.')
         .action(async function action(issueId) {
-        const { client, accessToken, organizationId } = createAuthenticatedContext(dependencies, configOptions);
-        await client.deleteIssue({
-            accessToken,
-            organizationId,
-            issueId
-        });
-        writeResult(this, dependencies, [`Issue ${issueId} deleted.`], {
-            command: 'issues.delete',
-            issueId,
-            deleted: true
+        await runAuthenticatedCommand({
+            command: this,
+            dependencies,
+            configOptions,
+            operation: ({ client, accessToken, organizationId }) => client.deleteIssue({
+                accessToken,
+                organizationId,
+                issueId
+            }),
+            text: () => [`Issue ${issueId} deleted.`],
+            json: () => ({
+                command: 'issues.delete',
+                issueId,
+                deleted: true
+            })
         });
     });
+}
+function registerProjectCommands(program, dependencies, configOptions) {
     const projectsCommand = program.command('projects').description('Manage projects.');
     projectsCommand
         .command('list')
@@ -413,17 +583,176 @@ function createProgram(dependencies) {
         .option('--sort-by <sortBy>', 'Sort field')
         .option('--sort-order <sortOrder>', 'Sort direction')
         .action(async function action(options) {
-        const { client, accessToken, organizationId } = createAuthenticatedContext(dependencies, configOptions);
-        const result = await client.listProjects({
-            accessToken,
-            organizationId,
-            ...options
+        await runAuthenticatedCommand({
+            command: this,
+            dependencies,
+            configOptions,
+            operation: ({ client, accessToken, organizationId }) => client.listProjects({
+                accessToken,
+                organizationId,
+                ...options
+            }),
+            text: (result) => (0, formatters_1.formatProjectLines)(result),
+            json: (result) => ({
+                command: 'projects.list',
+                result
+            })
         });
-        writeResult(this, dependencies, formatProjectLines(result), {
-            command: 'projects.list',
-            result
+    });
+}
+function registerContentCommands(program, dependencies, configOptions) {
+    const contentCommand = program.command('content').description('Manage content entries.');
+    contentCommand
+        .command('list')
+        .description('List org-scoped content by default, or project-scoped content when a project id or key is provided.')
+        .option('--scope <scope>', 'Content scope filter')
+        .option('--project-id <projectId>', 'Project id filter', Number)
+        .option('--project-key <projectKey>', 'Project key filter')
+        .option('--parent-id <parentId>', 'Parent content id filter', Number)
+        .option('--slug <slug>', 'Slug filter')
+        .action(async function action(options) {
+        const normalizedOptions = (0, command_inputs_1.normalizeContentListOptions)(options);
+        await runAuthenticatedCommand({
+            command: this,
+            dependencies,
+            configOptions,
+            operation: ({ client, accessToken, organizationId }) => client.listContent({
+                accessToken,
+                organizationId,
+                ...normalizedOptions
+            }),
+            text: (result) => (0, formatters_1.formatContentLines)(result),
+            json: (result) => ({
+                command: 'content.list',
+                result
+            })
+        });
+    });
+    contentCommand
+        .command('get <contentId>')
+        .alias('show')
+        .description('Get one content entry by id in the configured organization.')
+        .action(async function action(contentId) {
+        await runAuthenticatedCommand({
+            command: this,
+            dependencies,
+            configOptions,
+            operation: ({ client, accessToken, organizationId }) => client.getContent({
+                accessToken,
+                organizationId,
+                contentId
+            }),
+            text: (content) => (0, formatters_1.formatContentDetailLines)(content),
+            json: (content) => ({
+                command: 'content.get',
+                content
+            })
+        });
+    });
+    contentCommand
+        .command('create')
+        .description('Create one content entry in the configured organization.')
+        .option('--title <title>', 'Content title')
+        .option('--content-markdown <contentMarkdown>', 'Content body in markdown')
+        .option('--slug <slug>', 'Content slug')
+        .option('--project-id <projectId>', 'Project id', Number)
+        .option('--parent-id <parentId>', 'Parent content id', Number)
+        .option('--position <position>', 'Content position', Number)
+        .action(async function action(options) {
+        if (!options.title?.trim()) {
+            throw new Error('Title is required');
+        }
+        if (!options.contentMarkdown?.trim()) {
+            throw new Error('Content markdown is required');
+        }
+        const title = options.title.trim();
+        const contentMarkdown = options.contentMarkdown;
+        await runAuthenticatedCommand({
+            command: this,
+            dependencies,
+            configOptions,
+            operation: ({ client, accessToken, organizationId }) => client.createContent({
+                accessToken,
+                organizationId,
+                content: {
+                    title,
+                    contentMarkdown,
+                    ...(options.slug !== undefined ? { slug: options.slug } : {}),
+                    ...(options.projectId !== undefined ? { projectId: options.projectId } : {}),
+                    ...(options.parentId !== undefined ? { parentId: options.parentId } : {}),
+                    ...(options.position !== undefined ? { position: options.position } : {})
+                }
+            }),
+            text: (content) => (0, formatters_1.formatContentDetailLines)(content),
+            json: (content) => ({
+                command: 'content.create',
+                content
+            })
         });
     });
+    contentCommand
+        .command('update <contentId>')
+        .description('Update one content entry by id in the configured organization.')
+        .option('--title <title>', 'Content title')
+        .option('--content-markdown <contentMarkdown>', 'Content body in markdown')
+        .option('--slug <slug>', 'Content slug')
+        .option('--parent-id <parentId>', 'Parent content id', Number)
+        .option('--position <position>', 'Content position', Number)
+        .option('--clear-parent', 'Clear the current parent content id')
+        .option('--base-revision <baseRevision>', 'Optimistic concurrency token from the last content read')
+        .action(async function action(contentId, options) {
+        await runAuthenticatedCommand({
+            command: this,
+            dependencies,
+            configOptions,
+            operation: ({ client, accessToken, organizationId }) => client.updateContent({
+                accessToken,
+                organizationId,
+                contentId,
+                content: (0, command_inputs_1.buildUpdateContentPayload)(options)
+            }),
+            text: (content) => (0, formatters_1.formatContentDetailLines)(content),
+            json: (content) => ({
+                command: 'content.update',
+                content
+            })
+        });
+    });
+    contentCommand
+        .command('delete <contentId>')
+        .description('Delete one content entry by id in the configured organization.')
+        .action(async function action(contentId) {
+        await runAuthenticatedCommand({
+            command: this,
+            dependencies,
+            configOptions,
+            operation: ({ client, accessToken, organizationId }) => client.deleteContent({
+                accessToken,
+                organizationId,
+                contentId
+            }),
+            text: () => [`Content ${contentId} deleted.`],
+            json: () => ({
+                command: 'content.delete',
+                contentId,
+                deleted: true
+            })
+        });
+    });
+    contentCommand
+        .command('publish <contentId>')
+        .description('Publish one content artifact when supported by the installed CLI/API surface.')
+        .action(async () => {
+        throw unsupportedContentError("publish" /* UnsupportedContentCommand.Publish */);
+    });
+    contentCommand
+        .command('attach <contentId>')
+        .description('Attach an artifact to content when supported by the installed CLI/API surface.')
+        .action(async () => {
+        throw unsupportedContentError("attach" /* UnsupportedContentCommand.Attach */);
+    });
+}
+function registerConfigCommands(program, dependencies, configOptions) {
     const configCommand = program
         .command('config')
         .description('Inspect resolved CLI configuration.');
@@ -446,6 +775,8 @@ function createProgram(dependencies) {
             config: renderConfigSummary(config, Boolean(options.includeSensitive))
         });
     });
+}
+function registerSessionCommands(program, dependencies, configOptions) {
     program
         .command('login')
         .description('Authenticate with the Reximo API and save auth state for the active profile.')
@@ -546,7 +877,6 @@ function createProgram(dependencies) {
             tokensCleared: true
         });
     });
-    return program;
 }
 async function runCli(args, dependencies) {
     const runtimeDependencies = toRuntimeDependencies(dependencies);