@accomplish_ai/agent-core 0.0.0-pr-353-20260205225158

package/mcp-tools/file-permission/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "file-permission",
+  "version": "0.0.1",
+  "type": "module",
+  "imports": {
+    "@/*": "./src/*"
+  },
+  "scripts": {
+    "start": "npx tsx src/index.ts",
+    "dev": "npx tsx --watch src/index.ts"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.0.0"
+  }
+}

package/mcp-tools/file-permission/src/index.ts

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  type CallToolResult,
+} from '@modelcontextprotocol/sdk/types.js';
+
+const PERMISSION_API_PORT = process.env.PERMISSION_API_PORT || '9226';
+const PERMISSION_API_URL = `http://localhost:${PERMISSION_API_PORT}/permission`;
+
+interface FilePermissionInput {
+  operation: 'create' | 'delete' | 'rename' | 'move' | 'modify' | 'overwrite';
+  filePath?: string;
+  filePaths?: string[];
+  targetPath?: string;
+  contentPreview?: string;
+}
+
+const server = new Server(
+  { name: 'file-permission', version: '1.0.0' },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'request_file_permission',
+      description:
+        'Request user permission before performing file operations (create, delete, rename, move, modify, overwrite). Always call this tool BEFORE executing any file modification. Returns "allowed" or "denied".',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          operation: {
+            type: 'string',
+            enum: ['create', 'delete', 'rename', 'move', 'modify', 'overwrite'],
+            description: 'The type of file operation to perform',
+          },
+          filePath: {
+            type: 'string',
+            description: 'Absolute path to the file being operated on',
+          },
+          filePaths: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Array of absolute paths for batch operations (e.g., deleting multiple files)',
+          },
+          targetPath: {
+            type: 'string',
+            description: 'Target path for rename/move operations',
+          },
+          contentPreview: {
+            type: 'string',
+            description: 'Preview of file content for create/modify operations (first ~500 chars)',
+          },
+        },
+        required: ['operation'],
+      },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request): Promise<CallToolResult> => {
+  if (request.params.name !== 'request_file_permission') {
+    return {
+      content: [{ type: 'text', text: `Error: Unknown tool: ${request.params.name}` }],
+      isError: true,
+    };
+  }
+
+  const args = request.params.arguments as FilePermissionInput;
+  const { operation, filePath, filePaths, targetPath, contentPreview } = args;
+
+  if (!operation || (!filePath && (!filePaths || filePaths.length === 0))) {
+    return {
+      content: [{ type: 'text', text: 'Error: operation and either filePath or filePaths are required' }],
+      isError: true,
+    };
+  }
+
+  try {
+    const response = await fetch(PERMISSION_API_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        operation,
+        filePath,
+        filePaths,
+        targetPath,
+        contentPreview: contentPreview?.substring(0, 500),
+      }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return {
+        content: [{ type: 'text', text: `Error: Permission API returned ${response.status}: ${errorText}` }],
+        isError: true,
+      };
+    }
+
+    const result = (await response.json()) as { allowed: boolean };
+    return {
+      content: [{ type: 'text', text: result.allowed ? 'allowed' : 'denied' }],
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      content: [{ type: 'text', text: `Error: Failed to request permission: ${errorMessage}` }],
+      isError: true,
+    };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('File Permission MCP Server started');
+}
+
+main().catch((error) => {
+  console.error('Failed to start server:', error);
+  process.exit(1);
+});

package/mcp-tools/file-permission/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/mcp-tools/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "accomplish-mcp-tools",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "@hono/node-server": "^1.19.7",
+    "@hono/node-ws": "^1.2.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "express": "^4.21.0",
+    "hono": "^4.11.1",
+    "playwright": "npm:rebrowser-playwright@^1.52.0"
+  }
+}

package/mcp-tools/report-checkpoint/src/index.ts

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  type CallToolResult,
+} from '@modelcontextprotocol/sdk/types.js';
+
+const THOUGHT_STREAM_PORT = process.env.THOUGHT_STREAM_PORT || '9228';
+const CHECKPOINT_URL = `http://127.0.0.1:${THOUGHT_STREAM_PORT}/checkpoint`;
+const THOUGHT_STREAM_TASK_ID =
+  process.env.THOUGHT_STREAM_TASK_ID || process.env.ACCOMPLISH_TASK_ID || '';
+
+interface ReportCheckpointInput {
+  status: 'progress' | 'complete' | 'stuck';
+  summary: string;
+  nextPlanned?: string;
+  blocker?: string;
+}
+
+const server = new Server(
+  { name: 'report-checkpoint', version: '1.0.0' },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'report_checkpoint',
+      description:
+        'Report a progress checkpoint to the UI. Use this to mark significant milestones, completion of subtasks, or when stuck and needing help.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          status: {
+            type: 'string',
+            enum: ['progress', 'complete', 'stuck'],
+            description:
+              'Status: progress (ongoing work), complete (task finished), stuck (blocked/need help)',
+          },
+          summary: {
+            type: 'string',
+            description: 'Brief summary of what was accomplished or the current state',
+          },
+          nextPlanned: {
+            type: 'string',
+            description: 'What you plan to do next (optional, for progress status)',
+          },
+          blocker: {
+            type: 'string',
+            description: 'Description of what is blocking progress (optional, for stuck status)',
+          },
+        },
+        required: ['status', 'summary'],
+      },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request): Promise<CallToolResult> => {
+  if (request.params.name !== 'report_checkpoint') {
+    return {
+      content: [{ type: 'text', text: `Error: Unknown tool: ${request.params.name}` }],
+      isError: true,
+    };
+  }
+
+  const args = request.params.arguments as unknown as ReportCheckpointInput;
+  const { status, summary, nextPlanned, blocker } = args;
+
+  if (!status || !summary) {
+    return {
+      content: [{ type: 'text', text: 'Error: status and summary are required' }],
+      isError: true,
+    };
+  }
+
+  console.error(`[report-checkpoint] [${status}] ${summary}`);
+  if (nextPlanned) {
+    console.error(`[report-checkpoint] Next planned: ${nextPlanned}`);
+  }
+  if (blocker) {
+    console.error(`[report-checkpoint] Blocker: ${blocker}`);
+  }
+
+  if (THOUGHT_STREAM_TASK_ID) {
+    try {
+      const response = await fetch(CHECKPOINT_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          taskId: THOUGHT_STREAM_TASK_ID,
+          status,
+          summary,
+          nextPlanned,
+          blocker,
+          agentName: process.env.ACCOMPLISH_AGENT_NAME || 'agent',
+          timestamp: Date.now(),
+        }),
+        signal: AbortSignal.timeout(1000),
+      });
+
+      if (!response.ok) {
+        console.error(`[report-checkpoint] HTTP error (non-fatal): ${response.status}`);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(`[report-checkpoint] HTTP error (non-fatal): ${errorMessage}`);
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: 'Checkpoint recorded.' }],
+  };
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('[report-checkpoint] MCP server running');
+}
+
+main().catch((error) => {
+  console.error('[report-checkpoint] Fatal error:', error);
+  process.exit(1);
+});

