memoryblock 0.1.0-beta → 0.1.2

package/src/cli/commands/status.ts

@@ -1,90 +0,0 @@
-import { promises as fsp } from 'node:fs';
-import { join } from 'node:path';
-import chalk from 'chalk';
-import {
-    loadGlobalConfig, resolveBlocksDir, loadPulseState, loadBlockConfig, isInitialized,
-} from '../../utils/config.js';
-import { pathExists } from '../../utils/fs.js';
-import { log } from '../logger.js';
-import { t } from '@memoryblock/locale';
-import type { BlockStatus } from '../../types.js';
-
-const STATUS_ICON: Record<BlockStatus, string> = {
-    SLEEPING: chalk.gray('💤'),
-    ACTIVE: chalk.green('🟢'),
-    BUSY: chalk.yellow('🔶'),
-    ERROR: chalk.red('🔴'),
-};
-
-export async function statusCommand(): Promise<void> {
-    if (!(await isInitialized())) {
-        log.error(t.general.notInitialized);
-        process.exit(1);
-    }
-
-    const globalConfig = await loadGlobalConfig();
-    const blocksDir = resolveBlocksDir(globalConfig);
-
-    if (!(await pathExists(blocksDir))) {
-        log.info(t.general.noBlocksDir);
-        return;
-    }
-
-    const entries = await fsp.readdir(blocksDir, { withFileTypes: true });
-    const blocks = entries.filter((e) => e.isDirectory() && !e.name.startsWith('_') && !e.name.startsWith('.'));
-
-    log.brand(`Status — ${blocks.length} block(s)\n`);
-
-    if (blocks.length === 0) {
-        console.log(`  ${chalk.dim(t.status.noActive)}`);
-    }
-
-    for (const block of blocks) {
-        const blockPath = join(blocksDir, block.name);
-        try {
-            const config = await loadBlockConfig(blockPath);
-            const pulse = await loadPulseState(blockPath);
-            const icon = STATUS_ICON[pulse.status] || '❓';
-
-            console.log(`  ${icon} ${chalk.bold(config.name)} ${chalk.dim(`(${pulse.status})`)}`);
-            if (pulse.currentTask) {
-                console.log(`     ${chalk.dim('Task:')} ${pulse.currentTask}`);
-            }
-            if (pulse.lastRun) {
-                console.log(`     ${chalk.dim('Last:')} ${pulse.lastRun}`);
-            }
-            if (pulse.error) {
-                console.log(`     ${chalk.red('Error:')} ${pulse.error}`);
-            }
-        } catch {
-            console.log(`  ❓ ${chalk.bold(block.name)} ${chalk.dim(`(${t.status.invalidConfig})`)}`);
-        }
-    }
-
-    // Show archived blocks
-    const archiveDir = join(blocksDir, '_archive');
-    if (await pathExists(archiveDir)) {
-        try {
-            const archiveEntries = await fsp.readdir(archiveDir, { withFileTypes: true });
-            const archived = archiveEntries.filter(e => e.isDirectory());
-
-            if (archived.length > 0) {
-                console.log('');
-                console.log(`  ${chalk.dim(t.status.archived(archived.length))}`);
-                for (const a of archived) {
-                    // Extract block name and date from "name_2026-03-21T10-33-24-242Z"
-                    const match = a.name.match(/^(.*?)_(\d{4}-\d{2}-\d{2})T/);
-                    const name = match ? match[1] : a.name;
-                    const date = match ? match[2] : '';
-                    console.log(`     ${chalk.dim('·')} ${chalk.dim(name)}${date ? chalk.dim(` (${date})`) : ''}`);
-                }
-                console.log('');
-                console.log(`     ${chalk.dim(t.status.restoreHint)}`);
-            }
-        } catch {
-            // Archive dir exists but can't be read — skip
-        }
-    }
-
-    console.log('');
-}

package/src/cli/commands/stop.ts

