@perstack/base 0.0.54 → 0.0.56

package/README.md

@@ -39,22 +39,12 @@ registerWriteTextFile(server)
 ### File Operations
 - `readTextFile` - Read text files with optional line range
 - `writeTextFile` - Create or overwrite text files
-- `appendTextFile` - Append content to existing files
 - `editTextFile` - Replace text in existing files
-- `deleteFile` - Remove files
-- `moveFile` - Move or rename files
-- `getFileInfo` - Get file metadata
 - `readImageFile` - Read image files (PNG, JPEG, GIF, WebP)
 - `readPdfFile` - Read PDF files
 
-### Directory Operations
-- `listDirectory` - List directory contents
-- `createDirectory` - Create directories
-- `deleteDirectory` - Remove directories
-
 ### Utilities
 - `exec` - Execute system commands
-- `healthCheck` - Check Perstack runtime health status
 - `todo` - Task list management
 - `clearTodo` - Clear task list
 - `attemptCompletion` - Signal task completion (validates todos first)

package/dist/bin/server.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { package_default, createBaseServer } from '../chunk-HUJMWPRE.js';
+import { package_default, createBaseServer } from '../chunk-HXMW3IUI.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { Command } from 'commander';
 

package/dist/chunk-HXMW3IUI.js

@@ -0,0 +1,575 @@
+import { z } from 'zod/v4';
+import { realpathSync, existsSync } from 'fs';
+import fs, { constants, stat, mkdir, open, lstat } from 'fs/promises';
+import os from 'os';
+import path, { dirname } from 'path';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { getFilteredEnv } from '@perstack/core';
+import mime from 'mime-types';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+// package.json
+var package_default = {
+  name: "@perstack/base",
+  version: "0.0.56",
+  description: "Perstack base skills for agents.",
+  author: "Wintermute Technologies, Inc.",
+  license: "Apache-2.0",
+  type: "module",
+  exports: {
+    ".": "./src/index.ts"
+  },
+  publishConfig: {
+    access: "public",
+    bin: {
+      "@perstack/base": "dist/bin/server.js"
+    },
+    exports: {
+      ".": "./dist/src/index.js"
+    },
+    types: {
+      ".": "./dist/src/index.d.ts"
+    }
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    clean: "rm -rf dist",
+    build: "pnpm run clean && tsup",
+    typecheck: "tsc --noEmit"
+  },
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@perstack/core": "workspace:*",
+    commander: "^14.0.3",
+    "mime-types": "^3.0.2",
+    zod: "^4.3.6"
+  },
+  devDependencies: {
+    "@tsconfig/node22": "^22.0.5",
+    "@types/mime-types": "^3.0.1",
+    "@types/node": "^25.2.3",
+    tsup: "^8.5.1",
+    typescript: "^5.9.3",
+    vitest: "^4.0.18"
+  },
+  engines: {
+    node: ">=22.0.0"
+  }
+};
+
+// src/lib/tool-result.ts
+function successToolResult(result) {
+  return { content: [{ type: "text", text: JSON.stringify(result) }] };
+}
+function errorToolResult(e) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: e.name, message: e.message }) }]
+  };
+}
+var Todo = class {
+  currentTodoId = 0;
+  todos = [];
+  processTodo(input) {
+    const { newTodos, completedTodos } = input;
+    if (newTodos) {
+      this.todos.push(
+        ...newTodos.map((title) => ({ id: this.currentTodoId++, title, completed: false }))
+      );
+    }
+    if (completedTodos) {
+      this.todos = this.todos.map((todo2) => ({
+        ...todo2,
+        completed: todo2.completed || completedTodos.includes(todo2.id)
+      }));
+    }
+    return {
+      todos: this.todos
+    };
+  }
+  clearTodo() {
+    this.todos = [];
+    this.currentTodoId = 0;
+    return {
+      todos: this.todos
+    };
+  }
+};
+var todoSingleton = new Todo();
+async function todo(input) {
+  return todoSingleton.processTodo(input);
+}
+async function clearTodo() {
+  return todoSingleton.clearTodo();
+}
+function getRemainingTodos() {
+  return todoSingleton.todos.filter((t) => !t.completed);
+}
+function registerTodo(server) {
+  server.registerTool(
+    "todo",
+    {
+      title: "todo",
+      description: "Manage a todo list: add tasks and mark them completed.",
+      inputSchema: {
+        newTodos: z.array(z.string()).describe("New todos to add").optional(),
+        completedTodos: z.array(z.number()).describe("Todo ids that are completed").optional()
+      }
+    },
+    async (input) => {
+      try {
+        return successToolResult(await todo(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+function registerClearTodo(server) {
+  server.registerTool(
+    "clearTodo",
+    {
+      title: "clearTodo",
+      description: "Clear all todos.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        return successToolResult(await clearTodo());
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+
+// src/tools/attempt-completion.ts
+async function attemptCompletion() {
+  const remainingTodos = getRemainingTodos();
+  if (remainingTodos.length > 0) {
+    return { remainingTodos };
+  }
+  return {};
+}
+function registerAttemptCompletion(server) {
+  server.registerTool(
+    "attemptCompletion",
+    {
+      title: "Attempt completion",
+      description: "Signal task completion. Validates all todos are complete before ending.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        return successToolResult(await attemptCompletion());
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var workspacePath = realpathSync(expandHome(process.cwd()));
+function expandHome(filepath) {
+  if (filepath.startsWith("~/") || filepath === "~") {
+    return path.join(os.homedir(), filepath.slice(1));
+  }
+  return filepath;
+}
+async function validatePath(requestedPath) {
+  const expandedPath = expandHome(requestedPath);
+  const absolute = path.isAbsolute(expandedPath) ? path.resolve(expandedPath) : path.resolve(process.cwd(), expandedPath);
+  const perstackDir = `${workspacePath}/perstack`.toLowerCase();
+  if (absolute.toLowerCase() === perstackDir || absolute.toLowerCase().startsWith(`${perstackDir}/`)) {
+    throw new Error("Access denied - perstack directory is not allowed");
+  }
+  try {
+    const realAbsolute = await fs.realpath(absolute);
+    if (!isWithinWorkspace(realAbsolute)) {
+      throw new Error("Access denied - symlink target outside allowed directories");
+    }
+    return realAbsolute;
+  } catch (_error) {
+    const parentDir = path.dirname(absolute);
+    try {
+      const realParentPath = await fs.realpath(parentDir);
+      if (!isWithinWorkspace(realParentPath)) {
+        throw new Error("Access denied - parent directory outside allowed directories");
+      }
+      return absolute;
+    } catch {
+      if (!isWithinWorkspace(absolute)) {
+        throw new Error(
+          `Access denied - path outside allowed directories: ${absolute} not in ${workspacePath}`
+        );
+      }
+      throw new Error(`Parent directory does not exist: ${parentDir}`);
+    }
+  }
+}
+function isWithinWorkspace(absolutePath) {
+  return absolutePath === workspacePath || absolutePath.startsWith(`${workspacePath}/`);
+}
+var O_NOFOLLOW = constants.O_NOFOLLOW ?? 0;
+typeof constants.O_NOFOLLOW === "number";
+async function checkNotSymlink(path2) {
+  const stats = await lstat(path2).catch(() => null);
+  if (stats?.isSymbolicLink()) {
+    throw new Error("Operation denied: target is a symbolic link");
+  }
+}
+async function safeWriteFile(path2, data) {
+  let handle;
+  try {
+    await checkNotSymlink(path2);
+    const flags = constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | O_NOFOLLOW;
+    handle = await open(path2, flags, 420);
+    await handle.writeFile(data, "utf-8");
+  } finally {
+    await handle?.close();
+  }
+}
+async function safeReadFile(path2) {
+  let handle;
+  try {
+    await checkNotSymlink(path2);
+    const flags = constants.O_RDONLY | O_NOFOLLOW;
+    handle = await open(path2, flags);
+    const buffer = await handle.readFile("utf-8");
+    return buffer;
+  } finally {
+    await handle?.close();
+  }
+}
+
+// src/tools/edit-text-file.ts
+async function editTextFile(input) {
+  const { path: path2, newText, oldText } = input;
+  const validatedPath = await validatePath(path2);
+  const stats = await stat(validatedPath).catch(() => null);
+  if (!stats) {
+    throw new Error(`File ${path2} does not exist.`);
+  }
+  if (!(stats.mode & 128)) {
+    throw new Error(`File ${path2} is not writable`);
+  }
+  await applyFileEdit(validatedPath, newText, oldText);
+  return {
+    path: validatedPath,
+    newText,
+    oldText
+  };
+}
+function normalizeLineEndings(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+async function applyFileEdit(filePath, newText, oldText) {
+  const content = normalizeLineEndings(await safeReadFile(filePath));
+  const normalizedOld = normalizeLineEndings(oldText);
+  const normalizedNew = normalizeLineEndings(newText);
+  if (!content.includes(normalizedOld)) {
+    throw new Error(`Could not find exact match for oldText in file ${filePath}`);
+  }
+  const modifiedContent = content.replace(normalizedOld, normalizedNew);
+  await safeWriteFile(filePath, modifiedContent);
+}
+function registerEditTextFile(server) {
+  server.registerTool(
+    "editTextFile",
+    {
+      title: "Edit text file",
+      description: "Replace exact text in an existing file. Normalizes line endings (CRLF \u2192 LF).",
+      inputSchema: {
+        path: z.string().describe("Target file path to edit."),
+        newText: z.string().describe("Text to replace with."),
+        oldText: z.string().describe("Exact text to find and replace.")
+      }
+    },
+    async (input) => {
+      try {
+        return successToolResult(await editTextFile(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var execFileAsync = promisify(execFile);
+function isExecError(error) {
+  return error instanceof Error && "code" in error;
+}
+async function exec(input) {
+  const validatedCwd = await validatePath(input.cwd);
+  const { stdout, stderr } = await execFileAsync(input.command, input.args, {
+    cwd: validatedCwd,
+    env: getFilteredEnv(input.env),
+    timeout: input.timeout,
+    maxBuffer: 10 * 1024 * 1024
+  });
+  let output = "";
+  if (input.stdout) {
+    output += stdout;
+  }
+  if (input.stderr) {
+    output += stderr;
+  }
+  if (!output.trim()) {
+    output = "Command executed successfully, but produced no output.";
+  }
+  return { output };
+}
+function registerExec(server) {
+  server.registerTool(
+    "exec",
+    {
+      title: "Execute Command",
+      description: "Execute a system command. Returns stdout/stderr.",
+      inputSchema: {
+        command: z.string().describe("The command to execute"),
+        args: z.array(z.string()).describe("The arguments to pass to the command"),
+        env: z.record(z.string(), z.string()).describe("The environment variables to set"),
+        cwd: z.string().describe("The working directory to execute the command in"),
+        stdout: z.boolean().describe("Whether to capture the standard output"),
+        stderr: z.boolean().describe("Whether to capture the standard error"),
+        timeout: z.number().optional().default(6e4).describe("Timeout in milliseconds (default: 60000)")
+      }
+    },
+    async (input) => {
+      try {
+        return successToolResult(await exec(input));
+      } catch (error) {
+        let message;
+        let stdout;
+        let stderr;
+        if (isExecError(error)) {
+          if ((error.killed || error.signal === "SIGTERM") && typeof input.timeout === "number") {
+            message = `Command timed out after ${input.timeout}ms.`;
+          } else if (error.message.includes("timeout")) {
+            message = `Command timed out after ${input.timeout}ms.`;
+          } else {
+            message = error.message;
+          }
+          stdout = error.stdout;
+          stderr = error.stderr;
+        } else if (error instanceof Error) {
+          message = error.message;
+        } else {
+          message = "An unknown error occurred.";
+        }
+        const result = { error: message };
+        if (stdout && input.stdout) {
+          result.stdout = stdout;
+        }
+        if (stderr && input.stderr) {
+          result.stderr = stderr;
+        }
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
+    }
+  );
+}
+var MAX_IMAGE_SIZE = 15 * 1024 * 1024;
+async function readImageFile(input) {
+  const { path: path2 } = input;
+  const validatedPath = await validatePath(path2);
+  const isFile = existsSync(validatedPath);
+  if (!isFile) {
+    throw new Error(`File ${path2} does not exist.`);
+  }
+  const mimeType = mime.lookup(validatedPath);
+  if (!mimeType || !["image/png", "image/jpeg", "image/gif", "image/webp"].includes(mimeType)) {
+    throw new Error(`File ${path2} is not supported.`);
+  }
+  const fileStats = await stat(validatedPath);
+  const fileSizeMB = fileStats.size / (1024 * 1024);
+  if (fileStats.size > MAX_IMAGE_SIZE) {
+    throw new Error(
+      `Image file too large (${fileSizeMB.toFixed(1)}MB). Maximum supported size is ${MAX_IMAGE_SIZE / (1024 * 1024)}MB. Please use a smaller image file.`
+    );
+  }
+  return {
+    path: validatedPath,
+    mimeType,
+    size: fileStats.size
+  };
+}
+function registerReadImageFile(server) {
+  server.registerTool(
+    "readImageFile",
+    {
+      title: "Read image file",
+      description: "Read an image file as base64. Supports PNG, JPEG, GIF, WebP. Max 15MB.",
+      inputSchema: {
+        path: z.string()
+      }
+    },
+    async (input) => {
+      try {
+        return successToolResult(await readImageFile(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var MAX_PDF_SIZE = 30 * 1024 * 1024;
+async function readPdfFile(input) {
+  const { path: path2 } = input;
+  const validatedPath = await validatePath(path2);
+  const isFile = existsSync(validatedPath);
+  if (!isFile) {
+    throw new Error(`File ${path2} does not exist.`);
+  }
+  const mimeType = mime.lookup(validatedPath);
+  if (mimeType !== "application/pdf") {
+    throw new Error(`File ${path2} is not a PDF file.`);
+  }
+  const fileStats = await stat(validatedPath);
+  const fileSizeMB = fileStats.size / (1024 * 1024);
+  if (fileStats.size > MAX_PDF_SIZE) {
+    throw new Error(
+      `PDF file too large (${fileSizeMB.toFixed(1)}MB). Maximum supported size is ${MAX_PDF_SIZE / (1024 * 1024)}MB. Please use a smaller PDF file.`
+    );
+  }
+  return {
+    path: validatedPath,
+    mimeType,
+    size: fileStats.size
+  };
+}
+function registerReadPdfFile(server) {
+  server.registerTool(
+    "readPdfFile",
+    {
+      title: "Read PDF file",
+      description: "Read a PDF file as base64. Max 30MB.",
+      inputSchema: {
+        path: z.string()
+      }
+    },
+    async (input) => {
+      try {
+        return successToolResult(await readPdfFile(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+async function readTextFile(input) {
+  const { path: path2, from, to } = input;
+  const validatedPath = await validatePath(path2);
+  const stats = await stat(validatedPath).catch(() => null);
+  if (!stats) {
+    throw new Error(`File ${path2} does not exist.`);
+  }
+  const fileContent = await safeReadFile(validatedPath);
+  const lines = fileContent.split("\n");
+  const fromLine = from ?? 0;
+  const toLine = to ?? lines.length;
+  const selectedLines = lines.slice(fromLine, toLine);
+  const content = selectedLines.join("\n");
+  return {
+    path: path2,
+    content,
+    from: fromLine,
+    to: toLine
+  };
+}
+function registerReadTextFile(server) {
+  server.registerTool(
+    "readTextFile",
+    {
+      title: "Read text file",
+      description: "Read a UTF-8 text file. Supports partial reading via line ranges.",
+      inputSchema: {
+        path: z.string(),
+        from: z.number().optional().describe("The line number to start reading from."),
+        to: z.number().optional().describe("The line number to stop reading at.")
+      }
+    },
+    async (input) => {
+      try {
+        return successToolResult(await readTextFile(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+async function writeTextFile(input) {
+  const { path: path2, text } = input;
+  const validatedPath = await validatePath(path2);
+  const stats = await stat(validatedPath).catch(() => null);
+  if (stats && !(stats.mode & 128)) {
+    throw new Error(`File ${path2} is not writable`);
+  }
+  const dir = dirname(validatedPath);
+  await mkdir(dir, { recursive: true });
+  await safeWriteFile(validatedPath, text);
+  return {
+    path: validatedPath,
+    text
+  };
+}
+function registerWriteTextFile(server) {
+  server.registerTool(
+    "writeTextFile",
+    {
+      title: "writeTextFile",
+      description: "Create or overwrite a UTF-8 text file. Creates parent directories as needed.",
+      inputSchema: {
+        path: z.string().describe("Target file path (relative or absolute)."),
+        text: z.string().describe("Text to write to the file.")
+      }
+    },
+    async (input) => {
+      try {
+        return successToolResult(await writeTextFile(input));
+      } catch (e) {
+        if (e instanceof Error) return errorToolResult(e);
+        throw e;
+      }
+    }
+  );
+}
+var BASE_SKILL_NAME = package_default.name;
+var BASE_SKILL_VERSION = package_default.version;
+function registerAllTools(server) {
+  registerAttemptCompletion(server);
+  registerTodo(server);
+  registerClearTodo(server);
+  registerExec(server);
+  registerReadTextFile(server);
+  registerReadImageFile(server);
+  registerReadPdfFile(server);
+  registerWriteTextFile(server);
+  registerEditTextFile(server);
+}
+function createBaseServer() {
+  const server = new McpServer(
+    {
+      name: BASE_SKILL_NAME,
+      version: BASE_SKILL_VERSION
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  registerAllTools(server);
+  return server;
+}
+
+export { BASE_SKILL_NAME, BASE_SKILL_VERSION, attemptCompletion, clearTodo, createBaseServer, editTextFile, errorToolResult, exec, getRemainingTodos, package_default, readImageFile, readPdfFile, readTextFile, registerAllTools, registerAttemptCompletion, registerClearTodo, registerEditTextFile, registerExec, registerReadImageFile, registerReadPdfFile, registerReadTextFile, registerTodo, registerWriteTextFile, successToolResult, todo, validatePath, writeTextFile };
+//# sourceMappingURL=chunk-HXMW3IUI.js.map
+//# sourceMappingURL=chunk-HXMW3IUI.js.map