meshwire 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meshwire",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "CLI and MCP tools for the MeshWire multi-agent messaging service",
   "type": "module",
   "main": "src/index.js",
@@ -17,8 +17,14 @@
     "dev": "node bin/meshwire.js"
   },
   "keywords": [
-    "meshwire", "multi-agent", "agent-mesh", "mcp", "cli",
-    "agent-communication", "long-polling", "ai-agents"
+    "meshwire",
+    "multi-agent",
+    "agent-mesh",
+    "mcp",
+    "cli",
+    "agent-communication",
+    "long-polling",
+    "ai-agents"
   ],
   "author": "htekdev",
   "license": "MIT",

package/src/auth.js

@@ -0,0 +1,75 @@
+// MeshWire credential resolution — reads from multiple sources in priority order
+//
+// Priority: credentials.json > MESHWIRE_TOKEN env > .mesh.json > config.json > null
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { readConfig } from './config.js';
+import { readMeshJson } from './mesh-schema.js';
+
+const CREDS_DIR = join(homedir(), '.meshwire');
+const CREDS_FILE = join(CREDS_DIR, 'credentials.json');
+
+export function readCredentials() {
+  if (!existsSync(CREDS_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync(CREDS_FILE, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function writeCredentials(data) {
+  mkdirSync(CREDS_DIR, { recursive: true });
+  writeFileSync(CREDS_FILE, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+// Resolve token from all sources in priority order
+export function resolveToken() {
+  // 1. credentials.json
+  const creds = readCredentials();
+  if (creds?.token) return creds.token;
+
+  // 2. Environment variable
+  if (process.env.MESHWIRE_TOKEN) return process.env.MESHWIRE_TOKEN;
+
+  // 3. Legacy config.json
+  const config = readConfig();
+  if (config.token) return config.token;
+
+  return null;
+}
+
+// Resolve mesh ID — workspace .mesh.json takes precedence (it's repo-specific)
+export function resolveMeshId() {
+  // 1. Workspace .mesh.json
+  const meshJson = readMeshJson();
+  if (meshJson?.mesh_id) return meshJson.mesh_id;
+
+  // 2. credentials.json default mesh
+  const creds = readCredentials();
+  if (creds?.defaultMeshId) return creds.defaultMeshId;
+
+  // 3. Environment variable
+  if (process.env.MESHWIRE_MESH_ID) return process.env.MESHWIRE_MESH_ID;
+
+  // 4. Legacy config.json
+  const config = readConfig();
+  if (config.meshId) return config.meshId;
+
+  return null;
+}
+
+export function resolveAgentName() {
+  const meshJson = readMeshJson();
+  if (meshJson?.agent_name) return meshJson.agent_name;
+
+  const config = readConfig();
+  return config.agentName || 'meshwire-agent';
+}
+
+export function resolveUrl() {
+  if (process.env.MESHWIRE_URL) return process.env.MESHWIRE_URL;
+  const config = readConfig();
+  return config.url || 'https://meshwire.io';
+}

package/src/cli.js

@@ -9,6 +9,7 @@ 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 { cmdLogin } from './commands/login.js';
 import { cmdMcp } from './mcp/server.js';
 
 export async function run(version) {
@@ -23,6 +24,15 @@ export async function run(version) {
     )
     .version(version, '-v, --version');
 
+  // ─── meshwire login ──────────────────────────────────────────────
+  program
+    .command('login')
+    .description('Sign in with GitHub — saves credentials to ~/.meshwire/credentials.json')
+    .option('--url <url>', 'MeshWire URL', 'https://meshwire.io')
+    .option('--force', 'Re-authenticate even if already signed in')
+    .option('--skip-mesh', 'Skip mesh setup prompt after login')
+    .action(cmdLogin);
+
   // ─── meshwire init ───────────────────────────────────────────────
   program
     .command('init')
@@ -30,6 +40,12 @@ export async function run(version) {
     .option('--token <token>', 'API token (mw_...)')
     .option('--url <url>', 'MeshWire API URL', 'https://meshwire.io')
     .option('--mesh <meshId>', 'Mesh ID to connect to')
+    .option(
+      '--harness <name>',
+      'Set up for a specific harness: copilot | claude | hermes | cursor',
+    )
+    .option('--agent <name>', 'Agent name for harness setup')
+    .option('--workspace <name>', 'Workspace name for .mesh.json')
     .action(cmdInit);
 
   // ─── meshwire status ─────────────────────────────────────────────

package/src/commands/init.js

@@ -1,8 +1,9 @@
-// meshwire init — configure token, URL, and mesh
+// meshwire init — configure token, URL, and mesh. Supports --harness for harness-specific setup.
 import chalk from 'chalk';
 import { createInterface } from 'readline/promises';
 import { writeConfig, readConfig } from '../config.js';
 import { MeshWireClient } from '../api.js';
+import { resolveToken, resolveMeshId, readCredentials, writeCredentials } from '../auth.js';
 
 const MESHWIRE_URL = 'https://meshwire.io';
 
@@ -12,8 +13,54 @@ function prompt(rl, question, defaultVal) {
 }
 
 export async function cmdInit(opts) {
+  // ── Harness-specific setup ────────────────────────────────────────────────
+  if (opts.harness) {
+    const harness = opts.harness.toLowerCase();
+    const config = readConfig();
+    const meshId = opts.mesh || resolveMeshId();
+    const token = opts.token || resolveToken();
+    const url = opts.url || config.url || MESHWIRE_URL;
+
+    switch (harness) {
+      case 'copilot': {
+        const { setupCopilot } = await import('../harness/copilot.js');
+        await setupCopilot({ meshId, agentName: opts.agent, meshwireUrl: url, workspaceName: opts.workspace });
+        return;
+      }
+      case 'claude':
+      case 'cursor': {
+        const { setupClaude } = await import('../harness/claude.js');
+        await setupClaude({ meshId, agentName: opts.agent, meshwireUrl: url, workspaceName: opts.workspace });
+        return;
+      }
+      case 'hermes': {
+        const { setupHermes } = await import('../harness/hermes.js');
+        await setupHermes({ meshId, agentName: opts.agent, meshwireUrl: url, workspaceName: opts.workspace });
+        return;
+      }
+      default:
+        console.error(chalk.red(`  Unknown harness: ${harness}`));
+        console.error(chalk.dim('  Supported: copilot, claude, cursor, hermes\n'));
+        process.exit(1);
+    }
+  }
+
   console.log('\n' + chalk.bold('🕸  MeshWire Setup') + '\n');
 
+  // Auto-detect existing token from credentials or env
+  const detectedToken = resolveToken();
+  const detectedMesh = resolveMeshId();
+
+  if (detectedToken && !opts.token) {
+    const creds = readCredentials();
+    console.log(chalk.dim(`  Found credentials for ${creds?.login || 'your account'}`));
+    console.log(chalk.dim(`  Token: mw_••••••••${detectedToken.slice(-6)}`));
+    if (detectedMesh) {
+      console.log(chalk.dim(`  Mesh:  ${detectedMesh}`));
+    }
+    console.log('');
+  }
+
   // If token + mesh passed via flags, use them directly
   if (opts.token && opts.mesh) {
     const config = writeConfig({
@@ -21,6 +68,7 @@ export async function cmdInit(opts) {
       url: opts.url || MESHWIRE_URL,
       meshId: opts.mesh,
     });
+    writeCredentials({ token: opts.token, defaultMeshId: opts.mesh, savedAt: new Date().toISOString() });
     printSuccess(config);
     return;
   }
@@ -29,12 +77,16 @@ export async function cmdInit(opts) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
 
   try {
-    console.log(chalk.dim(`  Get your token at: ${MESHWIRE_URL}/dashboard\n`));
+    // Suggest login if no credentials found
+    if (!detectedToken) {
+      console.log(chalk.dim(`  No credentials found. Run ${chalk.cyan('meshwire login')} for browser auth,`));
+      console.log(chalk.dim(`  or get your token at: ${MESHWIRE_URL}/dashboard\n`));
+    }
 
-    const token = opts.token || await prompt(rl, 'API token (mw_...)', existing.token);
+    const token = opts.token || detectedToken || 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`));
+      console.error(chalk.dim(`  Run 'meshwire login' or sign in at ${MESHWIRE_URL}.\n`));
       process.exit(1);
     }
 
@@ -88,8 +140,11 @@ function printSuccess(config) {
   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'));
+  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 init --harness copilot') + chalk.dim('   — set up Copilot CLI extension'));
+  console.log(chalk.cyan('    meshwire init --harness claude') + chalk.dim('    — set up Claude Desktop MCP'));
+  console.log(chalk.cyan('    meshwire init --harness hermes') + chalk.dim('    — set up Hermes integration'));
+  console.log(chalk.cyan('    meshwire integrate') + chalk.dim('                — get full API guide\n'));
 }

package/src/commands/login.js

@@ -0,0 +1,179 @@
+// meshwire login — browser-based OAuth, saves credentials to ~/.meshwire/credentials.json
+//
+// Flow:
+// 1. Find a free local port
+// 2. Start a tiny HTTP server to receive the OAuth callback
+// 3. Open browser to meshwire.io/auth/cli?port=PORT
+// 4. User signs in with GitHub (standard OAuth flow)
+// 5. Server redirects to http://localhost:PORT?token=mw_xxx&login=username
+// 6. CLI captures the token, saves to ~/.meshwire/credentials.json
+// 7. Optionally register as an agent in the last-used mesh
+
+import { createServer } from 'http';
+import { URL } from 'url';
+import chalk from 'chalk';
+import { writeCredentials, readCredentials } from '../auth.js';
+import { readConfig, writeConfig } from '../config.js';
+import { MeshWireClient } from '../api.js';
+
+const DEFAULT_URL = 'https://meshwire.io';
+const CLI_PORT_RANGE = [57700, 57799]; // range of ports to try
+
+function findFreePort() {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      server.close(() => resolve(port));
+    });
+    server.on('error', reject);
+  });
+}
+
+function waitForCallback(port, timeoutMs = 120_000) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      server.close();
+      reject(new Error('Login timed out after 2 minutes. Try again.'));
+    }, timeoutMs);
+
+    const server = createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost:${port}`);
+      const token = url.searchParams.get('token');
+      const login = url.searchParams.get('login');
+      const error = url.searchParams.get('error');
+
+      // Send a nice success/error page back to the browser
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+      if (token) {
+        res.end(`<!DOCTYPE html><html><head><title>MeshWire</title>
+          <style>body{font-family:system-ui;background:#080808;color:#f5f5f5;display:grid;place-items:center;height:100vh;margin:0}
+          .box{text-align:center;padding:40px;border:1px solid rgba(124,58,237,.4);border-radius:20px;background:rgba(124,58,237,.08)}
+          h2{color:#a78bfa;margin-bottom:12px}p{color:rgba(255,255,255,.6)}</style></head>
+          <body><div class="box"><h2>✅ Signed in as ${login || 'you'}!</h2>
+          <p>You can close this tab and return to your terminal.</p></div></body></html>`);
+      } else {
+        res.end(`<!DOCTYPE html><html><head><title>MeshWire</title>
+          <style>body{font-family:system-ui;background:#080808;color:#f5f5f5;display:grid;place-items:center;height:100vh;margin:0}
+          .box{text-align:center;padding:40px;border:1px solid rgba(251,113,133,.4);border-radius:20px}
+          h2{color:#fb7185;margin-bottom:12px}p{color:rgba(255,255,255,.6)}</style></head>
+          <body><div class="box"><h2>❌ Login failed</h2>
+          <p>${error || 'Unknown error'}. Please close this tab and try again.</p></div></body></html>`);
+      }
+
+      clearTimeout(timer);
+      server.close();
+
+      if (token) {
+        resolve({ token, login });
+      } else {
+        reject(new Error(`Login failed: ${error || 'unknown error'}`));
+      }
+    });
+
+    server.listen(port, '127.0.0.1', () => {
+      // Server is ready
+    });
+
+    server.on('error', (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+async function openBrowser(url) {
+  const { platform } = process;
+  const { execSync } = await import('child_process');
+  try {
+    if (platform === 'darwin') execSync(`open "${url}"`, { stdio: 'ignore' });
+    else if (platform === 'win32') execSync(`start "" "${url}"`, { shell: true, stdio: 'ignore' });
+    else execSync(`xdg-open "${url}"`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function cmdLogin(opts) {
+  const meshwireUrl = opts.url || readConfig().url || DEFAULT_URL;
+
+  console.log('\n' + chalk.bold('🕸  MeshWire Login') + '\n');
+
+  // Check if already logged in
+  const existing = readCredentials();
+  if (existing?.token && !opts.force) {
+    console.log(chalk.dim('  Already signed in as ') + chalk.bold(existing.login || 'unknown'));
+    console.log(chalk.dim('  Use --force to re-authenticate.\n'));
+
+    const { createInterface } = await import('readline/promises');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await rl.question(chalk.dim('  Re-authenticate? (y/N) '));
+    rl.close();
+    if (!answer.toLowerCase().startsWith('y')) {
+      console.log(chalk.dim('\n  Keeping existing credentials.\n'));
+      return;
+    }
+  }
+
+  // Find a free port
+  const port = await findFreePort();
+  const authUrl = `${meshwireUrl}/auth/cli?port=${port}`;
+
+  console.log(chalk.dim('  Opening browser for GitHub OAuth...\n'));
+  console.log(chalk.cyan(`  ${authUrl}\n`));
+  console.log(chalk.dim('  If the browser did not open, paste the URL above.\n'));
+
+  const opened = await openBrowser(authUrl);
+  if (!opened) {
+    console.log(chalk.yellow('  Could not open browser automatically.'));
+    console.log(chalk.dim('  Please open the URL above in your browser.\n'));
+  }
+
+  // Wait for callback
+  let result;
+  try {
+    result = await waitForCallback(port);
+  } catch (err) {
+    console.error('\n' + chalk.red(`  ✗ ${err.message}\n`));
+    process.exit(1);
+  }
+
+  const { token, login } = result;
+
+  // Save to credentials.json
+  writeCredentials({ token, login, savedAt: new Date().toISOString() });
+
+  // Also update legacy config.json for backward compat
+  writeConfig({ token });
+
+  console.log(chalk.bold.green(`\n  ✅ Signed in as ${login}!\n`));
+  console.log(chalk.dim('  Credentials saved to ~/.meshwire/credentials.json\n'));
+
+  // Optionally create a mesh if none exists
+  const config = readConfig();
+  if (!config.meshId && !opts.skipMesh) {
+    console.log(chalk.dim('  No mesh configured yet.'));
+    console.log(chalk.dim(`  Run ${chalk.cyan('meshwire mesh create')} to create one, or`));
+    console.log(chalk.dim(`  run ${chalk.cyan('meshwire init')} for full interactive setup.\n`));
+  } else if (config.meshId) {
+    // Update credentials with default mesh
+    writeCredentials({ token, login, defaultMeshId: config.meshId, savedAt: new Date().toISOString() });
+    console.log(chalk.dim(`  Default mesh: ${config.meshId}`));
+    console.log('');
+  }
+
+  // Verify connection
+  try {
+    const client = new MeshWireClient({ url: meshwireUrl, token });
+    await client.health();
+    console.log(chalk.green('  ✓ Connected to MeshWire\n'));
+  } catch {
+    console.log(chalk.yellow('  ⚠ Could not verify connection — check your URL\n'));
+  }
+
+  console.log(chalk.dim('  Next steps:'));
+  console.log(chalk.cyan('    meshwire init') + chalk.dim('                 — full workspace setup'));
+  console.log(chalk.cyan('    meshwire init --harness copilot') + chalk.dim(' — set up Copilot CLI extension'));
+  console.log(chalk.cyan('    meshwire status') + chalk.dim('               — verify everything is wired\n'));
+}

package/src/commands/mesh.js

@@ -1,6 +1,7 @@
 // meshwire mesh — create, list, switch meshes
 import chalk from 'chalk';
 import { requireConfig, writeConfig, readConfig } from '../config.js';
+import { writeMeshJson } from '../mesh-schema.js';
 import { MeshWireClient } from '../api.js';
 
 export async function cmdMesh(subcommand, opts) {
@@ -22,8 +23,23 @@ export async function cmdMesh(subcommand, opts) {
     }
 
     case 'use': {
-      writeConfig({ meshId: opts.meshId });
-      console.log(chalk.green(`✓ Active mesh set to: ${opts.meshId}`));
+      const { meshId } = opts;
+      // Write to global config
+      writeConfig({ meshId });
+
+      // Also write .mesh.json in the current workspace directory
+      // so this folder is associated with the mesh
+      const config = readConfig();
+      writeMeshJson({
+        mesh_id: meshId,
+        workspace_name: process.cwd().split(/[/\\]/).pop() || 'workspace',
+        agent_name: config.agentName || 'agent',
+        harness: config.harness || 'copilot',
+      });
+
+      console.log(chalk.green(`✓ Active mesh: ${meshId}`));
+      console.log(chalk.dim(`  ~/.meshwire/config.json updated`));
+      console.log(chalk.dim(`  .mesh.json written to current directory`));
       break;
     }
 

package/src/harness/claude.js

@@ -0,0 +1,88 @@
+// Claude Desktop / Cursor harness setup
+// Generates MCP server config at ~/Library/Application Support/Claude/claude_desktop_config.json
+// (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows)
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir, platform } from 'os';
+import { join } from 'path';
+import chalk from 'chalk';
+import { writeMeshJson, readMeshJson } from '../mesh-schema.js';
+import { readCredentials } from '../auth.js';
+import { MeshWireClient } from '../api.js';
+
+function getClaudeConfigPath() {
+  if (platform() === 'win32') {
+    return join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+  }
+  if (platform() === 'darwin') {
+    return join(homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+  }
+  return join(homedir(), '.config', 'claude', 'claude_desktop_config.json');
+}
+
+export async function setupClaude({ meshId, agentName, meshwireUrl, workspaceName }) {
+  console.log('\n' + chalk.bold('⚙️  Setting up Claude Desktop / Cursor harness') + '\n');
+
+  const creds = readCredentials();
+  if (!creds?.token) {
+    console.error(chalk.red('  ✗ Not authenticated. Run `meshwire login` first.\n'));
+    process.exit(1);
+  }
+
+  // 1. Write .mesh.json
+  const existing = readMeshJson() || {};
+  const meshJsonData = {
+    mesh_id: meshId || existing.mesh_id,
+    workspace_name: workspaceName || existing.workspace_name || process.cwd().split(/[/\\]/).pop(),
+    agent_name: agentName || existing.agent_name || 'claude-agent',
+    harness: 'claude',
+  };
+
+  if (!meshJsonData.mesh_id) {
+    console.error(chalk.red('  ✗ No mesh ID. Run `meshwire mesh create` first.\n'));
+    process.exit(1);
+  }
+
+  writeMeshJson(meshJsonData);
+  console.log(chalk.green('  ✓ .mesh.json written'));
+
+  // 2. Update Claude Desktop config
+  const configPath = getClaudeConfigPath();
+  let config = {};
+  if (existsSync(configPath)) {
+    try { config = JSON.parse(readFileSync(configPath, 'utf8')); } catch { config = {}; }
+  }
+
+  config.mcpServers = config.mcpServers || {};
+  config.mcpServers.meshwire = {
+    command: 'npx',
+    args: ['meshwire', 'mcp', '--mesh', meshJsonData.mesh_id, '--agent', meshJsonData.agent_name],
+    env: {
+      MESHWIRE_TOKEN: creds.token,
+      MESHWIRE_URL: meshwireUrl || 'https://meshwire.io',
+    },
+  };
+
+  mkdirSync(join(configPath, '..'), { recursive: true });
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+  console.log(chalk.green(`\n  ✓ Claude Desktop config updated`));
+  console.log(chalk.dim(`    ${configPath}`));
+
+  // 3. Register agent
+  try {
+    const client = new MeshWireClient({ url: meshwireUrl, token: creds.token, meshId: meshJsonData.mesh_id });
+    const agent = await client.registerAgent(meshJsonData.mesh_id, {
+      name: meshJsonData.agent_name,
+      description: 'Claude Desktop / Cursor agent',
+      workspace: meshJsonData.workspace_name,
+      metadata: { platform: 'claude', harness: 'meshwire' },
+    });
+    console.log(chalk.green(`  ✓ Registered as ${agent.name} (${agent.agent_id})`));
+  } catch (err) {
+    console.log(chalk.yellow(`  ⚠ ${err.message}`));
+  }
+
+  console.log('\n' + chalk.bold.green('  ✅ Claude harness ready!\n'));
+  console.log(chalk.dim('  Restart Claude Desktop to load the MeshWire MCP server.'));
+  console.log(chalk.dim('  MCP tools: meshwire_send_message, meshwire_get_messages, meshwire_list_agents\n'));
+}

package/src/harness/copilot.js

@@ -0,0 +1,266 @@
+// Copilot CLI harness setup
+// Generates a user-level Copilot extension at ~/.copilot/extensions/meshwire.mjs
+// The extension reads credentials from ~/.meshwire/credentials.json and
+// workspace config from .mesh.json in the current directory.
+
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import chalk from 'chalk';
+import { writeMeshJson, readMeshJson } from '../mesh-schema.js';
+import { readCredentials } from '../auth.js';
+import { MeshWireClient } from '../api.js';
+
+const EXTENSION_DIR = join(homedir(), '.copilot', 'extensions');
+const EXTENSION_FILE = join(EXTENSION_DIR, 'meshwire.mjs');
+
+// The generated extension template
+function buildExtensionSource({ meshwireUrl }) {
+  return `// MeshWire — Copilot CLI Extension
+// Auto-generated by: meshwire init --harness copilot
+// Reads credentials from ~/.meshwire/credentials.json
+// Reads workspace mesh from .mesh.json in the current directory
+
+import { readFileSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const CREDS_FILE = join(homedir(), '.meshwire', 'credentials.json');
+const DEFAULT_URL = '${meshwireUrl}';
+
+function loadCreds() {
+  if (!existsSync(CREDS_FILE)) return null;
+  try { return JSON.parse(readFileSync(CREDS_FILE, 'utf8')); } catch { return null; }
+}
+
+function loadMeshJson() {
+  const file = join(process.cwd(), '.mesh.json');
+  if (!existsSync(file)) return null;
+  try { return JSON.parse(readFileSync(file, 'utf8')); } catch { return null; }
+}
+
+async function api(path, method = 'GET', body = null) {
+  const creds = loadCreds();
+  if (!creds?.token) throw new Error('Not authenticated. Run: meshwire login');
+  const meshJson = loadMeshJson();
+  const url = DEFAULT_URL + path.replace('{meshId}', meshJson?.mesh_id || '');
+  const opts = {
+    method,
+    headers: {
+      'Authorization': 'Bearer ' + creds.token,
+      'Content-Type': 'application/json',
+    },
+  };
+  if (body) opts.body = JSON.stringify(body);
+  const res = await fetch(url, opts);
+  if (!res.ok) {
+    const txt = await res.text().catch(() => '');
+    let msg; try { msg = JSON.parse(txt).error; } catch { msg = txt || res.statusText; }
+    throw new Error(msg);
+  }
+  return res.json();
+}
+
+// ─── Tool Definitions ────────────────────────────────────────────────────────
+
+export const tools = [
+  {
+    name: 'mesh_send_message',
+    description: 'Send a message to agents in the mesh. Use recipient_id "*" to broadcast.',
+    parameters: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'Message content' },
+        recipient_id: { type: 'string', default: '*', description: 'Target agent ID or "*" for all' },
+        priority: { type: 'string', enum: ['urgent', 'high', 'normal', 'low'], default: 'normal' },
+      },
+      required: ['content'],
+    },
+    async execute({ content, recipient_id = '*', priority = 'normal' }) {
+      const creds = loadCreds();
+      const meshJson = loadMeshJson();
+      if (!meshJson?.mesh_id) throw new Error('No mesh configured. Add .mesh.json to this workspace.');
+      const agent_id = creds?.agentId || 'copilot-cli';
+      const msg = await api(
+        '/mesh/{meshId}/messages', 'POST',
+        { sender_id: agent_id, recipient_id, content, priority }
+      );
+      return { sent: true, message_id: msg.message_id, to: recipient_id };
+    },
+  },
+
+  {
+    name: 'mesh_get_messages',
+    description: 'Fetch new messages from the mesh. Uses long-polling (up to 10s).',
+    parameters: {
+      type: 'object',
+      properties: {
+        offset: { type: 'integer', default: 0, description: 'Return messages with ID > offset' },
+        timeout: { type: 'integer', default: 10, description: 'Poll timeout in seconds (max 30)' },
+      },
+    },
+    async execute({ offset = 0, timeout = 10 }) {
+      const creds = loadCreds();
+      const meshJson = loadMeshJson();
+      if (!meshJson?.mesh_id) throw new Error('No mesh configured. Add .mesh.json to this workspace.');
+      const agentId = creds?.agentId || undefined;
+      const params = new URLSearchParams({ offset: String(offset), timeout: String(Math.min(timeout, 30)) });
+      if (agentId) params.set('recipient', agentId);
+      const result = await api('/mesh/{meshId}/messages?' + params.toString());
+      if (!result.messages?.length) return { messages: [], count: 0 };
+      return {
+        count: result.count,
+        messages: result.messages.map(m => ({
+          id: m.message_id,
+          from: m.sender_id,
+          to: m.recipient_id,
+          content: m.content,
+          priority: m.priority,
+          time: m.created_at,
+        })),
+      };
+    },
+  },
+
+  {
+    name: 'mesh_list_agents',
+    description: 'List all agents currently registered in this workspace mesh.',
+    parameters: { type: 'object', properties: {} },
+    async execute() {
+      const meshJson = loadMeshJson();
+      if (!meshJson?.mesh_id) throw new Error('No mesh configured. Add .mesh.json to this workspace.');
+      const result = await api('/mesh/{meshId}/agents');
+      return {
+        count: result.count,
+        agents: result.agents.map(a => ({
+          id: a.agent_id,
+          name: a.name,
+          status: a.status,
+          workspace: a.workspace,
+          last_seen: a.last_seen,
+        })),
+      };
+    },
+  },
+
+  {
+    name: 'mesh_status',
+    description: 'Check MeshWire connection status and current mesh/agent info.',
+    parameters: { type: 'object', properties: {} },
+    async execute() {
+      const creds = loadCreds();
+      const meshJson = loadMeshJson();
+      const health = await fetch(DEFAULT_URL + '/health').then(r => r.json()).catch(() => null);
+      return {
+        authenticated: Boolean(creds?.token),
+        login: creds?.login || null,
+        mesh_id: meshJson?.mesh_id || null,
+        workspace: meshJson?.workspace_name || null,
+        agent_name: meshJson?.agent_name || null,
+        service: health?.status || 'unreachable',
+      };
+    },
+  },
+];
+
+// ─── Hooks ───────────────────────────────────────────────────────────────────
+
+export const hooks = {
+  // Called on session start — register this agent in the mesh
+  async onSessionStart({ agentName } = {}) {
+    const creds = loadCreds();
+    const meshJson = loadMeshJson();
+    if (!creds?.token || !meshJson?.mesh_id) return;
+
+    const name = agentName || meshJson?.agent_name || 'copilot-cli';
+    try {
+      const agent = await api('/mesh/{meshId}/agents', 'POST', {
+        name,
+        description: 'GitHub Copilot CLI agent',
+        workspace: process.cwd().split('/').pop() || 'workspace',
+        metadata: { platform: 'copilot-cli', harness: 'meshwire' },
+      });
+      // Store agent ID in a runtime variable for this session
+      if (typeof globalThis !== 'undefined') {
+        globalThis.__meshwire_agent_id__ = agent.agent_id;
+      }
+      console.log('[meshwire] Registered as ' + name + ' (' + agent.agent_id + ')');
+    } catch (err) {
+      console.warn('[meshwire] Could not register agent:', err.message);
+    }
+  },
+
+  // Called periodically — keep heartbeat alive
+  async onHeartbeat() {
+    const creds = loadCreds();
+    const meshJson = loadMeshJson();
+    const agentId = globalThis.__meshwire_agent_id__;
+    if (!creds?.token || !meshJson?.mesh_id || !agentId) return;
+    await api('/mesh/{meshId}/agents/' + agentId + '/heartbeat', 'POST').catch(() => {});
+  },
+};
+`;
+}
+
+export async function setupCopilot({ meshId, agentName, meshwireUrl, workspaceName }) {
+  console.log('\n' + chalk.bold('⚙️  Setting up Copilot CLI harness') + '\n');
+
+  const creds = readCredentials();
+  if (!creds?.token) {
+    console.error(chalk.red('  ✗ Not authenticated. Run `meshwire login` first.\n'));
+    process.exit(1);
+  }
+
+  // 1. Create/update .mesh.json in the current workspace
+  const existing = readMeshJson() || {};
+  const meshJsonData = {
+    mesh_id: meshId || existing.mesh_id,
+    workspace_name: workspaceName || existing.workspace_name || process.cwd().split(/[/\\]/).pop(),
+    agent_name: agentName || existing.agent_name || 'copilot-agent',
+    harness: 'copilot',
+  };
+
+  if (!meshJsonData.mesh_id) {
+    console.error(chalk.red('  ✗ No mesh ID. Create a mesh first: meshwire mesh create\n'));
+    process.exit(1);
+  }
+
+  writeMeshJson(meshJsonData);
+  console.log(chalk.green('  ✓ .mesh.json written'));
+  console.log(chalk.dim(`    mesh_id:    ${meshJsonData.mesh_id}`));
+  console.log(chalk.dim(`    agent_name: ${meshJsonData.agent_name}`));
+  console.log(chalk.dim(`    harness:    copilot`));
+
+  // 2. Generate and write the Copilot extension
+  mkdirSync(EXTENSION_DIR, { recursive: true });
+  const source = buildExtensionSource({ meshwireUrl: meshwireUrl || 'https://meshwire.io' });
+  writeFileSync(EXTENSION_FILE, source, 'utf8');
+  console.log(chalk.green(`\n  ✓ Extension installed at ${EXTENSION_FILE}`));
+
+  // 3. Register the agent in the mesh now
+  console.log(chalk.dim('\n  Registering agent in mesh...'));
+  try {
+    const client = new MeshWireClient({ url: meshwireUrl, token: creds.token, meshId: meshJsonData.mesh_id });
+    const agent = await client.registerAgent(meshJsonData.mesh_id, {
+      name: meshJsonData.agent_name,
+      description: 'GitHub Copilot CLI agent',
+      workspace: meshJsonData.workspace_name,
+      metadata: { platform: 'copilot-cli', harness: 'meshwire' },
+    });
+    console.log(chalk.green(`  ✓ Registered as ${agent.name} (${agent.agent_id})`));
+  } catch (err) {
+    console.log(chalk.yellow(`  ⚠ Could not register now: ${err.message}`));
+    console.log(chalk.dim('    The extension will auto-register on next Copilot CLI session.'));
+  }
+
+  // 4. Print summary
+  console.log('\n' + chalk.bold.green('  ✅ Copilot harness ready!\n'));
+  console.log(chalk.dim('  The extension provides these tools in every Copilot session:'));
+  console.log(chalk.cyan('    mesh_send_message') + chalk.dim('   — broadcast or target a specific agent'));
+  console.log(chalk.cyan('    mesh_get_messages') + chalk.dim('   — poll for new messages'));
+  console.log(chalk.cyan('    mesh_list_agents') + chalk.dim('    — discover agents in the mesh'));
+  console.log(chalk.cyan('    mesh_status') + chalk.dim('         — check connection health'));
+  console.log('');
+  console.log(chalk.dim('  The .mesh.json file in this repo defines which mesh Copilot connects to.'));
+  console.log(chalk.dim('  Commit .mesh.json so your teammates auto-join the same mesh.\n'));
+}

package/src/harness/hermes.js

@@ -0,0 +1,101 @@
+// Hermes / generic harness setup
+// Writes a skill document + env file for Hermes (Pi) and other harnesses
+
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import { writeMeshJson, readMeshJson } from '../mesh-schema.js';
+import { readCredentials } from '../auth.js';
+import { MeshWireClient } from '../api.js';
+
+export async function setupHermes({ meshId, agentName, meshwireUrl, workspaceName }) {
+  console.log('\n' + chalk.bold('⚙️  Setting up Hermes / generic harness') + '\n');
+
+  const creds = readCredentials();
+  if (!creds?.token) {
+    console.error(chalk.red('  ✗ Not authenticated. Run `meshwire login` first.\n'));
+    process.exit(1);
+  }
+
+  const existing = readMeshJson() || {};
+  const meshJsonData = {
+    mesh_id: meshId || existing.mesh_id,
+    workspace_name: workspaceName || existing.workspace_name || 'hermes',
+    agent_name: agentName || existing.agent_name || 'hermes-agent',
+    harness: 'hermes',
+  };
+
+  if (!meshJsonData.mesh_id) {
+    console.error(chalk.red('  ✗ No mesh ID. Run `meshwire mesh create` first.\n'));
+    process.exit(1);
+  }
+
+  writeMeshJson(meshJsonData);
+  console.log(chalk.green('  ✓ .mesh.json written'));
+
+  // Write a .env.meshwire file for Hermes to source
+  const envContent = [
+    `MESHWIRE_TOKEN=${creds.token}`,
+    `MESHWIRE_URL=${meshwireUrl || 'https://meshwire.io'}`,
+    `MESHWIRE_MESH_ID=${meshJsonData.mesh_id}`,
+    `MESHWIRE_AGENT_NAME=${meshJsonData.agent_name}`,
+    '',
+  ].join('\n');
+
+  writeFileSync(join(process.cwd(), '.env.meshwire'), envContent, 'utf8');
+  console.log(chalk.green('  ✓ .env.meshwire written'));
+
+  // Write skill document
+  const skillContent = `# MeshWire Skill — ${meshJsonData.workspace_name}
+
+## Mesh
+\`\`\`
+MESH_ID=${meshJsonData.mesh_id}
+AGENT_NAME=${meshJsonData.agent_name}
+BASE_URL=${meshwireUrl || 'https://meshwire.io'}
+\`\`\`
+
+## Quick commands
+
+### Send message
+\`\`\`bash
+curl -sX POST $MESHWIRE_URL/mesh/${meshJsonData.mesh_id}/messages \\
+  -H "Authorization: Bearer $MESHWIRE_TOKEN" \\
+  -H "Content-Type: application/json" \\
+  -d '{"sender_id":"YOUR_AGENT_ID","content":"hello","recipient_id":"*"}'
+\`\`\`
+
+### Poll messages
+\`\`\`bash
+curl -s "$MESHWIRE_URL/mesh/${meshJsonData.mesh_id}/messages?timeout=30&offset=0" \\
+  -H "Authorization: Bearer $MESHWIRE_TOKEN"
+\`\`\`
+
+### List agents
+\`\`\`bash
+curl -s "$MESHWIRE_URL/mesh/${meshJsonData.mesh_id}/agents" \\
+  -H "Authorization: Bearer $MESHWIRE_TOKEN"
+\`\`\`
+`;
+
+  writeFileSync(join(process.cwd(), 'MESHWIRE_SKILL.md'), skillContent, 'utf8');
+  console.log(chalk.green('  ✓ MESHWIRE_SKILL.md written'));
+
+  // Register agent
+  try {
+    const client = new MeshWireClient({ url: meshwireUrl, token: creds.token, meshId: meshJsonData.mesh_id });
+    const agent = await client.registerAgent(meshJsonData.mesh_id, {
+      name: meshJsonData.agent_name,
+      description: 'Hermes agent',
+      workspace: meshJsonData.workspace_name,
+      metadata: { platform: 'hermes', harness: 'meshwire' },
+    });
+    console.log(chalk.green(`  ✓ Registered as ${agent.name} (${agent.agent_id})`));
+  } catch (err) {
+    console.log(chalk.yellow(`  ⚠ ${err.message}`));
+  }
+
+  console.log('\n' + chalk.bold.green('  ✅ Hermes harness ready!\n'));
+  console.log(chalk.dim('  Source .env.meshwire in your Hermes startup script.'));
+  console.log(chalk.dim('  Drop MESHWIRE_SKILL.md into your agent context.\n'));
+}

package/src/mesh-schema.js

@@ -0,0 +1,41 @@
+// .mesh.json — workspace-level mesh config
+// Lives in the repo root. Defines which mesh this workspace participates in.
+//
+// Schema:
+// {
+//   "mesh_id": "kR9xQpLmW3aZ",          — which mesh this workspace joins
+//   "workspace_name": "rocha-family",    — human label for this workspace
+//   "agent_name": "copilot-assistant",   — how this agent appears in the mesh
+//   "harness": "copilot"                 — which harness drives this workspace
+// }
+
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+const MESH_JSON_FILE = '.mesh.json';
+
+export function readMeshJson(cwd = process.cwd()) {
+  const file = join(cwd, MESH_JSON_FILE);
+  if (!existsSync(file)) return null;
+  try {
+    return JSON.parse(readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function writeMeshJson(data, cwd = process.cwd()) {
+  const file = join(cwd, MESH_JSON_FILE);
+  writeFileSync(file, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+export function meshJsonExists(cwd = process.cwd()) {
+  return existsSync(join(cwd, MESH_JSON_FILE));
+}
+
+export const MESH_JSON_SCHEMA = {
+  mesh_id: 'string — which mesh this workspace connects to',
+  workspace_name: 'string — human-readable label for this workspace',
+  agent_name: 'string — how this agent appears in the mesh',
+  harness: 'string — copilot | claude | hermes | cursor | raw',
+};