@link-assistant/agent 0.0.8 → 0.0.11

package/src/cli/cmd/stats.ts

@@ -1,98 +1,112 @@
-import type { Argv } from "yargs"
-import { cmd } from "./cmd"
-import { Session } from "../../session"
-import { bootstrap } from "../bootstrap"
-import { Storage } from "../../storage/storage"
-import { Project } from "../../project/project"
-import { Instance } from "../../project/instance"
+import type { Argv } from 'yargs';
+import { cmd } from './cmd';
+import { Session } from '../../session';
+import { bootstrap } from '../bootstrap';
+import { Storage } from '../../storage/storage';
+import { Project } from '../../project/project';
+import { Instance } from '../../project/instance';
 
 interface SessionStats {
-  totalSessions: number
-  totalMessages: number
-  totalCost: number
+  totalSessions: number;
+  totalMessages: number;
+  totalCost: number;
   totalTokens: {
-    input: number
-    output: number
-    reasoning: number
+    input: number;
+    output: number;
+    reasoning: number;
     cache: {
-      read: number
-      write: number
-    }
-  }
-  toolUsage: Record<string, number>
+      read: number;
+      write: number;
+    };
+  };
+  toolUsage: Record<string, number>;
   dateRange: {
-    earliest: number
-    latest: number
-  }
-  days: number
-  costPerDay: number
+    earliest: number;
+    latest: number;
+  };
+  days: number;
+  costPerDay: number;
 }
 
 export const StatsCommand = cmd({
-  command: "stats",
-  describe: "show token usage and cost statistics",
+  command: 'stats',
+  describe: 'show token usage and cost statistics',
   builder: (yargs: Argv) => {
     return yargs
-      .option("days", {
-        describe: "show stats for the last N days (default: all time)",
-        type: "number",
+      .option('days', {
+        describe: 'show stats for the last N days (default: all time)',
+        type: 'number',
       })
-      .option("tools", {
-        describe: "number of tools to show (default: all)",
-        type: "number",
-      })
-      .option("project", {
-        describe: "filter by project (default: all projects, empty string: current project)",
-        type: "string",
+      .option('tools', {
+        describe: 'number of tools to show (default: all)',
+        type: 'number',
       })
+      .option('project', {
+        describe:
+          'filter by project (default: all projects, empty string: current project)',
+        type: 'string',
+      });
   },
   handler: async (args) => {
     await bootstrap(process.cwd(), async () => {
-      const stats = await aggregateSessionStats(args.days, args.project)
-      displayStats(stats, args.tools)
-    })
+      const stats = await aggregateSessionStats(args.days, args.project);
+      displayStats(stats, args.tools);
+    });
   },
-})
+});
 
 async function getCurrentProject(): Promise<Project.Info> {
-  return Instance.project
+  return Instance.project;
 }
 
 async function getAllSessions(): Promise<Session.Info[]> {
-  const sessions: Session.Info[] = []
+  const sessions: Session.Info[] = [];
 
-  const projectKeys = await Storage.list(["project"])
-  const projects = await Promise.all(projectKeys.map((key) => Storage.read<Project.Info>(key)))
+  const projectKeys = await Storage.list(['project']);
+  const projects = await Promise.all(
+    projectKeys.map((key) => Storage.read<Project.Info>(key))
+  );
 
   for (const project of projects) {
-    if (!project) continue
+    if (!project) continue;
 
-    const sessionKeys = await Storage.list(["session", project.id])
-    const projectSessions = await Promise.all(sessionKeys.map((key) => Storage.read<Session.Info>(key)))
+    const sessionKeys = await Storage.list(['session', project.id]);
+    const projectSessions = await Promise.all(
+      sessionKeys.map((key) => Storage.read<Session.Info>(key))
+    );
 
     for (const session of projectSessions) {
       if (session) {
-        sessions.push(session)
+        sessions.push(session);
       }
     }
   }
 
-  return sessions
+  return sessions;
 }
 