@@ -1,91 +0,0 @@
-import type { GlobalConfig } from '../../types.js';
-import { loadGlobalConfig, resolveBlocksDir, resolveBlockPath, savePulseState, loadPulseState, loadBlockConfig, saveBlockConfig } from '../../utils/config.js';
-import { pathExists } from '../../utils/fs.js';
-import { log } from '../logger.js';
-import { promises as fsp } from 'node:fs';
-import { join } from 'node:path';
-
-const DAEMON_PKG = '@memoryblock/daemon';
-
-/**
- * Stop a running block monitor.
- * Updates pulse state to SLEEPING.
- * In the MVP foreground model, this is mainly used for cleanup.
- */
-export async function stopCommand(blockName?: string, options?: { preserveEnabled?: boolean }): Promise<void> {
-  const globalConfig = await loadGlobalConfig();
-  const blocksDir = resolveBlocksDir(globalConfig);
-
-  if (!await pathExists(blocksDir)) {
-    log.warn('No blocks directory found. Nothing to stop.');
-    return;
-  }
-
-  if (blockName) {
-    await stopBlock(globalConfig, blockName, options);
-  } else {
-    log.brand('Stopping all blocks...\n');
-    const entries = await fsp.readdir(blocksDir, { withFileTypes: true });
-    let stopped = 0;
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const didStop = await stopBlock(globalConfig, entry.name, options);
-        if (didStop) stopped++;
-      }
-    }
-    if (stopped === 0) {
-      log.dim('  No active blocks to stop.');
-    }
-  }
-}
-
-async function stopBlock(globalConfig: GlobalConfig, name: string, options?: { preserveEnabled?: boolean }): Promise<boolean> {
-  const blockPath = resolveBlockPath(globalConfig, name);
-
-  if (!await pathExists(join(blockPath, 'pulse.json'))) {
-    log.warn(`Block "${name}" not found.`);
-    return false;
-  }
-
-  const pulse = await loadPulseState(blockPath);
-
-  let daemonKilled = false;
-  try {
-    const daemon = await import(DAEMON_PKG);
-    daemonKilled = await daemon.killDaemon(blockPath);
-  } catch {
-    // Daemon package not found or error parsing pid
-  }
-
-  if (pulse.status === 'SLEEPING' && !daemonKilled) {
-    log.dim(`  ${name}: already sleeping`);
-    return false;
-  }
-
-  await savePulseState(blockPath, {
-    status: 'SLEEPING',
-    lastRun: new Date().toISOString(),
-    nextWakeUp: null,
-    currentTask: null,
-    error: null,
-  });
-
-  // Persist disabled state across reboots (unless preserveEnabled is set)
-  if (!options?.preserveEnabled) {
-    try {
-      const blockConfig = await loadBlockConfig(blockPath);
-      if (blockConfig.enabled !== false) {
-        blockConfig.enabled = false;
-        await saveBlockConfig(blockPath, blockConfig);
-      }
-    } catch { /* config read failure is non-critical */ }
-  }
-
-  if (daemonKilled) {
-    log.success(`  ${name}: stopped (daemon process killed)`);
-  } else {
-    log.success(`  ${name}: stopped`);
-  }
-  
-  return true;
-}

package/src/cli/commands/web.ts

@@ -1,74 +0,0 @@
-import {
-    isInitialized,
-} from '../../utils/config.js';
-import { log } from '../logger.js';
-import { DEFAULT_PORT } from '../constants.js';
-
-const API_PKG = '@memoryblock/api';
-
-export async function webCommand(options?: { port?: string; newToken?: boolean }): Promise<void> {
-    if (!(await isInitialized())) {
-        log.error('Not initialized. Run `mblk init` first.');
-        process.exit(1);
-    }
-
-    const port = parseInt(options?.port || DEFAULT_PORT, 10);
-
-    let api: any;
-    try {
-        api = await import(API_PKG);
-    } catch (err) {
-        log.error(`Failed to load API package: ${(err as Error).message}`);
-        process.exit(1);
-    }
-
-    // Determine workspace path for token persistence
-    const workspacePath = process.cwd();
-
-    // Generate or reuse auth token
-    const authToken = await api.generateAuthToken(workspacePath, options?.newToken);
-
-    log.brand('web\n');
-    log.dim(`  http://localhost:${port}`);
-    log.dim(`  token: ${authToken}`);
-    console.log('');
-
-    // Resolve web UI static files path
-    let webRoot: string | undefined;
-    try {
-        const { createRequire } = await import('node:module');
-        const require = createRequire(import.meta.url);
-        const webPkg = require.resolve('@memoryblock/web/package.json');
-        const { dirname, join } = await import('node:path');
-        webRoot = join(dirname(webPkg), 'public');
-    } catch {
-        log.warn('Web UI package not found. API-only mode.');
-    }
-
-    const server = new api.ApiServer({
-        port,
-        authToken,
-        workspacePath,
-        webRoot,
-    });
-
-    const shutdown = async () => {
-        log.system('web', 'shutting down...');
-        await server.stop();
-        process.exit(0);
-    };
-
-    process.on('SIGINT', shutdown);
-    process.on('SIGTERM', shutdown);
-
-    try {
-        await server.start();
-        log.dim('  api server running. ctrl+c to stop.');
-    } catch (err) {
-        log.error(`API server failed: ${(err as Error).message}`);
-        process.exit(1);
-    }
-
-    // Keep alive
-    await new Promise(() => {});
-}