package/mcp-tools/report-checkpoint/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}

package/mcp-tools/report-thought/src/index.ts

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  type CallToolResult,
+} from '@modelcontextprotocol/sdk/types.js';
+
+const THOUGHT_STREAM_PORT = process.env.THOUGHT_STREAM_PORT || '9228';
+const THOUGHT_STREAM_URL = `http://127.0.0.1:${THOUGHT_STREAM_PORT}/thought`;
+const THOUGHT_STREAM_TASK_ID =
+  process.env.THOUGHT_STREAM_TASK_ID || process.env.ACCOMPLISH_TASK_ID || '';
+
+interface ReportThoughtInput {
+  content: string;
+  category: 'observation' | 'reasoning' | 'decision' | 'action';
+}
+
+const server = new Server(
+  { name: 'report-thought', version: '1.0.0' },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'report_thought',
+      description:
+        'Stream a thought to the UI for real-time visibility into agent reasoning. Use frequently to narrate what you see and do.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          content: {
+            type: 'string',
+            description: 'The thought content to display',
+          },
+          category: {
+            type: 'string',
+            enum: ['observation', 'reasoning', 'decision', 'action'],
+            description:
+              'Category: observation (what you see), reasoning (why), decision (what you chose), action (what you are doing)',
+          },
+        },
+        required: ['content', 'category'],
+      },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request): Promise<CallToolResult> => {
+  if (request.params.name !== 'report_thought') {
+    return {
+      content: [{ type: 'text', text: `Error: Unknown tool: ${request.params.name}` }],
+      isError: true,
+    };
+  }
+
+  const args = request.params.arguments as unknown as ReportThoughtInput;
+  const { content, category } = args;
+
+  if (!content || !category) {
+    return {
+      content: [{ type: 'text', text: 'Error: content and category are required' }],
+      isError: true,
+    };
+  }
+
+  console.error(`[report-thought] [${category}] ${content}`);
+
+  if (THOUGHT_STREAM_TASK_ID) {
+    try {
+      const response = await fetch(THOUGHT_STREAM_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          taskId: THOUGHT_STREAM_TASK_ID,
+          content,
+          category,
+          agentName: process.env.ACCOMPLISH_AGENT_NAME || 'agent',
+          timestamp: Date.now(),
+        }),
+        signal: AbortSignal.timeout(1000),
+      });
+
+      if (!response.ok) {
+        console.error(`[report-thought] HTTP error (non-fatal): ${response.status}`);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(`[report-thought] HTTP error (non-fatal): ${errorMessage}`);
+    }
+  }
+
+  return {
+    content: [{ type: 'text', text: 'Thought recorded.' }],
+  };
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('[report-thought] MCP server running');
+}
+
+main().catch((error) => {
+  console.error('[report-thought] Fatal error:', error);
+  process.exit(1);
+});

package/mcp-tools/report-thought/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}

package/mcp-tools/safe-file-deletion/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: safe-file-deletion
+description: Enforces explicit user permission before any file deletion. Activates when you're about to use rm, unlink, fs.rm, or any operation that removes files from disk. MUST be followed for all delete operations.
+---
+
+# Safe File Deletion
+
+## Rule
+
+Before deleting ANY file, you MUST:
+
+1. Call `request_file_permission` with `operation: "delete"`
+2. For multiple files, use `filePaths` array (not multiple calls)
+3. Wait for response
+4. Only proceed if "allowed"
+5. If "denied", acknowledge and do NOT delete
+
+## Applies To
+
+- `rm` commands (single or multiple files)
+- `rm -rf` (directories)
+- `unlink`, `fs.rm`, `fs.rmdir`
+- Any script or tool that deletes files
+
+## Examples
+
+Single file:
+```json
+{
+  "operation": "delete",
+  "filePath": "/path/to/file.txt"
+}
+```
+
+Multiple files (batched into one prompt):
+```json
+{
+  "operation": "delete",
+  "filePaths": ["/path/to/file1.txt", "/path/to/file2.txt"]
+}
+```
+
+## No Workarounds
+
+Never bypass deletion warnings by:
+- Emptying files instead of deleting
+- Moving to hidden/temp locations
+- Using obscure commands
+
+The user will see a prominent warning. Wait for explicit approval.