-async function aggregateSessionStats(days?: number, projectFilter?: string): Promise<SessionStats> {
-  const sessions = await getAllSessions()
-  const DAYS_IN_SECOND = 24 * 60 * 60 * 1000
-  const cutoffTime = days ? Date.now() - days * DAYS_IN_SECOND : 0
+async function aggregateSessionStats(
+  days?: number,
+  projectFilter?: string
+): Promise<SessionStats> {
+  const sessions = await getAllSessions();
+  const DAYS_IN_SECOND = 24 * 60 * 60 * 1000;
+  const cutoffTime = days ? Date.now() - days * DAYS_IN_SECOND : 0;
 
-  let filteredSessions = days ? sessions.filter((session) => session.time.updated >= cutoffTime) : sessions
+  let filteredSessions = days
+    ? sessions.filter((session) => session.time.updated >= cutoffTime)
+    : sessions;
 
   if (projectFilter !== undefined) {
-    if (projectFilter === "") {
-      const currentProject = await getCurrentProject()
-      filteredSessions = filteredSessions.filter((session) => session.projectID === currentProject.id)
+    if (projectFilter === '') {
+      const currentProject = await getCurrentProject();
+      filteredSessions = filteredSessions.filter(
+        (session) => session.projectID === currentProject.id
+      );
     } else {
-      filteredSessions = filteredSessions.filter((session) => session.projectID === projectFilter)
+      filteredSessions = filteredSessions.filter(
+        (session) => session.projectID === projectFilter
+      );
     }
   }
 
@@ -116,46 +130,54 @@ async function aggregateSessionStats(days?: number, projectFilter?: string): Pro
     },
     days: 0,
     costPerDay: 0,
-  }
+  };
 
   if (filteredSessions.length > 1000) {
-    console.log(`Large dataset detected (${filteredSessions.length} sessions). This may take a while...`)
+    console.log(
+      `Large dataset detected (${filteredSessions.length} sessions). This may take a while...`
+    );
   }
 
   if (filteredSessions.length === 0) {
-    return stats
+    return stats;
   }
 
-  let earliestTime = Date.now()
-  let latestTime = 0
+  let earliestTime = Date.now();
+  let latestTime = 0;
 
-  const BATCH_SIZE = 20
+  const BATCH_SIZE = 20;
   for (let i = 0; i < filteredSessions.length; i += BATCH_SIZE) {
-    const batch = filteredSessions.slice(i, i + BATCH_SIZE)
+    const batch = filteredSessions.slice(i, i + BATCH_SIZE);
 
     const batchPromises = batch.map(async (session) => {
-      const messages = await Session.messages({ sessionID: session.id })
+      const messages = await Session.messages({ sessionID: session.id });
 
-      let sessionCost = 0
-      let sessionTokens = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }
-      let sessionToolUsage: Record<string, number> = {}
+      let sessionCost = 0;
+      let sessionTokens = {
+        input: 0,
+        output: 0,
+        reasoning: 0,
+        cache: { read: 0, write: 0 },
+      };
+      let sessionToolUsage: Record<string, number> = {};
 
       for (const message of messages) {
-        if (message.info.role === "assistant") {
-          sessionCost += message.info.cost || 0
+        if (message.info.role === 'assistant') {
+          sessionCost += message.info.cost || 0;
 
           if (message.info.tokens) {
-            sessionTokens.input += message.info.tokens.input || 0
-            sessionTokens.output += message.info.tokens.output || 0
-            sessionTokens.reasoning += message.info.tokens.reasoning || 0
-            sessionTokens.cache.read += message.info.tokens.cache?.read || 0
-            sessionTokens.cache.write += message.info.tokens.cache?.write || 0
+            sessionTokens.input += message.info.tokens.input || 0;
+            sessionTokens.output += message.info.tokens.output || 0;
+            sessionTokens.reasoning += message.info.tokens.reasoning || 0;
+            sessionTokens.cache.read += message.info.tokens.cache?.read || 0;
+            sessionTokens.cache.write += message.info.tokens.cache?.write || 0;
           }
         }
 
         for (const part of message.parts) {
-          if (part.type === "tool" && part.tool) {
-            sessionToolUsage[part.tool] = (sessionToolUsage[part.tool] || 0) + 1
+          if (part.type === 'tool' && part.tool) {
+            sessionToolUsage[part.tool] =
+              (sessionToolUsage[part.tool] || 0) + 1;
           }
         }
       }
@@ -167,110 +189,127 @@ async function aggregateSessionStats(days?: number, projectFilter?: string): Pro
         sessionToolUsage,
         earliestTime: session.time.created,
         latestTime: session.time.updated,
-      }
-    })
+      };
+    });
 
