@amanm/openpaw 0.1.0

package/gateway/tui/tui-active-thread-store.ts

@@ -0,0 +1,103 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { getSessionsDir } from "../../config/paths";
+import type { SessionId } from "../../agent/types";
+import { TUI_ACTIVE_THREAD_FILENAME } from "./constants";
+
+const LEGACY_TUI_SESSION: SessionId = "tui:main";
+
+type TuiActiveThreadState = {
+  /** When set, active session is `tui:main:${threadUuid}`; otherwise legacy `tui:main`. */
+  threadUuid?: string;
+  /** Explicit non-TUI session id (for example `telegram:<chatId>[:threadUuid]`). */
+  sessionId?: SessionId;
+};
+
+function activeThreadPath(): string {
+  return join(getSessionsDir(), TUI_ACTIVE_THREAD_FILENAME);
+}
+
+async function readState(): Promise<TuiActiveThreadState> {
+  const path = activeThreadPath();
+  if (!existsSync(path)) {
+    return {};
+  }
+  try {
+    const raw = await Bun.file(path).text();
+    const parsed = JSON.parse(raw) as unknown;
+    if (typeof parsed !== "object" || parsed === null) {
+      return {};
+    }
+    const sessionId = (parsed as TuiActiveThreadState).sessionId;
+    if (typeof sessionId === "string" && sessionId.length > 0) {
+      return { sessionId };
+    }
+    const threadUuid = (parsed as TuiActiveThreadState).threadUuid;
+    if (typeof threadUuid === "string" && threadUuid.length > 0) {
+      return { threadUuid };
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+
+async function writeState(state: TuiActiveThreadState): Promise<void> {
+  const dir = getSessionsDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const payload =
+    state.sessionId && state.sessionId.length > 0
+      ? { sessionId: state.sessionId }
+      : state.threadUuid && state.threadUuid.length > 0
+        ? { threadUuid: state.threadUuid }
+        : {};
+  await Bun.write(activeThreadPath(), JSON.stringify(payload, null, 2));
+}
+
+/**
+ * OpenPaw persistence session id for the TUI (legacy `tui:main` or threaded `tui:main:uuid`).
+ */
+export async function getTuiPersistenceSessionId(): Promise<SessionId> {
+  const state = await readState();
+  if (state.sessionId) {
+    return state.sessionId;
+  }
+  if (state.threadUuid) {
+    return `tui:main:${state.threadUuid}`;
+  }
+  return LEGACY_TUI_SESSION;
+}
+
+/**
+ * Starts a new TUI thread: new uuid in the active store. Returns the new persistence session id.
+ */
+export async function startNewTuiThread(): Promise<SessionId> {
+  const uuid = crypto.randomUUID();
+  await writeState({ threadUuid: uuid });
+  return `tui:main:${uuid}`;
+}
+
+/**
+ * Points the TUI at an existing persistence session (legacy or thread file).
+ */
+export async function setActiveTuiSession(persistenceSessionId: SessionId): Promise<void> {
+  if (persistenceSessionId === LEGACY_TUI_SESSION) {
+    await writeState({});
+    return;
+  }
+  if (!persistenceSessionId.trim()) {
+    throw new Error("Invalid session id");
+  }
+  const prefix = `${LEGACY_TUI_SESSION}:`;
+  if (persistenceSessionId.startsWith(prefix)) {
+    const uuid = persistenceSessionId.slice(prefix.length);
+    if (!uuid) {
+      throw new Error("Invalid thread id");
+    }
+    await writeState({ threadUuid: uuid });
+    return;
+  }
+  await writeState({ sessionId: persistenceSessionId });
+}

package/gateway/tui/tui-session-discovery.ts

@@ -0,0 +1,94 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { readdir, stat } from "node:fs/promises";
+import { getSessionsDir } from "../../config/paths";
+import type { SessionId } from "../../agent/types";
+import { TUI_ACTIVE_THREAD_FILENAME } from "./constants";
+import {
+  TELEGRAM_ACTIVE_THREADS_FILENAME,
+  TELEGRAM_CHAT_PREFERENCES_FILENAME,
+} from "../telegram/constants";
+
+export type TuiSessionListEntry = {
+  sessionId: SessionId;
+  mtimeMs: number;
+};
+
+function parseTuiSessionFilename(stem: string): SessionId | null {
+  if (stem === "tui_main") {
+    return "tui:main";
+  }
+  if (stem.startsWith("tui_main_")) {
+    const suffix = stem.slice("tui_main_".length);
+    if (!suffix) {
+      return null;
+    }
+    return `tui:main:${suffix}`;
+  }
+  return null;
+}
+
+function parseTelegramSessionFilename(stem: string): SessionId | null {
+  const match = /^telegram_(\d+)(?:_(.+))?$/.exec(stem);
+  if (!match) {
+    return null;
+  }
+  const chatId = match[1]!;
+  const suffix = match[2];
+  if (!suffix) {
+    return `telegram:${chatId}`;
+  }
+  return `telegram:${chatId}:${suffix}`;
+}
+
+/**
+ * Maps a sessions-dir filename stem back to a resumable TUI-visible session id.
+ * TUI-native and Telegram sessions are supported.
+ */
+function parseResumableSessionFilename(filename: string): SessionId | null {
+  if (
+    !filename.endsWith(".json") ||
+    filename === TUI_ACTIVE_THREAD_FILENAME ||
+    filename === TELEGRAM_ACTIVE_THREADS_FILENAME ||
+    filename === TELEGRAM_CHAT_PREFERENCES_FILENAME
+  ) {
+    return null;
+  }
+  const stem = filename.slice(0, -".json".length);
+  const tui = parseTuiSessionFilename(stem);
+  if (tui) {
+    return tui;
+  }
+  const telegram = parseTelegramSessionFilename(stem);
+  if (telegram) {
+    return telegram;
+  }
+  return null;
+}
+
+/**
+ * Lists on-disk sessions visible to TUI /sessions and /resume, newest first.
+ */
+export async function listTuiSessions(): Promise<TuiSessionListEntry[]> {
+  const dir = getSessionsDir();
+  if (!existsSync(dir)) {
+    return [];
+  }
+  const names = await readdir(dir);
+  const entries: TuiSessionListEntry[] = [];
+  for (const name of names) {
+    const sessionId = parseResumableSessionFilename(name);
+    if (!sessionId) {
+      continue;
+    }
+    const path = join(dir, name);
+    try {
+      const st = await stat(path);
+      entries.push({ sessionId, mtimeMs: st.mtimeMs });
+    } catch {
+      continue;
+    }
+  }
+  entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return entries;
+}

package/gateway/tui/tui-session-label.ts

@@ -0,0 +1,22 @@
+/**
+ * Human-readable label for a TUI /sessions row.
+ */
+export function formatTuiSessionLabel(sessionId: string): string {
+  const tuiLegacy = "tui:main";
+  if (sessionId === tuiLegacy) {
+    return "main";
+  }
+  const tuiPrefix = `${tuiLegacy}:`;
+  if (sessionId.startsWith(tuiPrefix)) {
+    return sessionId.slice(tuiPrefix.length);
+  }
+
+  const telegramMatch = /^telegram:(\d+)(?::(.+))?$/.exec(sessionId);
+  if (telegramMatch) {
+    const chatId = telegramMatch[1]!;
+    const suffix = telegramMatch[2];
+    return suffix ? `telegram ${chatId} / ${suffix}` : `telegram ${chatId} / main`;
+  }
+
+  return sessionId;
+}

package/gateway/tui/tui-sessions-list-message.ts

@@ -0,0 +1,37 @@
+import type { SessionId } from "../../agent/types";
+import { formatTuiSessionLabel } from "./tui-session-label";
+import type { TuiSessionListEntry } from "./tui-session-discovery";
+
+const MAX_LINES = 20;
+const MAX_CHARS = 3500;
+
+/**
+ * Builds the plaintext body for a TUI /sessions reply (numbered list, active marker, truncation).
+ */
+export function formatTuiSessionsListMessage(
+  entries: TuiSessionListEntry[],
+  activeSessionId: SessionId,
+): string {
+  if (entries.length === 0) {
+    return "No saved sessions yet.";
+  }
+
+  const lines: string[] = [];
+  const shown = Math.min(entries.length, MAX_LINES);
+  for (let i = 0; i < shown; i++) {
+    const e = entries[i]!;
+    const n = i + 1;
+    const mark = e.sessionId === activeSessionId ? " (active)" : "";
+    const label = formatTuiSessionLabel(e.sessionId);
+    lines.push(`${n}. ${label}${mark}`);
+  }
+  if (entries.length > MAX_LINES) {
+    lines.push(`…and ${entries.length - MAX_LINES} more.`);
+  }
+
+  let body = "Saved sessions (newest first):\n" + lines.join("\n");
+  if (body.length > MAX_CHARS) {
+    body = `${body.slice(0, MAX_CHARS - 20)}\n…(truncated)`;
+  }
+  return body;
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@amanm/openpaw",
+  "version": "0.1.0",
+  "description": "Local Bun + TypeScript agent runtime with TUI and messaging gateway adapters.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "openpaw": "bin/openpaw.cjs"
+  },
+  "scripts": {
+    "openpaw": "bun run ./cli/openpaw.tsx",
+    "gateway:dev": "bun run ./cli/openpaw.tsx gateway dev",
+    "tui": "bun run ./cli/openpaw.tsx tui",
+    "onboard": "bun run ./cli/openpaw.tsx onboard",
+    "typecheck": "bunx tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "files": [
+    "agent/",
+    "bin/",
+    "bundled-skills/",
+    "cli/",
+    "config/",
+    "gateway/",
+    "README.md",
+    "AGENTS.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@ai-sdk/openai-compatible": "^2.0.37",
+    "@opentui/core": "^0.1.90",
+    "@opentui/react": "^0.1.90",
+    "ai": "^6.0.138",
+    "commander": "^14.0.3",
+    "grammy": "^1.41.1",
+    "react": "^19.2.4",
+    "tg-markdown-converter": "^1.1.1",
+    "web-tree-sitter": "0.25.10",
+    "yaml": "^2.8.3",
+    "zod": "^4.3.6"
+  }
+}