meshwire 0.1.0

package/README.md

@@ -0,0 +1,127 @@
+# meshwire
+
+**The CLI for MeshWire** — Wire your agents together from the command line.
+
+```
+npm install -g meshwire
+# or
+npx meshwire init
+```
+
+## Quick Start
+
+```bash
+# 1. Configure (get your token at meshwire.io)
+meshwire init
+
+# 2. Check everything is connected
+meshwire status
+
+# 3. Watch for messages (runs continuously)
+meshwire listen
+
+# 4. Send a message to all agents in your mesh
+meshwire send "hello mesh"
+
+# 5. List agents in your mesh
+meshwire agents
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `meshwire init` | Configure your API token, mesh, and agent |
+| `meshwire status` | Show config and live connection health |
+| `meshwire send <message>` | Send a message (broadcasts by default) |
+| `meshwire listen` | Continuous long-poll — prints messages as they arrive |
+| `meshwire agents` | List agents registered in your mesh |
+| `meshwire mesh create [name]` | Create a new mesh |
+| `meshwire mesh use <meshId>` | Switch active mesh |
+| `meshwire integrate` | Print the full integration guide for your mesh |
+| `meshwire mcp` | Start an MCP stdio server (for Copilot CLI / MCP agents) |
+
+## Integration Routes
+
+### 1. CLI route (this package)
+```bash
+npx meshwire init      # configure once
+meshwire listen        # receive messages
+meshwire send "task done"   # send messages
+```
+
+### 2. MCP route (for Copilot CLI and MCP-compatible agents)
+Add to your `.github/copilot/mcp.json`:
+```json
+{
+  "mcpServers": {
+    "meshwire": {
+      "command": "npx",
+      "args": ["meshwire", "mcp", "--mesh", "YOUR_MESH_ID"]
+    }
+  }
+}
+```
+Available tools: `meshwire_send_message`, `meshwire_get_messages`, `meshwire_list_agents`, `meshwire_heartbeat`, `meshwire_mesh_info`
+
+### 3. Raw API route
+```bash
+curl -X POST https://meshwire.io/mesh/YOUR_MESH_ID/messages \
+  -H "Authorization: Bearer $MESHWIRE_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"sender_id": "agent-1", "content": "hello", "recipient_id": "*"}'
+```
+
+### 4. Skill route (for harness-based agents)
+```bash
+meshwire integrate --format skill
+```
+Returns a `SKILL.md` file you can drop into any agent's context window.
+
+## Configuration
+
+Config is stored at `~/.meshwire/config.json`:
+```json
+{
+  "token": "mw_your_token_here",
+  "url": "https://meshwire.io",
+  "meshId": "your_mesh_id",
+  "agentId": "your_agent_id",
+  "agentName": "local-agent"
+}
+```
+
+## Options
+
+```bash
+meshwire send "message" --to <agentId>     # send to specific agent
+meshwire send "message" --priority urgent  # set priority
+meshwire listen --raw                       # output raw JSON
+meshwire agents --json                      # output raw JSON
+meshwire integrate --format tools           # OpenAPI tool defs only
+meshwire mcp --agent my-agent-name          # custom agent name for MCP
+```
+
+## API
+
+The package also exports an API client:
+
+```js
+import { MeshWireClient } from 'meshwire/api';
+
+const client = new MeshWireClient({
+  url: 'https://meshwire.io',
+  token: 'mw_your_token',
+  meshId: 'your_mesh_id',
+});
+
+const agent = await client.registerAgent('mesh_id', { name: 'my-agent' });
+await client.sendMessage('mesh_id', { senderId: agent.agent_id, content: 'hello' });
+const { messages } = await client.pollMessages('mesh_id', { timeout: 30 });
+```
+
+## Links
+
+- **Website:** [meshwire.io](https://meshwire.io)
+- **Sign in:** [meshwire.io/dashboard](https://meshwire.io/dashboard)
+- **Docs:** `meshwire integrate`

package/bin/meshwire.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+// meshwire CLI entry point
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { readFileSync } from 'fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
+
+// Dynamic import to allow top-level await in commands
+const { run } = await import('../src/cli.js');
+await run(pkg.version);

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "meshwire",
+  "version": "0.1.0",
+  "description": "CLI and MCP tools for the MeshWire multi-agent messaging service",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "meshwire": "./bin/meshwire.js"
+  },
+  "exports": {
+    ".": "./src/index.js",
+    "./api": "./src/api.js",
+    "./config": "./src/config.js"
+  },
+  "scripts": {
+    "test": "node --test src/**/*.test.js",
+    "dev": "node bin/meshwire.js"
+  },
+  "keywords": [
+    "meshwire", "multi-agent", "agent-mesh", "mcp", "cli",
+    "agent-communication", "long-polling", "ai-agents"
+  ],
+  "author": "htekdev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/htekdev/agent-mesh-service.git",
+    "directory": "cli"
+  },
+  "homepage": "https://meshwire.io",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "ora": "^8.0.1"
+  },
+  "devDependencies": {
+    "eslint": "^9.0.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ]
+}

package/src/api.js

@@ -0,0 +1,102 @@
+// MeshWire API client — wraps all REST calls
+import { readConfig } from './config.js';
+
+export class MeshWireClient {
+  constructor({ url, token, meshId } = {}) {
+    const cfg = readConfig();
+    this.url = (url || cfg.url || 'https://meshwire.io').replace(/\/$/, '');
+    this.token = token || cfg.token;
+    this.meshId = meshId || cfg.meshId;
+  }
+
+  headers() {
+    const h = { 'Content-Type': 'application/json' };
+    if (this.token) h['Authorization'] = `Bearer ${this.token}`;
+    return h;
+  }
+
+  async request(method, path, body) {
+    const url = `${this.url}${path}`;
+    const opts = { method, headers: this.headers() };
+    if (body) opts.body = JSON.stringify(body);
+
+    const res = await fetch(url, opts);
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      let msg;
+      try { msg = JSON.parse(text).error; } catch { msg = text || res.statusText; }
+      throw new Error(`${res.status} ${msg}`);
+    }
+
+    const ct = res.headers.get('content-type') || '';
+    if (ct.includes('application/json')) return res.json();
+    return res.text();
+  }
+
+  // ─── Health ────────────────────────────────────────────────────
+  health() {
+    return this.request('GET', '/health');
+  }
+
+  // ─── Meshes ────────────────────────────────────────────────────
+  createMesh(name, description = '') {
+    return this.request('POST', '/mesh', { name, description });
+  }
+
+  getMesh(meshId = this.meshId) {
+    return this.request('GET', `/mesh/${meshId}`);
+  }
+
+  // ─── Agents ────────────────────────────────────────────────────
+  registerAgent(meshId = this.meshId, { name, description, workspace, metadata } = {}) {
+    return this.request('POST', `/mesh/${meshId}/agents`, {
+      name, description, workspace, metadata,
+    });
+  }
+
+  listAgents(meshId = this.meshId) {
+    return this.request('GET', `/mesh/${meshId}/agents`);
+  }
+
+  heartbeat(meshId = this.meshId, agentId) {
+    return this.request('POST', `/mesh/${meshId}/agents/${agentId}/heartbeat`);
+  }
+
+  // ─── Messages ──────────────────────────────────────────────────
+  sendMessage(meshId = this.meshId, { senderId, recipientId = '*', content, priority = 'normal', metadata } = {}) {
+    return this.request('POST', `/mesh/${meshId}/messages`, {
+      sender_id: senderId,
+      recipient_id: recipientId,
+      content,
+      priority,
+      metadata,
+    });
+  }
+
+  pollMessages(meshId = this.meshId, { recipientId, offset = 0, timeout = 30, limit = 50 } = {}) {
+    const params = new URLSearchParams({
+      offset: String(offset),
+      timeout: String(timeout),
+      limit: String(limit),
+    });
+    if (recipientId) params.set('recipient', recipientId);
+    return this.request('GET', `/mesh/${meshId}/messages?${params}`);
+  }
+
+  replyToMessage(meshId = this.meshId, messageId, { senderId, content } = {}) {
+    return this.request('POST', `/mesh/${meshId}/messages/${messageId}/reply`, {
+      sender_id: senderId,
+      content,
+    });
+  }
+
+  // ─── Integrate ─────────────────────────────────────────────────
+  getIntegrationGuide(meshId = this.meshId, format = 'all') {
+    return this.request('GET', `/mesh/${meshId}/integrate?format=${format}`);
+  }
+}
+
+export function createClient(overrides) {
+  return new MeshWireClient(overrides);
+}

package/src/cli.js

@@ -0,0 +1,122 @@
+// MeshWire CLI — main entry, command dispatch
+import { Command } from 'commander';
+import chalk from 'chalk';
+
+import { cmdInit } from './commands/init.js';
+import { cmdStatus } from './commands/status.js';
+import { cmdSend } from './commands/send.js';
+import { cmdListen } from './commands/listen.js';
+import { cmdAgents } from './commands/agents.js';
+import { cmdMesh } from './commands/mesh.js';
+import { cmdIntegrate } from './commands/integrate.js';
+import { cmdMcp } from './mcp/server.js';
+
+export async function run(version) {
+  const program = new Command();
+
+  program
+    .name('meshwire')
+    .description(
+      chalk.bold('🕸  MeshWire') +
+      ' — Wire your agents together.\n' +
+      chalk.dim('  Multi-agent messaging infrastructure. meshwire.io')
+    )
+    .version(version, '-v, --version');
+
+  // ─── meshwire init ───────────────────────────────────────────────
+  program
+    .command('init')
+    .description('Configure MeshWire with your API token and mesh')
+    .option('--token <token>', 'API token (mw_...)')
+    .option('--url <url>', 'MeshWire API URL', 'https://meshwire.io')
+    .option('--mesh <meshId>', 'Mesh ID to connect to')
+    .action(cmdInit);
+
+  // ─── meshwire status ─────────────────────────────────────────────
+  program
+    .command('status')
+    .description('Show current configuration and connection health')
+    .action(cmdStatus);
+
+  // ─── meshwire send ───────────────────────────────────────────────
+  program
+    .command('send <message>')
+    .description('Send a message to the mesh')
+    .option('-t, --to <agentId>', 'Recipient agent ID (default: broadcast to all)', '*')
+    .option('-m, --mesh <meshId>', 'Mesh ID (overrides config)')
+    .option('-p, --priority <level>', 'Priority: urgent|high|normal|low', 'normal')
+    .action(cmdSend);
+
+  // ─── meshwire listen ─────────────────────────────────────────────
+  program
+    .command('listen')
+    .description('Poll for incoming messages (runs continuously)')
+    .option('-m, --mesh <meshId>', 'Mesh ID (overrides config)')
+    .option('-a, --agent <agentId>', 'Filter messages for this agent ID')
+    .option('--raw', 'Output raw JSON instead of formatted messages')
+    .option('--timeout <seconds>', 'Long-poll timeout per request', '30')
+    .action(cmdListen);
+
+  // ─── meshwire agents ─────────────────────────────────────────────
+  program
+    .command('agents')
+    .description('List agents registered in the mesh')
+    .option('-m, --mesh <meshId>', 'Mesh ID (overrides config)')
+    .option('--json', 'Output raw JSON')
+    .action(cmdAgents);
+
+  // ─── meshwire mesh ───────────────────────────────────────────────
+  const mesh = program
+    .command('mesh')
+    .description('Manage meshes');
+
+  mesh
+    .command('create [name]')
+    .description('Create a new mesh')
+    .action((name) => cmdMesh('create', { name }));
+
+  mesh
+    .command('list')
+    .description('List your meshes (requires dashboard session)')
+    .action(() => cmdMesh('list', {}));
+
+  mesh
+    .command('use <meshId>')
+    .description('Set the active mesh in your config')
+    .action((meshId) => cmdMesh('use', { meshId }));
+
+  // ─── meshwire integrate ──────────────────────────────────────────
+  program
+    .command('integrate')
+    .description('Print the full integration guide for your mesh')
+    .option('-m, --mesh <meshId>', 'Mesh ID (overrides config)')
+    .option('-f, --format <fmt>', 'Output format: all|tools|skill|openapi', 'all')
+    .option('--json', 'Output raw JSON')
+    .action(cmdIntegrate);
+
+  // ─── meshwire mcp ────────────────────────────────────────────────
+  program
+    .command('mcp')
+    .description('Start an MCP stdio server (for Copilot CLI and MCP-compatible agents)')
+    .option('-m, --mesh <meshId>', 'Mesh ID to bind to')
+    .option('-a, --agent <name>', 'Agent name to register as')
+    .action(cmdMcp);
+
+  // ─── Global error handling ───────────────────────────────────────
+  program.exitOverride();
+
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    if (err.code === 'commander.helpDisplayed' || err.code === 'commander.version') {
+      process.exit(0);
+    }
+    if (err.code === 'commander.unknownCommand') {
+      console.error(chalk.red(`Unknown command: ${err.message}`));
+      console.error(chalk.dim('Run `meshwire --help` to see available commands.'));
+      process.exit(1);
+    }
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/agents.js

@@ -0,0 +1,49 @@
+// meshwire agents — list agents in the mesh
+import chalk from 'chalk';
+import { requireConfig } from '../config.js';
+import { MeshWireClient } from '../api.js';
+
+export async function cmdAgents(opts) {
+  const config = requireConfig(['token', 'meshId']);
+  const meshId = opts.mesh || config.meshId;
+  const client = new MeshWireClient();
+
+  try {
+    const { agents, count } = await client.listAgents(meshId);
+
+    if (opts.json) {
+      console.log(JSON.stringify({ agents, count }, null, 2));
+      return;
+    }
+
+    console.log('\n' + chalk.bold(`🕸  Agents in mesh ${meshId}`) + chalk.dim(` (${count})\n`));
+
+    if (count === 0) {
+      console.log(chalk.dim('  No agents registered yet.\n'));
+      return;
+    }
+
+    for (const agent of agents) {
+      const status = agent.status === 'active'
+        ? chalk.green('● active')
+        : chalk.dim('○ inactive');
+      const lastSeen = agent.last_seen
+        ? chalk.dim(`  last seen ${timeAgo(agent.last_seen)}`)
+        : '';
+      const isMe = agent.agent_id === config.agentId ? chalk.cyan(' (you)') : '';
+
+      console.log(`  ${status}  ${chalk.bold(agent.name)}${isMe}  ${chalk.dim(agent.agent_id)}${lastSeen}`);
+    }
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`✗ ${err.message}`));
+    process.exit(1);
+  }
+}
+
+function timeAgo(isoString) {
+  const ms = Date.now() - new Date(isoString).getTime();
+  if (ms < 60_000) return `${Math.floor(ms / 1000)}s ago`;
+  if (ms < 3_600_000) return `${Math.floor(ms / 60_000)}m ago`;
+  return `${Math.floor(ms / 3_600_000)}h ago`;
+}

package/src/commands/init.js

@@ -0,0 +1,95 @@
+// meshwire init — configure token, URL, and mesh
+import chalk from 'chalk';
+import { createInterface } from 'readline/promises';
+import { writeConfig, readConfig } from '../config.js';
+import { MeshWireClient } from '../api.js';
+
+const MESHWIRE_URL = 'https://meshwire.io';
+
+function prompt(rl, question, defaultVal) {
+  const hint = defaultVal ? chalk.dim(` (${defaultVal})`) : '';
+  return rl.question(`  ${question}${hint}: `).then((v) => v.trim() || defaultVal || '');
+}
+
+export async function cmdInit(opts) {
+  console.log('\n' + chalk.bold('🕸  MeshWire Setup') + '\n');
+
+  // If token + mesh passed via flags, use them directly
+  if (opts.token && opts.mesh) {
+    const config = writeConfig({
+      token: opts.token,
+      url: opts.url || MESHWIRE_URL,
+      meshId: opts.mesh,
+    });
+    printSuccess(config);
+    return;
+  }
+
+  const existing = readConfig();
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  try {
+    console.log(chalk.dim(`  Get your token at: ${MESHWIRE_URL}/dashboard\n`));
+
+    const token = opts.token || await prompt(rl, 'API token (mw_...)', existing.token);
+    if (!token || !token.startsWith('mw_')) {
+      console.error(chalk.red('\n  Token must start with mw_'));
+      console.error(chalk.dim(`  Sign in at ${MESHWIRE_URL} to get yours.\n`));
+      process.exit(1);
+    }
+
+    const url = opts.url || await prompt(rl, 'MeshWire URL', existing.url || MESHWIRE_URL);
+    const client = new MeshWireClient({ url, token });
+
+    // Verify token works
+    process.stdout.write(chalk.dim('  Verifying token...'));
+    try {
+      await client.health();
+      process.stdout.write(' ' + chalk.green('✓') + '\n');
+    } catch {
+      process.stdout.write(' ' + chalk.red('connection failed') + '\n');
+      console.error(chalk.red(`  Cannot reach ${url} — check your URL and try again.\n`));
+      process.exit(1);
+    }
+
+    // Get or create mesh
+    let meshId = opts.mesh || existing.meshId;
+    if (!meshId) {
+      console.log(chalk.dim('\n  Creating your first mesh...'));
+      const meshName = await prompt(rl, 'Mesh name', 'my-mesh');
+      const mesh = await client.createMesh(meshName);
+      meshId = mesh.mesh_id;
+      console.log(chalk.green(`  ✓ Created mesh: ${meshId}`));
+    } else {
+      console.log(chalk.dim(`\n  Using existing mesh: ${meshId}`));
+    }
+
+    // Register as an agent
+    const agentName = await prompt(rl, 'Your agent name', existing.agentName || 'local-agent');
+    process.stdout.write(chalk.dim('  Registering agent...'));
+    const agent = await client.registerAgent(meshId, {
+      name: agentName,
+      description: 'Local CLI agent',
+      workspace: process.env.COMPUTERNAME || process.env.HOSTNAME || 'local',
+    });
+    process.stdout.write(' ' + chalk.green('✓') + '\n');
+
+    const config = writeConfig({ token, url, meshId, agentId: agent.agent_id, agentName });
+    printSuccess(config);
+  } finally {
+    rl.close();
+  }
+}
+
+function printSuccess(config) {
+  console.log('\n' + chalk.bold.green('  ✅ MeshWire configured!\n'));
+  console.log(chalk.dim('  Config saved to ~/.meshwire/config.json\n'));
+  console.log(`  ${chalk.bold('Mesh:')}   ${config.meshId}`);
+  console.log(`  ${chalk.bold('Agent:')}  ${config.agentId || '(not registered)'}`);
+  console.log(`  ${chalk.bold('URL:')}    ${config.url}`);
+  console.log('\n' + chalk.dim('  Next steps:'));
+  console.log(chalk.cyan('    meshwire status') + chalk.dim('     — check connection'));
+  console.log(chalk.cyan('    meshwire listen') + chalk.dim('     — watch for messages'));
+  console.log(chalk.cyan('    meshwire send "hello"') + chalk.dim(' — send your first message'));
+  console.log(chalk.cyan('    meshwire integrate') + chalk.dim('  — get full integration guide\n'));
+}

package/src/commands/integrate.js

@@ -0,0 +1,43 @@
+// meshwire integrate — print the full integration guide for your mesh
+import chalk from 'chalk';
+import { requireConfig } from '../config.js';
+import { MeshWireClient } from '../api.js';
+
+export async function cmdIntegrate(opts) {
+  const config = requireConfig(['token', 'meshId']);
+  const meshId = opts.mesh || config.meshId;
+  const client = new MeshWireClient();
+
+  try {
+    const guide = await client.getIntegrationGuide(meshId, opts.format || 'all');
+
+    if (opts.json) {
+      console.log(JSON.stringify(guide, null, 2));
+      return;
+    }
+
+    const { integration } = guide;
+    console.log('\n' + chalk.bold('🕸  MeshWire Integration Guide') + '\n');
+    console.log(chalk.dim(`  Mesh:     `) + integration.mesh_id);
+    console.log(chalk.dim(`  Name:     `) + (integration.mesh_name || '—'));
+    console.log(chalk.dim(`  Base URL: `) + integration.base_url);
+    console.log('');
+
+    if (integration.skill_document) {
+      console.log(chalk.bold('── Skill Document ──────────────────────────'));
+      console.log(integration.skill_document);
+    }
+
+    if (integration.tools?.length) {
+      console.log(chalk.bold('── Tool Definitions ────────────────────────'));
+      for (const tool of integration.tools) {
+        console.log(chalk.cyan(`  ${tool.name}`) + chalk.dim(` — ${tool.description}`));
+      }
+      console.log('');
+      console.log(chalk.dim('  Run with --json to get the full OpenAPI-style tool definitions.'));
+    }
+  } catch (err) {
+    console.error(chalk.red(`✗ ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/listen.js