-    const batchResults = await Promise.all(batchPromises)
+    const batchResults = await Promise.all(batchPromises);
 
     for (const result of batchResults) {
-      earliestTime = Math.min(earliestTime, result.earliestTime)
-      latestTime = Math.max(latestTime, result.latestTime)
+      earliestTime = Math.min(earliestTime, result.earliestTime);
+      latestTime = Math.max(latestTime, result.latestTime);
 
-      stats.totalMessages += result.messageCount
-      stats.totalCost += result.sessionCost
-      stats.totalTokens.input += result.sessionTokens.input
-      stats.totalTokens.output += result.sessionTokens.output
-      stats.totalTokens.reasoning += result.sessionTokens.reasoning
-      stats.totalTokens.cache.read += result.sessionTokens.cache.read
-      stats.totalTokens.cache.write += result.sessionTokens.cache.write
+      stats.totalMessages += result.messageCount;
+      stats.totalCost += result.sessionCost;
+      stats.totalTokens.input += result.sessionTokens.input;
+      stats.totalTokens.output += result.sessionTokens.output;
+      stats.totalTokens.reasoning += result.sessionTokens.reasoning;
+      stats.totalTokens.cache.read += result.sessionTokens.cache.read;
+      stats.totalTokens.cache.write += result.sessionTokens.cache.write;
 
       for (const [tool, count] of Object.entries(result.sessionToolUsage)) {
-        stats.toolUsage[tool] = (stats.toolUsage[tool] || 0) + count
+        stats.toolUsage[tool] = (stats.toolUsage[tool] || 0) + count;
       }
     }
   }
 
-  const actualDays = Math.max(1, Math.ceil((latestTime - earliestTime) / DAYS_IN_SECOND))
+  const actualDays = Math.max(
+    1,
+    Math.ceil((latestTime - earliestTime) / DAYS_IN_SECOND)
+  );
   stats.dateRange = {
     earliest: earliestTime,
     latest: latestTime,
-  }
-  stats.days = actualDays
-  stats.costPerDay = stats.totalCost / actualDays
+  };
+  stats.days = actualDays;
+  stats.costPerDay = stats.totalCost / actualDays;
 
