lcagent-cli 0.1.5 → 0.1.7

package/dist/tools/permissions.js

@@ -0,0 +1,105 @@
+import { isAbsolute, normalize, relative, resolve, sep } from 'node:path';
+export const DANGEROUS_FILES = [
+    '.gitconfig',
+    '.gitmodules',
+    '.bashrc',
+    '.bash_profile',
+    '.zshrc',
+    '.zprofile',
+    '.profile',
+    '.mcp.json',
+    '.claude.json',
+];
+export const DANGEROUS_DIRECTORIES = ['.git', '.vscode', '.idea', '.claude'];
+function normalizeCaseForComparison(filePath) {
+    return filePath.toLowerCase();
+}
+function resolveTargetPath(cwd, targetPath) {
+    return isAbsolute(targetPath) ? normalize(targetPath) : normalize(resolve(cwd, targetPath));
+}
+function toDisplayPath(cwd, absolutePath) {
+    const relativePath = relative(cwd, absolutePath);
+    if (!relativePath || relativePath.startsWith(`..${sep}`) || relativePath === '..') {
+        return absolutePath;
+    }
+    return relativePath;
+}
+function isDangerousPath(absolutePath) {
+    const normalizedPath = normalizeCaseForComparison(absolutePath);
+    const pathSegments = normalizedPath.split(/[\\/]+/).filter(Boolean);
+    const fileName = pathSegments[pathSegments.length - 1];
+    if (fileName && DANGEROUS_FILES.includes(fileName)) {
+        return true;
+    }
+    return pathSegments.some(segment => DANGEROUS_DIRECTORIES.includes(segment));
+}
+function extractPatchTarget(patchText) {
+    const lines = patchText.split(/\r?\n/);
+    for (const line of lines) {
+        if (line.startsWith('+++ ') || line.startsWith('--- ')) {
+            const rawPath = line.slice(4).trim();
+            if (!rawPath || rawPath === '/dev/null') {
+                continue;
+            }
+            return rawPath.replace(/^(a|b)\//, '');
+        }
+    }
+    return null;
+}
+function extractCandidateTargets(toolName, input) {
+    if (!input || typeof input !== 'object') {
+        return [];
+    }
+    const record = input;
+    const directPath = [record.path, record.filePath, record.file_path]
+        .find(value => typeof value === 'string' && value.trim().length > 0);
+    if (toolName === 'grep') {
+        const searchPath = [record.path, record.directory]
+            .find(value => typeof value === 'string' && value.trim().length > 0);
+        return searchPath ? [String(searchPath)] : [];
+    }
+    if (toolName === 'run_shell') {
+        return [];
+    }
+    const patchText = [record.patch, record.diff, record.unifiedDiff, record.unified_diff]
+        .find(value => typeof value === 'string' && value.trim().length > 0);
+    const patchPath = typeof patchText === 'string' ? extractPatchTarget(patchText) : null;
+    return [directPath, patchPath].filter((value) => Boolean(value));
+}
+export function buildApprovalRequest(tool, input, context) {
+    if (context.approvalMode === 'auto') {
+        return null;
+    }
+    if (tool.isReadOnly) {
+        return null;
+    }
+    const candidateTargets = extractCandidateTargets(tool.name, input);
+    const absoluteTargets = candidateTargets.map(target => resolveTargetPath(context.cwd, target));
+    const displayTargets = absoluteTargets.map(target => toDisplayPath(context.cwd, target));
+    const hasDangerousTarget = absoluteTargets.some(isDangerousPath);
+    if (tool.name === 'run_shell') {
+        const command = input && typeof input === 'object'
+            ? input.command ?? input.cmd
+            : undefined;
+        return {
+            toolName: tool.name,
+            summary: `Shell execution requested${typeof command === 'string' ? `: ${command}` : '.'}`,
+            reason: 'run_shell can execute arbitrary commands and modify the filesystem or environment.',
+            targets: [],
+            risk: 'high',
+            input,
+        };
+    }
+    return {
+        toolName: tool.name,
+        summary: displayTargets.length > 0
+            ? `Write access requested for ${displayTargets.join(', ')}`
+            : 'Write access requested.',
+        reason: hasDangerousTarget
+            ? 'Target includes a protected configuration or metadata path from the Claude Code-style danger list.'
+            : 'This tool can modify files on disk.',
+        targets: displayTargets,
+        risk: hasDangerousTarget ? 'high' : 'medium',
+        input,
+    };
+}

package/dist/tools/readFile.d.ts

@@ -1,9 +1,13 @@
 import { z } from 'zod';
 import type { ToolDefinition } from './types.js';
 declare const inputSchema: z.ZodObject<{
-    path: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    filePath: z.ZodOptional<z.ZodString>;
+    file_path: z.ZodOptional<z.ZodString>;
     startLine: z.ZodOptional<z.ZodNumber>;
+    start_line: z.ZodOptional<z.ZodNumber>;
     endLine: z.ZodOptional<z.ZodNumber>;
+    end_line: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export declare const readFileTool: ToolDefinition<z.infer<typeof inputSchema>>;
 export {};

package/dist/tools/readFile.js

@@ -2,9 +2,13 @@ import { readFile } from 'node:fs/promises';
 import { isAbsolute, resolve } from 'node:path';
 import { z } from 'zod';
 const inputSchema = z.object({
-    path: z.string().min(1),
+    path: z.string().min(1).optional(),
+    filePath: z.string().min(1).optional(),
+    file_path: z.string().min(1).optional(),
     startLine: z.number().int().positive().optional(),
+    start_line: z.number().int().positive().optional(),
     endLine: z.number().int().positive().optional(),
+    end_line: z.number().int().positive().optional(),
 });
 function resolvePath(cwd, filePath) {
     return isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
@@ -25,11 +29,20 @@ export const readFileTool = {
     },
     isReadOnly: true,
     async execute(input, context) {
-        const absolutePath = resolvePath(context.cwd, input.path);
+        const normalizedPath = input.path ?? input.filePath ?? input.file_path;
+        if (!normalizedPath) {
+            return {
+                isError: true,
+                content: 'Missing required field: path',
+            };
+        }
+        const startLine = input.startLine ?? input.start_line;
+        const endLine = input.endLine ?? input.end_line;
+        const absolutePath = resolvePath(context.cwd, normalizedPath);
         const contents = await readFile(absolutePath, 'utf8');
         const lines = contents.split(/\r?\n/);
-        const start = Math.max((input.startLine ?? 1) - 1, 0);
-        const end = Math.min(input.endLine ?? lines.length, lines.length);
+        const start = Math.max((startLine ?? 1) - 1, 0);
+        const end = Math.min(endLine ?? lines.length, lines.length);
         const slice = lines.slice(start, end);
         const numbered = slice
             .map((line, index) => `${start + index + 1}: ${line}`)

package/dist/tools/runShell.d.ts

@@ -1,7 +1,8 @@
 import { z } from 'zod';
 import type { ToolDefinition } from './types.js';
 declare const inputSchema: z.ZodObject<{
-    command: z.ZodString;
+    command: z.ZodOptional<z.ZodString>;
+    cmd: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const runShellTool: ToolDefinition<z.infer<typeof inputSchema>>;
 export {};

package/dist/tools/runShell.js

@@ -3,7 +3,8 @@ import { promisify } from 'node:util';
 import { z } from 'zod';
 const execAsync = promisify(exec);
 const inputSchema = z.object({
-    command: z.string().min(1),
+    command: z.string().min(1).optional(),
+    cmd: z.string().min(1).optional(),
 });
 export const runShellTool = {
     name: 'run_shell',
@@ -22,16 +23,17 @@ export const runShellTool = {
     },
     isReadOnly: false,
     async execute(input, context) {
-        if (context.approvalMode === 'manual') {
-            return {
-                isError: true,
-                content: 'run_shell is blocked in manual approval mode. Switch config approvalMode to auto to enable shell execution.',
-            };
-        }
         try {
-            const { stdout, stderr } = await execAsync(input.command, {
+            const command = input.command ?? input.cmd;
+            if (!command) {
+                return {
+                    isError: true,
+                    content: 'Missing required field: command',
+                };
+            }
+            const { stdout, stderr } = await execAsync(command, {
                 cwd: context.cwd,
-                shell: '/bin/sh',
+                shell: process.platform === 'win32' ? process.env.ComSpec || 'cmd.exe' : '/bin/sh',
                 maxBuffer: 1024 * 1024,
             });
             const output = [stdout.trim(), stderr.trim()].filter(Boolean).join('\n');

package/dist/tools/types.d.ts

@@ -2,10 +2,38 @@ import type { z } from 'zod';
 export type ToolExecutionResult = {
     content: string;
     isError?: boolean;
+    meta?: ToolExecutionMeta;
+};
+export type ToolFailureStage = 'lookup' | 'validation' | 'approval' | 'execution';
+export type ToolApprovalRequest = {
+    toolName: string;
+    summary: string;
+    reason: string;
+    targets: string[];
+    risk: 'low' | 'medium' | 'high';
+    input: unknown;
+};
+export type ToolApprovalResponse = {
+    approved: boolean;
+    reason?: string;
+};
+export type ToolApprovalMeta = {
+    mode: 'auto' | 'manual';
+    required: boolean;
+    approved?: boolean;
+    risk?: 'low' | 'medium' | 'high';
+    targets?: string[];
+};
+export type ToolExecutionMeta = {
+    cwd: string;
+    durationMs: number;
+    approval: ToolApprovalMeta;
+    failureStage?: ToolFailureStage;
 };
 export type ToolContext = {
     cwd: string;
     approvalMode: 'auto' | 'manual';
+    requestApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResponse>;
 };
 export type AnthropicToolDefinition = {
     name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lcagent-cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "A minimal coding agent CLI for terminal-based coding workflows.",
   "type": "module",
   "publishConfig": {
@@ -18,6 +18,7 @@
     "dev": "tsx src/bin/cli.ts",
     "build": "tsc -p tsconfig.json",
     "check": "tsc -p tsconfig.json --noEmit",
+    "smoke": "npm run build && node ./scripts/smoke.mjs",
     "start": "node dist/bin/cli.js",
     "prepublishOnly": "npm run build"
   },
@@ -32,6 +33,7 @@
   ],
   "dependencies": {
     "commander": "^11.1.0",
+    "diff": "^8.0.4",
     "undici": "^5.28.5",
     "zod": "^4.1.5"
   },