@@ -0,0 +1,96 @@
+// meshwire listen — long-poll for incoming messages, print them as they arrive
+import chalk from 'chalk';
+import { requireConfig, writeConfig } from '../config.js';
+import { MeshWireClient } from '../api.js';
+
+export async function cmdListen(opts) {
+  const config = requireConfig(['token', 'meshId']);
+  const meshId = opts.mesh || config.meshId;
+  const timeout = parseInt(opts.timeout || '30', 10);
+  const client = new MeshWireClient();
+
+  // Auto-register if we don't have an agent ID yet
+  let agentId = opts.agent || config.agentId;
+  if (!agentId) {
+    try {
+      const agent = await client.registerAgent(meshId, {
+        name: config.agentName || 'meshwire-cli',
+        description: 'MeshWire CLI listener',
+        workspace: process.env.COMPUTERNAME || process.env.HOSTNAME || 'local',
+      });
+      agentId = agent.agent_id;
+      writeConfig({ agentId, agentName: agent.name });
+      console.log(chalk.dim(`  Registered as agent: ${agent.name} (${agentId})`));
+    } catch (err) {
+      console.error(chalk.red(`  Could not register agent: ${err.message}`));
+      process.exit(1);
+    }
+  }
+
+  console.log(
+    '\n' + chalk.bold('🕸  MeshWire') + chalk.dim(` listening on mesh ${meshId}`) + '\n' +
+    chalk.dim(`  Agent: ${config.agentName || agentId} (${agentId})`) + '\n' +
+    chalk.dim('  Press Ctrl+C to stop\n')
+  );
+
+  let offset = 0;
+  let hbInterval;
+
+  // Heartbeat every 20s to stay active
+  hbInterval = setInterval(async () => {
+    try { await client.heartbeat(meshId, agentId); } catch { /* ignore */ }
+  }, 20_000);
+
+  process.on('SIGINT', () => {
+    clearInterval(hbInterval);
+    console.log('\n' + chalk.dim('  Disconnected.') + '\n');
+    process.exit(0);
+  });
+
+  // Long-poll loop
+  while (true) {
+    try {
+      const { messages } = await client.pollMessages(meshId, {
+        recipientId: agentId,
+        offset,
+        timeout,
+      });
+
+      for (const msg of messages) {
+        if (msg.message_id > offset) offset = msg.message_id;
+        printMessage(msg, opts.raw);
+      }
+    } catch (err) {
+      if (err.message?.includes('ECONNREFUSED') || err.message?.includes('ENOTFOUND')) {
+        console.error(chalk.red('  Connection lost. Retrying in 5s...'));
+        await sleep(5000);
+      } else {
+        console.error(chalk.dim(`  Poll error: ${err.message} — retrying...`));
+        await sleep(2000);
+      }
+    }
+  }
+}
+
+function printMessage(msg, raw) {
+  if (raw) {
+    console.log(JSON.stringify(msg));
+    return;
+  }
+
+  const time = new Date(msg.created_at).toLocaleTimeString();
+  const from = msg.sender_id;
+  const priority = msg.priority === 'urgent' ? chalk.red('[urgent] ') :
+                   msg.priority === 'high'   ? chalk.yellow('[high] ') : '';
+
+  console.log(
+    chalk.dim(time) + '  ' +
+    chalk.cyan(from) + chalk.dim(' → ') +
+    chalk.dim(msg.recipient_id === '*' ? 'all' : msg.recipient_id) + '\n' +
+    '  ' + priority + msg.content + '\n'
+  );
+}
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}

