bortexcode 1.2.1

package/README.md

@@ -0,0 +1,108 @@
+# Bortex Code CLI
+
+Terminal AI coding assistant powered by https://bortex.site.
+
+## Install
+
+After publishing to npm:
+
+```bash
+npm install -g bortexcode
+```
+
+Fallback installer:
+
+```bash
+curl -fsSL https://bortex.site/install.sh | bash
+```
+
+Windows PowerShell:
+
+```powershell
+irm https://bortex.site/install.ps1 | iex
+```
+
+Direct tarball fallback:
+
+```bash
+npm install -g https://bortex.site/bortex-code/bortex-code-latest.tgz
+```
+
+## Login
+
+```bash
+bortexcode --login
+```
+
+Or provide an API key:
+
+```bash
+bortexcode --api-key <YOUR_API_KEY>
+export BORTEX_API_KEY=<YOUR_API_KEY>
+```
+
+## Usage
+
+```bash
+bortexcode
+bortexcode "explain this function"
+bortexcode --agent "refactor src/utils.js"
+```
+
+## REPL Commands
+
+Press `/` at the beginning of the prompt to open the command menu.
+Press Tab to complete slash commands.
+
+Common commands:
+
+```text
+/agent on|off
+/status
+/commands
+/help
+/llm-config show
+/llm-config sync
+/exit
+```
+
+## Options
+
+```text
+-a, --agent         Agent mode
+    --chat          Chat mode (default)
+-u, --url <url>     Bortex server URL
+    --api-key <k>   API key
+    --login         Open browser login
+-m, --model <name>  Force a specific LLM model
+    --api-url <u>   Custom LLM endpoint
+    --offline       Local mode
+    --verbose       Show routing details
+    --progress      Show server progress events
+    --no-spinner    Disable spinner
+    --icons         Enable icon output
+    --check-update  Check for updates now
+    --no-update-check
+                    Disable startup update check
+-v, --version       Show version
+-h, --help          Show help
+```
+
+## Updates
+
+Bortex Code checks for newer versions on startup. When an update is available,
+it asks before installing it globally with npm.
+
+```bash
+bortexcode --check-update
+bortexcode --no-update-check
+```
+
+## Environment
+
+```text
+BORTEX_URL
+BORTEX_API_KEY
+BORTEX_CLI_ICONS=1
+BORTEX_NO_UPDATE_CHECK=1
+```

package/bin/bortex-agent.js

