@moda-ai/cli 1.0.4 → 1.0.5

package/README.md

@@ -1,8 +1,8 @@
 # moda-cli
 
-CLI and MCP server for [Moda](https://modaflows.com) -- AI agent analytics and observability.
+CLI for [Moda](https://modaflows.com) -- AI agent analytics and observability.
 
-Query your conversation analytics from the terminal or connect AI assistants (Claude Code, Cursor, etc.) to your Moda data via the Model Context Protocol.
+Query your conversation analytics from the terminal.
 
 ## Install
 
@@ -18,13 +18,21 @@ npx -p @moda-ai/cli moda overview
 
 ## Setup
 
-Get your API key from [modaflows.com/settings](https://modaflows.com/settings), then:
+Run the wizard to authenticate, pick an org, and provision an API key:
+
+```bash
+moda init
+```
+
+Or set the key manually:
 
 ```bash
 export MODA_API_KEY="moda_sk_..."
 ```
 
-## CLI Usage
+Get your API key from [modaflows.com/settings](https://modaflows.com/settings).
+
+## Usage
 
 ```bash
 moda overview                                    # Dashboard overview
@@ -47,6 +55,15 @@ moda frustrations --days-back=14 --limit=20
 
 moda tool-failures                               # Tool failure overview
 moda tool-failure-detail <tool_name>             # Per-tool failure detail
+
+# Agent runs runtime (workflows = recurring class, run = one execution)
+moda workflows --time-range=7d                   # Recurring workflow catalog with health
+moda runs                                        # Last 7d of workflow executions
+moda runs --time-range=24h --outcome=partial     # Last 24h, partial completions only
+moda runs --class-id=cron:helpscout-triage-hourly # Scoped to one workflow class
+moda run <run_id>                                # One execution + its side-effect receipts
+moda loops                                       # Currently-active loop detections
+moda loop <detection_id>                         # One loop detail (signature + blast radius)
 ```
 
 All commands output JSON. Pipe to `jq` for filtering:
@@ -54,57 +71,11 @@ All commands output JSON. Pipe to `jq` for filtering:
 ```bash
 moda overview | jq '.frustrations'
 moda frustrations | jq '.frustrations[].primary_cause'
+moda runs --outcome=partial | jq '.runs[] | {job_id, intent_summary, outcome_reason}'
+moda loops | jq '.loops | sort_by(-.cycle_visits) | .[0:5] | .[].loop_signature_human'
+moda workflows | jq '.workflows | sort_by(.health) | .[] | select(.health < 0.8)'
 ```
 
-## MCP Server
-
-### Claude Code
-
-```bash
-claude mcp add moda -- npx -y @moda-ai/cli
-```
-
-Or add manually to your MCP config:
-
-```json
-{
-  "mcpServers": {
-    "moda": {
-      "command": "npx",
-      "args": ["-y", "@moda-ai/cli"],
-      "env": {
-        "MODA_API_KEY": "moda_sk_your_key_here"
-      }
-    }
-  }
-}
-```
-
-### Other MCP Clients (Cursor, etc.)
-
-```json
-{
-  "command": "npx",
-  "args": ["-y", "@moda-ai/cli"],
-  "env": {
-    "MODA_API_KEY": "moda_sk_your_key_here"
-  }
-}
-```
-
-### Available MCP Tools
-
-| Tool | Description |
-|------|-------------|
-| `moda_get_overview` | Dashboard overview with KPIs, top clusters, recent activity |
-| `moda_get_clusters` | Browse topic cluster hierarchy |
-| `moda_get_cluster_conversations` | List conversations in a specific cluster |
-| `moda_search_conversations` | Search and filter conversations |
-| `moda_get_conversation_context` | Get windowed conversation context (max 5 messages) |
-| `moda_get_frustrations` | User frustration detections with evidence |
-| `moda_get_tool_failures` | Tool failure overview |
-| `moda_get_tool_failure_detail` | Per-tool failure detail with examples |
-
 ## Environment Variables
 
 | Variable | Required | Default | Description |
@@ -115,7 +86,6 @@ Or add manually to your MCP config:
 ## Documentation
 
 - [CLI Reference](https://docs.modaflows.com/data-api/cli)
-- [MCP Server Setup](https://docs.modaflows.com/data-api/mcp)
 - [Data API Overview](https://docs.modaflows.com/data-api/overview)
 - [Quickstart](https://docs.modaflows.com/quickstart)
 

package/dist/auth.js

@@ -1,24 +1,13 @@
-// src/auth.ts — Browser-based PKCE authentication for moda init
-import { createHash, randomBytes } from 'node:crypto';
+// src/auth.ts — Browser-based authentication for moda init via frontend
 import { createServer } from 'node:http';
 import { readFileSync, writeFileSync, mkdirSync, chmodSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { MODA_BASE_URL } from './config.js';
-const AUTH0_DOMAIN = 'dev-6kukcoznniv30wau.us.auth0.com';
-const AUTH0_CLIENT_ID = 'JuqWjslalOwI9TXLeU2KkF0NTZab3qgC';
-const AUTH0_AUDIENCE = 'https://moda-api';
 const CALLBACK_PORT = 8432;
 const AUTH_TIMEOUT_MS = 120_000;
 const MODA_DIR = join(homedir(), '.moda');
 const TOKEN_PATH = join(MODA_DIR, 'auth.json');
-// --- PKCE ---
-function generateVerifier() {
-    return randomBytes(32).toString('base64url');
-}
-function generateChallenge(verifier) {
-    return createHash('sha256').update(verifier).digest('base64url');
-}
 export function loadToken() {
     try {
         if (!existsSync(TOKEN_PATH))
@@ -56,71 +45,64 @@ const SUCCESS_HTML = `<!DOCTYPE html>
 </div>
 <script>setTimeout(()=>window.close(),2000)</script>
 </body></html>`;
+// Page served at /callback that extracts token from URL fragment and
+// forwards it to /callback-token as query params (fragments never reach the server).
+const FRAGMENT_EXTRACTOR_HTML = `<!DOCTYPE html>
+<html><body>
+<script>
+var h = window.location.hash.substring(1);
+if (h) {
+  window.location.replace('/callback-token?' + h);
+} else {
+  document.body.innerText = 'No token received.';
+}
+</script>
+</body></html>`;
 export async function login(screen = 'login') {
-    const verifier = generateVerifier();
-    const challenge = generateChallenge(verifier);
     return new Promise((resolve, reject) => {
         let settled = false;
         const server = createServer(async (req, res) => {
             if (settled)
                 return;
             const url = new URL(req.url || '/', `http://localhost:${CALLBACK_PORT}`);
-            if (url.pathname !== '/callback') {
+            // Serve fragment extractor at /callback — the frontend redirects here
+            // with token in the URL fragment (#token=...) which never reaches the server.
+            // This page extracts it client-side and forwards to /callback-token as query params.
+            if (url.pathname === '/callback') {
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(FRAGMENT_EXTRACTOR_HTML);
+                return;
+            }
+            if (url.pathname !== '/callback-token') {
                 res.writeHead(404);
                 res.end('Not found');
                 return;
             }
-            const code = url.searchParams.get('code');
+            const token = url.searchParams.get('token');
+            const expiresIn = url.searchParams.get('expires_in');
             const error = url.searchParams.get('error');
-            const errorDescription = url.searchParams.get('error_description');
             if (error) {
                 res.writeHead(400, { 'Content-Type': 'text/html' });
-                res.end(`<html><body><h2>Error</h2><p>${errorDescription || error}</p></body></html>`);
+                res.end(`<html><body><h2>Error</h2><p>${error}</p></body></html>`);
                 settled = true;
                 server.close();
-                reject(new Error(`Auth0 error: ${errorDescription || error}`));
+                reject(new Error(`Authentication error: ${error}`));
                 return;
             }
-            if (!code) {
+            if (!token) {
                 res.writeHead(400, { 'Content-Type': 'text/html' });
-                res.end('<html><body><h2>Error</h2><p>No authorization code received.</p></body></html>');
+                res.end('<html><body><h2>Error</h2><p>No token received.</p></body></html>');
                 settled = true;
                 server.close();
-                reject(new Error('No authorization code received'));
+                reject(new Error('No token received'));
                 return;
             }
-            // Exchange code for tokens
-            try {
-                const tokenResponse = await fetch(`https://${AUTH0_DOMAIN}/oauth/token`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        grant_type: 'authorization_code',
-                        client_id: AUTH0_CLIENT_ID,
-                        code,
-                        redirect_uri: `http://localhost:${CALLBACK_PORT}/callback`,
-                        code_verifier: verifier,
-                    }),
-                });
-                if (!tokenResponse.ok) {
-                    const errBody = await tokenResponse.text();
-                    throw new Error(`Token exchange failed (${tokenResponse.status}): ${errBody}`);
-                }
-                const tokens = (await tokenResponse.json());
-                saveToken(tokens.access_token, tokens.expires_in);
-                res.writeHead(200, { 'Content-Type': 'text/html' });
-                res.end(SUCCESS_HTML);
-                settled = true;
-                server.close();
-                resolve(tokens.access_token);
-            }
-            catch (err) {
-                res.writeHead(500, { 'Content-Type': 'text/html' });
-                res.end('<html><body><h2>Error</h2><p>Token exchange failed.</p></body></html>');
-                settled = true;
-                server.close();
-                reject(err);
-            }
+            saveToken(token, parseInt(expiresIn || '86400', 10));
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(SUCCESS_HTML);
+            settled = true;
+            server.close();
+            resolve(token);
         });
         // Timeout
         const timeout = setTimeout(() => {
@@ -140,23 +122,13 @@ export async function login(screen = 'login') {
             }
         });
         server.listen(CALLBACK_PORT, async () => {
-            const authUrl = new URL(`https://${AUTH0_DOMAIN}/authorize`);
-            authUrl.searchParams.set('response_type', 'code');
-            authUrl.searchParams.set('client_id', AUTH0_CLIENT_ID);
-            authUrl.searchParams.set('redirect_uri', `http://localhost:${CALLBACK_PORT}/callback`);
-            authUrl.searchParams.set('audience', AUTH0_AUDIENCE);
-            authUrl.searchParams.set('scope', 'openid profile email');
-            authUrl.searchParams.set('code_challenge', challenge);
-            authUrl.searchParams.set('code_challenge_method', 'S256');
-            if (screen === 'signup') {
-                authUrl.searchParams.set('screen_hint', 'signup');
-            }
+            const authUrl = `${MODA_BASE_URL}/auth/cli?port=${CALLBACK_PORT}&screen=${screen}`;
             try {
                 const open = (await import('open')).default;
-                await open(authUrl.toString());
+                await open(authUrl);
             }
             catch {
-                console.error(`  Open this URL in your browser:\n  ${authUrl.toString()}`);
+                console.error(`  Open this URL in your browser:\n  ${authUrl}`);
             }
         });
         // Clean up on process exit

package/dist/cli.js

@@ -2,7 +2,7 @@
 import { z } from 'zod';
 import { validateConfig, VERSION } from './config.js';
 import { callDataAPI, ApiError } from './api-client.js';
-import { OverviewSchema, ClustersSchema, ClusterConversationsSchema, ConversationsSchema, ContextSchema, FrustrationsSchema, ToolFailuresSchema, ToolFailureDetailSchema, } from './schemas.js';
+import { OverviewSchema, ClustersSchema, ClusterConversationsSchema, ConversationsSchema, ContextSchema, FrustrationsSchema, ToolFailuresSchema, ToolFailureDetailSchema, WorkflowsSchema, RunsSchema, RunDetailSchema, LoopsSchema, LoopDetailSchema, } from './schemas.js';
 export function parseArgs(argv) {
     const args = argv.slice(2);
     const command = args[0] || '';
@@ -67,6 +67,13 @@ Commands:
   tool-failures                    Get tool failure overview
   tool-failure-detail <tool_name>  Get per-tool failure detail
 
+  Agent runs runtime:
+  workflows                        Recurring workflow catalog (per-class 30d health)
+  runs                             List workflow executions with classified outcomes
+  run <run_id>                     Get single execution + side-effect receipts
+  loops                            Currently-active loop detections
+  loop <detection_id>              Single loop detail
+
 Options:
   --help                           Show this help message
   --version                        Show version number
@@ -77,24 +84,29 @@ Common flags:
   --offset=N                       Number of results to skip
   --time-range=RANGE               Time range filter (all|1h|3d|7d|24h|30d|90d)
 
+Runs flags:
+  --outcome=OUTCOME                Filter by outcome (running|succeeded|partial|failed|loop|abandoned|unknown)
+  --class-id=ID                    Filter to a single workflow class (e.g. cron:helpscout-triage-hourly)
+  --user-id=ID                     Filter to a single user
+
 Init flags:
   --yes                            Accept all defaults (non-interactive)
-  --skip-sdk                       Skip SDK installation
-  --skip-mcp                       Skip MCP server configuration
 
 Examples:
   moda init
-  moda init --yes
-  moda overview
   moda overview --days-back=30
   moda clusters --time-range=7d
   moda conversations --search="error" --limit=5
   moda frustrations --days-back=14 --limit=20
-  moda context <conversation_id> --window=3`);
+  moda context <conversation_id> --window=3
+  moda workflows --time-range=7d
+  moda runs --time-range=24h --outcome=partial
+  moda runs --class-id=cron:helpscout-triage-hourly --limit=20
+  moda run 12345678-1234-1234-1234-1234567890ab
+  moda loops --limit=10
+  moda loop 12345678-1234-1234-1234-1234567890ab`);
 }
 // --- Command Handlers ---
-// Each handler replicates the URL construction from src/handlers.ts
-// but outputs JSON directly instead of wrapping in MCP envelope.
 async function runCommand(command, positional, flags) {
     switch (command) {
         case 'overview': {
@@ -222,6 +234,76 @@ async function runCommand(command, positional, flags) {
             console.log(JSON.stringify(data, null, 2));
             break;
         }
+        // ─── Workflows + Runs ──────────────────────────────────────
+        case 'workflows': {
+            const args = flagsToArgs(flags);
+            const params = WorkflowsSchema.parse(args);
+            const query = new URLSearchParams();
+            if (params.time_range)
+                query.set('time_range', params.time_range);
+            if (params.user_id)
+                query.set('user_id', params.user_id);
+            const queryString = query.toString() ? `?${query.toString()}` : '';
+            const data = await callDataAPI(`/workflows${queryString}`);
+            console.log(JSON.stringify(data, null, 2));
+            break;
+        }
+        case 'runs': {
+            const args = flagsToArgs(flags);
+            const params = RunsSchema.parse(args);
+            const query = new URLSearchParams();
+            if (params.time_range)
+                query.set('time_range', params.time_range);
+            if (params.outcome)
+                query.set('outcome', params.outcome);
+            if (params.class_id)
+                query.set('class_id', params.class_id);
+            if (params.user_id)
+                query.set('user_id', params.user_id);
+            if (params.limit)
+                query.set('limit', params.limit.toString());
+            if (params.offset !== undefined)
+                query.set('offset', params.offset.toString());
+            const queryString = query.toString() ? `?${query.toString()}` : '';
+            const data = await callDataAPI(`/runs${queryString}`);
+            console.log(JSON.stringify(data, null, 2));
+            break;
+        }
+        case 'run': {
+            if (!positional) {
+                console.error('Error: <run_id> is required');
+                console.error('Usage: moda run <run_id>');
+                process.exit(1);
+            }
+            const args = flagsToArgs(flags, 'run_id', positional);
+            const params = RunDetailSchema.parse(args);
+            const data = await callDataAPI(`/runs/${params.run_id}`);
+            console.log(JSON.stringify(data, null, 2));
+            break;
+        }
+        case 'loops': {
+            const args = flagsToArgs(flags);
+            const params = LoopsSchema.parse(args);
+            const query = new URLSearchParams();
+            if (params.limit)
+                query.set('limit', params.limit.toString());
+            const queryString = query.toString() ? `?${query.toString()}` : '';
+            const data = await callDataAPI(`/loops/active${queryString}`);
+            console.log(JSON.stringify(data, null, 2));
+            break;
+        }
+        case 'loop': {
+            if (!positional) {
+                console.error('Error: <detection_id> is required');
+                console.error('Usage: moda loop <detection_id>');
+                process.exit(1);
+            }
+            const args = flagsToArgs(flags, 'detection_id', positional);
+            const params = LoopDetailSchema.parse(args);
+            const data = await callDataAPI(`/loops/${params.detection_id}`);
+            console.log(JSON.stringify(data, null, 2));
+            break;
+        }
         default:
             console.error(`Error: Unknown command '${command}'`);
             console.error('Run "moda --help" for usage information.');
@@ -250,11 +332,10 @@ async function main() {
     await runCommand(command, positional, flags);
 }
 // Only run main() when this file is executed directly (not when imported as a module).
-// In ESM, import.meta.url is the file URL of the current module; process.argv[1] is
-// the path of the entry-point script. Comparing them lets tests import parseArgs /
-// flagsToArgs without triggering the CLI bootstrap.
 import { fileURLToPath } from 'url';
-const isMain = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+import { realpathSync } from 'fs';
+const isMain = process.argv[1] &&
+    fileURLToPath(import.meta.url) === realpathSync(process.argv[1]);
 if (isMain) {
     main().catch((error) => {
         if (error instanceof z.ZodError) {

package/dist/config.d.ts

@@ -1,6 +1,5 @@
-export declare const VERSION = "1.0.0";
+export declare const VERSION = "1.0.4";
 export declare const MODA_API_KEY: string | undefined;
 export declare const MODA_BASE_URL: string;
-export declare const PORT: number;
 export declare function validateConfig(): void;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -1,8 +1,7 @@
 // src/config.ts
-export const VERSION = '1.0.0';
+export const VERSION = '1.0.4';
 export const MODA_API_KEY = process.env.MODA_API_KEY;
 export const MODA_BASE_URL = process.env.MODA_BASE_URL || 'https://modaflows.com';
-export const PORT = parseInt(process.env.PORT || '3003', 10);
 export function validateConfig() {
     if (!MODA_API_KEY) {
         console.error('Error: MODA_API_KEY environment variable is required');

package/dist/init/detect.d.ts

@@ -4,6 +4,6 @@ export interface ProjectInfo {
     llmProviders: string[];
 }
 export declare function detectProject(): Promise<ProjectInfo>;
-export declare function installSDK(project: ProjectInfo): Promise<void>;
+export declare function installSDK(project: ProjectInfo): Promise<boolean>;
 export declare function getInitSnippet(project: ProjectInfo): string;
 //# sourceMappingURL=detect.d.ts.map

package/dist/init/detect.js

@@ -2,7 +2,7 @@
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { execSync } from 'node:child_process';
-import { select } from '@inquirer/prompts';
+import { select, confirm } from '@inquirer/prompts';
 const LOCKFILE_TO_PM = {
     'package-lock.json': 'npm',
     'yarn.lock': 'yarn',
@@ -59,8 +59,21 @@ export async function detectProject() {
                 break;
             }
         }
-        if (!packageManager)
-            packageManager = 'npm';
+        // No lockfile — detect which package manager is actually installed
+        if (!packageManager) {
+            for (const pm of ['bun', 'pnpm', 'yarn', 'npm']) {
+                try {
+                    execSync(`${pm} --version`, { stdio: 'pipe' });
+                    packageManager = pm;
+                    break;
+                }
+                catch {
+                    // not installed
+                }
+            }
+            if (!packageManager)
+                packageManager = 'npm';
+        }
     }
     else if (language === 'python') {
         if (existsSync(join(cwd, 'poetry.lock'))) {
@@ -115,19 +128,29 @@ function detectLLMProviders(cwd, language) {
 }
 export async function installSDK(project) {
     if (!project.packageManager)
-        return;
+        return false;
     const command = INSTALL_COMMANDS[project.packageManager];
     if (!command)
-        return;
+        return false;
+    const shouldInstall = await confirm({
+        message: `Install moda-ai SDK? (${command})`,
+        default: true,
+    });
+    if (!shouldInstall) {
+        console.log(`  Skipped. Run manually: ${command}`);
+        return false;
+    }
     console.log(`  Installing moda-ai (${project.packageManager})...`);
     try {
         execSync(command, { cwd: process.cwd(), stdio: 'pipe' });
         console.log('  Installed moda-ai');
+        return true;
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         console.error(`  Warning: SDK install failed: ${message}`);
         console.error(`  Run manually: ${command}`);
+        return false;
     }
 }
 export function getInitSnippet(project) {

package/dist/init/index.js

@@ -2,25 +2,25 @@
 import { select } from '@inquirer/prompts';
 import { login, loadToken } from '../auth.js';
 import { selectTenantAndCreateKey } from './tenant.js';
-import { detectProject, installSDK, getInitSnippet } from './detect.js';
-import { detectAgents, configureMCP } from './mcp.js';
+import { detectAgents } from './mcp.js';
 import { installRules } from './rules.js';
 export async function runInit(flags) {
     const yes = flags.yes === true || flags.y === true;
-    const skipSdk = flags.skip_sdk === true;
-    const skipMcp = flags.skip_mcp === true;
     console.log('\n  Moda — LLM Observability for Agents\n');
     // Step 1: Authentication
-    console.log('  Step 1/5: Authentication');
+    console.log('  Step 1/3: Authentication');
     let token = loadToken();
     if (!token) {
-        const action = await select({
-            message: 'Get started',
-            choices: [
-                { name: 'Sign up', value: 'signup' },
-                { name: 'Login', value: 'login' },
-            ],
-        });
+        let action = 'login';
+        if (!yes) {
+            action = await select({
+                message: 'Get started',
+                choices: [
+                    { name: 'Sign up', value: 'signup' },
+                    { name: 'Login', value: 'login' },
+                ],
+            });
+        }
         console.log(`  Opening browser to ${action === 'signup' ? 'sign up' : 'log in'}...`);
         token = await login(action);
         console.log('  Authentication successful');
@@ -29,66 +29,24 @@ export async function runInit(flags) {
         console.log('  Already authenticated (cached token)');
     }
     // Step 2: Tenant + API Key
-    console.log('\n  Step 2/5: Select Organization');
-    const { apiKey, tenantName } = await selectTenantAndCreateKey();
-    // Step 3: SDK
-    if (!skipSdk) {
-        console.log('\n  Step 3/5: Install SDK');
-        const project = await detectProject();
-        if (project.language) {
-            const parts = [project.language];
-            if (project.packageManager)
-                parts.push(project.packageManager);
-            if (project.llmProviders.length > 0) {
-                parts.push(project.llmProviders.join(', '));
-            }
-            console.log(`  Detected: ${parts.join(' / ')}`);
-            await installSDK(project);
-            const snippet = getInitSnippet(project);
-            if (snippet) {
-                console.log('\n  Add this to your entry file:');
-                console.log(snippet);
-            }
-        }
-        else {
-            console.log('  No project detected, skipping SDK installation');
-            console.log('  Install manually: npm install moda-ai (or pip install moda-ai)');
-        }
-    }
-    else {
-        console.log('\n  Step 3/5: Install SDK (skipped)');
-    }
-    // Step 4: MCP
-    if (!skipMcp) {
-        console.log('\n  Step 4/5: Configure MCP Server');
-        const agents = detectAgents();
-        if (agents.length > 0) {
-            console.log(`  Detected: ${agents.map((a) => a.name).join(', ')}`);
-            const configured = await configureMCP(agents, apiKey, yes);
-            if (configured.length > 0) {
-                console.log(`  Configured ${configured.length} agent(s): ${configured.join(', ')}`);
-            }
-        }
-        else {
-            console.log('  No coding agents detected');
-            console.log('  Manual setup: claude mcp add moda -- npx -y @moda-ai/cli');
-        }
-    }
-    else {
-        console.log('\n  Step 4/5: Configure MCP Server (skipped)');
-    }
-    // Step 5: Rules
-    console.log('\n  Step 5/5: Agent Rules (optional)');
-    const agentNames = detectAgents().map((a) => a.name);
-    if (agentNames.length > 0) {
-        await installRules(agentNames, yes);
+    console.log('\n  Step 2/3: Select Organization');
+    const { tenantName } = await selectTenantAndCreateKey();
+    // Step 3: Install SDK integration guide for coding agents
+    console.log('\n  Step 3/3: Install SDK Guide');
+    const agents = detectAgents();
+    if (agents.length > 0) {
+        console.log(`  Detected: ${agents.join(', ')}`);
+        await installRules(agents);
     }
     else {
-        console.log('  Skipped (no agents detected)');
+        console.log('  No coding agents detected, skipping');
     }
     // Done
-    console.log(`\n  Setup complete for ${tenantName}!`);
-    console.log('  Dashboard: https://app.modaflows.com');
+    console.log(`\n  Setup complete for ${tenantName}!\n`);
+    console.log('  Now paste this into your coding agent to integrate Moda:\n');
+    console.log('    Integrate the Moda SDK into this project. Follow the Moda SDK');
+    console.log('    integration guide in the project rules.\n');
+    console.log('  Dashboard: https://modaflows.com');
     console.log('');
 }
 //# sourceMappingURL=index.js.map

package/dist/init/mcp.d.ts

@@ -1,8 +1,2 @@
-export interface DetectedAgent {
-    name: string;
-    configPath: string;
-    configKey: string;
-}
-export declare function detectAgents(): DetectedAgent[];
-export declare function configureMCP(agents: DetectedAgent[], apiKey: string, autoYes?: boolean): Promise<string[]>;
+export declare function detectAgents(): string[];
 //# sourceMappingURL=mcp.d.ts.map