package/src/cli/constants.ts

@@ -1,88 +0,0 @@
-/**
- * Shared constants for the CLI commands.
- * Single source of truth — imported by init.ts, start.ts, and mblk.ts.
- */
-
-// Default port for the web/API server
-export const DEFAULT_PORT = '8420';
-
-// Available LLM providers
-export const PROVIDERS = [
-    { value: 'bedrock',   label: 'AWS Bedrock',        hint: 'Claude, Llama via AWS' },
-    { value: 'anthropic', label: 'Anthropic',           hint: 'Claude API direct' },
-    { value: 'openai',    label: 'OpenAI',              hint: 'GPT-4, GPT-4o' },
-    { value: 'gemini',    label: 'Google Gemini',        hint: 'Gemini Pro, Flash' },
-    { value: 'ollama',    label: 'Ollama (local)',       hint: 'Run models locally — no API key' },
-] as Array<{ value: string; label: string; hint: string }>;
-
-// Available communication channels
-export const CHANNELS = [
-    { value: 'cli',      label: 'Terminal (CLI)',   hint: 'always enabled' },
-    { value: 'web',      label: 'Web Dashboard',    hint: 'always enabled' },
-    { value: 'telegram', label: 'Telegram',         hint: 'bot token required' },
-    { value: 'discord',  label: 'Discord',          hint: 'coming soon' },
-    { value: 'slack',    label: 'Slack',             hint: 'coming soon' },
-] as Array<{ value: string; label: string; hint: string }>;
-
-// Optional skills & plugins
-export const PLUGINS = [
-    { value: 'web-search',    label: 'Web Search',      hint: 'search the web via Brave API' },
-    { value: 'fetch-webpage', label: 'Fetch Webpage',    hint: 'extract text from URLs' },
-    { value: 'aws',           label: 'AWS Tools',        hint: 'S3, Lambda, etc.' },
-] as Array<{ value: string; label: string; hint: string }>;
-
-// Auth fields needed per provider
-export const PROVIDER_AUTH: Record<string, {
-    fields: Array<{ key: string; label: string; secret: boolean }>;
-}> = {
-    bedrock: {
-        fields: [
-            { key: 'accessKeyId', label: 'Access Key ID', secret: true },
-            { key: 'secretAccessKey', label: 'Secret Access Key', secret: true },
-            { key: 'region', label: 'Region', secret: false },
-        ],
-    },
-    anthropic: {
-        fields: [{ key: 'apiKey', label: 'API Key', secret: true }],
-    },
-    openai: {
-        fields: [{ key: 'apiKey', label: 'API Key', secret: true }],
-    },
-    gemini: {
-        fields: [{ key: 'apiKey', label: 'API Key', secret: true }],
-    },
-    ollama: {
-        fields: [], // No auth needed
-    },
-};
-
-// Auth fields for channels
-export const CHANNEL_AUTH: Record<string, Array<{ key: string; label: string; secret: boolean }>> = {
-    telegram: [
-        { key: 'botToken', label: 'Bot Token (from @BotFather)', secret: true },
-        { key: 'chatId', label: 'Chat ID', secret: false },
-    ],
-};
-
-/**
- * Read the package version from core's package.json at runtime.
- * Falls back to 'dev' if the file can't be read.
- */
-export async function getVersion(): Promise<string> {
-    try {
-        const { readFile } = await import('node:fs/promises');
-        const { join, dirname } = await import('node:path');
-        const { fileURLToPath } = await import('node:url');
-
-        // Navigate from this file to the core package.json
-        // This file is at: packages/core/src/cli/constants.ts
-        // package.json is at: packages/core/package.json
-        const thisDir = dirname(fileURLToPath(import.meta.url));
-        const pkgPath = join(thisDir, '..', '..', '..', 'package.json');
-        const raw = await readFile(pkgPath, 'utf-8');
-        const pkg = JSON.parse(raw);
-        return pkg.version || 'dev';
-    } catch {
-        return 'dev';
-    }
-}

