lonny-agent 0.2.4 → 0.2.7

package/src/tools/execute/bash/index.ts

@@ -0,0 +1,131 @@
+import * as os from 'node:os'
+
+import { fmtErr } from '../../errors.js'
+import type { Tool, ToolResult } from '../../types.js'
+import { MAX_OUTPUT_LENGTH } from './constants.js'
+import { buildErrorMsg, extractPowerShellNativeOutput, truncateOutput } from './errors.js'
+import { execCommand } from './execution.js'
+import { ENCODING, env } from './platform.js'
+import { checkDestructive, redactSensitive } from './security.js'
+import { validateInput } from './validation.js'
+
+export const bashTool: Tool = {
+  definition: {
+    name: 'bash',
+    category: 'Execute',
+    group: 'Shell',
+    description: `Execute a shell command. Returns stdout and stderr.
+
+Environment: ${env.osInfo}
+Shell: ${env.shell}
+Console encoding: ${ENCODING}
+
+⚠️  Use this tool for READ-ONLY operations (run tests, check builds, list files).
+For creating/modifying files, use the 'edit' tool instead.
+For git operations (status, diff, log), use the 'git' tool instead.`,
+    parameters: {
+      command: {
+        type: 'string',
+        description: 'Shell command to execute (required, non-empty string)',
+        required: true,
+      },
+      description: {
+        type: 'string',
+        description:
+          'Brief description (e.g. "Run unit tests"). Included in the output for traceability.',
+      },
+      timeout: {
+        type: 'number',
+        description:
+          'Timeout in ms (100-600000, default: 120000). Increase for slow operations like npm install.',
+      },
+      cwd: {
+        type: 'string',
+        description:
+          'Working directory path. Use when you need to run a command inside a subdirectory. Must exist.',
+      },
+    },
+  },
+  async execute(input): Promise<ToolResult> {
+    // ── Step 1: Validate input ──────────────────────────────────────────
+    const validated = validateInput(input)
+    if (!validated.ok) {
+      return { success: false, output: '', error: validated.error }
+    }
+
+    const { command, timeout, description, cwd } = validated
+
+    // ── Step 2: Security check ──────────────────────────────────────────
+    const destructiveHint = checkDestructive(command)
+    if (destructiveHint) {
+      return {
+        success: false,
+        output: '',
+        error: `Destructive command blocked: ${destructiveHint}.\nUse the 'edit' tool for file modifications instead.`,
+      }
+    }
+
+    try {
+      const { stdout, stderr, exitCode, timedOut } = await execCommand(command, timeout, cwd)
+
+      // ── Step 3: Build output ──────────────────────────────────────────
+      let output = ''
+      if (description) {
+        output += `[bash] ${description}\n`
+      }
+
+      // Redact sensitive data from output (API keys, tokens, passwords, etc.)
+      const stdoutTrimmed = redactSensitive(stdout.trim())
+      if (stdoutTrimmed) {
+        output += stdoutTrimmed
+      }
+
+      let stderrTrimmed = redactSensitive(stderr.trim())
+
+      // On Windows, PowerShell wraps native command stderr in ErrorRecord format
+      // even when the command succeeds (exit code 0). Detect this and extract the
+      // actual message content so it doesn't pollute output with "Command exited..." noise.
+      if (exitCode === 0 && stderrTrimmed && os.platform() === 'win32') {
+        const cleaned = extractPowerShellNativeOutput(stderrTrimmed)
+        if (cleaned) {
+          // Prepend a newline if there's already output
+          output += (output ? '\n' : '') + cleaned
+          stderrTrimmed = ''
+        }
+      }
+
+      if (stderrTrimmed) {
+        if (output) output += '\n'
+        output += `(stderr):\n${stderrTrimmed}`
+      }
+
+      // Apply global truncation
+      output = truncateOutput(output, MAX_OUTPUT_LENGTH, 'output')
+
+      if (!output || output === (description ? `[bash] ${description}\n` : '')) {
+        output = description ? `[bash] ${description}\n(no output)` : '(no output)'
+      }
+
+      if (timedOut) {
+        return {
+          success: false,
+          output,
+          error: buildErrorMsg(0, stderr, command, true, cwd),
+        }
+      }
+
+      if (exitCode !== 0) {
+        return {
+          success: false,
+          output,
+          error: buildErrorMsg(exitCode, stderr, command, false, cwd),
+        }
+      }
+
+      return { success: true, output }
+    } catch (err) {
+      const msg = fmtErr(err)
+      return { success: false, output: '', error: `Command failed unexpectedly: ${msg}` }
+    }
+  },
+}

