@infinitedusky/indusk-mcp 1.4.0 → 1.4.2

package/dist/bin/commands/extensions.js

@@ -95,6 +95,7 @@ export async function extensionsEnable(projectRoot, names) {
             console.info(`  ${name}: enabled (built-in)`);
             runHook(projectRoot, name, "on_init");
             installSkill(projectRoot, name);
+            installMcpServer(projectRoot, name);
             continue;
         }
         console.info(`  ${name}: not found — use 'extensions add ${name} --from <source>' for third-party`);
@@ -465,6 +466,54 @@ function runHook(projectRoot, name, hook) {
         console.info(`  ${name}: ${hook} hook failed`);
     }
 }
+function installMcpServer(projectRoot, name) {
+    const extPath = join(extensionsDir(projectRoot), `${name}.json`);
+    const manifest = loadExtension(extPath);
+    if (!manifest?.mcp_server)
+        return;
+    const mcpJsonPath = join(projectRoot, ".mcp.json");
+    let mcpConfig = {};
+    if (existsSync(mcpJsonPath)) {
+        try {
+            mcpConfig = JSON.parse(readFileSync(mcpJsonPath, "utf-8"));
+        }
+        catch {
+            mcpConfig = {};
+        }
+    }
+    if (!mcpConfig.mcpServers)
+        mcpConfig.mcpServers = {};
+    if (mcpConfig.mcpServers[name]) {
+        console.info(`  ${name}: .mcp.json entry already exists`);
+    }
+    else {
+        const serverConfig = {};
+        const srv = manifest.mcp_server;
+        if (srv.type)
+            serverConfig.type = srv.type;
+        if (srv.url)
+            serverConfig.url = srv.url;
+        if (srv.command)
+            serverConfig.command = srv.command;
+        if (srv.args)
+            serverConfig.args = srv.args;
+        if (srv.headers)
+            serverConfig.headers = srv.headers;
+        if (srv.env)
+            serverConfig.env = srv.env;
+        mcpConfig.mcpServers[name] = serverConfig;
+        writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, "\t") + "\n");
+        console.info(`  ${name}: added to .mcp.json`);
+    }
+    // Print setup instructions if any
+    if (manifest.mcp_server.setup_instructions) {
+        console.info(`\n  Setup required for ${name}:`);
+        for (const instruction of manifest.mcp_server.setup_instructions) {
+            console.info(`    ${instruction}`);
+        }
+        console.info("");
+    }
+}
 function installSkill(projectRoot, name) {
     const extPath = join(extensionsDir(projectRoot), `${name}.json`);
     const manifest = loadExtension(extPath);

package/dist/lib/extension-loader.d.ts

@@ -45,6 +45,16 @@ export interface ExtensionManifest {
         on_onboard?: string;
     };
     detect?: DetectRule;
+    mcp_server?: {
+        type?: string;
+        url?: string;
+        command?: string;
+        args?: string[];
+        headers?: Record<string, string>;
+        env?: Record<string, string>;
+        env_from_shell?: string[];
+        setup_instructions?: string[];
+    };
 }
 export interface LoadedExtension {
     manifest: ExtensionManifest;

package/extensions/dash0/manifest.json

@@ -1,17 +1,35 @@
 {
 	"name": "dash0",
-	"description": "Dash0 observability — query logs, traces, and metrics from your OpenTelemetry data via MCP",
+	"description": "Dash0 observability — query logs, traces, and metrics from your OpenTelemetry data via MCP and CLI",
 	"provides": {
 		"skill": true,
 		"health_checks": [
 			{
 				"name": "dash0-mcp-configured",
 				"command": "node -e \"const m=JSON.parse(require('fs').readFileSync('.mcp.json','utf-8'));process.exit(m.mcpServers?.dash0 ? 0 : 1)\""
+			},
+			{
+				"name": "dash0-cli-installed",
+				"command": "dash0 version --agent-mode"
 			}
 		]
 	},
+	"mcp_server": {
+		"type": "streamableHttp",
+		"url": "DASH0_ENDPOINT_MCP",
+		"headers": {
+			"Authorization": "Bearer DASH0_AUTH_TOKEN"
+		},
+		"setup_instructions": [
+			"1. Log into Dash0 > Organization Settings > Endpoints > MCP to get your endpoint URL",
+			"2. Create an auth token at Organization Settings > Auth Tokens",
+			"3. Edit .mcp.json: replace DASH0_ENDPOINT_MCP with your regional endpoint URL",
+			"4. Edit .mcp.json: replace DASH0_AUTH_TOKEN with your token",
+			"5. Optional: install CLI with 'brew install dash0hq/dash0-cli/dash0'"
+		]
+	},
 	"hooks": {
-		"on_init": "echo 'Dash0 extension enabled. Configure the Dash0 MCP server in .mcp.json if not already present.'"
+		"on_enable": "echo 'Dash0 extension enabled.'"
 	},
 	"detect": {
 		"mcp_server": "dash0"

package/extensions/dash0/skill.md

@@ -1,6 +1,25 @@
 # Dash0 Observability
 
-Dash0 provides access to your OpenTelemetry data — logs, traces, and metrics — directly from Claude Code via its MCP server.
+Dash0 provides access to your OpenTelemetry data — logs, traces, and metrics — via two interfaces: the MCP server (for in-session tool calls) and the CLI (for terminal operations and agent mode).
+
+## Two Interfaces
+
+**MCP Server (remote, streamable HTTP — NOT an npm package):**
+- This is a remote server hosted by Dash0, not a local npm package. No `npx`, no `npm install`.
+- Used by Claude Code tools directly during sessions
+- Provides 23 tools for logs, traces, metrics, services
+- Configured in `.mcp.json` with a URL and auth token
+
+**CLI (`dash0` binary):**
+- Installed via `brew install dash0hq/dash0-cli/dash0`
+- Auto-detects Claude Code and enables agent mode (JSON output, no prompts)
+- Use for: log queries, trace lookups, PromQL metrics, dashboard management, asset deployment
+- Key commands:
+  - `dash0 logs query` — search logs
+  - `dash0 traces get <trace-id>` — fetch trace details
+  - `dash0 metrics instant --query 'sum(...)'` — PromQL queries
+  - `dash0 dashboards list` — view dashboards
+  - `dash0 apply -f assets.yaml` — deploy dashboards, views, checks (GitOps)
 
 ## When to Use Dash0
 
@@ -9,41 +28,52 @@ Dash0 provides access to your OpenTelemetry data — logs, traces, and metrics
 - **Performance investigation**: query metrics (PromQL) to check latency, throughput, error rates
 - **Deployment verification**: check traces and error rates after deploying a change
 - **During /work verification**: if a verification step involves checking service health, query Dash0
+- **Dashboard management**: use the CLI to create/update dashboards from YAML definitions
 
-## Available Tools (from Dash0 MCP server)
+## When to Use MCP vs CLI
 
-Dash0's MCP server provides 23 tools. The most useful for development:
-
-| Tool | When |
-|------|------|
-| Search logs | Find errors, warnings, or specific log messages |
-| Search traces | Find request traces by service, endpoint, status, or trace ID |
-| Query metrics (PromQL) | Check latency percentiles, error rates, throughput |
-| List services | See what services are sending telemetry |
-| Get trace details | Deep-dive into a specific trace's spans |
+| Task | Use |
+|------|-----|
+| Query logs during a session | MCP tools |
+| Search traces by service or ID | MCP tools |
+| Run PromQL metrics query | Either — MCP for simple, CLI for complex |
+| Deploy dashboard from YAML | CLI (`dash0 apply -f`) |
+| Diagnose a failing service | MCP tools (faster, in-session) |
+| CI/CD observability checks | CLI (scriptable, agent mode) |
+| Get trace details for debugging | Either |
 
 ## Setup
 
-1. Sign up at [dash0.com](https://www.dash0.com)
-2. Get your API token from the Dash0 dashboard
-3. Add the Dash0 MCP server to your `.mcp.json`:
+### MCP Server (enabled automatically by `extensions enable dash0`)
+
+**Important:** The Dash0 MCP server is a remote hosted service, not an npm package. Do not use `npx` or install anything for the MCP server. You only need a URL and an auth token.
+
+The `.mcp.json` entry is added when you enable the extension:
 
 ```json
-{
-  "mcpServers": {
-    "dash0": {
-      "command": "npx",
-      "args": ["@dash0hq/mcp-server"],
-      "env": {
-        "DASH0_API_TOKEN": "your-token-here",
-        "DASH0_DATASET": "default"
-      }
-    }
+"dash0": {
+  "type": "streamableHttp",
+  "url": "YOUR_ENDPOINT_URL",
+  "headers": {
+    "Authorization": "Bearer YOUR_AUTH_TOKEN"
   }
 }
 ```
 
-4. Enable the extension: `extensions enable dash0`
+Get your endpoint URL and auth token from Dash0: Organization Settings > Endpoints > MCP, and Organization Settings > Auth Tokens.
+
+### CLI
+
+```bash
+brew tap dash0hq/dash0-cli https://github.com/dash0hq/dash0-cli
+brew install dash0hq/dash0-cli/dash0
+
+dash0 config profiles create dev \
+  --api-url https://api.us-west-2.aws.dash0.com \
+  --auth-token YOUR_AUTH_TOKEN
+```
+
+The CLI auto-detects Claude Code sessions and switches to agent mode (JSON output, no confirmation prompts, structured errors on stderr).
 
 ## Workflow Integration
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@infinitedusky/indusk-mcp",
-	"version": "1.4.0",
+	"version": "1.4.2",
 	"description": "InDusk development system — skills, MCP tools, and CLI for structured AI-assisted development",
 	"type": "module",
 	"files": [

package/skills/toolbelt.md

@@ -1,6 +1,18 @@
 # InDusk Toolbelt
 
-You have MCP tools from two servers: **indusk** (dev system) and **codegraphcontext** (code graph). This skill tells you when to use them.
+You have MCP tools from multiple servers. This skill tells you when to use them and how they connect.
+
+## MCP Server Types
+
+There are two types of MCP servers in your `.mcp.json`:
+
+**Command-based** (`"command": "..."`) — a local process that runs on your machine. Examples: indusk, codegraphcontext. These start when Claude Code starts and communicate via stdio.
+
+**Streamable HTTP** (`"type": "streamableHttp"`) — a remote server hosted externally. Example: Dash0. These connect over HTTPS to a URL. No local process, no npm package, no `npx`. They just need a URL and auth credentials in `.mcp.json`.
+
+Both types expose tools the same way — you call them identically. The difference is where they run.
+
+To see which MCP servers and extensions are active, call `extensions_status`.
 
 ## How the Skills Work Together