@visual-z/xeno 0.8.2 → 0.8.3

package/src/store/secrets.ts

@@ -0,0 +1,44 @@
+/**
+ * The per-session vault behind `[[xeno-secret-N]]` placeholders (S.9).
+ *
+ * A separate append-only file, never a log event: projections, handoffs,
+ * exports and history pages read the log, so a value kept here cannot reach a
+ * model request or a shared transcript. 0600 like every session file. It is
+ * read back at start so a placeholder written by an earlier run still expands
+ * after a restart.
+ */
+import { copyFile, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { durableAppend } from "./atomic.ts";
+import type { SecretEntry } from "../core/secrets.ts";
+
+export const SECRETS_FILE = "secrets.jsonl";
+
+export async function readVault(dir: string): Promise<SecretEntry[]> {
+  let text: string;
+  try { text = await readFile(join(dir, SECRETS_FILE), "utf8"); }
+  catch (error) { if ((error as { code?: string }).code === "ENOENT") return []; throw error; }
+  const entries: SecretEntry[] = [];
+  for (const line of text.split("\n")) {
+    if (!line) continue;
+    // A torn final line from a crash loses that one entry; its placeholder then
+    // stays literal rather than expanding to something else.
+    try {
+      const value = JSON.parse(line) as Partial<SecretEntry>;
+      if (Number.isSafeInteger(value.n) && typeof value.value === "string" && typeof value.rule === "string" &&
+        !entries.some(entry => entry.n === value.n)) entries.push({ n: value.n!, value: value.value, rule: value.rule });
+    } catch { /* see above */ }
+  }
+  return entries;
+}
+
+export async function appendVault(dir: string, entries: readonly SecretEntry[]): Promise<void> {
+  if (entries.length === 0) return;
+  await durableAppend(join(dir, SECRETS_FILE), entries.map(entry => JSON.stringify(entry) + "\n").join(""));
+}
+
+/** A fork's log carries the parent's placeholders, so it needs their values. */
+export async function copyVault(from: string, to: string): Promise<void> {
+  try { await copyFile(join(from, SECRETS_FILE), join(to, SECRETS_FILE)); }
+  catch (error) { if ((error as { code?: string }).code !== "ENOENT") throw error; }
+}

package/src/store/sessions.ts

@@ -35,6 +35,7 @@ import {
   readCursor,
   readCursorAt,
   readNode,
+  forkedAt,
   writeCursor,
   setParentSession,
   type Manifest,
@@ -44,6 +45,7 @@ import { replayContext } from "./replay.ts";
 import { recoverCut } from "./recovery.ts";
 import { planSessionEntry, type SessionEntryFlags } from "../core/session-entry.ts";
 import { assertNever } from "../core/exhaustive.ts";
+import type { LogEvent } from "../core/events.ts";
 import { resolveHistoryPosition } from "./session-position.ts";
 import { importSessionArchive } from "./session-archive.ts";
 
@@ -86,6 +88,10 @@ export type ListedSession =
       workspace?: string;
       parent_session?: string;
       text?: string;
+      /** Details only: whether any node holds a user event (fix-skip-empty-sessions). */
+      conversation?: boolean;
+      /** Details only, forks only: when the copy was made (fix-fork-start-time). */
+      forked_at?: string;
     }
   | {
       ok: false;
@@ -370,8 +376,7 @@ export async function resolveLogDir(
       return { logDir: created.path, created: true };
     }
     case "continue": {
-      const { sessions } = await listSessions(workspace, opts.sessionDir, Infinity);
-      const newest = sessions.find((s) => s.ok);
+      const newest = await newestConversation(workspace, opts.sessionDir);
       if (newest !== undefined) return { logDir: newest.path, created: false };
       break;
     }
@@ -399,7 +404,8 @@ export async function readListed(id: string, path: string, details?: { workspace
     if ((err as { code?: string }).code === "ENOENT") {
       return {
         ok: true, id, path,
-        name: null, model: null, node: null, events: 0, updated_at: null, ...(details ? { workspace: details.workspace } : {}),
+        name: null, model: null, node: null, events: 0, updated_at: null,
+        ...(details ? { workspace: details.workspace, conversation: await hasConversation(path) } : {}),
       };
     }
     return { ok: false, id, path, error: `${path} could not be read: ${(err as Error).message}` };
@@ -414,7 +420,8 @@ export async function readListed(id: string, path: string, details?: { workspace
   if (cursor === undefined) {
     return {
       ok: true, id, path,
-      name: null, model: null, node: null, events: 0, updated_at: null, ...(details ? { workspace: details.workspace } : {}),
+      name: null, model: null, node: null, events: 0, updated_at: null,
+      ...(details ? { workspace: details.workspace, conversation: await hasConversation(path) } : {}),
     };
   }
 
@@ -423,15 +430,18 @@ export async function readListed(id: string, path: string, details?: { workspace
   // bad tree is the same shape as a list that throws for one bad file.
   const events = (await readNode(path, cursor.node)).events.length;
   const text: string[] = [];
+  let conversation = false;
   if (details) for (const node of await listNodes(path)) {
     if (details.signal?.aborted) break;
     const read = await readNode(path, node);
     if (read.corrupt.length) throw new Error(`${path} has corrupt events`);
     for (const event of read.events) {
+      if (userActivity(event)) conversation = true;
       if (event.t === "user") text.push(event.text);
       else if (event.t === "assistant") for (const block of event.blocks) if (block.type === "text") text.push(block.text);
     }
   }
+  const forked = details ? await forkedAt(path) : null;
   return {
     ok: true,
     id,
@@ -441,11 +451,44 @@ export async function readListed(id: string, path: string, details?: { workspace
     node: cursor.node,
     events,
     updated_at: cursor.updated_at,
-    ...(details ? { workspace: cursor.workspace ?? details.workspace, text: text.join("\n"),
-      ...(manifest.parent_session ? { parent_session: manifest.parent_session } : {}) } : {}),
+    ...(details ? { workspace: cursor.workspace ?? details.workspace, text: text.join("\n"), conversation,
+      ...(manifest.parent_session ? { parent_session: manifest.parent_session } : {}),
+      ...(forked === null ? {} : { forked_at: forked }) } : {}),
   };
 }
 
+/**
+ * A session the user opened and left without a word still has a header,
+ * cursor and manifest: Session.start writes them before the first message.
+ * Pi avoids such files by not persisting until a message exists; xeno keeps
+ * its write order and filters on read instead, like Codex's resume picker,
+ * so -c and the pickers land on a conversation (fix-skip-empty-sessions).
+ * A shell command the user ran counts: it is their activity, not setup.
+ */
+function userActivity(event: LogEvent): boolean {
+  return event.t === "user" || event.t === "user_bash";
+}
+
+/**
+ * Stops at the first node holding user activity, so a real session costs one
+ * node read. An unreadable node counts as activity: hiding a session we
+ * cannot judge would silently skip it, while opening it reports the error.
+ */
+export async function hasConversation(path: string): Promise<boolean> {
+  for (const node of await listNodes(path)) {
+    try { if ((await readNode(path, node)).events.some(userActivity)) return true; }
+    catch { return true; }
+  }
+  return false;
+}
+
+/** What -c continues: the newest readable session the user actually spoke in. */
+export async function newestConversation(workspace: string, sessionDir?: string): Promise<Extract<ListedSession, { ok: true }> | undefined> {
+  const { sessions } = await listSessions(workspace, sessionDir, Infinity);
+  for (const session of sessions) if (session.ok && await hasConversation(session.path)) return session;
+  return undefined;
+}
+
 function byRecordedTime(a: ListedSession, b: ListedSession): number {
   const ta = a.ok ? a.updated_at : null;
   const tb = b.ok ? b.updated_at : null;

package/src/tui/ui/image-size.ts

@@ -26,9 +26,13 @@ export function imageCells(pixels: { readonly width: number; readonly height: nu
   return { cols: Math.max(1, Math.min(capCols, cols)), rows: Math.max(1, Math.min(capRows, rows)) };
 }
 
-/** Rows for pictures in the transcript: a quarter of the terminal, 4–12. Assumed, between OpenCode (≤8) and Grok (≤20). */
+/**
+ * Rows for pictures in the transcript: half the terminal, 4–20 (feat-tui-image-full-size).
+ * A quarter left a screenshot's text unreadable; 20 is Grok's ceiling, past which one picture
+ * pushes the conversation off screen. Assumed, not measured. Full size is a click away.
+ */
 export function transcriptImageRows(terminalRows: number): number {
-  return Math.max(4, Math.min(12, Math.floor(terminalRows / 4)));
+  return Math.max(4, Math.min(20, Math.floor(terminalRows / 2)));
 }
 
 /** Rows for the attachment strip above the input box: a sixth of the terminal, 3–6. Assumed. */

package/src/tui/ui/items.ts

@@ -8,7 +8,9 @@
 export type ToolStatus = "pending" | "ok" | "error";
 
 /** A picture the view may draw: its blob address, name and pixel size (from the log's ImageRef). */
-export interface ImageView { readonly sha256: string; readonly name: string; readonly width: number; readonly height: number }
+export interface ImageView { readonly sha256: string; readonly name: string; readonly width: number; readonly height: number;
+  /** The blob a click opens when it differs from `sha256`: what was attached, before any reduction for the model. */
+  readonly full?: string }
 
 export type ViewItem =
   | { readonly kind: "user"; readonly id: string; readonly rev: string; readonly text: string; readonly images?: readonly ImageView[]; readonly interrupted?: boolean }

package/src/tui/ui/pictures.ts

@@ -8,6 +8,10 @@
  * pictures are off, or the terminal can only draw block characters, the
  * row is a single muted line: `▣ shot.png · 1280×720   +2 more`.
  *
+ * A click on a drawn picture asks the source to open its full-size original
+ * (docs/tasks/feat-tui-image-full-size.md): a thumbnail cannot show a
+ * screenshot's text, the system viewer can.
+ *
  * The view never reads a file: the app's source loads and verifies bytes.
  */
 import { BoxRenderable, ImageRenderable, type CliRenderer, type ImageRenderProtocol, type NativeImage } from "@opentui/core";
@@ -28,6 +32,8 @@ export interface PictureSource {
   readonly reason?: string;
   /** The decoded picture for a blob, shared by every node that shows it, or its preparation failure. */
   load(sha256: string): Promise<PictureLoad>;
+  /** Show a blob at full size outside the terminal; absent where nothing can (tests, print mode). */
+  open?(sha256: string): void;
 }
 
 export type PictureLoad = { readonly kind: "ready"; readonly image: NativeImage } |
@@ -72,7 +78,7 @@ export class Pictures extends BoxRenderable {
         const size = imageCells(image, Math.min(each, source.widthCells), options.maxRows, source.cell);
         const picture = new ImageRenderable(ctx, { id: `${id}-${image.sha256.slice(0, 8)}-${serial++}`, width: size.cols, height: size.rows,
           fit: "fit", protocol: source.protocol, flexShrink: 0,
-          onLoad: () => { states[index] = "decoded"; if (!caption.isDestroyed) paintCaption(); },
+          onLoad: () => { states[index] = source.open ? "click to open" : "decoded"; if (!caption.isDestroyed) paintCaption(); },
           onError: () => { states[index] = "preview failed: decode"; picture.visible = false; if (!caption.isDestroyed) paintCaption(); } });
         void source.load(image.sha256).then(result => {
           if (picture.isDestroyed) return;
@@ -82,6 +88,13 @@ export class Pictures extends BoxRenderable {
           if (picture.isDestroyed) return;
           picture.visible = false; states[index] = "preview failed: decode"; paintCaption();
         });
+        const open = source.open;
+        if (open) {
+          // Same rule as a tool card's head: press and release on one cell is a click; anything else is a selection.
+          let down: { x: number; y: number } | undefined;
+          picture.onMouseDown = event => { down = { x: event.x, y: event.y }; };
+          picture.onMouseUp = event => { if (down && down.x === event.x && down.y === event.y && picture.image) open(image.full ?? image.sha256); down = undefined; };
+        }
         pictures.push(picture);
         row.add(picture);
       }