nolo-cli 0.1.37 → 0.1.39

package/dialogCommands.ts

@@ -14,6 +14,15 @@ import {
   readLiveDbRecordAfterTombstoneMerge,
 } from "./globalRecordOperations";
 
+type ReadSource = "http" | "local-db-fallback";
+
+type HttpAttempt = {
+  base: string;
+  ok: boolean;
+  status?: number;
+  message?: string;
+};
+
 type ListedDialog = {
   id: string;
   dbKey: string;
@@ -36,6 +45,7 @@ const VALUE_FLAGS = new Set([
   "--space",
   "--space-id",
   "--token",
+  "--user",
 ]);
 
 function hasFlag(args: string[], flag: string) {
@@ -196,6 +206,411 @@ Deletes are global across the selected/profile server plus known Nolo cluster pe
 `);
 }
 
+function printReadUsage(output: { write(chunk: string): unknown }) {
+  output.write(`Usage:
+  nolo dialog read <dialogId|dialogKey|dialogUrl> [limit]
+
+Options:
+  --server <url>  Prefer this server when reading by raw dialog id.
+  --token <jwt>   Override AUTH_TOKEN.
+  --user <userId> Override dialog owner for raw dialog ids.
+
+Reads dialog metadata and messages as JSON.
+`);
+}
+
+function printStatusUsage(output: { write(chunk: string): unknown }) {
+  output.write(`Usage:
+  nolo dialog status <dialogId|dialogKey|dialogUrl>
+
+Options:
+  --server <url>  Prefer this server when reading by raw dialog id.
+  --token <jwt>   Override AUTH_TOKEN.
+  --user <userId> Override dialog owner for raw dialog ids.
+
+Prints compact dialog run status and next-step hints.
+`);
+}
+
+function isHelpArg(value?: string) {
+  return value === "-h" || value === "--help";
+}
+
+function readDialogLimitArg(args: string[], fallback: number) {
+  const explicit = readOption(args, "--limit");
+  const positional = args.find((value, index) =>
+    index > 0 && /^\d+$/.test(value) && args[index - 1] !== "--limit"
+  );
+  const raw = explicit ?? positional;
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function readDialogOwnerId(args: string[], env: Record<string, string | undefined>, authToken: string) {
+  return readOption(args, "--user") ??
+    env.USER_ID ??
+    parseUserIdFromAuthToken(authToken) ??
+    "";
+}
+
+function resolveDialogReadTarget(args: string[], env: Record<string, string | undefined>, authToken: string) {
+  const rawInput = readFirstPositional(args);
+  if (!rawInput) return null;
+  const preferredServer = readOption(args, "--server") ?? readOption(args, "--server-url");
+  const ownerFallback = readDialogOwnerId(args, env, authToken);
+
+  const raw = rawInput.trim();
+  if (raw.startsWith("http://") || raw.startsWith("https://")) {
+    const url = new URL(raw);
+    const match = url.pathname.match(DIALOG_PATH_RE);
+    if (!match) throw new Error(`Unsupported dialog URL path: ${url.pathname}`);
+    const [, spaceId, ownerId, dialogId] = match;
+    const base = preferredServer ?? env.READ_DIALOG_BASE ?? url.origin;
+    return {
+      base,
+      dialogId,
+      dialogKey: `dialog-${ownerId}-${dialogId}`,
+      userId: ownerId,
+      spaceId: spaceId ? decodeURIComponent(spaceId) : undefined,
+    };
+  }
+
+  if (raw.startsWith("dialog-")) {
+    const dialogId = getDialogIdFromKey(raw);
+    const ownerId = raw.slice("dialog-".length, Math.max("dialog-".length, raw.length - dialogId.length - 1));
+    return {
+      base: preferredServer ?? env.READ_DIALOG_BASE ?? resolveServerUrl(args, env),
+      dialogId,
+      dialogKey: raw,
+      userId: ownerId || ownerFallback,
+    };
+  }
+
+  if (!DIALOG_ID_RE.test(raw)) {
+    throw new Error(`Unsupported dialog id: ${raw}`);
+  }
+
+  if (!ownerFallback) {
+    throw new Error("raw dialog ids require an auth token userId or --user");
+  }
+  return {
+    base: preferredServer ?? env.READ_DIALOG_BASE ?? resolveServerUrl(args, env),
+    dialogId: raw,
+    dialogKey: `dialog-${ownerFallback}-${raw}`,
+    userId: ownerFallback,
+  };
+}
+
+function toToolName(value: unknown) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function countByName(values: string[]) {
+  return values.reduce<Record<string, number>>((acc, value) => {
+    acc[value] = (acc[value] ?? 0) + 1;
+    return acc;
+  }, {});
+}
+
+function uniq(values: string[]) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function parseJsonObject(raw: unknown): Record<string, any> | null {
+  if (typeof raw !== "string" || !raw.trim()) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function deriveWrittenFiles(toolMessages: any[]) {
+  const writeToolNames = new Set(["applyEdit", "applyLineEdits", "writeFile", "createDoc", "updateDoc"]);
+  const files: string[] = [];
+  for (const message of toolMessages) {
+    const toolName = toToolName(message?.toolName ?? message?.name);
+    if (!writeToolNames.has(toolName)) continue;
+    const payload = message?.toolPayload ?? {};
+    const content = parseJsonObject(message?.content);
+    for (const candidate of [payload?.input?.filePath, payload?.response?.filePath, content?.filePath]) {
+      const normalized = typeof candidate === "string" ? candidate.trim() : "";
+      if (normalized) files.push(normalized);
+    }
+  }
+  return uniq(files);
+}
+
+function deriveToolErrors(toolMessages: any[]) {
+  const errors: string[] = [];
+  for (const message of toolMessages) {
+    const toolName = toToolName(message?.toolName ?? message?.name);
+    const payload = message?.toolPayload ?? {};
+    const content = parseJsonObject(message?.content);
+    if (payload?.status === "failed" || content?.ok === false || content?.applied === false || content?.success === false) {
+      errors.push(toolName || "unknown-tool");
+    }
+  }
+  return uniq(errors);
+}
+
+function isLocalBaseUrl(base: string) {
+  try {
+    const url = new URL(base);
+    return url.hostname === "127.0.0.1" || url.hostname === "localhost";
+  } catch {
+    return false;
+  }
+}
+
+async function readDialogOverHttp(args: {
+  base: string;
+  dialogKey: string;
+  dialogId: string;
+  limit: number;
+  authToken: string;
+  fetchImpl: typeof fetch;
+}) {
+  const authHeaders = {
+    Authorization: `Bearer ${args.authToken}`,
+    "Content-Type": "application/json",
+  };
+  const readViaBridge = async () => {
+    const bridgeRes = await args.fetchImpl(`${args.base}/api/dialog-read`, {
+      method: "POST",
+      headers: authHeaders,
+      body: JSON.stringify({
+        dialogKey: args.dialogKey,
+        dialogId: args.dialogId,
+        limit: args.limit,
+      }),
+    });
+    if (!bridgeRes.ok) {
+      throw Object.assign(new Error(`dialog read bridge failed: HTTP ${bridgeRes.status}`), {
+        status: bridgeRes.status,
+        base: args.base,
+      });
+    }
+    const payload = await bridgeRes.json();
+    if (!payload?.ok) {
+      throw Object.assign(new Error(`dialog read bridge failed: ${payload?.error ?? "unknown error"}`), {
+        status: 500,
+        base: args.base,
+      });
+    }
+    return {
+      meta: payload.meta,
+      msgs: payload.msgs,
+      source: "http" as ReadSource,
+    };
+  };
+
+  const metaRes = await args.fetchImpl(
+    `${args.base}/api/v1/db/read/${encodeURIComponent(args.dialogKey)}`,
+    { headers: { Authorization: `Bearer ${args.authToken}` } }
+  );
+  if (!metaRes.ok) {
+    if (metaRes.status === 401 || metaRes.status === 403) return readViaBridge();
+    throw Object.assign(new Error(`read dialog meta failed: HTTP ${metaRes.status}`), {
+      status: metaRes.status,
+      base: args.base,
+    });
+  }
+  const meta = await metaRes.json();
+
+  const msgsRes = await args.fetchImpl(`${args.base}/rpc/getConvMsgs`, {
+    method: "POST",
+    headers: authHeaders,
+    body: JSON.stringify({ dialogId: args.dialogId, limit: args.limit }),
+  });
+  if (!msgsRes.ok) {
+    if (msgsRes.status === 401 || msgsRes.status === 403) return readViaBridge();
+    throw Object.assign(new Error(`read dialog messages failed: HTTP ${msgsRes.status}`), {
+      status: msgsRes.status,
+      base: args.base,
+    });
+  }
+  return {
+    meta,
+    msgs: await msgsRes.json(),
+    source: "http" as ReadSource,
+  };
+}
+
+async function tryHttpDialogCandidates(args: {
+  bases: string[];
+  dialogKey: string;
+  dialogId: string;
+  limit: number;
+  authToken: string;
+  fetchImpl: typeof fetch;
+}) {
+  const attempts: HttpAttempt[] = [];
+  for (const base of args.bases) {
+    try {
+      const result = await readDialogOverHttp({ ...args, base });
+      attempts.push({ base, ok: true });
+      return { ...result, resolvedBase: base, attempts };
+    } catch (error) {
+      attempts.push({
+        base,
+        ok: false,
+        status:
+          typeof error === "object" && error !== null && "status" in error
+            ? Number((error as any).status)
+            : undefined,
+        message: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+  throw Object.assign(new Error("All HTTP dialog reads failed"), { attempts });
+}
+
+async function readDialogFromLocalDb(dialogKey: string, dialogId: string, limit: number) {
+  const { readDialogFromLocalDb: readLocalDialog } = await import("./agent-runtime/localDialogRead");
+  const result = await readLocalDialog({ dialogKey, dialogId, limit });
+  return {
+    ...result,
+    source: "local-db-fallback" as ReadSource,
+  };
+}
+
+async function readDialogSnapshot(args: {
+  authToken: string;
+  base: string;
+  dialogId: string;
+  dialogKey: string;
+  fetchImpl: typeof fetch;
+  limit: number;
+}) {
+  const candidateBases = resolveServerCandidates({ NOLO_SERVER: args.base }, args.base);
+  let attempts: HttpAttempt[] = [];
+  try {
+    const result = await tryHttpDialogCandidates({
+      bases: candidateBases,
+      dialogKey: args.dialogKey,
+      dialogId: args.dialogId,
+      limit: args.limit,
+      authToken: args.authToken,
+      fetchImpl: args.fetchImpl,
+    });
+    return { ...result, candidateBases };
+  } catch (error) {
+    attempts =
+      typeof error === "object" && error !== null && "attempts" in error
+        ? ((error as any).attempts as HttpAttempt[])
+        : attempts;
+    const statuses = attempts.map((attempt) => attempt.status).filter((status): status is number => typeof status === "number");
+    const all404 = attempts.length > 0 && statuses.length === attempts.length && statuses.every((status) => status === 404);
+    const localhostCandidate = candidateBases.find(isLocalBaseUrl);
+    if (!localhostCandidate || all404) {
+      throw Object.assign(new Error(
+        all404
+          ? `dialog not found on tried servers: ${candidateBases.join(", ")}`
+          : `read dialog failed across candidates: ${attempts.map((attempt) => `${attempt.base} -> ${attempt.status ?? attempt.message}`).join("; ")}`
+      ), { attempts });
+    }
+    const fallback = await readDialogFromLocalDb(args.dialogKey, args.dialogId, args.limit);
+    return {
+      ...fallback,
+      resolvedBase: localhostCandidate,
+      attempts,
+      candidateBases,
+    };
+  }
+}
+
+function compact(value: unknown, max = 180) {
+  const text = typeof value === "string" ? value.trim() : "";
+  if (!text) return "";
+  return text.length > max ? `${text.slice(0, max - 3)}...` : text;
+}
+
+function renderCompactDialogStatus(snapshot: any) {
+  const checkpoint = snapshot.runtimeCheckpoint ?? {};
+  const checkpointStatus = typeof checkpoint.status === "string" ? checkpoint.status : null;
+  const status = snapshot.status ?? checkpointStatus ?? "unknown";
+  const state =
+    checkpointStatus === "done" || checkpointStatus === "completed" || status === "done" || status === "completed"
+      ? "done"
+      : checkpointStatus === "failed" || checkpointStatus === "error" || status === "failed" || status === "error"
+        ? "failed"
+        : status === "running" || status === "pending" || status === "queued"
+          ? "active"
+          : "unknown";
+  const tools = Array.isArray(snapshot.toolsUsed)
+    ? snapshot.toolsUsed.filter((tool: unknown): tool is string => typeof tool === "string" && tool.trim()).slice(0, 8)
+    : Array.isArray(checkpoint.lastToolNames)
+      ? checkpoint.lastToolNames.filter((tool: unknown): tool is string => typeof tool === "string" && tool.trim()).slice(0, 8)
+      : [];
+  const files = Array.isArray(snapshot.writtenFiles) && snapshot.writtenFiles.length
+    ? snapshot.writtenFiles.filter((file: unknown): file is string => typeof file === "string" && file.trim()).slice(0, 8)
+    : snapshot.artifacts && typeof snapshot.artifacts === "object" && Array.isArray(snapshot.artifacts.changedFiles ?? snapshot.artifacts.writtenFiles ?? snapshot.artifacts.files)
+      ? (snapshot.artifacts.changedFiles ?? snapshot.artifacts.writtenFiles ?? snapshot.artifacts.files)
+        .filter((file: unknown): file is string => typeof file === "string" && file.trim())
+        .slice(0, 8)
+      : [];
+  const subjectRefs = Array.isArray(snapshot.subjectRefs)
+    ? snapshot.subjectRefs
+      .map((ref: any) => {
+        const kind = typeof ref?.kind === "string" ? ref.kind.trim() : "";
+        const id = typeof ref?.id === "string" ? ref.id.trim() : "";
+        if (!kind || !id) return "";
+        const role = typeof ref?.role === "string" && ref.role.trim() ? `#${ref.role.trim()}` : "";
+        return `${kind}:${id}${role}`;
+      })
+      .filter(Boolean)
+      .slice(0, 8)
+    : [];
+  const toolErrors = Array.isArray(snapshot.toolErrors)
+    ? snapshot.toolErrors.filter((tool: unknown): tool is string => typeof tool === "string" && tool.trim()).slice(0, 8)
+    : [];
+  const checkpointUpdatedAt = typeof checkpoint.updatedAt === "number" || typeof checkpoint.updatedAt === "string"
+    ? Date.parse(String(checkpoint.updatedAt))
+    : NaN;
+  const activeHealth = state !== "active"
+    ? ""
+    : !snapshot.runtimeCheckpoint
+      ? "no-checkpoint"
+      : !Number.isFinite(checkpointUpdatedAt)
+        ? "checkpoint-without-updatedAt"
+        : Date.now() - checkpointUpdatedAt > 5 * 60_000
+          ? "stale-running"
+          : "running";
+  const errorMessage = compact(checkpoint.errorMessage ?? snapshot.errorMessage);
+  const lines = [
+    `dialog: ${snapshot.dialogId}`,
+    ...(snapshot.base ? [`base: ${snapshot.base}`] : []),
+    ...(snapshot.title ? [`title: ${snapshot.title}`] : []),
+    ...(snapshot.parentDialogId ? [`parentDialogId: ${snapshot.parentDialogId}`] : []),
+    ...(snapshot.rootDialogId ? [`rootDialogId: ${snapshot.rootDialogId}`] : []),
+    `status: ${status}`,
+    ...(checkpointStatus ? [`checkpoint: ${checkpointStatus}`] : []),
+    `state: ${state}`,
+    ...(activeHealth ? [`activeHealth: ${activeHealth}`] : []),
+    ...(typeof snapshot.durationMs === "number" ? [`durationMs: ${snapshot.durationMs}`] : []),
+    ...(snapshot.updatedAt ? [`updatedAt: ${snapshot.updatedAt}`] : []),
+    ...(snapshot.finishedAt ? [`finishedAt: ${snapshot.finishedAt}`] : []),
+    ...(compact(checkpoint.lastUserInput) ? [`lastUserInput: ${compact(checkpoint.lastUserInput)}`] : []),
+    ...(compact(checkpoint.lastAssistantText) ? [`lastAssistantText: ${compact(checkpoint.lastAssistantText)}`] : []),
+    ...(errorMessage ? [`error: ${errorMessage}`] : []),
+    ...(tools.length ? [`tools: ${tools.join(", ")}`] : []),
+    ...(files.length ? [`files: ${files.join(", ")}`] : []),
+    ...(subjectRefs.length ? [`subjects: ${subjectRefs.join(", ")}`] : []),
+    ...(toolErrors.length ? [`toolErrors: ${toolErrors.join(", ")}`] : []),
+    "",
+    "next:",
+    `- read full dialog: nolo dialog read ${snapshot.dialogId} 120`,
+  ];
+  if (state === "active") lines.push(`- poll again: nolo dialog status ${snapshot.dialogId}`);
+  else if (state === "failed") lines.push(`- inspect failure and rerun/continue with: nolo agent run <agent> --continue ${snapshot.dialogId} --msg "..."`);
+  else if (state === "done") lines.push("- use artifacts/files above for review, handoff, or alpha integration.");
+  else lines.push("- inspect meta/messages before deciding whether to continue or rerun.");
+  return `${lines.join("\n")}\n`;
+}
+
 async function readSpaceDialogRecords(args: {
   authToken: string;
   fetchImpl: typeof fetch;
@@ -232,6 +647,163 @@ async function readSpaceDialogRecords(args: {
   return { spaceId, records, failures };
 }
 
+export async function runDialogReadCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  if (isHelpArg(args[0])) {
+    printReadUsage(output);
+    return 0;
+  }
+
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write("[nolo] dialog read requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+
+  let target: ReturnType<typeof resolveDialogReadTarget>;
+  try {
+    target = resolveDialogReadTarget(args, env, authToken);
+  } catch (error) {
+    output.write(`[nolo] dialog read failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+  if (!target) {
+    printReadUsage(output);
+    return 1;
+  }
+
+  try {
+    const limit = readDialogLimitArg(args, 50);
+    const read = await readDialogSnapshot({
+      authToken,
+      base: target.base,
+      dialogId: target.dialogId,
+      dialogKey: target.dialogKey,
+      fetchImpl: deps.fetchImpl ?? fetch,
+      limit,
+    });
+    const orderedMsgs = Array.isArray(read.msgs) ? [...read.msgs].reverse() : read.msgs;
+    const lastAssistantMessage = Array.isArray(orderedMsgs)
+      ? [...orderedMsgs].reverse().find((message) => message?.role === "assistant" || message?.authorRole === "assistant")
+      : null;
+    const toolMessages = Array.isArray(orderedMsgs)
+      ? orderedMsgs.filter((message) => message?.role === "tool" || message?.authorRole === "tool")
+      : [];
+    const toolNamesFromMessages = toolMessages
+      .map((message) => toToolName(message?.toolName ?? message?.name))
+      .filter(Boolean);
+    const toolsUsed = Array.isArray(read.meta?.toolsUsed) && read.meta.toolsUsed.length > 0
+      ? read.meta.toolsUsed.map((tool: unknown) => toToolName(tool)).filter(Boolean)
+      : uniq(toolNamesFromMessages);
+    const writtenFiles = Array.isArray(read.meta?.writtenFiles) && read.meta.writtenFiles.length > 0
+      ? uniq(read.meta.writtenFiles.map((value: unknown) => (typeof value === "string" ? value.trim() : "")).filter(Boolean))
+      : deriveWrittenFiles(toolMessages);
+    const toolErrors = Array.isArray(read.meta?.toolErrors) && read.meta.toolErrors.length > 0
+      ? uniq(read.meta.toolErrors.map((value: unknown) => (typeof value === "string" ? value.trim() : "")).filter(Boolean))
+      : deriveToolErrors(toolMessages);
+
+    output.write(JSON.stringify({
+      source: read.source as ReadSource,
+      base: read.resolvedBase,
+      triedBases: read.candidateBases,
+      httpAttempts: read.attempts,
+      spaceId: target.spaceId,
+      dialogId: target.dialogId,
+      dialogKey: target.dialogKey,
+      userId: target.userId,
+      title: read.meta?.title ?? null,
+      cybots: Array.isArray(read.meta?.cybots) ? read.meta.cybots : [],
+      category: read.meta?.category ?? null,
+      inheritedFromDialogKey: read.meta?.inheritedFromDialogKey ?? null,
+      inheritedFromDialogTitle: read.meta?.inheritedFromDialogTitle ?? null,
+      parentDialogId: read.meta?.parentDialogId ?? null,
+      rootDialogId: read.meta?.rootDialogId ?? null,
+      status: read.meta?.status,
+      errorMessage: read.meta?.errorMessage ?? null,
+      runtimeCheckpoint: read.meta?.runtimeCheckpoint ?? null,
+      durationMs: read.meta?.durationMs,
+      finishedAt: read.meta?.finishedAt,
+      createdAt: read.meta?.createdAt,
+      updatedAt: read.meta?.updatedAt,
+      artifacts: read.meta?.artifacts ?? null,
+      writtenFiles,
+      toolsUsed,
+      toolErrors,
+      toolSummary: {
+        metaToolsCount: toolsUsed.length,
+        metaToolsUnique: [...new Set(toolsUsed)],
+        toolMessageCount: toolMessages.length,
+        toolNamesFromMessages: [...new Set(toolNamesFromMessages)],
+        toolMessageCountsByName: countByName(toolNamesFromMessages),
+      },
+      agentReply: read.meta?.agentReply ?? null,
+      messagesCount: Array.isArray(orderedMsgs) ? orderedMsgs.length : 0,
+      lastAssistantMessage,
+      messages: orderedMsgs,
+    }, null, 2));
+    output.write("\n");
+    return 0;
+  } catch (error) {
+    output.write(`[nolo] dialog read failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+}
+
+export async function runDialogStatusCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  if (isHelpArg(args[0])) {
+    printStatusUsage(output);
+    return 0;
+  }
+
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write("[nolo] dialog status requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+
+  let target: ReturnType<typeof resolveDialogReadTarget>;
+  try {
+    target = resolveDialogReadTarget(args, env, authToken);
+  } catch (error) {
+    output.write(`[nolo] dialog status failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+  if (!target) {
+    printStatusUsage(output);
+    return 1;
+  }
+
+  try {
+    const read = await readDialogSnapshot({
+      authToken,
+      base: target.base,
+      dialogId: target.dialogId,
+      dialogKey: target.dialogKey,
+      fetchImpl: deps.fetchImpl ?? fetch,
+      limit: 1,
+    });
+    output.write(renderCompactDialogStatus({
+      ...(read.meta ?? {}),
+      dialogId: target.dialogId,
+      dialogKey: target.dialogKey,
+      base: read.resolvedBase,
+    }));
+    return 0;
+  } catch (error) {
+    output.write(`[nolo] dialog status failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+}
+
 export async function runDialogListCommand(
   args: string[],
   deps: AgentCommandDeps = {}

package/dialogInternalCommandEntries.ts

@@ -3,11 +3,15 @@ import { createEnvCommand } from "./cliCommandFactories";
 import {
   runDialogDeleteCommand,
   runDialogListCommand,
+  runDialogReadCommand,
+  runDialogStatusCommand,
 } from "./dialogCommands";
 
 export function getDialogInternalCommandEntries(): CommandEntry[] {
   return [
     createEnvCommand(["dialog", "list"], "List dialogs", runDialogListCommand),
     createEnvCommand(["dialog", "delete"], "Delete a dialog", runDialogDeleteCommand),
+    createEnvCommand(["dialog", "read"], "Read a dialog", runDialogReadCommand),
+    createEnvCommand(["dialog", "status"], "Read compact dialog status", runDialogStatusCommand),
   ];
 }