@llmtune/cli 0.1.0 → 0.1.1

package/src/tools/sandbox/docker.ts

@@ -1,225 +0,0 @@
-/**
- * Docker-based tool sandbox for enterprise deployments.
- * Isolates bash and file write operations inside a Docker container
- * to prevent accidental or malicious damage to the host system.
- */
-import { execFile } from "child_process"
-import { promisify } from "util"
-import * as path from "path"
-import * as fs from "fs"
-import * as os from "os"
-import type { ToolResult } from "../protocol"
-
-const execFileAsync = promisify(execFile)
-
-const SANDBOX_IMAGE = "llmtune-sandbox:latest"
-const SANDBOX_WORKDIR = "/workspace"
-const EXECUTION_TIMEOUT_MS = 60_000
-const MAX_OUTPUT_BYTES = 100_000
-
-export interface SandboxConfig {
-  enabled: boolean
-  image: string
-  timeoutMs: number
-  readOnlyPaths: string[]
-  maxMemoryMB: number
-}
-
-export const DEFAULT_SANDBOX_CONFIG: SandboxConfig = {
-  enabled: false,
-  image: SANDBOX_IMAGE,
-  timeoutMs: EXECUTION_TIMEOUT_MS,
-  readOnlyPaths: [],
-  maxMemoryMB: 512,
-}
-
-let sandboxConfig: SandboxConfig = { ...DEFAULT_SANDBOX_CONFIG }
-
-export function configureSandbox(config: Partial<SandboxConfig>): void {
-  sandboxConfig = { ...sandboxConfig, ...config }
-}
-
-export function isSandboxEnabled(): boolean {
-  return sandboxConfig.enabled
-}
-
-export async function isDockerAvailable(): Promise<boolean> {
-  try {
-    const { stdout } = await execFileAsync("docker", ["--version"], {
-      timeout: 5000,
-    })
-    return /docker/i.test(stdout)
-  } catch {
-    return false
-  }
-}
-
-export async function ensureSandboxImage(): Promise<boolean> {
-  try {
-    const { stdout } = await execFileAsync("docker", ["images", "-q", sandboxConfig.image], {
-      timeout: 10000,
-    })
-    if (stdout.trim()) return true
-
-    // Pull the image if not found
-    console.log(`Pulling sandbox image: ${sandboxConfig.image}...`)
-    await execFileAsync("docker", ["pull", sandboxConfig.image], {
-      timeout: 120_000,
-    })
-    return true
-  } catch {
-    return false
-  }
-}
-
-export async function runInSandbox(command: string, cwd: string): Promise<ToolResult> {
-  if (!sandboxConfig.enabled) {
-    return {
-      name: "sandbox",
-      output: { error: "Sandbox is not enabled" },
-      isError: true,
-    }
-  }
-
-  const dockerAvailable = await isDockerAvailable()
-  if (!dockerAvailable) {
-    return {
-      name: "sandbox",
-      output: { error: "Docker is not available. Install Docker to use sandbox mode." },
-      isError: true,
-    }
-  }
-
-  const workspaceMount = `${path.resolve(cwd)}:${SANDBOX_WORKDIR}`
-  const memoryLimit = `${sandboxConfig.maxMemoryMB}m`
-  const timeout = Math.min(sandboxConfig.timeoutMs, 120_000)
-
-  const args = [
-    "run",
-    "--rm",
-    "--network", "none",
-    "--memory", memoryLimit,
-    "--cpus", "1",
-    "--timeout", String(Math.ceil(timeout / 1000)),
-    "-v", `${workspaceMount}:ro`,
-    "--workdir", SANDBOX_WORKDIR,
-    sandboxConfig.image,
-    "sh", "-c", command,
-  ]
-
-  try {
-    const { stdout, stderr } = await execFileAsync("docker", args, {
-      timeout: timeout + 10_000,
-      maxBuffer: MAX_OUTPUT_BYTES,
-    })
-
-    let output = ""
-    if (stdout) output += truncateOutput(stdout)
-    if (stderr) {
-      output += "\n--- stderr ---\n"
-      output += truncateOutput(stderr)
-    }
-
-    return {
-      name: "sandbox",
-      output: {
-        stdout: output.trim(),
-        exit_code: 0,
-        sandboxed: true,
-      },
-      isError: false,
-    }
-  } catch (err: unknown) {
-    const execErr = err as { stdout?: string; stderr?: string; killed?: boolean; code?: number }
-    let output = ""
-    if (execErr.stdout) output += truncateOutput(execErr.stdout)
-    if (execErr.stderr) {
-      output += "\n--- stderr ---\n"
-      output += truncateOutput(execErr.stderr)
-    }
-    if (execErr.killed) {
-      output += `\n--- Process killed (timeout or memory limit) ---`
-    }
-
-    return {
-      name: "sandbox",
-      output: {
-        stdout: output.trim(),
-        exit_code: typeof execErr.code === "number" ? execErr.code : 1,
-        sandboxed: true,
-        timed_out: execErr.killed ?? false,
-      },
-      isError: true,
-    }
-  }
-}
-
-export async function writeFileInSandbox(
-  filePath: string,
-  content: string,
-  cwd: string,
-): Promise<ToolResult> {
-  if (!sandboxConfig.enabled) {
-    return {
-      name: "sandbox",
-      output: { error: "Sandbox is not enabled" },
-      isError: true,
-    }
-  }
-
-  // Write to a temp file on host, then copy into container
-  const tmpDir = path.join(os.tmpdir(), "llmtune-sandbox")
-  fs.mkdirSync(tmpDir, { recursive: true })
-  const tmpFile = path.join(tmpDir, `write-${Date.now()}.tmp`)
-  fs.writeFileSync(tmpFile, content, "utf-8")
-
-  try {
-    const absTarget = path.resolve(cwd, filePath)
-    const containerPath = `${SANDBOX_WORKDIR}/${path.relative(cwd, absTarget).replace(/\\/g, "/")}`
-    const workspaceMount = `${path.resolve(cwd)}:${SANDBOX_WORKDIR}`
-
-    const dockerArgs = [
-      "run",
-      "--rm",
-      "--network", "none",
-      "--memory", `${sandboxConfig.maxMemoryMB}m`,
-      "-v", `${workspaceMount}`,
-      "-v", `${tmpFile}:/tmp/write-content.tmp:ro`,
-      "--workdir", SANDBOX_WORKDIR,
-      sandboxConfig.image,
-      "sh", "-c", `mkdir -p "$(dirname '${containerPath}')" && cp /tmp/write-content.tmp '${containerPath}'`,
-    ]
-
-    await execFileAsync("docker", dockerArgs, { timeout: 30_000 })
-
-    return {
-      name: "sandbox",
-      output: {
-        type: "text",
-        filePath,
-        bytesWritten: Buffer.byteLength(content, "utf-8"),
-        sandboxed: true,
-      },
-      isError: false,
-    }
-  } catch (err: unknown) {
-    return {
-      name: "sandbox",
-      output: { error: `Sandbox write failed: ${(err as Error).message}` },
-      isError: true,
-    }
-  } finally {
-    try {
-      fs.unlinkSync(tmpFile)
-    } catch {
-      // cleanup failure is non-critical
-    }
-  }
-}
-
-function truncateOutput(output: string): string {
-  if (output.length > 50_000) {
-    return output.slice(0, 50_000) + "\n... (truncated)"
-  }
-  return output
-}

