@shaifulshabuj-waymarks/cli 0.1.0

package/dist/commands/init.js

@@ -0,0 +1,274 @@
+"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 });
+exports.run = run;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const readline = __importStar(require("readline"));
+const child_process_1 = require("child_process");
+const DEFAULT_CONFIG = {
+    version: '1',
+    policies: {
+        allowedPaths: [
+            './src/**',
+            './data/**',
+            './README.md',
+            './CLAUDE.md'
+        ],
+        blockedPaths: [
+            './.env',
+            './.env.*',
+            './package-lock.json',
+            '/etc/**',
+            '/usr/**'
+        ],
+        blockedCommands: [
+            'rm -rf',
+            'DROP TABLE',
+            'DROP DATABASE',
+            'chmod 777',
+            'regex:\\|\\s*bash',
+            'regex:\\|\\s*sh\\b',
+            'regex:\\$\\(curl',
+            'regex:\\$\\(wget',
+            'wget '
+        ],
+        requireApproval: [
+            './src/db/**',
+            './waymark.config.json'
+        ],
+        maxBashOutputBytes: 10000
+    }
+};
+const CLAUDE_MD_CONTENT = `# Waymark — Active in this project
+
+All file system actions in this project are monitored and controlled by Waymark.
+
+## Rules (auto-loaded from waymark.config.json)
+- Always use Waymark MCP tools for file operations
+- Use waymark:write_file instead of write_file
+- Use waymark:read_file instead of read_file
+- Use waymark:bash instead of bash
+- Never bypass Waymark tools for any file operation
+
+## Why
+Waymark logs all actions, enforces scope policies,
+enables rollback, and routes sensitive paths for
+human approval before execution.
+
+## Dashboard
+View all actions at: http://localhost:3001
+`;
+const WAYMARK_MARKER = '<!-- waymark -->';
+function prompt(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        rl.question(question, answer => { rl.close(); resolve(answer.trim()); });
+    });
+}
+function getClaudeDesktopConfigPath() {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        return path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    }
+    else if (platform === 'win32') {
+        return path.join(process.env.APPDATA || os.homedir(), 'Claude', 'claude_desktop_config.json');
+    }
+    else {
+        return path.join(os.homedir(), '.config', 'Claude', 'claude_desktop_config.json');
+    }
+}
+function resolveServerBin() {
+    // Try installed @shaifulshabuj-waymarks/server package
+    try {
+        return require.resolve('@shaifulshabuj-waymarks/server/dist/mcp/server.js');
+    }
+    catch {
+        // Fallback: assume we're inside the waymark monorepo
+        return path.resolve(__dirname, '../../../server/dist/mcp/server.js');
+    }
+}
+async function run() {
+    const projectRoot = process.cwd();
+    console.log(`Initializing Waymark in: ${projectRoot}`);
+    // Step 1 — Detect project
+    const hasPackageJson = fs.existsSync(path.join(projectRoot, 'package.json'));
+    const hasGit = fs.existsSync(path.join(projectRoot, '.git'));
+    if (!hasPackageJson && !hasGit) {
+        console.warn('Warning: No package.json or .git found. Continuing anyway.');
+    }
+    // Step 2 — Install @shaifulshabuj-waymarks/server (skip if already resolvable or in monorepo)
+    let serverBin;
+    try {
+        serverBin = require.resolve('@shaifulshabuj-waymarks/server/dist/mcp/server.js');
+        console.log('✓ @shaifulshabuj-waymarks/server already installed');
+    }
+    catch {
+        const monorepoFallback = path.resolve(__dirname, '../../../server/dist/mcp/server.js');
+        if (fs.existsSync(monorepoFallback)) {
+            serverBin = monorepoFallback;
+            console.log('✓ Using local @shaifulshabuj-waymarks/server (monorepo)');
+        }
+        else {
+            console.log('Installing @shaifulshabuj-waymarks/server...');
+            const result = (0, child_process_1.spawnSync)('npm', ['install', '--save-dev', '@shaifulshabuj-waymarks/server'], {
+                stdio: 'inherit',
+                cwd: projectRoot
+            });
+            if (result.status !== 0) {
+                console.error('Failed to install @shaifulshabuj-waymarks/server');
+                process.exit(1);
+            }
+            serverBin = resolveServerBin();
+        }
+    }
+    // Step 3 — Create waymark.config.json
+    const configPath = path.join(projectRoot, 'waymark.config.json');
+    if (fs.existsSync(configPath)) {
+        const answer = await prompt('waymark.config.json exists. Overwrite? (y/N) ');
+        if (answer.toLowerCase() !== 'y') {
+            console.log('Keeping existing waymark.config.json');
+        }
+        else {
+            fs.writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2) + '\n');
+            console.log('✓ Created waymark.config.json');
+        }
+    }
+    else {
+        fs.writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2) + '\n');
+        console.log('✓ Created waymark.config.json');
+    }
+    // Step 4 — Create/append CLAUDE.md
+    const claudeMdPath = path.join(projectRoot, 'CLAUDE.md');
+    if (fs.existsSync(claudeMdPath)) {
+        const existing = fs.readFileSync(claudeMdPath, 'utf8');
+        if (existing.includes(WAYMARK_MARKER)) {
+            console.log('✓ CLAUDE.md already has Waymark section');
+        }
+        else {
+            fs.appendFileSync(claudeMdPath, `\n${WAYMARK_MARKER}\n${CLAUDE_MD_CONTENT}`);
+            console.log('✓ Appended Waymark section to CLAUDE.md');
+        }
+    }
+    else {
+        fs.writeFileSync(claudeMdPath, `${WAYMARK_MARKER}\n${CLAUDE_MD_CONTENT}`);
+        console.log('✓ Created CLAUDE.md — Claude Code will now use Waymark automatically');
+    }
+    // Step 5 — Update .gitignore
+    const gitignorePath = path.join(projectRoot, '.gitignore');
+    const gitignoreContent = fs.existsSync(gitignorePath)
+        ? fs.readFileSync(gitignorePath, 'utf8')
+        : '';
+    const linesToAdd = ['.waymark/', 'waymark.db', 'data/waymark.db']
+        .filter(line => !gitignoreContent.includes(line));
+    if (linesToAdd.length > 0) {
+        const section = '\n# Waymark\n' + linesToAdd.join('\n') + '\n';
+        fs.appendFileSync(gitignorePath, section);
+        console.log('✓ Updated .gitignore');
+    }
+    else {
+        console.log('✓ .gitignore already up to date');
+    }
+    // Step 6 — Register MCP in both Claude configs
+    const nodeBin = process.execPath;
+    const mcpEntry = {
+        command: nodeBin,
+        args: [serverBin, '--project-root', projectRoot]
+    };
+    // Claude Desktop config
+    const desktopConfigPath = getClaudeDesktopConfigPath();
+    try {
+        const desktopDir = path.dirname(desktopConfigPath);
+        if (!fs.existsSync(desktopDir))
+            fs.mkdirSync(desktopDir, { recursive: true });
+        const desktopConfig = fs.existsSync(desktopConfigPath)
+            ? JSON.parse(fs.readFileSync(desktopConfigPath, 'utf8'))
+            : { mcpServers: {} };
+        if (!desktopConfig.mcpServers)
+            desktopConfig.mcpServers = {};
+        if (desktopConfig.mcpServers.waymark) {
+            console.log('✓ Claude Desktop MCP entry already exists — skipping');
+        }
+        else {
+            desktopConfig.mcpServers.waymark = mcpEntry;
+            fs.writeFileSync(desktopConfigPath, JSON.stringify(desktopConfig, null, 2) + '\n');
+            console.log('✓ Registered Waymark MCP server in Claude Desktop config');
+        }
+    }
+    catch (err) {
+        console.warn(`Warning: Could not update Claude Desktop config: ${err.message}`);
+    }
+    // .mcp.json (Claude Code project-level)
+    const mcpJsonPath = path.join(projectRoot, '.mcp.json');
+    try {
+        const mcpJson = fs.existsSync(mcpJsonPath)
+            ? JSON.parse(fs.readFileSync(mcpJsonPath, 'utf8'))
+            : { mcpServers: {} };
+        if (!mcpJson.mcpServers)
+            mcpJson.mcpServers = {};
+        if (mcpJson.mcpServers.waymark) {
+            console.log('✓ .mcp.json Waymark entry already exists — skipping');
+        }
+        else {
+            mcpJson.mcpServers.waymark = { type: 'stdio', ...mcpEntry, cwd: projectRoot };
+            fs.writeFileSync(mcpJsonPath, JSON.stringify(mcpJson, null, 2) + '\n');
+            console.log('✓ Created .mcp.json for Claude Code');
+        }
+    }
+    catch (err) {
+        console.warn(`Warning: Could not update .mcp.json: ${err.message}`);
+    }
+    // Step 7 — Success summary
+    console.log('');
+    console.log('┌─────────────────────────────────────┐');
+    console.log('│  ✅ Waymark initialized             │');
+    console.log('│                                     │');
+    console.log('│  Files created:                     │');
+    console.log('│    waymark.config.json              │');
+    console.log('│    CLAUDE.md                        │');
+    console.log('│                                     │');
+    console.log('│  Next steps:                        │');
+    console.log('│  1. Restart Claude Code             │');
+    console.log('│  2. Open this project in Claude     │');
+    console.log('│  3. View dashboard:                 │');
+    console.log('│npx @shaifulshabuj-waymarks/cli start│');
+    console.log('│     http://localhost:3001           │');
+    console.log('│                                     │');
+    console.log('│  Waymark is now always-on in        │');
+    console.log('│  this project. No manual setup      │');
+    console.log('│  required per session.              │');
+    console.log('└─────────────────────────────────────┘');
+}

