osai-agent 4.0.0

package/LICENSE

@@ -0,0 +1,7 @@
+OS AI AGENT
+
+Copyright © 2026 OLOJEDE Samuel. All rights reserved.
+
+This software and its source code are proprietary and confidential.
+Unauthorized copying, distribution, modification, or use is strictly
+prohibited without prior written permission from the copyright holder.

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "osai-agent",
+  "version": "4.0.0",
+  "type": "module",
+  "description": "OS AI Agent - YOUR AI AGENT",
+  "main": "src/index.js",
+  "bin": {
+    "osai-agent": "./src/index.js"
+  },
+  "scripts": {
+    "start": "node src/index.js run",
+    "cli": "node src/index.js",
+    "run": "node src/index.js run",
+    "connect": "node src/index.js connect",
+    "dev": "node --watch src/index.js run"
+  },
+  "files": [
+    "src/",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/King03-sam/osai-agent.git"
+  },
+  "bugs": {
+    "url": "https://github.com/King03-sam/osai-agent/issues"
+  },
+  "homepage": "https://github.com/King03-sam/osai-agent#readme",
+  "license": "UNLICENSED",
+  "keywords": [
+    "cli",
+    "agent",
+    "ai",
+    "sysadmin",
+    "network",
+    "ssh"
+  ],
+  "dependencies": {
+    "@cfworker/json-schema": "^4.1.1",
+    "@modelcontextprotocol/client": "^2.0.0-alpha.2",
+    "@tavily/core": "^0.7.3",
+    "boxen": "^8.0.1",
+    "chalk": "^5.3.0",
+    "cli-highlight": "^2.1.11",
+    "conf": "^12.0.0",
+    "duck-duck-scrape": "^2.2.7",
+    "fast-glob": "^3.3.3",
+    "@google/generative-ai": "^0.24.1",
+    "openai": "^6.42.0",
+    "ink": "^7.0.3",
+    "ink-scroll-view": "^0.3.7",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "inquirer": "^13.4.2",
+    "marked": "^15.0.12",
+    "marked-terminal": "^7.3.0",
+    "minimist": "^1.2.8",
+    "node-machine-id": "^1.1.12",
+    "ora": "^9.4.0",
+    "react": "^19.2.6",
+    "serpapi": "^2.2.1",
+    "ssh2": "^1.15.0",
+    "tokenx": "^1.3.0",
+    "uuid": "^14.0.0",
+    "ws": "^8.18.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/agent/context.js

@@ -0,0 +1,141 @@
+// =============================================================================
+// OS AI Agent — Context Builder
+// =============================================================================
+// Builds structured context for the agent loop, including device information,
+// OS detection, and device capabilities. Used primarily in network/SSH mode.
+// =============================================================================
+
+/**
+ * Build a structured context object for the agent
+ */
+export const buildContext = ({ goal, todos, history, device, mode, step = 0 }) => {
+  const context = {
+    mode: mode || 'network',
+    goal: goal || '',
+    todos: todos || [],
+    history: history || [],
+    step,
+    timestamp: new Date().toISOString(),
+  };
+
+  if (device) {
+    context.device = {
+      id: device._id || device.id,
+      name: device.name,
+      type: device.type,
+      ip: device.ip,
+    };
+  }
+
+  if (mode === 'network' && device) {
+    context.deviceInfo = {
+      os: getDeviceOS(device.type),
+      capabilities: getDeviceCapabilities(device.type),
+    };
+  }
+
+  return context;
+};
+
+/**
+ * Get the operating system name for a given device type
+ */
+const getDeviceOS = (deviceType) => {
+  const type = (deviceType || '').toLowerCase();
+  if (type.includes('cisco')) {
+    if (type.includes('asa')) return 'Cisco ASA';
+    if (type.includes('ios-xe')) return 'Cisco IOS-XE';
+    if (type.includes('nx-os')) return 'Cisco NX-OS';
+    return 'Cisco IOS';
+  }
+  if (type.includes('mikrotik') || type.includes('routeros')) return 'MikroTik RouterOS';
+  if (type.includes('pfsense')) return 'pfSense';
+  if (type.includes('junos')) return 'Juniper JunOS';
+  if (type.includes('linux')) return 'Linux';
+  if (type.includes('windows')) return 'Windows Server';
+  return 'Unknown';
+};
+
+/**
+ * Get device capabilities based on device type
+ */
+const getDeviceCapabilities = (deviceType) => {
+  const type = (deviceType || '').toLowerCase();
+  const capabilities = {
+    show: true,
+    configure: false,
+    routing: false,
+    firewall: false,
+    vlan: false,
+    interface: true,
+  };
+
+  if (type.includes('cisco') || type.includes('mikrotik') || type.includes('junos')) {
+    capabilities.configure = true;
+    capabilities.routing = true;
+    capabilities.firewall = true;
+    capabilities.vlan = true;
+  }
+
+  if (type.includes('pfsense')) {
+    capabilities.configure = true;
+    capabilities.firewall = true;
+    capabilities.routing = true;
+  }
+
+  if (type.includes('linux')) {
+    capabilities.configure = true;
+    capabilities.routing = true;
+    capabilities.firewall = true;
+  }
+
+  return capabilities;
+};
+
+/**
+ * Update context with a new result from the agent
+ */
+export const updateContext = (context, { result, command, status }) => {
+  return {
+    ...context,
+    history: [
+      ...context.history,
+      {
+        step: context.history.length,
+        command,
+        result,
+        status,
+        timestamp: new Date().toISOString(),
+      },
+    ],
+    step: context.step + 1,
+  };
+};
+
+/**
+ * Check if the agent's goal is complete based on context
+ */
+export const isGoalComplete = (context) => {
+  if (!context.todos || context.todos.length === 0) {
+    return context.history.length > 0;
+  }
+  return context.todos.every((todo) => todo.completed);
+};
+
+/**
+ * Generate a device info summary for inclusion in system prompts
+ */
+export const getDeviceInfoSummary = (device) => {
+  if (!device) return null;
+
+  return [
+    `Device: ${device.name}`,
+    `Type: ${device.type}`,
+    `IP: ${device.ip}:${device.port || 22}`,
+    `OS: ${getDeviceOS(device.type)}`,
+    `Capabilities: ${Object.entries(getDeviceCapabilities(device.type))
+      .filter(([_, v]) => v)
+      .map(([k]) => k)
+      .join(', ')}`,
+  ].join('\n');
+};

package/src/agent/loop/context-summary.js

@@ -0,0 +1,196 @@
+import { TOOLS, CONTEXT_SUMMARY_TAG, HISTORY_SUMMARY_TRIGGER_TOKENS, HISTORY_SUMMARY_KEEP_RECENT_TOKENS, HISTORY_SUMMARY_MIN_GROWTH_TOKENS, MAX_CONTEXT_TOKENS, MAX_CONTEXT_SUMMARY_CHARS } from '../../utils/constants.js';
+import { logger } from '../../utils/logger.js';
+import { estimateTokenCount } from 'tokenx';
+
+export default {
+  _appendConversationMessage(role, content) {
+    if (typeof content !== 'string' || !content.trim()) return;
+    this.conversationHistory.push({ role, content });
+    this._scheduleBackgroundSummary();
+  },
+
+  _scheduleBackgroundSummary() {
+    if (this._summaryInProgress || this._summaryTimer) return;
+    const totalTokens = this._estimateTokens();
+    if (totalTokens < HISTORY_SUMMARY_TRIGGER_TOKENS) return;
+    if ((totalTokens - this._lastSummaryAtTokenCount) < HISTORY_SUMMARY_MIN_GROWTH_TOKENS && this._lastSummaryAtTokenCount > 0) return;
+
+    const WRITE_TOOLS = new Set([TOOLS.WRITE_FILE, TOOLS.EDIT_FILE, TOOLS.APPEND_FILE]);
+    const VALIDATION_TOOLS = new Set([TOOLS.DIAG_POST_EDIT, TOOLS.RUN_SCRIPT, TOOLS.LOCAL_CMD, TOOLS.GIT]);
+    const recentTools = this._toolSequenceWindow.map(e => e.tool);
+    const lastWriteIdx = [...recentTools].reverse().findIndex(t => WRITE_TOOLS.has(t));
+    const lastValidationIdx = [...recentTools].reverse().findIndex(t => VALIDATION_TOOLS.has(t));
+    if (lastWriteIdx !== -1 && (lastValidationIdx === -1 || lastWriteIdx < lastValidationIdx)) {
+      return;
+    }
+
+    this._summaryTimer = setTimeout(() => {
+      this._summaryTimer = null;
+      this._runBackgroundSummary();
+    }, 0);
+  },
+
+  _runBackgroundSummary() {
+    if (this._summaryInProgress) return;
+    this._summaryInProgress = true;
+    (async () => {
+      try {
+        const history = this.conversationHistory
+          .filter((m) => m && typeof m.role === 'string' && typeof m.content === 'string')
+          .filter((m) => (m.role === 'user' || m.role === 'assistant' || m.role === 'system') && m.content.trim().length > 0);
+
+        let previousSummary = '';
+        let workingHistory = history;
+        const first = workingHistory[0];
+        if (first?.role === 'system' && first.content.startsWith(CONTEXT_SUMMARY_TAG)) {
+          previousSummary = first.content.slice(CONTEXT_SUMMARY_TAG.length).trim();
+          workingHistory = workingHistory.slice(1);
+        }
+
+        if (this._estimateTokens(workingHistory) < HISTORY_SUMMARY_TRIGGER_TOKENS) return;
+        if (this._estimateTokens(workingHistory) <= HISTORY_SUMMARY_KEEP_RECENT_TOKENS) return;
+
+        let tokenAccum = 0;
+        let cutoff = workingHistory.length;
+        for (let i = workingHistory.length - 1; i >= 0; i--) {
+          tokenAccum += estimateTokenCount(workingHistory[i].content || '');
+          if (tokenAccum > HISTORY_SUMMARY_KEEP_RECENT_TOKENS) {
+            cutoff = i + 1;
+            break;
+          }
+        }
+        const oldMessages = workingHistory.slice(0, cutoff);
+        const recentMessages = workingHistory.slice(cutoff);
+        this.onObservation({
+          type: 'context_summary_start',
+          totalMessages: workingHistory.length,
+          summarizeCount: oldMessages.length,
+          keepRecent: HISTORY_SUMMARY_KEEP_RECENT_TOKENS,
+        });
+        const summaryBody = this._buildContextSummaryBody(oldMessages, previousSummary);
+        const summaryMessage = `${CONTEXT_SUMMARY_TAG}\n${summaryBody}`;
+
+        this.conversationHistory = [{ role: 'system', content: summaryMessage }, ...recentMessages];
+        this._lastCompactInteraction = this._toolInteractionCounter;
+        this._lastSummaryAtTokenCount = this._estimateTokens();
+        this.onObservation({
+          type: 'context_summary_end',
+          summarizedMessages: oldMessages.length,
+          remainingMessages: this.conversationHistory.length,
+        });
+        this._trimContext();
+        this.totalTokensUsed = this._estimateTokens();
+        this.onStats?.(this.totalTokensUsed);
+      } catch (error) {
+        logger.debug('Background summary failed', { error: error.message });
+      } finally {
+        this._summaryInProgress = false;
+      }
+    })();
+  },
+
+  _buildContextSummaryBody(messages, previousSummary = '') {
+    const normalize = (text, max = 180) => String(text || '')
+      .replace(/\s+/g, ' ')
+      .trim()
+      .slice(0, max);
+
+    const userIntents = [];
+    const toolOutcomes = [];
+    const assistantNotes = [];
+
+    for (const msg of messages) {
+      const content = String(msg.content || '');
+      if (msg.role === 'user' && content.startsWith('[TOOL_RESULT]')) {
+        const tool = content.match(/Tool:\s*([A-Z_]+)/i)?.[1] || 'UNKNOWN';
+        const target = normalize(content.match(/Target:\s*([^\n]+)/i)?.[1] || '', 120);
+        const status = content.match(/Status:\s*([A-Z]+)/i)?.[1] || '';
+        const detail = `Tool ${tool}${status ? ` ${status}` : ''}${target ? ` on ${target}` : ''}`;
+        toolOutcomes.push(detail);
+
+        if (tool === 'READ_FILE' && status === 'SUCCESS') {
+          const outputMatch = content.match(/Output:\n([\s\S]*)/);
+          if (outputMatch) {
+            const fileContent = outputMatch[1].trim();
+            const maxLines = 80;
+            const maxChars = 2000;
+            const lines = fileContent.split('\n');
+            let preserved = fileContent;
+            if (lines.length > maxLines) {
+              preserved = lines.slice(0, maxLines).join('\n') + `\n... (${lines.length - maxLines} more lines)`;
+            }
+            if (preserved.length > maxChars) {
+              preserved = preserved.slice(0, maxChars) + `\n... (${fileContent.length - maxChars} more chars)`;
+            }
+            toolOutcomes.push(`File content (${target}):\n${preserved}`);
+          }
+        }
+        continue;
+      }
+      if (msg.role === 'user') {
+        userIntents.push(normalize(content, 160));
+        continue;
+      }
+      if (msg.role === 'assistant') {
+        assistantNotes.push(normalize(content, 160));
+      }
+    }
+
+    const takeLast = (arr, n) => arr.filter(Boolean).slice(-n);
+    const lines = [];
+    lines.push(`Summary refreshed: ${new Date().toISOString()}`);
+
+    if (previousSummary) {
+      lines.push('Previous summary context:');
+      lines.push(`- ${normalize(previousSummary, 380)}`);
+    }
+
+    const intents = takeLast(userIntents, 5);
+    if (intents.length > 0) {
+      lines.push('User intents:');
+      for (const item of intents) lines.push(`- ${item}`);
+    }
+
+    const outcomes = takeLast(toolOutcomes, 8);
+    if (outcomes.length > 0) {
+      lines.push('Tool outcomes:');
+      for (const item of outcomes) lines.push(`- ${item}`);
+    }
+
+    const notes = takeLast(assistantNotes, 5);
+    if (notes.length > 0) {
+      lines.push('Assistant conclusions:');
+      for (const item of notes) lines.push(`- ${item}`);
+    }
+
+    const summary = lines.join('\n').trim();
+    if (summary.length <= MAX_CONTEXT_SUMMARY_CHARS) return summary;
+    return summary.slice(0, MAX_CONTEXT_SUMMARY_CHARS) + '\n...[summary truncated]';
+  },
+
+  _trimContext() {
+    this._scheduleBackgroundSummary();
+    if (this._estimateTokens() <= MAX_CONTEXT_TOKENS) return;
+    let tokenAccum = 0;
+    let cutoff = this.conversationHistory.length;
+    for (let i = this.conversationHistory.length - 1; i >= 0; i--) {
+      tokenAccum += estimateTokenCount(this.conversationHistory[i].content || '');
+      if (tokenAccum > MAX_CONTEXT_TOKENS) {
+        cutoff = i + 1;
+        break;
+      }
+    }
+    const first = this.conversationHistory[0];
+    if (first?.role === 'system') {
+      const rest = this.conversationHistory.slice(cutoff);
+      this.conversationHistory = [first, ...rest];
+      return;
+    }
+    this.conversationHistory = this.conversationHistory.slice(cutoff);
+  },
+
+  _estimateTokens(messages) {
+    const target = messages || this.conversationHistory;
+    return target.reduce((sum, msg) => sum + estimateTokenCount(msg.content || ''), 0);
+  },
+};

package/src/agent/loop/directory-utils.js

@@ -0,0 +1,102 @@
+import { TOOLS, MODES } from '../../utils/constants.js';
+import path from 'path';
+import fs from 'fs';
+
+export default {
+  _isPathInsideCodingRoot(candidatePath) {
+    if (!candidatePath || !this._codingRootPath) return true;
+    if (candidatePath === this._codingRootPath) return true;
+    return candidatePath.startsWith(this._codingRootPath + path.sep);
+  },
+
+  _getDirectoryCandidate(candidatePath) {
+    if (!candidatePath) return null;
+    try {
+      const st = fs.existsSync(candidatePath) ? fs.statSync(candidatePath) : null;
+      if (st?.isDirectory()) return candidatePath;
+      return path.dirname(candidatePath);
+    } catch {
+      return path.dirname(candidatePath);
+    }
+  },
+
+  _isApprovedExternalDir(dirPath) {
+    for (const approved of this._approvedExternalDirs) {
+      if (dirPath === approved || dirPath.startsWith(approved + path.sep)) return true;
+    }
+    return false;
+  },
+
+  _extractCommandDirectoryTargets(cmdRaw) {
+    const cmd = String(cmdRaw || '');
+    if (!cmd.trim()) return [];
+    const targets = [];
+    const segments = cmd.split(/&&|\|\||;/g).map((s) => s.trim()).filter(Boolean);
+    for (const seg of segments) {
+      let m = seg.match(/^cd(?:\s+\/d)?\s+(.+)$/i);
+      if (!m) m = seg.match(/^(?:Set-Location|sl)\s+(.+)$/i);
+      if (!m) continue;
+      let target = String(m[1] || '').trim();
+      if (!target) continue;
+      target = target.replace(/^["'`]+|["'`]+$/g, '');
+      if (!target || target === '.') continue;
+      targets.push(target);
+    }
+    return targets;
+  },
+
+  _getDirectoryApprovalRequirement(toolCall) {
+    if (this.mode !== MODES.CODING) return { required: false };
+    if (this.isSubagent) return { required: false };
+    const tool = toolCall.tool || TOOLS.LOCAL_CMD;
+    const rawCandidates = [];
+
+    const pushPath = (v) => { if (typeof v === 'string' && v.trim()) rawCandidates.push(v.trim()); };
+
+    switch (tool) {
+      case TOOLS.READ_FILE:
+      case TOOLS.WRITE_FILE:
+      case TOOLS.EDIT_FILE:
+      case TOOLS.APPEND_FILE:
+      case TOOLS.DELETE_FILE:
+      case TOOLS.LIST_DIR:
+      case TOOLS.SEARCH_FILE:
+      case TOOLS.CREATE_DIR:
+      case TOOLS.TREE_VIEW:
+      case TOOLS.RUN_SCRIPT:
+      case TOOLS.FILE_INFO:
+      case TOOLS.GREP:
+      case TOOLS.GIT:
+        pushPath(toolCall.path);
+        pushPath(toolCall.cwd);
+        break;
+      case TOOLS.MOVE_FILE:
+      case TOOLS.COPY_FILE:
+        pushPath(toolCall.source);
+        pushPath(toolCall.destination);
+        break;
+      case TOOLS.LOCAL_CMD: {
+        const cmdTargets = this._extractCommandDirectoryTargets(toolCall.cmd);
+        for (const t of cmdTargets) rawCandidates.push(t);
+        break;
+      }
+      default:
+        break;
+    }
+
+    for (const raw of rawCandidates) {
+      const normalized = this._normalizeTrackedPath(raw);
+      if (!normalized) continue;
+      const dirCandidate = this._getDirectoryCandidate(normalized) || normalized;
+      if (this._isPathInsideCodingRoot(dirCandidate)) continue;
+      if (this._isApprovedExternalDir(dirCandidate)) continue;
+      return {
+        required: true,
+        targetPath: dirCandidate,
+        reason: `Target is outside current coding directory (${this._codingRootPath}).`,
+      };
+    }
+
+    return { required: false };
+  },
+};