@shaifulshabuj-waymarks/server 0.1.0

package/dist/mcp/server.js

@@ -0,0 +1,331 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+// Parse --project-root arg before any imports trigger module-level DB/config initialization
+const _projectRootIdx = process.argv.indexOf('--project-root');
+if (_projectRootIdx !== -1 && process.argv[_projectRootIdx + 1]) {
+    process.env.WAYMARK_PROJECT_ROOT = process.argv[_projectRootIdx + 1];
+}
+require("dotenv/config");
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const uuid_1 = require("uuid");
+const database_1 = require("../db/database");
+const engine_1 = require("../policies/engine");
+const slack_1 = require("../notifications/slack");
+const SESSION_ID = (0, uuid_1.v4)();
+// Bug 1: Build PATH that includes nvm-managed node binaries.
+// Sourcing shell profiles non-interactively is unreliable (NVM_DIR unset, brew missing, etc.)
+// Instead: read nvm's default alias directly from ~/.nvm and append known bin paths.
+function getUserPath() {
+    const base = process.env.PATH || '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin';
+    const extra = [];
+    const home = process.env.HOME || require('os').homedir();
+    const nvmDir = process.env.NVM_DIR || path.join(home, '.nvm');
+    // Add all nvm version bin dirs that exist, default alias first
+    try {
+        const defaultAlias = path.join(nvmDir, 'alias', 'default');
+        if (fs.existsSync(defaultAlias)) {
+            const ver = fs.readFileSync(defaultAlias, 'utf8').trim().replace(/^v/, '');
+            const binDir = path.join(nvmDir, 'versions', 'node', `v${ver}`, 'bin');
+            if (fs.existsSync(binDir))
+                extra.push(binDir);
+        }
+    }
+    catch { }
+    // Also add common fixed locations as fallback
+    for (const p of ['/usr/local/bin', '/opt/homebrew/bin']) {
+        if (fs.existsSync(p) && !base.includes(p))
+            extra.push(p);
+    }
+    return extra.length ? `${extra.join(':')}:${base}` : base;
+}
+const USER_PATH = getUserPath();
+const server = new index_js_1.Server({ name: 'waymark', version: '0.1.0' }, { capabilities: { tools: {} } });
+// List available tools
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: 'write_file',
+                description: 'Write content to a file. Creates or overwrites the file.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Absolute or relative path to the file' },
+                        content: { type: 'string', description: 'Content to write to the file' },
+                    },
+                    required: ['path', 'content'],
+                },
+            },
+            {
+                name: 'read_file',
+                description: 'Read content from a file.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Absolute or relative path to the file' },
+                    },
+                    required: ['path'],
+                },
+            },
+            {
+                name: 'bash',
+                description: 'Execute a bash command and return output.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        command: { type: 'string', description: 'The bash command to execute' },
+                    },
+                    required: ['command'],
+                },
+            },
+        ],
+    };
+});
+// Handle tool calls
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const action_id = (0, uuid_1.v4)();
+    const input_payload = JSON.stringify(args);
+    if (name === 'write_file') {
+        const filePath = args.path;
+        const content = args.content;
+        const resolvedPath = path.resolve(filePath);
+        // Policy check before execution
+        const config = (0, engine_1.loadConfig)();
+        const policyResult = (0, engine_1.checkFileAction)(resolvedPath, 'write', config);
+        if (policyResult.decision === 'block') {
+            (0, database_1.insertAction)({
+                action_id, session_id: SESSION_ID, tool_name: 'write_file',
+                target_path: resolvedPath, input_payload, status: 'blocked',
+                decision: 'block', policy_reason: policyResult.reason, matched_rule: policyResult.matchedRule,
+            });
+            throw new Error(`Waymark blocked: ${policyResult.reason} [rule: ${policyResult.matchedRule}]`);
+        }
+        if (policyResult.decision === 'pending') {
+            (0, database_1.insertAction)({
+                action_id, session_id: SESSION_ID, tool_name: 'write_file',
+                target_path: resolvedPath, input_payload, status: 'pending',
+                decision: 'pending', policy_reason: policyResult.reason, matched_rule: policyResult.matchedRule,
+            });
+            // Fire-and-forget Slack notification (no console.log — MCP uses stdio)
+            (0, slack_1.notifyPendingAction)({
+                action_id, session_id: SESSION_ID, tool_name: 'write_file',
+                target_path: resolvedPath, input_payload,
+                before_snapshot: null, after_snapshot: null,
+                status: 'pending', error_message: null, stdout: null, stderr: null,
+                rolled_back: 0, rolled_back_at: null,
+                created_at: new Date().toISOString(),
+                decision: 'pending', policy_reason: policyResult.reason, matched_rule: policyResult.matchedRule,
+                approved_at: null, approved_by: null, rejected_at: null, rejected_reason: null,
+                id: 0,
+            }).catch(() => { });
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Action requires approval.\nAction ID: ${action_id}\nCheck status: GET /api/actions/${action_id}/status\n\nThis action is pending human approval. You can continue with other tasks. Poll the status endpoint to check if approved. If approved, the action has already been executed. If rejected, check the status response for the reason.`,
+                    }],
+            };
+        }
+        // Capture before snapshot
+        let before_snapshot = null;
+        try {
+            before_snapshot = fs.readFileSync(resolvedPath, 'utf8');
+        }
+        catch {
+            // File doesn't exist yet — that's fine
+        }
+        (0, database_1.insertAction)({
+            action_id,
+            session_id: SESSION_ID,
+            tool_name: 'write_file',
+            target_path: resolvedPath,
+            input_payload,
+            before_snapshot,
+            status: 'pending',
+        });
+        try {
+            // Ensure directory exists
+            fs.mkdirSync(path.dirname(resolvedPath), { recursive: true });
+            fs.writeFileSync(resolvedPath, content, 'utf8');
+            (0, database_1.updateAction)(action_id, {
+                status: 'success',
+                after_snapshot: content,
+            });
+            return {
+                content: [{ type: 'text', text: `File written successfully: ${resolvedPath}` }],
+            };
+        }
+        catch (err) {
+            (0, database_1.updateAction)(action_id, {
+                status: 'error',
+                error_message: err.message,
+            });
+            throw err;
+        }
+    }
+    else if (name === 'read_file') {
+        const filePath = args.path;
+        const resolvedPath = path.resolve(filePath);
+        // Policy check before execution
+        const config = (0, engine_1.loadConfig)();
+        const policyResult = (0, engine_1.checkFileAction)(resolvedPath, 'read', config);
+        if (policyResult.decision === 'block') {
+            (0, database_1.insertAction)({
+                action_id, session_id: SESSION_ID, tool_name: 'read_file',
+                target_path: resolvedPath, input_payload, status: 'blocked',
+                decision: 'block', policy_reason: policyResult.reason, matched_rule: policyResult.matchedRule,
+            });
+            throw new Error(`Waymark blocked: ${policyResult.reason} [rule: ${policyResult.matchedRule}]`);
+        }
+        if (policyResult.decision === 'pending') {
+            (0, database_1.insertAction)({
+                action_id, session_id: SESSION_ID, tool_name: 'read_file',
+                target_path: resolvedPath, input_payload, status: 'pending',
+                decision: 'pending', policy_reason: policyResult.reason, matched_rule: policyResult.matchedRule,
+            });
+            (0, slack_1.notifyPendingAction)({
+                action_id, session_id: SESSION_ID, tool_name: 'read_file',
+                target_path: resolvedPath, input_payload,
+                before_snapshot: null, after_snapshot: null,
+                status: 'pending', error_message: null, stdout: null, stderr: null,
+                rolled_back: 0, rolled_back_at: null,
+                created_at: new Date().toISOString(),
+                decision: 'pending', policy_reason: policyResult.reason, matched_rule: policyResult.matchedRule,
+                approved_at: null, approved_by: null, rejected_at: null, rejected_reason: null,
+                id: 0,
+            }).catch(() => { });
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Action requires approval.\nAction ID: ${action_id}\nCheck status: GET /api/actions/${action_id}/status\n\nThis action is pending human approval. You can continue with other tasks. Poll the status endpoint to check if approved. If approved, the action has already been executed. If rejected, check the status response for the reason.`,
+                    }],
+            };
+        }
+        (0, database_1.insertAction)({
+            action_id,
+            session_id: SESSION_ID,
+            tool_name: 'read_file',
+            target_path: resolvedPath,
+            input_payload,
+            status: 'pending',
+        });
+        try {
+            const content = fs.readFileSync(resolvedPath, 'utf8');
+            (0, database_1.updateAction)(action_id, {
+                status: 'success',
+                after_snapshot: content,
+            });
+            return {
+                content: [{ type: 'text', text: content }],
+            };
+        }
+        catch (err) {
+            (0, database_1.updateAction)(action_id, {
+                status: 'error',
+                error_message: err.message,
+            });
+            throw err;
+        }
+    }
+    else if (name === 'bash') {
+        const command = args.command;
+        // Policy check before execution
+        const config = (0, engine_1.loadConfig)();
+        const policyResult = (0, engine_1.checkBashAction)(command, config);
+        if (policyResult.decision === 'block') {
+            (0, database_1.insertAction)({
+                action_id, session_id: SESSION_ID, tool_name: 'bash',
+                target_path: null, input_payload, status: 'blocked',
+                decision: 'block', policy_reason: policyResult.reason, matched_rule: policyResult.matchedRule,
+            });
+            throw new Error(`Waymark blocked command: ${policyResult.reason} [rule: ${policyResult.matchedRule}]`);
+        }
+        (0, database_1.insertAction)({
+            action_id,
+            session_id: SESSION_ID,
+            tool_name: 'bash',
+            target_path: null,
+            input_payload,
+            status: 'pending',
+        });
+        // Bug 1 + Bug 2: use spawnSync for clean stdout/stderr separation and USER_PATH
+        const result = (0, child_process_1.spawnSync)('sh', ['-c', command], {
+            encoding: 'utf8',
+            timeout: 30000,
+            env: { ...process.env, PATH: USER_PATH },
+        });
+        const stdout = result.stdout || '';
+        const stderr = result.stderr || '';
+        const failed = result.status !== 0 || !!result.error;
+        if (!failed) {
+            (0, database_1.updateAction)(action_id, {
+                status: 'success',
+                stdout,
+                stderr,
+            });
+            return {
+                content: [{ type: 'text', text: stdout || '(no output)' }],
+            };
+        }
+        else {
+            const errorMessage = result.error ? result.error.message : `Command exited with code ${result.status}`;
+            (0, database_1.updateAction)(action_id, {
+                status: 'error',
+                stdout,
+                stderr,
+                error_message: errorMessage,
+            });
+            throw new Error(stderr || errorMessage);
+        }
+    }
+    else {
+        throw new Error(`Unknown tool: ${name}`);
+    }
+});
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    // MCP server communicates via stdio — no console.log here to avoid polluting the stream
+}
+main().catch((err) => {
+    process.stderr.write(`MCP server error: ${err.message}\n`);
+    process.exit(1);
+});