package/src/cli/logger.ts

@@ -1,48 +0,0 @@
-import chalk from 'chalk';
-
-const BRAND = chalk.hex('#7C3AED');
-const BRAND_BG = chalk.bgHex('#7C3AED').white.bold;
-const NAME = BRAND_BG(' ⬡ memoryblock ');
-
-export const log = {
-    banner(): void {
-        /* eslint-disable no-irregular-whitespace */
-        const ascii = `
- █▀▄▀█ █▀▀ █▀▄▀█ █▀█ █▀█ █▄█ █▄▄ █░░ █▀█ █▀▀ █▄▀
- █░▀░█ ██▄ █░▀░█ █▄█ █▀▄ ░█░ █▄█ █▄▄ █▄█ █▄▄ █░█ 
-`;
-        /* eslint-enable no-irregular-whitespace */
-        console.log(chalk.hex('#805AD5').bold(ascii));
-    },
-    info(message: string): void {
-        console.log(`${chalk.blue('ℹ')} ${message}`);
-    },
-
-    success(message: string): void {
-        console.log(`${chalk.green('✓')} ${message}`);
-    },
-
-    warn(message: string): void {
-        console.log(`${chalk.yellow('⚠')} ${message}`);
-    },
-
-    error(message: string): void {
-        console.error(`${chalk.red('✖')} ${message}`);
-    },
-
-    system(blockName: string, message: string): void {
-        console.log(`${chalk.gray(`⚙️  [${blockName}]`)} ${message}`);
-    },
-
-    monitor(blockName: string, monitorName: string, message: string): void {
-        console.log(`${BRAND(`⬡ ${monitorName}`)} ${chalk.gray(`[${blockName}]`)} ${message}`);
-    },
-
-    brand(message: string): void {
-        console.log(`\n${NAME} ${message}`);
-    },
-
-    dim(message: string): void {
-        console.log(chalk.dim(message));
-    },
-};

package/src/engine/agent.ts

@@ -1,19 +0,0 @@
-/**
- * Agent: Ephemeral worker spawned by the Monitor.
- * Lives in blocks/<name>/agents/<agent-id>/
- * Has its own memory and tool scope.
- *
- * MVP: Placeholder — Monitor can function without agents.
- * Full agent spawning will be implemented post-MVP.
- */
-export class Agent {
-    readonly id: string;
-    readonly role: string;
-    readonly agentPath: string;
-
-    constructor(id: string, role: string, agentPath: string) {
-        this.id = id;
-        this.role = role;
-        this.agentPath = agentPath;
-    }
-}

package/src/engine/conversation-log.ts