@@ -0,0 +1,472 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const packageMeta = require('../package.json');
+const { getAgentsCatalogFallbackPath } = require('./bortex-shared-paths');
+
+const DEFAULT_URL = process.env.BORTEX_AGENT_URL || process.env.BORTEX_URL || 'https://bortex.site';
+const DEFAULT_SERVER_WAIT_MS = 30000;
+const AGENT_CATALOG_FALLBACK = getAgentsCatalogFallbackPath();
+const CLI_VERSION = String(packageMeta.version || '0.0.0');
+
+function getInvokedCliName() {
+  const scriptPath = String(process.argv[1] || '').trim();
+  const baseName = scriptPath ? path.basename(scriptPath, path.extname(scriptPath)) : '';
+  return baseName || 'bortexcode-agent';
+}
+
+function printUsage() {
+  const cliName = getInvokedCliName();
+  console.log('Bortex Agent CLI');
+  console.log('');
+  console.log('Uso:');
+  console.log(`  ${cliName} list [--url http://127.0.0.1:3210]`);
+  console.log(`  ${cliName} health [--url http://127.0.0.1:3210]`);
+  console.log(`  ${cliName} run (--id <id> | --name <name> | --file <manifest>) [--input "testo"]`);
+  console.log(`  ${cliName} stop [--run-id <id> | --all]`);
+  console.log('');
+  console.log('Opzioni:');
+  console.log('  --url <url>           URL del server locale Bortex');
+  console.log('  --id <id>             Avvia un agente dal catalogo tramite id');
+  console.log('  --name <name>         Avvia un agente dal catalogo tramite nome');
+  console.log('  --file <path>         Avvia un agente esportato da manifest .bortex-agent.json');
+  console.log('  --input <text>        Messaggio iniziale / prompt agente');
+  console.log('  --outputs <csv>       Override outputs agente, es. inapp,push');
+  console.log('  --run-id <id>         Run id esplicito');
+  console.log('  --all                 Ferma tutte le run locali');
+  console.log('  --json                Output JSON dove possibile');
+  console.log('  --no-wait             Non attendere l avvio del server locale');
+  console.log('  -v, --version         Mostra versione');
+  console.log('  -h, --help            Mostra aiuto');
+}
+
+function parseArgs(argv) {
+  const args = Array.isArray(argv) ? [...argv] : [];
+  const initial = String(args[0] || '').trim();
+  const command = !initial || initial.startsWith('-')
+    ? 'help'
+    : String(args.shift() || 'help').trim().toLowerCase();
+  const options = {
+    command,
+    url: DEFAULT_URL,
+    id: '',
+    name: '',
+    file: '',
+    input: '',
+    outputs: [],
+    json: false,
+    waitForServer: true,
+    runId: '',
+    stopAll: false
+  };
+  const positional = [];
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+      continue;
+    }
+    if (arg === '--version' || arg === '-v') {
+      options.version = true;
+      continue;
+    }
+    if (arg === '--json') {
+      options.json = true;
+      continue;
+    }
+    if (arg === '--no-wait') {
+      options.waitForServer = false;
+      continue;
+    }
+    if (arg === '--all') {
+      options.stopAll = true;
+      continue;
+    }
+    if ((arg === '--url' || arg === '-u') && args[i + 1]) {
+      options.url = String(args[i + 1] || '').trim() || options.url;
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--url=')) {
+      options.url = String(arg.slice('--url='.length) || '').trim() || options.url;
+      continue;
+    }
+    if (arg === '--id' && args[i + 1]) {
+      options.id = String(args[i + 1] || '').trim();
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--id=')) {
+      options.id = String(arg.slice('--id='.length) || '').trim();
+      continue;
+    }
+    if (arg === '--name' && args[i + 1]) {
+      options.name = String(args[i + 1] || '').trim();
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--name=')) {
+      options.name = String(arg.slice('--name='.length) || '').trim();
+      continue;
+    }
+    if (arg === '--file' && args[i + 1]) {
+      options.file = String(args[i + 1] || '').trim();
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--file=')) {
+      options.file = String(arg.slice('--file='.length) || '').trim();
+      continue;
+    }
+    if (arg === '--input' && args[i + 1]) {
+      options.input = String(args[i + 1] || '');
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--input=')) {
+      options.input = String(arg.slice('--input='.length) || '');
+      continue;
+    }
+    if (arg === '--outputs' && args[i + 1]) {
+      options.outputs = String(args[i + 1] || '')
+        .split(',')
+        .map((entry) => String(entry || '').trim())
+        .filter(Boolean);
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--outputs=')) {
+      options.outputs = String(arg.slice('--outputs='.length) || '')
+        .split(',')
+        .map((entry) => String(entry || '').trim())
+        .filter(Boolean);
+      continue;
+    }
+    if (arg === '--run-id' && args[i + 1]) {
+      options.runId = String(args[i + 1] || '').trim();
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--run-id=')) {
+      options.runId = String(arg.slice('--run-id='.length) || '').trim();
+      continue;
+    }
+    positional.push(arg);
+  }
+
+  if (!options.input && positional.length && options.command === 'run') {
+    options.input = positional.join(' ').trim();
+  }
+
+  return options;
+}
+
+function normalizeBaseUrl(url) {
+  return String(url || DEFAULT_URL).trim().replace(/\/+$/, '') || DEFAULT_URL;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function requestJson(method, url, payload = null, extraHeaders = {}) {
+  const headers = {
+    Accept: 'application/json',
+    ...extraHeaders
+  };
+  const init = { method, headers };
+  if (payload !== null && payload !== undefined) {
+    headers['Content-Type'] = 'application/json';
+    init.body = JSON.stringify(payload);
+  }
+  const res = await fetch(url, init);
+  const rawText = await res.text();
+  let data = null;
+  if (rawText) {
+    try {
+      data = JSON.parse(rawText);
+    } catch (_) {
+      data = rawText;
+    }
+  }
+  if (!res.ok) {
+    const detail = data && typeof data === 'object'
+      ? (data.error || data.message || JSON.stringify(data))
+      : String(data || res.statusText || 'Request failed').trim();
+    throw new Error(`HTTP ${res.status}: ${detail}`);
+  }
+  return data;
+}
+
+async function waitForServer(baseUrl, timeoutMs = DEFAULT_SERVER_WAIT_MS) {
+  const startedAt = Date.now();
+  let lastError = null;
+  while ((Date.now() - startedAt) < timeoutMs) {
+    try {
+      const health = await requestJson('GET', `${baseUrl}/health`);
+      if (health && (health.ok === true || health.status === 'ok')) {
+        return health;
+      }
+    } catch (err) {
+      lastError = err;
+    }
+    await sleep(1000);
+  }
+  if (lastError) throw lastError;
+  throw new Error('Server Bortex non raggiungibile.');
+}
+
+function loadManifestAgent(filePath) {
+  const resolved = path.resolve(filePath);
+  const raw = fs.readFileSync(resolved, 'utf8');
+  const parsed = JSON.parse(raw);
+  if (parsed?.agent && typeof parsed.agent === 'object') return parsed.agent;
+  if (Array.isArray(parsed?.agents) && parsed.agents.length) return parsed.agents[0];
+  if (parsed && typeof parsed === 'object') return parsed;
+  throw new Error('Manifest agente non valido.');
+}
+
+function loadCatalogFallback() {
+  if (!fs.existsSync(AGENT_CATALOG_FALLBACK)) return [];
+  try {
+    const raw = fs.readFileSync(AGENT_CATALOG_FALLBACK, 'utf8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch (_) {
+    return [];
+  }
+}
+
+function printAgentList(agents = [], asJson = false) {
+  if (asJson) {
+    console.log(JSON.stringify({ ok: true, agents }, null, 2));
+    return;
+  }
+  if (!agents.length) {
+    console.log('Nessun agente trovato.');
+    return;
+  }
+  agents.forEach((agent) => {
+    const runtimeProfile = String(agent?.runtimeProfile || '').trim();
+    const mission = String(agent?.mission || '').trim();
+    console.log(`- ${agent.id || '(senza id)'} | ${agent.name || 'Agente'}`);
+    if (runtimeProfile) console.log(`  runtime: ${runtimeProfile}`);
+    if (mission) console.log(`  mission: ${mission}`);
+  });
+}
+
+function formatProgressLine(step = {}) {
+  const type = String(step?.type || 'step').trim();
+  const action = String(step?.action || '').trim();
+  const text = String(step?.text || step?.thought || '').trim();
+  if (type === 'tool_result') {
+    return `[${type}] ${action || 'tool'} ok`;
+  }
+  if (action && text) return `[${type}] ${action} - ${text}`;
+  if (action) return `[${type}] ${action}`;
+  if (text) return `[${type}] ${text}`;
+  return `[${type}]`;
+}
+
+async function streamAgentRun(baseUrl, payload, asJson = false) {
+  const res = await fetch(`${baseUrl}/agents/run`, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/x-ndjson, application/json',
+      'Content-Type': 'application/json',
+      'x-bortex-progress': '1'
+    },
+    body: JSON.stringify({ ...payload, progress: true })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`HTTP ${res.status}: ${text || res.statusText}`);
+  }
+
+  if (!res.body) {
+    throw new Error('Stream progress non disponibile.');
+  }
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let finalResult = null;
+
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    let newlineIndex = buffer.indexOf('\n');
+    while (newlineIndex !== -1) {
+      const line = buffer.slice(0, newlineIndex).trim();
+      buffer = buffer.slice(newlineIndex + 1);
+      if (line) {
+        const event = JSON.parse(line);
+        if (event.type === 'progress') {
+          const step = event?.data?.step || event?.data || {};
+          if (asJson) {
+            console.log(JSON.stringify(event));
+          } else {
+            console.log(formatProgressLine(step));
+          }
+        } else if (event.type === 'result') {
+          finalResult = event;
+        }
+      }
+      newlineIndex = buffer.indexOf('\n');
+    }
+  }
+
+  if (!finalResult) {
+    throw new Error('Run agente terminata senza risultato finale.');
+  }
+  if (finalResult.status !== 'success') {
+    throw new Error(finalResult.error || 'Run agente fallita.');
+  }
+  return finalResult.data || null;
+}
+
+async function handleListCommand(options) {
+  const baseUrl = normalizeBaseUrl(options.url);
+  try {
+    if (options.waitForServer) await waitForServer(baseUrl);
+    const data = await requestJson('GET', `${baseUrl}/agents`);
+    printAgentList(Array.isArray(data?.agents) ? data.agents : [], options.json);
+  } catch (err) {
+    const fallback = loadCatalogFallback().map((agent) => ({
+      id: agent?.id || '',
+      name: agent?.name || '',
+      mission: agent?.mission || '',
+      runtimeProfile: agent?.runtimeProfile || ''
+    }));
+    if (!fallback.length) {
+      throw new Error(`Catalogo agenti non disponibile da ${baseUrl} e nessun catalogo sincronizzato trovato in locale.`);
+    }
+    printAgentList(fallback, options.json);
+  }
+}
+
+async function handleHealthCommand(options) {
+  const baseUrl = normalizeBaseUrl(options.url);
+  const data = await requestJson('GET', `${baseUrl}/health`);
+  if (options.json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  console.log(`Server Bortex online su ${baseUrl}`);
+}
+
+async function handleRunCommand(options) {
+  const baseUrl = normalizeBaseUrl(options.url);
+  const runId = options.runId || `cli_${Date.now()}`;
+  if (options.waitForServer) {
+    await waitForServer(baseUrl);
+  }
+
+  const payload = { runId };
+  if (options.input) payload.userMessage = options.input;
+  if (options.outputs.length) payload.agentOutputs = options.outputs;
+  if (options.file) {
+    payload.agentConfig = loadManifestAgent(options.file);
+  } else if (options.id) {
+    payload.agentId = options.id;
+  } else if (options.name) {
+    payload.agentName = options.name;
+  } else {
+    throw new Error('Per run serve --id, --name oppure --file.');
+  }
+
+  let stopping = false;
+  const stopHandler = async () => {
+    if (stopping) return;
+    stopping = true;
+    try {
+      await requestJson('POST', `${baseUrl}/agents/stop`, { runId });
+      console.error(`Run ${runId} fermata.`);
+    } catch (err) {
+      console.error(`Stop run ${runId} fallita: ${err.message}`);
+    } finally {
+      process.exit(130);
+    }
+  };
+  process.once('SIGINT', stopHandler);
+  process.once('SIGTERM', stopHandler);
+
+  try {
+    const result = await streamAgentRun(baseUrl, payload, options.json);
+    if (options.json) {
+      console.log(JSON.stringify({ ok: true, runId, result }, null, 2));
+    } else {
+      console.log(`Run completata: ${runId}`);
+    }
+  } finally {
+    process.removeListener('SIGINT', stopHandler);
+    process.removeListener('SIGTERM', stopHandler);
+  }
+}
+
+async function handleStopCommand(options) {
+  const baseUrl = normalizeBaseUrl(options.url);
+  if (options.waitForServer) {
+    await waitForServer(baseUrl);
+  }
+  const payload = options.stopAll ? {} : { runId: options.runId };
+  if (!options.stopAll && !payload.runId) {
+    throw new Error('Per stop serve --run-id oppure --all.');
+  }
+  const result = await requestJson('POST', `${baseUrl}/agents/stop`, payload);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (options.stopAll) {
+    console.log('Stop richiesto per tutte le run agent locali.');
+  } else {
+    console.log(`Stop richiesto per run ${options.runId}.`);
+  }
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.version) {
+    console.log(CLI_VERSION);
+    return;
+  }
+  if (options.help || !options.command || options.command === 'help') {
+    printUsage();
+    return;
+  }
+  if (options.command === 'list') {
+    await handleListCommand(options);
+    return;
+  }
+  if (options.command === 'health') {
+    await handleHealthCommand(options);
+    return;
+  }
+  if (options.command === 'run') {
+    await handleRunCommand(options);
+    return;
+  }
+  if (options.command === 'stop') {
+    await handleStopCommand(options);
+    return;
+  }
+  throw new Error(`Comando non supportato: ${options.command}`);
+}
+
+if (require.main === module) {
+  main().catch((err) => {
+    console.error(err?.message || err);
+    process.exit(1);
+  });
+} else {
+  module.exports = {
+    parseArgs,
+    main
+  };
+}

