@mecha.im/cli 0.3.4

package/agent/session-history.ts

@@ -0,0 +1,318 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import type { PtyManager } from "./pty-manager.js";
+import type { JContentBlock, ConversationMessage, SessionSummary, SessionDetail, SearchMatch, SearchResult } from "./session-history-types.js";
+import {
+  normalizeCwd, SKIP_TYPES, UUID_RE, isToolResultLine,
+  collectMetaUuids, isRealUserMessage, extractTextFromContent,
+  extractToolResultText, parseLines, extractSnippet,
+} from "./session-history-utils.js";
+
+export type { SearchMatch, SearchResult, SessionSummary, ConversationMessage, SessionDetail } from "./session-history-types.js";
+export { extractSnippet } from "./session-history-utils.js";
+
+export class SessionHistory {
+  private projectDir: string;
+  private ptyManager?: PtyManager;
+  private listCache: { summaries: SessionSummary[]; mtimes: Map<string, number>; cachedAt: number } | null = null;
+  private static LIST_CACHE_TTL_MS = 5_000;
+
+  constructor(workspaceCwd: string, ptyManager?: PtyManager) {
+    const normalized = normalizeCwd(workspaceCwd);
+    this.projectDir = join(homedir(), ".claude", "projects", normalized);
+    this.ptyManager = ptyManager;
+  }
+
+  async list(): Promise<SessionSummary[]> {
+    if (!existsSync(this.projectDir)) return [];
+
+    // Return cached result if fresh enough
+    if (this.listCache && Date.now() - this.listCache.cachedAt < SessionHistory.LIST_CACHE_TTL_MS) {
+      return this.listCache.summaries;
+    }
+
+    const files = await readdir(this.projectDir);
+    const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+
+    const ptySessions = new Set(
+      this.ptyManager?.listSessions().map((s) => s.claudeSessionId) ?? [],
+    );
+
+    const summaries: SessionSummary[] = [];
+
+    for (const file of jsonlFiles) {
+      const id = file.replace(".jsonl", "");
+      if (!UUID_RE.test(id)) continue;
+
+      try {
+        const filePath = join(this.projectDir, file);
+        const fileStat = await stat(filePath);
+        const raw = await readFile(filePath, "utf-8");
+        const lines = parseLines(raw);
+
+        let title = "";
+        let timestamp = "";
+        let lastActivity = "";
+        let model = "";
+        let messageCount = 0;
+        const metaUuids = collectMetaUuids(lines);
+
+        for (const line of lines) {
+          if (SKIP_TYPES.has(line.type)) continue;
+
+          // Track timestamps
+          if (line.timestamp) {
+            if (!timestamp) timestamp = line.timestamp;
+            lastActivity = line.timestamp;
+          }
+
+          // First user message = title
+          if (!title && isRealUserMessage(line, metaUuids)) {
+            const c = line.message!.content!;
+            const text = typeof c === "string" ? c : extractTextFromContent(c as JContentBlock[]);
+            title = text.slice(0, 100);
+          }
+
+          // Count real user messages and final assistant messages
+          if (isRealUserMessage(line, metaUuids)) messageCount++;
+          if (line.type === "assistant" && line.message?.stop_reason === "end_turn") {
+            messageCount++;
+            if (!model && line.message.model) model = line.message.model;
+          }
+
+        }
+
+        if (!title && !timestamp) continue; // skip empty/system-only sessions
+
+        summaries.push({
+          id,
+          title: title || "(no prompt)",
+          timestamp: timestamp || fileStat.mtime.toISOString(),
+          lastActivity: lastActivity || fileStat.mtime.toISOString(),
+          model: model || "unknown",
+          messageCount,
+          costUsd: 0, // JSONL doesn't store cost directly; could estimate from tokens
+          hasPty: ptySessions.has(id),
+        });
+      } catch {
+        // skip unreadable files
+      }
+    }
+
+    // Sort by lastActivity descending
+    summaries.sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
+    this.listCache = { summaries, mtimes: new Map(), cachedAt: Date.now() };
+    return summaries;
+  }
+
+  async getConversation(sessionId: string): Promise<SessionDetail | null> {
+    if (!UUID_RE.test(sessionId)) return null;
+
+    const filePath = join(this.projectDir, `${sessionId}.jsonl`);
+    if (!existsSync(filePath)) return null;
+
+    const raw = await readFile(filePath, "utf-8");
+    const lines = parseLines(raw);
+
+    const messages: ConversationMessage[] = [];
+    let model = "";
+    const metaUuids = collectMetaUuids(lines);
+    for (const line of lines) {
+      if (SKIP_TYPES.has(line.type)) continue;
+      const content = line.message?.content;
+      if (content === undefined || content === null) continue;
+
+      // Real user message (string or array content)
+      if (isRealUserMessage(line, metaUuids)) {
+        const text = typeof content === "string"
+          ? content
+          : extractTextFromContent(content as JContentBlock[]);
+        messages.push({
+          role: "user",
+          content: text,
+          timestamp: line.timestamp ?? "",
+        });
+        continue;
+      }
+
+      if (!Array.isArray(content)) continue;
+
+      // Tool result (type=user with tool_result content)
+      if (isToolResultLine(line)) {
+        const resultText = extractToolResultText(content);
+        const toolUseId = content.find((b) => b.type === "tool_result")?.tool_use_id;
+        if (toolUseId) {
+          messages.push({
+            role: "tool_result",
+            content: resultText.slice(0, 5000), // truncate large tool outputs
+            timestamp: line.timestamp ?? "",
+            toolUseId,
+          });
+        }
+        continue;
+      }
+
+      // Assistant message — skip streaming chunks (stop_reason === null)
+      if (line.type === "assistant") {
+        const stopReason = line.message?.stop_reason;
+        if (stopReason === null || stopReason === undefined) continue;
+
+        if (!model && line.message?.model) model = line.message.model;
+
+        const usage = line.message?.usage;
+
+        // Extract content blocks
+        let textContent = "";
+        let thinkingContent = "";
+
+        for (const block of content) {
+          if (block.type === "text" && block.text) {
+            textContent += block.text;
+          } else if (block.type === "thinking" && block.thinking) {
+            thinkingContent += block.thinking;
+          } else if (block.type === "tool_use") {
+            messages.push({
+              role: "tool_use",
+              content: "",
+              timestamp: line.timestamp ?? "",
+              toolName: block.name,
+              toolInput: block.input,
+              toolUseId: block.id,
+              model: line.message?.model,
+            });
+          }
+        }
+
+        if (textContent) {
+          messages.push({
+            role: "assistant",
+            content: textContent,
+            timestamp: line.timestamp ?? "",
+            model: line.message?.model,
+            thinkingContent: thinkingContent || undefined,
+            tokensIn: usage?.input_tokens,
+            tokensOut: usage?.output_tokens,
+          });
+        }
+      }
+    }
+
+    return {
+      id: sessionId,
+      messages,
+      totalCostUsd: 0,
+      model: model || "unknown",
+    };
+  }
+
+  /**
+   * Search across all sessions for messages containing the query string.
+   * Returns matched sessions with snippet context around each hit.
+   */
+  async search(query: string, limit = 20): Promise<SearchResult[]> {
+    if (!query.trim() || !existsSync(this.projectDir)) return [];
+
+    const needle = query.toLowerCase();
+    const files = await readdir(this.projectDir);
+    const jsonlFiles = files.filter((f) => {
+      const id = f.replace(".jsonl", "");
+      return f.endsWith(".jsonl") && UUID_RE.test(id);
+    });
+
+    const ptySessions = new Set(
+      this.ptyManager?.listSessions().map((s) => s.claudeSessionId) ?? [],
+    );
+
+    // Search files concurrently in batches of 10
+    const BATCH_SIZE = 10;
+    const results: SearchResult[] = [];
+
+    for (let i = 0; i < jsonlFiles.length; i += BATCH_SIZE) {
+      const batch = jsonlFiles.slice(i, i + BATCH_SIZE);
+      const batchResults = await Promise.all(
+        batch.map((file) => this.searchFile(file, needle, ptySessions)),
+      );
+      for (const r of batchResults) {
+        if (r) results.push(r);
+      }
+      if (results.length >= limit) break;
+    }
+
+    // Sort by lastActivity descending, then trim to limit
+    results.sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
+    return results.slice(0, limit);
+  }
+
+  private async searchFile(file: string, needle: string, ptySessions: Set<string>): Promise<SearchResult | null> {
+    const id = file.replace(".jsonl", "");
+    try {
+      const filePath = join(this.projectDir, file);
+      const raw = await readFile(filePath, "utf-8");
+      const lines = parseLines(raw);
+
+      let title = "";
+      let model = "";
+      let lastActivity = "";
+      const matches: SearchMatch[] = [];
+      const metaUuids = collectMetaUuids(lines);
+
+      for (const line of lines) {
+        if (SKIP_TYPES.has(line.type)) continue;
+        const content = line.message?.content;
+        if (content === undefined || content === null) continue;
+
+        if (line.timestamp) lastActivity = line.timestamp;
+
+        // Extract title from first user message
+        if (!title && isRealUserMessage(line, metaUuids)) {
+          title = (typeof content === "string" ? content : extractTextFromContent(content as JContentBlock[])).slice(0, 100);
+        }
+
+        // Track model (consistent with list(): only from final assistant turn)
+        if (!model && line.type === "assistant" && line.message?.stop_reason === "end_turn" && line.message.model) {
+          model = line.message.model;
+        }
+
+        // Search in user messages
+        if (isRealUserMessage(line, metaUuids)) {
+          const text = typeof content === "string" ? content : extractTextFromContent(content as JContentBlock[]);
+          if (text.toLowerCase().includes(needle)) {
+            matches.push({
+              role: "user",
+              snippet: extractSnippet(text, needle),
+              timestamp: line.timestamp ?? "",
+            });
+          }
+        }
+
+        // Search in assistant messages (final turn only)
+        if (line.type === "assistant" && line.message?.stop_reason === "end_turn" && Array.isArray(content)) {
+          const text = extractTextFromContent(content);
+          if (text.toLowerCase().includes(needle)) {
+            matches.push({
+              role: "assistant",
+              snippet: extractSnippet(text, needle),
+              timestamp: line.timestamp ?? "",
+            });
+          }
+        }
+      }
+
+      if (matches.length > 0) {
+        return {
+          id,
+          title: title || "(no prompt)",
+          model: model || "unknown",
+          lastActivity,
+          hasPty: ptySessions.has(id),
+          matches: matches.slice(0, 5),
+        };
+      }
+    } catch {
+      // skip unreadable files
+    }
+    return null;
+  }
+}

