@ryuu-reinzz/ryuu-cli 0.4.3 → 0.5.1

package/plugins/google-drive/zip-writer.js

@@ -0,0 +1,204 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import zlib from 'node:zlib';
+import { Writable } from 'node:stream';
+import { once } from 'node:events';
+import { pipeline } from 'node:stream/promises';
+import { RyuuError } from '../../src/utils/errors.js';
+
+/**
+ * Dependency-free streaming ZIP writer.
+ *
+ * Only Node built-ins are used: each file is deflated through a stream straight
+ * into the archive, so a 1 GB project never sits in memory. Sizes and CRC32 are
+ * carried by data descriptors (general-purpose bit 3), which is what allows the
+ * writer to stream without a second pass over every entry.
+ */
+
+const SIG_LOCAL = 0x04034b50;
+const SIG_DESCRIPTOR = 0x08074b50;
+const SIG_CENTRAL = 0x02014b50;
+const SIG_EOCD = 0x06054b50;
+const MAX32 = 0xffffffff;
+
+const CRC_TABLE = (() => {
+  const table = new Int32Array(256);
+  for (let i = 0; i < 256; i += 1) {
+    let c = i;
+    for (let k = 0; k < 8; k += 1) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    table[i] = c;
+  }
+  return table;
+})();
+
+/** Running CRC32 so entries stream without buffering. */
+export function createCrc32() {
+  let crc = -1;
+  return {
+    update(chunk) {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      for (let i = 0; i < buffer.length; i += 1) crc = CRC_TABLE[(crc ^ buffer[i]) & 0xff] ^ (crc >>> 8);
+      return this;
+    },
+    digest() {
+      return (crc ^ -1) >>> 0;
+    },
+  };
+}
+
+function dosDateTime(date = new Date()) {
+  const year = Math.max(1980, date.getFullYear());
+  const time = (date.getHours() << 11) | (date.getMinutes() << 5) | Math.floor(date.getSeconds() / 2);
+  const day = ((year - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate();
+  return { time: time & 0xffff, date: day & 0xffff };
+}
+
+/** Normalise an entry name to forward slashes with no absolute or parent parts. */
+export function safeEntryName(name) {
+  const normalised = String(name).replace(/\\/g, '/').replace(/^\/+/, '');
+  const parts = normalised.split('/').filter((part) => part && part !== '.');
+  if (parts.some((part) => part === '..') || /^[A-Za-z]:/.test(normalised)) {
+    throw new RyuuError(`Nama entri arsip tidak aman: ${name}`, { code: 'ZIP_UNSAFE' });
+  }
+  return parts.join('/');
+}
+
+export class ZipWriter {
+  constructor({ file, compressionLevel = 6 } = {}) {
+    this.file = file;
+    this.level = Math.min(Math.max(Number(compressionLevel ?? 6), 0), 9);
+    this.entries = [];
+    this.offset = 0;
+    this.stream = null;
+  }
+
+  async open() {
+    await fsp.mkdir(path.dirname(this.file), { recursive: true });
+    this.stream = fs.createWriteStream(this.file, { mode: 0o600 });
+    return this;
+  }
+
+  async #write(buffer) {
+    this.offset += buffer.length;
+    if (!this.stream.write(buffer)) await once(this.stream, 'drain');
+  }
+
+  /** Stream one local file into the archive under `entryName`. */
+  async addFile(entryName, absPath, { signal = null } = {}) {
+    const name = Buffer.from(safeEntryName(entryName), 'utf8');
+    const stat = await fsp.stat(absPath);
+    const { time, date } = dosDateTime(stat.mtime);
+    const method = this.level === 0 || stat.size === 0 ? 0 : 8;
+    const headerOffset = this.offset;
+
+    const header = Buffer.alloc(30);
+    header.writeUInt32LE(SIG_LOCAL, 0);
+    header.writeUInt16LE(20, 4); // version needed
+    header.writeUInt16LE(0x0808, 6); // data descriptor + UTF-8 names
+    header.writeUInt16LE(method, 8);
+    header.writeUInt16LE(time, 10);
+    header.writeUInt16LE(date, 12);
+    header.writeUInt32LE(0, 14); // crc32 (in descriptor)
+    header.writeUInt32LE(0, 18); // compressed size (in descriptor)
+    header.writeUInt32LE(0, 22); // uncompressed size (in descriptor)
+    header.writeUInt16LE(name.length, 26);
+    header.writeUInt16LE(0, 28);
+    await this.#write(Buffer.concat([header, name]));
+
+    const crc = createCrc32();
+    let uncompressed = 0;
+    let compressed = 0;
+    const source = fs.createReadStream(absPath);
+    // CRC32 and the uncompressed size are measured before deflate; the
+    // compressed size is measured on the deflated bytes.
+    const meter = async function* (stream) {
+      for await (const chunk of stream) {
+        if (signal?.aborted) throw new RyuuError('Backup dibatalkan.', { code: 'CANCELLED' });
+        crc.update(chunk);
+        uncompressed += chunk.length;
+        yield chunk;
+      }
+    };
+    const sink = new Writable({
+      write: (chunk, _encoding, callback) => {
+        compressed += chunk.length;
+        this.#write(chunk).then(() => callback(), (error) => callback(error));
+      },
+    });
+    if (method === 8) {
+      await pipeline(source, meter, zlib.createDeflateRaw({ level: this.level }), sink);
+    } else {
+      await pipeline(source, meter, sink);
+    }
+    if (compressed > MAX32 || uncompressed > MAX32) {
+      throw new RyuuError('Arsip melebihi 4 GB: ZIP64 tidak didukung. Pecah backup menjadi beberapa bagian.', {
+        code: 'ZIP_TOO_LARGE',
+      });
+    }
+
+    const descriptor = Buffer.alloc(16);
+    descriptor.writeUInt32LE(SIG_DESCRIPTOR, 0);
+    descriptor.writeUInt32LE(crc.digest(), 4);
+    descriptor.writeUInt32LE(compressed, 8);
+    descriptor.writeUInt32LE(uncompressed, 12);
+    await this.#write(descriptor);
+
+    this.entries.push({
+      name: name.toString('utf8'),
+      method,
+      crc32: crc.digest(),
+      compressedSize: compressed,
+      uncompressedSize: uncompressed,
+      offset: headerOffset,
+      time,
+      date,
+    });
+    return { name: name.toString('utf8'), size: uncompressed, storedSize: compressed };
+  }
+
+  async close() {
+    const centralStart = this.offset;
+    for (const entry of this.entries) {
+      const name = Buffer.from(entry.name, 'utf8');
+      const record = Buffer.alloc(46);
+      record.writeUInt32LE(SIG_CENTRAL, 0);
+      record.writeUInt16LE(20, 4); // version made by
+      record.writeUInt16LE(20, 6); // version needed
+      record.writeUInt16LE(0x0808, 8);
+      record.writeUInt16LE(entry.method, 10);
+      record.writeUInt16LE(entry.time, 12);
+      record.writeUInt16LE(entry.date, 14);
+      record.writeUInt32LE(entry.crc32, 16);
+      record.writeUInt32LE(entry.compressedSize, 20);
+      record.writeUInt32LE(entry.uncompressedSize, 24);
+      record.writeUInt16LE(name.length, 28);
+      record.writeUInt16LE(0, 30); // extra
+      record.writeUInt16LE(0, 32); // comment
+      record.writeUInt16LE(0, 34); // disk
+      record.writeUInt16LE(0, 36); // internal attrs
+      record.writeUInt32LE(0, 38); // external attrs
+      record.writeUInt32LE(entry.offset, 42);
+      await this.#write(Buffer.concat([record, name]));
+    }
+    const centralSize = this.offset - centralStart;
+    if (this.offset > MAX32) {
+      throw new RyuuError('Arsip melewati 4 GB: ZIP64 tidak didukung.', { code: 'ZIP_TOO_LARGE' });
+    }
+    const eocd = Buffer.alloc(22);
+    eocd.writeUInt32LE(SIG_EOCD, 0);
+    eocd.writeUInt16LE(0, 4);
+    eocd.writeUInt16LE(0, 6);
+    eocd.writeUInt16LE(this.entries.length, 8);
+    eocd.writeUInt16LE(this.entries.length, 10);
+    eocd.writeUInt32LE(centralSize, 12);
+    eocd.writeUInt32LE(centralStart, 16);
+    eocd.writeUInt16LE(0, 20);
+    await this.#write(eocd);
+    this.stream.end();
+    await once(this.stream, 'finish');
+    return { file: this.file, bytes: this.offset, fileCount: this.entries.length };
+  }
+}
+
+export { SIG_LOCAL, SIG_CENTRAL, SIG_EOCD, MAX32 };

package/plugins/index.js

@@ -0,0 +1,58 @@
+import { createGoogleDrivePlugin, googleDrivePluginDescriptor } from './google-drive/index.js';
+import { createGitHubPlugin, githubPluginDescriptor } from './github/index.js';
+
+/**
+ * Plugin host for Ryuu CLI.
+ *
+ * Plugins live outside `src/` on purpose: they are optional integrations that
+ * are wired into the existing tool registry and command parser instead of
+ * becoming part of the core service layer. A plugin never registers its tools
+ * directly — the host does, and only when the integration is enabled and
+ * authenticated.
+ */
+
+const FACTORIES = [
+  { descriptor: googleDrivePluginDescriptor, create: (options) => createGoogleDrivePlugin(options) },
+  { descriptor: githubPluginDescriptor, create: (options) => createGitHubPlugin(options) },
+];
+
+/** Instantiate every known plugin. Failures are reported, not fatal. */
+export function loadPlugins({ logger = null, workspace = null, config = null } = {}) {
+  const plugins = [];
+  for (const entry of FACTORIES) {
+    try {
+      plugins.push(entry.create({ logger, workspace, config }));
+    } catch (error) {
+      logger?.warn?.(`plugin ${entry.descriptor.name} failed to load`, { error: error.message });
+    }
+  }
+  return plugins;
+}
+
+/**
+ * Attach the plugin tools to a registry when its lifecycle state allows it.
+ *
+ * Returns the number of tools registered. Registration is idempotent per
+ * process: a second call with the same state reuses the registry's plugin
+ * bookkeeping instead of throwing a collision.
+ */
+export async function syncPluginTools(plugin, registry) {
+  if (!plugin || !registry) return 0;
+  const ready = (await plugin.isEnabled()) && (await plugin.isAuthenticated());
+  if (!ready) return 0;
+  if (registry.plugins?.has?.(plugin.name)) return plugin.tools.length;
+  registry.registerPlugin({ name: plugin.name, version: plugin.version, tools: plugin.tools });
+  return plugin.tools.length;
+}
+
+/** Remove one plugin's tools from the registry (used by /drive disable). */
+export function unregisterPluginTools(plugin, registry) {
+  if (!plugin || !registry?.plugins?.has?.(plugin.name)) return 0;
+  const entry = registry.plugins.get(plugin.name);
+  const names = entry?.toolNames || [];
+  for (const name of names) registry.tools.delete(name);
+  registry.plugins.delete(plugin.name);
+  return names.length;
+}
+
+export { googleDrivePluginDescriptor, githubPluginDescriptor };

package/src/agent/agent.js

@@ -1018,6 +1018,11 @@ export class Agent {
         for (const call of calls) {
           checkAbort();
           callIndex += 1;
+          // The plugin a tool belongs to, if any: the CLI paints plugin tools in
+          // their own colour. Resolved once here so every event of this call
+          // carries the same flag.
+          const callPlugin = typeof this.registry?.pluginFor === 'function' ? this.registry.pluginFor(call.name) : null;
+          const pluginName = callPlugin ? callPlugin.name : null;
           const duplicateKey = `${call.name}\u0000${call.argumentsText}`;
           if (seenInStep.has(duplicateKey)) {
             this.#toolReply(messages, call, { ok: false, error: { code: 'DUPLICATE_CALL', message: 'Duplicate tool call in the same step was ignored.' } }, session);
@@ -1100,6 +1105,7 @@ export class Agent {
                 ok: true,
                 durationMs: 0,
                 cached: true,
+                plugin: pluginName,
                 summary: `${args.path} already read and unchanged — not read again`,
               });
               this.#toolReply(
@@ -1147,7 +1153,7 @@ export class Agent {
               ok: false,
               error: { code: previewError.code || 'PREVIEW_FAILED', message: previewError.message },
             }, session);
-            this.#emit('toolEnd', { name: call.name, ok: false, durationMs: 0, summary: previewError.message });
+            this.#emit('toolEnd', { name: call.name, ok: false, durationMs: 0, plugin: pluginName, summary: previewError.message });
             continue;
           }
 
@@ -1177,12 +1183,15 @@ export class Agent {
             }
           }
 
