@ai-devkit/agent-manager 0.32.0 → 0.33.1

package/src/providers/pi/PiSessionLocator.ts

@@ -0,0 +1,95 @@
+import * as path from "path";
+import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { matchProcessesToSessions, type MatchResult } from "../../utils/matching.js";
+import { isDirectory, safeReaddir, safeStat, type SessionFile } from "../../utils/session.js";
+import { PiSessionParser } from "./PiSessionParser.js";
+
+export interface PiSessionLocatorOptions {
+  sessionsDir?: string;
+}
+
+export interface PiProcessSessionMatches {
+  legacyMatches: MatchResult[];
+  fallback: ProcessInfo[];
+}
+
+export class PiSessionLocator {
+  private readonly sessionsDir: string;
+
+  constructor(
+    options: PiSessionLocatorOptions = {},
+    private readonly parser: PiSessionParser = new PiSessionParser(),
+  ) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    this.sessionsDir = options.sessionsDir ?? path.join(homeDir, ".pi", "agent", "sessions");
+  }
+
+  matchRunningProcesses(processes: ProcessInfo[]): PiProcessSessionMatches {
+    if (processes.length === 0) return { legacyMatches: [], fallback: [] };
+
+    const sessions = this.discoverLiveSessions(processes);
+    if (sessions.length === 0) return { legacyMatches: [], fallback: processes };
+
+    return {
+      legacyMatches: matchProcessesToSessions(processes, sessions),
+      fallback: processes,
+    };
+  }
+
+  discoverLiveSessions(processes: ProcessInfo[] = []): SessionFile[] {
+    if (!isDirectory(this.sessionsDir)) return [];
+
+    const cwdByProjectDir = this.buildProjectDirCwdMap(processes);
+    const sessions: SessionFile[] = [];
+    for (const filePath of this.discoverHistoricalSessionFiles()) {
+      const stat = safeStat(filePath);
+      if (!stat) continue;
+
+      const session = this.parser.readSession(filePath);
+      const sessionId = session?.sessionId || this.parser.sessionIdFromFile(filePath);
+      const projectDir = path.dirname(filePath);
+      sessions.push({
+        sessionId,
+        filePath,
+        projectDir,
+        birthtimeMs: stat.birthtimeMs || stat.mtimeMs,
+        resolvedCwd: session?.projectPath || cwdByProjectDir.get(path.basename(projectDir)) || "",
+      });
+    }
+
+    return sessions;
+  }
+
+  discoverHistoricalSessionFiles(): string[] {
+    return this.collectJsonlFiles(this.sessionsDir);
+  }
+
+  private buildProjectDirCwdMap(processes: ProcessInfo[]): Map<string, string> {
+    const map = new Map<string, string>();
+    for (const proc of processes) {
+      if (!proc.cwd) continue;
+      map.set(this.encodeProjectDir(proc.cwd), proc.cwd);
+    }
+    return map;
+  }
+
+  private collectJsonlFiles(dir: string): string[] {
+    const files: string[] = [];
+    for (const entry of safeReaddir(dir)) {
+      const fullPath = path.join(dir, entry);
+      const stat = safeStat(fullPath);
+      if (!stat) continue;
+      if (stat.isDirectory()) {
+        files.push(...this.collectJsonlFiles(fullPath));
+      } else if (stat.isFile() && entry.endsWith(".jsonl")) {
+        files.push(fullPath);
+      }
+    }
+    return files;
+  }
+
+  private encodeProjectDir(cwd: string): string {
+    const normalized = path.resolve(cwd);
+    return `--${normalized.replace(/^\//, "").replace(/\//g, "-")}--`;
+  }
+}

package/src/providers/pi/PiSessionParser.ts

