osai-agent 4.0.0

package/src/services/ssh.js

@@ -0,0 +1,176 @@
+// =============================================================================
+// OS AI Agent — SSH Connection Manager
+// =============================================================================
+import { Client } from 'ssh2';
+import { DEFAULTS } from '../utils/constants.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Validate SSH private key format before connection
+ */
+const validateSshPrivateKey = (privateKey) => {
+  if (!privateKey || typeof privateKey !== 'string') {
+    throw new Error('Invalid SSH private key: missing or not a string');
+  }
+  
+  const trimmedKey = privateKey.trim();
+  
+  // Check for common SSH private key headers
+  const validKeyPatterns = [
+    /^-----BEGIN ([A-Z ]+) PRIVATE KEY-----/,
+    /^-----BEGIN OPENSSH PRIVATE KEY-----/,
+    /^-----BEGIN RSA PRIVATE KEY-----/,
+    /^-----BEGIN DSA PRIVATE KEY-----/,
+    /^-----BEGIN EC PRIVATE KEY-----/,
+    /^-----BEGIN ED25519 PRIVATE KEY-----/,
+    /^-----BEGIN ENCRYPTED PRIVATE KEY-----/,
+  ];
+  
+  const isValidFormat = validKeyPatterns.some(pattern => pattern.test(trimmedKey));
+  
+  if (!isValidFormat) {
+    throw new Error('Invalid SSH private key format: must be a valid PEM-formatted private key');
+  }
+  
+  // Check for key footer
+  if (!trimmedKey.includes('-----END')) {
+    throw new Error('Invalid SSH private key: missing END marker');
+  }
+  
+  // Basic length check
+  if (trimmedKey.length < 100) {
+    throw new Error('Invalid SSH private key: too short to be valid');
+  }
+  
+  if (trimmedKey.length > 100000) {
+    throw new Error('Invalid SSH private key: exceeds maximum length');
+  }
+  
+  return trimmedKey;
+};
+
+const connections = new Map();
+const timeouts = new Map();
+
+export const connectSSH = async ({ host, port, username, password, privateKey }, deviceType) => {
+  return new Promise((resolve, reject) => {
+    if (!host) return reject(new Error('SSH host is required'));
+
+    const conn = new Client();
+    const connectPort = port || 22;
+    const connectConfig = {
+      host,
+      port: connectPort,
+      username: username || 'root',
+      readyTimeout: 30000,
+      keepaliveInterval: 30000,
+      keepaliveCountMax: 3,
+    };
+
+    if (privateKey) {
+      try {
+        const validatedKey = validateSshPrivateKey(privateKey);
+        connectConfig.privateKey = validatedKey;
+        if (password) connectConfig.passphrase = password;
+      } catch (keyError) {
+        return reject(new Error(`SSH key validation failed: ${keyError.message}`));
+      }
+    } else if (password) {
+      connectConfig.password = password;
+    } else {
+      return reject(new Error('No authentication method provided (need password or privateKey)'));
+    }
+
+    conn.on('ready', () => {
+      logger.info(`SSH connected: ${host}:${connectPort}`);
+      // Store key on the connection object for timer reset in execSSH
+      conn._sshKey = `${host}:${connectPort}`;
+      // Device-specific initialization commands
+      if (deviceType?.toLowerCase().includes('cisco')) {
+        conn.exec('terminal length 0\n', () => {});
+      } else if (deviceType?.toLowerCase().includes('mikrotik')) {
+        conn.exec(':put "connected"\n', () => {});
+      }
+      // Auto-close on inactivity
+      const timeoutId = setTimeout(() => {
+        logger.info(`SSH closed (inactivity): ${host}`);
+        try { conn.end(); } catch {}
+        connections.delete(`${host}:${connectPort}`);
+      }, DEFAULTS.SSH_INACTIVITY_TIMEOUT);
+      timeouts.set(host, timeoutId);
+      connections.set(`${host}:${connectPort}`, conn);
+      resolve(conn);
+    });
+
+    conn.on('error', (err) => {
+      logger.error(`SSH connection error: ${host}`, { error: err.message });
+      reject(err);
+    });
+
+    conn.on('close', () => {
+      const key = `${host}:${connectPort}`;
+      connections.delete(key);
+      const tid = timeouts.get(host);
+      if (tid) { clearTimeout(tid); timeouts.delete(host); }
+      logger.debug(`SSH closed: ${host}`);
+    });
+
+    conn.connect(connectConfig);
+  });
+};
+
+export const execSSH = (conn, cmd, timeout = DEFAULTS.SSH_COMMAND_TIMEOUT) => {
+  return new Promise((resolve, reject) => {
+    if (!conn) return reject(new Error('No SSH connection provided'));
+    if (!cmd) return reject(new Error('No command provided'));
+
+    // Reset inactivity timer on command execution
+    const fullKey = conn._sshKey;
+    if (fullKey) {
+      const host = fullKey.split(':')[0];
+      const old = timeouts.get(host);
+      if (old) clearTimeout(old);
+      const t = setTimeout(() => {
+        logger.info(`SSH closed (inactivity): ${fullKey}`);
+        try { conn.end(); } catch {}
+        connections.delete(fullKey);
+        timeouts.delete(host);
+      }, DEFAULTS.SSH_INACTIVITY_TIMEOUT);
+      timeouts.set(host, t);
+    }
+
+    const timer = setTimeout(() => {
+      reject(new Error(`SSH command timed out after ${timeout / 1000}s`));
+    }, timeout);
+
+    conn.exec(cmd, (err, stream) => {
+      if (err) {
+        clearTimeout(timer);
+        return reject(err);
+      }
+      let output = '';
+      stream.on('data', (data) => { output += data.toString(); });
+      stream.stderr?.on('data', (data) => { output += data.toString(); });
+      stream.on('close', (code) => {
+        clearTimeout(timer);
+        resolve({ output, status: code === 0 || code === null ? 'success' : 'error', exitCode: code });
+      });
+      stream.on('error', (e) => {
+        clearTimeout(timer);
+        resolve({ output: e.message, status: 'error' });
+      });
+    });
+  });
+};
+
+export const closeSSH = (host) => {
+  const conn = connections.get(host);
+  if (conn) {
+    try { conn.end(); } catch {}
+    connections.delete(host);
+    const tid = timeouts.get(host);
+    if (tid) { clearTimeout(tid); timeouts.delete(host); }
+  }
+};
+
+export const getActiveConnectionCount = () => connections.size;