package/dist/notifications/slack.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notifyPendingAction = notifyPendingAction;
+async function notifyPendingAction(action) {
+    const webhookUrl = process.env.WAYMARK_SLACK_WEBHOOK_URL;
+    if (!webhookUrl)
+        return;
+    const baseUrl = process.env.WAYMARK_BASE_URL || 'http://localhost:3001';
+    const dashboardUrl = `${baseUrl}/action/${action.action_id}`;
+    const timeAgo = (() => {
+        const diff = Math.floor((Date.now() - new Date(action.created_at + (action.created_at.includes('Z') ? '' : 'Z')).getTime()) / 1000);
+        if (diff < 60)
+            return `${diff}s ago`;
+        if (diff < 3600)
+            return `${Math.floor(diff / 60)}m ago`;
+        return `${Math.floor(diff / 3600)}h ago`;
+    })();
+    const body = {
+        blocks: [
+            {
+                type: 'header',
+                text: { type: 'plain_text', text: '⏳ Waymark — Approval Required', emoji: true },
+            },
+            {
+                type: 'section',
+                fields: [
+                    { type: 'mrkdwn', text: `*Tool:*\n${action.tool_name}` },
+                    { type: 'mrkdwn', text: `*Path:*\n${action.target_path || '—'}` },
+                    { type: 'mrkdwn', text: `*Rule:*\n${action.matched_rule || '—'}` },
+                    { type: 'mrkdwn', text: `*Time:*\n${timeAgo}` },
+                ],
+            },
+            {
+                type: 'actions',
+                elements: [
+                    {
+                        type: 'button',
+                        text: { type: 'plain_text', text: 'View in Dashboard', emoji: true },
+                        url: dashboardUrl,
+                    },
+                ],
+            },
+            {
+                type: 'actions',
+                elements: [
+                    {
+                        type: 'button',
+                        text: { type: 'plain_text', text: '✅ Approve', emoji: true },
+                        style: 'primary',
+                        action_id: 'waymark_approve',
+                        value: action.action_id,
+                    },
+                    {
+                        type: 'button',
+                        text: { type: 'plain_text', text: '❌ Reject', emoji: true },
+                        style: 'danger',
+                        action_id: 'waymark_reject',
+                        value: action.action_id,
+                    },
+                ],
+            },
+        ],
+    };
+    try {
+        const res = await fetch(webhookUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            process.stderr.write(`Waymark Slack notification failed: ${res.status} ${res.statusText}\n`);
+        }
+    }
+    catch (err) {
+        process.stderr.write(`Waymark Slack notification error: ${err.message}\n`);
+    }
+}