@@ -0,0 +1,284 @@
+import * as path from "path";
+import type { ConversationMessage, SessionSummary } from "../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { safeReadFile, safeStat } from "../../utils/session.js";
+
+export interface PiSession {
+  sessionId: string;
+  projectPath: string;
+  summary: string;
+  sessionStart: Date;
+  lastActive: Date;
+  lastRole?: ConversationMessage["role"];
+}
+
+interface PiLine {
+  timestamp?: string;
+  role?: string;
+  type?: string;
+  content?: unknown;
+  text?: unknown;
+  message?: unknown;
+  sessionId?: string;
+  session_id?: string;
+  id?: string;
+  cwd?: string;
+  projectPath?: string;
+  project_path?: string;
+  payload?: Record<string, unknown>;
+  data?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+type PiRecord = Record<string, unknown>;
+
+const IDLE_THRESHOLD_MINUTES = 5;
+
+export class PiSessionParser {
+  readSession(filePath: string, fallbackCwd = ""): PiSession | null {
+    const entries = this.readJsonl(filePath);
+    if (entries.length === 0) return null;
+    return this.sessionFromEntries(entries, filePath, fallbackCwd);
+  }
+
+  determineStatus(session: PiSession): AgentStatus {
+    const diffMs = Date.now() - session.lastActive.getTime();
+    const diffMinutes = diffMs / 60000;
+
+    if (diffMinutes > IDLE_THRESHOLD_MINUTES) return AgentStatus.IDLE;
+    if (session.lastRole === "assistant") return AgentStatus.WAITING;
+    return AgentStatus.RUNNING;
+  }
+
+  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
+    const includeSystem = options?.verbose ?? false;
+    return this.entriesToMessages(this.readJsonl(sessionFilePath), includeSystem);
+  }
+
+  fileToSessionSummary(filePath: string): SessionSummary | null {
+    const entries = this.readJsonl(filePath);
+    if (entries.length === 0) return null;
+
+    const session = this.sessionFromEntries(entries, filePath);
+    const firstUserMessage =
+      this.entriesToMessages(entries, false).find((msg) => msg.role === "user")?.content ?? "";
+    return {
+      type: "pi",
+      sessionId: session.sessionId,
+      cwd: session.projectPath,
+      firstUserMessage,
+      lastActive: session.lastActive,
+      startedAt: session.sessionStart,
+      sessionFilePath: filePath,
+    };
+  }
+
+  sessionIdFromFile(filePath: string): string {
+    const base = path.basename(filePath, ".jsonl");
+    const underscore = base.lastIndexOf("_");
+    return underscore >= 0 ? base.slice(underscore + 1) : base;
+  }
+
+  private sessionFromEntries(entries: PiLine[], filePath: string, fallbackCwd = ""): PiSession {
+    const stat = safeStat(filePath);
+    const timestamps = entries
+      .map((entry) => this.parseTimestamp(this.entryTimestamp(entry)))
+      .filter((value): value is Date => value !== null);
+
+    const sessionStart = timestamps[0] ?? stat?.birthtime ?? stat?.mtime ?? new Date();
+    const lastActive = timestamps[timestamps.length - 1] ?? stat?.mtime ?? sessionStart;
+    const messages = this.entriesToMessages(entries, true);
+    const lastUser = [...messages].reverse().find((msg) => msg.role === "user");
+    const lastMessage = messages[messages.length - 1];
+
+    return {
+      sessionId: this.sessionIdFromEntries(entries) || this.sessionIdFromFile(filePath),
+      projectPath: this.cwdFromEntries(entries) || fallbackCwd,
+      summary: lastUser?.content ? this.truncate(lastUser.content, 120) : "Pi session active",
+      sessionStart,
+      lastActive,
+      lastRole: lastMessage?.role,
+    };
+  }
+
+  private readJsonl(filePath: string): PiLine[] {
+    const content = safeReadFile(filePath);
+    if (content === undefined) return [];
+
+    const entries: PiLine[] = [];
+    for (const line of content.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          entries.push(parsed as PiLine);
+        }
+      } catch {
+        continue;
+      }
+    }
+    return entries;
+  }
+
+  private entriesToMessages(entries: PiLine[], includeSystem: boolean): ConversationMessage[] {
+    return entries
+      .map((entry) => this.entryToMessage(entry, includeSystem))
+      .filter((msg): msg is ConversationMessage => msg !== null);
+  }
+
+  private entryToMessage(entry: PiLine, includeSystem: boolean): ConversationMessage | null {
+    const role = this.entryRole(entry);
+    if (!role) return null;
+    if (role === "system" && !includeSystem) return null;
+
+    const content = this.entryContent(entry).trim();
+    if (!content) return null;
+
+    return {
+      role,
+      content,
+      timestamp: this.entryTimestamp(entry),
+    };
+  }
+
+  private entryRole(entry: PiLine): ConversationMessage["role"] | null {
+    const message = this.messageRecord(entry);
+    const raw = this.firstString(
+      entry.role,
+      message?.role,
+      this.roleLikeType(entry.type),
+      entry.payload?.role,
+      entry.payload?.type,
+      entry.data?.role,
+      entry.data?.type,
+    );
+    if (!raw) return null;
+    const normalized = raw.toLowerCase();
+    if (normalized === "user" || normalized === "human") return "user";
+    if (normalized === "assistant" || normalized === "ai" || normalized === "pi")
+      return "assistant";
+    if (normalized === "system") return "system";
+    return null;
+  }
+
+  private entryContent(entry: PiLine): string {
+    const message = this.messageRecord(entry);
+    const candidates = [
+      entry.content,
+      entry.text,
+      message?.content,
+      message?.text,
+      message?.message,
+      entry.message,
+      entry.payload?.content,
+      entry.payload?.text,
+      entry.payload?.message,
+      entry.data?.content,
+      entry.data?.text,
+      entry.data?.message,
+    ];
+
+    for (const candidate of candidates) {
+      const text = this.contentToString(candidate);
+      if (text) return text;
+    }
+    return "";
+  }
+
+  private contentToString(value: unknown): string {
+    if (typeof value === "string") return value;
+    if (Array.isArray(value)) {
+      return value
+        .map((item) => this.contentToString(item))
+        .filter(Boolean)
+        .join("");
+    }
+    if (!value || typeof value !== "object") return "";
+
+    const record = value as Record<string, unknown>;
+    return this.contentToString(record.content ?? record.text ?? record.value);
+  }
+
+  private messageRecord(entry: PiLine): PiRecord | null {
+    return this.asRecord(entry.message);
+  }
+
+  private asRecord(value: unknown): PiRecord | null {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+    return value as PiRecord;
+  }
+
+  private roleLikeType(value: unknown): string | undefined {
+    if (typeof value !== "string") return undefined;
+    const normalized = value.toLowerCase();
+    if (["user", "human", "assistant", "ai", "pi", "system"].includes(normalized)) {
+      return value;
+    }
+    return undefined;
+  }
+
+  private entryTimestamp(entry: PiLine): string | undefined {
+    return this.firstString(
+      entry.timestamp,
+      entry.payload?.timestamp,
+      entry.data?.timestamp,
+      entry.createdAt,
+      entry.created_at,
+    );
+  }
+
+  private sessionIdFromEntries(entries: PiLine[]): string | null {
+    for (const entry of entries) {
+      const sessionId = this.firstString(
+        entry.sessionId,
+        entry.session_id,
+        entry.id,
+        entry.payload?.sessionId,
+        entry.payload?.session_id,
+        entry.payload?.id,
+        entry.data?.sessionId,
+        entry.data?.session_id,
+        entry.data?.id,
+      );
+      if (sessionId) return sessionId;
+    }
+    return null;
+  }
+
+  private cwdFromEntries(entries: PiLine[]): string {
+    for (const entry of entries) {
+      const cwd = this.firstString(
+        entry.cwd,
+        entry.projectPath,
+        entry.project_path,
+        entry.payload?.cwd,
+        entry.payload?.projectPath,
+        entry.payload?.project_path,
+        entry.data?.cwd,
+        entry.data?.projectPath,
+        entry.data?.project_path,
+      );
+      if (cwd) return cwd;
+    }
+    return "";
+  }
+
+  private firstString(...values: unknown[]): string | undefined {
+    for (const value of values) {
+      if (typeof value === "string" && value) return value;
+    }
+    return undefined;
+  }
+
+  private parseTimestamp(value?: string): Date | null {
+    if (!value) return null;
+    const timestamp = new Date(value);
+    return Number.isNaN(timestamp.getTime()) ? null : timestamp;
+  }
+
+  private truncate(value: string, maxLength: number): string {
+    if (value.length <= maxLength) return value;
+    return `${value.slice(0, maxLength - 3)}...`;
+  }
+}