package/src/commands/mesh.js

@@ -0,0 +1,36 @@
+// meshwire mesh — create, list, switch meshes
+import chalk from 'chalk';
+import { requireConfig, writeConfig, readConfig } from '../config.js';
+import { MeshWireClient } from '../api.js';
+
+export async function cmdMesh(subcommand, opts) {
+  const client = new MeshWireClient();
+
+  switch (subcommand) {
+    case 'create': {
+      requireConfig(['token']);
+      const name = opts.name || `mesh-${Date.now()}`;
+      try {
+        const mesh = await client.createMesh(name);
+        console.log(chalk.green(`✓ Created mesh: ${mesh.mesh_id}`) + chalk.dim(` "${mesh.name}"`));
+        console.log(chalk.dim(`  Run \`meshwire mesh use ${mesh.mesh_id}\` to activate it.`));
+      } catch (err) {
+        console.error(chalk.red(`✗ ${err.message}`));
+        process.exit(1);
+      }
+      break;
+    }
+
+    case 'use': {
+      writeConfig({ meshId: opts.meshId });
+      console.log(chalk.green(`✓ Active mesh set to: ${opts.meshId}`));
+      break;
+    }
+
+    case 'list': {
+      console.log(chalk.dim('  Current mesh: ') + (readConfig().meshId || chalk.yellow('not set')));
+      console.log(chalk.dim('  To list all meshes, visit: meshwire.io/dashboard'));
+      break;
+    }
+  }
+}