package/dist/policies/engine.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.checkFileAction = checkFileAction;
+exports.checkBashAction = checkBashAction;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const micromatch_1 = __importDefault(require("micromatch"));
+const PROJECT_ROOT = process.env.WAYMARK_PROJECT_ROOT || process.cwd();
+const CONFIG_PATH = path.join(PROJECT_ROOT, 'waymark.config.json');
+const DEFAULT_CONFIG = {
+    version: '1',
+    policies: {
+        allowedPaths: [],
+        blockedPaths: [],
+        blockedCommands: [],
+        requireApproval: [],
+        maxBashOutputBytes: 10000,
+    },
+};
+function loadConfig() {
+    try {
+        const raw = fs.readFileSync(CONFIG_PATH, 'utf8');
+        const parsed = JSON.parse(raw);
+        // Ensure all policy arrays exist
+        if (!parsed.policies)
+            return DEFAULT_CONFIG;
+        return {
+            version: parsed.version || '1',
+            policies: {
+                allowedPaths: parsed.policies.allowedPaths || [],
+                blockedPaths: parsed.policies.blockedPaths || [],
+                blockedCommands: parsed.policies.blockedCommands || [],
+                requireApproval: parsed.policies.requireApproval || [],
+                maxBashOutputBytes: parsed.policies.maxBashOutputBytes ?? 10000,
+            },
+        };
+    }
+    catch {
+        return DEFAULT_CONFIG;
+    }
+}
+function resolvePattern(pattern) {
+    // Absolute patterns pass through; relative (./...) resolve from project root
+    if (path.isAbsolute(pattern))
+        return pattern;
+    return path.resolve(PROJECT_ROOT, pattern);
+}
+function matchesAny(absFilePath, patterns) {
+    for (const pattern of patterns) {
+        const absPattern = resolvePattern(pattern);
+        if (micromatch_1.default.isMatch(absFilePath, absPattern, { dot: true })) {
+            return pattern;
+        }
+    }
+    return null;
+}
+function checkFileAction(filePath, _action, config) {
+    const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(PROJECT_ROOT, filePath);
+    const { blockedPaths, requireApproval, allowedPaths } = config.policies;
+    // 1. Blocked
+    const blockedMatch = matchesAny(absPath, blockedPaths);
+    if (blockedMatch) {
+        return {
+            decision: 'block',
+            reason: `Path matches blocked rule`,
+            matchedRule: blockedMatch,
+        };
+    }
+    // 2. Requires approval (queued/pending)
+    const approvalMatch = matchesAny(absPath, requireApproval);
+    if (approvalMatch) {
+        return {
+            decision: 'pending',
+            reason: `Path requires approval before execution`,
+            matchedRule: approvalMatch,
+        };
+    }
+    // 3. Allowed
+    const allowedMatch = matchesAny(absPath, allowedPaths);
+    if (allowedMatch) {
+        return {
+            decision: 'allow',
+            reason: `Path matches allowed rule`,
+            matchedRule: allowedMatch,
+        };
+    }
+    // 4. Default: block
+    return {
+        decision: 'block',
+        reason: `Path not in allowedPaths`,
+        matchedRule: '(default deny)',
+    };
+}
+function isCommandBlocked(command, rule) {
+    if (rule.startsWith('regex:')) {
+        const pattern = rule.slice(6);
+        try {
+            return new RegExp(pattern, 'i').test(command);
+        }
+        catch {
+            console.warn(`Invalid regex in blockedCommands: ${rule}`);
+            return false;
+        }
+    }
+    return command.includes(rule);
+}
+function checkBashAction(command, config) {
+    const { blockedCommands } = config.policies;
+    for (const rule of blockedCommands) {
+        if (isCommandBlocked(command, rule)) {
+            const displayRule = rule.startsWith('regex:') ? rule.slice(6) : rule;
+            return {
+                decision: 'block',
+                reason: `Command matches blocked rule: "${displayRule}"`,
+                matchedRule: rule,
+            };
+        }
+    }
+    return {
+        decision: 'allow',
+        reason: 'Command allowed',
+        matchedRule: '(default allow)',
+    };
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@shaifulshabuj-waymarks/server",
+  "version": "0.1.0",
+  "description": "Waymark MCP server and dashboard",
+  "author": "Waymark <hello@waymarks.dev>",
+  "license": "MIT",
+  "homepage": "https://github.com/waymarks/waymark",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/waymarks/waymark.git"
+  },
+  "bugs": {
+    "url": "https://github.com/waymarks/waymark/issues"
+  },
+  "keywords": [
+    "ai-agents",
+    "claude-code",
+    "mcp",
+    "security",
+    "developer-tools",
+    "llm",
+    "agent-control"
+  ],
+  "main": "dist/api/server.js",
+  "bin": {
+    "waymark-server": "./dist/mcp/server.js"
+  },
+  "files": [
+    "dist/**",
+    "src/ui/**"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/api/server.js",
+    "dev:api": "nodemon --exec ts-node src/api/server.ts",
+    "dev:mcp": "ts-node src/mcp/server.ts",
+    "db:reset": "node -e \"require('fs').rmSync('./data/waymark.db', {force:true}); console.log('DB deleted.')\" && ts-node -e \"require('./src/db/database'); console.log('DB recreated.')\""
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "better-sqlite3": "^9.4.3",
+    "dotenv": "^16.0.0",
+    "express": "^4.18.2",
+    "micromatch": "^4.0.5",
+    "uuid": "^9.0.0",
+    "concurrently": "^8.2.2"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.8",
+    "@types/express": "^4.17.21",
+    "@types/micromatch": "^4.0.9",
+    "@types/node": "^20.11.5",
+    "@types/uuid": "^9.0.7",
+    "nodemon": "^3.0.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  }
+}