ubume 0.1.0

package/src/core/version/updateCheck.ts

@@ -0,0 +1,203 @@
+import { APP_VERSION } from "../../config/settings.js";
+import { isLocalDevChannel } from "./channel.js";
+
+export const UBUME_NPM_PACKAGE = "ubume";
+export const UBUME_NPM_REGISTRY_URL = "https://registry.npmjs.org/ubume";
+export const UBUME_UPDATE_COMMAND = `npm install -g ${UBUME_NPM_PACKAGE}@latest`;
+
+export const CODEXA_NPM_PACKAGE = UBUME_NPM_PACKAGE;
+export const CODEXA_NPM_REGISTRY_URL = UBUME_NPM_REGISTRY_URL;
+export const CODEXA_UPDATE_COMMAND = UBUME_UPDATE_COMMAND;
+
+export type UpdateStatus = "up-to-date" | "update-available" | "unknown" | "error";
+
+export interface NpmRegistryMetadata {
+  "dist-tags"?: { latest?: unknown };
+}
+
+export interface UpdateCheckResult {
+  status: UpdateStatus;
+  currentVersion: string;
+  latestVersion: string | null;
+  errorMessage?: string;
+  checkedAt: number;
+  source?: "npm" | "cache";
+}
+
+const FETCH_TIMEOUT_MS = 5000;
+
+/** Strip a leading "v" so "v1.0.2" and "1.0.2" are treated as equal. */
+export function normalizeVersion(v: string): string {
+  return v.startsWith("v") ? v.slice(1) : v;
+}
+
+export function formatVersionLabel(version: string): string {
+  const normalized = normalizeVersion(version.trim());
+  return normalized ? `v${normalized}` : version;
+}
+
+const SEMVER_RE = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
+
+/** Returns true for valid semver strings with or without a leading "v". */
+export function isValidSemver(v: string): boolean {
+  return SEMVER_RE.test(normalizeVersion(v));
+}
+
+export function shouldRunStartupUpdateCheck(
+  env: NodeJS.ProcessEnv = process.env,
+  enabled = true,
+): boolean {
+  return enabled && !isLocalDevChannel(env);
+}
+
+// Compares two semver strings numerically. Returns negative if a < b, 0 if equal, positive if a > b.
+// Pre-release versions (e.g. 1.0.2-beta.1) sort below their release counterpart (1.0.2 > 1.0.2-beta.1).
+// Leading "v" is stripped before comparison.
+export function compareSemver(a: string, b: string): number {
+  const parseParts = (v: string): { numeric: number[]; prerelease: string | null } => {
+    const norm = normalizeVersion(v);
+    const dashIdx = norm.indexOf("-");
+    const base = dashIdx === -1 ? norm : norm.slice(0, dashIdx);
+    const prerelease = dashIdx === -1 ? null : norm.slice(dashIdx + 1);
+    const numeric = base.split(".").map((p) => parseInt(p, 10) || 0);
+    return { numeric, prerelease };
+  };
+
+  const pa = parseParts(a);
+  const pb = parseParts(b);
+  const len = Math.max(pa.numeric.length, pb.numeric.length);
+
+  for (let i = 0; i < len; i++) {
+    const diff = (pa.numeric[i] ?? 0) - (pb.numeric[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+
+  // Same numeric version: no pre-release > has pre-release
+  if (pa.prerelease === null && pb.prerelease !== null) return 1;
+  if (pa.prerelease !== null && pb.prerelease === null) return -1;
+  if (pa.prerelease !== null && pb.prerelease !== null) {
+    return pa.prerelease < pb.prerelease ? -1 : pa.prerelease > pb.prerelease ? 1 : 0;
+  }
+  return 0;
+}
+
+export function isNewerVersion(candidate: string, current: string): boolean {
+  return compareSemver(candidate, current) > 0;
+}
+
+export interface UpdateCheckOverrides {
+  currentVersion?: string;
+  fetchNpmMetadataFn?: (url: string) => Promise<NpmRegistryMetadata>;
+}
+
+async function defaultFetchNpmMetadata(url: string): Promise<NpmRegistryMetadata> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, {
+      signal: controller.signal,
+      headers: { "User-Agent": `${UBUME_NPM_PACKAGE}-update-checker/1.0` },
+    });
+    if (!res.ok) throw new Error(`npm registry returned HTTP ${res.status}`);
+    return await res.json() as NpmRegistryMetadata;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function checkForUpdates(
+  opts?: { enabled?: boolean },
+  overrides?: UpdateCheckOverrides,
+): Promise<UpdateCheckResult> {
+  const currentVersion = normalizeVersion(overrides?.currentVersion ?? APP_VERSION);
+
+  if (opts?.enabled === false) {
+    return { status: "unknown", currentVersion, latestVersion: null, checkedAt: Date.now(), source: "npm" };
+  }
+
+  try {
+    const fetchFn = overrides?.fetchNpmMetadataFn ?? defaultFetchNpmMetadata;
+    const metadata = await fetchFn(UBUME_NPM_REGISTRY_URL);
+    const rawLatest = metadata["dist-tags"]?.latest;
+
+    if (typeof rawLatest !== "string" || !rawLatest.trim()) {
+      return {
+        status: "error",
+        currentVersion,
+        latestVersion: null,
+        errorMessage: "npm registry response did not include dist-tags.latest",
+        checkedAt: Date.now(),
+        source: "npm",
+      };
+    }
+
+    const latestVersion = normalizeVersion(rawLatest.trim());
+
+    if (!isValidSemver(latestVersion) || !isValidSemver(currentVersion)) {
+      return {
+        status: "unknown",
+        currentVersion,
+        latestVersion: rawLatest,
+        errorMessage: `Invalid semver — current: "${currentVersion}", latest: "${rawLatest}"`,
+        checkedAt: Date.now(),
+        source: "npm",
+      };
+    }
+
+    const status = isNewerVersion(latestVersion, currentVersion) ? "update-available" : "up-to-date";
+    return { status, currentVersion, latestVersion, checkedAt: Date.now(), source: "npm" };
+  } catch (err) {
+    return {
+      status: "error",
+      currentVersion,
+      latestVersion: null,
+      errorMessage: err instanceof Error ? err.message : String(err),
+      checkedAt: Date.now(),
+      source: "npm",
+    };
+  }
+}
+
+export function formatUpdateInstructions(
+  result: UpdateCheckResult | null,
+  updateCommand: string = UBUME_UPDATE_COMMAND,
+): string {
+  const current = result?.currentVersion ?? APP_VERSION;
+  const latest = result?.latestVersion ?? "unknown";
+
+  if (result?.status === "error") {
+    return [
+      `Current installed version: ${current}`,
+      `npm latest version:        ${latest}`,
+      `Error checking npm update status: ${result.errorMessage ?? "unknown error"}`,
+    ].join("\n");
+  }
+
+  if (result?.status === "up-to-date") {
+    return [
+      "Ubume is up to date.",
+      `Current installed version: ${current}`,
+      `npm latest version:        ${latest}`,
+    ].join("\n");
+  }
+
+  const statusLine = result?.status === "update-available" && result.latestVersion
+    ? `Update available: Ubume ${formatVersionLabel(result.latestVersion)}`
+    : "Status unknown — could not reach npm registry.";
+
+  return [
+    `Current installed version: ${current}`,
+    `npm latest version:        ${latest}`,
+    `Status:          ${statusLine}`,
+    "",
+    `Run: ${updateCommand}`,
+  ].join("\n");
+}
+
+export function formatLocalDevUpdateStatus(): string {
+  return [
+    "Running local-dev Ubume.",
+    "Automatic published npm update prompts are disabled for this channel.",
+    "Run /update check to explicitly check the published npm package.",
+  ].join("\n");
+}

package/src/core/workspace/appData.ts

@@ -0,0 +1,107 @@
+import { createHash } from "node:crypto";
+import { cpSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, normalize } from "node:path";
+
+type Platform = "win32" | "darwin" | "linux" | string;
+type Environment = Record<string, string | undefined>;
+
+export function resolveLegacyCodexaDataDir(
+  platformOverride?: Platform,
+  env: Environment = process.env,
+  home = homedir(),
+): string {
+  const configuredDir = env["CODEXA_DATA_DIR"]?.trim();
+  if (configuredDir) return configuredDir;
+
+  const platform = platformOverride ?? process.platform;
+  if (platform === "win32") {
+    return join(env["LOCALAPPDATA"]?.trim() || env["APPDATA"]?.trim() || join(home, "AppData", "Local"), "Codexa");
+  }
+  if (platform === "darwin") {
+    return join(home, "Library", "Application Support", "Codexa");
+  }
+
+  return join(env["XDG_DATA_HOME"]?.trim() || join(home, ".local", "share"), "codexa");
+}
+
+export function resolveUbumeDataDir(
+  platformOverride?: Platform,
+  env: Environment = process.env,
+  home = homedir(),
+): string {
+  const configuredDir = env["UBUME_DATA_DIR"]?.trim() || env["CODEXA_DATA_DIR"]?.trim();
+  if (configuredDir) return configuredDir;
+
+  const platform = platformOverride ?? process.platform;
+  if (platform === "win32") {
+    return join(env["LOCALAPPDATA"]?.trim() || env["APPDATA"]?.trim() || join(home, "AppData", "Local"), "Ubume");
+  }
+  if (platform === "darwin") {
+    return join(home, "Library", "Application Support", "Ubume");
+  }
+
+  return join(env["XDG_DATA_HOME"]?.trim() || join(home, ".local", "share"), "ubume");
+}
+
+let dataMigrated = false;
+
+export function maybeMigrateLegacyData(
+  platformOverride?: Platform,
+  env: Environment = process.env,
+  home = homedir(),
+): void {
+  if (dataMigrated) return;
+  dataMigrated = true;
+
+  try {
+    const ubumeDir = resolveUbumeDataDir(platformOverride, env, home);
+    const legacyDir = resolveLegacyCodexaDataDir(platformOverride, env, home);
+
+    if (ubumeDir !== legacyDir && !existsSync(ubumeDir) && existsSync(legacyDir)) {
+      // Safe non-destructive one-time copy
+      cpSync(legacyDir, ubumeDir, { recursive: true });
+    }
+  } catch {
+    // Non-destructive best-effort migration
+  }
+}
+
+export function resetDataMigrationForTests(): void {
+  dataMigrated = false;
+}
+
+export function workspaceStorageKey(workspaceRoot: string): string {
+  return createHash("sha256").update(workspaceRoot).digest("hex").slice(0, 16);
+}
+
+export function resolveUbumeWorkspaceDataDir(workspaceRoot: string): string {
+  maybeMigrateLegacyData();
+  return join(resolveUbumeDataDir(), "workspaces", workspaceStorageKey(workspaceRoot));
+}
+
+export function resolveUbumeConversationDir(workspaceRoot: string): string {
+  return join(resolveUbumeWorkspaceDataDir(workspaceRoot), "conversations");
+}
+
+export function resolveUbumeAttachmentDir(workspaceRoot: string, configuredDir: string): string {
+  if (isAbsolute(configuredDir)) return configuredDir;
+
+  const normalized = configuredDir
+    .trim()
+    .replace(/\\/g, "/")
+    .replace(/^\.(?:ubume|codexa)\/?/, "") || "attachments";
+  const safeRelativeDir = normalize(normalized).replace(/^(\.\.([/\\]|$))+/, "") || "attachments";
+  return join(resolveUbumeWorkspaceDataDir(workspaceRoot), safeRelativeDir);
+}
+
+export function resolveUbumeDebugLogPath(env: Environment = process.env): string {
+  return join(resolveUbumeDataDir(undefined, env), "debug", "render-status.log");
+}
+
+// Backwards-compatible aliases
+export const resolveCodexaDataDir = resolveUbumeDataDir;
+export const resolveCodexaWorkspaceDataDir = resolveUbumeWorkspaceDataDir;
+export const resolveCodexaConversationDir = resolveUbumeConversationDir;
+export const resolveCodexaAttachmentDir = resolveUbumeAttachmentDir;
+export const resolveCodexaDebugLogPath = resolveUbumeDebugLogPath;

package/src/core/workspace/conversationStore.ts

@@ -0,0 +1,335 @@
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import type { ProviderBackendKind } from "../providerRuntime/types.js";
+import type { ProviderId } from "../providerLauncher/types.js";
+import type { LocalBackendId } from "../providerLauncher/types.js";
+import { resolveUbumeConversationDir } from "./appData.js";
+
+export type ConversationMessageRole = "user" | "assistant";
+
+export interface ConversationMessage {
+  role: ConversationMessageRole;
+  content: string;
+  /** Files changed / commands run during the run that produced this reply. */
+  activitySummary?: string;
+}
+
+export interface ConversationContextCheckpoint {
+  version: 1;
+  modelId: string;
+  contextLength: number | null;
+  throughMessageCount: number;
+  transcriptHash: string;
+  summary: string;
+  activeWindowChars?: number;
+  responseCharsCovered?: number;
+  updatedAt: string;
+}
+
+export interface LocalHarnessSessionMetadata {
+  version: 1;
+  sessionId: string;
+  harnessVersion: string;
+  routeFingerprint: string;
+  throughMessageCount: number;
+  transcriptHash: string;
+  updatedAt: string;
+}
+
+export interface ConversationMetadata {
+  version: 1;
+  id: string;
+  title: string;
+  createdAt: string;
+  updatedAt: string;
+  providerId: ProviderId | string | null;
+  modelId: string;
+  backendKind: ProviderBackendKind | string | null;
+  reasoning?: string;
+  localBackend?: LocalBackendId;
+  localContextCheckpoint?: ConversationContextCheckpoint;
+  localHarnessSession?: LocalHarnessSessionMetadata;
+  messageCount: number;
+}
+
+export interface ConversationRecord {
+  metadata: ConversationMetadata;
+  messages: ConversationMessage[];
+}
+
+export interface ConversationListEntry extends ConversationMetadata {}
+
+interface ConversationStoreOptions {
+  rootDir?: string;
+  now?: () => Date;
+  idFactory?: () => string;
+  onDiagnostic?: (message: string) => void;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function safeString(value: unknown): string | null {
+  return typeof value === "string" && value.trim() ? value : null;
+}
+
+function isNonNegativeInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+
+function parseContextCheckpoint(value: unknown): ConversationContextCheckpoint | null {
+  if (!isRecord(value) || value.version !== 1) return null;
+  const modelId = safeString(value.modelId);
+  const transcriptHash = safeString(value.transcriptHash);
+  const summary = safeString(value.summary);
+  const updatedAt = safeString(value.updatedAt);
+  const contextLength = value.contextLength === null
+    ? null
+    : isNonNegativeInteger(value.contextLength) && value.contextLength > 0
+      ? value.contextLength
+      : undefined;
+  if (
+    !modelId
+    || contextLength === undefined
+    || !isNonNegativeInteger(value.throughMessageCount)
+    || !transcriptHash
+    || !summary
+    || !updatedAt
+    || (value.activeWindowChars !== undefined && !isNonNegativeInteger(value.activeWindowChars))
+    || (value.responseCharsCovered !== undefined && !isNonNegativeInteger(value.responseCharsCovered))
+  ) return null;
+
+  return {
+    version: 1,
+    modelId,
+    contextLength,
+    throughMessageCount: value.throughMessageCount,
+    transcriptHash,
+    summary,
+    ...(value.activeWindowChars === undefined ? {} : { activeWindowChars: value.activeWindowChars }),
+    ...(value.responseCharsCovered === undefined ? {} : { responseCharsCovered: value.responseCharsCovered }),
+    updatedAt,
+  };
+}
+
+function parseLocalHarnessSession(value: unknown): LocalHarnessSessionMetadata | null {
+  if (!isRecord(value) || value.version !== 1) return null;
+  const sessionId = safeString(value.sessionId);
+  const harnessVersion = safeString(value.harnessVersion);
+  const routeFingerprint = safeString(value.routeFingerprint);
+  const transcriptHash = safeString(value.transcriptHash);
+  const updatedAt = safeString(value.updatedAt);
+  if (!sessionId || !harnessVersion || !routeFingerprint || !transcriptHash || !updatedAt) return null;
+  if (!isNonNegativeInteger(value.throughMessageCount)) return null;
+  return {
+    version: 1,
+    sessionId,
+    harnessVersion,
+    routeFingerprint,
+    throughMessageCount: value.throughMessageCount,
+    transcriptHash,
+    updatedAt,
+  };
+}
+
+function parseMessages(value: unknown): ConversationMessage[] | null {
+  if (!Array.isArray(value)) return null;
+  const messages: ConversationMessage[] = [];
+  for (const item of value) {
+    if (!isRecord(item)) return null;
+    const role = item.role;
+    const content = item.content;
+    if ((role !== "user" && role !== "assistant") || typeof content !== "string") return null;
+    const activitySummary = typeof item.activitySummary === "string" && item.activitySummary.trim()
+      ? item.activitySummary
+      : null;
+    messages.push({ role, content, ...(activitySummary ? { activitySummary } : {}) });
+  }
+  return messages;
+}
+
+function parseMetadata(value: unknown, fallbackId: string): ConversationMetadata | null {
+  if (!isRecord(value)) return null;
+  const id = safeString(value.id) ?? fallbackId;
+  const title = safeString(value.title) ?? "Untitled conversation";
+  const createdAt = safeString(value.createdAt) ?? new Date(0).toISOString();
+  const updatedAt = safeString(value.updatedAt) ?? createdAt;
+  const modelId = safeString(value.modelId) ?? "unknown";
+  const messageCount = typeof value.messageCount === "number" && Number.isInteger(value.messageCount)
+    ? Math.max(0, value.messageCount)
+    : 0;
+  const localContextCheckpoint = parseContextCheckpoint(value.localContextCheckpoint);
+  const localHarnessSession = parseLocalHarnessSession(value.localHarnessSession);
+  return {
+    version: 1,
+    id,
+    title,
+    createdAt,
+    updatedAt,
+    providerId: typeof value.providerId === "string" ? value.providerId : null,
+    modelId,
+    backendKind: typeof value.backendKind === "string" ? value.backendKind : null,
+    ...(typeof value.reasoning === "string" && value.reasoning.trim() ? { reasoning: value.reasoning } : {}),
+    ...(value.localBackend === "lm-studio" || value.localBackend === "unsloth" ? { localBackend: value.localBackend } : {}),
+    ...(localContextCheckpoint ? { localContextCheckpoint } : {}),
+    ...(localHarnessSession ? { localHarnessSession } : {}),
+    messageCount,
+  };
+}
+
+function titleFromMessages(messages: ConversationMessage[]): string {
+  const firstUser = messages.find((message) => message.role === "user" && message.content.trim());
+  if (!firstUser) return "Untitled conversation";
+  const title = firstUser.content.replace(/\s+/g, " ").trim();
+  return title.length > 72 ? `${title.slice(0, 69).trimEnd()}...` : title;
+}
+
+function atomicWriteJson(filePath: string, value: unknown): void {
+  const temporaryPath = `${filePath}.tmp`;
+  writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+  renameSync(temporaryPath, filePath);
+}
+
+function isSafeConversationId(id: string): boolean {
+  return /^chat_[A-Za-z0-9-]+$/.test(id);
+}
+
+export class ConversationStore {
+  private readonly rootDir: string;
+  private readonly now: () => Date;
+  private readonly idFactory: () => string;
+  private readonly onDiagnostic: (message: string) => void;
+
+  constructor(workspaceRoot: string, options: ConversationStoreOptions = {}) {
+    this.rootDir = options.rootDir ?? resolveUbumeConversationDir(workspaceRoot);
+    this.now = options.now ?? (() => new Date());
+    this.idFactory = options.idFactory ?? (() => randomUUID());
+    this.onDiagnostic = options.onDiagnostic ?? (() => undefined);
+  }
+
+  private conversationDir(id: string): string {
+    if (!isSafeConversationId(id)) throw new Error("Invalid conversation id.");
+    return join(this.rootDir, id);
+  }
+
+  private ensureRoot(): void {
+    mkdirSync(this.rootDir, { recursive: true });
+  }
+
+  createConversation(route: {
+    providerId: ProviderId | string | null;
+    modelId: string;
+    backendKind: ProviderBackendKind | string | null;
+    reasoning?: string;
+    localBackend?: LocalBackendId;
+  }): ConversationRecord {
+    this.ensureRoot();
+    const id = `chat_${this.idFactory()}`;
+    const timestamp = this.now().toISOString();
+    const metadata: ConversationMetadata = {
+      version: 1,
+      id,
+      title: "Untitled conversation",
+      createdAt: timestamp,
+      updatedAt: timestamp,
+      providerId: route.providerId,
+      modelId: route.modelId,
+      backendKind: route.backendKind,
+      ...(route.reasoning ? { reasoning: route.reasoning } : {}),
+      ...(route.localBackend ? { localBackend: route.localBackend } : {}),
+      messageCount: 0,
+    };
+    return { metadata, messages: [] };
+  }
+
+  save(record: ConversationRecord): void {
+    const dir = this.conversationDir(record.metadata.id);
+    mkdirSync(dir, { recursive: true });
+    const messages = record.messages.map((message) => ({
+      role: message.role,
+      content: message.content,
+      ...(message.activitySummary ? { activitySummary: message.activitySummary } : {}),
+    }));
+    const metadata: ConversationMetadata = {
+      ...record.metadata,
+      title: record.metadata.title === "Untitled conversation" ? titleFromMessages(record.messages) : record.metadata.title,
+      updatedAt: this.now().toISOString(),
+      messageCount: messages.length,
+    };
+    atomicWriteJson(join(dir, "messages.json"), messages);
+    atomicWriteJson(join(dir, "metadata.json"), metadata);
+  }
+
+  load(id: string): ConversationRecord | null {
+    try {
+      const dir = this.conversationDir(id);
+      const messages = parseMessages(JSON.parse(readFileSync(join(dir, "messages.json"), "utf8")));
+      if (!messages) throw new Error("messages.json is not a valid conversation message array");
+      let metadata: ConversationMetadata | null = null;
+      const metadataPath = join(dir, "metadata.json");
+      if (existsSync(metadataPath)) {
+        metadata = parseMetadata(JSON.parse(readFileSync(metadataPath, "utf8")), id);
+      }
+      const timestamp = this.now().toISOString();
+      metadata ??= {
+        version: 1,
+        id,
+        title: titleFromMessages(messages),
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        providerId: null,
+        modelId: "unknown",
+        backendKind: null,
+        messageCount: messages.length,
+      };
+      metadata = { ...metadata, messageCount: messages.length };
+      return { metadata, messages };
+    } catch (error) {
+      this.onDiagnostic(`Skipped conversation ${id}: ${error instanceof Error ? error.message : "invalid data"}`);
+      return null;
+    }
+  }
+
+  list(): ConversationListEntry[] {
+    if (!existsSync(this.rootDir)) return [];
+    const entries: ConversationListEntry[] = [];
+    let directoryEntries;
+    try {
+      directoryEntries = readdirSync(this.rootDir, { withFileTypes: true });
+    } catch (error) {
+      this.onDiagnostic(`Unable to list conversations: ${error instanceof Error ? error.message : "filesystem error"}`);
+      return [];
+    }
+    for (const entry of directoryEntries) {
+      if (!entry.isDirectory() || !isSafeConversationId(entry.name)) continue;
+      const dir = join(this.rootDir, entry.name);
+      try {
+        const metadataPath = join(dir, "metadata.json");
+        if (existsSync(metadataPath)) {
+          const metadata = parseMetadata(JSON.parse(readFileSync(metadataPath, "utf8")), entry.name);
+          if (metadata) {
+            entries.push(metadata);
+            continue;
+          }
+        }
+        const record = this.load(entry.name);
+        if (record) entries.push(record.metadata);
+      } catch (error) {
+        this.onDiagnostic(`Skipped conversation ${entry.name}: ${error instanceof Error ? error.message : "invalid metadata"}`);
+      }
+    }
+    return entries.sort((left, right) => {
+      const updated = right.updatedAt.localeCompare(left.updatedAt);
+      return updated !== 0 ? updated : right.id.localeCompare(left.id);
+    });
+  }
+}