package/dist/commands/logs.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const BASE = 'http://localhost:3001';
+function relativeTime(iso) {
+    const diffMs = Date.now() - new Date(iso.replace(' ', 'T') + 'Z').getTime();
+    const mins = Math.floor(diffMs / 60000);
+    if (mins < 1)
+        return 'just now';
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    return `${Math.floor(hours / 24)}d ago`;
+}
+function truncate(str, len) {
+    if (!str)
+        return '—';
+    const s = str.split('/').pop() || str;
+    return s.length > len ? s.slice(0, len - 1) + '…' : s;
+}
+function pad(str, len) {
+    return str.padEnd(len).slice(0, len);
+}
+async function run() {
+    const args = process.argv.slice(3);
+    const limitIdx = args.indexOf('--limit');
+    const limit = limitIdx !== -1 ? parseInt(args[limitIdx + 1], 10) || 20 : 20;
+    const pendingOnly = args.includes('--pending');
+    const blockedOnly = args.includes('--blocked');
+    let rows;
+    try {
+        const res = await fetch(`${BASE}/api/actions`);
+        if (!res.ok)
+            throw new Error('Bad response');
+        rows = await res.json();
+    }
+    catch {
+        console.log('Waymark is not running. Start with: waymark start');
+        return;
+    }
+    if (pendingOnly)
+        rows = rows.filter((r) => r.status === 'pending');
+    if (blockedOnly)
+        rows = rows.filter((r) => r.status === 'blocked');
+    rows = rows.slice(0, limit);
+    if (rows.length === 0) {
+        console.log('No actions found.');
+        return;
+    }
+    console.log(pad('Time', 10) + '  ' +
+        pad('Tool', 12) + '  ' +
+        pad('Path / Command', 40) + '  ' +
+        pad('Decision', 10) + '  ' +
+        'Status');
+    console.log('─'.repeat(86));
+    for (const r of rows) {
+        const target = r.target_path
+            ? truncate(r.target_path, 40)
+            : truncate(JSON.parse(r.input_payload || '{}').command || '—', 40);
+        console.log(pad(relativeTime(r.created_at), 10) + '  ' +
+            pad(r.tool_name, 12) + '  ' +
+            pad(target, 40) + '  ' +
+            pad(r.decision || '—', 10) + '  ' +
+            r.status);
+    }
+}

