orchestrix 15.14.0

package/lib/mcp-client.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const https = require('https');
+const http = require('http');
+const { MCP_SERVER_URL } = require('./merge');
+
+/**
+ * Validate license key by calling MCP server tools/list
+ * Returns: { valid: true, tier: string } or { valid: false, error: string }
+ */
+async function validateKey(key) {
+  try {
+    const response = await mcpRequest(key, 'tools/list', {});
+    if (response.result) {
+      return { valid: true, tier: 'pro' }; // If tools/list works, key is valid
+    }
+    return { valid: false, error: response.error?.message || 'Unknown error' };
+  } catch (err) {
+    return { valid: false, error: err.message };
+  }
+}
+
+/**
+ * Fetch init data from MCP server
+ * Returns parsed response or null on failure
+ */
+async function fetchInit(key, type = 'all') {
+  try {
+    const response = await mcpRequest(key, 'tools/call', {
+      name: 'orchestrix-init',
+      arguments: { type },
+    });
+    if (response.result && response.result.content) {
+      return response.result.content[0]?.text || null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Send a JSON-RPC request to the MCP server
+ */
+function mcpRequest(key, method, params) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(MCP_SERVER_URL);
+    const transport = url.protocol === 'https:' ? https : http;
+
+    const body = JSON.stringify({
+      jsonrpc: '2.0',
+      method,
+      params,
+      id: 1,
+    });
+
+    // Detect proxy from environment
+    const proxyUrl = process.env.https_proxy || process.env.HTTPS_PROXY ||
+                     process.env.http_proxy || process.env.HTTP_PROXY;
+
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: url.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+        Authorization: `Bearer ${key}`,
+      },
+      timeout: 15000,
+    };
+
+    // If proxy is set, try to use it (basic support)
+    if (proxyUrl) {
+      try {
+        const proxy = new URL(proxyUrl);
+        options.hostname = proxy.hostname;
+        options.port = proxy.port;
+        options.path = MCP_SERVER_URL;
+        options.headers.Host = url.hostname;
+      } catch {
+        // Invalid proxy URL, proceed without proxy
+      }
+    }
+
+    const req = transport.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          resolve(json);
+        } catch {
+          reject(new Error(`Invalid response from MCP server: ${data.slice(0, 200)}`));
+        }
+      });
+    });
+
+    req.on('error', (err) => reject(err));
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('MCP server request timed out (15s)'));
+    });
+
+    req.write(body);
+    req.end();
+  });
+}
+
+module.exports = { validateKey, fetchInit, mcpRequest };

package/lib/merge.js