package/bin/bortex-shared-paths.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const APPDATA_DIR_NAME = 'bortexcode';
+const LEGACY_APPDATA_DIR_NAME = 'coding-agent-editor';
+const SETTINGS_FILE_NAME = 'bortex-settings.json';
+const AGENTS_CATALOG_FILE_NAME = 'agents-catalog.runtime-generic.v2.json';
+
+// Cross-platform config root:
+//   Windows  → %APPDATA%\bortexcode\
+//   macOS    → ~/Library/Application Support/bortexcode/
+//   Linux    → ~/.config/bortexcode/  (rispetta XDG_CONFIG_HOME)
+function getAppDataRoot() {
+  if (process.platform === 'win32') {
+    return process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+  }
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support');
+  }
+  return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+}
+
+function getLegacySharedDir() {
+  return path.join(getAppDataRoot(), LEGACY_APPDATA_DIR_NAME);
+}
+
+function getPreferredSharedDir() {
+  return path.join(getAppDataRoot(), APPDATA_DIR_NAME);
+}
+
+function resolveSharedDir() {
+  const preferredDir = getPreferredSharedDir();
+  const legacyDir = getLegacySharedDir();
+  try {
+    if (fs.existsSync(preferredDir)) return preferredDir;
+  } catch (_err) { }
+  try {
+    if (fs.existsSync(legacyDir)) return legacyDir;
+  } catch (_err) { }
+  return preferredDir;
+}
+
+function getSharedSettingsPath() {
+  return path.join(resolveSharedDir(), SETTINGS_FILE_NAME);
+}
+
+function getAgentsCatalogFallbackPath() {
+  return path.join(resolveSharedDir(), AGENTS_CATALOG_FILE_NAME);
+}
+
+module.exports = {
+  APPDATA_DIR_NAME,
+  LEGACY_APPDATA_DIR_NAME,
+  SETTINGS_FILE_NAME,
+  AGENTS_CATALOG_FILE_NAME,
+  getAppDataRoot,
+  getLegacySharedDir,
+  getPreferredSharedDir,
+  resolveSharedDir,
+  getSharedSettingsPath,
+  getAgentsCatalogFallbackPath
+};