package/src/tools/sandbox/index.ts

@@ -1,91 +0,0 @@
-/**
- * Sandbox manager: decides when to use Docker isolation vs local execution.
- *
- * Modes:
- * - "off"       — all tools run locally (default)
- * - "available" — use Docker when available, fall back to local
- * - "required"  — require Docker for destructive tools (enterprise mode)
- */
-import type { ToolResult } from "../protocol"
-import { runInSandbox } from "./docker"
-
-export type SandboxMode = "off" | "available" | "required"
-
-let sandboxMode: SandboxMode = "off"
-let dockerAvailable: boolean | null = null
-
-export function getSandboxMode(): SandboxMode {
-  return sandboxMode
-}
-
-export function setSandboxMode(mode: SandboxMode): void {
-  sandboxMode = mode
-  dockerAvailable = null // re-check on next use
-}
-
-export function isDockerAvailable(): boolean {
-  if (dockerAvailable !== null) return dockerAvailable
-  // Quick check: can we run `docker info`?
-  try {
-    const { execSync } = require("child_process") as typeof import("child_process")
-    execSync("docker info", { timeout: 3000, stdio: "pipe" })
-    dockerAvailable = true
-  } catch {
-    dockerAvailable = false
-  }
-  return dockerAvailable
-}
-
-/**
- * Execute a bash command, optionally in a Docker sandbox.
- */
-export async function sandboxedExec(
-  command: string,
-  cwd: string,
-  timeout: number,
-): Promise<ToolResult> {
-  if (sandboxMode === "off") {
-    return localExec(command, cwd, timeout)
-  }
-
-  if (sandboxMode === "available" && !isDockerAvailable()) {
-    return localExec(command, cwd, timeout)
-  }
-
-  if (sandboxMode === "required" && !isDockerAvailable()) {
-    return {
-      name: "bash",
-      output: {
-        error: "Enterprise mode requires Docker but Docker is not available. Install Docker or disable enterprise mode.",
-      },
-      isError: true,
-    }
-  }
-
-  return runInSandbox(command, cwd)
-}
-
-function localExec(command: string, cwd: string, timeout: number): ToolResult {
-  const { execSync } = require("child_process") as typeof import("child_process")
-  try {
-    const stdout = execSync(command, {
-      cwd,
-      timeout,
-      maxBuffer: 1024 * 1024 * 10,
-      encoding: "utf-8",
-      shell: process.platform === "win32" ? "cmd.exe" : "/bin/bash",
-    })
-    return { name: "bash", output: { stdout: stdout || "(no output)", exitCode: 0 }, isError: false }
-  } catch (err: unknown) {
-    const e = err as { stdout?: string; stderr?: string; status?: number; killed?: boolean }
-    let output = ""
-    if (e.stdout) output += String(e.stdout).slice(0, 50_000)
-    if (e.stderr) output += "\n--- stderr ---\n" + String(e.stderr).slice(0, 50_000)
-    if (e.killed) output += `\n--- Process timed out after ${timeout}ms ---`
-    return {
-      name: "bash",
-      output: { stdout: output.trim(), exitCode: e.status ?? 1 },
-      isError: true,
-    }
-  }
-}