package/dist/commands/start.js

@@ -0,0 +1,88 @@
+"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 });
+exports.run = run;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+function resolveServerBin(name) {
+    const file = name === 'mcp' ? 'mcp/server.js' : 'api/server.js';
+    try {
+        return require.resolve(`@shaifulshabuj-waymarks/server/dist/${file}`);
+    }
+    catch {
+        return path.resolve(__dirname, `../../../server/dist/${file}`);
+    }
+}
+function openBrowser(url) {
+    try {
+        const cmd = process.platform === 'darwin' ? 'open'
+            : process.platform === 'win32' ? 'start'
+                : 'xdg-open';
+        (0, child_process_1.execSync)(`${cmd} ${url}`, { stdio: 'ignore' });
+    }
+    catch {
+        // ignore — browser open is best-effort
+    }
+}
+function run() {
+    const projectRoot = process.cwd();
+    const configPath = path.join(projectRoot, 'waymark.config.json');
+    if (!fs.existsSync(configPath)) {
+        console.error('waymark.config.json not found. Run waymark init first.');
+        process.exit(1);
+    }
+    const nodeBin = process.execPath;
+    const mcpBin = resolveServerBin('mcp');
+    const apiBin = resolveServerBin('api');
+    const env = { ...process.env, WAYMARK_PROJECT_ROOT: projectRoot };
+    console.log('Starting Waymark...');
+    const apiProc = (0, child_process_1.spawn)(nodeBin, [apiBin], { env, stdio: 'inherit' });
+    const mcpProc = (0, child_process_1.spawn)(nodeBin, [mcpBin, '--project-root', projectRoot], { env, stdio: 'ignore' });
+    // Open browser after short delay for server startup
+    setTimeout(() => openBrowser('http://localhost:3001'), 1500);
+    console.log('');
+    console.log('Waymark running');
+    console.log('Dashboard:  http://localhost:3001');
+    console.log('MCP server: active (stdio)');
+    console.log('Press Ctrl+C to stop');
+    const cleanup = () => {
+        apiProc.kill();
+        mcpProc.kill();
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+}

package/dist/commands/status.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const BASE = 'http://localhost:3001';
+async function run() {
+    try {
+        const [countRes, actionsRes] = await Promise.all([
+            fetch(`${BASE}/api/actions?count=true`),
+            fetch(`${BASE}/api/actions`)
+        ]);
+        if (!countRes.ok || !actionsRes.ok)
+            throw new Error('Bad response');
+        const { count: pending } = await countRes.json();
+        const actions = await actionsRes.json();
+        const total = actions.length;
+        console.log('Waymark status');
+        console.log(`Dashboard:          ${BASE} (running)`);
+        console.log(`Pending approvals:  ${pending}`);
+        console.log(`Total actions logged: ${total}`);
+    }
+    catch {
+        console.log('Waymark is not running. Start with: waymark start');
+    }
+}

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+const command = process.argv[2];
+switch (command) {
+    case 'init':
+        require('./commands/init').run();
+        break;
+    case 'start':
+        require('./commands/start').run();
+        break;
+    case 'status':
+        require('./commands/status').run();
+        break;
+    case 'logs':
+        require('./commands/logs').run();
+        break;
+    default:
+        console.log('Usage: waymark <init|start|status|logs>');
+        console.log('');
+        console.log('Commands:');
+        console.log('  init    Set up Waymark in the current project');
+        console.log('  start   Start the Waymark dashboard and MCP server');
+        console.log('  status  Show current Waymark status and pending count');
+        console.log('  logs    Show recent action log');
+        process.exit(command ? 1 : 0);
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@shaifulshabuj-waymarks/cli",
+  "version": "0.1.0",
+  "description": "Control what AI agents can do in your codebase",
+  "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"
+  ],
+  "bin": {
+    "waymark": "./dist/index.js"
+  },
+  "files": [
+    "dist/**"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@shaifulshabuj-waymarks/server": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.5",
+    "typescript": "^5.3.3"
+  }
+}