@blackbelt-technology/pi-agent-dashboard 0.4.6 → 0.5.0

package/packages/shared/src/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Barrel re-exports for selected shared symbols. Most consumers import
+ * directly from per-file paths (`@blackbelt-technology/pi-dashboard-shared/<file>.js`)
+ * via the package's `exports` map. This barrel exists for symbols that
+ * would otherwise be cumbersome to wire — currently the doctor core.
+ *
+ * Added by change: doctor-rich-output.
+ */
+export * from "./doctor-core.js";

package/packages/shared/src/installable-list.ts

@@ -0,0 +1,152 @@
+/**
+ * installable-list.ts — types and helpers for ~/.pi/dashboard/installable.json.
+ *
+ * This file describes the set of packages the dashboard needs installed.
+ * Electron seeds the file on first run; Bridge / Standalone ignore it (file-absent
+ * path is a no-op in the server bootstrap). The server reads it during bootstrap.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export type InstallableKind = "npm" | "pi-extension";
+
+export interface InstallablePackage {
+  name: string;
+  /** Semver range or "*". */
+  version: string;
+  required: boolean;
+  kind: InstallableKind;
+  deprecated?: boolean;
+  defaultOff?: boolean;
+}
+
+export interface InstallableList {
+  version: string;
+  packages: InstallablePackage[];
+}
+
+export interface MergeResult {
+  list: InstallableList;
+  warnings: string[];
+}
+
+const VALID_KINDS: ReadonlySet<string> = new Set<InstallableKind>(["npm", "pi-extension"]);
+
+function defaultConfigDir(): string {
+  return path.join(os.homedir(), ".pi", "dashboard");
+}
+
+function installablePath(configDir: string): string {
+  return path.join(configDir, "installable.json");
+}
+
+/**
+ * Read `~/.pi/dashboard/installable.json` (or `configDir/installable.json`).
+ *
+ * Returns `null` when the file is absent. Logs a warning and drops entries
+ * with an invalid `kind` field. Does NOT create the file.
+ */
+export async function readInstallableList(
+  configDir?: string,
+): Promise<InstallableList | null> {
+  const dir = configDir ?? defaultConfigDir();
+  const filePath = installablePath(dir);
+
+  let raw: string;
+  try {
+    raw = await fs.promises.readFile(filePath, "utf-8");
+  } catch (err: any) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+
+  const parsed = JSON.parse(raw) as InstallableList;
+
+  const validPackages: InstallablePackage[] = [];
+  for (const pkg of parsed.packages ?? []) {
+    if (!VALID_KINDS.has(pkg.kind)) {
+      console.warn(
+        `[installable-list] Dropping entry "${pkg.name}" with unknown kind "${pkg.kind}".`,
+      );
+      continue;
+    }
+    validPackages.push(pkg);
+  }
+
+  return { version: parsed.version, packages: validPackages };
+}
+
+/**
+ * Atomically write `list` to `configDir/installable.json`.
+ * Writes a temp file then renames so readers never see a partial write.
+ */
+export async function writeInstallableList(
+  list: InstallableList,
+  configDir?: string,
+): Promise<void> {
+  const dir = configDir ?? defaultConfigDir();
+  const filePath = installablePath(dir);
+  const tmpPath = filePath + ".tmp." + process.pid;
+
+  await fs.promises.mkdir(dir, { recursive: true });
+  await fs.promises.writeFile(tmpPath, JSON.stringify(list, null, 2), "utf-8");
+  await fs.promises.rename(tmpPath, filePath);
+}
+
+/**
+ * Pure merge: reconcile a user's `existing` list against the `bundled` defaults.
+ *
+ * Rules:
+ * - Package in both: keep user's pinned version (user wins); emit a warning when
+ *   the bundled default differs.
+ * - Package in existing but NOT in bundled: keep it, set `deprecated: true`, emit warning.
+ * - New `required: true` package in bundled: add it.
+ * - New `required: false` package in bundled: add it with `defaultOff: true`.
+ * - Result version marker comes from `bundled.version`.
+ */
+export function mergeInstallableList(
+  existing: InstallableList,
+  bundled: InstallableList,
+): MergeResult {
+  const warnings: string[] = [];
+  const bundledMap = new Map(bundled.packages.map((p) => [p.name, p]));
+  const existingMap = new Map(existing.packages.map((p) => [p.name, p]));
+
+  const merged: InstallablePackage[] = [];
+
+  // Walk existing packages.
+  for (const pkg of existing.packages) {
+    const bundledPkg = bundledMap.get(pkg.name);
+    if (!bundledPkg) {
+      // Dropped in bundled → deprecate.
+      warnings.push(
+        `Package "${pkg.name}" is no longer in the bundled list and has been marked deprecated.`,
+      );
+      merged.push({ ...pkg, deprecated: true });
+    } else {
+      // Present in both → user version wins.
+      if (pkg.version !== bundledPkg.version) {
+        warnings.push(
+          `Package "${pkg.name}" is pinned at "${pkg.version}" (bundled default: "${bundledPkg.version}"). User pin preserved.`,
+        );
+      }
+      merged.push({ ...pkg });
+    }
+  }
+
+  // Walk bundled packages not yet in existing.
+  for (const bundledPkg of bundled.packages) {
+    if (existingMap.has(bundledPkg.name)) continue;
+    if (!bundledPkg.required) {
+      merged.push({ ...bundledPkg, defaultOff: true });
+    } else {
+      merged.push({ ...bundledPkg });
+    }
+  }
+
+  return {
+    list: { version: bundled.version, packages: merged },
+    warnings,
+  };
+}