-  return stats
+  return stats;
 }
 
 export function displayStats(stats: SessionStats, toolLimit?: number) {
-  const width = 56
+  const width = 56;
 
   function renderRow(label: string, value: string): string {
-    const availableWidth = width - 1
-    const paddingNeeded = availableWidth - label.length - value.length
-    const padding = Math.max(0, paddingNeeded)
-    return `│${label}${" ".repeat(padding)}${value} │`
+    const availableWidth = width - 1;
+    const paddingNeeded = availableWidth - label.length - value.length;
+    const padding = Math.max(0, paddingNeeded);
+    return `│${label}${' '.repeat(padding)}${value} │`;
   }
 
   // Overview section
-  console.log("┌────────────────────────────────────────────────────────┐")
-  console.log("│                       OVERVIEW                         │")
-  console.log("├────────────────────────────────────────────────────────┤")
-  console.log(renderRow("Sessions", stats.totalSessions.toLocaleString()))
-  console.log(renderRow("Messages", stats.totalMessages.toLocaleString()))
-  console.log(renderRow("Days", stats.days.toString()))
-  console.log("└────────────────────────────────────────────────────────┘")
-  console.log()
+  console.log('┌────────────────────────────────────────────────────────┐');
+  console.log('│                       OVERVIEW                         │');
+  console.log('├────────────────────────────────────────────────────────┤');
+  console.log(renderRow('Sessions', stats.totalSessions.toLocaleString()));
+  console.log(renderRow('Messages', stats.totalMessages.toLocaleString()));
+  console.log(renderRow('Days', stats.days.toString()));
+  console.log('└────────────────────────────────────────────────────────┘');
+  console.log();
 
   // Cost & Tokens section
-  console.log("┌────────────────────────────────────────────────────────┐")
-  console.log("│                    COST & TOKENS                       │")
-  console.log("├────────────────────────────────────────────────────────┤")
-  const cost = isNaN(stats.totalCost) ? 0 : stats.totalCost
-  const costPerDay = isNaN(stats.costPerDay) ? 0 : stats.costPerDay
-  console.log(renderRow("Total Cost", `$${cost.toFixed(2)}`))
-  console.log(renderRow("Cost/Day", `$${costPerDay.toFixed(2)}`))
-  console.log(renderRow("Input", formatNumber(stats.totalTokens.input)))
-  console.log(renderRow("Output", formatNumber(stats.totalTokens.output)))
-  console.log(renderRow("Cache Read", formatNumber(stats.totalTokens.cache.read)))
-  console.log(renderRow("Cache Write", formatNumber(stats.totalTokens.cache.write)))
-  console.log("└────────────────────────────────────────────────────────┘")
-  console.log()
+  console.log('┌────────────────────────────────────────────────────────┐');
+  console.log('│                    COST & TOKENS                       │');
+  console.log('├────────────────────────────────────────────────────────┤');
+  const cost = isNaN(stats.totalCost) ? 0 : stats.totalCost;
+  const costPerDay = isNaN(stats.costPerDay) ? 0 : stats.costPerDay;
+  console.log(renderRow('Total Cost', `$${cost.toFixed(2)}`));
+  console.log(renderRow('Cost/Day', `$${costPerDay.toFixed(2)}`));
+  console.log(renderRow('Input', formatNumber(stats.totalTokens.input)));
+  console.log(renderRow('Output', formatNumber(stats.totalTokens.output)));
+  console.log(
+    renderRow('Cache Read', formatNumber(stats.totalTokens.cache.read))
+  );
+  console.log(
+    renderRow('Cache Write', formatNumber(stats.totalTokens.cache.write))
+  );
+  console.log('└────────────────────────────────────────────────────────┘');
+  console.log();
 
   // Tool Usage section
   if (Object.keys(stats.toolUsage).length > 0) {
-    const sortedTools = Object.entries(stats.toolUsage).sort(([, a], [, b]) => b - a)
-    const toolsToDisplay = toolLimit ? sortedTools.slice(0, toolLimit) : sortedTools
-
-    console.log("┌────────────────────────────────────────────────────────┐")
-    console.log("│                      TOOL USAGE                        │")
-    console.log("├────────────────────────────────────────────────────────┤")
-
-    const maxCount = Math.max(...toolsToDisplay.map(([, count]) => count))
-    const totalToolUsage = Object.values(stats.toolUsage).reduce((a, b) => a + b, 0)
+    const sortedTools = Object.entries(stats.toolUsage).sort(
+      ([, a], [, b]) => b - a
+    );
+    const toolsToDisplay = toolLimit
+      ? sortedTools.slice(0, toolLimit)
+      : sortedTools;
+
+    console.log('┌────────────────────────────────────────────────────────┐');
+    console.log('│                      TOOL USAGE                        │');
+    console.log('├────────────────────────────────────────────────────────┤');
+
+    const maxCount = Math.max(...toolsToDisplay.map(([, count]) => count));
+    const totalToolUsage = Object.values(stats.toolUsage).reduce(
+      (a, b) => a + b,
+      0
+    );
 
     for (const [tool, count] of toolsToDisplay) {
-      const barLength = Math.max(1, Math.floor((count / maxCount) * 20))
-      const bar = "█".repeat(barLength)
-      const percentage = ((count / totalToolUsage) * 100).toFixed(1)
-
-      const maxToolLength = 18
-      const truncatedTool = tool.length > maxToolLength ? tool.substring(0, maxToolLength - 2) + ".." : tool
-      const toolName = truncatedTool.padEnd(maxToolLength)
-
-      const content = ` ${toolName} ${bar.padEnd(20)} ${count.toString().padStart(3)} (${percentage.padStart(4)}%)`
-      const padding = Math.max(0, width - content.length - 1)
-      console.log(`│${content}${" ".repeat(padding)} │`)
+      const barLength = Math.max(1, Math.floor((count / maxCount) * 20));
+      const bar = '█'.repeat(barLength);
+      const percentage = ((count / totalToolUsage) * 100).toFixed(1);
+
+      const maxToolLength = 18;
+      const truncatedTool =
+        tool.length > maxToolLength
+          ? tool.substring(0, maxToolLength - 2) + '..'
+          : tool;
+      const toolName = truncatedTool.padEnd(maxToolLength);
+
+      const content = ` ${toolName} ${bar.padEnd(20)} ${count.toString().padStart(3)} (${percentage.padStart(4)}%)`;
+      const padding = Math.max(0, width - content.length - 1);
+      console.log(`│${content}${' '.repeat(padding)} │`);
     }
-    console.log("└────────────────────────────────────────────────────────┘")
+    console.log('└────────────────────────────────────────────────────────┘');
   }
-  console.log()
+  console.log();
 }
 
 function formatNumber(num: number): string {
   if (num >= 1000000) {
-    return (num / 1000000).toFixed(1) + "M"
+    return (num / 1000000).toFixed(1) + 'M';
   } else if (num >= 1000) {
-    return (num / 1000).toFixed(1) + "K"
+    return (num / 1000).toFixed(1) + 'K';
   }
-  return num.toString()
+  return num.toString();
 }

