memoryblock 0.0.1 → 0.1.0-beta

package/src/cli/commands/init.ts

@@ -0,0 +1,241 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { ensureDir, writeJson } from '../../utils/fs.js';
+import {
+  getWsRoot, getConfigPath, getAuthPath, isInitialized,
+} from '../../utils/config.js';
+import { GlobalConfigSchema } from '../../schemas.js';
+import { log } from '../logger.js';
+
+import { PROVIDERS, CHANNELS, PLUGINS, PROVIDER_AUTH, CHANNEL_AUTH } from '../constants.js';
+
+// Brand accent
+const ACCENT = chalk.hex('#805AD5');
+const DIM = chalk.dim;
+
+/**
+ * Interactive onboarding wizard.
+ * Multi-step setup: providers → channels → plugins → API keys → first block.
+ * Uses @clack/prompts for styled terminal UI.
+ */
+export async function initCommand(options?: { nonInteractive?: boolean }): Promise<void> {
+  const wsDir = getWsRoot();
+
+  // Non-interactive: create defaults and exit
+  if (options?.nonInteractive) {
+    await ensureDir(wsDir);
+    const defaultConfig = GlobalConfigSchema.parse({
+        blocksDir: './blocks'
+    });
+    await writeJson(getConfigPath(), defaultConfig);
+    await writeJson(getAuthPath(), {
+      aws: { accessKeyId: '', secretAccessKey: '', region: 'us-east-1' },
+      anthropic: { apiKey: '' },
+      openai: { apiKey: '' },
+      gemini: { apiKey: '' },
+      telegram: { botToken: '', chatId: '' },
+      brave: { apiKey: '' }
+    });
+    log.brand('Initialized (non-interactive)');
+    log.success(`Workspace: ${wsDir}`);
+    log.success(`Config:    ${getConfigPath()}`);
+    return;
+  }
+
+  const alreadyInit = await isInitialized();
+
+  // Welcome
+  console.log('');
+  log.banner();
+  console.log(DIM('  Deploy isolated AI workspaces on your machine.\n'));
+
+  p.intro(chalk.bold('Setup Wizard'));
+
+  if (alreadyInit) {
+    const proceed = await p.confirm({
+      message: 'Already configured globally. Re-run setup?',
+      initialValue: false,
+    });
+    if (p.isCancel(proceed) || !proceed) {
+      p.outro('Setup cancelled.');
+      return;
+    }
+  }
+
+  // ─── Step 1: Providers ───────────────────────────────
+  const selectedProviders = await p.multiselect({
+    message: 'Which providers do you want to use?',
+    options: PROVIDERS,
+    initialValues: ['bedrock'],
+    required: true,
+  });
+
+  if (p.isCancel(selectedProviders)) {
+    p.outro('Setup cancelled.');
+    return;
+  }
+
+  // ─── Step 2: Channels ───────────────────────────────
+  const selectedChannels = await p.multiselect({
+    message: 'Which channels do you want to enable?',
+    options: CHANNELS.map(ch => ({
+      ...ch,
+      label: (ch.value === 'cli' || ch.value === 'web') ? `${ch.label} (always on)` : ch.label,
+    })),
+    initialValues: ['cli', 'web'],
+    required: true,
+  });
+
+  if (p.isCancel(selectedChannels)) {
+    p.outro('Setup cancelled.');
+    return;
+  }
+
+  // ─── Step 3: Skills & Plugins ───────────────────────
+  p.log.info(`${chalk.green('✓')} Core skills (file ops, shell, dev) — always available`);
+  p.log.info(`${chalk.green('✓')} Multi-Agent Orchestration — always available`);
+
+  let selectedPlugins: symbol | string[] = [];
+  if (PLUGINS.length > 0) {
+    selectedPlugins = await p.multiselect({
+      message: 'Select additional skills & plugins to install:',
+      options: PLUGINS.map(pl => ({
+        value: pl.value,
+        label: pl.label,
+        hint: pl.hint,
+      })),
+      required: false,
+    });
+
+    if (p.isCancel(selectedPlugins)) {
+      p.outro('Setup cancelled.');
+      return;
+    }
+  }
+
+  // ─── Step 4: API Keys ───────────────────────────────
+  const authData: Record<string, Record<string, string>> = {};
+
+  for (const provider of (selectedProviders as string[])) {
+    const providerAuth = PROVIDER_AUTH[provider];
+    if (!providerAuth || providerAuth.fields.length === 0) continue;
+
+    const providerLabel = PROVIDERS.find(p => p.value === provider)?.label || provider;
+    p.log.step(`${providerLabel} credentials`);
+
+    const data: Record<string, string> = {};
+    for (const field of providerAuth.fields) {
+      const value = await p.text({
+        message: field.label,
+        placeholder: field.key === 'region' ? 'us-east-1' : '',
+        defaultValue: field.key === 'region' ? 'us-east-1' : undefined,
+      });
+
+      if (p.isCancel(value)) {
+        p.outro('Setup cancelled.');
+        return;
+      }
+
+      data[field.key] = (value as string) || '';
+    }
+    authData[provider === 'bedrock' ? 'aws' : provider] = data;
+  }
+
+  // Channel auth (only telegram has auth currently)
+  for (const channel of (selectedChannels as string[])) {
+    const fields = CHANNEL_AUTH[channel];
+    if (!fields) continue;
+
+    const channelLabel = CHANNELS.find(c => c.value === channel)?.label || channel;
+    p.log.step(`${channelLabel} credentials`);
+
+    const data: Record<string, string> = {};
+    for (const field of fields) {
+      const value = await p.text({
+        message: field.label,
+        placeholder: field.secret ? '' : 'optional',
+      });
+
+      if (p.isCancel(value)) {
+        p.outro('Setup cancelled.');
+        return;
+      }
+
+      data[field.key] = (value as string) || '';
+    }
+    authData[channel] = data;
+  }
+
+  // ─── Step 5: Connection Testing ─────────────────────
+  const s = p.spinner();
+  const results: Array<{ name: string; ok: boolean }> = [];
+
+  // Test Bedrock
+  if (authData.aws?.accessKeyId) {
+    s.start('Testing Bedrock connection...');
+    try {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore — dynamic import, may not be installed
+      const { BedrockRuntimeClient, ConverseCommand } = await import('@aws-sdk/client-bedrock-runtime');
+      const client = new BedrockRuntimeClient({
+        region: authData.aws.region || 'us-east-1',
+        credentials: { accessKeyId: authData.aws.accessKeyId, secretAccessKey: authData.aws.secretAccessKey },
+      });
+      await client.send(new ConverseCommand({
+        modelId: 'anthropic.claude-3-haiku-20240307-v1:0',
+        messages: [{ role: 'user', content: [{ text: 'hi' }] }],
+        inferenceConfig: { maxTokens: 1 },
+      }));
+      results.push({ name: 'Bedrock', ok: true });
+      s.stop('Bedrock ✓');
+    } catch (err: any) {
+      // AccessDeniedException means credentials ARE valid, just model not enabled
+      const isAccessIssue = err?.name === 'AccessDeniedException' || err?.Code === 'AccessDeniedException';
+      if (isAccessIssue) {
+        results.push({ name: 'Bedrock', ok: true });
+        s.stop('Bedrock ✓ (credentials valid, enable models in AWS console)');
+      } else {
+        results.push({ name: 'Bedrock', ok: false });
+        s.stop('Bedrock ✗ (check credentials later)');
+      }
+    }
+  }
+
+  // Test Telegram
+  if (authData.telegram?.botToken) {
+    s.start('Testing Telegram bot...');
+    try {
+      const res = await fetch(`https://api.telegram.org/bot${authData.telegram.botToken}/getMe`);
+      const data = await res.json() as { ok: boolean };
+      results.push({ name: 'Telegram', ok: data.ok });
+      s.stop(data.ok ? 'Telegram ✓' : 'Telegram ✗');
+    } catch {
+      results.push({ name: 'Telegram', ok: false });
+      s.stop('Telegram ✗');
+    }
+  }
+
+  // ─── Step 6: Save Configuration ─────────────────────
+  await ensureDir(wsDir);
+
+  const defaultConfig = GlobalConfigSchema.parse({
+    blocksDir: './blocks',
+  });
+  await writeJson(getConfigPath(), defaultConfig);
+  await writeJson(getAuthPath(), authData);
+
+  // ─── Done ───────────────────────────────────────────
+  console.log('');
+  p.note(
+    [
+      ...results.map(r => `${r.ok ? chalk.green('✓') : chalk.yellow('○')} ${r.name}`),
+      ...(results.length === 0 ? [DIM('No connections configured yet')] : []),
+      '',
+      DIM(`Workspace: ${wsDir}`),
+      DIM(`Config:    ${getConfigPath()}`),
+    ].join('\n'),
+    'Setup Complete',
+  );
+
+  p.outro(`Run ${ACCENT('mblk start <name>')} to create and start your first block.`);
+}

