memoryblock 0.0.1 → 0.1.0-beta

package/src/bin/mblk.ts

@@ -0,0 +1,347 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander';
+import { log } from '../cli/logger.js';
+import { initCommand } from '../cli/commands/init.js';
+import { createCommand } from '../cli/commands/create.js';
+import { startCommand } from '../cli/commands/start.js';
+import { stopCommand } from '../cli/commands/stop.js';
+import { statusCommand } from '../cli/commands/status.js';
+import { resetCommand } from '../cli/commands/reset.js';
+import { serverStartCommand, serverStopCommand, serverStatusCommand, serverTokenCommand, shutdownCommand, restartCommand } from '../cli/commands/server.js';
+import { addCommand, removeCommand } from '../cli/commands/plugins.js';
+import { deleteCommand, restoreCommand } from '../cli/commands/delete.js';
+import { permissionsCommand } from '../cli/commands/permissions.js';
+import { pluginSettingsCommand } from '../cli/commands/plugin-settings.js';
+import { serviceInstallCommand, serviceUninstallCommand, serviceStatusCommand } from '../cli/commands/service.js';
+import { getVersion, DEFAULT_PORT } from '../cli/constants.js';
+
+(async () => {
+
+const version = await getVersion();
+const program = new Command();
+
+program
+    .name('mblk')
+    .description('Deploy isolated, multi-agent AI assistants with extreme resource efficiency.')
+    .version(version)
+    .exitOverride(() => process.exit(0)) // Don't throw ELIFECYCLE when showing help
+    .configureOutput({
+        writeOut: (str) => process.stdout.write(str),
+        writeErr: (str) => process.stdout.write(str), // Prevent stderr noise from Commander
+    });
+
+program
+    .command('init')
+    .description('Interactive setup — configure credentials, verify connections, create your first block.')
+    .option('-y, --yes', 'Non-interactive mode: create defaults without prompts')
+    .action(async (opts: { yes?: boolean }) => {
+        try {
+            await initCommand({ nonInteractive: opts.yes });
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+program
+    .command('create <name>')
+    .description('Create a new block (isolated AI workspace).')
+    .action(async (name: string) => {
+        try {
+            await createCommand(name);
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+program
+    .command('start [block]')
+    .description('Start the monitor loop for a block (or all blocks).')
+    .option('-d, --daemon', 'Run the monitor in the background')
+    .option('-c, --channel <channel>', 'Specify override channel (e.g. web, cli)')
+    .action(async (block: string | undefined, opts: { daemon?: boolean; channel?: string }) => {
+        try {
+            await startCommand(block, opts);
+        } catch (err) {
+            const msg = (err as Error).message;
+            // If not initialized, auto-route to init and then retry
+            if (msg.includes('not initialized') || msg.includes('mblk init')) {
+                log.warn('Workspace not initialized. Running setup first...\n');
+                try {
+                    await initCommand();
+                    // Retry start after init completes
+                    await startCommand(block, opts);
+                } catch (initErr) {
+                    log.error((initErr as Error).message);
+                    process.exit(0);
+                }
+                return;
+            }
+            log.error(msg);
+            process.exit(0);
+        }
+    });
+
+program
+    .command('stop [block]')
+    .description('Stop a running block monitor (or all blocks).')
+    .action(async (block?: string) => {
+        try {
+            await stopCommand(block);
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+program
+    .command('status')
+    .description('Show the status of all blocks.')
+    .action(async () => {
+        try {
+            await statusCommand();
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+program
+    .command('reset <block>')
+    .description('Reset a block state (memory, pulse, costs). Use --hard to wipe logs.')
+    .option('--hard', 'Wipe logs directory as well')
+    .action(async (block: string, opts: { hard?: boolean }) => {
+        try {
+            await resetCommand(block, opts);
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+
+program
+    .command('delete <block>')
+    .description('Archive a block to prevent data loss. Use --hard to permanently delete.')
+    .option('--hard', 'Permanently wipe the block from disk')
+    .action(async (block: string, opts: { hard?: boolean }) => {
+        try {
+            await deleteCommand(block, opts);
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+program
+    .command('restore <name>')
+    .description('Restore an archived block by name.')
+    .action(async (archive: string) => {
+        try {
+            await restoreCommand(archive);
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+program
+    .command('permissions <block>')
+    .description('View or update block permissions (CLI-only).')
+    .option('-s, --scope <level>', 'Set scope: block, workspace, or system')
+    .option('--allow-shell', 'Allow shell command execution')
+    .option('--deny-shell', 'Deny shell command execution')
+    .option('--allow-network', 'Allow network/fetch access')
+    .option('--deny-network', 'Deny network/fetch access')
+    .option('--max-timeout <seconds>', 'Max command timeout in seconds')
+    .action(async (block: string, opts: any) => {
+        try {
+            await permissionsCommand(block, opts);
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+program
+    .command('settings [plugin]')
+    .description('View or edit plugin settings.')
+    .action(async (pluginId?: string) => {
+        try {
+            await pluginSettingsCommand(pluginId);
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+// ===== Server Subcommand Group =====
+
+const server = program
+    .command('server')
+    .description('Manage the web/API server.');
+
+server
+    .command('start')
+    .description('Start the web UI and API server.')
+    .option('-p, --port <port>', 'Port to listen on', DEFAULT_PORT)
+    .option('--new-token', 'Generate a new auth token')
+    .option('-d, --daemon', 'Run the server in the background')
+    .action(async (opts: { port?: string; newToken?: boolean; daemon?: boolean }) => {
+        try {
+            await serverStartCommand(opts);
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+server
+    .command('stop')
+    .description('Stop the running server.')
+    .action(async () => {
+        try {
+            await serverStopCommand();
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+server
+    .command('status')
+    .description('Show server status (PID, port, running state).')
+    .action(async () => {
+        try {
+            await serverStatusCommand();
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+server
+    .command('token')
+    .description('View the current API token, or generate a new one.')
+    .option('--new-token', 'Generate and set a new API token')
+    .action(async (opts: { newToken?: boolean }) => {
+        try {
+            await serverTokenCommand(opts);
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+// ===== Service Subcommand Group =====
+
+const service = program
+    .command('service')
+    .description('Manage OS-level auto-start (launchd/systemd).');
+
+service
+    .command('install')
+    .description('Register memoryblock to start on boot/login.')
+    .action(async () => {
+        try {
+            await serviceInstallCommand();
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+service
+    .command('uninstall')
+    .description('Remove memoryblock from system auto-start.')
+    .action(async () => {
+        try {
+            await serviceUninstallCommand();
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+service
+    .command('status')
+    .description('Check if the auto-start service is installed.')
+    .action(async () => {
+        try {
+            await serviceStatusCommand();
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+// ===== Lifecycle Commands =====
+
+program
+    .command('shutdown')
+    .description('Stop all blocks and the server.')
+    .action(async () => {
+        try {
+            await shutdownCommand();
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+program
+    .command('restart')
+    .description('Restart: stop everything, then start server as daemon.')
+    .option('-p, --port <port>', 'Port to listen on', DEFAULT_PORT)
+    .action(async (opts: { port?: string }) => {
+        try {
+            await restartCommand(opts);
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+// Backward-compatible alias: `mblk web` = `mblk server start`
+program
+    .command('web')
+    .description('Alias for `mblk server start`.')
+    .option('-p, --port <port>', 'Port to listen on', DEFAULT_PORT)
+    .option('--new-token', 'Generate a new auth token')
+    .option('-d, --daemon', 'Run the server in the background')
+    .action(async (opts: { port?: string; newToken?: boolean; daemon?: boolean }) => {
+        try {
+            await serverStartCommand(opts);
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+program
+    .command('add [plugin]')
+    .description('Install a plugin (run without args to list available plugins).')
+    .action(async (plugin: string) => {
+        try {
+            await addCommand(plugin);
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+program
+    .command('remove <plugin>')
+    .description('Remove an installed plugin.')
+    .action(async (plugin: string) => {
+        try {
+            await removeCommand(plugin);
+        } catch (err) {
+            log.error((err as Error).message);
+            process.exit(0);
+        }
+    });
+
+program.parse();
+
+})();

package/src/cli/commands/create.ts

@@ -0,0 +1,62 @@
+import { join } from 'node:path';
+import { ensureDir, writeJson, atomicWrite, pathExists } from '../../utils/fs.js';
+import {
+    loadGlobalConfig, resolveBlockPath, isInitialized,
+} from '../../utils/config.js';
+import { BlockConfigSchema, PulseStateSchema } from '../../schemas.js';
+import { log } from '../logger.js';
+import { FILE_TEMPLATES } from '../../engine/prompts.js';
+
+
+// Templates moved to prompts.ts
+
+export async function createCommand(blockName: string): Promise<void> {
+    if (!(await isInitialized())) {
+        throw new Error('Not initialized. Run `mblk init` first.');
+    }
+
+    if (!/^[a-z0-9][a-z0-9-]{0,31}$/.test(blockName)) {
+        throw new Error('Block name must start with a letter/number and contain only lowercase letters, numbers, and hyphens (max 32 chars).');
+    }
+
+    const globalConfig = await loadGlobalConfig();
+    const blockPath = resolveBlockPath(globalConfig, blockName);
+
+    if (await pathExists(blockPath)) {
+        throw new Error(`Block "${blockName}" already exists at ${blockPath}`);
+    }
+
+    log.brand(`Creating block: ${blockName}\n`);
+
+    // Directory structure
+    await ensureDir(blockPath);
+    await ensureDir(join(blockPath, 'agents'));
+    await ensureDir(join(blockPath, 'logs'));
+
+    // Block config (inherits global defaults)
+    const blockConfig = BlockConfigSchema.parse({
+        name: blockName,
+        adapter: globalConfig.defaults.adapter,
+        memory: globalConfig.defaults.memory,
+        pulse: globalConfig.defaults.pulse,
+    });
+    await writeJson(join(blockPath, 'config.json'), blockConfig);
+    log.success('Created config.json');
+
+    // Initial pulse state
+    const pulse = PulseStateSchema.parse({});
+    await writeJson(join(blockPath, 'pulse.json'), pulse);
+    log.success('Created pulse.json');
+
+    // Core identity files
+    await atomicWrite(join(blockPath, 'memory.md'), FILE_TEMPLATES.MEMORY_MD);
+    log.success('Created memory.md');
+
+    await atomicWrite(join(blockPath, 'monitor.md'), FILE_TEMPLATES.MONITOR_MD(blockName));
+    log.success('Created monitor.md');
+
+    console.log('');
+    log.brand(`Block "${blockName}" is ready.`);
+    log.dim(`  Path: ${blockPath}`);
+    log.dim(`  Start: mblk start ${blockName}`);
+}

package/src/cli/commands/delete.ts

@@ -0,0 +1,165 @@
+import { join } from 'node:path';
+import { promises as fsp } from 'node:fs';
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { loadGlobalConfig, resolveBlocksDir, isInitialized } from '../../utils/config.js';
+import { ensureDir, pathExists } from '../../utils/fs.js';
+import { log } from '../logger.js';
+import { t } from '@memoryblock/locale';
+
+/**
+ * Find archived folders matching a block name.
+ * Supports both:
+ *   - Exact archive name: "dev-pal_2026-03-21T10-33-24-242Z"
+ *   - Block name prefix: "dev-pal" (matches all archives of that block)
+ */
+async function findArchives(archiveDir: string, query: string): Promise<string[]> {
+    // Strip _archive/ prefix if user pastes it
+    const name = query.replace(/^_archive\//, '');
+
+    try {
+        const entries = await fsp.readdir(archiveDir);
+
+        // 1. Exact match
+        if (entries.includes(name)) return [name];
+
+        // 2. Prefix match: "dev-pal" matches "dev-pal_2026-03-21T10-33-24-242Z"
+        const matches = entries
+            .filter(e => e.startsWith(`${name}_`))
+            .sort()
+            .reverse(); // newest first
+
+        return matches;
+    } catch {
+        return [];
+    }
+}
+
+/**
+ * Resolve a single archive — if multiple exist, let user pick.
+ */
+async function resolveArchive(archiveDir: string, query: string): Promise<string | null> {
+    const matches = await findArchives(archiveDir, query);
+
+    if (matches.length === 0) return null;
+    if (matches.length === 1) return matches[0];
+
+    // Multiple archives — let the user pick
+    const selection = await p.select({
+        message: `Multiple archives found for "${query}". Which one?`,
+        options: matches.map(m => {
+            // Extract the timestamp for a cleaner label
+            const tsMatch = m.match(/_(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2})/);
+            const hint = tsMatch ? tsMatch[1].replace(/-/g, ':').replace('T', ' ').slice(0, 16) : '';
+            return { value: m, label: m, hint };
+        }),
+    });
+
+    if (p.isCancel(selection)) return null;
+    return selection as string;
+}
+
+export async function deleteCommand(blockName: string, options?: { hard?: boolean }): Promise<void> {
+    if (!(await isInitialized())) {
+        throw new Error(t.general.notInitialized);
+    }
+
+    const globalConfig = await loadGlobalConfig();
+    const blocksDir = resolveBlocksDir(globalConfig);
+    const blockPath = join(blocksDir, blockName);
+
+    // Check if it's a direct block path first
+    if (await pathExists(blockPath)) {
+        if (blockName.startsWith('_archive/')) {
+            if (!options?.hard) {
+                throw new Error(t.archive.mustUseHard);
+            }
+        }
+
+        if (options?.hard) {
+            try {
+                await fsp.rm(blockPath, { recursive: true, force: true });
+                log.success(t.archive.hardDeleteSuccess(blockName));
+            } catch (err) {
+                throw new Error(`Failed to delete: ${(err as Error).message}`);
+            }
+            return;
+        }
+
+        // Soft delete — move to _archive directory
+        const archiveDir = join(blocksDir, '_archive');
+        await ensureDir(archiveDir);
+
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const archiveName = `${blockName}_${timestamp}`;
+        const archivePath = join(archiveDir, archiveName);
+
+        try {
+            await fsp.rename(blockPath, archivePath);
+            log.success(t.archive.success(blockName));
+            log.dim(`  ${t.archive.location(`_archive/${archiveName}`)}`);
+            log.dim(`  ${t.archive.restoreCmd(blockName)}`);
+            log.dim(`  ${t.archive.deleteCmd(blockName)}`);
+        } catch (err) {
+            throw new Error(`Failed to archive block: ${(err as Error).message}`);
+        }
+        return;
+    }
+
+    // Not a live block — maybe user wants to hard-delete an archive by name?
+    if (options?.hard) {
+        const archiveDir = join(blocksDir, '_archive');
+        const resolved = await resolveArchive(archiveDir, blockName);
+
+        if (!resolved) {
+            throw new Error(`Block or archive "${blockName}" not found.`);
+        }
+
+        const archivePath = join(archiveDir, resolved);
+        try {
+            await fsp.rm(archivePath, { recursive: true, force: true });
+            log.success(`"${resolved}" permanently deleted from archive.`);
+        } catch (err) {
+            throw new Error(`Failed to delete: ${(err as Error).message}`);
+        }
+        return;
+    }
+
+    throw new Error(`Block "${blockName}" not found. Run \`mblk status\` to see available blocks.`);
+}
+
+export async function restoreCommand(archiveName: string): Promise<void> {
+    if (!(await isInitialized())) {
+        throw new Error(t.general.notInitialized);
+    }
+
+    const globalConfig = await loadGlobalConfig();
+    const blocksDir = resolveBlocksDir(globalConfig);
+    const archiveDir = join(blocksDir, '_archive');
+
+    // Resolve the archive — supports block name, full name, or prefix
+    const resolved = await resolveArchive(archiveDir, archiveName);
+
+    if (!resolved) {
+        throw new Error(`No archive found for "${archiveName}". Run \`mblk status\` to check archives.`);
+    }
+
+    const archivePath = join(archiveDir, resolved);
+
+    // Extract original block name (strip timestamp suffix)
+    const match = resolved.match(/^(.*?)_\d{4}-\d{2}-\d{2}T.*/);
+    const targetName = match ? match[1] : resolved;
+    const targetPath = join(blocksDir, targetName);
+
+    if (await pathExists(targetPath)) {
+        throw new Error(`Cannot restore: A block named "${targetName}" already exists. Delete or rename it first.`);
+    }
+
+    try {
+        await fsp.rename(archivePath, targetPath);
+        log.success(`Block "${targetName}" restored successfully.`);
+        log.dim(`  Start with: ${chalk.bold(`mblk start ${targetName}`)}`);
+    } catch (err) {
+        throw new Error(`Failed to restore block: ${(err as Error).message}`);
+    }
+}