osai-agent 4.0.0

package/src/agent/subagent.js

@@ -0,0 +1,263 @@
+// =============================================================================
+// OS AI Agent — Subagent Runner (max 1 concurrent)
+// =============================================================================
+// Spawns a read-only child agent for exploration. Results are returned to the
+// parent via structured [SUBAGENT_RESULT] tool output.
+// =============================================================================
+
+import { AgentLoop } from './react-loop.js';
+import { SUBAGENT_MAX_ITERATIONS } from '../utils/constants.js';
+import { logger } from '../utils/logger.js';
+
+let _subagentCounter = 0;
+const STREAM_SUBAGENT_TO_PARENT = process.env.OSAI_SUBAGENT_STREAM === '1';
+
+function nextSubagentId() {
+  _subagentCounter += 1;
+  return `subagent-${Date.now()}-${_subagentCounter}`;
+}
+
+function emitSubagentObservation(parent, payload) {
+  if (typeof parent.onObservation === 'function') {
+    parent.onObservation(payload);
+  }
+}
+
+/**
+ * Run a single read-only subagent and return findings to the parent agent.
+ * @param {import('./react-loop.js').AgentLoop} parent
+ * @param {{ prompt: string, description?: string }} task
+ */
+export async function runSubagent(parent, { prompt, description = '' }) {
+  const cleanPrompt = String(prompt || '').trim();
+  const cleanDescription = String(description || '').trim();
+
+  if (!cleanPrompt) {
+    return {
+      success: false,
+      output: '',
+      error: 'Subagent task is empty. Provide a concrete exploration prompt.',
+      subagentLaunched: false,
+    };
+  }
+
+  if (parent.isSubagent) {
+    return {
+      success: false,
+      output: '',
+      error: 'Nested subagents are not allowed. The parent agent must handle this task directly.',
+      subagentLaunched: false,
+    };
+  }
+
+  if (parent._subagentActive) {
+    return {
+      success: false,
+      output: '',
+      error: 'A subagent is already running. Wait for it to finish before launching another (max 1 subagent).',
+      subagentLaunched: false,
+    };
+  }
+
+  const subagentId = nextSubagentId();
+  const label = cleanDescription || cleanPrompt.slice(0, 80);
+  const startedAt = Date.now();
+
+  parent._subagentActive = true;
+  parent._escapeFirstPress = false;
+  parent._subagentState = {
+    id: subagentId,
+    description: label,
+    status: 'running',
+    startedAt,
+    endedAt: null,
+    iterations: 0,
+    toolsUsed: 0,
+  };
+
+  emitSubagentObservation(parent, {
+    type: 'subagent_start',
+    id: subagentId,
+    description: label,
+    prompt: cleanPrompt.slice(0, 500),
+  });
+
+  let subLoop = null;
+
+  try {
+    let completionPayload = null;
+    const transcript = [];
+    let toolsUsed = 0;
+    let estimatedTokens = 0;
+    const parentBaseTokens = Number(parent.totalTokensUsed || 0);
+
+     subLoop = new AgentLoop({
+       device: parent.device,
+       mode: parent.mode,
+       executionMode: 'PLAN',
+       server: parent.server,
+       token: parent.token,
+       noConfirm: true,
+       isSubagent: true,
+       maxIterations: SUBAGENT_MAX_ITERATIONS,
+       readline: parent.readline,
+       onMarkdown: (text) => {
+         transcript.push(text);
+         if (STREAM_SUBAGENT_TO_PARENT) parent.onMarkdown(text);
+       },
+       onUpdateLastText: (text) => {
+         if (STREAM_SUBAGENT_TO_PARENT) parent.onUpdateLastText(text);
+       },
+       onThought: (text) => {
+         if (STREAM_SUBAGENT_TO_PARENT) parent.onThought(text);
+       },
+       onToolStart: (tc, safety) => {
+         toolsUsed += 1;
+         if (parent._subagentState) parent._subagentState.toolsUsed = toolsUsed;
+         emitSubagentObservation(parent, {
+           type: 'subagent_progress',
+           id: subagentId,
+           tool: tc.tool,
+           target: tc.path || tc.cmd || tc.query || tc.url || '',
+         });
+         parent.onToolStart({ ...tc, _subagent: true, _subagentId: subagentId }, safety);
+       },
+       onToolResult: (tc, res) => parent.onToolResult({ ...tc, _subagent: true, _subagentId: subagentId }, res),
+       onObservation: (observation) => {
+         if (STREAM_SUBAGENT_TO_PARENT) parent.onObservation(observation);
+       },
+       onError: (msg) => {
+         transcript.push(`[ERROR] ${msg}`);
+         if (STREAM_SUBAGENT_TO_PARENT) parent.onError(`Subagent: ${msg}`);
+       },
+       onComplete: (stats) => {
+         completionPayload = stats;
+       },
+       onTodos: () => {},
+       onBlocked: (msg) => transcript.push(`[BLOCKED] ${msg}`),
+       onThinkingStart: () => {},
+       onThinkingEnd: () => {},
+       onBadge: () => {},
+       onStats: (tokens) => {
+         estimatedTokens = Number(tokens || 0);
+         if (parent._subagentState) parent._subagentState.estimatedTokens = estimatedTokens;
+         emitSubagentObservation(parent, {
+           type: 'subagent_stats',
+           id: subagentId,
+           estimatedTokens,
+           totalEstimatedTokens: parentBaseTokens + estimatedTokens,
+         });
+         parent.onStats(parentBaseTokens + estimatedTokens);
+       },
+       onConfirmPrompt: () => {},
+       onAskUserPrompt: () => {},
+       onPlanPrompt: () => {},
+       onConnectionChange: () => {},
+     });
+
+     // Store reference to subagent loop for cancellation
+     parent._subagentLoop = subLoop;
+
+    await subLoop.run(
+      `${cleanPrompt}\n\n[SUBAGENT RULES]
+- You are a read-only exploration subagent working on behalf of the parent agent.
+- Do NOT modify files, run write commands, create skills, or spawn another subagent.
+- Do NOT ask the user for confirmation. If a file/path/tool requires confirmation or is blocked as sensitive, skip it, continue with other non-sensitive read-only exploration, and mention the skipped target in your final summary.
+- Allowed: READ_FILE, GLOB, GREP, LIST_DIR, TREE_VIEW, FILE_INFO, FETCH_URL, WEB_SEARCH, LOCAL_CMD (read-only), GIT (status/diff/log/branch only).
+- You must use tools to gather facts. Do not answer from assumptions.
+- When finished, write a clear summary with file paths and key facts.
+- End with [DONE] and a concise summary the parent agent can act on.`,
+    );
+
+    const history = subLoop.getConversationHistory();
+    const lastAssistant = [...history].reverse().find((m) => m.role === 'assistant');
+    const findings = lastAssistant?.content?.trim() || transcript.join('\n').trim() || 'Subagent finished with no summary.';
+    const iterations = completionPayload?.iterations || subLoop.iteration;
+    const completionSignal = completionPayload?.completionSignal || 'DONE';
+    const endedAt = Date.now();
+
+    parent._subagentState = {
+      ...parent._subagentState,
+      status: 'completed',
+      endedAt,
+      iterations,
+      toolsUsed,
+      estimatedTokens,
+      completionSignal,
+      findingsPreview: findings.slice(0, 200),
+    };
+    parent._lastSubagentResult = { id: subagentId, findings, iterations, completionSignal, estimatedTokens };
+
+    emitSubagentObservation(parent, {
+      type: 'subagent_end',
+      id: subagentId,
+      success: true,
+      iterations,
+      toolsUsed,
+      estimatedTokens,
+      totalEstimatedTokens: parentBaseTokens + estimatedTokens,
+      completionSignal,
+      durationMs: endedAt - startedAt,
+      findingsPreview: findings.slice(0, 200),
+      findings: findings.slice(0, 8000),
+    });
+
+    const output = [
+      `[SUBAGENT_COMPLETE] id=${subagentId}`,
+      `Status: SUCCESS`,
+      `Iterations: ${iterations}`,
+      `Tools used: ${toolsUsed}`,
+      `Estimated tokens: ${estimatedTokens}`,
+      `Completion: ${completionSignal}`,
+      label ? `Task: ${label}` : '',
+      '',
+      '--- FINDINGS (use these to continue your work) ---',
+      findings.slice(0, 12000),
+      '',
+      'The subagent has finished. Review the findings above and continue as the parent agent.',
+    ].filter(Boolean).join('\n');
+
+    return {
+      success: true,
+      output,
+      subagentLaunched: true,
+      subagentId,
+      iterations,
+      toolsUsed,
+      estimatedTokens,
+      completionSignal,
+      findings,
+    };
+  } catch (err) {
+    logger.error('Subagent failed', { error: err.message });
+
+    parent._subagentState = {
+      ...parent._subagentState,
+      status: 'failed',
+      endedAt: Date.now(),
+      error: err.message,
+    };
+
+    emitSubagentObservation(parent, {
+      type: 'subagent_end',
+      id: subagentId,
+      success: false,
+      error: err.message,
+    });
+
+    return {
+      success: false,
+      output: '',
+      error: `Subagent failed: ${err.message}`,
+      subagentLaunched: true,
+      subagentId,
+    };
+   } finally {
+      parent._subagentActive = false;
+      parent._subagentLoop = null;
+      parent._escapeFirstPress = false;
+     if (subLoop) {
+       try { await subLoop.cleanup(); } catch {}
+     }
+   }
+}

