@copado/agentia-cli 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/commands/cicd/data/template/save-detail.js

@@ -2,7 +2,7 @@ import { Args } from '@oclif/core';
 import { AgentiaCommand } from '../../../../lib/agentia-command.js';
 import { CicdGateway } from '../../../../lib/cicd-gateway.js';
 import { assertJsonObject, jsonBodyFlags, readJsonBodyFromFileOrStdin, } from '../../../../lib/data-flags.js';
-import { dataTemplateDetailEndpoint } from '../../../../lib/data-types.js';
+import { dataTemplateDetailEndpoint, normalizeDataTemplateSavePayload, } from '../../../../lib/data-types.js';
 export default class DataTemplateSaveDetail extends AgentiaCommand {
     static args = {
         id: Args.string({
@@ -26,7 +26,7 @@ export default class DataTemplateSaveDetail extends AgentiaCommand {
             required: true,
             stdin: flags.stdin,
         });
-        const body = assertJsonObject(raw, 'template detail');
+        const body = normalizeDataTemplateSavePayload(assertJsonObject(raw, 'template detail'));
         const result = await this.withSpinner('Saving data template detail', () => CicdGateway.call({
             body,
             endpoint: dataTemplateDetailEndpoint(args.id),

package/dist/commands/cicd/repository/auth/https/configure.js

@@ -0,0 +1,21 @@
+import { Args, Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../../../lib/agentia-command.js';
+import { configureHttps, promptHttpsPayload, readHttpsAuthPayloadFromStdin } from '../../../../../lib/repository-auth.js';
+export default class RepositoryAuthHttpsConfigure extends AgentiaCommand {
+    static args = { id: Args.string({ description: 'Copado Git repository ID', required: true }) };
+    static description = 'Configure HTTPS authentication. Use a personal access token as the password when required by the provider.';
+    static flags = {
+        'input-stdin': Flags.boolean({ description: 'Read the complete HTTPS authentication JSON payload from stdin' }),
+        overwrite: Flags.boolean({ description: 'Replace an existing validated HTTPS credential' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(RepositoryAuthHttpsConfigure);
+        if (this.jsonEnabled() && !flags['input-stdin'])
+            this.error('--json requires --input-stdin so secrets cannot be prompted.', { exit: 2 });
+        const payload = flags['input-stdin'] ? await readHttpsAuthPayloadFromStdin() : await promptHttpsPayload(args.id);
+        await this.withSpinner('Configuring HTTPS authentication', () => configureHttps(args.id, payload, flags.overwrite, !flags['input-stdin']));
+        this.display(() => this.log(`Configured HTTPS authentication for repository ${args.id}.`));
+        return { id: args.id };
+    }
+}
+//# sourceMappingURL=configure.js.map

package/dist/commands/cicd/repository/auth/oauth/login.js

@@ -0,0 +1,56 @@
+import { select } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../../../lib/agentia-command.js';
+import { CicdGateway } from '../../../../../lib/cicd-gateway.js';
+import { createLoopbackCallbackServer } from '../../../../../lib/loopback-callback-server.js';
+import { isHeadlessEnvironment, openUrl } from '../../../../../lib/open-browser.js';
+import { repositoryOAuthEndpoint, repositoryOAuthInitEndpoint, repositoryOAuthRepositoriesEndpoint, } from '../../../../../lib/repository-types.js';
+export default class RepositoryAuthOAuthLogin extends AgentiaCommand {
+    static args = { id: Args.string({ description: 'Copado Git repository ID', required: true }) };
+    static description = 'Authenticate a repository through browser OAuth and select a remote repository';
+    static flags = {
+        port: Flags.integer({ description: 'Local callback port (default: scan 8080-8090)' }),
+        timeout: Flags.integer({ default: 300, description: 'Seconds to wait for browser authentication' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(RepositoryAuthOAuthLogin);
+        if (this.jsonEnabled())
+            this.error('OAuth login requires an interactive terminal to select a repository.', { exit: 2 });
+        const callback = await createLoopbackCallbackServer({ port: flags.port });
+        if (!callback)
+            this.error('Could not bind a local OAuth callback port.', { exit: 2 });
+        try {
+            const init = await this.withSpinner('Generating OAuth authorization URL', () => CicdGateway.call({
+                endpoint: repositoryOAuthInitEndpoint(args.id, callback.callbackUrl),
+                method: 'POST',
+            }));
+            if (isHeadlessEnvironment()) {
+                this.log(`Complete authentication in your browser by opening this URL:\n${init.authUrl}`);
+            }
+            else {
+                this.log('Complete authentication in the browser window that opens.');
+                await openUrl(init.authUrl);
+            }
+            const result = await callback.waitForCallback({ timeoutMs: flags.timeout * 1000 });
+            if (!result.ok)
+                this.error(result.errorDescription ?? result.errorCode ?? 'OAuth authentication failed.', { exit: 1 });
+            const available = await CicdGateway.call({ endpoint: repositoryOAuthRepositoriesEndpoint(args.id), method: 'GET' });
+            const remoteRepositoryId = await select({
+                choices: available.repositories.map((repository) => ({ name: repository.name, value: repository.id })),
+                message: `Select ${available.provider} repository`,
+            });
+            await this.withSpinner('Saving selected repository', () => CicdGateway.call({
+                body: { remoteRepositoryId },
+                endpoint: repositoryOAuthEndpoint(args.id),
+                headers: { 'Content-Type': 'application/json' },
+                method: 'POST',
+            }));
+            this.log(`Configured OAuth authentication for repository ${args.id}.`);
+            return { id: args.id, remoteRepositoryId };
+        }
+        finally {
+            await callback.close().catch(() => { });
+        }
+    }
+}
+//# sourceMappingURL=login.js.map

package/dist/commands/cicd/repository/auth/setup.js

@@ -0,0 +1,28 @@
+import { select } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../../lib/agentia-command.js';
+export default class RepositoryAuthSetup extends AgentiaCommand {
+    static args = { id: Args.string({ description: 'Copado Git repository ID', required: true }) };
+    static description = 'Interactively configure repository authentication; OAuth is selected by default';
+    static flags = { overwrite: Flags.boolean({ description: 'Replace an existing HTTPS or SSH credential' }) };
+    async run() {
+        const { args, flags } = await this.parse(RepositoryAuthSetup);
+        if (this.jsonEnabled())
+            this.error('Repository auth setup requires an interactive terminal.', { exit: 2 });
+        const authType = await select({
+            choices: [
+                { name: 'OAuth (recommended)', value: 'oauth' },
+                { name: 'HTTPS', value: 'https' },
+                { name: 'SSH', value: 'ssh' },
+            ],
+            default: 'oauth',
+            message: 'Authentication type',
+        });
+        const command = authType === 'oauth'
+            ? 'cicd:repository:auth:oauth:login'
+            : `cicd:repository:auth:${authType}:configure`;
+        const argv = [args.id, ...(flags.overwrite && authType !== 'oauth' ? ['--overwrite'] : [])];
+        await this.config.runCommand(command, argv);
+    }
+}
+//# sourceMappingURL=setup.js.map

package/dist/commands/cicd/repository/auth/ssh/configure.js

@@ -0,0 +1,22 @@
+import { Args, Flags } from '@oclif/core';
+import { AgentiaCommand } from '../../../../../lib/agentia-command.js';
+import { configureSsh, promptConnection } from '../../../../../lib/repository-auth.js';
+export default class RepositoryAuthSshConfigure extends AgentiaCommand {
+    static args = { id: Args.string({ description: 'Copado Git repository ID', required: true }) };
+    static description = 'Generate SSH authentication and a public key. Add the key to your Git provider as a deploy, access, or SSH key.';
+    static flags = {
+        overwrite: Flags.boolean({ description: 'Replace an existing SSH key after confirmation' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(RepositoryAuthSshConfigure);
+        if (this.jsonEnabled())
+            this.error('SSH authentication requires an interactive terminal to collect connection details.', { exit: 2 });
+        const payload = await promptConnection(args.id, 'SSH');
+        const publicKey = await this.withSpinner('Generating SSH key', () => configureSsh(args.id, payload, flags.overwrite));
+        this.display(() => {
+            this.log(`Add this public key to your Git provider's repository deploy/access/SSH keys, then retain it for this repository:\n${publicKey}`);
+        });
+        return { id: args.id, publicKey };
+    }
+}
+//# sourceMappingURL=configure.js.map

package/dist/commands/cicd/repository/create.js

@@ -10,9 +10,9 @@ export default class RepositoryCreate extends AgentiaCommand {
             required: true,
         }),
     };
-    static description = 'Create a Copado Git repository';
+    static description = 'Create a Copado Git repository shell';
     static examples = [
-        '<%= config.bin %> <%= command.id %> my-repo --source-format DX --provider Github --uri https://github.com/org/repo.git',
+        '<%= config.bin %> <%= command.id %> my-repo --source-format DX --provider Github',
         '<%= config.bin %> <%= command.id %> my-repo --source-format DX --provider GitLab --json',
     ];
     static flags = repositoryCreateFlags;

package/dist/commands/cicd/repository/reset.js

@@ -1,4 +1,5 @@
-import { Args } from '@oclif/core';
+import { confirm } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
 import { AgentiaCommand } from '../../../lib/agentia-command.js';
 import { CicdGateway } from '../../../lib/cicd-gateway.js';
 import { repositoryResetEndpoint } from '../../../lib/repository-types.js';
@@ -9,13 +10,24 @@ export default class RepositoryReset extends AgentiaCommand {
             required: true,
         }),
     };
-    static description = 'Reset a Copado Git repository';
+    static description = 'Reset a Copado Git repository and its authentication configuration';
     static examples = [
-        '<%= config.bin %> <%= command.id %> repo-001',
-        '<%= config.bin %> <%= command.id %> repo-001 --json',
+        '<%= config.bin %> <%= command.id %> repo-001 --yes',
+        '<%= config.bin %> <%= command.id %> repo-001 --yes --json',
     ];
+    static flags = {
+        yes: Flags.boolean({ char: 'y', default: false, description: 'Confirm reset without prompting' }),
+    };
     async run() {
-        const { args } = await this.parse(RepositoryReset);
+        const { args, flags } = await this.parse(RepositoryReset);
+        if (!flags.yes) {
+            if (this.jsonEnabled() || process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+                this.error('Repository reset requires confirmation. Pass --yes for headless or JSON execution.', { exit: 2 });
+            }
+            if (!(await confirm({ default: false, message: `Reset repository ${args.id} and remove its authentication configuration?` }))) {
+                this.error('Repository reset canceled.', { exit: 1 });
+            }
+        }
         await this.withSpinner('Resetting repository', () => CicdGateway.call({
             endpoint: repositoryResetEndpoint(args.id),
             method: 'PUT',

package/dist/commands/cicd/repository/update.js

@@ -2,7 +2,7 @@ import { Args } from '@oclif/core';
 import { AgentiaCommand } from '../../../lib/agentia-command.js';
 import { CicdGateway } from '../../../lib/cicd-gateway.js';
 import { buildRepositoryMutationPayload, collectRepositoryMutationFlagKeys, REPOSITORY_STRING_VALIDATION_KEYS, repositoryUpdateFlags, validateNonEmptyStringFields, validateRepositoryMutationFlags, } from '../../../lib/repository-flags.js';
-import { normalizeRepository, repositoryEndpoint, withRequiredRepositoryFields, } from '../../../lib/repository-types.js';
+import { normalizeRepository, repositoryEndpoint } from '../../../lib/repository-types.js';
 export default class RepositoryUpdate extends AgentiaCommand {
     static args = {
         id: Args.string({
@@ -13,7 +13,7 @@ export default class RepositoryUpdate extends AgentiaCommand {
     static description = 'Update a Copado Git repository by ID';
     static examples = [
         '<%= config.bin %> <%= command.id %> repo-001 --uri https://github.com/org/repo.git',
-        '<%= config.bin %> <%= command.id %> repo-001 --clear-password',
+        '<%= config.bin %> <%= command.id %> repo-001 --clear-uri',
         '<%= config.bin %> <%= command.id %> repo-001 --provider GitLab --json',
     ];
     static flags = repositoryUpdateFlags;
@@ -25,7 +25,7 @@ export default class RepositoryUpdate extends AgentiaCommand {
                 exit: 2,
                 suggestions: [
                     `${this.config.bin} cicd repository update ${args.id} --uri <uri>`,
-                    `${this.config.bin} cicd repository update ${args.id} --clear-password`,
+                    `${this.config.bin} cicd repository update ${args.id} --clear-uri`,
                 ],
             });
         }
@@ -33,18 +33,10 @@ export default class RepositoryUpdate extends AgentiaCommand {
         if (flagError !== undefined) {
             this.error(flagError, { exit: 2 });
         }
-        const currentRepository = await this.withSpinner('Fetching repository', () => CicdGateway.call({
-            endpoint: repositoryEndpoint(args.id),
-            method: 'GET',
-        }));
-        const current = normalizeRepository(currentRepository);
-        const payload = withRequiredRepositoryFields(buildRepositoryMutationPayload(flags), current);
+        const payload = buildRepositoryMutationPayload(flags);
         const validationError = validateNonEmptyStringFields(payload, REPOSITORY_STRING_VALIDATION_KEYS);
-        if (payload.name === undefined ||
-            payload.sourceFormat === undefined ||
-            payload.provider === undefined ||
-            validationError !== undefined) {
-            this.error('Repository name, source format, and provider are required to update a repository.', { exit: 2 });
+        if (validationError !== undefined) {
+            this.error(validationError, { exit: 2 });
         }
         const response = await this.withSpinner('Updating repository', () => CicdGateway.call({
             body: payload,

package/dist/commands/cicd/work/environment-sync.js

@@ -1,5 +1,6 @@
 import { Flags } from '@oclif/core';
 import { AgentiaCommand } from '../../../lib/agentia-command.js';
+import { commandStdioCaptureOptions, withCapturedCommandOutput } from '../../../lib/command-output-buffer.js';
 import { assertEnvironmentSyncDestOrgSelector, formatWorkEnvironmentSyncResult, performWorkEnvironmentSync, WorkEnvironmentSyncConflictError, WorkEnvironmentSyncValidationError, } from '../../../lib/work-environment-sync.js';
 export default class WorkEnvironmentSync extends AgentiaCommand {
     static description = [
@@ -28,7 +29,7 @@ export default class WorkEnvironmentSync extends AgentiaCommand {
         }),
         continue: Flags.boolean({
             default: false,
-            description: 'Commit resolved merge conflicts and finish the remaining environment-sync git steps.',
+            description: 'Finish after merge conflicts. If the merge is still in progress (conflicts fixed and staged, but not committed), commits it; if you already committed, continues from there through the remaining git steps.',
             exclusive: ['abort'],
         }),
         'destination-credential': Flags.string({
@@ -51,70 +52,74 @@ export default class WorkEnvironmentSync extends AgentiaCommand {
     };
     async run() {
         const { flags } = await this.parse(WorkEnvironmentSync);
-        try {
-            await assertEnvironmentSyncDestOrgSelector({
-                abort: flags.abort === true,
-                continue: flags.continue === true,
-                destinationEnvironment: flags['destination-environment'],
-                devOrgBranch: flags['dev-org-branch'],
-                promotion: flags.promotion,
-            });
-            const result = await performWorkEnvironmentSync({
-                abort: flags.abort === true,
-                cliBin: this.config.bin,
-                continue: flags.continue === true,
-                hooks: {
-                    log: (message) => {
-                        this.display(() => {
-                            this.log(message);
-                        });
+        return withCapturedCommandOutput(async () => {
+            const startedAt = Date.now();
+            try {
+                await assertEnvironmentSyncDestOrgSelector({
+                    abort: flags.abort === true,
+                    continue: flags.continue === true,
+                    destinationEnvironment: flags['destination-environment'],
+                    devOrgBranch: flags['dev-org-branch'],
+                    promotion: flags.promotion,
+                });
+                const result = await performWorkEnvironmentSync({
+                    abort: flags.abort === true,
+                    cliBin: this.config.bin,
+                    continue: flags.continue === true,
+                    hooks: {
+                        log: (message) => {
+                            this.display(() => {
+                                this.log(message);
+                            });
+                        },
+                        withSpinner: (message, action) => this.withSpinner(message, action),
                     },
-                    withSpinner: (message, action) => this.withSpinner(message, action),
-                },
-                json: this.jsonEnabled(),
-                ...(flags['destination-credential'] === undefined
-                    ? {}
-                    : { destinationCredentialId: flags['destination-credential'] }),
-                ...(flags['destination-environment'] === undefined
-                    ? {}
-                    : { destinationEnvironment: flags['destination-environment'] }),
-                ...(flags['dev-org-branch'] === undefined ? {} : { devOrgBranch: flags['dev-org-branch'] }),
-                ...(flags['pipeline-id'] === undefined ? {} : { pipelineId: flags['pipeline-id'] }),
-                ...(flags.promotion === undefined ? {} : { promotion: flags.promotion }),
-            });
-            this.display(() => {
-                const formatted = formatWorkEnvironmentSyncResult(result);
-                if (formatted.length > 0) {
-                    this.log(formatted);
-                }
-            });
-            return result;
-        }
-        catch (error) {
-            if (error instanceof WorkEnvironmentSyncConflictError) {
-                const { suggestions } = error;
-                const suggestionOptions = suggestions === undefined ? {} : { suggestions };
-                if (this.jsonEnabled()) {
-                    const message = error.gitStatus === undefined || error.gitStatus.length === 0
-                        ? error.message
-                        : `${error.message}\n\n${error.gitStatus}`;
-                    this.error(message, { exit: error.exit, ...suggestionOptions });
+                    json: this.jsonEnabled(),
+                    ...(flags['destination-credential'] === undefined
+                        ? {}
+                        : { destinationCredentialId: flags['destination-credential'] }),
+                    ...(flags['destination-environment'] === undefined
+                        ? {}
+                        : { destinationEnvironment: flags['destination-environment'] }),
+                    ...(flags['dev-org-branch'] === undefined ? {} : { devOrgBranch: flags['dev-org-branch'] }),
+                    ...(flags['pipeline-id'] === undefined ? {} : { pipelineId: flags['pipeline-id'] }),
+                    ...(flags.promotion === undefined ? {} : { promotion: flags.promotion }),
+                });
+                this.display(() => {
+                    const formatted = formatWorkEnvironmentSyncResult(result);
+                    if (formatted.length > 0) {
+                        this.log(formatted);
+                    }
+                });
+                this.logElapsed(startedAt);
+                return result;
+            }
+            catch (error) {
+                if (error instanceof WorkEnvironmentSyncConflictError) {
+                    const { suggestions } = error;
+                    const suggestionOptions = suggestions === undefined ? {} : { suggestions };
+                    if (this.jsonEnabled()) {
+                        const message = error.gitStatus === undefined || error.gitStatus.length === 0
+                            ? error.message
+                            : `${error.message}\n\n${error.gitStatus}`;
+                        this.error(message, { exit: error.exit, ...suggestionOptions });
+                    }
+                    this.error(error.message, { exit: false, ...suggestionOptions });
+                    if (error.gitStatus !== undefined && error.gitStatus.length > 0) {
+                        this.log('');
+                        this.log(error.gitStatus);
+                    }
+                    this.exit(error.exit);
                 }
-                this.error(error.message, { exit: false, ...suggestionOptions });
-                if (error.gitStatus !== undefined && error.gitStatus.length > 0) {
-                    this.log('');
-                    this.log(error.gitStatus);
+                if (error instanceof WorkEnvironmentSyncValidationError) {
+                    this.error(error.message, {
+                        exit: error.exit,
+                        ...(error.suggestions === undefined ? {} : { suggestions: error.suggestions }),
+                    });
                 }
-                this.exit(error.exit);
-            }
-            if (error instanceof WorkEnvironmentSyncValidationError) {
-                this.error(error.message, {
-                    exit: error.exit,
-                    ...(error.suggestions === undefined ? {} : { suggestions: error.suggestions }),
-                });
+                throw error;
             }
-            throw error;
-        }
+        }, commandStdioCaptureOptions(this));
     }
 }
 //# sourceMappingURL=environment-sync.js.map

package/dist/commands/cicd/work/get.js

@@ -1,9 +1,9 @@
 import { Args, Flags } from '@oclif/core';
 import { AgentiaCommand } from '../../../lib/agentia-command.js';
-import { CicdGateway } from '../../../lib/cicd-gateway.js';
-import { resolveWorkItemId, WorkActiveResolutionError } from '../../../lib/work-active.js';
+import { WorkActiveResolutionError } from '../../../lib/work-active.js';
+import { fetchUserStory } from '../../../lib/work-get.js';
 import { formatUserStoriesAheadBehindLines, reportUserStoriesAheadBehindForStory, } from '../../../lib/work-submit-ahead-behind.js';
-import { formatUserStoryDetail, workEndpoint, } from '../../../lib/work-types.js';
+import { formatUserStoryDetail, } from '../../../lib/work-types.js';
 export default class WorkGet extends AgentiaCommand {
     static args = {
         id: Args.string({
@@ -27,9 +27,9 @@ export default class WorkGet extends AgentiaCommand {
     };
     async run() {
         const { args, flags } = await this.parse(WorkGet);
-        let workItemId;
+        let userStory;
         try {
-            workItemId = await resolveWorkItemId(args.id);
+            userStory = await this.withSpinner('Fetching user story', () => fetchUserStory(args.id));
         }
         catch (error) {
             if (error instanceof WorkActiveResolutionError) {
@@ -40,10 +40,6 @@ export default class WorkGet extends AgentiaCommand {
             }
             throw error;
         }
-        const userStory = await this.withSpinner('Fetching user story', () => CicdGateway.call({
-            endpoint: workEndpoint(workItemId),
-            method: 'GET',
-        }));
         let userStoriesAheadBehind;
         if (flags['user-stories-ahead-behind']) {
             userStoriesAheadBehind = await reportUserStoriesAheadBehindForStory(userStory, {

package/dist/commands/cicd/work/submit.js

@@ -20,7 +20,7 @@ export default class WorkSubmit extends AgentiaCommand {
         'pushes and registers commits when the branch is ahead of origin, then calls headless work/submit',
         '(Promote Action with validate=true).',
         'When the last pending related job template name contains Commit, waits up to 5 minutes for that job before submitting.',
-        'Before submit or promote, counts user stories ahead and behind between the source environment and the next pipeline environment, and warns when stories behind might cause promotion conflicts.',
+        'Before submit or promote, counts user stories ahead and behind between the source environment and the next pipeline environment, and warns when stories behind might cause promotion conflicts (advising `agentia cicd work environment-sync`).',
         'With --done or --deploy, matches Copado UI Submit when promoting (validate=false / headless work/done).',
         'cicd work done is a compatibility alias of this command with --done.',
     ].join(' ');

package/dist/commands/runtime.js

@@ -0,0 +1,26 @@
+import { Command, Flags } from '@oclif/core';
+import { AGENTIA_RUNTIME_DEFAULT_IDLE_MS, serveRuntimeRpc } from '../lib/runtime-rpc.js';
+/** Long-lived stdio NDJSON server so the IDE can reuse one Agentia process. */
+export default class Runtime extends Command {
+    static description = 'Start a stdio NDJSON runtime for in-process Agentia command invokes';
+    static enableJsonFlag = false;
+    static flags = {
+        'idle-ms': Flags.integer({
+            default: AGENTIA_RUNTIME_DEFAULT_IDLE_MS,
+            description: 'Exit after this many idle milliseconds with no in-flight requests',
+            min: 1000,
+        }),
+    };
+    static hidden = true;
+    async run() {
+        const { flags: { 'idle-ms': idleMs } } = await this.parse(Runtime);
+        const { config } = this;
+        await serveRuntimeRpc({
+            cliVersion: config.version,
+            finder: config,
+            idleMs,
+            runCommand: (id, argv) => config.runCommand(id, argv),
+        });
+    }
+}
+//# sourceMappingURL=runtime.js.map

package/dist/hooks/finally/ide-command-event.js

@@ -2,7 +2,7 @@ import { consumeIdeCommandError, publishIdeCommandCompleted } from '../../lib/id
 const hook = async function ({ config, error, id }) {
     try {
         const rememberedError = consumeIdeCommandError();
-        if (id.trim().length === 0) {
+        if (id.trim().length === 0 || id === 'runtime') {
             return;
         }
         await publishIdeCommandCompleted({

package/dist/hooks/init/plugin-host.js

@@ -0,0 +1,6 @@
+import { createPluginHost, registerPluginHost } from '../../lib/plugin-host/index.js';
+const hook = async function () {
+    registerPluginHost(createPluginHost({ cliVersion: this.config.version }));
+};
+export default hook;
+//# sourceMappingURL=plugin-host.js.map

package/dist/lib/agentia-command.js

@@ -3,6 +3,7 @@ import { format } from 'node:util';
 import { createTransactionId, runWithGatewayTransactionContext } from './cicd-gateway.js';
 import { isCommandOutputCaptureActive } from './command-output-buffer.js';
 import { rememberIdeCommandError } from './ide-command-events.js';
+const TRANSACTION_ID_REPORTED = Symbol('agentiaTransactionIdReported');
 export function elapsedSecondsSince(startedAtMs, nowMs = Date.now()) {
     return Math.max(0, Math.floor((nowMs - startedAtMs) / 1000));
 }
@@ -17,6 +18,10 @@ export class AgentiaCommand extends Command {
         this.commandTransactionId = transactionId;
         return runWithGatewayTransactionContext({ origin: 'cli', referer: this.id, transactionId }, () => super._run());
     }
+    async catch(error) {
+        this.reportHumanErrorTransactionId(error);
+        return super.catch(error);
+    }
     display(render) {
         if (!this.jsonEnabled() || isCommandOutputCaptureActive()) {
             render();
@@ -64,5 +69,16 @@ export class AgentiaCommand extends Command {
             throw error;
         }
     }
+    reportHumanErrorTransactionId(error) {
+        if (this.jsonEnabled() || this.commandTransactionId === undefined) {
+            return;
+        }
+        const reportedError = error;
+        if (reportedError[TRANSACTION_ID_REPORTED]) {
+            return;
+        }
+        reportedError[TRANSACTION_ID_REPORTED] = true;
+        this.logToStderr(`Transaction ID: ${this.commandTransactionId}`);
+    }
 }
 //# sourceMappingURL=agentia-command.js.map

package/dist/lib/cursor-mcp-config.js

@@ -3,14 +3,16 @@ const AGENTIA_MCP_ENTRY = modules["cursor-mcp-config.js"]["AGENTIA_MCP_ENTRY"]
 const AGENTIA_MCP_SERVER_NAME = modules["cursor-mcp-config.js"]["AGENTIA_MCP_SERVER_NAME"]
 const detectCursorInstall = modules["cursor-mcp-config.js"]["detectCursorInstall"]
 const findAgentiaMcpServer = modules["cursor-mcp-config.js"]["findAgentiaMcpServer"]
+const findCurrentAgentiaMcpServer = modules["cursor-mcp-config.js"]["findCurrentAgentiaMcpServer"]
 const getCursorMcpStatus = modules["cursor-mcp-config.js"]["getCursorMcpStatus"]
 const globalCursorMcpPath = modules["cursor-mcp-config.js"]["globalCursorMcpPath"]
 const hasConflictingAgentiaEntry = modules["cursor-mcp-config.js"]["hasConflictingAgentiaEntry"]
 const inspectCursorMcpStatus = modules["cursor-mcp-config.js"]["inspectCursorMcpStatus"]
 const isAgentiaMcpEntry = modules["cursor-mcp-config.js"]["isAgentiaMcpEntry"]
+const isCurrentAgentiaMcpEntry = modules["cursor-mcp-config.js"]["isCurrentAgentiaMcpEntry"]
 const localCursorMcpPath = modules["cursor-mcp-config.js"]["localCursorMcpPath"]
 const readCursorMcpDocument = modules["cursor-mcp-config.js"]["readCursorMcpDocument"]
 const resetCursorMcpDepsForTests = modules["cursor-mcp-config.js"]["resetCursorMcpDepsForTests"]
 const setCursorMcpDepsForTests = modules["cursor-mcp-config.js"]["setCursorMcpDepsForTests"]
 const upsertAgentiaCursorMcp = modules["cursor-mcp-config.js"]["upsertAgentiaCursorMcp"]
-export {AGENTIA_MCP_ENTRY, AGENTIA_MCP_SERVER_NAME, detectCursorInstall, findAgentiaMcpServer, getCursorMcpStatus, globalCursorMcpPath, hasConflictingAgentiaEntry, inspectCursorMcpStatus, isAgentiaMcpEntry, localCursorMcpPath, readCursorMcpDocument, resetCursorMcpDepsForTests, setCursorMcpDepsForTests, upsertAgentiaCursorMcp};
+export {AGENTIA_MCP_ENTRY, AGENTIA_MCP_SERVER_NAME, detectCursorInstall, findAgentiaMcpServer, findCurrentAgentiaMcpServer, getCursorMcpStatus, globalCursorMcpPath, hasConflictingAgentiaEntry, inspectCursorMcpStatus, isAgentiaMcpEntry, isCurrentAgentiaMcpEntry, localCursorMcpPath, readCursorMcpDocument, resetCursorMcpDepsForTests, setCursorMcpDepsForTests, upsertAgentiaCursorMcp};

package/dist/lib/data-types.js

@@ -1,5 +1,6 @@
 import {modules} from './runtime.js';
 const DATA_TEMPLATES_BASE = modules["data-types.js"]["DATA_TEMPLATES_BASE"]
+const DEFAULT_DATA_TEMPLATE_QUERY_LIMIT = modules["data-types.js"]["DEFAULT_DATA_TEMPLATE_QUERY_LIMIT"]
 const advancedFilterEndpoint = modules["data-types.js"]["advancedFilterEndpoint"]
 const advancedFiltersEndpoint = modules["data-types.js"]["advancedFiltersEndpoint"]
 const dataTemplateConvertOldEndpoint = modules["data-types.js"]["dataTemplateConvertOldEndpoint"]
@@ -21,10 +22,11 @@ const formatDatasetFileTable = modules["data-types.js"]["formatDatasetFileTable"
 const formatRecordMatchingFormulaTable = modules["data-types.js"]["formatRecordMatchingFormulaTable"]
 const formatSyncResultTable = modules["data-types.js"]["formatSyncResultTable"]
 const formatUserStoryDataCommitTable = modules["data-types.js"]["formatUserStoryDataCommitTable"]
+const normalizeDataTemplateSavePayload = modules["data-types.js"]["normalizeDataTemplateSavePayload"]
 const normalizeDataTemplates = modules["data-types.js"]["normalizeDataTemplates"]
 const recordMatchingFormulaEndpoint = modules["data-types.js"]["recordMatchingFormulaEndpoint"]
 const recordMatchingFormulasByObjectEndpoint = modules["data-types.js"]["recordMatchingFormulasByObjectEndpoint"]
 const sobjectFieldsEndpoint = modules["data-types.js"]["sobjectFieldsEndpoint"]
 const sobjectRelationshipsEndpoint = modules["data-types.js"]["sobjectRelationshipsEndpoint"]
 const userStoryDataCommitsEndpoint = modules["data-types.js"]["userStoryDataCommitsEndpoint"]
-export {DATA_TEMPLATES_BASE, advancedFilterEndpoint, advancedFiltersEndpoint, dataTemplateConvertOldEndpoint, dataTemplateDetailEndpoint, dataTemplateEndpoint, dataTemplateRecordMatchingFormulasEndpoint, dataTemplateUpdatesEndpoint, dataTemplatesCommitEndpoint, dataTemplatesListEndpoint, dataTemplatesRecordsEndpoint, dataTemplatesRecordsMatchEndpoint, dataTemplatesSyncEndpoint, datasetFileContentEndpoint, datasetFilesEndpoint, formatAdvancedFilterTable, formatDataRecordTable, formatDataTemplateTable, formatDatasetFileTable, formatRecordMatchingFormulaTable, formatSyncResultTable, formatUserStoryDataCommitTable, normalizeDataTemplates, recordMatchingFormulaEndpoint, recordMatchingFormulasByObjectEndpoint, sobjectFieldsEndpoint, sobjectRelationshipsEndpoint, userStoryDataCommitsEndpoint};
+export {DATA_TEMPLATES_BASE, DEFAULT_DATA_TEMPLATE_QUERY_LIMIT, advancedFilterEndpoint, advancedFiltersEndpoint, dataTemplateConvertOldEndpoint, dataTemplateDetailEndpoint, dataTemplateEndpoint, dataTemplateRecordMatchingFormulasEndpoint, dataTemplateUpdatesEndpoint, dataTemplatesCommitEndpoint, dataTemplatesListEndpoint, dataTemplatesRecordsEndpoint, dataTemplatesRecordsMatchEndpoint, dataTemplatesSyncEndpoint, datasetFileContentEndpoint, datasetFilesEndpoint, formatAdvancedFilterTable, formatDataRecordTable, formatDataTemplateTable, formatDatasetFileTable, formatRecordMatchingFormulaTable, formatSyncResultTable, formatUserStoryDataCommitTable, normalizeDataTemplateSavePayload, normalizeDataTemplates, recordMatchingFormulaEndpoint, recordMatchingFormulasByObjectEndpoint, sobjectFieldsEndpoint, sobjectRelationshipsEndpoint, userStoryDataCommitsEndpoint};

package/dist/lib/git-worktree.js

@@ -13,6 +13,7 @@ const createAndCheckoutBranch = modules["git-worktree.js"]["createAndCheckoutBra
 const fetchAndCheckoutBranch = modules["git-worktree.js"]["fetchAndCheckoutBranch"]
 const fetchOriginBranch = modules["git-worktree.js"]["fetchOriginBranch"]
 const fetchOriginBranchIfExists = modules["git-worktree.js"]["fetchOriginBranchIfExists"]
+const formatGitExecError = modules["git-worktree.js"]["formatGitExecError"]
 const getCommitsNameStatus = modules["git-worktree.js"]["getCommitsNameStatus"]
 const getCurrentBranch = modules["git-worktree.js"]["getCurrentBranch"]
 const getFileAtRef = modules["git-worktree.js"]["getFileAtRef"]
@@ -48,4 +49,4 @@ const restoreFeatureBranch = modules["git-worktree.js"]["restoreFeatureBranch"]
 const restoreHeadPaths = modules["git-worktree.js"]["restoreHeadPaths"]
 const setGitExecForTests = modules["git-worktree.js"]["setGitExecForTests"]
 const stageAndCommit = modules["git-worktree.js"]["stageAndCommit"]
-export {NAME_STATUS_PRETTY_FORMAT, abortMerge, checkoutBranch, checkoutFeatureBranch, checkoutPreferredBranch, commitAllTrackedChanges, commitAllowEmpty, commitCurrentMerge, commitStagedChanges, countCommitsSince, createAndCheckoutBranch, fetchAndCheckoutBranch, fetchOriginBranch, fetchOriginBranchIfExists, getCommitsNameStatus, getCurrentBranch, getFileAtRef, getGitRepoRoot, getHeadCommitId, getHumanGitStatus, getMergeBase, getRemoteUrl, hasUnpushedCommits, isAncestor, isInsideGitWorkTree, isMergeInProgress, isSafeGitBranchName, listDiffNamesVsHead, listPendingChanges, listStagedChanges, listUnmergedFiles, localBranchExists, mergeFfOnly, mergeNoFf, mergeNoFfNoCommit, mergeTheirsIgnoreSpaceChange, originBranchRef, originFetchRefspec, parseNameOnly, parsePorcelainPaths, pullOriginBranch, pushOriginBranch, pushOriginBranches, resetGitExecForTests, resetHardHead, restoreFeatureBranch, restoreHeadPaths, setGitExecForTests, stageAndCommit};
+export {NAME_STATUS_PRETTY_FORMAT, abortMerge, checkoutBranch, checkoutFeatureBranch, checkoutPreferredBranch, commitAllTrackedChanges, commitAllowEmpty, commitCurrentMerge, commitStagedChanges, countCommitsSince, createAndCheckoutBranch, fetchAndCheckoutBranch, fetchOriginBranch, fetchOriginBranchIfExists, formatGitExecError, getCommitsNameStatus, getCurrentBranch, getFileAtRef, getGitRepoRoot, getHeadCommitId, getHumanGitStatus, getMergeBase, getRemoteUrl, hasUnpushedCommits, isAncestor, isInsideGitWorkTree, isMergeInProgress, isSafeGitBranchName, listDiffNamesVsHead, listPendingChanges, listStagedChanges, listUnmergedFiles, localBranchExists, mergeFfOnly, mergeNoFf, mergeNoFfNoCommit, mergeTheirsIgnoreSpaceChange, originBranchRef, originFetchRefspec, parseNameOnly, parsePorcelainPaths, pullOriginBranch, pushOriginBranch, pushOriginBranches, resetGitExecForTests, resetHardHead, restoreFeatureBranch, restoreHeadPaths, setGitExecForTests, stageAndCommit};

package/dist/lib/mcp/data-tools.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { assertRequired } from '../assert.js';
 import { CicdGateway } from '../cicd-gateway.js';
-import { advancedFilterEndpoint, advancedFiltersEndpoint, DATA_TEMPLATES_BASE, datasetFileContentEndpoint, datasetFilesEndpoint, dataTemplateConvertOldEndpoint, dataTemplateDetailEndpoint, dataTemplateEndpoint, dataTemplateRecordMatchingFormulasEndpoint, dataTemplatesCommitEndpoint, dataTemplatesListEndpoint, dataTemplatesRecordsEndpoint, dataTemplatesRecordsMatchEndpoint, dataTemplatesSyncEndpoint, dataTemplateUpdatesEndpoint, normalizeDataTemplates, recordMatchingFormulaEndpoint, recordMatchingFormulasByObjectEndpoint, sobjectFieldsEndpoint, sobjectRelationshipsEndpoint, userStoryDataCommitsEndpoint, } from '../data-types.js';
+import { advancedFilterEndpoint, advancedFiltersEndpoint, DATA_TEMPLATES_BASE, datasetFileContentEndpoint, datasetFilesEndpoint, dataTemplateConvertOldEndpoint, dataTemplateDetailEndpoint, dataTemplateEndpoint, dataTemplateRecordMatchingFormulasEndpoint, dataTemplatesCommitEndpoint, dataTemplatesListEndpoint, dataTemplatesRecordsEndpoint, dataTemplatesRecordsMatchEndpoint, dataTemplatesSyncEndpoint, dataTemplateUpdatesEndpoint, normalizeDataTemplateSavePayload, normalizeDataTemplates, recordMatchingFormulaEndpoint, recordMatchingFormulasByObjectEndpoint, sobjectFieldsEndpoint, sobjectRelationshipsEndpoint, userStoryDataCommitsEndpoint, } from '../data-types.js';
 import { safelyHandleTool } from './result.js';
 async function dataTemplateList(args = {}) {
     const response = await CicdGateway.call({
@@ -55,7 +55,7 @@ async function dataTemplateSaveDetail(args) {
         throw new Error('Requires `body`.');
     }
     const result = await CicdGateway.call({
-        body: args.body,
+        body: normalizeDataTemplateSavePayload(args.body),
         endpoint: dataTemplateDetailEndpoint(id),
         headers: { 'Content-Type': 'application/json' },
         method: 'PUT',