package/src/tools/tools/ask-user.ts

@@ -1,60 +0,0 @@
-import { createInterface } from "readline"
-import type { Tool, ToolSpec, ToolResult, ToolContext } from "../protocol"
-
-export const askUserTool: Tool = {
-  spec(): ToolSpec {
-    return {
-      name: "ask_user",
-      description:
-        "Ask the user a question and wait for their response. Use when you need clarification, confirmation, or additional information before proceeding.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          question: {
-            type: "string",
-            description: "The question to ask the user",
-          },
-          options: {
-            type: "array",
-            items: { type: "string" },
-            description: "Optional list of choices for the user to pick from",
-          },
-        },
-        required: ["question"],
-      },
-      isReadOnly: true,
-    }
-  },
-
-  async run(input: Record<string, unknown>, _ctx: ToolContext): Promise<ToolResult> {
-    const question = String(input.question ?? "")
-    if (!question) {
-      return { name: "ask_user", output: { error: "question is required" }, isError: true }
-    }
-
-    const options = Array.isArray(input.options) ? input.options.map(String) : []
-
-    if (options.length > 0) {
-      console.log(`\n  ${question}`)
-      options.forEach((opt, i) => console.log(`    ${i + 1}. ${opt}`))
-      console.log()
-    } else {
-      console.log(`\n  ${question}\n`)
-    }
-
-    const rl = createInterface({ input: process.stdin, output: process.stdout })
-
-    const answer = await new Promise<string>((resolve) => {
-      rl.question("  > ", (ans) => {
-        rl.close()
-        resolve(ans.trim())
-      })
-    })
-
-    return {
-      name: "ask_user",
-      output: { question, answer, selectedOption: options.length > 0 ? parseInt(answer) || 0 : undefined },
-      isError: false,
-    }
-  },
-}