@@ -0,0 +1,200 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const MCP_SERVER_URL = 'https://orchestrix-mcp.youlidao.ai/api/mcp';
+
+/**
+ * Deep merge .mcp.json — preserves existing entries, adds/updates orchestrix
+ * Returns: 'create' | 'update' | 'skip'
+ */
+function mergeMcpJson(projectDir) {
+  const filePath = path.join(projectDir, '.mcp.json');
+  let existing = {};
+
+  if (fs.existsSync(filePath)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    } catch {
+      // Invalid JSON, start fresh but warn
+      existing = {};
+    }
+  }
+
+  if (!existing.mcpServers) {
+    existing.mcpServers = {};
+  }
+
+  let changed = false;
+
+  // Add/update orchestrix entry
+  const orchestrixEntry = {
+    type: 'http',
+    url: MCP_SERVER_URL,
+    headers: {
+      Authorization: 'Bearer {{env:ORCHESTRIX_LICENSE_KEY}}',
+    },
+  };
+
+  const existingOrchestrix = existing.mcpServers.orchestrix;
+  if (!existingOrchestrix) {
+    existing.mcpServers.orchestrix = orchestrixEntry;
+    changed = true;
+  } else {
+    // Update URL and headers if different
+    if (existingOrchestrix.url !== orchestrixEntry.url ||
+        existingOrchestrix.type !== orchestrixEntry.type) {
+      existing.mcpServers.orchestrix = { ...existingOrchestrix, ...orchestrixEntry };
+      changed = true;
+    }
+  }
+
+  // Add sequential-thinking if not present (don't overwrite)
+  if (!existing.mcpServers['sequential-thinking']) {
+    existing.mcpServers['sequential-thinking'] = {
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-sequential-thinking'],
+    };
+    changed = true;
+  }
+
+  if (!changed) {
+    return 'skip';
+  }
+
+  const action = fs.existsSync(filePath) ? 'update' : 'create';
+  fs.writeFileSync(filePath, JSON.stringify(existing, null, 2) + '\n');
+  return action;
+}
+
+/**
+ * Merge handoff-detector hook into .claude/settings.local.json
+ * Returns: 'create' | 'update' | 'skip'
+ */
+function mergeSettingsLocal(projectDir) {
+  const filePath = path.join(projectDir, '.claude', 'settings.local.json');
+  let existing = {};
+
+  if (fs.existsSync(filePath)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    } catch {
+      existing = {};
+    }
+  }
+
+  if (!existing.hooks) {
+    existing.hooks = {};
+  }
+  if (!existing.hooks.Stop) {
+    existing.hooks.Stop = [];
+  }
+
+  // Check if handoff-detector hook already exists
+  const hookCommand = "bash -c 'cd \"$(git rev-parse --show-toplevel)\" && .orchestrix-core/scripts/handoff-detector.sh'";
+  const hasHook = existing.hooks.Stop.some((entry) => {
+    if (!entry || !entry.hooks) return false;
+    return entry.hooks.some((h) => h.command && h.command.includes('handoff-detector'));
+  });
+
+  if (hasHook) {
+    return 'skip';
+  }
+
+  existing.hooks.Stop.push({
+    matcher: '',
+    hooks: [
+      {
+        type: 'command',
+        command: hookCommand,
+      },
+    ],
+  });
+
+  const action = fs.existsSync(filePath) ? 'update' : 'create';
+
+  // Ensure directory exists
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  fs.writeFileSync(filePath, JSON.stringify(existing, null, 2) + '\n');
+  return action;
+}
+
+/**
+ * Remove orchestrix entry from .mcp.json (for uninstall)
+ * Returns: true if file was modified
+ */
+function removeFromMcpJson(projectDir) {
+  const filePath = path.join(projectDir, '.mcp.json');
+  if (!fs.existsSync(filePath)) return false;
+
+  try {
+    const existing = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    if (!existing.mcpServers || !existing.mcpServers.orchestrix) return false;
+
+    delete existing.mcpServers.orchestrix;
+    // Also remove sequential-thinking if we added it
+    delete existing.mcpServers['sequential-thinking'];
+
+    // If mcpServers is now empty, remove the whole file
+    if (Object.keys(existing.mcpServers).length === 0 && Object.keys(existing).length === 1) {
+      fs.unlinkSync(filePath);
+    } else {
+      fs.writeFileSync(filePath, JSON.stringify(existing, null, 2) + '\n');
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Remove handoff-detector hook from settings.local.json (for uninstall)
+ * Returns: true if file was modified
+ */
+function removeFromSettingsLocal(projectDir) {
+  const filePath = path.join(projectDir, '.claude', 'settings.local.json');
+  if (!fs.existsSync(filePath)) return false;
+
+  try {
+    const existing = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    if (!existing.hooks || !existing.hooks.Stop) return false;
+
+    const before = existing.hooks.Stop.length;
+    existing.hooks.Stop = existing.hooks.Stop.filter((entry) => {
+      if (!entry || !entry.hooks) return true;
+      return !entry.hooks.some((h) => h.command && h.command.includes('handoff-detector'));
+    });
+
+    if (existing.hooks.Stop.length === before) return false;
+
+    // Clean up empty structures
+    if (existing.hooks.Stop.length === 0) {
+      delete existing.hooks.Stop;
+    }
+    if (Object.keys(existing.hooks).length === 0) {
+      delete existing.hooks;
+    }
+
+    if (Object.keys(existing).length === 0) {
+      fs.unlinkSync(filePath);
+    } else {
+      fs.writeFileSync(filePath, JSON.stringify(existing, null, 2) + '\n');
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  mergeMcpJson,
+  mergeSettingsLocal,
+  removeFromMcpJson,
+  removeFromSettingsLocal,
+  MCP_SERVER_URL,
+};

package/lib/ui.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const readline = require('readline');
+
+// ANSI color codes
+const colors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+  gray: '\x1b[90m',
+};
+
+function log(msg = '') {
+  console.log(`  ${msg}`);
+}
+
+function success(msg) {
+  console.log(`  ${colors.green}✓${colors.reset} ${msg}`);
+}
+
+function warn(msg) {
+  console.log(`  ${colors.yellow}⚠${colors.reset} ${msg}`);
+}
+
+function error(msg) {
+  console.log(`  ${colors.red}✗${colors.reset} ${msg}`);
+}
+
+function info(msg) {
+  console.log(`  ${colors.cyan}ℹ${colors.reset} ${msg}`);
+}
+
+function header(msg) {
+  console.log();
+  console.log(`  ${colors.bold}${msg}${colors.reset}`);
+  console.log();
+}
+
+function step(num, total, msg) {
+  console.log(`  ${colors.dim}[${num}/${total}]${colors.reset} ${msg}`);
+}
+
+function fileAction(action, filePath) {
+  const actionColors = {
+    create: colors.green,
+    update: colors.yellow,
+    merge: colors.cyan,
+    skip: colors.gray,
+    overwrite: colors.yellow,
+  };
+  const c = actionColors[action] || colors.reset;
+  console.log(`  ${c}${action.padEnd(10)}${colors.reset} ${filePath}`);
+}
+
+async function prompt(question, defaultValue) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const suffix = defaultValue ? ` (${defaultValue})` : '';
+
+  return new Promise((resolve) => {
+    rl.question(`  ${question}${suffix}: `, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue || '');
+    });
+  });
+}
+
+async function confirm(question, defaultYes = false) {
+  const hint = defaultYes ? '[Y/n]' : '[y/N]';
+  const answer = await prompt(`${question} ${hint}`);
+  if (!answer) return defaultYes;
+  return answer.toLowerCase().startsWith('y');
+}
+
+function banner() {
+  console.log();
+  console.log(`  ${colors.magenta}${colors.bold}o8x${colors.reset} ${colors.dim}— Orchestrix Installer${colors.reset}`);
+  console.log();
+}
+
+function done() {
+  console.log();
+  console.log(`  ${colors.green}${colors.bold}Done!${colors.reset}`);
+  console.log();
+}
+
+module.exports = {
+  colors,
+  log,
+  success,
+  warn,
+  error,
+  info,
+  header,
+  step,
+  fileAction,
+  prompt,
+  confirm,
+  banner,
+  done,
+};

package/lib/uninstall.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const ui = require('./ui');
+const { removeFromMcpJson, removeFromSettingsLocal } = require('./merge');
+
+async function uninstall(flags) {
+  ui.banner();
+  ui.header('Uninstalling Orchestrix');
+
+  const projectDir = process.cwd();
+
+  // 1. Remove slash commands
+  const commandsDir = path.join(projectDir, '.claude', 'commands');
+  const commandFiles = ['o.md', 'o-help.md', 'o-status.md'];
+  for (const f of commandFiles) {
+    const p = path.join(commandsDir, f);
+    if (fs.existsSync(p)) {
+      fs.unlinkSync(p);
+      ui.fileAction('remove', `.claude/commands/${f}`);
+    }
+  }
+
+  // 2. Remove from .mcp.json
+  if (removeFromMcpJson(projectDir)) {
+    ui.fileAction('update', '.mcp.json (removed orchestrix entries)');
+  }
+
+  // 3. Remove handoff hook from settings.local.json
+  if (removeFromSettingsLocal(projectDir)) {
+    ui.fileAction('update', '.claude/settings.local.json (removed hook)');
+  }
+
+  // 4. Remove .orchestrix-core (ask unless --force or --yes)
+  const orchestrixDir = path.join(projectDir, '.orchestrix-core');
+  if (fs.existsSync(orchestrixDir)) {
+    let shouldRemove = flags.force || flags.yes;
+    if (!shouldRemove) {
+      shouldRemove = await ui.confirm('Remove .orchestrix-core/ (includes project config)?', false);
+    }
+
+    if (shouldRemove) {
+      fs.rmSync(orchestrixDir, { recursive: true, force: true });
+      ui.fileAction('remove', '.orchestrix-core/');
+    } else {
+      ui.fileAction('skip', '.orchestrix-core/ (preserved)');
+    }
+  }
+
+  // Note: We do NOT remove .env.local or ORCHESTRIX_LICENSE_KEY from it
+  ui.info('.env.local preserved (manage license key manually)');
+
+  ui.done();
+}
+
+module.exports = { uninstall };

package/lib/upgrade.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const ui = require('./ui');
+const { install } = require('./install');
+
+/**
+ * Upgrade is just a force re-install that preserves core-config.yaml
+ * (install already skips core-config.yaml if it exists)
+ */
+async function upgrade(flags) {
+  ui.banner();
+  ui.info('Upgrading Orchestrix installation...');
+  console.log();
+
+  // Re-run install with force flag
+  await install({ ...flags, force: true });
+}
+
+module.exports = { upgrade };

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "orchestrix",
+  "version": "15.14.0",
+  "description": "Install Orchestrix multi-agent infrastructure into any project. One command: npx o8x install",
+  "bin": {
+    "o8x": "bin/o8x.js"
+  },
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "scripts": {
+    "test": "node --test 'test/*.test.js'"
+  },
+  "keywords": [
+    "orchestrix",
+    "ai-agent",
+    "multi-agent",
+    "claude-code",
+    "opencode",
+    "tmux-automation",
+    "handoff",
+    "cli"
+  ],
+  "author": "dorayo",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {}
+}