package/src/cli/commands/permissions.ts

@@ -0,0 +1,77 @@
+import { loadGlobalConfig, resolveBlockPath, loadBlockConfig, saveBlockConfig } from '../../utils/config.js';
+import { pathExists } from '../../utils/fs.js';
+import { log } from '../logger.js';
+import { join } from 'node:path';
+
+type PermissionScope = 'block' | 'workspace' | 'system';
+
+const VALID_SCOPES: PermissionScope[] = ['block', 'workspace', 'system'];
+
+/**
+ * View or update block permissions.
+ * Permissions are CLI-only — they cannot be changed via chat or web.
+ */
+export async function permissionsCommand(
+    blockName: string,
+    options?: {
+        scope?: string;
+        allowShell?: boolean;
+        denyShell?: boolean;
+        allowNetwork?: boolean;
+        denyNetwork?: boolean;
+        maxTimeout?: string;
+    },
+): Promise<void> {
+    const globalConfig = await loadGlobalConfig();
+    const blockPath = resolveBlockPath(globalConfig, blockName);
+
+    if (!await pathExists(join(blockPath, 'config.json'))) {
+        log.error(`Block "${blockName}" not found.`);
+        process.exit(1);
+    }
+
+    const config = await loadBlockConfig(blockPath);
+    const perms = config.permissions || { scope: 'block', allowShell: false, allowNetwork: true, maxTimeout: 120_000 };
+
+    // No flags = show current permissions
+    const hasFlags = options?.scope || options?.allowShell || options?.denyShell
+        || options?.allowNetwork || options?.denyNetwork || options?.maxTimeout;
+
+    if (!hasFlags) {
+        log.brand(`permissions — ${blockName}\n`);
+        console.log(`  Scope:          ${perms.scope}`);
+        console.log(`  Shell Access:   ${perms.allowShell ? '✓ allowed' : '✗ denied'}`);
+        console.log(`  Network:        ${perms.allowNetwork ? '✓ allowed' : '✗ denied'}`);
+        console.log(`  Max Timeout:    ${(perms.maxTimeout / 1000).toFixed(0)}s`);
+        console.log('');
+
+        log.dim('  Scopes:');
+        log.dim('    block     — read/write own block directory only (default)');
+        log.dim('    workspace — access the entire workspace');
+        log.dim('    system    — unrestricted file and shell access');
+        console.log('');
+        return;
+    }
+
+    // Apply changes
+    if (options?.scope) {
+        if (!VALID_SCOPES.includes(options.scope as PermissionScope)) {
+            log.error(`Invalid scope: "${options.scope}". Use: block, workspace, or system.`);
+            process.exit(1);
+        }
+        perms.scope = options.scope as PermissionScope;
+    }
+
+    if (options?.allowShell) perms.allowShell = true;
+    if (options?.denyShell) perms.allowShell = false;
+    if (options?.allowNetwork) perms.allowNetwork = true;
+    if (options?.denyNetwork) perms.allowNetwork = false;
+    if (options?.maxTimeout) perms.maxTimeout = parseInt(options.maxTimeout, 10) * 1000;
+
+    // Save
+    (config as any).permissions = perms;
+    await saveBlockConfig(blockPath, config);
+
+    log.success(`  Permissions updated for "${blockName}".`);
+    console.log(`  Scope: ${perms.scope}, Shell: ${perms.allowShell ? 'yes' : 'no'}, Network: ${perms.allowNetwork ? 'yes' : 'no'}, Timeout: ${(perms.maxTimeout / 1000).toFixed(0)}s`);
+}