package/src/cli/error.ts

@@ -1,27 +1,31 @@
-import { ConfigMarkdown } from "../config/markdown"
-import { Config } from "../config/config"
-import { MCP } from "../mcp"
-import { UI } from "./ui"
+import { ConfigMarkdown } from '../config/markdown';
+import { Config } from '../config/config';
+import { MCP } from '../mcp';
+import { UI } from './ui';
 
 export function FormatError(input: unknown) {
   if (MCP.Failed.isInstance(input))
-    return `MCP server "${input.data.name}" failed. Note, opencode does not support MCP authentication yet.`
+    return `MCP server "${input.data.name}" failed. Note, opencode does not support MCP authentication yet.`;
   if (Config.JsonError.isInstance(input)) {
     return (
-      `Config file at ${input.data.path} is not valid JSON(C)` + (input.data.message ? `: ${input.data.message}` : "")
-    )
+      `Config file at ${input.data.path} is not valid JSON(C)` +
+      (input.data.message ? `: ${input.data.message}` : '')
+    );
   }
   if (Config.ConfigDirectoryTypoError.isInstance(input)) {
-    return `Directory "${input.data.dir}" in ${input.data.path} is not valid. Use "${input.data.suggestion}" instead. This is a common typo.`
+    return `Directory "${input.data.dir}" in ${input.data.path} is not valid. Use "${input.data.suggestion}" instead. This is a common typo.`;
   }
   if (ConfigMarkdown.FrontmatterError.isInstance(input)) {
-    return `Failed to parse frontmatter in ${input.data.path}:\n${input.data.message}`
+    return `Failed to parse frontmatter in ${input.data.path}:\n${input.data.message}`;
   }
   if (Config.InvalidError.isInstance(input))
     return [
-      `Config file at ${input.data.path} is invalid` + (input.data.message ? `: ${input.data.message}` : ""),
-      ...(input.data.issues?.map((issue) => "↳ " + issue.message + " " + issue.path.join(".")) ?? []),
-    ].join("\n")
+      `Config file at ${input.data.path} is invalid` +
+        (input.data.message ? `: ${input.data.message}` : ''),
+      ...(input.data.issues?.map(
+        (issue) => '↳ ' + issue.message + ' ' + issue.path.join('.')
+      ) ?? []),
+    ].join('\n');
 
-  if (UI.CancelledError.isInstance(input)) return ""
+  if (UI.CancelledError.isInstance(input)) return '';
 }

package/src/cli/ui.ts