package/src/tools/execute/bash/platform.ts

@@ -0,0 +1,65 @@
+import { execSync } from 'node:child_process'
+import * as os from 'node:os'
+
+function detectEnv(): { osInfo: string; shell: string } {
+  const platform = os.platform()
+  const release = os.release()
+  const arch = os.arch()
+
+  if (platform === 'win32') {
+    return {
+      osInfo: `Windows ${release} (${arch})`,
+      shell: 'powershell.exe',
+    }
+  }
+
+  const osName = platform === 'darwin' ? 'macOS' : platform === 'linux' ? 'Linux' : platform
+  return {
+    osInfo: `${osName} ${release} (${arch})`,
+    shell: process.env.SHELL || '/bin/sh',
+  }
+}
+
+export const env = detectEnv()
+
+/**
+ * Detect Windows console code page to handle non-UTF-8 output correctly.
+ * Falls back to 'utf-8' if detection fails.
+ * On non-Windows platforms, always returns 'utf-8'.
+ */
+function detectEncoding(): string {
+  if (os.platform() !== 'win32') return 'utf-8'
+  try {
+    const result = execSync('[Console]::OutputEncoding.CodePage', {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 2000,
+      windowsHide: true,
+      encoding: 'utf-8',
+      shell: 'powershell.exe',
+    })
+    const cp = Number.parseInt(result.toString().trim(), 10)
+    // Common Windows code pages that need special handling
+    if (cp === 936) return 'gbk' // Chinese (Simplified)
+    if (cp === 950) return 'big5' // Chinese (Traditional)
+    if (cp === 932) return 'shift-jis' // Japanese
+    if (cp === 949) return 'euc-kr' // Korean
+    if (
+      cp === 1250 ||
+      cp === 1251 ||
+      cp === 1252 ||
+      cp === 1253 ||
+      cp === 1254 ||
+      cp === 1255 ||
+      cp === 1256 ||
+      cp === 1257
+    ) {
+      return `cp${cp}` // Windows code page
+    }
+    return 'utf-8'
+  } catch {
+    return 'utf-8'
+  }
+}
+
+// Cache encoding detection once at startup
+export const ENCODING = detectEncoding()

package/src/tools/execute/bash/security.ts

@@ -0,0 +1,28 @@
+import { DESTRUCTIVE_PATTERNS, SENSITIVE_PATTERNS } from './constants.js'
+
+/**
+ * Check if a command matches destructive patterns.
+ * Returns a warning string if detected, null otherwise.
+ */
+function checkDestructive(command: string): string | null {
+  for (const { regex, hint } of DESTRUCTIVE_PATTERNS) {
+    if (regex.test(command)) {
+      return hint
+    }
+  }
+  return null
+}
+
+/**
+ * Redact sensitive data from a string by replacing matches with "[REDACTED]".
+ * Returns the redacted string.
+ */
+function redactSensitive(s: string): string {
+  let result = s
+  for (const pattern of SENSITIVE_PATTERNS) {
+    result = result.replace(pattern, '[REDACTED]')
+  }
+  return result
+}
+
+export { checkDestructive, redactSensitive }

package/src/tools/execute/bash/validation.ts