package/src/cli/commands/plugin-settings.ts

@@ -0,0 +1,111 @@
+import * as p from '@clack/prompts';
+import { log } from '../logger.js';
+
+/**
+ * mblk settings <plugin> — view/edit plugin settings via CLI.
+ * Auto-generates forms from the plugin's settings schema.
+ */
+export async function pluginSettingsCommand(pluginId?: string): Promise<void> {
+    let installer: any;
+    try {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore — optional runtime dependency, not needed at compile time
+        const mod = await import('@memoryblock/plugin-installer');
+        installer = new mod.PluginInstaller();
+    } catch {
+        log.error('Plugin installer not available.');
+        process.exit(1);
+    }
+
+    const plugins = await installer.listPlugins();
+
+    // No plugin specified — list all plugins with settings
+    if (!pluginId) {
+        const withSettings = plugins.filter((pl: any) => pl.settings && Object.keys(pl.settings).length > 0);
+
+        if (withSettings.length === 0) {
+            log.dim('  No plugins with configurable settings.');
+            return;
+        }
+
+        log.brand('plugin settings\n');
+        for (const pl of withSettings) {
+            const fields = Object.keys(pl.settings).length;
+            console.log(`  ${pl.core ? '●' : '○'} ${pl.name} (${pl.id}) — ${fields} setting${fields > 1 ? 's' : ''}`);
+        }
+        console.log('');
+        log.dim('  Run `mblk settings <plugin-id>` to configure.');
+        return;
+    }
+
+    // Find the plugin
+    const plugin = plugins.find((pl: any) => pl.id === pluginId);
+    if (!plugin) {
+        log.error(`Plugin "${pluginId}" not found.`);
+        process.exit(1);
+    }
+
+    if (!plugin.settings || Object.keys(plugin.settings).length === 0) {
+        log.dim(`  Plugin "${plugin.name}" has no configurable settings.`);
+        return;
+    }
+
+    // Load current values
+    const current = await installer.getPluginSettings(pluginId);
+
+    p.intro(`${plugin.name} Settings`);
+
+    const updates: Record<string, unknown> = {};
+
+    for (const [key, field] of Object.entries(plugin.settings) as [string, any][]) {
+        const currentVal = current[key];
+
+        if (field.type === 'select') {
+            const result = await p.select({
+                message: field.label,
+                options: (field.options || []).map((o: string) => ({
+                    value: o,
+                    label: o,
+                    hint: o === currentVal ? 'current' : undefined,
+                })),
+                initialValue: currentVal || field.default,
+            });
+            if (p.isCancel(result)) { p.outro('Cancelled.'); return; }
+            updates[key] = result;
+        } else if (field.type === 'toggle') {
+            const result = await p.confirm({
+                message: field.label,
+                initialValue: currentVal ?? field.default ?? false,
+            });
+            if (p.isCancel(result)) { p.outro('Cancelled.'); return; }
+            updates[key] = result;
+        } else if (field.type === 'number') {
+            const result = await p.text({
+                message: `${field.label} (${field.min ?? ''}–${field.max ?? ''})`,
+                defaultValue: String(currentVal ?? field.default ?? ''),
+                placeholder: String(field.default ?? ''),
+                validate: (v: string | undefined) => {
+                    const n = parseInt(v || '', 10);
+                    if (isNaN(n)) return 'Must be a number';
+                    if (field.min !== undefined && n < field.min) return `Min: ${field.min}`;
+                    if (field.max !== undefined && n > field.max) return `Max: ${field.max}`;
+                },
+            });
+            if (p.isCancel(result)) { p.outro('Cancelled.'); return; }
+            updates[key] = parseInt(String(result), 10);
+        } else {
+            // text / password
+            const result = await p.text({
+                message: field.label,
+                defaultValue: String(currentVal ?? field.default ?? ''),
+                placeholder: field.placeholder || '',
+            });
+            if (p.isCancel(result)) { p.outro('Cancelled.'); return; }
+            updates[key] = result;
+        }
+    }
+
+    // Save
+    await installer.savePluginSettings(pluginId, updates);
+    p.outro(`Settings saved for ${plugin.name}.`);
+}

