@nordbyte/nordrelay 0.2.1

package/dist/pi-state.js

@@ -0,0 +1,226 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function getDefaultPiSessionDir() {
+    return path.join(os.homedir(), ".pi", "agent", "sessions");
+}
+export function resolvePiSessionDir(options = {}) {
+    return options.sessionDir ?? process.env.PI_CODING_AGENT_SESSION_DIR ?? getDefaultPiSessionDir();
+}
+export function listPiSessions(limit = 20, options = {}) {
+    const sessionDir = resolvePiSessionDir(options);
+    if (!existsSync(sessionDir)) {
+        return [];
+    }
+    const records = [];
+    for (const workspaceDir of safeReadDir(sessionDir)) {
+        const workspacePath = path.join(sessionDir, workspaceDir);
+        if (!safeStat(workspacePath)?.isDirectory()) {
+            continue;
+        }
+        for (const fileName of safeReadDir(workspacePath)) {
+            if (!fileName.endsWith(".jsonl")) {
+                continue;
+            }
+            const sessionPath = path.join(workspacePath, fileName);
+            const record = readPiSessionRecord(sessionPath, workspaceDir);
+            if (record) {
+                records.push(record);
+            }
+        }
+    }
+    return records
+        .sort((left, right) => right.updatedAt.getTime() - left.updatedAt.getTime())
+        .slice(0, limit);
+}
+export function getPiSession(idOrPath, options = {}) {
+    const normalized = idOrPath.trim();
+    if (!normalized) {
+        return null;
+    }
+    if (existsSync(normalized)) {
+        return readPiSessionRecord(normalized, path.basename(path.dirname(normalized)));
+    }
+    const matches = listPiSessions(500, options).filter((record) => record.id === normalized ||
+        record.id.startsWith(normalized) ||
+        record.sessionPath === normalized ||
+        path.basename(record.sessionPath, ".jsonl") === normalized ||
+        path.basename(record.sessionPath, ".jsonl").endsWith(`_${normalized}`));
+    return matches[0] ?? null;
+}
+export function listPiWorkspaces(options = {}) {
+    const workspaces = new Set();
+    for (const record of listPiSessions(500, options)) {
+        if (record.cwd) {
+            workspaces.add(record.cwd);
+        }
+    }
+    return [...workspaces].sort((left, right) => left.localeCompare(right));
+}
+export function readPiSessionRecord(sessionPath, workspaceSlug) {
+    try {
+        const fileStat = statSync(sessionPath);
+        const lines = readFileSync(sessionPath, "utf8")
+            .split(/\r?\n/)
+            .filter(Boolean);
+        const fallbackDate = parsePiSessionDateFromFilename(path.basename(sessionPath)) ?? fileStat.mtime;
+        let id = parsePiSessionIdFromFilename(path.basename(sessionPath));
+        let createdAt = fallbackDate;
+        let updatedAt = fileStat.mtime;
+        let cwd = workspaceSlug ? decodePiWorkspaceSlug(workspaceSlug) : path.dirname(sessionPath);
+        let model = null;
+        let reasoningEffort = null;
+        let firstUserMessage = null;
+        let lastAssistantText = null;
+        let title = null;
+        let messageCount = 0;
+        for (const line of lines) {
+            const entry = safeJsonParse(line);
+            if (!entry) {
+                continue;
+            }
+            if (entry.type === "session") {
+                id = stringValue(entry.id) ?? id;
+                cwd = stringValue(entry.cwd) ?? cwd;
+                createdAt = dateValue(entry.timestamp) ?? createdAt;
+            }
+            else if (entry.type === "model_change") {
+                const provider = stringValue(entry.provider);
+                const modelId = stringValue(entry.modelId) ?? stringValue(entry.model);
+                model = modelId ? (provider ? `${provider}/${modelId}` : modelId) : model;
+            }
+            else if (entry.type === "thinking_level_change") {
+                reasoningEffort = stringValue(entry.thinkingLevel) ?? reasoningEffort;
+            }
+            const entryTimestamp = dateValue(entry.timestamp);
+            if (entryTimestamp && entryTimestamp > updatedAt) {
+                updatedAt = entryTimestamp;
+            }
+            const message = objectValue(entry.message);
+            if (message) {
+                messageCount += 1;
+                const role = stringValue(message.role);
+                if (role === "user" && !firstUserMessage) {
+                    firstUserMessage = extractMessageText(message);
+                }
+                else if (role === "assistant") {
+                    const assistantText = extractMessageText(message);
+                    if (assistantText) {
+                        lastAssistantText = assistantText;
+                    }
+                    model = stringValue(message.model) ?? model;
+                }
+            }
+            title = stringValue(entry.sessionName) ?? stringValue(entry.name) ?? title;
+        }
+        return {
+            id,
+            title: title ?? summarizeTitle(firstUserMessage ?? lastAssistantText),
+            cwd,
+            model,
+            reasoningEffort,
+            createdAt,
+            updatedAt,
+            firstUserMessage,
+            agentId: "pi",
+            sessionPath,
+            messageCount,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function safeReadDir(directory) {
+    try {
+        return readdirSync(directory);
+    }
+    catch {
+        return [];
+    }
+}
+function safeStat(targetPath) {
+    try {
+        return statSync(targetPath);
+    }
+    catch {
+        return null;
+    }
+}
+function safeJsonParse(line) {
+    try {
+        const parsed = JSON.parse(line);
+        return objectValue(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+function objectValue(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function dateValue(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return new Date(value);
+    }
+    if (typeof value === "string" && value.trim()) {
+        const timestamp = Date.parse(value);
+        return Number.isNaN(timestamp) ? null : new Date(timestamp);
+    }
+    return null;
+}
+function parsePiSessionIdFromFilename(fileName) {
+    const withoutExt = fileName.replace(/\.jsonl$/i, "");
+    const uuidMatch = withoutExt.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i);
+    if (uuidMatch) {
+        return uuidMatch[1];
+    }
+    const underscoreIndex = withoutExt.lastIndexOf("_");
+    return underscoreIndex === -1 ? withoutExt : withoutExt.slice(underscoreIndex + 1);
+}
+function parsePiSessionDateFromFilename(fileName) {
+    const match = fileName.match(/^(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z)_/);
+    if (!match) {
+        return null;
+    }
+    const normalized = match[1]
+        .replace(/T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z$/, "T$1:$2:$3.$4Z");
+    const timestamp = Date.parse(normalized);
+    return Number.isNaN(timestamp) ? null : new Date(timestamp);
+}
+function decodePiWorkspaceSlug(slug) {
+    const normalized = slug.replace(/^--/, "").replace(/--$/, "");
+    if (!normalized) {
+        return "/";
+    }
+    return `/${normalized.replace(/-/g, "/")}`;
+}
+function extractMessageText(message) {
+    const content = message.content;
+    if (typeof content === "string") {
+        return content.trim() || null;
+    }
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    const parts = content
+        .map((part) => {
+        const block = objectValue(part);
+        if (!block) {
+            return "";
+        }
+        return stringValue(block.text) ?? stringValue(block.thinking) ?? "";
+    })
+        .filter(Boolean);
+    return parts.join("\n").trim() || null;
+}
+function summarizeTitle(text) {
+    if (!text) {
+        return null;
+    }
+    const normalized = text.replace(/\s+/g, " ").trim();
+    return normalized.length <= 60 ? normalized : `${normalized.slice(0, 57)}...`;
+}

package/dist/prompt-store.js

@@ -0,0 +1,241 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import { readJsonFileWithBackup, writeJsonFileAtomic } from "./persistence.js";
+export class PromptStore {
+    persistPath;
+    lastPrompts = new Map();
+    queues = new Map();
+    pausedContexts = new Set();
+    constructor(workspace) {
+        this.persistPath = path.join(workspace, ".nordrelay", "prompts.json");
+        this.load();
+    }
+    setLastPrompt(contextKey, prompt) {
+        this.lastPrompts.set(contextKey, prompt);
+        this.persist();
+    }
+    getLastPrompt(contextKey) {
+        return this.lastPrompts.get(contextKey);
+    }
+    enqueue(contextKey, prompt) {
+        const item = {
+            ...prompt,
+            id: createQueueId(),
+            contextKey,
+            createdAt: Date.now(),
+        };
+        const queue = this.queues.get(contextKey) ?? [];
+        queue.push(item);
+        this.queues.set(contextKey, queue);
+        this.persist();
+        return item;
+    }
+    enqueueFront(contextKey, prompt) {
+        const queue = this.queues.get(contextKey) ?? [];
+        queue.unshift(prompt);
+        this.queues.set(contextKey, queue);
+        this.persist();
+    }
+    dequeue(contextKey) {
+        const queue = this.queues.get(contextKey);
+        const item = queue?.shift();
+        if (!queue || queue.length === 0) {
+            this.queues.delete(contextKey);
+        }
+        if (item) {
+            item.attempts = (item.attempts ?? 0) + 1;
+            item.updatedAt = Date.now();
+        }
+        this.persist();
+        return item;
+    }
+    list(contextKey) {
+        return [...(this.queues.get(contextKey) ?? [])];
+    }
+    listContextKeys() {
+        return [...new Set([...this.queues.keys(), ...this.pausedContexts])];
+    }
+    remove(contextKey, id) {
+        const queue = this.queues.get(contextKey);
+        if (!queue) {
+            return undefined;
+        }
+        const index = queue.findIndex((item) => item.id === id);
+        if (index === -1) {
+            return undefined;
+        }
+        const [removed] = queue.splice(index, 1);
+        if (queue.length === 0) {
+            this.queues.delete(contextKey);
+        }
+        this.persist();
+        return removed;
+    }
+    moveToTop(contextKey, id) {
+        const queue = this.queues.get(contextKey);
+        if (!queue) {
+            return undefined;
+        }
+        const index = queue.findIndex((item) => item.id === id);
+        if (index === -1) {
+            return undefined;
+        }
+        const [item] = queue.splice(index, 1);
+        queue.unshift(item);
+        this.persist();
+        return item;
+    }
+    moveUp(contextKey, id) {
+        const queue = this.queues.get(contextKey);
+        if (!queue) {
+            return undefined;
+        }
+        const index = queue.findIndex((item) => item.id === id);
+        if (index <= 0) {
+            return queue[index];
+        }
+        const [item] = queue.splice(index, 1);
+        queue.splice(index - 1, 0, item);
+        item.updatedAt = Date.now();
+        this.persist();
+        return item;
+    }
+    moveDown(contextKey, id) {
+        const queue = this.queues.get(contextKey);
+        if (!queue) {
+            return undefined;
+        }
+        const index = queue.findIndex((item) => item.id === id);
+        if (index === -1) {
+            return undefined;
+        }
+        if (index >= queue.length - 1) {
+            return queue[index];
+        }
+        const [item] = queue.splice(index, 1);
+        queue.splice(index + 1, 0, item);
+        item.updatedAt = Date.now();
+        this.persist();
+        return item;
+    }
+    markFailed(contextKey, item, error) {
+        item.lastError = error;
+        item.updatedAt = Date.now();
+        this.enqueueFront(contextKey, item);
+    }
+    clear(contextKey) {
+        const count = this.queues.get(contextKey)?.length ?? 0;
+        this.queues.delete(contextKey);
+        this.persist();
+        return count;
+    }
+    pause(contextKey) {
+        this.pausedContexts.add(contextKey);
+        this.persist();
+    }
+    resume(contextKey) {
+        this.pausedContexts.delete(contextKey);
+        this.persist();
+    }
+    isPaused(contextKey) {
+        return this.pausedContexts.has(contextKey);
+    }
+    persist() {
+        try {
+            mkdirSync(path.dirname(this.persistPath), { recursive: true });
+            const payload = {
+                lastPrompts: Object.fromEntries(this.lastPrompts.entries()),
+                queues: Object.fromEntries(this.queues.entries()),
+                pausedContexts: [...this.pausedContexts],
+            };
+            writeJsonFileAtomic(this.persistPath, payload);
+        }
+        catch (error) {
+            console.warn("Failed to persist prompt store:", error instanceof Error ? error.message : String(error));
+        }
+    }
+    load() {
+        try {
+            const payload = readJsonFileWithBackup(this.persistPath).value;
+            if (!payload) {
+                return;
+            }
+            for (const [contextKey, prompt] of Object.entries(payload.lastPrompts ?? {})) {
+                if (isPromptEnvelope(prompt)) {
+                    this.lastPrompts.set(contextKey, prompt);
+                }
+            }
+            for (const [contextKey, queue] of Object.entries(payload.queues ?? {})) {
+                if (Array.isArray(queue)) {
+                    this.queues.set(contextKey, queue.filter(isQueuedPrompt));
+                }
+            }
+            if (Array.isArray(payload.pausedContexts)) {
+                this.pausedContexts = new Set(payload.pausedContexts.filter((contextKey) => typeof contextKey === "string"));
+            }
+        }
+        catch (error) {
+            console.warn("Failed to load prompt store:", error instanceof Error ? error.message : String(error));
+        }
+    }
+}
+export function describePromptInput(input) {
+    if (typeof input === "string") {
+        return trimDescription(input);
+    }
+    const parts = [];
+    if (input.text) {
+        parts.push(trimDescription(input.text));
+    }
+    if (input.imagePaths?.length) {
+        parts.push(`${input.imagePaths.length} image${input.imagePaths.length === 1 ? "" : "s"}`);
+    }
+    if (input.stagedFileInstructions) {
+        parts.push("staged file input");
+    }
+    return parts.join(" · ") || "prompt";
+}
+export function toPromptEnvelope(input, artifactOutDir) {
+    return {
+        input,
+        artifactOutDir,
+        description: describePromptInput(input),
+    };
+}
+function createQueueId() {
+    return randomUUID().replace(/-/g, "").slice(0, 8);
+}
+function isPromptEnvelope(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    return isCodexPromptInput(candidate.input) && typeof candidate.description === "string";
+}
+function isQueuedPrompt(value) {
+    return isPromptEnvelope(value) &&
+        typeof value.id === "string" &&
+        typeof value.contextKey === "string" &&
+        typeof value.createdAt === "number" &&
+        (value.updatedAt === undefined || typeof value.updatedAt === "number") &&
+        (value.attempts === undefined || typeof value.attempts === "number") &&
+        (value.lastError === undefined || typeof value.lastError === "string");
+}
+function isCodexPromptInput(value) {
+    if (typeof value === "string") {
+        return true;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    return ((candidate.text === undefined || typeof candidate.text === "string") &&
+        (candidate.stagedFileInstructions === undefined || typeof candidate.stagedFileInstructions === "string") &&
+        (candidate.imagePaths === undefined ||
+            (Array.isArray(candidate.imagePaths) && candidate.imagePaths.every((item) => typeof item === "string"))));
+}
+function trimDescription(text) {
+    const singleLine = text.replace(/\s+/g, " ").trim();
+    return singleLine.length <= 80 ? singleLine : `${singleLine.slice(0, 79)}…`;
+}

package/dist/redaction.js

@@ -0,0 +1,47 @@
+const DEFAULT_SECRET_PATTERNS = [
+    /\b\d{6,}:[A-Za-z0-9_-]{24,}\b/g,
+    /\bsk-[A-Za-z0-9_-]{20,}\b/g,
+    /\b(?:OPENAI|CODEX|TELEGRAM|ANTHROPIC|GITHUB|GITLAB|NPM)_[A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD)\s*=\s*[^\s"'`]+/gi,
+    /\b(?:api[_-]?key|access[_-]?token|refresh[_-]?token|secret|password)\s*[:=]\s*[^\s"'`]+/gi,
+];
+let configuredPatterns = [];
+export function configureRedaction(rawPatterns) {
+    configuredPatterns = rawPatterns
+        .map((pattern) => {
+        try {
+            return new RegExp(pattern, "gi");
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((pattern) => Boolean(pattern));
+}
+export function redactText(text) {
+    let redacted = text;
+    for (const pattern of [...DEFAULT_SECRET_PATTERNS, ...configuredPatterns]) {
+        redacted = redacted.replace(pattern, (match) => redactMatch(match));
+    }
+    return redacted;
+}
+export function redactUnknown(value) {
+    if (value instanceof Error) {
+        return `${value.name}: ${redactText(value.message)}`;
+    }
+    if (typeof value === "string") {
+        return redactText(value);
+    }
+    try {
+        return redactText(JSON.stringify(value));
+    }
+    catch {
+        return redactText(String(value));
+    }
+}
+function redactMatch(match) {
+    const separator = match.match(/^([^:=]+[:=]\s*)/);
+    if (separator?.[1]) {
+        return `${separator[1]}[REDACTED]`;
+    }
+    return "[REDACTED]";
+}