package/packages/shared/src/launch-source-flag.ts

@@ -0,0 +1,14 @@
+/**
+ * Feature flag for the LaunchSource V2 resolver.
+ * Default: true (Phase C cutover). Set LAUNCH_SOURCE_V2=false to revert to
+ * the legacy wizard + mode.json path for debugging.
+ *
+ * TODO: remove LAUNCH_SOURCE_V2 flag in follow-up change after Phase C ships
+ * without regressions for one release cycle. The flag and its CI matrix
+ * entry should be deleted at that point.
+ */
+export function isLaunchSourceV2Enabled(env: Record<string, string | undefined>): boolean {
+  const val = env["LAUNCH_SOURCE_V2"];
+  if (val === undefined) return true; // default ON in Phase C
+  return val === "true" || val === "1";
+}

package/packages/shared/src/launch-source-types.ts

@@ -0,0 +1,18 @@
+/**
+ * LaunchSource — discriminated union describing how the dashboard server was (or should be) started.
+ *
+ * "attach"      — a server is already running; Electron attaches to it.
+ * "devMonorepo" — running from a checked-out monorepo (dev workflow).
+ * "piExtension" — the pi bridge extension owns a server package in node_modules.
+ * "npmGlobal"   — `pi-dashboard` is installed globally via npm.
+ * "extracted"   — bundled Electron resources provide the server (managed install).
+ */
+
+export type SourceKind = "attach" | "devMonorepo" | "piExtension" | "npmGlobal" | "extracted";
+
+export type LaunchSource =
+  | { kind: "attach"; url: string; starter: "Bridge" | "Standalone" | "Electron" }
+  | { kind: "devMonorepo"; cliPath: string; cwd: string }
+  | { kind: "piExtension"; cliPath: string; cwd: string }
+  | { kind: "npmGlobal"; cliPath: string; cwd: string }
+  | { kind: "extracted"; cliPath: string; cwd: string; didExtract?: boolean };

package/packages/shared/src/openspec-activity-detector.ts

@@ -40,6 +40,22 @@ const CLI_ARCHIVE_RE = /openspec\s+archive\s+["']?([^\s"']+)["']?/;
 /** Regex to match openspec new change "name" (positional arg) */
 const CLI_NEW_CHANGE_RE = /openspec\s+new\s+change\s+["']?([^\s"']+)["']?/;
 
