ComposioHQ/composio · error · Error

Error reading file at

Error message

Error reading file at ${filePath}: ${error}

What it means

A catch-all wrapping any failure thrown while reading a local file (missing file, permission denied) into an Error with the path and underlying message. It originates from the try block around platform.readFileSync in readFileContent.

Solutions

  1. Verify the path exists and is readable before calling (fs.existsSync / fs.accessSync).
  2. Use an absolute path built from import.meta.url or process.cwd().
  3. Check the wrapped message after the colon — it contains the underlying OS error.

Example fix

// before
await readFile('./data/input.csv');
// after
import path from 'node:path';
await readFile(path.resolve(import.meta.dirname, 'data/input.csv'));
Defensive patterns

Strategy: validation

Validate before calling

import fs from 'node:fs';
if (!fs.existsSync(p) || !fs.statSync(p).isFile()) throw new Error(`missing file: ${p}`);

Try / catch

try { await readFile(p); }
catch (e) { if (/^Error reading file at/.test((e as Error).message)) {/* inspect suffix for OS error */} throw e; }

Prevention

When it happens

Trigger: Calling readFile with a path that does not exist, is a directory, or lacks read permissions; also thrown in runtimes without FS support (wrapping error 381).

Common situations: Typos in paths, relative paths resolved against an unexpected cwd, containerized apps where the file was not mounted, or read-only filesystems.

Related errors

AI-assisted analysis of ComposioHQ/composio@64b1b85502 (2026-08-28). Data as JSON: /api/errors/18d4eeb1687b70b3. Report an issue: GitHub.

Appendix: source

Thrown at ts/packages/core/src/utils/fileUtils.node.ts:166

const readFileContent = async (
  filePath: string
): Promise<{ fileName: string; content: string; mimeType: string }> => {
  try {
    if (!platform.supportsFileSystem) {
      throw new Error('File system operations are not supported in this runtime environment');
    }
    const content = platform.readFileSync(filePath);
    return {
      fileName: generateTimestampedFilename(filePath.split('.').pop() || 'txt'),
      content:
        content instanceof Uint8Array
          ? uint8ArrayToBase64(content)
          : uint8ArrayToBase64(new TextEncoder().encode(content)),
      mimeType: 'application/octet-stream',
    };
  } catch (error) {
    throw new Error(`Error reading file at ${filePath}: ${error}`);
  }
};

const readFileContentFromURL = async (
  path: string,
  signal?: AbortSignal
): Promise<{ fileName: string; content: string; mimeType: string }> => {
  // SSRF guard: `path` is user-supplied (and can come from an LLM-produced tool
  // argument), so it must not be allowed to reach internal/private addresses or
  // redirect into them. See ssrfGuard.node.ts.
  const response = await ssrfSafeFetch(path, { signal });
  if (!response.ok) {
    // The error path never reads the body, so release it explicitly (mirrors
    // `readResponseBodyWithLimit`) instead of leaving it to the garbage collector.
    await response.body?.cancel().catch(() => undefined);
    throw new Error(`Failed to fetch file: ${response.statusText}`);
  }
  const content = await readResponseBodyWithLimit(response);

View on GitHub (pinned to 64b1b85502)