package/src/commands/config.js

@@ -0,0 +1,53 @@
+import Conf from 'conf';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { printInfo, printSuccess } from '../ui/terminal.js';
+import { APP_VERSION } from '../utils/constants.js';
+
+export const detectDefaultOS = () => {
+  const p = process.platform;
+  if (p === 'win32') return 'windows';
+  if (p === 'darwin') return 'macos';
+  return 'linux';
+};
+
+export const showConfig = () => {
+  const config = new Conf({ projectName: 'osai-agent' });
+  const os = config.get('os') || `${detectDefaultOS()} (auto-detected)`;
+  printInfo(`Version:    ${APP_VERSION}`);
+  printInfo(`Server:     ${config.get('server') || 'not configured'}`);
+  printInfo(`Token:      ${config.get('token') ? 'present' : 'absent'}`);
+  printInfo(`User ID:    ${config.get('userId') || 'absent'}`);
+  printInfo(`Plan:       ${config.get('plan') || 'absent'}`);
+  printInfo(`OS:         ${os}`);
+  printInfo(`Auto-cont:  ${process.env.OSAI_AUTO_CONTINUE || '3 (default)'}`);
+  printInfo(`Max iter:   ${process.env.OSAI_MAX_ITERATIONS || '30 (default)'}`);
+  printInfo(`Debug:      ${process.env.OSAI_DEBUG || 'false (default)'}`);
+};
+
+export const setOS = async () => {
+  const config = new Conf({ projectName: 'osai-agent' });
+  const current = config.get('os');
+  const answer = await inquirer.prompt({
+    type: 'list', name: 'os', message: 'Select your operating system',
+    default: current || detectDefaultOS(),
+    choices: [{ name: 'Windows', value: 'windows' }, { name: 'macOS', value: 'macos' }, { name: 'Linux', value: 'linux' }]
+  });
+  config.set('os', answer.os);
+  printSuccess(`OS configured: ${answer.os}`);
+};
+
+export const showOS = () => {
+  const config = new Conf({ projectName: 'osai-agent' });
+  const os = config.get('os');
+  if (!os) {
+    printInfo(`OS: not configured (auto-detected: ${detectDefaultOS()})`);
+    printInfo('To set explicitly: osai-agent config set-os');
+    return;
+  }
+  printInfo(`OS: ${os}`);
+};
+
+export const showVersion = () => {
+  console.log(chalk.hex('#7aa2f7').bold(`OS AI Agent v${APP_VERSION}`));
+};