+          // Plugin tools are flagged so the CLI can paint them differently from
+          // built-in tooling. It is metadata only: execution is unchanged.
           this.#emit('toolStart', {
             name: call.name,
             args,
             risk: tool.risk,
             index: callIndex,
             total: calls.length,
+            plugin: pluginName,
             detail: describeToolTarget(call.name, args),
           });
           const toolStarted = Date.now();
@@ -1210,6 +1219,7 @@ export class Agent {
               name: call.name,
               ok: true,
               durationMs,
+              plugin: pluginName,
               summary: summarizeToolResult(call.name, result),
             });
             // The command the user approved and what it actually printed: the
@@ -1235,7 +1245,7 @@ export class Agent {
             const durationMs = Date.now() - toolStarted;
             const message = toolError?.message || String(toolError);
             failureCounts.set(callKey, previousFailures + 1);
-            this.#emit('toolEnd', { name: call.name, ok: false, durationMs, summary: message });
+            this.#emit('toolEnd', { name: call.name, ok: false, durationMs, plugin: pluginName, summary: message });
             session.issues.push(`${call.name}: ${message.slice(0, 300)}`);
             this.#toolReply(messages, call, {
               ok: false,

package/src/cli/app.js

@@ -7,6 +7,7 @@ import { UndoManager } from '../services/undo.js';
 import { createLogger } from '../services/logger.js';
 import { buildProjectSummary } from '../tools/project.js';
 import { buildToolRegistry } from '../tools/index.js';
+import { loadPlugins, syncPluginTools } from '../../plugins/index.js';
 import { createActiveProvider, selectionFor } from '../providers/index.js';
 import { buildProviders, parseExtraProviders, PROVIDER_REQUEST_FIELDS } from '../providers/catalog.js';
 import { buildRawConfig } from '../config/load.js';
@@ -110,6 +111,16 @@ export async function createApp({
   const provider = injectedProvider || createActiveProvider(config, { logger });
   if (!provider.config) provider.config = config;
   provider.processes = processes;
+  // Optional integrations live in plugins/ and attach their tools to the same
+  // registry. A plugin whose state forbids it (disabled / not logged in) leaves
+  // the registry untouched, so the model is never offered a tool that cannot run.
+  const plugins = loadPlugins({ logger, workspace, config });
+  for (const plugin of plugins) {
+    plugin.registry = registry;
+    await syncPluginTools(plugin, registry).catch((error) => {
+      logger.warn('plugin tools not registered', { plugin: plugin.name, error: error.message });
+    });
+  }
   const projectCache = new ProjectSummaryCache({ file: path.join(config.cacheDir, 'project-summary.json') });
 
   let prompts = null;
@@ -330,6 +341,9 @@ export async function createApp({
     provider,
     approvals,
     webSearch: registry.webSearchManager || injectedWebManager || null,
+    plugins,
+    getPlugin: (name) => plugins.find((plugin) => plugin.name === name) || null,
+    syncPluginTools: (plugin) => syncPluginTools(plugin, registry),
     interactive,
     getAgent: () => agent,
     getLastSummary: () => lastSummary,
@@ -343,6 +357,7 @@ export async function createApp({
       return true;
     },
     confirmLocal,
+    showCode: typeof renderer.showCode === 'function' ? (block) => renderer.showCode(block) : null,
   };
 
   const commands = createCommands(state);
@@ -451,6 +466,7 @@ export async function createApp({
     undo,
     approvals,
     webSearch: registry.webSearchManager || injectedWebManager || null,
+    plugins,
     renderer,
     logger,
     commands,

package/src/cli/commands.js

@@ -29,6 +29,8 @@ import { formatDoctor, runDoctor } from '../services/doctor.js';
 import { createUnifiedDiff, diffStats } from '../services/diff.js';
 import { PROVIDER_INFO } from '../services/websearch/providers.js';
 import { runUserShell } from '../services/ushell.js';
+import { createDriveCommand } from '../../plugins/google-drive/command.js';
+import { createGitHubCommand } from '../../plugins/github/command.js';
 import { RyuuError } from '../utils/errors.js';
 
 export function parseCommandLine(line) {
@@ -1116,6 +1118,48 @@ export function createCommands(state) {
     );
   });
 
+  // Optional plugins (plugins/): each contributes one namespaced command so the
+  // core parser stays untouched. `/drive` is only defined when the plugin loaded.
+  for (const plugin of state.plugins || []) {
+    if (plugin.name === 'github') {
+      const handler = createGitHubCommand({
+        plugin,
+        registry,
+        confirm: (question) => state.confirmLocal(question),
+        openBrowser: true,
+        showCode: state.showCode || null,
+      });
+      define(
+        'github',
+        'GitHub integration: login | logout | status | account | test | enable | disable | config',
+        '/github [login [--device]|logout|status|account|test|enable|disable|config]',
+        async (args = '') => handler(args, print),
+        [
+          '  Autentikasi memakai GitHub App lewat backend Ryuu, bukan token di CLI.',
+          '  login          membuka browser lalu menunggu persetujuan',
+          '  login --device device flow untuk mesin headless',
+          '  enable         mendaftarkan tool GitHub untuk AI Agent',
+          '  disable        melepas tool tanpa menghapus akun/token',
+        ].join('\n'),
+      );
+      continue;
+    }
+    if (plugin.name !== 'google-drive') continue;
+    const handler = createDriveCommand({
+      plugin,
+      registry,
+      confirm: (question) => state.confirmLocal(question),
+      openBrowser: true,
+      showCode: state.showCode || null,
+    });
+    define(
+      plugin.command || plugin.name,
+      `Google Drive integration: login | logout | account | enable | disable | status | config | test`,
+      '/drive [login|logout|account|enable|disable|status|config|test]',
+      async (args = '') => handler(args, print),
+    );
+  }
+
   define('config', 'Show effective configuration (secrets redacted)', '/config', async () => {
     const described = describeConfig(config);
     const width = Math.max(...Object.keys(described).map((key) => key.length));

package/src/cli/markdown.js

@@ -356,14 +356,18 @@ function renderCodeBlock(lines, lang, { width, c, color, accent = null, copy = t
   // narrow to read as a button instead of eating the whole rule.
   const chip = copy ? ' ⧉ copy ' : '';
   const showChip = Boolean(chip) && width - 2 - visibleLength(label) - visibleLength(chip) >= 4;
-  const rule = Math.max(1, width - 2 - visibleLength(label) - (showChip ? visibleLength(chip) : 0));
+  // The top rule must end in a corner and keep the same visible width as the
+  // bottom one, or the frame looks ragged in a fixed-width terminal.
+  const rule = Math.max(1, width - 3 - visibleLength(label) - (showChip ? visibleLength(chip) : 0));
   const paint = toAccent(accent, c);
   const chipPaint = showChip ? c.bgHex('#1e293b')(c.hex(SLATE)(chip)) : '';
   const output = [
-    `${paint('╭─')}${c.bold(label)}${c.dim('─'.repeat(rule))}${chipPaint}`,
+    `${paint('╭─')}${c.bold(label)}${c.dim('─'.repeat(rule))}${chipPaint}${paint('╮')}`,
   ];
   const body = lines.length > 0 ? lines : [''];
-  const codeWidth = Math.max(8, width - 2);
+  // Every body row is padded and closed with a right edge, so the frame is a
+  // real box instead of three ragged vertical bars.
+  const codeWidth = Math.max(8, width - 3);
   for (const line of body) {
     const chunks = [];
     for (let index = 0; index < line.length; index += codeWidth) {
@@ -371,10 +375,11 @@ function renderCodeBlock(lines, lang, { width, c, color, accent = null, copy = t
     }
     if (chunks.length === 0) chunks.push('');
     for (const chunk of chunks) {
-      output.push(`${paint('│')} ${highlightCode(chunk, lang, c, color)}`);
+      const pad = ' '.repeat(Math.max(0, width - 3 - visibleLength(chunk)));
+      output.push(`${paint('│')} ${highlightCode(chunk, lang, c, color)}${pad}${paint('│')}`);
     }
   }
-  output.push(paint(`╰${'─'.repeat(Math.max(1, width - 2))}`));
+  output.push(paint(`╰${'─'.repeat(Math.max(1, width - 2))}╯`));
   return output;
 }
 

package/src/cli/renderer.js

@@ -311,6 +311,15 @@ export class Renderer {
     return this.c.hex(PALETTE[name] || PALETTE.white)(String(text));
   }
 
+  /**
+   * Tool name colour: built-ins stay flat blue, plugin tools are sky blue and
+   * bold so an installed integration is visible at a glance.
+   */
+  #toolName(name, plugin) {
+    const text = String(name ?? '');
+    return plugin ? this.c.bold(this.c.hex(PALETTE.sky)(text)) : this.c.hex(PALETTE.blue)(text);
+  }
+
   #visibleLength(text) {
     return displayWidth(text, { ansi: true });
   }
@@ -510,6 +519,29 @@ export class Renderer {
     for (const line of String(text).split('\n')) this.#write(line);
   }
 
+  /**
+   * A framed monospace block with a `⧉ copy` chip — used by commands that must
+   * show something copyable, such as a login URL. It reuses the Markdown code
+   * block path, so the whole box is the clipboard hit target.
+   */
+  showCode({ label = '', text = '' } = {}) {
+    const body = String(text ?? '');
+    if (!body) return;
+    // A piped or plain run has no frame and no click target: print the value.
+    if (this.plain) {
+      this.lines(body);
+      return;
+    }
+    if (/(^|\n)\s*```/.test(body)) {
+      this.lines(body);
+      return;
+    }
+    const lang = String(label ?? '')
+      .replace(/[^A-Za-z0-9_+#.-]+/g, '-')
+      .replace(/^-+|-+$/g, '');
+    this.#markdown('```' + `${lang}\n${body}\n` + '```');
+  }
+
   banner({ version, model, provider, workspace, node, approvalPolicy, logFile }) {
     const c = this.c;
     if (this.plain) {
@@ -1344,7 +1376,7 @@ export class Renderer {
     }
   }
 
-  toolStart({ name, args, index = 0, total = 0, detail = '' }) {
+  toolStart({ name, args, index = 0, total = 0, detail = '', plugin = null }) {
     if (this.reasoning.active) this.reasoningEnd({});
     if (this.answer.active) this.answerEnd();
     // Running a tool is exactly the `working` phase the user asked for.
@@ -1365,11 +1397,11 @@ export class Renderer {
       return;
     }
     this.#write(
-      `  ${this.c.dim('│')} ${this.#paint('violet', '◆')} ${this.c.bold(this.c.hex(PALETTE.blue)(name))} ${this.c.dim(this.#fit(argsPreview, this.#innerWidth() - 20))}`,
+      `  ${this.c.dim('│')} ${this.#paint('violet', '◆')} ${this.#toolName(name, plugin)} ${this.c.dim(this.#fit(argsPreview, this.#innerWidth() - 20))}`,
     );
   }
 
-  toolEnd({ name, ok, durationMs, summary, cached = false }) {
+  toolEnd({ name, ok, durationMs, summary, cached = false, plugin = null }) {
     this.status.tool = '';
     this.status.toolIndex = 0;
     this.status.toolTotal = 0;
@@ -1384,7 +1416,7 @@ export class Renderer {
         this.#write(this.c.dim(`  [cached] ${name} · ${detail}`));
         return;
       }
-      this.#write(`  ${this.c.dim('│')} ${this.#paint('cyan', '↺')} ${this.c.hex(PALETTE.blue)(name)} ${this.c.dim(`· ${detail}`)}`);
+      this.#write(`  ${this.c.dim('│')} ${this.#paint('cyan', '↺')} ${this.#toolName(name, plugin)} ${this.c.dim(`· ${detail}`)}`);
       return;
     }
     if (this.plain) {
@@ -1396,8 +1428,9 @@ export class Renderer {
     }
     const symbol = ok ? this.#paint('green', '✓') : this.#paint('red', '✕');
     const stats = [duration, detail].filter(Boolean).join(' · ');
+    const label = ok ? this.#toolName(name, plugin) : this.c.hex(PALETTE.red)(String(name ?? ''));
     this.#write(
-      `  ${this.c.dim('│')} ${symbol} ${this.c.hex(PALETTE.blue)(name)}${stats ? ` ${this.c.dim(`· ${stats}`)}` : ''}`,
+      `  ${this.c.dim('│')} ${symbol} ${label}${stats ? ` ${this.c.dim(`· ${stats}`)}` : ''}`,
     );
   }