package/agent/session.ts

@@ -0,0 +1,152 @@
+import { z } from "zod";
+import { safeReadJson } from "../shared/safe-read.js";
+import { atomicWriteJson } from "../shared/atomic-write.js";
+import { log } from "../shared/logger.js";
+import { PATHS } from "./paths.js";
+
+const taskSourceSchema = z.enum(["interactive", "schedule", "webhook", "interbot"]);
+
+const taskSchema = z.object({
+  id: z.string(),
+  created: z.string(),
+  started_at: z.string().optional(),
+  ended_at: z.string().nullable().optional(),
+  source: taskSourceSchema.default("interactive"),
+  status: z.enum(["active", "completed", "error"]),
+  summary: z.string().optional(),
+  session_id: z.string().optional(),
+  cost_usd: z.number().default(0),
+  error: z.string().optional(),
+});
+
+const indexSchema = z.object({
+  active_task_id: z.string().nullable().default(null),
+  tasks: z.array(taskSchema).default([]),
+});
+
+type Task = z.infer<typeof taskSchema>;
+type SessionIndex = z.infer<typeof indexSchema>;
+export type TaskSource = z.infer<typeof taskSourceSchema>;
+
+const INDEX_PATH = PATHS.taskIndex;
+const MAX_TASKS = 500;
+
+export class SessionManager {
+  private index: SessionIndex;
+
+  constructor() {
+    const result = safeReadJson(INDEX_PATH, "session index", indexSchema);
+    if (result.ok) {
+      this.index = result.data;
+    } else {
+      if (result.reason !== "missing") {
+        log.warn(`SessionManager: ${result.reason} — ${result.detail}. Reinitializing.`);
+      }
+      this.index = { active_task_id: null, tasks: [] };
+      this.save();
+    }
+  }
+
+  getActiveTask(): Task | undefined {
+    if (!this.index.active_task_id) return undefined;
+    return this.index.tasks.find((t) => t.id === this.index.active_task_id);
+  }
+
+  ensureActiveTask(source: TaskSource = "interactive"): Task {
+    let task = this.getActiveTask();
+    if (!task) {
+      const now = new Date().toISOString();
+      task = {
+        id: crypto.randomUUID(),
+        created: now,
+        started_at: now,
+        ended_at: null,
+        source,
+        status: "active",
+        cost_usd: 0,
+      };
+      this.index.tasks.push(task);
+      this.index.active_task_id = task.id;
+      // Prune old completed/error tasks to prevent unbounded growth (keep active task)
+      if (this.index.tasks.length > MAX_TASKS) {
+        const activeId = this.index.active_task_id;
+        const kept = this.index.tasks.filter((t) => t.id === activeId || t.status === "active");
+        const rest = this.index.tasks.filter((t) => t.id !== activeId && t.status !== "active");
+        this.index.tasks = [...rest.slice(-MAX_TASKS + kept.length), ...kept];
+      }
+      this.save();
+    }
+    return task;
+  }
+
+  beginIsolatedTask(source: Exclude<TaskSource, "interactive">): Task {
+    this.completeTask();
+    return this.ensureActiveTask(source);
+  }
+
+  captureSessionId(sessionId: string): void {
+    const task = this.getActiveTask();
+    if (task) {
+      task.session_id = sessionId;
+      this.save();
+    }
+  }
+
+  addCost(costUsd: number): void {
+    if (!Number.isFinite(costUsd) || costUsd < 0) return;
+    const task = this.getActiveTask();
+    if (task) {
+      task.cost_usd += costUsd;
+      this.save();
+    }
+  }
+
+  completeTask(summary?: string): Task | undefined {
+    const task = this.getActiveTask();
+    if (task) {
+      task.status = "completed";
+      if (summary) task.summary = summary;
+      task.ended_at = new Date().toISOString();
+      this.index.active_task_id = null;
+      this.save();
+    }
+    return task;
+  }
+
+  markError(error?: string): Task | undefined {
+    const task = this.getActiveTask();
+    if (task) {
+      task.status = "error";
+      if (error) {
+        task.summary = error;
+        task.error = error;
+      }
+      task.ended_at = new Date().toISOString();
+      this.index.active_task_id = null;
+      this.save();
+    }
+    return task;
+  }
+
+  newSession(summary?: string): { newTask: Task; previousTask?: Task } {
+    const previousTask = this.completeTask(summary);
+    const newTask = this.ensureActiveTask("interactive");
+    return { newTask, previousTask };
+  }
+
+  listTasks(): Task[] {
+    return [...this.index.tasks].reverse();
+  }
+
+  getTask(id: string): Task | undefined {
+    return this.index.tasks.find((t) => t.id === id);
+  }
+
+  getResumeSessionId(): string | undefined {
+    return this.getActiveTask()?.session_id;
+  }
+
+  private save(): void {
+    atomicWriteJson(INDEX_PATH, this.index);
+  }
+}