+/**
+ * OpenSpec change-slug shape: lowercase kebab-case, must start with a letter,
+ * max 64 characters. Mirrors the validation enforced by `openspec new change`.
+ *
+ * Single source of truth for any code that needs to gate a captured token
+ * before treating it as an OpenSpec change name (detector + auto-attach
+ * defense-in-depth in event-wiring.ts).
+ *
+ * See change: fix-uuid-rename-bug.
+ */
+const OPENSPEC_CHANGE_SLUG_RE = /^[a-z][a-z0-9-]{0,63}$/;
+
+export function isValidOpenSpecChangeSlug(name: string): boolean {
+  return OPENSPEC_CHANGE_SLUG_RE.test(name);
+}
+
 export function detectOpenSpecActivity(
   toolName: string,
   args: Record<string, unknown> | undefined,
@@ -63,7 +79,7 @@ export function detectOpenSpecActivity(
 
     // Check for openspec change file read → change name detection (passive)
     const changeMatch = path.match(CHANGE_PATH_RE);
-    if (changeMatch) {
+    if (changeMatch && isValidOpenSpecChangeSlug(changeMatch[1])) {
       return { changeName: changeMatch[1], isActive: false };
     }
 
@@ -75,7 +91,7 @@ export function detectOpenSpecActivity(
     if (!path) return null;
 
     const changeMatch = path.match(CHANGE_PATH_RE);
-    if (changeMatch) {
+    if (changeMatch && isValidOpenSpecChangeSlug(changeMatch[1])) {
       return { changeName: changeMatch[1], isActive: true };
     }
 
@@ -94,11 +110,13 @@ export function detectOpenSpecActivity(
       if (!match) return null;
 
       const name = match[1];
-      // Reject flag-shaped tokens (e.g. `--help`, `-h`). The CLI regex capture
-      // groups use `[^\s"']+` which would otherwise treat `--help` as a change
-      // name and trigger downstream auto-attach + auto-rename.
-      // See change: fix-openspec-flag-rename-bug.
-      if (name.startsWith("-")) return null;
+      // Reject any token that is not a valid OpenSpec change slug. Subsumes the
+      // earlier `-`-prefix guard (a leading `-` fails the `[a-z]` first-char
+      // class) and additionally rejects UUIDs, mixed-case, underscored, or
+      // overlong tokens that the CLI regexes' `[^\s"']+` capture group would
+      // otherwise pass through into auto-attach + auto-rename.
+      // See changes: fix-openspec-flag-rename-bug, fix-uuid-rename-bug.
+      if (!isValidOpenSpecChangeSlug(name)) return null;
 
       return { changeName: name, isActive: true };
     }

package/packages/shared/src/platform/detached-spawn.ts

@@ -47,10 +47,18 @@ export interface SpawnDetachedOptions {
   /** Environment for the child. Defaults to `process.env` via Node. */
   env?: NodeJS.ProcessEnv;
   /**
-   * Optional file descriptor for stderr. When omitted, stderr is "ignore".
+   * Optional file descriptor for combined stdout + stderr. When omitted,
+   * BOTH stdout and stderr are "ignore".
+   *
    * Caller is responsible for `fs.openSync(logPath, "a")` and closing the
    * parent's copy after spawn (the child retains its dup via stdio
    * inheritance). File fds survive parent death; pipes do not.
+   *
+   * Routing both streams to a single fd matches what the standalone CLI
+   * (`packages/server/src/cli.ts`) does directly with raw `spawn()`. Prior
+   * to change `fix-electron-extracted-jiti-and-stdio-capture`, only stderr
+   * was captured and clean-startup `console.log` output was silently
+   * dropped (resulting in 0-byte server.log files).
    */
   logFd?: number;
   /**
@@ -123,7 +131,10 @@ export interface SpawnDetachedResult {
  */
 export async function spawnDetached(opts: SpawnDetachedOptions): Promise<SpawnDetachedResult> {
   const stdioIn: "ignore" | "pipe" = opts.stdinMode ?? "ignore";
-  const stdio: ("ignore" | "pipe" | number)[] = [stdioIn, "ignore", opts.logFd ?? "ignore"];
+  // logFd applies to BOTH stdout and stderr. See JSDoc on logFd above and
+  // change: fix-electron-extracted-jiti-and-stdio-capture.
+  const outFd: "ignore" | number = opts.logFd ?? "ignore";
+  const stdio: ("ignore" | "pipe" | number)[] = [stdioIn, outFd, outFd];
 
   let child: ChildProcess;
   let spawnError: string | null = null;

package/packages/shared/src/platform/managed-node-path.ts

@@ -0,0 +1,77 @@
+/**
+ * Prepend the managed Node runtime directory to a child-process `PATH`.
+ *
+ * The managed Node lives at `<managedDir>/node/` (Windows: binaries at
+ * the root; Unix: binaries under `bin/`). When present, every spawn the
+ * dashboard controls SHALL inherit that directory at the front of its
+ * `PATH` so plain `node` / `npm` invocations inside the child process
+ * resolve to the managed runtime.
+ *
+ * Pure helper: never mutates `process.env`, returns a distinct cloned
+ * env object, no-ops when the managed runtime is absent.
+ *
+ * See change: embed-managed-node-runtime (spec: managed-node-runtime,
+ * Requirement: Spawned children inherit managed Node on PATH).
+ */
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { getManagedDir, type ManagedPathsEnv } from "../managed-paths.js";
+
+/**
+ * Resolve the bin directory inside the managed Node tree.
+ *   Windows: `<managedDir>/node`        (node.exe + npm.cmd live at root)
+ *   Unix:    `<managedDir>/node/bin`    (node, npm, npx live under bin/)
+ *
+ * `platform` defaults to `process.platform`; tests inject `"win32"` from
+ * a Linux host to exercise the Windows layout.
+ */
+export function getManagedNodeBinDir(
+  env?: ManagedPathsEnv,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  const root = path.join(getManagedDir(env), "node");
+  return platform === "win32" ? root : path.join(root, "bin");
+}
+
+/** Path to the managed `node` / `node.exe` binary. */
+export function getManagedNodeBinary(
+  env?: ManagedPathsEnv,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  const bin = getManagedNodeBinDir(env, platform);
+  return path.join(bin, platform === "win32" ? "node.exe" : "node");
+}
+
+/** True iff the managed Node runtime is installed (binary exists). */
+export function isManagedNodePresent(
+  env?: ManagedPathsEnv,
+  platform: NodeJS.Platform = process.platform,
+): boolean {
+  return existsSync(getManagedNodeBinary(env, platform));
+}
+
+/**
+ * Return a shallow-cloned env with the managed Node bin directory
+ * prepended to `PATH`. No-op (still returns a clone) when the managed
+ * runtime is not installed or its directory is already on PATH.
+ *
+ * Never mutates the input env or `process.env`.
+ */
+export function prependManagedNodeToPath(
+  baseEnv: NodeJS.ProcessEnv = process.env,
+  managedPathsEnv?: ManagedPathsEnv,
+): NodeJS.ProcessEnv {
+  const cloned: NodeJS.ProcessEnv = { ...baseEnv };
+  if (!isManagedNodePresent(managedPathsEnv)) return cloned;
+
+  const dir = getManagedNodeBinDir(managedPathsEnv);
+  const currentPath = cloned.PATH ?? "";
+  // Avoid duplicate prepends when the dir is already at the head; cheap
+  // string contains check matches `buildSpawnEnv` style.
+  if (currentPath.split(path.delimiter).includes(dir)) return cloned;
+
+  cloned.PATH = currentPath
+    ? `${dir}${path.delimiter}${currentPath}`
+    : dir;
+  return cloned;
+}

package/packages/shared/src/protocol.ts

@@ -1,7 +1,7 @@
 /**
  * Extension ↔ Server WebSocket protocol messages.
  */
-import type { DashboardEvent, CommandInfo, FlowInfo, SessionSource, ImageContent, FileEntry, TurnUsage, ContextUsage, ModelInfo, PiSessionInfo, OpenSpecPhase, RoleInfo, ExtensionUiModule, DecoratorDescriptor } from "./types.js";
+import type { DashboardEvent, CommandInfo, FlowInfo, SessionSource, ImageContent, FileEntry, TurnUsage, ContextUsage, ModelInfo, ProviderInfo, PiSessionInfo, OpenSpecPhase, RoleInfo, ExtensionUiModule, DecoratorDescriptor } from "./types.js";
 
 // ── Extension → Server ──────────────────────────────────────────────
 
@@ -151,6 +151,17 @@ export interface ModelsListMessage {
   models: ModelInfo[];
 }
 
+/**
+ * Bridge -> server: pi's live provider catalogue derived from
+ * `modelRegistry.authStorage` + `modelRegistry.getProviderDisplayName`.
+ * Sent alongside ModelsListMessage. See change: replace-hardcoded-provider-lists.
+ */
+export interface ProvidersListMessage {
+  type: "providers_list";
+  sessionId: string;
+  providers: ProviderInfo[];
+}
+
 export interface SessionNameUpdateMessage {
   type: "session_name_update";
   sessionId: string;
@@ -286,6 +297,27 @@ export interface ExtUiDecoratorMessage {
   removed?: boolean;
 }
 
+// ── Markdown asset inlining (chat-markdown-local-images-and-math) ──
+//
+// Bridge → server: register a base64-encoded image asset under a content
+// hash. Emitted by the bridge BEFORE the `message_update` / `message_end`
+// event whose text references `pi-asset:<hash>`. Bytes ride exactly once
+// per (session, hash) pair — subsequent references in later events emit
+// no further `asset_register`. Persisted in `events.jsonl` alongside the
+// referencing message events so reconnect/replay rebuilds the per-session
+// asset registry deterministically. See change:
+// chat-markdown-local-images-and-math.
+export interface AssetRegisterMessage {
+  type: "asset_register";
+  sessionId: string;
+  /** Content hash (sha256 truncated to 16 hex chars). */
+  hash: string;
+  /** MIME type (one of the bridge's image allowlist). */
+  mimeType: string;
+  /** Base64-encoded file bytes. */
+  data: string;
+}
+
 export type ExtensionToServerMessage =
   | SessionRegisterMessage
   | SessionUnregisterMessage
@@ -299,6 +331,7 @@ export type ExtensionToServerMessage =
   | JjStateUpdateMessage
   | SessionNameUpdateMessage
   | ModelsListMessage
+  | ProvidersListMessage
   | ModelUpdateMessage
   | SessionsListExtensionMessage
   | ExtensionUiDismissMessage
@@ -312,7 +345,8 @@ export type ExtensionToServerMessage =
   | ProcessListMessage
   | UiModulesListMessage
   | UiDataListMessage
-  | ExtUiDecoratorMessage;
+  | ExtUiDecoratorMessage
+  | AssetRegisterMessage;
 
 // ── Server → Extension ──────────────────────────────────────────────
 
@@ -357,6 +391,15 @@ export interface RequestModelsMessage {
   sessionId: string;
 }
 
+/**
+ * Server -> bridge: ask the bridge to push a fresh providers_list.
+ * See change: replace-hardcoded-provider-lists.
+ */
+export interface RequestProvidersMessage {
+  type: "request_providers";
+  sessionId: string;
+}
+
 export interface SetThinkingLevelMessage {
   type: "set_thinking_level";
   sessionId: string;
@@ -514,6 +557,7 @@ export type ServerToExtensionMessage =
   | ListFilesMessage
   | RenameSessionExtensionMessage
   | RequestModelsMessage
+  | RequestProvidersMessage
   | SetThinkingLevelMessage
   | ListSessionsExtensionMessage
   | SetModelMessage

package/packages/shared/src/rest-api.ts

@@ -255,6 +255,10 @@ export interface ProviderAuthStatus {
   authenticated: boolean;
   expires?: number;
   maskedKey?: string;
+  /** Name of the env var pi-ai consults for this provider (api-key rows only). */
+  envVar?: string;
+  /** True when configured via ambient credential chain (AWS profile / GCP ADC). */
+  ambient?: boolean;
 }
 
 export interface AuthorizeResponse {

package/packages/shared/src/skill-block-parser.ts

@@ -0,0 +1,115 @@
+/**
+ * Skill block parser & builder.
+ *
+ * Pi's `_expandSkillCommand` (in `@mariozechner/pi-coding-agent`) wraps skill
+ * expansions in a `<skill name="..." location="...">…</skill>\n\nargs` envelope.
+ * The dashboard's bridge expander (`packages/extension/src/prompt-expander.ts`)
+ * aligns to the same byte format. This module is the single source of truth for
+ * both producing and recovering that envelope.
+ *
+ * See change: render-skill-invocations-collapsibly.
+ */
+
+export interface SkillBlock {
+  /** Bare skill name (no `skill:` prefix), e.g. `"openspec-explore"`. */
+  name: string;
+  /** Absolute path to `SKILL.md`. */
+  location: string;
+  /**
+   * Skill body with the `References are relative to <baseDir>.\n\n` preamble
+   * stripped — what users see in the card. The preamble is bridge-internal
+   * orientation for the LLM and is not interesting to users.
+   *
+   * Pi's own `parseSkillBlock` returns the unstripped form (calls it `content`).
+   * We strip here so the renderer doesn't have to. If the preamble shape ever
+   * changes upstream and stripping fails, `body` falls back to the captured
+   * content verbatim.
+   */
+  body: string;
+  /** User text after the skill name. `undefined` when no args were typed. */
+  args: string | undefined;
+  /** Slash-command form: `"/skill:" + name + (args ? " " + args : "")`. */
+  condensed: string;
+}
+
+/**
+ * Anchored, non-greedy match of a wrapped skill block.
+ *
+ * Why anchored: prevents a literal `<skill>` substring elsewhere in user text
+ * from matching. Why non-greedy + optional trailing args at end-of-string:
+ * forces the regex engine to extend the body to the last valid
+ * `\n</skill>(\n\nargs)?$` boundary, so SKILL.md bodies that document the
+ * `<skill>` tag (e.g. include the literal text in code samples) do not
+ * terminate the match prematurely.
+ */
+const SKILL_BLOCK_RE =
+  /^<skill name="([^"]+)" location="([^"]+)">\n([\s\S]*?)\n<\/skill>(?:\n\n([\s\S]+))?$/;
+
+/**
+ * Parse a skill block from message text. Returns `null` when the input is not
+ * a well-formed skill envelope.
+ */
+/**
+ * Strip the `References are relative to <baseDir>.\n\n` preamble from a captured
+ * `<skill>` content block. Returns the stripped body, or the input unchanged if
+ * the preamble shape doesn't match.
+ */
+function stripReferencesPreamble(content: string): string {
+  const m = content.match(/^References are relative to [^\n]+\.\n\n([\s\S]*)$/);
+  return m ? m[1] : content;
+}
+
+export function parseSkillBlock(text: string): SkillBlock | null {
+  const m = text.match(SKILL_BLOCK_RE);
+  if (!m) return null;
+  const name = m[1];
+  const location = m[2];
+  const body = stripReferencesPreamble(m[3]);
+  const args = m[4];
+  const condensed = `/skill:${name}${args ? " " + args : ""}`;
+  return { name, location, body, args, condensed };
+}
+
+export interface BuildSkillBlockArgs {
+  /** Bare skill name (no `skill:` prefix). */
+  name: string;
+  /** Absolute path to `SKILL.md`. */
+  filePath: string;
+  /** Skill base directory — `dirname(filePath)`. */
+  baseDir: string;
+  /** Skill body, frontmatter already stripped. Should be `.trim()`-ed. */
+  body: string;
+  /** Optional user-typed args appended after the closing tag. */
+  userArgs?: string;
+}
+
+/**
+ * Build a skill block in the exact byte format pi's `_expandSkillCommand`
+ * produces. The output is byte-identical to pi's output for the same inputs;
+ * `parseSkillBlock(buildSkillBlock(x))` round-trips for `name`, `body`, `args`.
+ */
+export function buildSkillBlock(input: BuildSkillBlockArgs): string {
+  const wrapper =
+    `<skill name="${input.name}" location="${input.filePath}">\n` +
+    `References are relative to ${input.baseDir}.\n\n` +
+    `${input.body}\n` +
+    `</skill>`;
+  return input.userArgs ? `${wrapper}\n\n${input.userArgs}` : wrapper;
+}
+
+/**
+ * Condense a user-message content string for `firstMessage` / display purposes.
+ *
+ * If `text` parses as a `<skill>` envelope, returns the slash-command form
+ * (`/skill:name args`) truncated to `maxLen` chars. Otherwise returns
+ * `text.slice(0, maxLen)`. Used by session-scanner / session-discovery so the
+ * 200-char `firstMessage` shows the recognisable slash form instead of the
+ * front of an opaque wrapper.
+ *
+ * See change: render-skill-invocations-collapsibly.
+ */
+export function condenseForFirstMessage(text: string, maxLen: number): string {
+  const block = parseSkillBlock(text);
+  if (block) return block.condensed.slice(0, maxLen);
+  return text.slice(0, maxLen);
+}