@uxmaltech/collab-cli 0.1.1 → 0.1.2

package/dist/commands/init.js

@@ -12,6 +12,7 @@ const config_1 = require("../lib/config");
 const ecosystem_1 = require("../lib/ecosystem");
 const compose_renderer_1 = require("../lib/compose-renderer");
 const errors_1 = require("../lib/errors");
+const infra_type_1 = require("../lib/infra-type");
 const mode_1 = require("../lib/mode");
 const parsers_1 = require("../lib/parsers");
 const orchestrator_1 = require("../lib/orchestrator");
@@ -52,19 +53,32 @@ function inferComposeMode(config) {
     }
     return 'consolidated';
 }
-async function resolveWizardSelection(options, config) {
+async function resolveWizardSelection(options, config, logger) {
     const defaults = {
         mode: (0, mode_1.parseMode)(options.mode, config.mode),
         composeMode: parseComposeMode(options.composeMode, inferComposeMode(config)),
+        infraType: (0, infra_type_1.parseInfraType)(options.infraType, config.infraType),
     };
     if (options.yes) {
         if (!options.mode) {
             process.stderr.write('Info: Non-interactive mode defaults to file-only. Use --mode indexed for graph/vector features.\n');
         }
+        const mode = options.mode ? (0, mode_1.parseMode)(options.mode) : 'file-only';
+        const infraType = mode === 'indexed'
+            ? (0, infra_type_1.parseInfraType)(options.infraType, 'local')
+            : 'local';
+        let mcpUrl;
+        if (infraType === 'remote') {
+            if (!options.mcpUrl) {
+                throw new errors_1.CliError('--mcp-url is required with --infra-type remote in non-interactive mode.');
+            }
+            mcpUrl = (0, infra_type_1.validateMcpUrl)(options.mcpUrl);
+        }
         return {
-            ...defaults,
-            mode: options.mode ? (0, mode_1.parseMode)(options.mode) : 'file-only',
+            mode,
             composeMode: options.composeMode ? parseComposeMode(options.composeMode) : 'consolidated',
+            infraType,
+            mcpUrl,
         };
     }
     const mode = options.mode
@@ -73,9 +87,26 @@ async function resolveWizardSelection(options, config) {
             { value: 'file-only', label: 'file-only (skip infra + MCP startup)' },
             { value: 'indexed', label: 'indexed (start infra + MCP and enable retrieval)' },
         ], defaults.mode);
-    // Skip compose-mode prompt when mode is file-only — no Docker/MCP
-    // infrastructure is used, so compose configuration is irrelevant.
-    const composeMode = mode === 'file-only'
+    // ── Indexed-only: infrastructure type selection ─────────────
+    let infraType = 'local';
+    let mcpUrl;
+    if (mode === 'indexed') {
+        logger.phaseHeader('collab init', 'Infrastructure');
+        infraType = options.infraType
+            ? (0, infra_type_1.parseInfraType)(options.infraType)
+            : await (0, prompt_1.promptChoice)('Infrastructure type:', [
+                { value: 'local', label: 'local (Docker Compose)' },
+                { value: 'remote', label: 'remote (connect to existing MCP server)' },
+            ], defaults.infraType);
+        if (infraType === 'remote') {
+            const rawUrl = options.mcpUrl
+                ?? await (0, prompt_1.promptText)('MCP server base URL:', 'http://127.0.0.1:7337');
+            mcpUrl = (0, infra_type_1.validateMcpUrl)(rawUrl);
+        }
+    }
+    // Skip compose-mode prompt when mode is file-only or infra is remote —
+    // Docker Compose configuration is only relevant for local infrastructure.
+    const composeMode = mode === 'file-only' || infraType === 'remote'
         ? parseComposeMode(options.composeMode, 'consolidated')
         : options.composeMode
             ? parseComposeMode(options.composeMode)
@@ -86,11 +117,15 @@ async function resolveWizardSelection(options, config) {
     return {
         mode,
         composeMode,
+        infraType,
+        mcpUrl,
     };
 }
 function renderMcpSnippet(provider, config) {
     const workspace = config.workspaceDir;
-    const mcpUrl = 'http://127.0.0.1:7337/mcp';
+    const mcpUrl = config.mcpUrl
+        ? `${config.mcpUrl}/mcp`
+        : 'http://127.0.0.1:7337/mcp';
     switch (provider) {
         case 'codex':
             return {
@@ -422,6 +457,70 @@ function buildInfraStages(effectiveConfig, executor, logger, options, composeMod
     ];
 }
 // ────────────────────────────────────────────────────────────────
+// Remote infra stages (no Docker — connect to existing MCP)
+// ────────────────────────────────────────────────────────────────
+function buildRemoteInfraStages(effectiveConfig, executor, logger, options, mcpUrl) {
+    const health = (0, service_health_1.dryRunHealthOptions)(executor, {
+        timeoutMs: (0, parsers_1.parseNumber)(options.timeoutMs, 5_000),
+        retries: (0, parsers_1.parseNumber)(options.retries, 15),
+        retryDelayMs: (0, parsers_1.parseNumber)(options.retryDelayMs, 2_000),
+    });
+    return [
+        {
+            id: 'mcp-health-check',
+            title: 'Verify remote MCP service health',
+            recovery: [
+                'Check that the remote MCP server is running and accessible.',
+                'Verify the --mcp-url value points to a healthy MCP endpoint.',
+                'Run collab init --resume after fixing remote connectivity.',
+            ],
+            run: async () => {
+                const parsed = new URL(mcpUrl);
+                const env = {
+                    MCP_HOST: parsed.hostname,
+                    MCP_PORT: parsed.port || (parsed.protocol === 'https:' ? '443' : '80'),
+                };
+                const probe = await (0, service_health_1.waitForMcpHealth)(env, health);
+                if (!probe.ok) {
+                    throw new errors_1.CliError(`Remote MCP is not healthy at ${mcpUrl}: ${probe.errors.join(', ')}`);
+                }
+                (0, service_health_1.logServiceHealth)(logger, 'remote MCP health', probe);
+            },
+        },
+        {
+            id: 'mcp-client-config',
+            title: 'Generate MCP client config snippets',
+            recovery: [
+                'Verify permissions in .collab directory.',
+                'Run collab init --resume to regenerate MCP config snippets.',
+            ],
+            run: () => {
+                if (options.skipMcpSnippets) {
+                    logger.info('Skipping MCP snippet generation by user choice.');
+                    return;
+                }
+                const enabled = (0, providers_1.getEnabledProviders)(effectiveConfig);
+                if (enabled.length === 0) {
+                    logger.info('No providers configured; skipping MCP snippet generation.');
+                    return;
+                }
+                for (const provider of enabled) {
+                    const snippet = renderMcpSnippet(provider, effectiveConfig);
+                    if (!snippet)
+                        continue;
+                    const target = node_path_1.default.join(effectiveConfig.collabDir, snippet.filename);
+                    executor.writeFile(target, snippet.content, {
+                        description: `write ${providers_1.PROVIDER_DEFAULTS[provider].label} MCP config snippet`,
+                    });
+                }
+                logger.info(`Generated MCP snippets for: ${enabled.map((k) => providers_1.PROVIDER_DEFAULTS[k].label).join(', ')}`);
+            },
+        },
+        graph_seed_1.graphSeedStage,
+        canon_ingest_1.canonIngestStage,
+    ];
+}
+// ────────────────────────────────────────────────────────────────
 // File-only pipeline (8 stages)
 // ────────────────────────────────────────────────────────────────
 function buildFileOnlyPipeline(effectiveConfig, executor, logger, configExistedBefore, options) {
@@ -440,20 +539,23 @@ function buildFileOnlyPipeline(effectiveConfig, executor, logger, configExistedB
 // ────────────────────────────────────────────────────────────────
 // Indexed pipeline (15 stages)
 // ────────────────────────────────────────────────────────────────
-function buildIndexedPipeline(effectiveConfig, executor, logger, configExistedBefore, options, composeMode) {
+function buildIndexedPipeline(effectiveConfig, executor, logger, configExistedBefore, options, composeMode, infraType = 'local', mcpUrl) {
+    const infraStages = infraType === 'remote' && mcpUrl
+        ? buildRemoteInfraStages(effectiveConfig, executor, logger, options, mcpUrl)
+        : buildInfraStages(effectiveConfig, executor, logger, options, composeMode);
     return [
         // Phase A — Local setup (shared with file-only)
-        buildPreflightStage(executor, logger, 'indexed'), // 1
-        buildConfigStage(effectiveConfig, executor, logger, configExistedBefore, options.force), // 2
-        buildGitHubAuthStage(effectiveConfig, logger, options), // 3
-        assistant_setup_1.assistantSetupStage, // 4
-        canon_sync_1.canonSyncStage, // 5
-        repo_scaffold_1.repoScaffoldStage, // 6
-        repo_analysis_1.repoAnalysisStage, // 7
-        ci_setup_1.ciSetupStage, // 8
-        agent_skills_setup_1.agentSkillsSetupStage, // 9
-        // Phase B — Infrastructure + Phase C — Ingestion  (9-14)
-        ...buildInfraStages(effectiveConfig, executor, logger, options, composeMode),
+        buildPreflightStage(executor, logger, infraType === 'local' ? 'indexed' : undefined),
+        buildConfigStage(effectiveConfig, executor, logger, configExistedBefore, options.force),
+        buildGitHubAuthStage(effectiveConfig, logger, options),
+        assistant_setup_1.assistantSetupStage,
+        canon_sync_1.canonSyncStage,
+        repo_scaffold_1.repoScaffoldStage,
+        repo_analysis_1.repoAnalysisStage,
+        ci_setup_1.ciSetupStage,
+        agent_skills_setup_1.agentSkillsSetupStage,
+        // Phase B — Infrastructure + Phase C — Ingestion
+        ...infraStages,
     ];
 }
 // ────────────────────────────────────────────────────────────────
@@ -473,26 +575,45 @@ async function runInfraOnly(context, options) {
         context.executor.ensureDirectory(effectiveConfig.collabDir);
         context.executor.writeFile(effectiveConfig.configFile, `${(0, config_1.serializeUserConfig)(effectiveConfig)}\n`, { description: 'write collab config (infra bootstrap)' });
     }
+    const infraType = (0, infra_type_1.parseInfraType)(options.infraType, effectiveConfig.infraType);
+    let mcpUrl;
+    if (infraType === 'remote') {
+        if (!options.mcpUrl && !effectiveConfig.mcpUrl) {
+            throw new errors_1.CliError('--mcp-url is required for remote infrastructure.');
+        }
+        mcpUrl = options.mcpUrl ? (0, infra_type_1.validateMcpUrl)(options.mcpUrl) : effectiveConfig.mcpUrl;
+        effectiveConfig.infraType = infraType;
+        effectiveConfig.mcpUrl = mcpUrl;
+    }
     const composeMode = parseComposeMode(options.composeMode, inferComposeMode(effectiveConfig));
-    context.logger.phaseHeader('Infrastructure', 'Docker + MCP services');
-    const infraStages = buildInfraStages(effectiveConfig, context.executor, context.logger, options, composeMode);
+    const infraLabel = infraType === 'remote' ? 'Remote MCP services' : 'Docker + MCP services';
+    context.logger.phaseHeader('Infrastructure', infraLabel);
+    const infraStages = infraType === 'remote' && mcpUrl
+        ? buildRemoteInfraStages(effectiveConfig, context.executor, context.logger, options, mcpUrl)
+        : buildInfraStages(effectiveConfig, context.executor, context.logger, options, composeMode);
     await (0, orchestrator_1.runOrchestration)({
         workflowId: 'init:infra',
         config: effectiveConfig,
         executor: context.executor,
         logger: context.logger,
         resume: options.resume,
-        mode: 'indexed (infra)',
+        mode: `indexed (infra ${infraType})`,
         stageOptions: { outputDir: options.outputDir },
     }, infraStages);
     // Summary
     context.logger.phaseHeader('Infrastructure Ready');
-    context.logger.summaryFooter([
-        { label: 'Phase', value: 'infra only' },
-        { label: 'Compose mode', value: composeMode },
+    const summaryEntries = [
+        { label: 'Phase', value: `infra ${infraType}` },
         { label: 'Dry-run', value: context.executor.dryRun ? 'yes' : 'no' },
         { label: 'Config', value: effectiveConfig.configFile },
-    ]);
+    ];
+    if (infraType === 'remote' && mcpUrl) {
+        summaryEntries.splice(1, 0, { label: 'MCP URL', value: mcpUrl });
+    }
+    else {
+        summaryEntries.splice(1, 0, { label: 'Compose mode', value: composeMode });
+    }
+    context.logger.summaryFooter(summaryEntries);
 }
 // ────────────────────────────────────────────────────────────────
 // Repo domain generation  (collab init --repo=<package>)
@@ -626,6 +747,8 @@ function registerInitCommand(program) {
         .option('--resume', 'Resume from the last incomplete wizard stage')
         .option('--mode <mode>', 'Wizard mode: file-only|indexed')
         .option('--compose-mode <mode>', 'Compose mode: consolidated|split')
+        .option('--infra-type <type>', 'Infrastructure type: local|remote (indexed mode only)')
+        .option('--mcp-url <url>', 'MCP server base URL for remote infrastructure')
         .option('--output-dir <directory>', 'Directory used to write compose outputs')
         .option('--repos <list>', 'Comma-separated repo directories for workspace mode')
         .option('--repo <package>', 'Generate domain definition from package analysis')
@@ -647,6 +770,7 @@ Examples:
   collab init --repos api,web,shared --yes
   collab init --repo collab-chat-ai-pkg --mode file-only
   collab init --repo collab-chat-ai-pkg --mode indexed
+  collab init --yes --mode indexed --infra-type remote --mcp-url http://my-server:7337 --business-canon none
   collab init --resume
   collab init infra
   collab init infra --resume
@@ -684,12 +808,14 @@ Examples:
         }
         // ── Step 1: Configuration wizard ────────────────────────
         context.logger.phaseHeader('collab init', 'Configuration');
-        const selections = await resolveWizardSelection(options, context.config);
+        const selections = await resolveWizardSelection(options, context.config, context.logger);
         const preserveExisting = configExistedBefore && !options.force;
         const effectiveConfig = {
             ...(0, config_1.defaultCollabConfig)(context.config.workspaceDir),
             ...context.config,
             mode: preserveExisting ? context.config.mode : selections.mode,
+            infraType: preserveExisting ? context.config.infraType : selections.infraType,
+            mcpUrl: preserveExisting ? context.config.mcpUrl : selections.mcpUrl,
         };
         // ── Step 2: Business canon configuration ──────────────────
         const canons = await resolveBusinessCanon(options, context.logger);
@@ -745,8 +871,13 @@ Examples:
             }
             // Phase I — infra stages (indexed only)
             if (selections.mode === 'indexed') {
-                context.logger.phaseHeader('Infrastructure', 'Docker + MCP services');
-                const infraStages = buildInfraStages(effectiveConfig, context.executor, context.logger, options, selections.composeMode);
+                const infraLabel = selections.infraType === 'remote'
+                    ? 'Remote MCP services'
+                    : 'Docker + MCP services';
+                context.logger.phaseHeader('Infrastructure', infraLabel);
+                const infraStages = selections.infraType === 'remote' && selections.mcpUrl
+                    ? buildRemoteInfraStages(effectiveConfig, context.executor, context.logger, options, selections.mcpUrl)
+                    : buildInfraStages(effectiveConfig, context.executor, context.logger, options, selections.composeMode);
                 await (0, orchestrator_1.runOrchestration)({
                     workflowId: 'init:infra',
                     config: effectiveConfig,
@@ -763,7 +894,7 @@ Examples:
             context.logger.phaseHeader('Project Setup', selections.mode);
             const stages = selections.mode === 'file-only'
                 ? buildFileOnlyPipeline(effectiveConfig, context.executor, context.logger, configExistedBefore, options)
-                : buildIndexedPipeline(effectiveConfig, context.executor, context.logger, configExistedBefore, options, selections.composeMode);
+                : buildIndexedPipeline(effectiveConfig, context.executor, context.logger, configExistedBefore, options, selections.composeMode, selections.infraType, selections.mcpUrl);
             await (0, orchestrator_1.runOrchestration)({
                 workflowId: 'init',
                 config: effectiveConfig,
@@ -790,7 +921,13 @@ Examples:
             summaryEntries.splice(1, 0, { label: 'Workspace', value: `${ws.name} (${ws.type})` }, { label: 'Repos', value: ws.repos.join(', ') });
         }
         if (selections.mode === 'indexed') {
-            summaryEntries.splice(ws ? 3 : 1, 0, { label: 'Compose mode', value: selections.composeMode });
+            summaryEntries.push({ label: 'Infrastructure', value: selections.infraType });
+            if (selections.infraType === 'remote' && selections.mcpUrl) {
+                summaryEntries.push({ label: 'MCP URL', value: selections.mcpUrl });
+            }
+            else {
+                summaryEntries.push({ label: 'Compose mode', value: selections.composeMode });
+            }
         }
         context.logger.summaryFooter(summaryEntries);
         // Ecosystem compatibility checks

package/dist/lib/config.js

@@ -15,6 +15,7 @@ exports.deriveWorkspaceName = deriveWorkspaceName;
 exports.detectWorkspaceLayout = detectWorkspaceLayout;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+const infra_type_1 = require("./infra-type");
 const mode_1 = require("./mode");
 const DEFAULT_COMPOSE_PATHS = {
     consolidatedFile: 'docker-compose.yml',
@@ -32,6 +33,7 @@ function defaultCollabConfig(cwd = process.cwd()) {
         stateFile: node_path_1.default.join(collabDir, 'state.json'),
         envFile: node_path_1.default.join(workspaceDir, '.env'),
         mode: mode_1.DEFAULT_MODE,
+        infraType: infra_type_1.DEFAULT_INFRA_TYPE,
         compose: { ...DEFAULT_COMPOSE_PATHS },
         architectureDir,
         uxmaltechDir: node_path_1.default.join(architectureDir, 'uxmaltech'),
@@ -54,9 +56,12 @@ function loadCollabConfig(cwd = process.cwd()) {
         ? node_path_1.default.resolve(defaults.workspaceDir, raw.architectureDir)
         : defaults.architectureDir;
     const workspace = migrateWorkspaceConfig(raw.workspace, defaults.workspaceDir);
+    const infraType = (0, infra_type_1.parseInfraType)(raw.infraType, defaults.infraType);
     return {
         ...defaults,
         mode: (0, mode_1.parseMode)(raw.mode, defaults.mode),
+        infraType,
+        mcpUrl: infraType === 'remote' && raw.mcpUrl ? raw.mcpUrl : undefined,
         envFile: raw.envFile ? node_path_1.default.resolve(defaults.workspaceDir, raw.envFile) : defaults.envFile,
         compose: {
             consolidatedFile: raw.compose?.consolidatedFile ?? defaults.compose.consolidatedFile,
@@ -82,6 +87,13 @@ function serializeUserConfig(config) {
         compose: config.compose,
         envFile: node_path_1.default.relative(config.workspaceDir, config.envFile),
     };
+    // Only persist infraType when it differs from the default (local).
+    if (config.infraType && config.infraType !== 'local') {
+        data.infraType = config.infraType;
+    }
+    if (config.mcpUrl) {
+        data.mcpUrl = config.mcpUrl;
+    }
     if (config.assistants) {
         data.assistants = config.assistants;
     }

package/dist/lib/infra-type.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_INFRA_TYPE = exports.INFRA_TYPES = void 0;
+exports.isInfraType = isInfraType;
+exports.parseInfraType = parseInfraType;
+exports.validateMcpUrl = validateMcpUrl;
+const errors_1 = require("./errors");
+/** Supported infrastructure types for indexed mode. */
+exports.INFRA_TYPES = ['local', 'remote'];
+const INFRA_SET = new Set(exports.INFRA_TYPES);
+/** Default infra type used when none is explicitly configured. */
+exports.DEFAULT_INFRA_TYPE = 'local';
+/** Type guard that checks whether a string is a valid {@link InfraType}. */
+function isInfraType(value) {
+    return INFRA_SET.has(value);
+}
+/**
+ * Parses an infra-type string from CLI flags or config, returning the fallback
+ * when undefined. Throws on invalid values.
+ */
+function parseInfraType(value, fallback = exports.DEFAULT_INFRA_TYPE) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (isInfraType(value)) {
+        return value;
+    }
+    throw new errors_1.CliError(`Invalid infra type '${value}'. Valid values: ${exports.INFRA_TYPES.join(', ')}`);
+}
+/**
+ * Validates and normalises an MCP base URL.
+ *
+ * - Must start with `http://` or `https://`.
+ * - Must be parseable by the URL constructor.
+ * - Trailing slashes are stripped from the origin.
+ *
+ * @returns The normalised base URL (e.g. `http://my-server:7337`).
+ */
+function validateMcpUrl(url) {
+    const trimmed = url.trim();
+    if (!trimmed) {
+        throw new errors_1.CliError('MCP URL cannot be empty.');
+    }
+    if (!/^https?:\/\//i.test(trimmed)) {
+        throw new errors_1.CliError(`MCP URL must start with http:// or https://. Got: ${trimmed}`);
+    }
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        throw new errors_1.CliError(`Invalid MCP URL: ${trimmed}`);
+    }
+    // Return origin (scheme + host + port) without trailing path/slash
+    return parsed.origin;
+}

package/dist/lib/mcp-client.js

@@ -48,6 +48,11 @@ function resolveMcpApiKey(env) {
     return firstFromList || undefined;
 }
 function getMcpBaseUrl(config) {
+    // Remote infra: use the explicitly configured URL.
+    if (config.mcpUrl) {
+        return config.mcpUrl;
+    }
+    // Local infra: derive from .env or defaults.
     const env = (0, service_health_1.loadRuntimeEnv)(config);
     const host = env.MCP_HOST || '127.0.0.1';
     const port = env.MCP_PORT || '7337';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxmaltech/collab-cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "CLI for collaborative architecture and delivery workflows.",
   "private": false,
   "license": "UNLICENSED",