@guildai/cli 0.5.9 → 0.5.11

package/dist/commands/trigger/update.js

@@ -20,6 +20,7 @@ export function createTriggerUpdateCommand() {
         .option('--time <time>', 'Time of day in HH:MM format (for time triggers)')
         .option('--days-of-week <days>', 'Days of week, comma-separated (for time triggers)')
         .option('--days-of-month <days>', 'Days of month, comma-separated (for time triggers)')
+        .option('--minutes-of-hour <minutes>', 'Minutes of hour, comma-separated (0-59, for HOURLY triggers)')
         .option('--input <json>', 'Agent input as JSON object (for time triggers)')
         .action(async (triggerId, options) => {
         const output = createOutputWriter();
@@ -66,6 +67,9 @@ export function createTriggerUpdateCommand() {
             if (options.daysOfMonth !== undefined) {
                 body.days_of_month = options.daysOfMonth;
             }
+            if (options.minutesOfHour !== undefined) {
+                body.minutes_of_hour = options.minutesOfHour;
+            }
             if (options.input !== undefined) {
                 try {
                     body.agent_input = JSON.parse(options.input);

package/dist/index.js

@@ -60,6 +60,16 @@ import { createSessionEventsCommand } from './commands/session/events.js';
 import { createSessionTasksCommand } from './commands/session/tasks.js';
 import { createSessionCreateCommand } from './commands/session/create.js';
 import { createSessionSendCommand } from './commands/session/send.js';
+import { createContainerGetCommand } from './commands/container/get.js';
+import { createContainerListCommand } from './commands/container/list.js';
+import { createContainerEventsCommand } from './commands/container/events.js';
+import { createContainerExecCommand } from './commands/container/exec.js';
+import { createContainerDestroyCommand } from './commands/container/destroy.js';
+import { createContainerImageListCommand } from './commands/container-image/list.js';
+import { createContainerImageGetCommand } from './commands/container-image/get.js';
+import { createContainerImageCreateCommand } from './commands/container-image/create.js';
+import { createJobGetCommand } from './commands/job/get.js';
+import { createJobStepGetCommand } from './commands/job/step-get.js';
 import { createConfigListCommand } from './commands/config/list.js';
 import { createConfigGetCommand } from './commands/config/get.js';
 import { createConfigSetCommand } from './commands/config/set.js';
@@ -208,6 +218,20 @@ triggerCmd.addCommand(createTriggerUpdateCommand());
 triggerCmd.addCommand(createTriggerActivateCommand());
 triggerCmd.addCommand(createTriggerDeactivateCommand());
 triggerCmd.addCommand(createTriggerSessionsCommand());
+// Container command group
+const containerCmd = program.command('container').description('Container management');
+containerCmd.addCommand(createContainerListCommand());
+containerCmd.addCommand(createContainerGetCommand());
+containerCmd.addCommand(createContainerEventsCommand());
+containerCmd.addCommand(createContainerExecCommand());
+containerCmd.addCommand(createContainerDestroyCommand());
+// Container image command group
+const containerImageCmd = program
+    .command('container-image')
+    .description('Container image management');
+containerImageCmd.addCommand(createContainerImageCreateCommand());
+containerImageCmd.addCommand(createContainerImageListCommand());
+containerImageCmd.addCommand(createContainerImageGetCommand());
 // Session command group
 const sessionCmd = program.command('session').description('Session management');
 sessionCmd.addCommand(createSessionListCommand());
@@ -216,6 +240,10 @@ sessionCmd.addCommand(createSessionEventsCommand());
 sessionCmd.addCommand(createSessionTasksCommand());
 sessionCmd.addCommand(createSessionCreateCommand());
 sessionCmd.addCommand(createSessionSendCommand());
+// Job command group
+const jobCmd = program.command('job').description('Job management');
+jobCmd.addCommand(createJobGetCommand());
+jobCmd.addCommand(createJobStepGetCommand());
 // Config command group
 const configCmd = program
     .command('config')

package/dist/lib/api-types.d.ts

@@ -315,6 +315,141 @@ export interface Organization {
     viewer_role: 'ADMIN' | 'MEMBER' | null;
 }
 export type OrganizationListResponse = PaginatedResponse<Organization>;
+/**
+ * Session entity from API responses.
+ * Used by: session list, container list (as owner)
+ */
+export interface Session {
+    id: string;
+    session_type: 'chat' | 'agent_test' | 'time' | 'webhook';
+    name?: string;
+    workspace?: {
+        id: string;
+        name: string;
+    };
+    created_at: string;
+    updated_at: string;
+}
+export type ContainerStatus = 'STARTING' | 'RUNNING' | 'ERRORED' | 'DESTROYED';
+/**
+ * Container image entity from the API.
+ */
+export interface ContainerImage {
+    id: string;
+    name: string;
+    image_name: string;
+    tag: string;
+    is_public: boolean;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * The actor that created the container (user or task agent).
+ */
+export interface ContainerActor {
+    id: string;
+    entity_type: string;
+    name?: string;
+    full_name?: string;
+}
+/**
+ * Container entity from the API.
+ * Used by: container list
+ */
+export interface Container {
+    id: string;
+    status: ContainerStatus;
+    owner: Session;
+    created_by: ContainerActor;
+    image: ContainerImage;
+    created_at: string;
+    updated_at: string;
+}
+export type ContainerListResponse = PaginatedResponse<Container>;
+/**
+ * Container image as returned in list responses.
+ */
+export interface ContainerImageListItem {
+    id: string;
+    name: string;
+    image_name: string;
+    tag: string;
+    is_public: boolean;
+    created_at: string;
+    updated_at: string;
+}
+export type ContainerImageListResponse = PaginatedResponse<ContainerImageListItem>;
+export type ContainerEventStatus = 'PENDING' | 'ERROR' | 'SUCCESS';
+/**
+ * Base fields shared by all container events.
+ */
+export interface ContainerEventBase {
+    id: string;
+    entity_type: string;
+    actor: ContainerActor;
+    status: ContainerEventStatus;
+    completed_at: string | null;
+    error: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface ContainerEventCreate extends ContainerEventBase {
+    entity_type: 'EntContainerEventCreate';
+    is_local: boolean;
+}
+export interface ContainerEventDestroy extends ContainerEventBase {
+    entity_type: 'EntContainerEventDestroy';
+    found: boolean | null;
+}
+export interface ContainerEventCommand extends ContainerEventBase {
+    entity_type: 'EntContainerEventCommand';
+    command: string;
+    return_code: number | null;
+    stdout: string | null;
+    stderr: string | null;
+}
+export type ContainerEvent = ContainerEventCreate | ContainerEventDestroy | ContainerEventCommand;
+export type ContainerEventListResponse = PaginatedResponse<ContainerEvent>;
+export type JobType = 'VALIDATION' | 'PUBLISH' | 'PUBLISH_PRE_CHECK';
+export type JobStatus = 'PENDING' | 'RUNNING' | 'SUCCEEDED' | 'FAILED' | 'ERRORED' | 'CANCELLED';
+export type JobStepStatus = 'PENDING' | 'RUNNING' | 'SUCCEEDED' | 'FAILED' | 'SKIPPED' | 'ERRORED';
+/**
+ * Job entity from the API.
+ * Used by: job get
+ */
+export interface Job {
+    id: string;
+    target_id: string;
+    job_type: JobType;
+    status: JobStatus;
+    started_at: string | null;
+    completed_at: string | null;
+    error_message: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Job step entity from the API.
+ * Used by: job get (steps table)
+ */
+export interface JobStep {
+    id: string;
+    job: Job;
+    name: string;
+    status: JobStepStatus;
+    started_at: string | null;
+    completed_at: string | null;
+    content: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Response from GET /jobs/:id/steps.
+ */
+export interface JobStepsResponse {
+    job_id: string;
+    steps: JobStep[];
+}
 /**
  * Contents of guild.json file in agent directories.
  */

package/dist/lib/generated-types.d.ts

@@ -1,5 +1,5 @@
 export declare const WEBHOOK_SERVICES: readonly ["AZURE_DEVOPS", "BITBUCKET", "CYPRESS", "GITHUB", "GOOGLE_DOCS", "GOOGLE_COMPUTE", "GOOGLE_LOGGING", "JIRA", "LINEAR", "NEWRELIC", "NOTION", "SLACK", "TESTRAIL", "ZENDESK"];
 export type WebhookService = (typeof WEBHOOK_SERVICES)[number];
-export declare const TIME_TRIGGER_FREQUENCIES: readonly ["HOURLY", "DAILY", "WEEKLY", "MONTHLY"];
+export declare const TIME_TRIGGER_FREQUENCIES: readonly ["HOURLY", "DAILY", "WEEKLY", "MONTHLY", "CRON"];
 export type TimeTriggerFrequency = (typeof TIME_TRIGGER_FREQUENCIES)[number];
 //# sourceMappingURL=generated-types.d.ts.map

package/dist/lib/generated-types.js

@@ -29,5 +29,6 @@ export const TIME_TRIGGER_FREQUENCIES = [
     'DAILY',
     'WEEKLY',
     'MONTHLY',
+    'CRON',
 ];
 //# sourceMappingURL=generated-types.js.map

package/dist/lib/output.d.ts

@@ -1,19 +1,5 @@
 import { type Spinner } from './progress.js';
-import type { Agent, AgentVersion, Context, Pagination, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
-/**
- * Session type from API responses
- */
-interface Session {
-    id: string;
-    session_type: 'chat' | 'agent_test' | 'time' | 'webhook';
-    name?: string;
-    workspace?: {
-        id: string;
-        name: string;
-    };
-    created_at: string;
-    updated_at: string;
-}
+import type { Agent, AgentVersion, Container, ContainerEvent, ContainerImageListItem, Context, JobStep, Pagination, Session, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
 /**
  * Format an agent list as a human-readable table.
  * Shared by agent list and agent search commands.
@@ -49,6 +35,26 @@ export declare function formatSessionTable(sessions: Session[], pagination: Pagi
  * Used by trigger list command.
  */
 export declare function formatTriggerTable(triggers: Trigger[], pagination: Pagination): void;
+/**
+ * Format a container list as a human-readable table.
+ * Used by container list command.
+ */
+export declare function formatContainerTable(containers: Container[], pagination: Pagination): void;
+/**
+ * Format a container image list as a human-readable table.
+ * Used by container-image list command.
+ */
+export declare function formatContainerImageTable(images: ContainerImageListItem[], pagination: Pagination): void;
+/**
+ * Format a container event list as a human-readable table.
+ * Used by container events command.
+ */
+export declare function formatContainerEventTable(events: ContainerEvent[], pagination: Pagination): void;
+/**
+ * Format job steps as a human-readable table.
+ * Used by job get command.
+ */
+export declare function formatJobStepTable(steps: JobStep[]): void;
 /**
  * Output writer interface for consistent CLI output
  *
@@ -108,5 +114,4 @@ export declare class JSONOutputWriter implements OutputWriter {
  * Create output writer based on current mode
  */
 export declare function createOutputWriter(): OutputWriter;
-export {};
 //# sourceMappingURL=output.d.ts.map

package/dist/lib/output.js

@@ -1,7 +1,7 @@
 // Copyright 2026 Guild.ai
 // SPDX-License-Identifier: Apache-2.0
 import chalk from 'chalk';
-import { Table } from 'console-table-printer';
+import { Table } from './table.js';
 import { getOutputMode, isQuietMode } from './output-mode.js';
 import { createSpinner } from './progress.js';
 import { brand, hyperlink } from './colors.js';
@@ -313,6 +313,189 @@ export function formatTriggerTable(triggers, pagination) {
         console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} triggers`));
     }
 }
+/**
+ * Format a container list as a human-readable table.
+ * Used by container list command.
+ */
+export function formatContainerTable(containers, pagination) {
+    if (containers.length === 0) {
+        console.log(chalk.dim('No containers found'));
+        return;
+    }
+    const table = new Table({
+        columns: [
+            { name: 'id', title: 'ID', alignment: 'left' },
+            { name: 'status', title: 'STATUS', alignment: 'left' },
+            { name: 'image', title: 'IMAGE', alignment: 'left' },
+            { name: 'tag', title: 'TAG', alignment: 'left' },
+            { name: 'created', title: 'CREATED', alignment: 'left' },
+        ],
+    });
+    containers.forEach((container) => {
+        const statusColor = container.status === 'RUNNING'
+            ? chalk.green
+            : container.status === 'ERRORED'
+                ? chalk.red
+                : container.status === 'DESTROYED'
+                    ? chalk.dim
+                    : chalk.yellow;
+        table.addRow({
+            id: container.id,
+            status: statusColor(container.status),
+            image: container.image?.name || '-',
+            tag: container.image?.tag || '-',
+            created: container.created_at ? formatRelativeTime(container.created_at) : '',
+        });
+    });
+    table.printTable();
+    const showing = Math.min(pagination.limit, containers.length);
+    if (pagination.has_more) {
+        const nextOffset = pagination.offset + pagination.limit;
+        console.log(`\nShowing ${showing} of ${pagination.total_count} containers. ` +
+            chalk.dim(`Use --offset ${nextOffset} to see more.`));
+    }
+    else if (pagination.total_count > showing) {
+        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} containers`));
+    }
+}
+/**
+ * Format a container image list as a human-readable table.
+ * Used by container-image list command.
+ */
+export function formatContainerImageTable(images, pagination) {
+    if (images.length === 0) {
+        console.log(chalk.dim('No container images found'));
+        return;
+    }
+    const table = new Table({
+        columns: [
+            { name: 'id', title: 'ID', alignment: 'left' },
+            { name: 'name', title: 'NAME', alignment: 'left' },
+            { name: 'image', title: 'IMAGE', alignment: 'left' },
+            { name: 'tag', title: 'TAG', alignment: 'left' },
+            { name: 'public', title: 'PUBLIC', alignment: 'left' },
+        ],
+    });
+    images.forEach((image) => {
+        table.addRow({
+            id: image.id,
+            name: image.name,
+            image: image.image_name,
+            tag: image.tag,
+            public: image.is_public ? chalk.green('yes') : chalk.dim('no'),
+        });
+    });
+    table.printTable();
+    const showing = Math.min(pagination.limit, images.length);
+    if (pagination.has_more) {
+        const nextOffset = pagination.offset + pagination.limit;
+        console.log(`\nShowing ${showing} of ${pagination.total_count} images. ` +
+            chalk.dim(`Use --offset ${nextOffset} to see more.`));
+    }
+    else if (pagination.total_count > showing) {
+        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} images`));
+    }
+}
+/**
+ * Derive a human-readable event type label from entity_type.
+ */
+function formatEventType(entityType) {
+    if (entityType === 'EntContainerEventCreate')
+        return 'create';
+    if (entityType === 'EntContainerEventDestroy')
+        return 'destroy';
+    if (entityType === 'EntContainerEventCommand')
+        return 'command';
+    return entityType;
+}
+/**
+ * Format a container event list as a human-readable table.
+ * Used by container events command.
+ */
+export function formatContainerEventTable(events, pagination) {
+    if (events.length === 0) {
+        console.log(chalk.dim('No events found'));
+        return;
+    }
+    const table = new Table({
+        columns: [
+            { name: 'id', title: 'ID', alignment: 'left' },
+            { name: 'type', title: 'TYPE', alignment: 'left', color: 'cyan' },
+            { name: 'status', title: 'STATUS', alignment: 'left' },
+            { name: 'actor', title: 'ACTOR', alignment: 'left' },
+            { name: 'detail', title: 'DETAIL', alignment: 'left' },
+            { name: 'created', title: 'CREATED', alignment: 'left' },
+        ],
+    });
+    events.forEach((event) => {
+        const statusColor = event.status === 'SUCCESS'
+            ? chalk.green
+            : event.status === 'ERROR'
+                ? chalk.red
+                : chalk.yellow;
+        let detail = '';
+        if (event.entity_type === 'EntContainerEventCommand') {
+            detail = truncate(event.command, 30);
+        }
+        else if (event.status === 'ERROR' && event.error) {
+            detail = truncate(event.error, 30);
+        }
+        table.addRow({
+            id: event.id,
+            type: formatEventType(event.entity_type),
+            status: statusColor(event.status),
+            actor: event.actor?.name || event.actor?.full_name || '-',
+            detail,
+            created: event.created_at ? formatRelativeTime(event.created_at) : '',
+        });
+    });
+    table.printTable();
+    const showing = Math.min(pagination.limit, events.length);
+    if (pagination.has_more) {
+        const nextOffset = pagination.offset + pagination.limit;
+        console.log(`\nShowing ${showing} of ${pagination.total_count} events. ` +
+            chalk.dim(`Use --offset ${nextOffset} to see more.`));
+    }
+    else if (pagination.total_count > showing) {
+        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} events`));
+    }
+}
+/**
+ * Format job steps as a human-readable table.
+ * Used by job get command.
+ */
+export function formatJobStepTable(steps) {
+    if (steps.length === 0) {
+        console.log(chalk.dim('No steps found'));
+        return;
+    }
+    const table = new Table({
+        columns: [
+            { name: 'name', title: 'STEP', alignment: 'left' },
+            { name: 'status', title: 'STATUS', alignment: 'left' },
+            { name: 'started', title: 'STARTED', alignment: 'left' },
+            { name: 'completed', title: 'COMPLETED', alignment: 'left' },
+        ],
+    });
+    steps.forEach((step) => {
+        const statusColor = step.status === 'SUCCEEDED'
+            ? chalk.green
+            : step.status === 'FAILED' || step.status === 'ERRORED'
+                ? chalk.red
+                : step.status === 'RUNNING'
+                    ? chalk.yellow
+                    : step.status === 'SKIPPED'
+                        ? chalk.dim
+                        : chalk.white;
+        table.addRow({
+            name: step.name,
+            status: statusColor(step.status),
+            started: step.started_at ? formatRelativeTime(step.started_at) : '-',
+            completed: step.completed_at ? formatRelativeTime(step.completed_at) : '-',
+        });
+    });
+    table.printTable();
+}
 /**
  * Human-friendly output writer
  *

package/dist/lib/session-events.d.ts

@@ -85,6 +85,7 @@ export interface RuntimeWaitingEvent extends BaseEvent {
 export interface RuntimeErrorEvent extends BaseEvent {
     type: 'runtime_error';
     content: string;
+    stack: string | null;
 }
 export interface RuntimeDoneEvent extends BaseEvent {
     type: 'runtime_done';

package/dist/lib/table.d.ts

@@ -0,0 +1,22 @@
+interface ColumnConfig {
+    name: string;
+    title: string;
+    alignment?: 'left';
+    color?: string;
+}
+/**
+ * Minimal table renderer using string-width@7 for ANSI-aware column sizing.
+ * Handles OSC8 hyperlink sequences correctly (string-width uses strip-ansi@7).
+ */
+export declare class Table {
+    private columns;
+    private rows;
+    constructor(config: {
+        columns: ColumnConfig[];
+    });
+    addRow(row: Record<string, string>): void;
+    render(): string;
+    printTable(): void;
+}
+export {};
+//# sourceMappingURL=table.d.ts.map

package/dist/lib/table.js

@@ -0,0 +1,60 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import chalk from 'chalk';
+import stringWidth from 'string-width';
+/**
+ * Minimal table renderer using string-width@7 for ANSI-aware column sizing.
+ * Handles OSC8 hyperlink sequences correctly (string-width uses strip-ansi@7).
+ */
+export class Table {
+    columns;
+    rows = [];
+    constructor(config) {
+        this.columns = config.columns;
+    }
+    addRow(row) {
+        const sanitized = {};
+        for (const [k, v] of Object.entries(row)) {
+            sanitized[k] = v.replace(/[\r\n]+/g, ' ').trim();
+        }
+        this.rows.push(sanitized);
+    }
+    render() {
+        const widths = this.columns.map((col) => {
+            const headerWidth = stringWidth(col.title);
+            const maxData = this.rows.reduce((max, row) => Math.max(max, stringWidth(row[col.name] ?? '')), 0);
+            return Math.max(headerWidth, maxData);
+        });
+        const pad = (text, width) => {
+            const visible = stringWidth(text);
+            return visible >= width ? text : text + ' '.repeat(width - visible);
+        };
+        const top = '┌' + widths.map((w) => '─'.repeat(w + 2)).join('┬') + '┐';
+        const mid = '├' + widths.map((w) => '─'.repeat(w + 2)).join('┼') + '┤';
+        const bot = '└' + widths.map((w) => '─'.repeat(w + 2)).join('┴') + '┘';
+        const header = '│' +
+            this.columns
+                .map((col, i) => ' ' + chalk.bold(pad(col.title, widths[i])) + ' ')
+                .join('│') +
+            '│';
+        const dataRows = this.rows.map((row) => '│' +
+            this.columns
+                .map((col, i) => {
+                const val = row[col.name] ?? '';
+                const padded = pad(val, widths[i]);
+                if (col.color && col.color in chalk) {
+                    return (' ' +
+                        chalk[col.color](padded) +
+                        ' ');
+                }
+                return ' ' + padded + ' ';
+            })
+                .join('│') +
+            '│');
+        return [top, header, mid, ...dataRows, bot].join('\n');
+    }
+    printTable() {
+        console.log(this.render());
+    }
+}
+//# sourceMappingURL=table.js.map

package/docs/CLI_WORKFLOW.md

@@ -7,6 +7,12 @@ description: Agent development using the Guild CLI. Activated when user mentions
 
 For local agent development using the Guild CLI. This workflow manages agent code via the Guild git server.
 
+## MCP vs CLI
+
+If Guild MCP tools are available (check for tools prefixed with `guild_`), use them for **read operations**: searching agents, listing workspaces, reading contexts, checking sessions, viewing credentials. MCP tools are faster and don't require shell execution.
+
+Use the **CLI** (via Bash) for **local development operations**: `guild agent create`, `guild agent save`, `guild agent test`, `guild agent pull`, `guild agent clone`. These involve the local filesystem and git, which MCP can't do.
+
 ## CRITICAL: Always Use the Guild CLI
 
 **NEVER manually create agent files or use raw git commands.**

package/docs/DESIGN.md

@@ -190,6 +190,8 @@ Environments are Docker containers managed by GuildCore. The CLI provides a simp
 
 The CLI integrates with AI coding assistants like Claude Code, Cursor, and others. Run `guild setup` to install Guild skills into your project.
 
+The CLI also exposes a [Model Context Protocol](https://modelcontextprotocol.io/) (MCP) server via `guild mcp`. This gives coding assistants direct access to Guild's API — searching agents, managing workspaces, reading contexts, and starting sessions — without leaving the editor. `guild setup` configures it by default; use `--no-mcp` to skip.
+
 **Typical Workflow:**
 
 1. Initialize agent: `guild agent init --name my-agent --template LLM`

package/docs/skills/agent-dev.md

@@ -7,6 +7,12 @@ description: Local agent development using the Guild CLI. Activated when user me
 
 Build agents for Guild using the CLI. **Always use the Guild CLI for agent operations - never use raw git commands.**
 
+## MCP vs CLI
+
+If Guild MCP tools are available (check for tools prefixed with `guild_`), use them for **read operations**: searching agents, listing workspaces, reading contexts, checking sessions, viewing credentials. MCP tools are faster and don't require shell execution.
+
+Use the **CLI** (via Bash) for **local development operations**: `guild agent create`, `guild agent save`, `guild agent test`, `guild agent pull`, `guild agent clone`. These involve the local filesystem and git, which MCP can't do.
+
 ## When to Use This
 
 Activate when user:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guildai/cli",
-  "version": "0.5.9",
+  "version": "0.5.11",
   "description": "Guild.ai CLI - Build, test, and deploy AI agents",
   "type": "module",
   "main": "dist/index.js",
@@ -59,9 +59,7 @@
     "@napi-rs/keyring": "^1.2.0",
     "axios": "^1.13.2",
     "chalk": "^5.3.0",
-    "cli-table3": "^0.6.5",
     "commander": "^12.1.0",
-    "console-table-printer": "^2.15.0",
     "dotenv": "^16.4.7",
     "execa": "^9.6.1",
     "ink": "^5.0.1",
@@ -76,6 +74,7 @@
     "react": "^18.3.1",
     "sharp": "^0.34.5",
     "shell-quote": "^1.8.2",
+    "string-width": "^7.2.0",
     "svg-pathdata": "^8.0.0",
     "svgdom": "^0.1.22",
     "ws": "^8.18.0",