package/src/commands/connect.js

@@ -0,0 +1,190 @@
+import pkg from 'node-machine-id';
+const { machineIdSync } = pkg;
+import { execSync } from 'child_process';
+import Conf from 'conf';
+import inquirer from 'inquirer';
+import { render } from 'ink';
+import { App } from '../ui/App.js';
+import { h } from '../ui/h.js';
+import { AgentLoop } from '../agent/react-loop.js';
+import { decrypt, deriveKey } from '../services/crypto.js';
+import { toHttpUrl, toWsUrl } from '../services/server-url.js';
+import { MODES } from '../utils/constants.js';
+import { printNotLoggedIn } from '../ui/terminal.js';
+import ora from 'ora';
+import { connectSSH } from '../services/ssh.js';
+
+export const connect = async ({ device: deviceOverride, server: serverOverride, noConfirm = false } = {}) => {
+  const config = new Conf({ projectName: 'osai-agent' });
+  const token = config.get('token');
+  const server = toWsUrl(serverOverride ? `ws://${serverOverride}` : config.get('server'));
+  const httpServer = toHttpUrl(server);
+
+  if (!token) { printNotLoggedIn(); return; }
+
+  let devices = [];
+  try {
+    const response = await fetch(`${httpServer}/devices`, { headers: { Authorization: `Bearer ${token}` } });
+    devices = await response.json();
+    if (!devices.length) { console.error('No devices. Add one with: osai-agent devices add'); return; }
+  } catch (err) { console.error(err.message); return; }
+
+  let deviceId = deviceOverride;
+  if (!deviceId) {
+    const answer = await inquirer.prompt({
+      type: 'input', name: 'deviceName', message: 'Device name',
+      validate: (v) => Boolean(v.trim()) || 'Device name required'
+    });
+    deviceId = answer.deviceName;
+  }
+
+  const search = String(deviceId).trim();
+  const device = devices.find((item, index) => {
+    const id = String(item._id);
+    return id === search
+      || id.startsWith(search)
+      || String(index + 1) === search
+      || item.name.toLowerCase() === search.toLowerCase()
+      || item.name.toLowerCase().includes(search.toLowerCase());
+  });
+  if (!device) {
+    console.log(`Device "${deviceId}" not found.\n`);
+    console.log('Available devices:');
+    devices.forEach((d, i) => {
+      console.log(`  ${i+1}. ${d.name}  (${d.type})  ${d.ip}`);
+    });
+    return;
+  }
+
+  const machineId = machineIdSync();
+  const key = deriveKey(machineId);
+  let auth = {};
+  try {
+    auth = device.auth_encrypted ? JSON.parse(decrypt(device.auth_encrypted, key)) : {};
+  } catch (err) {
+    console.error(`Failed to decrypt device credentials. Try re-adding the device.`);
+    return;
+  }
+  const deviceWithAuth = { ...device, auth_decrypted: auth };
+
+  // Test SSH connection before launching UI
+  const sshUser = auth.username || 'root';
+  let sshPassword = auth.password;
+  let connected = false;
+
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const spinner = ora({
+      text: `Connecting to ${sshUser}@${device.ip}...`,
+      spinner: 'dots'
+    }).start();
+
+    try {
+      const conn = await connectSSH({
+        host: device.ip,
+        port: device.port || 22,
+        username: sshUser,
+        password: sshPassword,
+      }, device.type);
+
+      conn.end();
+      spinner.succeed(`Connected to ${sshUser}@${device.ip}`);
+      connected = true;
+      break;
+    } catch (err) {
+      spinner.fail(`Connection failed: ${err.message}`);
+
+      if (attempt >= 2) {
+        console.error('Maximum connection attempts reached.');
+        return;
+      }
+
+      const answer = await inquirer.prompt({
+        type: 'password',
+        name: 'password',
+        message: `Password for ${sshUser}@${device.ip}:`,
+        mask: '*',
+      });
+
+      sshPassword = answer.password;
+      auth.password = sshPassword;
+      deviceWithAuth.auth_decrypted = { ...auth };
+    }
+  }
+
+  if (!connected) return;
+
+  const agentConfig = {
+    mode: /cisco|mikrotik|pfsense|junos/.test(device.type?.toLowerCase() || '') ? MODES.NETWORK : MODES.SSH,
+    server: httpServer,
+    token,
+    noConfirm,
+    device: deviceWithAuth,
+  };
+
+  const createAgentLoop = (options) => {
+    return new AgentLoop(options);
+  };
+
+  // Disable XON/XOFF immediately (prevents Ctrl+S from freezing the terminal)
+  if (process.stdout.isTTY) {
+    try { execSync('stty sane', { stdio: 'ignore' }); } catch {}
+    try { execSync('stty -ixon', { stdio: 'ignore' }); } catch {}
+    try { execSync('stty discard undef', { stdio: 'ignore' }); } catch {}
+  }
+
+  // Restore terminal state on unexpected signals
+  const restoreTerminal = () => {
+    try {
+      process.stdout.write('\x1B[?25h');
+      process.stdout.write('\x1B[?7h');
+      if (process.stdin.isTTY) process.stdin.setRawMode?.(false);
+      if (process.stdout.isTTY) {
+        try { execSync('stty sane', { stdio: 'ignore' }); } catch {}
+        try { execSync('stty -ixon', { stdio: 'ignore' }); } catch {}
+        try { execSync('stty discard undef', { stdio: 'ignore' }); } catch {}
+      }
+    } catch {}
+  };
+
+  const sigHandler = () => {
+    restoreTerminal();
+    process.exit(0);
+  };
+  process.prependListener('SIGINT', sigHandler);
+  process.prependListener('SIGTERM', sigHandler);
+
+  process.stdout.write('\x1Bc');
+  await new Promise(r => setTimeout(r, 100));
+  const isLinux = process.platform === 'linux';
+  const envFps = Number.parseInt(process.env.OSAI_MAX_FPS || '', 10);
+  const maxFps = Number.isFinite(envFps) && envFps > 0 ? envFps : (isLinux ? 10 : 15);
+
+  let clear, waitUntilExit;
+  try {
+    ({ clear, waitUntilExit } = render(h(App, { 
+      createAgentLoop, 
+      agentConfig, 
+      onExit: () => {
+        clear();
+        restoreTerminal();
+        process.removeListener('SIGINT', sigHandler);
+        process.removeListener('SIGTERM', sigHandler);
+        process.exit(0);
+      } 
+    }), {
+      incrementalRendering: true,
+      maxFps,
+    }));
+  } catch {
+    restoreTerminal();
+    process.exit(1);
+  }
+
+  // Re-disable XON/XOFF after Ink init
+  if (process.stdout.isTTY) {
+    try { execSync('stty -ixon', { stdio: 'ignore' }); } catch {}
+    try { execSync('stty discard undef', { stdio: 'ignore' }); } catch {}
+  }
+
+  await waitUntilExit;
+};