package/src/services/websocket.js

@@ -0,0 +1,112 @@
+// =============================================================================
+// OS AI Agent — WebSocket Client (Standalone)
+// =============================================================================
+// Standalone WebSocket client with auto-reconnect and exponential backoff.
+// Used as a lower-level utility that can be imported by the agent loop or
+// other modules needing persistent WebSocket connections.
+// =============================================================================
+import WebSocket from 'ws';
+import { DEFAULTS } from '../utils/constants.js';
+import { logger } from '../utils/logger.js';
+
+let ws = null;
+let reconnectAttempts = 0;
+let reconnecting = false;
+const MAX_RECONNECT_DELAY = DEFAULTS.WS_RECONNECT_MAX_DELAY;
+
+export const connectWS = async (serverUrl, token, onMessage) => {
+  return new Promise((resolve, reject) => {
+    ws = new WebSocket(`${serverUrl}/ws`);
+
+    ws.on('open', () => {
+      ws.send(JSON.stringify({ type: 'REGISTER', token }));
+      reconnectAttempts = 0;
+      logger.info('WebSocket connected');
+    });
+
+    ws.on('message', async (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        await onMessage(msg);
+        if (msg.type === 'REGISTERED') resolve(msg);
+      } catch (e) {
+        logger.error('WebSocket message parse error', { error: e.message });
+      }
+    });
+
+    ws.on('close', (code, reason) => {
+      logger.warn(`WebSocket closed: ${code} ${reason}`);
+      if (reconnecting) return;
+      if (reconnectAttempts >= DEFAULTS.WS_RECONNECT_MAX_ATTEMPTS) {
+        logger.warn('Max WebSocket reconnection attempts reached');
+        return;
+      }
+      reconnecting = true;
+      const delay = Math.min(
+        DEFAULTS.WS_RECONNECT_BASE_DELAY * Math.pow(2, reconnectAttempts),
+        MAX_RECONNECT_DELAY
+      );
+      reconnectAttempts++;
+      setTimeout(() => {
+        reconnecting = false;
+        connectWS(serverUrl, token, onMessage).catch(() => {});
+      }, delay);
+    });
+
+    ws.on('error', (err) => {
+      logger.error('WebSocket error', { error: err.message });
+      reject(err);
+    });
+
+    ws.on('ping', () => {
+      try { ws.pong(); } catch {}
+    });
+  });
+};
+
+export const send = (data) => {
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify(data));
+  } else {
+    logger.warn('WebSocket not connected');
+  }
+};
+
+export const sendCancellation = (taskId) => {
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    try {
+      ws.send(JSON.stringify({
+        type: 'CANCEL',
+        taskId: taskId,
+        timestamp: Date.now()
+      }));
+      logger.info('Cancellation signal sent to server', { taskId });
+      return true;
+    } catch (error) {
+      logger.error('Failed to send cancellation signal', { error: error.message });
+      return false;
+    }
+  }
+  logger.warn('WebSocket not connected for cancellation');
+  return false;
+};
+
+export const close = () => {
+  if (ws) {
+    ws.close();
+    ws = null;
+  }
+};
+
+export const isConnected = () => ws && ws.readyState === WebSocket.OPEN;
+
+export const getConnectionState = () => {
+  if (!ws) return 'disconnected';
+  switch (ws.readyState) {
+    case WebSocket.CONNECTING: return 'connecting';
+    case WebSocket.OPEN: return 'connected';
+    case WebSocket.CLOSING: return 'closing';
+    case WebSocket.CLOSED: return 'closed';
+    default: return 'unknown';
+  }
+};