@@ -1,90 +0,0 @@
-import { promises as fsp } from 'node:fs';
-import { join } from 'node:path';
-
-/**
- * Conversation logger — writes all interactions to timestamped .txt files
- * in the block's logs/ directory.
- *
- * Log format:
- * ---
- * [2025-03-12 00:09:51] [CHANNEL:telegram] [FROM:user] [CHAT:5315436002]
- * Hello, how are you?
- *
- * [2025-03-12 00:09:54] [CHANNEL:telegram] [FROM:monitor:Sam] [EMOJI:🌟]
- * I'm doing well! How can I help you today?
- * ---
- */
-export class ConversationLogger {
-    private logDir: string;
-    private logFile: string;
-    private buffer: string[] = [];
-    private flushTimer: ReturnType<typeof setTimeout> | null = null;
-
-    constructor(blockPath: string) {
-        this.logDir = join(blockPath, 'logs');
-        // Temporary filename until init() provides block name and channel
-        this.logFile = join(this.logDir, `session-${Date.now()}.txt`);
-    }
-
-    async init(blockName: string, monitorName: string, channelType: string): Promise<void> {
-        await fsp.mkdir(this.logDir, { recursive: true });
-
-        // Build filename: {blockName}-{channelType}-{timestamp}.txt
-        const now = new Date();
-        const stamp = now.toISOString().replace('T', '_').replace(/:/g, '-').slice(0, 16);
-        this.logFile = join(this.logDir, `${blockName}-${channelType}-${stamp}.txt`);
-
-        const header = [
-            '═'.repeat(60),
-            `SESSION START: ${new Date().toISOString()}`,
-            `Block: ${blockName}`,
-            `Monitor: ${monitorName}`,
-            `Channel: ${channelType}`,
-            '═'.repeat(60),
-            '',
-        ].join('\n');
-        await fsp.writeFile(this.logFile, header, 'utf-8');
-    }
-
-    logUser(content: string, meta: { channel: string; chatId?: string }): void {
-        const ts = new Date().toISOString().replace('T', ' ').slice(0, 19);
-        const chatPart = meta.chatId ? ` [CHAT:${meta.chatId}]` : '';
-        const entry = `[${ts}] [CHANNEL:${meta.channel}] [FROM:user]${chatPart}\n${content}\n\n`;
-        this.buffer.push(entry);
-        this.scheduleFlush();
-    }
-
-    logMonitor(content: string, meta: { channel: string; monitorName: string; emoji?: string }): void {
-        const ts = new Date().toISOString().replace('T', ' ').slice(0, 19);
-        const emojiPart = meta.emoji ? ` [EMOJI:${meta.emoji}]` : '';
-        const entry = `[${ts}] [CHANNEL:${meta.channel}] [FROM:monitor:${meta.monitorName}]${emojiPart}\n${content}\n\n`;
-        this.buffer.push(entry);
-        this.scheduleFlush();
-    }
-
-    logSystem(message: string): void {
-        const ts = new Date().toISOString().replace('T', ' ').slice(0, 19);
-        const entry = `[${ts}] [SYSTEM]\n${message}\n\n`;
-        this.buffer.push(entry);
-        this.scheduleFlush();
-    }
-
-    async close(): Promise<void> {
-        if (this.flushTimer) clearTimeout(this.flushTimer);
-        await this.flush();
-        const footer = `\n${'═'.repeat(60)}\nSESSION END: ${new Date().toISOString()}\n${'═'.repeat(60)}\n`;
-        await fsp.appendFile(this.logFile, footer, 'utf-8');
-    }
-
-    private scheduleFlush(): void {
-        if (this.flushTimer) clearTimeout(this.flushTimer);
-        this.flushTimer = setTimeout(() => this.flush(), 500);
-    }
-
-    private async flush(): Promise<void> {
-        if (!this.buffer.length) return;
-        const content = this.buffer.join('');
-        this.buffer = [];
-        await fsp.appendFile(this.logFile, content, 'utf-8');
-    }
-}

package/src/engine/cost-tracker.ts