@@ -0,0 +1,78 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+import { DEFAULT_TIMEOUT, MAX_TIMEOUT, MIN_TIMEOUT } from './constants.js'
+
+interface ValidatedInput {
+  ok: true
+  command: string
+  timeout: number
+  description: string
+  cwd: string | undefined
+}
+interface InputError {
+  ok: false
+  error: string
+}
+type ValidateResult = ValidatedInput | InputError
+
+function validateInput(input: Record<string, unknown>): ValidateResult {
+  // command: must be a non-empty string
+  const command = input.command
+  if (command === undefined || command === null) {
+    return { ok: false, error: 'command is required' }
+  }
+  if (typeof command !== 'string') {
+    return { ok: false, error: `command must be a string, got ${typeof command}` }
+  }
+  if (command.trim() === '') {
+    return { ok: false, error: 'command must not be empty or whitespace-only' }
+  }
+
+  // timeout: must be a number (or default), within bounds
+  let timeout = DEFAULT_TIMEOUT
+  if (input.timeout !== undefined) {
+    if (
+      typeof input.timeout === 'number' &&
+      !Number.isNaN(input.timeout) &&
+      Number.isFinite(input.timeout)
+    ) {
+      timeout = Math.round(input.timeout)
+      if (timeout < MIN_TIMEOUT) {
+        timeout = MIN_TIMEOUT
+      } else if (timeout > MAX_TIMEOUT) {
+        timeout = MAX_TIMEOUT
+      }
+    }
+    // If timeout is not a valid number, silently use default
+  }
+
+  // description: optional string
+  const description = typeof input.description === 'string' ? input.description : ''
+
+  // cwd: optional string, must be a valid directory, no path traversal
+  let cwd: string | undefined
+  if (typeof input.cwd === 'string' && input.cwd.trim()) {
+    const rawCwd = input.cwd.trim()
+    // Path traversal protection
+    if (/(?:^|[\\/])\.\.(?:[\\/]|$)/.test(rawCwd)) {
+      return {
+        ok: false,
+        error: `cwd contains path traversal (..) which is not allowed: "${rawCwd}"`,
+      }
+    }
+    const resolvedCwd = path.resolve(rawCwd)
+    if (!fs.existsSync(resolvedCwd)) {
+      return { ok: false, error: `cwd directory does not exist: "${resolvedCwd}"` }
+    }
+    if (!fs.statSync(resolvedCwd).isDirectory()) {
+      return { ok: false, error: `cwd is not a directory: "${resolvedCwd}"` }
+    }
+    cwd = resolvedCwd
+  }
+
+  return { ok: true, command: command.trim(), timeout, description, cwd }
+}
+
+export type { InputError, ValidatedInput, ValidateResult }
+export { validateInput }

package/src/tools/execute/git.ts