package/agent/tools/mecha-call.ts

@@ -0,0 +1,106 @@
+import { logEvent } from "../event-log.js";
+import { isValidName } from "../../shared/validation.js";
+import { log } from "../../shared/logger.js";
+
+const FLEET_INTERNAL_SECRET = process.env.MECHA_FLEET_INTERNAL_SECRET;
+
+export async function callBot(botName: string, message: string): Promise<string> {
+  if (!isValidName(botName)) {
+    return `Error: invalid bot name "${botName}" (must be lowercase alphanumeric + hyphens, 1-32 chars)`;
+  }
+  const url = `http://mecha-${botName}:3000/prompt`;
+  const start = Date.now();
+
+  const headers: Record<string, string> = { "Content-Type": "application/json" };
+  if (FLEET_INTERNAL_SECRET) {
+    headers["x-mecha-internal-auth"] = FLEET_INTERNAL_SECRET;
+  }
+
+  let resp: Response;
+  try {
+    resp = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ message }),
+      signal: AbortSignal.timeout(5 * 60 * 1000), // 5 min timeout
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logEvent({ type: "mecha_call", target: botName, duration: Date.now() - start, success: false, error: msg });
+    return `Error: could not reach bot "${botName}" — ${msg}`;
+  }
+
+  if (resp.status === 409) {
+    logEvent({ type: "mecha_call", target: botName, duration: Date.now() - start, success: false, error: "busy" });
+    return `Error: bot "${botName}" is busy processing another request`;
+  }
+
+  if (!resp.ok) {
+    logEvent({ type: "mecha_call", target: botName, duration: Date.now() - start, success: false, error: `HTTP ${resp.status}` });
+    return `Error: bot "${botName}" returned HTTP ${resp.status}`;
+  }
+
+  // Parse SSE stream and collect text
+  const reader = resp.body?.getReader();
+  if (!reader) {
+    logEvent({ type: "mecha_call", target: botName, duration: Date.now() - start, success: false, error: "no body" });
+    return "Error: no response body";
+  }
+
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const textParts: string[] = [];
+  let parseErrors = 0;
+
+  // SSE parser: accumulate event blocks (event + data lines), dispatch on blank line
+  let currentData: string[] = [];
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+
+    for (const line of lines) {
+      if (line === "") {
+        // End of SSE event block — process accumulated data
+        if (currentData.length > 0) {
+          const joined = currentData.join("\n");
+          try {
+            const data = JSON.parse(joined);
+            if (data.content) textParts.push(data.content);
+            if (data.message && !data.task_id) textParts.push(`[error: ${data.message}]`);
+          } catch {
+            parseErrors++;
+          }
+        }
+        currentData = [];
+      } else if (line.startsWith("data: ")) {
+        currentData.push(line.slice(6));
+      } else if (line.startsWith("data:")) {
+        currentData.push(line.slice(5));
+      }
+    }
+  }
+
+  // Process any trailing event block without final blank line
+  if (currentData.length > 0) {
+    const joined = currentData.join("\n");
+    try {
+      const data = JSON.parse(joined);
+      if (data.content) textParts.push(data.content);
+    } catch {
+      parseErrors++;
+    }
+  }
+
+  if (parseErrors > 0) {
+    log.warn(`mecha_call to "${botName}": ${parseErrors} malformed SSE data chunk(s) skipped`);
+  }
+
+  const result = textParts.join("") || "(empty response)";
+  logEvent({ type: "mecha_call", target: botName, duration: Date.now() - start, success: true });
+  return result;
+}