@nordbyte/nordrelay 0.3.1 → 0.4.0

package/dist/pi-session.js

@@ -2,7 +2,7 @@ import { spawnSync } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { PI_AGENT_CAPABILITIES, PI_THINKING_LEVELS, } from "./agent.js";
-import { createDefaultLaunchProfile } from "./codex-launch.js";
+import { findPiLaunchProfile, listPiLaunchProfiles, piProfileAsLaunchProfile } from "./pi-launch.js";
 import { resolvePiCli } from "./pi-cli.js";
 import { PiRpcClient } from "./pi-rpc.js";
 import { getPiSession, listPiSessions, listPiWorkspaces, readPiSessionRecord, resolvePiSessionDir, } from "./pi-state.js";
@@ -10,7 +10,7 @@ export class PiSessionService {
     config;
     sessionDir;
     cliPath;
-    launchProfile;
+    currentLaunchProfile;
     rpc = null;
     currentWorkspace;
     currentThreadId = null;
@@ -31,13 +31,14 @@ export class PiSessionService {
         this.currentWorkspace = config.workspace;
         this.currentModel = config.piDefaultModel;
         this.currentThinking = config.piDefaultThinking;
-        this.launchProfile = createDefaultLaunchProfile("workspace-write", "never");
+        this.currentLaunchProfile = findPiLaunchProfile(config.piDefaultLaunchProfileId);
     }
     static async create(config, options) {
         const service = new PiSessionService(config);
         service.currentWorkspace = options?.workspace ?? config.workspace;
         service.currentModel = options?.model ?? config.piDefaultModel;
         service.currentThinking = options?.reasoningEffort ?? config.piDefaultThinking;
+        service.currentLaunchProfile = findPiLaunchProfile(options?.launchProfileId ?? config.piDefaultLaunchProfileId);
         if (options?.sessionPath) {
             await service.switchSession(options.sessionPath);
             return service;
@@ -59,9 +60,9 @@ export class PiSessionService {
             workspace: this.currentWorkspace,
             model: this.currentModel,
             reasoningEffort: this.currentThinking,
-            launchProfileId: "pi-rpc",
-            launchProfileLabel: "Pi RPC",
-            launchProfileBehavior: "rpc / host",
+            launchProfileId: this.currentLaunchProfile.id,
+            launchProfileLabel: this.currentLaunchProfile.label,
+            launchProfileBehavior: this.currentLaunchProfile.behavior,
             sandboxMode: "host",
             approvalPolicy: "never",
             fastMode: false,
@@ -220,6 +221,9 @@ export class PiSessionService {
         workspaces.add(this.config.workspace);
         return [...workspaces].sort((left, right) => left.localeCompare(right));
     }
+    async refreshModels() {
+        // Pi models are read from the CLI on each listModels() call.
+    }
     listModels() {
         const result = spawnSync(this.cliPath, ["--list-models"], {
             cwd: this.currentWorkspace,
@@ -243,11 +247,17 @@ export class PiSessionService {
                 continue;
             }
             const slug = `${provider}/${model}`;
-            const maxInputTokens = parseCompactTokenCount(parts[2]);
+            const contextWindow = parseCompactTokenCount(parts[2]);
+            const maxOutputTokens = parseCompactTokenCount(parts[3]);
+            const supportsThinking = parseYesNo(parts[4]);
+            const supportsImages = parseYesNo(parts[5]);
             records.push({
                 slug,
                 displayName: slug,
-                ...(maxInputTokens !== undefined ? { maxInputTokens } : {}),
+                ...(contextWindow !== undefined ? { maxInputTokens: contextWindow, contextWindow } : {}),
+                ...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}),
+                ...(supportsThinking !== undefined ? { supportsThinking } : {}),
+                ...(supportsImages !== undefined ? { supportsImages } : {}),
             });
         }
         if (this.currentModel && !records.some((record) => record.slug === this.currentModel)) {
@@ -255,6 +265,9 @@ export class PiSessionService {
         }
         return records;
     }
+    listLaunchProfiles() {
+        return listPiLaunchProfiles();
+    }
     getSessionRecord(threadId) {
         return getPiSession(threadId, { sessionDir: this.sessionDir });
     }
@@ -297,21 +310,68 @@ export class PiSessionService {
         }
         return { value: level, appliedToActiveThread };
     }
-    setLaunchProfile() {
-        throw new Error("Launch profiles are only supported by Codex sessions");
+    setLaunchProfile(profileId) {
+        this.ensureIdle("change Pi profile");
+        this.currentLaunchProfile = findPiLaunchProfile(profileId);
+        this.restartRpcIfIdle();
+        return piProfileAsLaunchProfile(this.currentLaunchProfile);
     }
     setFastMode() {
         throw new Error("Fast mode is only supported by Codex sessions");
     }
     getSelectedLaunchProfile() {
-        return this.launchProfile;
+        return piProfileAsLaunchProfile(this.currentLaunchProfile);
     }
-    syncFromCodexState() {
+    syncFromAgentState(options = {}) {
+        const before = {
+            threadId: this.currentThreadId,
+            workspace: this.currentWorkspace,
+            model: this.currentModel,
+            thinking: this.currentThinking,
+            sessionPath: this.currentSessionPath,
+        };
+        const changedFields = new Set();
+        const record = this.currentSessionPath
+            ? readPiSessionRecord(this.currentSessionPath, path.basename(path.dirname(this.currentSessionPath)))
+            : this.currentThreadId
+                ? getPiSession(this.currentThreadId, { sessionDir: this.sessionDir })
+                : null;
+        if (record) {
+            if (record.id !== this.currentThreadId)
+                changedFields.add("thread");
+            if (record.cwd && record.cwd !== this.currentWorkspace)
+                changedFields.add("workspace");
+            if (record.model && record.model !== this.currentModel)
+                changedFields.add("model");
+            if (record.reasoningEffort && record.reasoningEffort !== this.currentThinking)
+                changedFields.add("reasoning");
+            if (record.sessionPath !== this.currentSessionPath)
+                changedFields.add("sessionPath");
+            this.currentThreadId = record.id;
+            this.currentWorkspace = record.cwd || this.currentWorkspace;
+            this.currentSessionPath = record.sessionPath;
+            this.currentModel = record.model ?? this.currentModel;
+            this.currentThinking = record.reasoningEffort ?? this.currentThinking;
+            if (changedFields.has("thread") || changedFields.has("sessionPath")) {
+                this.cachedStats = {};
+            }
+        }
+        const changed = changedFields.size > 0 ||
+            before.threadId !== this.currentThreadId ||
+            before.workspace !== this.currentWorkspace ||
+            before.model !== this.currentModel ||
+            before.thinking !== this.currentThinking ||
+            before.sessionPath !== this.currentSessionPath;
+        let reattached = false;
+        if (changed && options.reattach && this.rpc && !this.processing) {
+            this.restartRpc();
+            reattached = true;
+        }
         return {
             threadId: this.currentThreadId,
-            changed: false,
-            reattached: false,
-            changedFields: [],
+            changed,
+            reattached,
+            changedFields: [...changedFields],
             info: this.getInfo(),
         };
     }
@@ -354,6 +414,7 @@ export class PiSessionService {
             sessionPath: this.currentSessionPath,
             model: this.currentModel,
             thinking: this.currentThinking,
+            ...this.currentLaunchProfile.cli,
             env: { PI_CODING_AGENT_SESSION_DIR: this.sessionDir },
         });
     }
@@ -433,11 +494,25 @@ export class PiSessionService {
             data: (await readFile(imagePath)).toString("base64"),
             mimeType: mimeTypeForImage(imagePath),
         })));