@@ -1,134 +0,0 @@
-import { promises as fsp } from 'node:fs';
-import { join } from 'node:path';
-import type { TokenUsage } from '../types.js';
-
-/**
- * Pricing per 1M tokens (USD) — system-level, zero model tokens used.
- * Source: AWS Bedrock / Anthropic pricing pages.
- */
-const MODEL_PRICING: Record<string, { input: number; output: number }> = {
-    // Opus
-    'us.anthropic.claude-opus-4-6-v1': { input: 15, output: 75 },
-    'us.anthropic.claude-opus-4-20250514-v1:0': { input: 15, output: 75 },
-    // Sonnet
-    'us.anthropic.claude-sonnet-4-20250514-v1:0': { input: 3, output: 15 },
-    'us.anthropic.claude-sonnet-4-5-20250929-v1:0': { input: 3, output: 15 },
-    // Haiku
-    'us.anthropic.claude-3-5-haiku-20241022-v1:0': { input: 0.80, output: 4 },
-};
-
-const DEFAULT_PRICING = { input: 3, output: 15 };
-
-interface CostSnapshot {
-    sessionInput: number;
-    sessionOutput: number;
-    totalInput: number;
-    totalOutput: number;
-    sessionCost: number;
-    totalCost: number;
-    lastUpdated: string;
-}
-
-/**
- * System-level cost tracker — tracks tokens and calculates USD cost.
- * Persists to costs.json in the block directory.
- * No model tokens wasted — this is pure system bookkeeping.
- */
-export class CostTracker {
-    private model: string;
-    private pricing: { input: number; output: number };
-    private sessionInput = 0;
-    private sessionOutput = 0;
-    private totalInput = 0;
-    private totalOutput = 0;
-    private turnCount = 0;
-    private lastTurnInput = 0;
-    private lastTurnOutput = 0;
-    private costFile: string;
-
-    constructor(blockPath: string, model: string) {
-        this.model = model;
-        this.costFile = join(blockPath, 'costs.json');
-        // Find pricing or use default
-        this.pricing = MODEL_PRICING[model] || DEFAULT_PRICING;
-    }
-
-    /** Load previous totals from costs.json. */
-    async load(): Promise<void> {
-        try {
-            const raw = await fsp.readFile(this.costFile, 'utf-8');
-            const data = JSON.parse(raw);
-            this.totalInput = data.totalInput || 0;
-            this.totalOutput = data.totalOutput || 0;
-        } catch {
-            // First run — no file
-        }
-    }
-
-    /** Track a single API call's usage. */
-    track(usage: TokenUsage): void {
-        this.lastTurnInput = usage.inputTokens;
-        this.lastTurnOutput = usage.outputTokens;
-        this.sessionInput += usage.inputTokens;
-        this.sessionOutput += usage.outputTokens;
-        this.totalInput += usage.inputTokens;
-        this.totalOutput += usage.outputTokens;
-        this.turnCount++;
-    }
-
-    /** Get session cost in USD. */
-    getSessionCost(): number {
-        return (this.sessionInput / 1_000_000) * this.pricing.input +
-               (this.sessionOutput / 1_000_000) * this.pricing.output;
-    }
-
-    /** Get total cost in USD (all sessions). */
-    getTotalCost(): number {
-        return (this.totalInput / 1_000_000) * this.pricing.input +
-               (this.totalOutput / 1_000_000) * this.pricing.output;
-    }
-
-    /** Format cost for display. */
-    formatCost(cost: number): string {
-        return `$${cost.toFixed(4)}`;
-    }
-
-    /** Get formatted session report. */
-    getSessionReport(): string {
-        return `${this.sessionInput.toLocaleString()} in / ${this.sessionOutput.toLocaleString()} out`;
-    }
-
-    /** Get per-turn report for the last API call. */
-    getPerTurnReport(): string {
-        return `${this.lastTurnInput.toLocaleString()} in / ${this.lastTurnOutput.toLocaleString()} out`;
-    }
-
-    /** Get all-time total report. */
-    getTotalReport(): string {
-        return `${this.totalInput.toLocaleString()} in / ${this.totalOutput.toLocaleString()} out`;
-    }
-
-    /** Get turn count. */
-    getTurnCount(): number {
-        return this.turnCount;
-    }
-
-    /** Get snapshot for display / persistence. */
-    getSnapshot(): CostSnapshot {
-        return {
-            sessionInput: this.sessionInput,
-            sessionOutput: this.sessionOutput,
-            totalInput: this.totalInput,
-            totalOutput: this.totalOutput,
-            sessionCost: this.getSessionCost(),
-            totalCost: this.getTotalCost(),
-            lastUpdated: new Date().toISOString(),
-        };
-    }
-
-    /** Persist to costs.json. */
-    async save(): Promise<void> {
-        const snapshot = this.getSnapshot();
-        await fsp.writeFile(this.costFile, JSON.stringify(snapshot, null, 2), 'utf-8');
-    }
-}

package/src/engine/gatekeeper.ts

@@ -1,53 +0,0 @@
-import type { Channel, ApprovalRequest } from 'memoryblock';
-import { log } from 'memoryblock';
-
-/**
- * Gatekeeper: The sovereign human approval system.
- * When a tool requires approval (e.g., shell commands), execution pauses
- * and the system requests explicit human approval via the active channel.
- */
-export class Gatekeeper {
-    private channel: Channel;
-    private blockName: string;
-    private monitorName: string;
-
-    constructor(channel: Channel, blockName: string, monitorName: string) {
-        this.channel = channel;
-        this.blockName = blockName;
-        this.monitorName = monitorName;
-    }
-
-    /**
-     * Request human approval for a tool execution.
-     * Returns true if approved, false if denied.
-     */
-    async requestApproval(
-        toolName: string,
-        toolInput: Record<string, unknown>,
-    ): Promise<boolean> {
-        const description = this.formatDescription(toolName, toolInput);
-
-        const request: ApprovalRequest = {
-            toolName,
-            toolInput,
-            description,
-            blockName: this.blockName,
-            monitorName: this.monitorName,
-        };
-
-        log.system(this.blockName, `Approval required: ${description}`);
-
-        return this.channel.requestApproval(request);
-    }
-
-    /** Format a human-readable description of the action. */
-    private formatDescription(toolName: string, input: Record<string, unknown>): string {
-        if (toolName === 'execute_command') {
-            return `Run command: ${input.command}`;
-        }
-        const params = Object.entries(input)
-            .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
-            .join(', ');
-        return `${toolName}(${params})`;
-    }
-}