@ornexus/synapse-cli 4.2.0

package/install.js

@@ -0,0 +1,323 @@
+#!/usr/bin/env node
+
+/**
+ * Synapse CLI - Binary Installer
+ *
+ * Downloads and installs the pre-compiled native binary from GitHub Releases.
+ * The binary is self-contained with all assets encrypted inside.
+ *
+ * Usage: npx @ornexus/synapse-cli
+ */
+
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+const crypto = require('crypto');
+
+const args = process.argv.slice(2);
+
+const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
+const VERSION = pkg.version;
+const REPO = 'OrNexus-AI/synapse-cli';
+const RELEASE_URL = `https://api.github.com/repos/${REPO}/releases/tags/v${VERSION}`;
+const LATEST_RELEASE_URL = `https://api.github.com/repos/${REPO}/releases/latest`;
+
+// Auth token for private repos (GITHUB_TOKEN, GH_TOKEN, or gh CLI token)
+function getGitHubToken() {
+    if (process.env.GITHUB_TOKEN) return process.env.GITHUB_TOKEN;
+    if (process.env.GH_TOKEN) return process.env.GH_TOKEN;
+    // Try to get token from gh CLI
+    try {
+        return execSync('gh auth token', { stdio: 'pipe', timeout: 5000 }).toString().trim();
+    } catch {
+        return null;
+    }
+}
+
+const GITHUB_TOKEN = getGitHubToken();
+
+// ═══════════════════════════════════════════════════════════════════
+// PLATFORM DETECTION
+// ═══════════════════════════════════════════════════════════════════
+
+function getPlatformInfo() {
+    const platform = os.platform();
+    const arch = os.arch();
+
+    const map = {
+        'darwin-arm64': { binary: 'synapse-cli-darwin-arm64', installDir: path.join(os.homedir(), '.local', 'bin') },
+        'darwin-x64': { binary: 'synapse-cli-darwin-x64', installDir: path.join(os.homedir(), '.local', 'bin') },
+        'linux-x64': { binary: 'synapse-cli-linux-x64', installDir: path.join(os.homedir(), '.local', 'bin') },
+        'win32-x64': { binary: 'synapse-cli-windows-x64.exe', installDir: path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'synapse-cli') },
+    };
+
+    const key = `${platform}-${arch}`;
+    const info = map[key];
+
+    if (!info) {
+        console.error(`\n  Plataforma nao suportada: ${platform}-${arch}`);
+        console.error(`  Plataformas suportadas: ${Object.keys(map).join(', ')}`);
+        console.error(`\n  Build from source: bun install && bun run compile\n`);
+        process.exit(1);
+    }
+
+    return info;
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// HTTP HELPERS
+// ═══════════════════════════════════════════════════════════════════
+
+function fetch(url, options = {}) {
+    return new Promise((resolve, reject) => {
+        const protocol = url.startsWith('https') ? https : http;
+        const headers = {
+            'User-Agent': `synapse-cli/${VERSION}`,
+            'Accept': options.accept || 'application/json',
+            ...options.headers,
+        };
+        // Add auth token for GitHub API requests (required for private repos)
+        if (GITHUB_TOKEN && url.includes('github.com')) {
+            headers['Authorization'] = `Bearer ${GITHUB_TOKEN}`;
+        }
+        const req = protocol.get(url, { headers }, (res) => {
+            // Follow redirects
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                return fetch(res.headers.location, options).then(resolve).catch(reject);
+            }
+
+            if (res.statusCode !== 200) {
+                reject(new Error(`HTTP ${res.statusCode}: ${url}`));
+                res.resume();
+                return;
+            }
+
+            if (options.stream) {
+                resolve(res);
+                return;
+            }
+
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+            res.on('error', reject);
+        });
+
+        req.on('error', reject);
+        req.setTimeout(30000, () => {
+            req.destroy();
+            reject(new Error(`Timeout: ${url}`));
+        });
+    });
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// DOWNLOAD & INSTALL
+// ═══════════════════════════════════════════════════════════════════
+
+async function downloadBinary(url, destPath) {
+    const res = await fetch(url, { accept: 'application/octet-stream', stream: true });
+    const totalSize = parseInt(res.headers['content-length'] || '0', 10);
+
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(destPath);
+        let downloaded = 0;
+        let lastPercent = -1;
+
+        res.on('data', (chunk) => {
+            downloaded += chunk.length;
+            if (totalSize > 0) {
+                const percent = Math.floor((downloaded / totalSize) * 100);
+                if (percent !== lastPercent && percent % 10 === 0) {
+                    process.stdout.write(`\r  Downloading... ${percent}%`);
+                    lastPercent = percent;
+                }
+            }
+        });
+
+        res.pipe(file);
+        file.on('finish', () => {
+            process.stdout.write('\r  Downloading... 100%\n');
+            file.close(resolve);
+        });
+        file.on('error', reject);
+        res.on('error', reject);
+    });
+}
+
+async function getChecksums(release) {
+    const checksumAsset = release.assets.find(a => a.name === 'SHA256SUMS.txt');
+    if (!checksumAsset) return {};
+
+    const checksumUrl = GITHUB_TOKEN ? checksumAsset.url : checksumAsset.browser_download_url;
+    const content = await fetch(checksumUrl, { accept: 'application/octet-stream' });
+    const checksums = {};
+    for (const line of content.split('\n')) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length === 2) {
+            checksums[parts[1]] = parts[0];
+        }
+    }
+    return checksums;
+}
+
+function verifySha256(filePath, expectedHash) {
+    const fileBuffer = fs.readFileSync(filePath);
+    const hash = crypto.createHash('sha256').update(fileBuffer).digest('hex');
+    return hash === expectedHash;
+}
+
+function isInPath(dir) {
+    const pathDirs = (process.env.PATH || '').split(path.delimiter);
+    return pathDirs.some(d => {
+        try {
+            return fs.realpathSync(d) === fs.realpathSync(dir);
+        } catch {
+            return d === dir;
+        }
+    });
+}
+
+async function install() {
+    const { binary, installDir } = getPlatformInfo();
+
+    console.log(`\n  Synapse CLI v${VERSION}`);
+    console.log(`  Binary: ${binary}`);
+    console.log(`  Install: ${installDir}`);
+    console.log(`  Auth: ${GITHUB_TOKEN ? 'token detected' : 'none (public repos only)'}\n`);
+
+    // Fetch release info
+    process.stdout.write('  Fetching release info...');
+    let release;
+    try {
+        const data = await fetch(RELEASE_URL);
+        release = JSON.parse(data);
+    } catch {
+        // Fallback to latest release
+        try {
+            const data = await fetch(LATEST_RELEASE_URL);
+            release = JSON.parse(data);
+        } catch (err) {
+            console.error(`\n\n  Falha ao buscar release: ${err.message}`);
+            if (!GITHUB_TOKEN) {
+                console.error('\n  O repositorio requer autenticacao. Configure um token:');
+                console.error('    export GITHUB_TOKEN=<seu-token>');
+                console.error('    # ou autentique com: gh auth login');
+            }
+            console.error(`\n  Baixe manualmente: https://github.com/${REPO}/releases\n`);
+            process.exit(1);
+        }
+    }
+    console.log(' OK');
+
+    // Find binary asset
+    const asset = release.assets.find(a => a.name === binary);
+    if (!asset) {
+        console.error(`\n  Binario nao encontrado na release: ${binary}`);
+        console.error(`  Assets disponiveis: ${release.assets.map(a => a.name).join(', ')}`);
+        console.error(`\n  Baixe manualmente: https://github.com/${REPO}/releases\n`);
+        process.exit(1);
+    }
+
+    // Create install directory
+    fs.mkdirSync(installDir, { recursive: true });
+    const destPath = path.join(installDir, os.platform() === 'win32' ? 'synapse-cli.exe' : 'synapse-cli');
+    const tmpPath = destPath + '.tmp';
+
+    // Download — use API URL for private repos (browser_download_url requires browser auth)
+    const downloadUrl = GITHUB_TOKEN
+        ? asset.url  // API URL: api.github.com/repos/.../releases/assets/{id}
+        : asset.browser_download_url;
+    await downloadBinary(downloadUrl, tmpPath);
+
+    // Verify checksum
+    process.stdout.write('  Verifying SHA256 checksum...');
+    const checksums = await getChecksums(release);
+    const expectedHash = checksums[binary];
+    if (expectedHash) {
+        if (verifySha256(tmpPath, expectedHash)) {
+            console.log(' OK');
+        } else {
+            console.log(' FAILED');
+            fs.unlinkSync(tmpPath);
+            console.error('\n  ERRO: Checksum invalido! O download pode estar corrompido.');
+            console.error(`  Baixe manualmente: https://github.com/${REPO}/releases\n`);
+            process.exit(1);
+        }
+    } else {
+        console.log(' (no checksum available, skipped)');
+    }
+
+    // Atomic move
+    if (fs.existsSync(destPath)) {
+        fs.unlinkSync(destPath);
+    }
+    fs.renameSync(tmpPath, destPath);
+
+    // Set executable permission on Unix
+    if (os.platform() !== 'win32') {
+        fs.chmodSync(destPath, 0o755);
+    }
+
+    console.log(`\n  Instalado: ${destPath}`);
+
+    // Check if install dir is in PATH
+    if (!isInPath(installDir)) {
+        console.log(`\n  Adicione ao PATH:`);
+        if (os.platform() === 'win32') {
+            console.log(`    setx PATH "%PATH%;${installDir}"`);
+        } else {
+            const shell = process.env.SHELL || '/bin/bash';
+            const rcFile = shell.includes('zsh') ? '~/.zshrc' : '~/.bashrc';
+            console.log(`    echo 'export PATH="${installDir}:$PATH"' >> ${rcFile}`);
+            console.log(`    source ${rcFile}`);
+        }
+    }
+
+    console.log(`\n  Execute: synapse-cli --help\n`);
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// HELP & VERSION
+// ═══════════════════════════════════════════════════════════════════
+
+function showVersion() {
+    console.log(`@ornexus/synapse-cli v${VERSION}`);
+    process.exit(0);
+}
+
+function showHelp() {
+    console.log('');
+    console.log(`  Synapse CLI Installer v${VERSION}`);
+    console.log('  Downloads and installs the native binary from GitHub Releases.');
+    console.log('');
+    console.log('  Usage: npx @ornexus/synapse-cli [options]');
+    console.log('');
+    console.log('  Options:');
+    console.log('    -v, --version    Show version');
+    console.log('    -h, --help       Show this help');
+    console.log('');
+    console.log('  Auth (for private repos):');
+    console.log('    export GITHUB_TOKEN=<token>   # or GH_TOKEN');
+    console.log('    gh auth login                  # or use gh CLI');
+    console.log('');
+    console.log('  The binary is self-contained with encrypted assets.');
+    console.log(`  Manual download: https://github.com/${REPO}/releases`);
+    console.log('');
+    process.exit(0);
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// MAIN
+// ═══════════════════════════════════════════════════════════════════
+
+if (args.includes('-v') || args.includes('--version')) showVersion();
+if (args.includes('-h') || args.includes('--help')) showHelp();
+
+install().catch(err => {
+    console.error(`\n  Erro: ${err.message}\n`);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,111 @@
+{
+  "name": "@ornexus/synapse-cli",
+  "version": "4.2.0",
+  "description": "Synapse CLI - AI Agent Orchestrator for multi-platform development (Claude Code, Cursor, VS Code, Gemini, Codex)",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "agent",
+    "orchestrator",
+    "development-workflow",
+    "epic",
+    "story",
+    "automation",
+    "ai-agent",
+    "llm",
+    "devops",
+    "ci-cd",
+    "git-workflow",
+    "pull-request",
+    "code-review"
+  ],
+  "author": {
+    "name": "OrNexus Team",
+    "url": "https://github.com/ornexus-ai"
+  },
+  "license": "MIT",
+  "workspaces": [
+    "packages/shared",
+    "packages/core",
+    "packages/cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/OrNexus-AI/synapse-cli.git"
+  },
+  "homepage": "https://github.com/OrNexus-AI/synapse-cli#readme",
+  "bugs": {
+    "url": "https://github.com/OrNexus-AI/synapse-cli/issues"
+  },
+  "bin": {
+    "synapse-cli": "install.js"
+  },
+  "files": [
+    "README.md",
+    "install.js",
+    "sync-version.js",
+    ".env.example"
+  ],
+  "scripts": {
+    "postinstall": "node -e \"console.log('\\nSynapse CLI v'+require('./package.json').version+' instalado!\\n\\nSetup: npx @ornexus/synapse-cli\\nBinarios: https://github.com/OrNexus-AI/synapse-cli/releases\\n')\"",
+    "sync": "node sync-version.js",
+    "prepublishOnly": "node sync-version.js && node -e \"console.log('Publishing Synapse CLI v'+require('./package.json').version)\"",
+    "version": "npm run sync && echo '🔖 Nova versão:' && cat package.json | grep version",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "bunx biome check packages/",
+    "lint:fix": "bunx biome check --fix packages/",
+    "bundle:assets": "bun run scripts/bundle-assets.ts",
+    "build": "bun run --filter '@synapse-cli/shared' build && bun run --filter '@synapse-cli/core' build && bun run --filter '@synapse-cli/cli' build",
+    "compile": "bun run bundle:assets && bun run build && bun run compile:all",
+    "compile:all": "bun run compile:linux-x64 && bun run compile:darwin-arm64 && bun run compile:darwin-x64 && bun run compile:windows-x64",
+    "compile:linux-x64": "bun build packages/cli/src/index.ts --compile --target=bun-linux-x64 --outfile dist/bin/synapse-cli-linux-x64",
+    "compile:darwin-arm64": "bun build packages/cli/src/index.ts --compile --target=bun-darwin-arm64 --outfile dist/bin/synapse-cli-darwin-arm64",
+    "compile:darwin-x64": "bun build packages/cli/src/index.ts --compile --target=bun-darwin-x64 --outfile dist/bin/synapse-cli-darwin-x64",
+    "compile:windows-x64": "bun build packages/cli/src/index.ts --compile --target=bun-windows-x64 --outfile dist/bin/synapse-cli-windows-x64.exe",
+    "build:publish": "bun run scripts/build-publish.ts",
+    "check": "bun run lint && bun run typecheck && bun run test"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/ornexus"
+  },
+  "overrides": {
+    "signal-exit": "3.0.7",
+    "ai": "4.3.19",
+    "hono": ">=4.12.2",
+    "jsondiffpatch": ">=0.7.2"
+  },
+  "resolutions": {
+    "ai": "4.3.19",
+    "hono": ">=4.12.2",
+    "jsondiffpatch": ">=0.7.2"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.0.1",
+    "@modelcontextprotocol/sdk": "1.27.1",
+    "ai": "4.3.19",
+    "execa": "^9.6.1",
+    "node-cache": "^5.1.2",
+    "picocolors": "^1.1.1",
+    "signal-exit": "3.0.7",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^3.2.4",
+    "react-devtools-core": "7.0.1",
+    "vitest": "^3.2.4"
+  }
+}

package/sync-version.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+/**
+ * Synapse - Version Sync Script
+ *
+ * Sincroniza a versão do package.json em todos os arquivos do projeto.
+ * Executado automaticamente no prepublishOnly.
+ *
+ * Uso: node sync-version.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Ler versão do package.json (fonte única de verdade)
+const pkg = require('./package.json');
+const VERSION = pkg.version;
+const VERSION_MAJOR_MINOR = VERSION.split('.').slice(0, 2).join('.');
+
+console.log(`\n🔄 Sincronizando versão ${VERSION} em todos os arquivos...\n`);
+
+// Definição dos arquivos e padrões a substituir
+const replacements = [
+  // Sub-package versions (shared, core, cli)
+  {
+    file: 'packages/shared/package.json',
+    patterns: [
+      [/"version": "[\d.]+"/g, `"version": "${VERSION}"`],
+    ]
+  },
+  {
+    file: 'packages/core/package.json',
+    patterns: [
+      [/"version": "[\d.]+"/g, `"version": "${VERSION}"`],
+    ]
+  },
+  {
+    file: 'packages/cli/package.json',
+    patterns: [
+      [/"version": "[\d.]+"/g, `"version": "${VERSION}"`],
+    ]
+  },
+  // synapse-cli.md
+  {
+    file: 'targets/claude-code/synapse-cli.md',
+    patterns: [
+      [/# Synapse v[\d.]+ -/g, `# Synapse v${VERSION} -`],
+      [/SYNAPSE-CLI v[\d.]+ \(state\.json\)/g, `SYNAPSE-CLI v${VERSION} (state.json)`],
+    ]
+  },
+  // synapse-cli.agent.yaml
+  {
+    file: 'targets/claude-code/synapse-cli.agent.yaml',
+    patterns: [
+      [/version: '[\d.]+'/g, `version: '${VERSION}'`],
+      [/SYNAPSE-CLI v[\d.]+ \(External Claude CLI\)/g, `SYNAPSE-CLI v${VERSION} (External Claude CLI)`],
+    ]
+  },
+  // install.sh
+  {
+    file: 'install.sh',
+    patterns: [
+      [/VERSION="[\d.]+"/g, `VERSION="${VERSION}"`],
+    ]
+  },
+  // install.ps1
+  {
+    file: 'install.ps1',
+    patterns: [
+      [/\$VERSION = "[\d.]+"/g, `$VERSION = "${VERSION}"`],
+    ]
+  },
+  // core/data/state-template.json
+  {
+    file: 'core/data/state-template.json',
+    patterns: [
+      [/"version": "[\d.]+"/g, `"version": "${VERSION}"`],
+      [/"synapse_cli_version": "[\d.]+"/g, `"synapse_cli_version": "${VERSION}"`],
+    ]
+  },
+  // core/data/step-registry.json
+  {
+    file: 'core/data/step-registry.json',
+    patterns: [
+      [/"version": "[\d.]+"/g, `"version": "${VERSION}"`],
+    ]
+  },
+  // core/data/state-utils.md
+  {
+    file: 'core/data/state-utils.md',
+    patterns: [
+      [/# State Utilities - Synapse v[\d.]+/g, `# State Utilities - Synapse v${VERSION}`],
+    ]
+  },
+  // core/data/worktree-sync.md
+  {
+    file: 'core/data/worktree-sync.md',
+    patterns: [
+      [/# Worktree Synchronization Utilities - Synapse v[\d.]+/g, `# Worktree Synchronization Utilities - Synapse v${VERSION}`],
+    ]
+  },
+  // core/data/worktree-sync-functions.sh
+  {
+    file: 'core/data/worktree-sync-functions.sh',
+    patterns: [
+      [/# Synapse - Worktree Sync Functions v[\d.]+/g, `# Synapse - Worktree Sync Functions v${VERSION}`],
+    ]
+  },
+  // targets/claude-code/workflow.md
+  {
+    file: 'targets/claude-code/workflow.md',
+    patterns: [
+      [/Synapse v[\d.]+/g, `Synapse v${VERSION}`],
+    ]
+  },
+  // Platform agent files
+  {
+    file: 'targets/cursor/agent.md',
+    patterns: [
+      [/# Synapse v[\d.]+ -/g, `# Synapse v${VERSION} -`],
+    ]
+  },
+  {
+    file: 'targets/vscode/agent.md',
+    patterns: [
+      [/# Synapse v[\d.]+ -/g, `# Synapse v${VERSION} -`],
+    ]
+  },
+  {
+    file: 'targets/gemini-cli/agent.md',
+    patterns: [
+      [/# Synapse v[\d.]+ -/g, `# Synapse v${VERSION} -`],
+    ]
+  },
+  {
+    file: 'targets/codex/agents.md',
+    patterns: [
+      [/# Synapse v[\d.]+ -/g, `# Synapse v${VERSION} -`],
+    ]
+  },
+  {
+    file: 'targets/antigravity/gemini.md',
+    patterns: [
+      [/Synapse v[\d.]+/g, `Synapse v${VERSION}`],
+    ]
+  },
+  {
+    file: 'targets/antigravity/skill/SKILL.md',
+    patterns: [
+      [/Synapse v[\d.]+/g, `Synapse v${VERSION}`],
+    ]
+  },
+];
+
+let filesUpdated = 0;
+let totalReplacements = 0;
+
+for (const { file, patterns } of replacements) {
+  const filePath = path.join(__dirname, file);
+
+  if (!fs.existsSync(filePath)) {
+    console.log(`  ⚠️  ${file} não encontrado, pulando...`);
+    continue;
+  }
+
+  let content = fs.readFileSync(filePath, 'utf8');
+  let fileReplacements = 0;
+
+  for (const [pattern, replacement] of patterns) {
+    const matches = content.match(pattern);
+    if (matches) {
+      content = content.replace(pattern, replacement);
+      fileReplacements += matches.length;
+    }
+  }
+
+  if (fileReplacements > 0) {
+    fs.writeFileSync(filePath, content);
+    console.log(`  ✅ ${file} (${fileReplacements} substituição(ões))`);
+    filesUpdated++;
+    totalReplacements += fileReplacements;
+  } else {
+    console.log(`  ⏭️  ${file} (já atualizado)`);
+  }
+}
+
+console.log(`\n✨ Sincronização completa: ${filesUpdated} arquivo(s), ${totalReplacements} substituição(ões)\n`);