@yeyuan98/opencode-bioresearcher-plugin 1.5.1 → 1.5.2-alpha.3

package/dist/tools/sandbox/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Sandbox Tool Types
+ *
+ * TypeScript interfaces for the sandbox system.
+ */
+/**
+ * Represents the active sandbox state for a session.
+ */
+export interface SandboxState {
+    sessionID: string;
+    sessionName: string;
+    sandboxPath: string;
+    projectRoot: string;
+    enabled: boolean;
+    enabledAt: number;
+}
+/**
+ * Result of path validation and transformation.
+ */
+export interface PathValidationResult {
+    allowed: boolean;
+    originalPath: string;
+    transformedPath: string;
+    error?: string;
+}
+/**
+ * Result of bash command path extraction.
+ */
+export interface BashPathExtractionResult {
+    paths: string[];
+    hasAbsolutePath: boolean;
+    absolutePaths: string[];
+}
+/**
+ * Tool path argument configuration.
+ * Maps tool names to their path-containing argument names.
+ */
+export type ToolPathArgsMap = Record<string, string[]>;

package/dist/tools/sandbox/types.js

@@ -0,0 +1,6 @@
+/**
+ * Sandbox Tool Types
+ *
+ * TypeScript interfaces for the sandbox system.
+ */
+export {};

package/dist/tools/sandbox/validator.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Sandbox Path Validator
+ *
+ * Validates and transforms file paths for sandbox containment.
+ * Handles cross-platform path operations (Windows, macOS, Linux).
+ */
+import type { PathValidationResult } from './types';
+/**
+ * Check if a string is an absolute path (cross-platform).
+ */
+export declare function isAbsolutePath(inputPath: string): boolean;
+/**
+ * Check if a resolved path is within the sandbox directory.
+ * Handles cross-platform case sensitivity.
+ */
+export declare function isPathWithinSandbox(resolvedPath: string, sandboxPath: string): boolean;
+/**
+ * Validate and transform a path for sandbox containment.
+ *
+ * - Rejects absolute paths
+ * - Resolves relative paths against sandbox
+ * - Detects path traversal attempts that escape sandbox
+ */
+export declare function validateAndTransformPath(inputPath: string, sandboxPath: string): PathValidationResult;
+/**
+ * Normalize a path for display/comparison purposes.
+ */
+export declare function normalizePathForDisplay(inputPath: string): string;
+/**
+ * Check if a path string looks like it could be a file path.
+ * Used for bash command parsing heuristics.
+ */
+export declare function looksLikePath(str: string): boolean;

package/dist/tools/sandbox/validator.js