package/src/commands/devices.js

@@ -0,0 +1,121 @@
+import pkg from 'node-machine-id';
+const { machineIdSync } = pkg;
+import chalk from 'chalk';
+import Conf from 'conf';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { encrypt, decrypt, deriveKey } from '../services/crypto.js';
+import { clearScreen, printDeviceList, printError, printShell, printSuccess, printInfo, printNotLoggedIn } from '../ui/terminal.js';
+import { toHttpUrl } from '../services/server-url.js';
+
+const getConfig = () => new Conf({ projectName: 'osai-agent' });
+const DEVICE_TYPES = ['Cisco IOS', 'Cisco IOS-XE', 'Cisco ASA', 'Cisco NX-OS', 'MikroTik RouterOS', 'Linux', 'pfSense', 'Juniper JunOS', 'Windows Server'];
+const getServer = () => toHttpUrl(getConfig().get('server'));
+const getToken = () => getConfig().get('token');
+
+const isLocalMode = () => {
+  const argv = process.argv.slice(2);
+  return argv.includes('--local');
+};
+
+function getLocalDevices() {
+  const config = getConfig();
+  return config.get('localDevices', []);
+}
+
+function saveLocalDevices(devices) {
+  const config = getConfig();
+  config.set('localDevices', devices);
+}
+
+export const listDevices = async () => {
+  if (isLocalMode()) {
+    const devices = getLocalDevices();
+    if (!devices.length) {
+      printInfo('No local devices configured. Add one with: osai-agent devices add --local');
+      return;
+    }
+    clearScreen(); printShell('osai-agent - local devices'); console.log();
+    printDeviceList(devices); console.log();
+    return;
+  }
+
+  const token = getToken();
+  if (!token) { printNotLoggedIn(); return; }
+  try {
+    const response = await fetch(`${getServer()}/devices`, { headers: { 'Authorization': `Bearer ${token}` } });
+    const devices = await response.json();
+    if (!devices.length) { printInfo('No devices configured. Add one with: osai-agent devices add'); return; }
+    clearScreen(); printShell('osai-agent - devices'); console.log();
+    printDeviceList(devices); console.log();
+  } catch (err) { printError(err.message); }
+};
+
+export const addDevice = async () => {
+  clearScreen(); printShell('osai-agent - new device'); console.log();
+
+  const answers = await inquirer.prompt([
+    { type: 'input', name: 'name', message: 'Device name', validate: (v) => Boolean(v.trim()) || 'Name required' },
+    { type: 'list', name: 'type', message: 'Type', choices: DEVICE_TYPES },
+    { type: 'input', name: 'ip', message: 'IP address or hostname', validate: (v) => Boolean(v.trim()) || 'Address required' },
+    { type: 'number', name: 'port', message: 'SSH Port', default: 22 },
+    { type: 'input', name: 'username', message: 'SSH Username', validate: (v) => Boolean(v.trim()) || 'Username required' },
+    { type: 'password', name: 'password', message: 'SSH Password (or key passphrase)', mask: '*' }
+  ]);
+
+  // Normalize device type (case-insensitive) before sending
+  const normalizedType = DEVICE_TYPES.find(t => t.toLowerCase() === answers.type.toLowerCase()) || answers.type;
+
+  const machineId = machineIdSync();
+  const key = deriveKey(machineId);
+  const authEncrypted = encrypt(JSON.stringify({ username: answers.username, password: answers.password }), key);
+
+  if (isLocalMode()) {
+    const devices = getLocalDevices();
+    const id = `local_${Date.now()}`;
+    devices.push({ id, name: answers.name, type: normalizedType, ip: answers.ip, port: answers.port || 22, auth_encrypted: authEncrypted });
+    saveLocalDevices(devices);
+    printSuccess(`Device saved locally: ${id}`);
+    return;
+  }
+
+  const token = getToken();
+  if (!token) { printNotLoggedIn(); return; }
+
+  const spinner = ora('Registering device...').start();
+  try {
+    const response = await fetch(`${getServer()}/devices`, {
+      method: 'POST',
+      headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: answers.name, type: normalizedType, ip: answers.ip, port: answers.port || 22, auth_encrypted: authEncrypted })
+    });
+    const data = await response.json();
+    if (!response.ok) { spinner.fail('Registration refused'); printError(data.error || 'Error during creation'); return; }
+    spinner.succeed('Device registered');
+    printSuccess(`Device created: ${data.id}`);
+  } catch (err) { spinner.fail('Unable to register'); printError(err.message); }
+};
+
+export const removeDevice = async (deviceId) => {
+  if (!deviceId) { printError('Usage: osai-agent devices remove <id>'); return; }
+
+  if (isLocalMode()) {
+    const devices = getLocalDevices();
+    const filtered = devices.filter(d => d.id !== deviceId);
+    if (filtered.length === devices.length) {
+      printError(`Device not found: ${deviceId}`);
+      return;
+    }
+    saveLocalDevices(filtered);
+    printSuccess('Local device deleted');
+    return;
+  }
+
+  const token = getToken();
+  if (!token) { printNotLoggedIn(); return; }
+  try {
+    const response = await fetch(`${getServer()}/devices/${deviceId}`, { method: 'DELETE', headers: { 'Authorization': `Bearer ${token}` } });
+    if (!response.ok) { const data = await response.json(); printError(data.error || 'Error during deletion'); return; }
+    printSuccess('Device deleted');
+  } catch (err) { printError(err.message); }
+};