@@ -0,0 +1,209 @@
+import { exec } from 'node:child_process'
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import type { Tool, ToolDefinition } from '../types.js'
+
+/** Normalize a git command string — strip common LLM mistakes. */
+function normalizeGitCommand(raw: string): string {
+  let cmd = String(raw).trim()
+  // LLM often writes `git("git status")` or `git("git status --short")`
+  cmd = cmd.replace(/^git\s+/, '')
+  // Strip leading `git(` or `git'` artifacts from LLM hallucination
+  cmd = cmd.replace(/^git['"(]\s*/, '').replace(/['")]\s*$/, '')
+  return cmd
+}
+
+/** Common corrections map for git subcommand typos. */
+const COMMON_TYPOS: Record<string, string> = {
+  stauts: 'status',
+  staus: 'status',
+  statsu: 'status',
+  comit: 'commit',
+  commmit: 'commit',
+  brach: 'branch',
+  branc: 'branch',
+  chekout: 'checkout',
+  checkut: 'checkout',
+  'diff --staged': 'diff --cached',
+  'diff --stage': 'diff --cached',
+}
+
+/** Suggest a fix for a failed git command based on stderr content. */
+function suggestFix(cmd: string, stderr: string): string | null {
+  const lower = stderr.toLowerCase()
+  if (lower.includes('not a git repository') || lower.includes('not a git repo')) {
+    return 'Not a git repository. Check that you are in the correct directory.'
+  }
+  if (lower.includes('did not match any file(s) known to git')) {
+    return 'The path does not match any tracked files. Use `git status` to see tracked files first.'
+  }
+  if (lower.includes('pathspec') && lower.includes('did not match')) {
+    return 'The pathspec did not match. Check the file path is correct and tracked by git.'
+  }
+  if (lower.includes('unknown option') || lower.includes('usage:')) {
+    return 'Unknown flag or syntax error. Check `git help` for the correct usage.'
+  }
+  if (lower.includes('ambiguous argument')) {
+    return 'Ambiguous argument. Try quoting the path or using `--` to separate options from paths.'
+  }
+  if (lower.includes('permission denied') || lower.includes('denied')) {
+    return 'Permission denied. You may not have access to this repository.'
+  }
+  return null
+}
+
+export const createGitTool = (cwd: string): Tool => {
+  const definition: ToolDefinition = {
+    name: 'git',
+    category: 'Execute',
+    group: 'Git',
+    description: `Run git commands for repository operations.
+
+COMMON USE CASES:
+  git({ command: "status" })             # Working tree status
+  git({ command: "diff" })               # Unstaged changes
+  git({ command: "diff --cached" })      # Staged changes
+  git({ command: "log --oneline -5" })   # Recent commits
+  git({ command: "show <hash>" })        # Show a specific commit
+  git({ command: "branch" })             # List branches
+  git({ command: "branch -a" })          # List all branches (including remote)
+
+NOTES:
+  - Omit the "git" prefix — just pass the subcommand.
+  - Use \`cwd\` to run in a subdirectory of the repo.`,
+    parameters: {
+      command: {
+        type: 'string',
+        description:
+          'Git subcommand and arguments (e.g. "status", "diff", "log --oneline -5"). Do NOT include the "git " prefix.',
+        required: true,
+      },
+      path: {
+        type: 'string',
+        description: 'Repository path (alias: cwd). Defaults to working directory.',
+        required: false,
+      },
+      cwd: {
+        type: 'string',
+        description: 'Working directory (alias: path). Defaults to working directory.',
+        required: false,
+      },
+    },
+  }
+
+  const execute = async (
+    input: Record<string, unknown>,
+  ): Promise<{ success: boolean; output: string; error?: string }> => {
+    let gitCmd = normalizeGitCommand(String(input.command || ''))
+
+    // Accept both `path` and `cwd` parameters (LLM convention)
+    const repoPath = String(input.path || input.cwd || cwd)
+
+    if (!gitCmd) {
+      return {
+        success: false,
+        output: '',
+        error:
+          'command is required. Use: git({ command: "status" }) — pass the subcommand without the "git " prefix.',
+      }
+    }
+
+    // Auto-correct common typos in the first subcommand word
+    const firstWord = gitCmd.split(/\s+/)[0]!
+    if (firstWord && COMMON_TYPOS[firstWord]) {
+      gitCmd = gitCmd.replace(firstWord, COMMON_TYPOS[firstWord]!)
+    }
+
+    // Safety: block destructive commands (checked AFTER normalization)
+    const destructivePatterns = [
+      /^push\b/i,
+      /^reset\s+(--hard|--soft|--mixed|--merge|--keep)/i,
+      /^(rebase|merge|cherry-pick|revert)\b/i,
+      /^branch\s+-[dD]/i,
+      /^branch\s+--delete\b/i,
+      /^tag\s+-[dD]/i,
+      /^(clean|gc|prune)\b/i,
+      /^update-ref\b/i,
+      /^rm\b/i,
+      /^commit\b/i,
+      /^checkout\b/i,
+      /^fetch\s+.*--force/i,
+      /^stash\s+(drop|clear)\b/i,
+      /^config\b/i,
+    ]
+
+    for (const pattern of destructivePatterns) {
+      if (pattern.test(gitCmd)) {
+        return {
+          success: false,
+          output: '',
+          error: `Destructive git command not allowed: "${gitCmd}". Only read-only operations are permitted. If you need to make changes, use the \`edit\` tool for file modifications and git add/commit for staging.`,
+        }
+      }
+    }
+
+    // Verify the repo path exists
+    if (!fs.existsSync(repoPath)) {
+      return {
+        success: false,
+        output: '',
+        error: `Repository path does not exist: "${repoPath}". Use a valid directory path.`,
+      }
+    }
+    if (!fs.statSync(repoPath).isDirectory()) {
+      return {
+        success: false,
+        output: '',
+        error: `Repository path is not a directory: "${repoPath}".`,
+      }
+    }
+
+    return new Promise(resolve => {
+      const child = exec(
+        `git ${gitCmd}`,
+        {
+          cwd: repoPath,
+          encoding: 'utf-8',
+          timeout: 30000,
+          maxBuffer: 10 * 1024 * 1024, // 10MB
+        },
+        (err, stdout, stderr) => {
+          if (err) {
+            const exitCode = typeof err.code === 'number' ? err.code : -1
+            const stderrMsg = stderr?.trim() || ''
+            const stdoutMsg = stdout?.trim() || ''
+
+            // git diff exits with 1 when there are differences — that's not an error
+            if ((gitCmd.startsWith('diff') || gitCmd.startsWith('status')) && stdoutMsg) {
+              return resolve({ success: true, output: stdoutMsg })
+            }
+
+            let errorMsg = stderrMsg || err.message || String(err)
+            const hint = suggestFix(gitCmd, errorMsg)
+            if (hint) errorMsg += `\n💡 ${hint}`
+
+            return resolve({
+              success: exitCode === 0 && stdoutMsg ? true : false,
+              output: stdoutMsg,
+              error: errorMsg,
+            })
+          }
+
+          const output = (stdout || '').trim() || '(empty output)'
+          return resolve({ success: true, output })
+        },
+      )
+
+      // Handle spawn error (e.g. git not installed)
+      child.on('error', spawnErr => {
+        return resolve({
+          success: false,
+          output: '',
+          error: `Failed to run git: ${spawnErr.message}. Ensure git is installed and in your PATH.`,
+        })
+      })
+    })
+  }
+
+  return { definition, execute }
+}

package/src/tools/execute/task_complete.ts

@@ -0,0 +1,40 @@
+import type { Tool, ToolResult } from '../types.js'
+
+/**
+ * A tool the model can call to explicitly signal that the task is complete.
+ * In loop mode, this stops the automatic continuation and ends the session.
+ */
+export const taskCompleteTool: Tool = {
+  definition: {
+    name: 'task_complete',
+    description: `Call this ONLY when you have confirmed at least THREE TIMES that the task is truly complete.
+
+  ⚠️  TRIPLE CONFIRMATION REQUIRED ⚠️
+  Before calling this tool, you MUST verify each of the following three checks:
+
+  Check 1 — All requested work is done: Have you addressed every item the user asked for?
+  Check 2 — All changes are verified: Did you run the relevant tests / build / commands and confirm they pass?
+  Check 3 — No remaining steps: Is there nothing left to do? No pending edits, unverified changes, or unanswered questions?
+
+  Only call this tool after all three checks pass. If any check fails, continue working instead.
+
+  Use this instead of just describing completion in text — calling this tool explicitly signals the system to stop processing.
+
+  Examples:
+    - After finishing all requested edits AND verifying they work (all 3 checks pass)
+    - After completing a research task AND presenting findings (all 3 checks pass)
+    - After a planned task is fully executed AND verified (all 3 checks pass)`,
+    parameters: {
+      summary: {
+        type: 'string',
+        description:
+          'A brief summary of what was accomplished in this session (include the 3 checks you verified)',
+        required: true,
+      },
+    },
+  },
+  async execute(input): Promise<ToolResult> {
+    const summary = (input.summary as string) || ''
+    return { success: true, output: `TASK_COMPLETE: ${summary}` }
+  },
+}