package/src/providers/pi/PiSessionTracker.ts

@@ -0,0 +1,87 @@
+import * as fs from "fs";
+import * as path from "path";
+import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { safeReadFile } from "../../utils/session.js";
+
+export interface PiTrackerMatch {
+  process: ProcessInfo;
+  filePath: string;
+}
+
+export interface PiTrackerMatchResult {
+  matches: PiTrackerMatch[];
+  fallback: ProcessInfo[];
+}
+
+export interface PiSessionTrackerOptions {
+  sessionsDir?: string;
+  trackerPath?: string;
+}
+
+export class PiSessionTracker {
+  private readonly sessionsDir: string;
+  private readonly trackerPath: string;
+
+  constructor(options: PiSessionTrackerOptions = {}) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    const agentDir = path.join(homeDir, ".pi", "agent");
+    this.sessionsDir = options.sessionsDir ?? path.join(agentDir, "sessions");
+    this.trackerPath = options.trackerPath ?? path.join(agentDir, "sessions.json");
+  }
+
+  match(processes: ProcessInfo[]): PiTrackerMatchResult {
+    const tracker = this.readTracker();
+    if (tracker.size === 0) return { matches: [], fallback: processes };
+
+    const matches: PiTrackerMatch[] = [];
+    const fallback: ProcessInfo[] = [];
+
+    for (const processInfo of processes) {
+      const filePath = tracker.get(processInfo.pid);
+      if (!filePath || !this.isTrustedSessionPath(filePath) || !fs.existsSync(filePath)) {
+        fallback.push(processInfo);
+        continue;
+      }
+
+      matches.push({ process: processInfo, filePath });
+    }
+
+    return { matches, fallback };
+  }
+
+  private readTracker(): Map<number, string> {
+    const content = safeReadFile(this.trackerPath);
+    if (content === undefined) return new Map();
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      return new Map();
+    }
+
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return new Map();
+
+    const map = new Map<number, string>();
+    for (const [key, value] of Object.entries(parsed)) {
+      const keyPid = this.toPid(key);
+      if (keyPid !== null && typeof value === "string" && value) {
+        map.set(keyPid, value);
+      }
+    }
+    return map;
+  }
+
+  private toPid(value: unknown): number | null {
+    if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
+    if (typeof value !== "string" || !/^\d+$/.test(value)) return null;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
+  }
+
+  private isTrustedSessionPath(filePath: string): boolean {
+    const resolvedRoot = path.resolve(this.sessionsDir);
+    const resolvedPath = path.resolve(filePath);
+    return resolvedPath === resolvedRoot || resolvedPath.startsWith(`${resolvedRoot}${path.sep}`);
+  }
+}

