chainlesschain 0.37.8 → 0.37.10

package/src/commands/p2p.js

@@ -0,0 +1,274 @@
+/**
+ * P2P commands
+ * chainlesschain p2p peers|send|inbox|pair|unpair|devices|status
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  registerPeer,
+  getAllPeers,
+  getOnlinePeers,
+  sendMessage,
+  getInbox,
+  markMessageRead,
+  getMessageCount,
+  pairDevice,
+  confirmPairing,
+  getPairedDevices,
+  unpairDevice,
+  generatePeerId,
+  P2PBridge,
+} from "../lib/p2p-manager.js";
+
+export function registerP2pCommand(program) {
+  const p2p = program
+    .command("p2p")
+    .description("Peer-to-peer messaging and device management");
+
+  // p2p status
+  p2p
+    .command("status", { isDefault: true })
+    .description("Show P2P connection status")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const peers = getAllPeers(db);
+        const devices = getPairedDevices(db);
+        const bridge = new P2PBridge();
+        const bridgeAvailable = await bridge.checkBridge();
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              { peers: peers.length, devices: devices.length, bridgeAvailable },
+              null,
+              2,
+            ),
+          );
+        } else {
+          logger.log(chalk.bold("P2P Status:\n"));
+          logger.log(`  ${chalk.bold("Peers:")}    ${peers.length}`);
+          logger.log(`  ${chalk.bold("Devices:")}  ${devices.length}`);
+          logger.log(
+            `  ${chalk.bold("Bridge:")}   ${bridgeAvailable ? chalk.green("connected") : chalk.gray("not available")}`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // p2p peers
+  p2p
+    .command("peers")
+    .description("List known peers")
+    .option("--online", "Show only online peers")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const peers = options.online ? getOnlinePeers(db) : getAllPeers(db);
+
+        if (options.json) {
+          console.log(JSON.stringify(peers, null, 2));
+        } else if (peers.length === 0) {
+          logger.info("No peers found");
+        } else {
+          logger.log(chalk.bold(`Peers (${peers.length}):\n`));
+          for (const p of peers) {
+            const status =
+              p.status === "online"
+                ? chalk.green("online")
+                : chalk.gray(p.status);
+            const name = p.display_name ? ` (${p.display_name})` : "";
+            logger.log(`  ${chalk.cyan(p.peer_id)}${name} [${status}]`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // p2p send
+  p2p
+    .command("send")
+    .description("Send a message to a peer")
+    .argument("<peer>", "Peer ID to send to")
+    .argument("<message>", "Message content")
+    .action(async (peer, message) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const myPeerId = generatePeerId();
+        registerPeer(db, myPeerId, "CLI User", null, null, "cli");
+        const msg = sendMessage(db, myPeerId, peer, message);
+        logger.success(`Message sent (${msg.id})`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // p2p inbox
+  p2p
+    .command("inbox")
+    .description("Show received messages")
+    .option("--unread", "Show only unread messages")
+    .option("--peer-id <id>", "Your peer ID")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const peerId = options.peerId || "cli-user";
+        const messages = getInbox(db, peerId, { unreadOnly: options.unread });
+
+        if (options.json) {
+          console.log(JSON.stringify(messages, null, 2));
+        } else if (messages.length === 0) {
+          logger.info("No messages");
+        } else {
+          logger.log(chalk.bold(`Inbox (${messages.length}):\n`));
+          for (const m of messages) {
+            const read = m.read ? chalk.gray("[read]") : chalk.yellow("[new]");
+            logger.log(`  ${read} ${chalk.cyan(m.from_peer)}: ${m.content}`);
+            logger.log(`    ${chalk.gray(m.created_at)}`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // p2p pair
+  p2p
+    .command("pair")
+    .description("Pair a new device")
+    .argument("<device-name>", "Device name")
+    .option("--type <type>", "Device type (desktop/mobile/tablet)", "unknown")
+    .action(async (deviceName, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const device = pairDevice(db, deviceName, options.type);
+
+        logger.success("Device pairing initiated");
+        logger.log(
+          `  ${chalk.bold("Device ID:")}    ${chalk.cyan(device.deviceId)}`,
+        );
+        logger.log(
+          `  ${chalk.bold("Pairing Code:")} ${chalk.yellow(device.pairingCode)}`,
+        );
+        logger.log(
+          `\n  Enter this code on the other device to complete pairing.`,
+        );
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // p2p devices
+  p2p
+    .command("devices")
+    .description("List paired devices")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const devices = getPairedDevices(db);
+
+        if (options.json) {
+          console.log(JSON.stringify(devices, null, 2));
+        } else if (devices.length === 0) {
+          logger.info("No paired devices");
+        } else {
+          logger.log(chalk.bold(`Paired Devices (${devices.length}):\n`));
+          for (const d of devices) {
+            const status =
+              d.status === "active"
+                ? chalk.green("active")
+                : chalk.gray(d.status);
+            logger.log(
+              `  ${chalk.cyan(d.device_id)} - ${d.device_name} [${status}]`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // p2p unpair
+  p2p
+    .command("unpair")
+    .description("Unpair a device")
+    .argument("<device-id>", "Device ID to unpair")
+    .action(async (deviceId) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const ok = unpairDevice(db, deviceId);
+
+        if (ok) {
+          logger.success("Device unpaired");
+        } else {
+          logger.error(`Device not found: ${deviceId}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/plugin.js

@@ -0,0 +1,398 @@
+/**
+ * Plugin management commands
+ * chainlesschain plugin list|install|remove|enable|disable|update|info|search|registry|summary
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  installPlugin,
+  getPlugin,
+  listPlugins,
+  enablePlugin,
+  disablePlugin,
+  removePlugin,
+  updatePlugin,
+  getPluginSettings,
+  setPluginSetting,
+  searchRegistry,
+  listRegistry,
+  registerInMarketplace,
+  getPluginSummary,
+} from "../lib/plugin-manager.js";
+
+export function registerPluginCommand(program) {
+  const plugin = program
+    .command("plugin")
+    .description("Plugin and marketplace management");
+
+  // plugin list
+  plugin
+    .command("list", { isDefault: true })
+    .description("List installed plugins")
+    .option("--enabled", "Show only enabled plugins")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const plugins = listPlugins(db, { enabledOnly: options.enabled });
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              plugins.map((p) => ({
+                name: p.name,
+                version: p.version,
+                enabled: p.enabled === 1,
+                status: p.status,
+              })),
+              null,
+              2,
+            ),
+          );
+        } else if (plugins.length === 0) {
+          logger.info(
+            'No plugins installed. Install one with "chainlesschain plugin install <name>"',
+          );
+        } else {
+          logger.log(chalk.bold(`Plugins (${plugins.length}):\n`));
+          for (const p of plugins) {
+            const status = p.enabled
+              ? chalk.green("enabled")
+              : chalk.gray("disabled");
+            logger.log(`  ${chalk.cyan(p.name)} v${p.version} [${status}]`);
+            if (p.description) logger.log(`    ${chalk.gray(p.description)}`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // plugin install
+  plugin
+    .command("install")
+    .description("Install a plugin")
+    .argument("<name>", "Plugin name")
+    .option("--version <version>", "Plugin version", "1.0.0")
+    .option("--description <desc>", "Plugin description")
+    .option("--author <author>", "Plugin author")
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const result = installPlugin(db, {
+          name,
+          version: options.version,
+          description: options.description,
+          author: options.author,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.success(`Plugin installed: ${result.name} v${result.version}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // plugin remove
+  plugin
+    .command("remove")
+    .description("Remove a plugin")
+    .argument("<name>", "Plugin name")
+    .option("--force", "Skip confirmation")
+    .action(async (name, options) => {
+      try {
+        if (!options.force) {
+          const { confirm } = await import("@inquirer/prompts");
+          const ok = await confirm({
+            message: `Remove plugin "${name}"?`,
+          });
+          if (!ok) {
+            logger.info("Cancelled");
+            return;
+          }
+        }
+
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const ok = removePlugin(db, name);
+
+        if (ok) {
+          logger.success(`Plugin removed: ${name}`);
+        } else {
+          logger.error(`Plugin not found: ${name}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // plugin enable
+  plugin
+    .command("enable")
+    .description("Enable a plugin")
+    .argument("<name>", "Plugin name")
+    .action(async (name) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const ok = enablePlugin(db, name);
+
+        if (ok) {
+          logger.success(`Plugin enabled: ${name}`);
+        } else {
+          logger.error(`Plugin not found: ${name}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // plugin disable
+  plugin
+    .command("disable")
+    .description("Disable a plugin")
+    .argument("<name>", "Plugin name")
+    .action(async (name) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const ok = disablePlugin(db, name);
+
+        if (ok) {
+          logger.success(`Plugin disabled: ${name}`);
+        } else {
+          logger.error(`Plugin not found: ${name}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // plugin update
+  plugin
+    .command("update")
+    .description("Update a plugin version")
+    .argument("<name>", "Plugin name")
+    .argument("<version>", "New version")
+    .action(async (name, version) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const ok = updatePlugin(db, name, version);
+
+        if (ok) {
+          logger.success(`Plugin updated: ${name} → v${version}`);
+        } else {
+          logger.error(`Plugin not found: ${name}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // plugin info
+  plugin
+    .command("info")
+    .description("Show plugin details")
+    .argument("<name>", "Plugin name")
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const p = getPlugin(db, name);
+
+        if (!p) {
+          logger.error(`Plugin not found: ${name}`);
+          process.exit(1);
+        }
+
+        const settings = getPluginSettings(db, name);
+
+        if (options.json) {
+          console.log(JSON.stringify({ ...p, settings }, null, 2));
+        } else {
+          logger.log(chalk.bold("Plugin Info:\n"));
+          logger.log(`  ${chalk.bold("Name:")}        ${chalk.cyan(p.name)}`);
+          logger.log(`  ${chalk.bold("Version:")}     ${p.version}`);
+          logger.log(
+            `  ${chalk.bold("Description:")} ${p.description || chalk.gray("(none)")}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Author:")}      ${p.author || chalk.gray("(unknown)")}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Enabled:")}     ${p.enabled ? chalk.green("yes") : chalk.red("no")}`,
+          );
+          logger.log(`  ${chalk.bold("Installed:")}   ${p.installed_at}`);
+
+          if (Object.keys(settings).length > 0) {
+            logger.log(`\n  ${chalk.bold("Settings:")}`);
+            for (const [k, v] of Object.entries(settings)) {
+              logger.log(`    ${k}: ${v}`);
+            }
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // plugin search
+  plugin
+    .command("search")
+    .description("Search plugin registry")
+    .argument("<query>", "Search query")
+    .option("--json", "Output as JSON")
+    .action(async (query, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const results = searchRegistry(db, query);
+
+        if (options.json) {
+          console.log(JSON.stringify(results, null, 2));
+        } else if (results.length === 0) {
+          logger.info(`No plugins found for "${query}"`);
+        } else {
+          logger.log(chalk.bold(`Registry Results (${results.length}):\n`));
+          for (const r of results) {
+            logger.log(`  ${chalk.cyan(r.name)} v${r.latest_version}`);
+            if (r.description) logger.log(`    ${chalk.gray(r.description)}`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // plugin registry
+  plugin
+    .command("registry")
+    .description("List all plugins in registry")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const registry = listRegistry(db);
+
+        if (options.json) {
+          console.log(JSON.stringify(registry, null, 2));
+        } else if (registry.length === 0) {
+          logger.info("Registry is empty");
+        } else {
+          logger.log(chalk.bold(`Plugin Registry (${registry.length}):\n`));
+          for (const r of registry) {
+            logger.log(
+              `  ${chalk.cyan(r.name)} v${r.latest_version} - ${r.description || ""}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // plugin summary
+  plugin
+    .command("summary")
+    .description("Show plugin summary statistics")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const summary = getPluginSummary(db);
+
+        if (options.json) {
+          console.log(JSON.stringify(summary, null, 2));
+        } else {
+          logger.log(chalk.bold("Plugin Summary:\n"));
+          logger.log(`  ${chalk.bold("Installed:")} ${summary.installed}`);
+          logger.log(`  ${chalk.bold("Enabled:")}   ${summary.enabled}`);
+          logger.log(`  ${chalk.bold("Registry:")}  ${summary.registryCount}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}