@@ -0,0 +1,150 @@
+/**
+ * Sandbox Path Validator
+ *
+ * Validates and transforms file paths for sandbox containment.
+ * Handles cross-platform path operations (Windows, macOS, Linux).
+ */
+import path from 'path';
+/**
+ * Check if a string is an absolute path (cross-platform).
+ */
+export function isAbsolutePath(inputPath) {
+    if (path.isAbsolute(inputPath)) {
+        return true;
+    }
+    // Windows UNC paths: \\server\share
+    if (process.platform === 'win32') {
+        if (inputPath.startsWith('\\\\') || inputPath.startsWith('//')) {
+            return true;
+        }
+        // Windows extended-length path: \\?\C:\...
+        if (inputPath.startsWith('\\\\?\\') || inputPath.startsWith('\\\\??\\')) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if a resolved path is within the sandbox directory.
+ * Handles cross-platform case sensitivity.
+ */
+export function isPathWithinSandbox(resolvedPath, sandboxPath) {
+    // Normalize both paths
+    const normalizedSandbox = path.normalize(sandboxPath);
+    const normalizedTarget = path.normalize(resolvedPath);
+    // Both must be absolute for comparison
+    if (!path.isAbsolute(normalizedSandbox) || !path.isAbsolute(normalizedTarget)) {
+        return false;
+    }
+    // Platform-specific case handling
+    // Windows: case-insensitive comparison
+    // POSIX (macOS/Linux): case-sensitive comparison
+    let compareSandbox;
+    let compareTarget;
+    if (process.platform === 'win32') {
+        compareSandbox = normalizedSandbox.toLowerCase();
+        compareTarget = normalizedTarget.toLowerCase();
+    }
+    else {
+        compareSandbox = normalizedSandbox;
+        compareTarget = normalizedTarget;
+    }
+    // Ensure sandbox path ends with separator for proper prefix matching
+    // This prevents /sandbox from matching /sandboxescape
+    const sep = path.sep;
+    const sandboxWithSep = compareSandbox.endsWith(sep)
+        ? compareSandbox
+        : compareSandbox + sep;
+    // Check if target is within sandbox:
+    // - Target starts with sandbox + separator (nested file/folder)
+    // - Target equals sandbox exactly (sandbox folder itself)
+    return compareTarget.startsWith(sandboxWithSep) || compareTarget === compareSandbox;
+}
+/**
+ * Validate and transform a path for sandbox containment.
+ *
+ * - Rejects absolute paths
+ * - Resolves relative paths against sandbox
+ * - Detects path traversal attempts that escape sandbox
+ */
+export function validateAndTransformPath(inputPath, sandboxPath) {
+    // STEP 1: Check for absolute path - REJECT
+    if (isAbsolutePath(inputPath)) {
+        let errorMsg = `ABSOLUTE PATH REJECTED: "${inputPath}"\n`;
+        errorMsg += `When sandbox is enabled, you must use relative paths.\n`;
+        errorMsg += `Example: Use "./data/file.txt" instead of an absolute path.`;
+        // Special message for UNC paths on Windows
+        if (process.platform === 'win32' && (inputPath.startsWith('\\\\') || inputPath.startsWith('//'))) {
+            errorMsg = `UNC PATH REJECTED: "${inputPath}"\n`;
+            errorMsg += `Network paths are not allowed when sandbox is enabled.\n`;
+            errorMsg += `Use relative paths instead.`;
+        }
+        return {
+            allowed: false,
+            originalPath: inputPath,
+            transformedPath: inputPath,
+            error: errorMsg
+        };
+    }
+    // STEP 2: Resolve the relative path against sandbox
+    // This normalizes the path and resolves all ../ and ./ components
+    const resolvedPath = path.resolve(sandboxPath, inputPath);
+    // STEP 3: Check if resolved path is within sandbox
+    if (!isPathWithinSandbox(resolvedPath, sandboxPath)) {
+        const errorMsg = `PATH ESCAPE DETECTED: "${inputPath}"\n` +
+            `Resolved to: "${resolvedPath}"\n` +
+            `Sandbox boundary: "${sandboxPath}"\n` +
+            `Paths cannot escape the sandbox folder.`;
+        return {
+            allowed: false,
+            originalPath: inputPath,
+            transformedPath: inputPath,
+            error: errorMsg
+        };
+    }
+    // STEP 4: Return the resolved absolute path for tool use
+    return {
+        allowed: true,
+        originalPath: inputPath,
+        transformedPath: resolvedPath
+    };
+}
+/**
+ * Normalize a path for display/comparison purposes.
+ */
+export function normalizePathForDisplay(inputPath) {
+    return path.normalize(inputPath);
+}
+/**
+ * Check if a path string looks like it could be a file path.
+ * Used for bash command parsing heuristics.
+ */
+export function looksLikePath(str) {
+    if (!str || str.length === 0)
+        return false;
+    // Skip command flags/options
+    if (str.startsWith('-'))
+        return false;
+    // Skip shell operators and special characters
+    if (/^[|&;<>()$`\\]/.test(str))
+        return false;
+    // Skip common shell keywords
+    const shellKeywords = [
+        'then', 'else', 'fi', 'do', 'done', 'if', 'elif', 'while', 'for',
+        'in', 'case', 'esac', 'function', 'select', 'until', 'time',
+        'true', 'false', 'exit', 'break', 'continue', 'return'
+    ];
+    if (shellKeywords.includes(str.toLowerCase()))
+        return false;
+    // Likely a path if:
+    // - Contains path separators
+    // - Starts with ./ or ../
+    // - Has a common file extension
+    // - Contains dots (for relative paths)
+    return str.includes('/') ||
+        str.includes('\\') ||
+        str.startsWith('./') ||
+        str.startsWith('../') ||
+        str.startsWith('.') ||
+        /\.[a-zA-Z0-9]{1,4}$/.test(str);
+}

package/dist/tools/skill/registry.js

@@ -119,7 +119,6 @@ export async function getAllSkills(directory) {
         ...plugin,
     ].filter((skill) => {
         if (seen.has(skill.name)) {
-            console.warn(`[skill] Duplicate skill "${skill.name}" - using higher priority version`);
             return false;
         }
         seen.add(skill.name);

package/dist/tools/table/utils.js

@@ -19,10 +19,10 @@ function processCellValue(cell) {
     }
 }
 function formatError(context) {
-    return `Error: ${context.error.message || 'Unknown error'}
-Details:
-- File: ${context.file_path}
-${context.sheet_name ? `- Sheet: ${context.sheet_name}` : ''}
+    return `Error: ${context.error.message || 'Unknown error'}
+Details:
+- File: ${context.file_path}
+${context.sheet_name ? `- Sheet: ${context.sheet_name}` : ''}
 - Operation: ${context.operation}`;
 }
 function resolvePath(filePath, workingDir) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeyuan98/opencode-bioresearcher-plugin",
-  "version": "1.5.1",
+  "version": "1.5.2-alpha.3",
   "description": "OpenCode plugin that adds a bioresearcher agent",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",