+        if (images.length > 0) {
+            const imageSupport = this.currentModelSupportsImages();
+            if (imageSupport === false) {
+                throw new Error(`Current Pi model does not support image input: ${this.currentModel}`);
+            }
+        }
         return {
             message: textParts.join("\n\n") || "Please inspect the attached file(s).",
             ...(images.length > 0 ? { images } : {}),
         };
     }
+    currentModelSupportsImages() {
+        const model = this.currentModel;
+        if (!model) {
+            return null;
+        }
+        const record = this.listModels().find((candidate) => candidate.slug === model || candidate.slug.endsWith(`/${model}`));
+        return record?.supportsImages ?? null;
+    }
     refreshFromTurnEnd(event, callbacks) {
         const message = objectValue(event.message);
         const usage = objectValue(message?.usage);
@@ -556,6 +631,19 @@ function parseCompactTokenCount(value) {
     const multiplier = unit === "M" ? 1_000_000 : unit === "K" ? 1_000 : unit === "B" ? 1_000_000_000 : 1;
     return Math.round(number * multiplier);
 }
+function parseYesNo(value) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.toLowerCase();
+    if (["yes", "true", "1"].includes(normalized)) {
+        return true;
+    }
+    if (["no", "false", "0"].includes(normalized)) {
+        return false;
+    }
+    return undefined;
+}
 function mimeTypeForImage(filePath) {
     switch (path.extname(filePath).toLowerCase()) {
         case ".png":

package/dist/pi-state.js

@@ -48,6 +48,58 @@ export function getPiSession(idOrPath, options = {}) {
         path.basename(record.sessionPath, ".jsonl").endsWith(`_${normalized}`));
     return matches[0] ?? null;
 }
+export function getPiSessionActivity(idOrPath, options = {}) {
+    return getPiSessionSnapshot(idOrPath, { ...options, maxEvents: 0 })?.activity ?? null;
+}
+export function getPiSessionActivityLog(idOrPath, limit = 50, options = {}) {
+    const snapshot = getPiSessionSnapshot(idOrPath, { ...options, maxEvents: Math.max(1, limit) });
+    return snapshot?.events.slice(-Math.max(1, limit)) ?? [];
+}
+export function getPiSessionSnapshot(idOrPath, options = {}) {
+    const record = getPiSession(idOrPath, options);
+    if (!record) {
+        return null;
+    }
+    return readPiSessionSnapshot(record, options);
+}
+export function getPiSessionDiagnostics(idOrPath, options = {}) {
+    const sessionDir = resolvePiSessionDir(options);
+    if (!idOrPath) {
+        return {
+            sessionDir,
+            sessionPath: null,
+            lineCount: 0,
+            status: "unavailable",
+            reason: "no active Pi session",
+            updatedAt: null,
+        };
+    }
+    const snapshot = getPiSessionSnapshot(idOrPath, { ...options, maxEvents: 0 });
+    if (!snapshot) {
+        return {
+            sessionDir,
+            sessionPath: null,
+            lineCount: 0,
+            status: "unavailable",
+            reason: "session file not found or unreadable",
+            updatedAt: null,
+        };
+    }
+    const status = snapshot.activity.active ? "active" : snapshot.activity.stale ? "stale" : "idle";
+    const reason = snapshot.activity.active
+        ? "latest Pi user turn has no assistant response yet"
+        : snapshot.activity.stale
+            ? "open Pi turn exceeded stale timeout"
+            : "latest Pi turn has a terminal response";
+    return {
+        sessionDir,
+        sessionPath: snapshot.sourcePath,
+        lineCount: snapshot.lineCount,
+        status,
+        reason,
+        updatedAt: snapshot.activity.updatedAt,
+    };
+}
 export function listPiWorkspaces(options = {}) {
     const workspaces = new Set();
     for (const record of listPiSessions(500, options)) {
@@ -131,6 +183,178 @@ export function readPiSessionRecord(sessionPath, workspaceSlug) {
         return null;
     }
 }
+function readPiSessionSnapshot(record, options = {}) {
+    try {
+        const fileStat = statSync(record.sessionPath);
+        const lines = readFileSync(record.sessionPath, "utf8")
+            .split(/\r?\n/)
+            .filter(Boolean);
+        const parsed = parsePiActivityEvents(lines, record.id, 0);
+        const staleAfterMs = options.staleAfterMs ?? 5 * 60 * 1000;
+        const nowMs = options.nowMs ?? Date.now();
+        const latestUser = [...parsed.events].reverse().find((event) => event.kind === "user");
+        const latestAgent = [...parsed.events].reverse().find((event) => event.kind === "agent");
+        const latestTerminal = [...parsed.events].reverse().find((event) => event.kind === "task" && event.status && event.status !== "started");
+        const latestTool = [...parsed.events].reverse().find((event) => event.kind === "tool" && event.toolName);
+        const latestTimestamp = parsed.latestTimestamp ?? fileStat.mtime;
+        const activeStartedAt = latestUser?.timestamp ?? null;
+        const hasAssistantAfterUser = Boolean(latestUser && latestAgent && latestAgent.lineNumber > latestUser.lineNumber);
+        const terminalAfterUser = Boolean(latestUser && latestTerminal && latestTerminal.lineNumber > latestUser.lineNumber);
+        const openTurn = Boolean(latestUser && !hasAssistantAfterUser && !terminalAfterUser);
+        const stale = openTurn && nowMs - latestTimestamp.getTime() > staleAfterMs;
+        const active = openTurn && !stale;
+        const turnId = latestUser?.turnId ?? latestTerminal?.turnId ?? null;
+        const maxEvents = options.maxEvents ?? 50;
+        const afterLine = options.afterLine ?? 0;
+        const events = maxEvents <= 0 ? [] : parsed.events.filter((event) => event.lineNumber > afterLine).slice(-maxEvents);
+        return {
+            agentId: "pi",
+            agentLabel: "Pi",
+            threadId: record.id,
+            sourcePath: record.sessionPath,
+            sourceLabel: "Pi session",
+            lineCount: lines.length,
+            activity: {
+                agentId: "pi",
+                agentLabel: "Pi",
+                threadId: record.id,
+                sourcePath: record.sessionPath,
+                sourceLabel: "Pi session",
+                active,
+                stale,
+                turnId,
+                startedAt: activeStartedAt,
+                updatedAt: latestTimestamp,
+            },
+            events,
+            latestAgentMessage: latestAgent?.text ?? null,
+            latestUserMessage: latestUser?.text ?? null,
+            latestToolName: latestTool?.toolName ?? null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function parsePiActivityEvents(lines, sessionId, afterLine) {
+    const events = [];
+    let latestTimestamp = null;
+    let currentTurnId = null;
+    for (const [index, line] of lines.entries()) {
+        const lineNumber = index + 1;
+        const entry = safeJsonParse(line);
+        if (!entry) {
+            continue;
+        }
+        const timestamp = dateValue(entry.timestamp) ?? dateValue(objectValue(entry.message)?.timestamp);
+        if (timestamp && (!latestTimestamp || timestamp > latestTimestamp)) {
+            latestTimestamp = timestamp;
+        }
+        const type = stringValue(entry.type) ?? "entry";
+        if (type === "message") {
+            const message = objectValue(entry.message);
+            const role = stringValue(message?.role);
+            const text = message ? extractMessageText(message) : null;
+            if (role === "user") {
+                currentTurnId = `pi-${sessionId}-${lineNumber}`;
+                pushEvent(events, afterLine, {
+                    lineNumber,
+                    kind: "task",
+                    timestamp,
+                    type: "turn",
+                    turnId: currentTurnId,
+                    status: "started",
+                    text,
+                    toolName: null,
+                    phase: null,
+                });
+                pushEvent(events, afterLine, {
+                    lineNumber,
+                    kind: "user",
+                    timestamp,
+                    type,
+                    turnId: currentTurnId,
+                    status: null,
+                    text,
+                    toolName: null,
+                    phase: null,
+                });
+            }
+            else if (role === "assistant") {
+                pushEvent(events, afterLine, {
+                    lineNumber,
+                    kind: "agent",
+                    timestamp,
+                    type,
+                    turnId: currentTurnId,
+                    status: "completed",
+                    text,
+                    toolName: null,
+                    phase: null,
+                });
+                pushEvent(events, afterLine, {
+                    lineNumber,
+                    kind: "task",
+                    timestamp,
+                    type: "turn",
+                    turnId: currentTurnId,
+                    status: "completed",
+                    text: null,
+                    toolName: null,
+                    phase: null,
+                });
+            }
+            else if (role === "tool") {
+                pushEvent(events, afterLine, {
+                    lineNumber,
+                    kind: "tool",
+                    timestamp,
+                    type,
+                    turnId: currentTurnId,
+                    status: "finished",
+                    text,
+                    toolName: stringValue(message?.name) ?? extractToolName(message) ?? "tool",
+                    phase: null,
+                });
+            }
+            continue;
+        }
+        if (/tool/i.test(type)) {
+            const status = /start/i.test(type) ? "started" : /error|fail/i.test(type) ? "failed" : /end|finish|complete/i.test(type) ? "finished" : null;
+            pushEvent(events, afterLine, {
+                lineNumber,
+                kind: "tool",
+                timestamp,
+                type,
+                turnId: currentTurnId,
+                status,
+                text: extractContentText(entry),
+                toolName: stringValue(entry.toolName) ?? stringValue(entry.name) ?? "tool",
+                phase: null,
+            });
+            continue;
+        }
+        if (/error|fail/i.test(type)) {
+            pushEvent(events, afterLine, {
+                lineNumber,
+                kind: "task",
+                timestamp,
+                type,
+                turnId: currentTurnId,
+                status: "failed",
+                text: stringValue(entry.error) ?? stringValue(entry.message),
+                toolName: null,
+                phase: null,
+            });
+        }
+    }
+    return { events, latestTimestamp };
+}
+function pushEvent(events, afterLine, event) {
+    if (event.lineNumber > afterLine) {
+        events.push(event);
+    }
+}
 function safeReadDir(directory) {
     try {
         return readdirSync(directory);
@@ -217,6 +441,35 @@ function extractMessageText(message) {
         .filter(Boolean);
     return parts.join("\n").trim() || null;
 }
+function extractContentText(container) {
+    const direct = stringValue(container.text) ?? stringValue(container.error);
+    if (direct) {
+        return direct;
+    }
+    const content = container.content;
+    if (typeof content === "string") {
+        return content.trim() || null;
+    }
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    const text = content
+        .map((entry) => {
+        const block = objectValue(entry);
+        return block ? stringValue(block.text) ?? stringValue(block.content) ?? "" : "";
+    })
+        .filter(Boolean)
+        .join("\n")
+        .trim();
+    return text || null;
+}
+function extractToolName(message) {
+    if (!message) {
+        return null;
+    }
+    const toolCall = objectValue(message.toolCall) ?? objectValue(message.tool_call);
+    return stringValue(toolCall?.name) ?? stringValue(toolCall?.toolName) ?? stringValue(message.toolName);
+}
 function summarizeTitle(text) {
     if (!text) {
         return null;