package/src/tools/tools/bash.ts

@@ -1,97 +0,0 @@
-import { exec } from "child_process"
-import { promisify } from "util"
-import type { Tool, ToolSpec, ToolResult, ToolContext } from "../protocol"
-
-const execAsync = promisify(exec)
-
-const MAX_OUTPUT = 50_000
-const TIMEOUT_MS = 120_000
-
-export const bashTool: Tool = {
-  spec(): ToolSpec {
-    return {
-      name: "bash",
-      description:
-        "Execute a shell command. Returns stdout, stderr, and exit code. Use for running builds, tests, git commands, and other shell operations.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          command: {
-            type: "string",
-            description: "The command to execute",
-          },
-          timeout: {
-            type: "number",
-            description: "Optional timeout in ms (default 120000, max 300000)",
-          },
-        },
-        required: ["command"],
-      },
-      isReadOnly: false,
-      isDestructive: true,
-    }
-  },
-
-  async run(
-    input: Record<string, unknown>,
-    _ctx: ToolContext
-  ): Promise<ToolResult> {
-    const command = String(input.command ?? "")
-    const timeout = Math.min(
-      typeof input.timeout === "number" ? input.timeout : TIMEOUT_MS,
-      300_000
-    )
-
-    if (!command.trim()) {
-      return { name: "bash", output: { error: "command is required" }, isError: true }
-    }
-
-    try {
-      const { stdout, stderr } = await execAsync(command, {
-        maxBuffer: 1024 * 1024 * 10,
-        timeout,
-        shell: process.platform === "win32" ? "cmd" : "/bin/bash",
-      })
-
-      let output = ""
-      if (stdout) {
-        output += stdout.length > MAX_OUTPUT
-          ? stdout.slice(0, MAX_OUTPUT) + "\n... (truncated)"
-          : stdout
-      }
-      if (stderr) {
-        output += "\n--- stderr ---\n"
-        output += stderr.length > MAX_OUTPUT
-          ? stderr.slice(0, MAX_OUTPUT) + "\n... (truncated)"
-          : stderr
-      }
-
-      return {
-        name: "bash",
-        output: { stdout: output.trim(), exit_code: 0 },
-        isError: false,
-      }
-    } catch (err: unknown) {
-      const e = err as { stdout?: string; stderr?: string; code?: number | string; killed?: boolean }
-      const stdout = e.stdout || ""
-      const stderr = e.stderr || ""
-      const exitCode = typeof e.code === "number" ? e.code : 1
-
-      let output = ""
-      if (stdout) output += stdout.slice(0, MAX_OUTPUT)
-      if (stderr) {
-        output += "\n--- stderr ---\n"
-        output += stderr.slice(0, MAX_OUTPUT)
-      }
-      if (e.killed) {
-        output += `\n--- Process timed out after ${timeout}ms ---`
-      }
-
-      return {
-        name: "bash",
-        output: { stdout: output.trim(), exit_code: exitCode },
-        isError: true,
-      }
-    }
-  },
-}

package/src/tools/tools/edit.ts