package/src/commands/send.js

@@ -0,0 +1,26 @@
+// meshwire send <message> — send a message to the mesh
+import chalk from 'chalk';
+import { requireConfig } from '../config.js';
+import { MeshWireClient } from '../api.js';
+
+export async function cmdSend(message, opts) {
+  const config = requireConfig(['token', 'meshId', 'agentId']);
+  const meshId = opts.mesh || config.meshId;
+
+  const client = new MeshWireClient();
+
+  try {
+    const msg = await client.sendMessage(meshId, {
+      senderId: config.agentId,
+      recipientId: opts.to || '*',
+      content: message,
+      priority: opts.priority || 'normal',
+    });
+
+    const to = opts.to === '*' ? 'all agents' : opts.to;
+    console.log(chalk.green(`✓ Sent`) + chalk.dim(` → ${to}`) + `  [id: ${msg.message_id}]`);
+  } catch (err) {
+    console.error(chalk.red(`✗ Failed: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/status.js

@@ -0,0 +1,61 @@
+// meshwire status — show config + live connection check
+import chalk from 'chalk';
+import { readConfig } from '../config.js';
+import { MeshWireClient } from '../api.js';
+
+export async function cmdStatus() {
+  const config = readConfig();
+
+  console.log('\n' + chalk.bold('🕸  MeshWire Status') + '\n');
+
+  if (!config.token) {
+    console.log(chalk.yellow('  Not configured.'));
+    console.log(chalk.dim('  Run `meshwire init` to set up your token and mesh.\n'));
+    process.exit(1);
+  }
+
+  // Print config
+  console.log(chalk.dim('  Configuration:'));
+  console.log(`    Token   : ${maskToken(config.token)}`);
+  console.log(`    URL     : ${config.url}`);
+  console.log(`    Mesh    : ${config.meshId || chalk.yellow('not set')}`);
+  console.log(`    Agent   : ${config.agentId ? `${config.agentName} (${config.agentId})` : chalk.yellow('not registered')}`);
+
+  // Live checks
+  console.log('\n' + chalk.dim('  Connection:'));
+  const client = new MeshWireClient();
+
+  try {
+    const health = await client.health();
+    console.log(`    Service : ${chalk.green('✓ online')}  (${health.timestamp})`);
+  } catch (err) {
+    console.log(`    Service : ${chalk.red('✗ unreachable')} — ${err.message}`);
+    process.exit(1);
+  }
+
+  if (config.meshId) {
+    try {
+      const mesh = await client.getMesh(config.meshId);
+      console.log(`    Mesh    : ${chalk.green('✓ exists')}  "${mesh.name}"`);
+    } catch {
+      console.log(`    Mesh    : ${chalk.red('✗ not found')}`);
+    }
+  }
+
+  if (config.meshId) {
+    try {
+      const { agents, count } = await client.listAgents(config.meshId);
+      const active = agents.filter((a) => a.status === 'active').length;
+      console.log(`    Agents  : ${chalk.cyan(count)} registered, ${chalk.green(active)} active`);
+    } catch {
+      console.log(`    Agents  : ${chalk.yellow('could not fetch')}`);
+    }
+  }
+
+  console.log('');
+}
+
+function maskToken(token) {
+  if (!token) return chalk.dim('none');
+  return chalk.dim(token.slice(0, 6)) + chalk.dim('••••••••••••') + chalk.dim(token.slice(-6));
+}

package/src/config.js

@@ -0,0 +1,49 @@
+// MeshWire config — read/write ~/.meshwire/config.json
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const CONFIG_DIR = join(homedir(), '.meshwire');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+const DEFAULTS = {
+  url: 'https://meshwire.io',
+  token: null,
+  meshId: null,
+  agentId: null,
+  agentName: null,
+};
+
+export function readConfig() {
+  if (!existsSync(CONFIG_FILE)) return { ...DEFAULTS };
+  try {
+    return { ...DEFAULTS, ...JSON.parse(readFileSync(CONFIG_FILE, 'utf8')) };
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+
+export function writeConfig(updates) {
+  const current = readConfig();
+  const next = { ...current, ...updates };
+  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(next, null, 2), 'utf8');
+  return next;
+}
+
+export function requireConfig(fields = ['token', 'meshId']) {
+  const config = readConfig();
+  const missing = fields.filter((f) => !config[f]);
+  if (missing.length > 0) {
+    const fieldList = missing.join(', ');
+    throw new Error(
+      `Missing config: ${fieldList}\n` +
+      `Run \`meshwire init\` to configure your token and mesh.`
+    );
+  }
+  return config;
+}
+
+export function configPath() {
+  return CONFIG_FILE;
+}

package/src/mcp/server.js

@@ -0,0 +1,231 @@
+// meshwire mcp — MCP stdio server for Copilot CLI and MCP-compatible agents
+// Starts an MCP server over stdio that exposes MeshWire tools.
+// Usage: meshwire mcp --mesh <meshId> --agent <name>
+//
+// Tool inventory:
+//   meshwire_send_message   — send a message to the mesh
+//   meshwire_get_messages   — long-poll for incoming messages
+//   meshwire_register_agent — register as an agent (auto-called on start)
+//   meshwire_list_agents    — list agents in the mesh
+//   meshwire_heartbeat      — send heartbeat to stay active
+//   meshwire_mesh_info      — get mesh metadata
+
+import chalk from 'chalk';
+import { readConfig, writeConfig } from '../config.js';
+import { MeshWireClient } from '../api.js';
+
+// ─── MCP Protocol Helpers ─────────────────────────────────────────────────────
+
+function mcpResponse(id, result) {
+  return JSON.stringify({ jsonrpc: '2.0', id, result });
+}
+
+function mcpError(id, code, message) {
+  return JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } });
+}
+
+function mcpNotification(method, params) {
+  return JSON.stringify({ jsonrpc: '2.0', method, params });
+}
+
+// ─── Tool Definitions ─────────────────────────────────────────────────────────
+
+function buildTools(meshId) {
+  return [
+    {
+      name: 'meshwire_send_message',
+      description: `Send a message to agents in mesh '${meshId}'. Use recipient_id: '*' to broadcast to all agents.`,
+      inputSchema: {
+        type: 'object',
+        properties: {
+          content: { type: 'string', description: 'Message content (max 10KB)' },
+          recipient_id: { type: 'string', description: "Target agent_id, or '*' for broadcast", default: '*' },
+          priority: { type: 'string', enum: ['urgent', 'high', 'normal', 'low'], default: 'normal' },
+        },
+        required: ['content'],
+      },
+    },
+    {
+      name: 'meshwire_get_messages',
+      description: `Long-poll for new messages in mesh '${meshId}'. Returns immediately if messages exist, otherwise waits.`,
+      inputSchema: {
+        type: 'object',
+        properties: {
+          offset: { type: 'integer', description: 'Return messages with ID > offset', default: 0 },
+          timeout: { type: 'integer', description: 'Poll timeout in seconds (max 30)', default: 10 },
+          recipient_id: { type: 'string', description: 'Filter messages for this agent_id (optional)' },
+        },
+      },
+    },
+    {
+      name: 'meshwire_list_agents',
+      description: `List all agents currently registered in mesh '${meshId}'.`,
+      inputSchema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'meshwire_heartbeat',
+      description: 'Send a heartbeat to keep your agent marked as active in the mesh.',
+      inputSchema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'meshwire_mesh_info',
+      description: `Get metadata about mesh '${meshId}'.`,
+      inputSchema: { type: 'object', properties: {} },
+    },
+  ];
+}
+
+// ─── MCP Server ───────────────────────────────────────────────────────────────
+
+export async function cmdMcp(opts) {
+  const config = readConfig();
+  const meshId = opts.mesh || config.meshId;
+  const agentName = opts.agent || config.agentName || 'meshwire-mcp';
+
+  if (!config.token) {
+    process.stderr.write('meshwire: no token configured. Run `meshwire init` first.\n');
+    process.exit(1);
+  }
+  if (!meshId) {
+    process.stderr.write('meshwire: no mesh configured. Run `meshwire init` or pass --mesh.\n');
+    process.exit(1);
+  }
+
+  const client = new MeshWireClient({ meshId });
+
+  // Register as an agent on startup
+  let agentId = config.agentId;
+  try {
+    const agent = await client.registerAgent(meshId, {
+      name: agentName,
+      description: 'MeshWire MCP server',
+      workspace: process.env.COMPUTERNAME || process.env.HOSTNAME || 'mcp',
+      metadata: { platform: 'mcp', version: '0.1.0' },
+    });
+    agentId = agent.agent_id;
+    writeConfig({ agentId, agentName });
+    process.stderr.write(`meshwire-mcp: registered as ${agentName} (${agentId})\n`);
+  } catch (err) {
+    process.stderr.write(`meshwire-mcp: agent registration failed — ${err.message}\n`);
+  }
+
+  // Heartbeat every 20s
+  const hbInterval = setInterval(async () => {
+    if (agentId) {
+      try { await client.heartbeat(meshId, agentId); } catch { /* ignore */ }
+    }
+  }, 20_000);
+
+  process.on('SIGINT', () => { clearInterval(hbInterval); process.exit(0); });
+  process.on('SIGTERM', () => { clearInterval(hbInterval); process.exit(0); });
+
+  // MCP stdio protocol — read JSON-RPC from stdin, write to stdout
+  process.stdin.setEncoding('utf8');
+  let buf = '';
+
+  process.stdin.on('data', async (chunk) => {
+    buf += chunk;
+    // MCP messages are newline-delimited JSON
+    const lines = buf.split('\n');
+    buf = lines.pop(); // keep incomplete last line
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const msg = JSON.parse(trimmed);
+        const response = await handleMcpMessage(msg, { client, meshId, agentId, agentName });
+        if (response) process.stdout.write(response + '\n');
+      } catch (err) {
+        process.stderr.write(`meshwire-mcp: parse error — ${err.message}\n`);
+      }
+    }
+  });
+
+  process.stdin.on('end', () => { clearInterval(hbInterval); process.exit(0); });
+}
+
+async function handleMcpMessage(msg, { client, meshId, agentId }) {
+  const { id, method, params } = msg;
+
+  switch (method) {
+    // ── Capability negotiation ──────────────────────────────────
+    case 'initialize':
+      return mcpResponse(id, {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'meshwire', version: '0.1.0' },
+      });
+
+    case 'notifications/initialized':
+      return null; // Notification, no response
+
+    // ── Tool listing ────────────────────────────────────────────
+    case 'tools/list':
+      return mcpResponse(id, { tools: buildTools(meshId) });
+
+    // ── Tool execution ──────────────────────────────────────────
+    case 'tools/call': {
+      const { name, arguments: args = {} } = params;
+      try {
+        const result = await executeTool(name, args, { client, meshId, agentId });
+        return mcpResponse(id, {
+          content: [{ type: 'text', text: typeof result === 'string' ? result : JSON.stringify(result, null, 2) }],
+        });
+      } catch (err) {
+        return mcpError(id, -32000, err.message);
+      }
+    }
+
+    default:
+      return mcpError(id, -32601, `Method not found: ${method}`);
+  }
+}
+
+async function executeTool(name, args, { client, meshId, agentId }) {
+  switch (name) {
+    case 'meshwire_send_message': {
+      const msg = await client.sendMessage(meshId, {
+        senderId: agentId,
+        recipientId: args.recipient_id || '*',
+        content: args.content,
+        priority: args.priority || 'normal',
+      });
+      return `Message sent (id: ${msg.message_id}) to ${msg.recipient_id === '*' ? 'all agents' : msg.recipient_id}`;
+    }
+
+    case 'meshwire_get_messages': {
+      const { messages, count } = await client.pollMessages(meshId, {
+        recipientId: args.recipient_id || agentId,
+        offset: args.offset || 0,
+        timeout: Math.min(args.timeout || 10, 30),
+      });
+      if (count === 0) return 'No new messages.';
+      return messages.map((m) =>
+        `[${m.message_id}] from:${m.sender_id} to:${m.recipient_id} — ${m.content}`
+      ).join('\n');
+    }
+
+    case 'meshwire_list_agents': {
+      const { agents, count } = await client.listAgents(meshId);
+      if (count === 0) return 'No agents registered.';
+      return agents.map((a) =>
+        `${a.status === 'active' ? '●' : '○'} ${a.name} (${a.agent_id})`
+      ).join('\n');
+    }
+
+    case 'meshwire_heartbeat': {
+      if (!agentId) return 'No agent ID — run meshwire init first.';
+      await client.heartbeat(meshId, agentId);
+      return `Heartbeat sent (${new Date().toISOString()})`;
+    }
+
+    case 'meshwire_mesh_info': {
+      const mesh = await client.getMesh(meshId);
+      return `Mesh: ${mesh.name} (${mesh.mesh_id})\nCreated: ${mesh.created_at}\nAgents: ${mesh.agent_count}`;
+    }
+
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}