@@ -0,0 +1,78 @@
+import { NamedError } from '../util/error';
+import z from 'zod';
+
+export namespace UI {
+  // ANSI color codes for terminal output
+  export const Style = {
+    TEXT_NORMAL: '\x1b[0m',
+    TEXT_BOLD: '\x1b[1m',
+    TEXT_DIM: '\x1b[2m',
+    TEXT_DANGER_BOLD: '\x1b[1;31m',
+    TEXT_SUCCESS_BOLD: '\x1b[1;32m',
+    TEXT_WARNING_BOLD: '\x1b[1;33m',
+    TEXT_INFO_BOLD: '\x1b[1;34m',
+    TEXT_HIGHLIGHT_BOLD: '\x1b[1;35m',
+    TEXT_DIM_BOLD: '\x1b[1;90m',
+  } as const;
+
+  // Error for cancelled operations (e.g., Ctrl+C in prompts)
+  export const CancelledError = NamedError.create(
+    'CancelledError',
+    z.object({})
+  );
+
+  // Print an empty line
+  export function empty() {
+    process.stderr.write('\n');
+  }
+
+  // Print a line with optional formatting
+  export function println(...args: string[]) {
+    process.stderr.write(args.join('') + Style.TEXT_NORMAL + '\n');
+  }
+
+  // Print an error message
+  export function error(message: string) {
+    process.stderr.write(
+      Style.TEXT_DANGER_BOLD + 'Error: ' + Style.TEXT_NORMAL + message + '\n'
+    );
+  }
+
+  // Print a success message
+  export function success(message: string) {
+    process.stderr.write(
+      Style.TEXT_SUCCESS_BOLD + 'Success: ' + Style.TEXT_NORMAL + message + '\n'
+    );
+  }
+
+  // Print an info message
+  export function info(message: string) {
+    process.stderr.write(
+      Style.TEXT_INFO_BOLD + 'Info: ' + Style.TEXT_NORMAL + message + '\n'
+    );
+  }
+
+  // Basic markdown rendering for terminal
+  export function markdown(text: string): string {
+    // Simple markdown to ANSI conversion
+    let result = text;
+
+    // Bold text: **text** or __text__
+    result = result.replace(
+      /\*\*(.+?)\*\*/g,
+      Style.TEXT_BOLD + '$1' + Style.TEXT_NORMAL
+    );
+    result = result.replace(
+      /__(.+?)__/g,
+      Style.TEXT_BOLD + '$1' + Style.TEXT_NORMAL
+    );
+
+    // Code blocks: `code`
+    result = result.replace(
+      /`([^`]+)`/g,
+      Style.TEXT_DIM + '$1' + Style.TEXT_NORMAL
+    );
+
+    return result;
+  }
+}

package/src/command/index.ts

@@ -1,26 +1,26 @@
-import z from "zod"
-import { Config } from "../config/config"
-import { Instance } from "../project/instance"
-import PROMPT_INITIALIZE from "./template/initialize.txt"
-import { Bus } from "../bus"
-import { Identifier } from "../id/id"
+import z from 'zod';
+import { Config } from '../config/config';
+import { Instance } from '../project/instance';
+import PROMPT_INITIALIZE from './template/initialize.txt';
+import { Bus } from '../bus';
+import { Identifier } from '../id/id';
 
 export namespace Command {
   export const Default = {
-    INIT: "init",
-  } as const
+    INIT: 'init',
+  } as const;
 
   export const Event = {
     Executed: Bus.event(
-      "command.executed",
+      'command.executed',
       z.object({
         name: z.string(),
-        sessionID: Identifier.schema("session"),
+        sessionID: Identifier.schema('session'),
         arguments: z.string(),
-        messageID: Identifier.schema("message"),
-      }),
+        messageID: Identifier.schema('message'),
+      })
     ),
-  }
+  };
 
   export const Info = z
     .object({
@@ -32,14 +32,14 @@ export namespace Command {
       subtask: z.boolean().optional(),
     })
     .meta({
-      ref: "Command",
-    })
-  export type Info = z.infer<typeof Info>
+      ref: 'Command',
+    });
+  export type Info = z.infer<typeof Info>;
 
   const state = Instance.state(async () => {
-    const cfg = await Config.get()
+    const cfg = await Config.get();
 
-    const result: Record<string, Info> = {}
+    const result: Record<string, Info> = {};
 
     for (const [name, command] of Object.entries(cfg.command ?? {})) {
       result[name] = {
@@ -49,25 +49,25 @@ export namespace Command {
         description: command.description,
         template: command.template,
         subtask: command.subtask,
-      }
+      };
     }
 
     if (result[Default.INIT] === undefined) {
       result[Default.INIT] = {
         name: Default.INIT,
-        description: "create/update AGENTS.md",
-        template: PROMPT_INITIALIZE.replace("${path}", Instance.worktree),
-      }
+        description: 'create/update AGENTS.md',
+        template: PROMPT_INITIALIZE.replace('${path}', Instance.worktree),
+      };
     }
 
-    return result
-  })
+    return result;
+  });
 
   export async function get(name: string) {
-    return state().then((x) => x[name])
+    return state().then((x) => x[name]);
   }
 
   export async function list() {
-    return state().then((x) => Object.values(x))
+    return state().then((x) => Object.values(x));
   }
 }