@@ -1,111 +0,0 @@
-import * as fs from "fs/promises"
-import * as path from "path"
-import type { Tool, ToolResult, ToolContext } from "../protocol"
-
-export const editTool: Tool = {
-  spec() {
-    return {
-      name: "edit",
-      description:
-        "Edit a file by replacing old text with new text. Supports replacing all occurrences.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          file_path: {
-            type: "string",
-            description: "Path to the file to edit",
-          },
-          old_string: {
-            type: "string",
-            description: "The text to find and replace",
-          },
-          new_string: {
-            type: "string",
-            description: "The replacement text",
-          },
-          replace_all: {
-            type: "boolean",
-            description: "Replace all occurrences (default: false)",
-          },
-        },
-        required: ["file_path", "old_string", "new_string"],
-      },
-      isReadOnly: false,
-      isDestructive: true,
-    }
-  },
-
-  async run(input: Record<string, unknown>, ctx: ToolContext): Promise<ToolResult> {
-    const filePath = String(input.file_path ?? "")
-    const oldString = String(input.old_string ?? "")
-    const newString = String(input.new_string ?? "")
-    const replaceAll = Boolean(input.replace_all)
-
-    if (!filePath) {
-      return { name: "edit", output: { error: "file_path is required" }, isError: true }
-    }
-    if (!oldString) {
-      return { name: "edit", output: { error: "old_string is required" }, isError: true }
-    }
-
-    const resolved = path.resolve(ctx.cwd, filePath)
-
-    let content: string
-    try {
-      content = await fs.readFile(resolved, "utf-8")
-    } catch (err: unknown) {
-      return {
-        name: "edit",
-        output: { error: `Failed to read file: ${(err as Error).message}` },
-        isError: true,
-      }
-    }
-
-    if (!content.includes(oldString)) {
-      return {
-        name: "edit",
-        output: {
-          error: `old_string not found in ${filePath}`,
-          hint: "Make sure the old_string matches exactly, including whitespace.",
-        },
-        isError: true,
-      }
-    }
-
-    const occurrences = content.split(oldString).length - 1
-    if (occurrences > 1 && !replaceAll) {
-      return {
-        name: "edit",
-        output: {
-          error: `Found ${occurrences} occurrences. Use replace_all: true or provide more specific old_string.`,
-          occurrences,
-        },
-        isError: true,
-      }
-    }
-
-    const newContent = replaceAll
-      ? content.split(oldString).join(newString)
-      : content.replace(oldString, newString)
-
-    try {
-      await fs.writeFile(resolved, newContent, "utf-8")
-    } catch (err: unknown) {
-      return {
-        name: "edit",
-        output: { error: `Failed to write file: ${(err as Error).message}` },
-        isError: true,
-      }
-    }
-
-    return {
-      name: "edit",
-      output: {
-        file_path: filePath,
-        replacements: replaceAll ? occurrences : 1,
-        status: "edited",
-      },
-      isError: false,
-    }
-  },
-}

package/src/tools/tools/glob.ts

@@ -1,68 +0,0 @@
-import * as fs from "fs"
-import * as path from "path"
-import { glob } from "glob"
-import type { Tool, ToolSpec, ToolResult, ToolContext } from "../protocol"
-
-export const globTool: Tool = {
-  spec(): ToolSpec {
-    return {
-      name: "glob",
-      description:
-        "Search for files matching a glob pattern. Returns matching file paths relative to the workspace root.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          pattern: {
-            type: "string",
-            description: "Glob pattern (e.g. '**/*.ts', 'src/**/*.py')",
-          },
-          path: {
-            type: "string",
-            description: "Base directory for the search (default: workspace root)",
-          },
-        },
-        required: ["pattern"],
-      },
-      isReadOnly: true,
-    }
-  },
-
-  async run(input: Record<string, unknown>, ctx: ToolContext): Promise<ToolResult> {
-    const pattern = String(input.pattern ?? "")
-    const baseDir = String(input.path ?? ctx.workspaceRoot)
-
-    if (!pattern) {
-      return { name: "glob", output: { error: "pattern is required" }, isError: true }
-    }
-
-    try {
-      const matches = await glob(pattern, {
-        cwd: baseDir,
-        nodir: true,
-        absolute: false,
-        ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/.next/**"],
-      })
-
-      const truncated = matches.length > 500
-      const limited = truncated ? matches.slice(0, 500) : matches
-
-      return {
-        name: "glob",
-        output: {
-          pattern,
-          baseDir,
-          matches: limited,
-          numFiles: matches.length,
-          truncated,
-        },
-        isError: false,
-      }
-    } catch (err: unknown) {
-      return {
-        name: "glob",
-        output: { error: String((err as Error).message ?? err) },
-        isError: true,
-      }
-    }
-  },
-}