package/src/skills/loader.js

@@ -0,0 +1,231 @@
+// =============================================================================
+// OS AI Agent — Skills Loader
+// =============================================================================
+// Discovers and manages SKILL.md files from personal and project directories.
+// =============================================================================
+
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import fg from 'fast-glob';
+import { logger } from '../utils/logger.js';
+
+const SKILL_FILENAME = 'SKILL.md';
+
+const SKILL_ROOTS = [
+  { base: path.join(os.homedir(), '.osai-agent', 'skills'), source: 'personal' },
+  { base: path.join(process.cwd(), '.osai-agent', 'skills'), source: 'project' },
+];
+
+let _cache = null;
+let _cacheCwd = null;
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) {
+    return { meta: {}, body: content.trim() };
+  }
+
+  const meta = {};
+  for (const line of match[1].split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const idx = trimmed.indexOf(':');
+    if (idx === -1) continue;
+    const key = trimmed.slice(0, idx).trim();
+    let value = trimmed.slice(idx + 1).trim();
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    meta[key] = value;
+  }
+
+  return { meta, body: content.slice(match[0].length).trim() };
+}
+
+function skillNameFromPath(skillPath) {
+  return path.basename(path.dirname(skillPath));
+}
+
+function sanitizeSkillName(name) {
+  return String(name || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 64);
+}
+
+async function fileExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function findSkillFiles() {
+  const files = new Set();
+
+  for (const { base } of SKILL_ROOTS) {
+    if (!(await fileExists(base))) continue;
+    const matches = await fg('**/SKILL.md', {
+      cwd: base,
+      absolute: true,
+      onlyFiles: true,
+      suppressErrors: true,
+    });
+    for (const match of matches) files.add(match);
+  }
+
+  return [...files];
+}
+
+function sourceLabel(skillPath) {
+  const normalized = skillPath.replace(/\\/g, '/');
+  const cwd = process.cwd().replace(/\\/g, '/');
+  const inProject = normalized.startsWith(`${cwd}/`);
+
+  if (inProject && normalized.includes('/.osai-agent/skills/')) return 'project';
+  if (normalized.includes('/.osai-agent/skills/')) return 'personal';
+  return 'unknown';
+}
+
+function skillDirForScope(scope = 'project') {
+  return scope === 'personal'
+    ? path.join(os.homedir(), '.osai-agent', 'skills')
+    : path.join(process.cwd(), '.osai-agent', 'skills');
+}
+
+/**
+ * Discover all available skills (metadata only).
+ * @param {{ refresh?: boolean }} opts
+ */
+export async function discoverSkills(opts = {}) {
+  if (!opts.refresh && _cache && _cacheCwd === process.cwd()) {
+    return _cache;
+  }
+
+  const skillFiles = await findSkillFiles();
+  const byName = new Map();
+
+  for (const skillPath of skillFiles) {
+    try {
+      const content = await fs.readFile(skillPath, 'utf-8');
+      const { meta } = parseFrontmatter(content);
+      const folderName = skillNameFromPath(skillPath);
+      const name = (meta.name || folderName).trim();
+      if (!name) continue;
+
+      const entry = {
+        name,
+        description: (meta.description || 'No description').trim(),
+        path: skillPath,
+        source: sourceLabel(skillPath),
+        disableModelInvocation: meta['disable-model-invocation'] === 'true',
+      };
+
+      const existing = byName.get(name);
+      if (!existing || entry.source === 'project') {
+        byName.set(name, entry);
+      }
+    } catch (err) {
+      logger.debug('Failed to read skill file', { skillPath, error: err.message });
+    }
+  }
+
+  _cache = [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+  _cacheCwd = process.cwd();
+  return _cache;
+}
+
+/**
+ * Load full skill content by name.
+ */
+export async function loadSkill(name) {
+  const skills = await discoverSkills();
+  const skill = skills.find((s) => s.name === name);
+  if (!skill) {
+    return {
+      success: false,
+      output: '',
+      error: `Skill not found: "${name}". Use SKILL_LIST to see available skills.`,
+    };
+  }
+
+  try {
+    const content = await fs.readFile(skill.path, 'utf-8');
+    const { meta, body } = parseFrontmatter(content);
+    const header = [
+      `# Skill: ${meta.name || skill.name}`,
+      meta.description ? `> ${meta.description}` : '',
+      `Source: ${skill.source} (${skill.path})`,
+      '',
+    ].filter(Boolean).join('\n');
+
+    return {
+      success: true,
+      output: `${header}\n${body}`,
+      skill: skill.name,
+      source: skill.source,
+    };
+  } catch (err) {
+    return { success: false, output: '', error: err.message };
+  }
+}
+
+/**
+ * Create or update a skill file.
+ */
+export async function createSkill({ name, description = '', content = '', scope = 'project' }) {
+  const safeName = sanitizeSkillName(name);
+  if (!safeName) {
+    return { success: false, output: '', error: 'Invalid skill name. Use letters, numbers, and hyphens only.' };
+  }
+
+  const desc = String(description || `Workflow for ${safeName}`).trim();
+  const body = String(content || `# ${safeName}\n\nAdd workflow instructions here.`).trim();
+  const dir = path.join(skillDirForScope(scope), safeName);
+  const skillPath = path.join(dir, SKILL_FILENAME);
+
+  try {
+    await fs.mkdir(dir, { recursive: true });
+    const fileContent = `---\nname: ${safeName}\ndescription: ${desc}\n---\n\n${body}\n`;
+    const exists = await fileExists(skillPath);
+    await fs.writeFile(skillPath, fileContent, 'utf-8');
+    invalidateSkillsCache();
+
+    return {
+      success: true,
+      output: `Skill "${safeName}" ${exists ? 'updated' : 'created'} at ${skillPath}`,
+      path: skillPath,
+      name: safeName,
+      scope: scope === 'personal' ? 'personal' : 'project',
+      updated: exists,
+    };
+  } catch (err) {
+    return { success: false, output: '', error: `Failed to create skill: ${err.message}` };
+  }
+}
+
+export function formatSkillsList(skills) {
+  if (!skills.length) {
+    return 'No skills found. Create ~/.osai-agent/skills/<name>/SKILL.md or .osai-agent/skills/<name>/SKILL.md';
+  }
+  return skills.map((s) => `- ${s.name}: ${s.description} [${s.source}]`).join('\n');
+}
+
+export function formatSkillsForPrompt(skills) {
+  if (!skills.length) return '';
+  const lines = skills
+    .filter((s) => !s.disableModelInvocation)
+    .map((s) => `- **${s.name}**: ${s.description}`);
+  if (!lines.length) return '';
+  return lines.join('\n');
+}
+
+export function invalidateSkillsCache() {
+  _cache = null;
+  _cacheCwd = null;
+}