memoryblock 0.1.0-beta → 0.1.1-beta

package/src/cli/commands/create.ts

@@ -1,62 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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}`);
-    }
-}

package/src/cli/commands/init.ts

@@ -1,241 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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}.`);
-}