package/src/cli/commands/plugins.ts

@@ -0,0 +1,89 @@
+import { log } from '../logger.js';
+
+const INSTALLER_PKG = '@memoryblock/plugin-installer';
+
+export async function addCommand(pluginId: string): Promise<void> {
+    let installer: any;
+    try {
+        const pkg = await import(INSTALLER_PKG);
+        installer = new pkg.PluginInstaller();
+    } catch {
+        log.error('Plugin installer not available. Install @memoryblock/plugin-installer.');
+        process.exit(1);
+    }
+
+    // Show available if no ID
+    if (!pluginId) {
+        const plugins = await installer.listPlugins();
+        log.brand('Skills & Plugins\n');
+
+        // Check installed status for each plugin
+        const rows: Array<{ id: string; name: string; status: string; installed: boolean }> = [];
+        for (const p of plugins) {
+            let installed = false;
+            try {
+                require.resolve(p.package, { paths: [process.cwd()] });
+                installed = true;
+            } catch { /* ignore */ }
+            rows.push({
+                id: p.id,
+                name: p.name,
+                status: p.status === 'upcoming' ? 'upcoming' : 'available',
+                installed,
+            });
+        }
+
+        // Table header
+        const colId = 16, colName = 24, colStatus = 12;
+        const header = `  ${'ID'.padEnd(colId)}${'Name'.padEnd(colName)}${'Status'.padEnd(colStatus)}Installed`;
+        const separator = `  ${'─'.repeat(colId)}${'─'.repeat(colName)}${'─'.repeat(colStatus)}${'─'.repeat(9)}`;
+        console.log(header);
+        console.log(separator);
+
+        for (const row of rows) {
+            const installedMark = row.installed ? '  ✓' : '  ·';
+            const statusLabel = row.status === 'upcoming' ? 'upcoming' : 'ready';
+            console.log(`  ${row.id.padEnd(colId)}${row.name.padEnd(colName)}${statusLabel.padEnd(colStatus)}${installedMark}`);
+        }
+        console.log('');
+        return;
+    }
+
+    log.dim(`  installing ${pluginId}...`);
+    const result = await installer.install(pluginId);
+
+    if (result.success) {
+        log.success(result.message);
+        if (result.plugin?.requiresAuth?.length) {
+            log.dim(`  requires: ${result.plugin.requiresAuth.join(', ')}`);
+        }
+    } else {
+        log.warn(result.message);
+    }
+}
+
+export async function removeCommand(pluginId: string): Promise<void> {
+    if (!pluginId) {
+        log.error('Specify a plugin ID: mblk remove <id>');
+        process.exit(1);
+    }
+
+    let installer: any;
+    try {
+        const pkg = await import(INSTALLER_PKG);
+        installer = new pkg.PluginInstaller();
+    } catch {
+        log.error('Plugin installer not available.');
+        process.exit(1);
+    }
+
+    log.dim(`  removing ${pluginId}...`);
+    const result = await installer.remove(pluginId);
+
+    if (result.success) {
+        log.success(result.message);
+    } else {
+        log.error(result.message);
+        process.exit(1);
+    }
+}