package/src/providers/pi/durable/PiCliProbe.ts

@@ -1,48 +1,56 @@
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import { PiPrintError } from '../../../durable/DurableAgent.js';
-import { sanitizeText } from '../../../durable/utils.js';
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { PiPrintError } from "../../../durable/DurableAgent.js";
+import { sanitizeText } from "../../../durable/utils.js";
 
 type ExecResult = { stdout: string; stderr: string };
 type Exec = (file: string, args: string[]) => Promise<ExecResult>;
 const execFileAsync = promisify(execFile);
-const REQUIRED = ['--mode', 'json', '--session-id', '--session'];
+const REQUIRED = ["--mode", "json", "--session-id", "--session"];
 
 export interface PiCliProbeOptions {
-    executable?: string;
-    exec?: Exec;
+  executable?: string;
+  exec?: Exec;
 }
 
 export class PiCliProbe {
-    private readonly executable: string;
-    private readonly exec: Exec;
+  private readonly executable: string;
+  private readonly exec: Exec;
 
-    constructor(options: PiCliProbeOptions = {}) {
-        this.executable = options.executable ?? 'pi';
-        this.exec = options.exec ?? (async (file, args) => {
-            const result = await execFileAsync(file, args, { encoding: 'utf8', maxBuffer: 1024 * 1024 });
-            return { stdout: result.stdout, stderr: result.stderr };
+  constructor(options: PiCliProbeOptions = {}) {
+    this.executable = options.executable ?? "pi";
+    this.exec =
+      options.exec ??
+      (async (file, args) => {
+        const result = await execFileAsync(file, args, {
+          encoding: "utf8",
+          maxBuffer: 1024 * 1024,
         });
-    }
+        return { stdout: result.stdout, stderr: result.stderr };
+      });
+  }
 
-    async validate(): Promise<{ executable: string; version: string }> {
-        try {
-            const version = await this.exec(this.executable, ['--version']);
-            const help = await this.exec(this.executable, ['--help']);
-            const missing = REQUIRED.filter((capability) => !help.stdout.includes(capability));
-            if (missing.length > 0) {
-                throw new PiPrintError(
-                    `Pi CLI does not support required print-mode capabilities: ${missing.join(', ')}.`,
-                    'PI_CLI_UNSUPPORTED',
-                );
-            }
-            return { executable: this.executable, version: sanitizeText(version.stdout, 256) || 'unknown' };
-        } catch (error) {
-            if (error instanceof PiPrintError) throw error;
-            throw new PiPrintError(
-                `Pi CLI validation failed: ${sanitizeText((error as Error).message, 512)}`,
-                'PI_CLI_UNAVAILABLE',
-            );
-        }
+  async validate(): Promise<{ executable: string; version: string }> {
+    try {
+      const version = await this.exec(this.executable, ["--version"]);
+      const help = await this.exec(this.executable, ["--help"]);
+      const missing = REQUIRED.filter((capability) => !help.stdout.includes(capability));
+      if (missing.length > 0) {
+        throw new PiPrintError(
+          `Pi CLI does not support required print-mode capabilities: ${missing.join(", ")}.`,
+          "PI_CLI_UNSUPPORTED",
+        );
+      }
+      return {
+        executable: this.executable,
+        version: sanitizeText(version.stdout, 256) || "unknown",
+      };
+    } catch (error) {
+      if (error instanceof PiPrintError) throw error;
+      throw new PiPrintError(
+        `Pi CLI validation failed: ${sanitizeText((error as Error).message, 512)}`,
+        "PI_CLI_UNAVAILABLE",
+      );
     }
+  }
 }