@specship/specship-win32-arm64 0.13.0 → 0.14.0

package/lib/dist/bin/specship.js

@@ -2699,11 +2699,21 @@ function main() {
         const { discoverWorkflows, loadWorkflowByName } = await Promise.resolve().then(() => __importStar(require('../workflows/discovery')));
         const { WorkflowExecutor } = await Promise.resolve().then(() => __importStar(require('../workflows/executor')));
         const { WorktreeProvider } = await Promise.resolve().then(() => __importStar(require('../isolation/worktree')));
+        const { handleJiraRunCompletion } = await Promise.resolve().then(() => __importStar(require('../mcp/jira-tools')));
         const cg = await SpecShip.open(projectRoot);
         try {
             const specQueries = cg.getSpecQueries();
             const worktrees = new WorktreeProvider(specQueries);
-            const executor = new WorkflowExecutor(specQueries, worktrees, projectRoot);
+            // On completion, a JIRA-started run raises its PR (REQ-JIRA-006); the hook
+            // is a silent no-op for any run without `metadata.jira`.
+            const executor = new WorkflowExecutor(specQueries, worktrees, projectRoot, async (run) => {
+                await handleJiraRunCompletion(run, {
+                    getIsolationEnvById: (id) => specQueries.getIsolationEnvById(id),
+                    projectRoot,
+                    // eslint-disable-next-line no-console
+                    log: (m) => console.log(m),
+                });
+            });
             switch (action) {
                 case 'list': {
                     const result = discoverWorkflows(projectRoot);
@@ -2928,6 +2938,175 @@ function main() {
         if (result.exitCode !== 0)
             process.exit(result.exitCode);
     });
+    /**
+     * specship jira — connect SpecShip to a JIRA instance (REQ-JIRA-001).
+     *
+     * Two subcommands:
+     *   - `configure` — collect base URL + credentials, infer the deployment,
+     *     save to `~/.specship/jira.json` (0600, user-level only), then probe.
+     *   - `test` — resolve the stored/env credentials and probe `/myself`.
+     *
+     * SECURITY: the token/PAT is NEVER echoed — not in a confirmation, not in
+     * `test` output, not in an error message. On success we print only
+     * "connected as <displayName>". Errors from the jira module are already
+     * scrubbed of secrets (REQ-JIRA-009 builds on this).
+     */
+    const jira = program
+        .command('jira')
+        .description('Connect SpecShip to a JIRA instance (Cloud or Data Center).');
+    jira
+        .command('configure')
+        .description('Save JIRA credentials to ~/.specship/jira.json (0600) and test the connection.')
+        .option('--base-url <url>', 'JIRA base URL, e.g. https://acme.atlassian.net')
+        .option('--email <email>', 'Cloud: account email (paired with --api-token)')
+        .option('--api-token <token>', 'Cloud: API token (paired with --email)')
+        .option('--pat <token>', 'Data Center: personal access token')
+        .option('--deployment <kind>', 'Deployment kind: "cloud" or "datacenter" (inferred if omitted)')
+        .action(async (opts) => {
+        const { saveJiraConfig, resolveJiraCredentials, inferDeployment, jiraConfigPath, JiraClient, JiraAuthError, } = await Promise.resolve().then(() => __importStar(require('../jira')));
+        const clack = await importESM('@clack/prompts');
+        const cancelled = (v) => clack.isCancel(v);
+        // Fully-flagged (non-interactive) path: base URL + a complete credential set.
+        const flagged = Boolean(opts.baseUrl && (opts.pat || (opts.email && opts.apiToken)));
+        clack.intro('Configure JIRA');
+        try {
+            let config;
+            if (flagged) {
+                const deployment = inferDeployment({
+                    deployment: opts.deployment,
+                    email: opts.email,
+                    apiToken: opts.apiToken,
+                    pat: opts.pat,
+                });
+                config = {
+                    baseUrl: opts.baseUrl.trim(),
+                    deployment,
+                    email: opts.email,
+                    apiToken: opts.apiToken,
+                    pat: opts.pat,
+                };
+            }
+            else {
+                const baseUrl = opts.baseUrl ?? (await clack.text({
+                    message: 'JIRA base URL',
+                    placeholder: 'https://acme.atlassian.net',
+                    validate: (v) => (v && v.trim() ? undefined : 'Required'),
+                }));
+                if (cancelled(baseUrl)) {
+                    clack.cancel('Cancelled — nothing saved.');
+                    return;
+                }
+                const deployment = (opts.deployment ?? (await clack.select({
+                    message: 'Deployment',
+                    options: [
+                        { value: 'cloud', label: 'Cloud (email + API token)' },
+                        { value: 'datacenter', label: 'Data Center / Server (personal access token)' },
+                    ],
+                })));
+                if (cancelled(deployment)) {
+                    clack.cancel('Cancelled — nothing saved.');
+                    return;
+                }
+                config = { baseUrl: String(baseUrl).trim(), deployment };
+                if (deployment === 'cloud') {
+                    const email = opts.email ?? (await clack.text({
+                        message: 'Account email',
+                        validate: (v) => (v && v.trim() ? undefined : 'Required'),
+                    }));
+                    if (cancelled(email)) {
+                        clack.cancel('Cancelled — nothing saved.');
+                        return;
+                    }
+                    const apiToken = opts.apiToken ?? (await clack.password({
+                        message: 'API token (input hidden, never printed)',
+                        validate: (v) => (v ? undefined : 'Required'),
+                    }));
+                    if (cancelled(apiToken)) {
+                        clack.cancel('Cancelled — nothing saved.');
+                        return;
+                    }
+                    config.email = String(email).trim();
+                    config.apiToken = String(apiToken);
+                }
+                else {
+                    const pat = opts.pat ?? (await clack.password({
+                        message: 'Personal access token (input hidden, never printed)',
+                        validate: (v) => (v ? undefined : 'Required'),
+                    }));
+                    if (cancelled(pat)) {
+                        clack.cancel('Cancelled — nothing saved.');
+                        return;
+                    }
+                    config.pat = String(pat);
+                }
+            }
+            saveJiraConfig(config);
+            // NOTE: never print the credential — only the path.
+            clack.log.success(`Saved credentials to ${jiraConfigPath()} (permissions 0600).`);
+            // Probe the connection so the user knows immediately whether it works.
+            const client = new JiraClient(resolveJiraCredentials());
+            const result = await client.testConnection();
+            clack.outro(`Connected as ${result.displayName ?? 'unknown user'}.`);
+        }
+        catch (err) {
+            // Messages from the jira module are already scrubbed of the secret.
+            const msg = err instanceof Error ? err.message : String(err);
+            const label = err instanceof JiraAuthError ? 'Authentication failed' : 'Connection failed';
+            clack.log.error(`${label}: ${msg}`);
+            process.exit(1);
+        }
+    });
+    jira
+        .command('test')
+        .description('Test the configured JIRA connection (uses ~/.specship/jira.json or SPECSHIP_JIRA_* env).')
+        .action(async () => {
+        const { resolveJiraCredentials, JiraClient, JiraAuthError } = await Promise.resolve().then(() => __importStar(require('../jira')));
+        try {
+            const creds = resolveJiraCredentials();
+            const client = new JiraClient(creds);
+            const result = await client.testConnection();
+            const kind = creds.deployment === 'cloud' ? 'JIRA Cloud' : 'JIRA Data Center';
+            // Never print the credential — only the resolved identity.
+            success(`Connected to ${kind} as ${result.displayName ?? 'unknown user'}.`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const label = err instanceof JiraAuthError ? 'Authentication failed' : 'Connection failed';
+            error(`${label}: ${msg}`);
+            process.exit(1);
+        }
+    });
+    /**
+     * specship jira track — read-only tracking view (REQ-JIRA-008). Joins each
+     * picked issue's SpecShip work-state (from its workflow run) with its LIVE JIRA
+     * status (a fresh read at track time). Never re-picks or re-starts anything.
+     */
+    jira
+        .command('track')
+        .description('Show each picked JIRA issue with its SpecShip work-state + live JIRA status.')
+        .option('--project <key>', 'narrow the live JIRA read to a project (e.g., "PROJ")')
+        .option('--path <projectRoot>', 'project root (default: cwd)')
+        .action(async (options) => {
+        const projectRoot = path.resolve(options.path ?? process.cwd());
+        if (!(0, directory_1.isInitialized)(projectRoot)) {
+            error(`SpecShip not initialized in ${projectRoot}. Run \`specship init -i\` first.`);
+            process.exit(1);
+        }
+        const { SpecShip } = await loadSpecShip();
+        const { handleSpecshipJiraTrack } = await Promise.resolve().then(() => __importStar(require('../mcp/jira-tools')));
+        const cg = await SpecShip.open(projectRoot);
+        try {
+            const result = await handleSpecshipJiraTrack({ project: options.project }, { specQueries: cg.getSpecQueries() });
+            const out = result.content.map((c) => c.text).join('\n');
+            // eslint-disable-next-line no-console
+            console.log(out);
+            if (result.isError)
+                process.exit(1);
+        }
+        finally {
+            cg.close();
+        }
+    });
     // Parse and run
     program.parse();
 } // end main()