package/src/cli/commands/reset.ts

@@ -0,0 +1,97 @@
+import { log } from '../logger.js';
+import { loadGlobalConfig, resolveBlockPath } from '../../utils/config.js';
+import { promises as fsp } from 'node:fs';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import chalk from 'chalk';
+import { FILE_TEMPLATES } from '../../engine/prompts.js';
+
+/**
+ * mblk reset <block>        — Light cleanup: reset memory, pulse, costs, session
+ * mblk reset <block> --hard  — Full wipe: also deletes logs/ (with confirmation)
+ */
+export async function resetCommand(blockName: string, options: { hard?: boolean }): Promise<void> {
+    const globalConfig = await loadGlobalConfig();
+    const blockPath = resolveBlockPath(globalConfig, blockName);
+
+    // Verify block exists
+    try {
+        await fsp.access(blockPath);
+    } catch {
+        throw new Error(`Block "${blockName}" not found at ${blockPath}`);
+    }
+
+    // --hard requires confirmation
+    if (options.hard) {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise<string>((resolve) => {
+            rl.question(chalk.yellow(`\n⚠  --hard will wipe ALL data for "${blockName}" (logs, memory, session). Continue? (y/n): `), resolve);
+        });
+        rl.close();
+
+        if (answer.trim().toLowerCase() !== 'y') {
+            log.dim('  cancelled.');
+            return;
+        }
+    }
+
+    log.dim(`  resetting ${blockName}${options.hard ? ' (hard)' : ''}...`);
+
+    // Light reset: memory, pulse, costs, session, chat.json, and logs directory
+    const filesToReset = ['memory.md', 'pulse.json', 'costs.json', 'session.json', 'chat.json'];
+
+    for (const file of filesToReset) {
+        const filePath = join(blockPath, file);
+        try {
+            await fsp.access(filePath);
+            if (file === 'memory.md') {
+                await fsp.writeFile(filePath, FILE_TEMPLATES.MEMORY_MD, 'utf-8');
+            } else if (file === 'pulse.json') {
+                await fsp.writeFile(filePath, JSON.stringify(FILE_TEMPLATES.PULSE_JSON, null, 4), 'utf-8');
+            } else if (file === 'costs.json') {
+                await fsp.writeFile(filePath, JSON.stringify(FILE_TEMPLATES.COSTS_JSON, null, 4), 'utf-8');
+            } else if (file === 'session.json' || file === 'chat.json') {
+                await fsp.unlink(filePath);
+            }
+            log.dim(`  ✓ ${file}`);
+        } catch {
+            // Skip if file doesn't exist
+        }
+    }
+
+    // Wipe logs continuously for both soft and hard resets
+    const logsDir = join(blockPath, 'logs');
+    try {
+        const files = await fsp.readdir(logsDir);
+        for (const file of files) {
+            await fsp.unlink(join(logsDir, file));
+        }
+        log.dim(`  ✓ logs/ wiped (${files.length} files)`);
+    } catch {
+        // Logs dir might not exist or be empty
+    }
+
+    // Hard reset: wipe monitor.md and monitor identity from config
+    if (options.hard) {
+        const monitorPath = join(blockPath, 'monitor.md');
+        try {
+            await fsp.writeFile(monitorPath, FILE_TEMPLATES.MONITOR_MD(blockName), 'utf-8');
+            log.dim('  ✓ monitor.md reset');
+        } catch { /* ignore */ }
+
+        // Clear monitor identity from config
+        const configPath = join(blockPath, 'config.json');
+        try {
+            const raw = await fsp.readFile(configPath, 'utf-8');
+            const config = JSON.parse(raw);
+            delete config.monitorName;
+            delete config.monitorEmoji;
+            await fsp.writeFile(configPath, JSON.stringify(config, null, 4), 'utf-8');
+            log.dim('  ✓ monitor identity cleared');
+        } catch { /* ignore */ }
+    } else {
+        log.dim('  ℹ monitor.md and identity preserved (use --hard to wipe)');
+    }
+
+    console.log(`\n${chalk.green(`✓ ${blockName} reset.`)}`);
+}