@streichsbaer/pi-mesh 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./pi-session-parser.js";
+export * from "./registry.js";
+export * from "./mesh.js";
+export * from "./lock.js";
+export * from "./pi-runner.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./pi-session-parser.js";
+export * from "./registry.js";
+export * from "./mesh.js";
+export * from "./lock.js";
+export * from "./pi-runner.js";

package/dist/live-socket.d.ts

@@ -0,0 +1,17 @@
+import net from "node:net";
+import type { DeliveryMode, ModelSelection } from "./types.js";
+export interface LiveSocketSession {
+    isStreaming: boolean;
+    agent: {
+        waitForIdle: () => Promise<void>;
+    };
+}
+export interface StartSessionSocketOptions<TSession extends LiveSocketSession> {
+    socketPath: string;
+    getSession: () => TSession;
+    deliverToSession: (session: TSession, message: string, delivery: DeliveryMode) => Promise<void>;
+    applyModelSelection: (session: TSession, selection: ModelSelection | undefined) => Promise<void>;
+    onStatus?: (status: "busy" | "idle" | "error", error?: string) => Promise<void> | void;
+}
+export declare function startSessionSocket<TSession extends LiveSocketSession>(options: StartSessionSocketOptions<TSession>): Promise<net.Server>;
+export declare function sendToLiveSocket(socketPath: string, message: string, delivery?: DeliveryMode, modelSelection?: ModelSelection, timeoutMs?: number): Promise<void>;

package/dist/live-socket.js

@@ -0,0 +1,116 @@
+import { promises as fs } from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import { hasModelSelection } from "./model-selection.js";
+import { ensurePrivateDir } from "./utils.js";
+export async function startSessionSocket(options) {
+    await ensurePrivateDir(path.dirname(options.socketPath));
+    await fs.rm(options.socketPath, { force: true }).catch(() => undefined);
+    let queue = Promise.resolve();
+    const enqueue = (task) => {
+        queue = queue.then(task, task);
+        void queue;
+    };
+    const server = net.createServer((socket) => {
+        let buffer = "";
+        socket.setEncoding("utf8");
+        socket.on("error", () => undefined); // Keep the live session running if a client disconnects.
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            while (true) {
+                const newlineIndex = buffer.indexOf("\n");
+                if (newlineIndex === -1)
+                    return;
+                const line = buffer.slice(0, newlineIndex).trim();
+                buffer = buffer.slice(newlineIndex + 1);
+                if (!line)
+                    continue;
+                let request;
+                try {
+                    request = JSON.parse(line);
+                    if (request.type !== "send" || !request.message)
+                        throw new Error("Expected send request with message");
+                }
+                catch (error) {
+                    socket.write(`${JSON.stringify({ type: "response", success: false, error: error.message })}\n`);
+                    continue;
+                }
+                enqueue(async () => {
+                    let markedBusy = false;
+                    try {
+                        const session = options.getSession();
+                        if (hasModelSelection(request.modelSelection) && session.isStreaming) {
+                            throw new Error("Cannot change model or thinking level while target session is busy; wait until idle or send without model options.");
+                        }
+                        await options.applyModelSelection(session, request.modelSelection);
+                        await options.onStatus?.("busy");
+                        markedBusy = true;
+                        await options.deliverToSession(session, request.message, request.delivery ?? "auto");
+                        await session.agent.waitForIdle();
+                        await options.onStatus?.("idle");
+                        socket.write(`${JSON.stringify({ id: request.id, type: "response", success: true })}\n`);
+                    }
+                    catch (error) {
+                        if (markedBusy)
+                            await options.onStatus?.("error", error.message);
+                        socket.write(`${JSON.stringify({ id: request.id, type: "response", success: false, error: error.message })}\n`);
+                    }
+                });
+            }
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(options.socketPath, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    return server;
+}
+export async function sendToLiveSocket(socketPath, message, delivery = "auto", modelSelection, timeoutMs = 0) {
+    const id = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    const request = { id, type: "send", message, delivery, modelSelection };
+    await new Promise((resolve, reject) => {
+        const socket = net.createConnection(socketPath);
+        let buffer = "";
+        let settled = false;
+        const timer = timeoutMs > 0
+            ? setTimeout(() => finish(new Error(`Socket request timed out after ${timeoutMs}ms`)), timeoutMs)
+            : undefined;
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            if (error)
+                reject(error);
+            else
+                resolve();
+            socket.destroy();
+        };
+        socket.setEncoding("utf8");
+        socket.once("connect", () => socket.write(`${JSON.stringify(request)}\n`));
+        socket.once("error", (error) => finish(error));
+        socket.once("end", () => finish(new Error("Socket closed before response")));
+        socket.once("close", () => finish(new Error("Socket closed before response")));
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex === -1)
+                return;
+            const line = buffer.slice(0, newlineIndex).trim();
+            try {
+                const response = JSON.parse(line);
+                if (response.success)
+                    finish();
+                else
+                    finish(new Error(response.error || "Socket request failed"));
+            }
+            catch (error) {
+                finish(error);
+            }
+        });
+    });
+}

package/dist/lock.d.ts

@@ -0,0 +1,7 @@
+export interface LockOptions {
+    staleMs?: number;
+    waitMs?: number;
+    pollMs?: number;
+    heartbeatMs?: number;
+}
+export declare function withDirectoryLock<T>(lockDir: string, fn: () => Promise<T>, options?: LockOptions): Promise<T>;

package/dist/lock.js

@@ -0,0 +1,82 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+const DEFAULT_STALE_MS = 20 * 60 * 1000;
+const DEFAULT_WAIT_MS = 60 * 1000;
+const DEFAULT_POLL_MS = 250;
+const DEFAULT_HEARTBEAT_MS = 5_000;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isProcessAlive(pid) {
+    if (!pid || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+async function readOwner(lockDir) {
+    try {
+        return JSON.parse(await fs.readFile(path.join(lockDir, "owner.json"), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function touchLock(lockDir) {
+    const now = new Date();
+    await fs.utimes(lockDir, now, now).catch(() => undefined);
+    await fs.utimes(path.join(lockDir, "owner.json"), now, now).catch(() => undefined);
+}
+async function removeIfStale(lockDir, staleMs) {
+    const stat = await fs.stat(lockDir).catch(() => null);
+    if (!stat)
+        return;
+    if (Date.now() - stat.mtimeMs <= staleMs)
+        return;
+    const owner = await readOwner(lockDir);
+    if (isProcessAlive(owner?.pid)) {
+        await touchLock(lockDir);
+        return;
+    }
+    await fs.rm(lockDir, { recursive: true, force: true }).catch(() => undefined);
+}
+export async function withDirectoryLock(lockDir, fn, options = {}) {
+    const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
+    const waitMs = options.waitMs ?? DEFAULT_WAIT_MS;
+    const pollMs = options.pollMs ?? DEFAULT_POLL_MS;
+    const heartbeatMs = Math.max(1_000, Math.min(options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS, Math.max(1_000, staleMs / 3)));
+    const started = Date.now();
+    let heartbeat;
+    await fs.mkdir(path.dirname(lockDir), { recursive: true });
+    while (true) {
+        await removeIfStale(lockDir, staleMs);
+        try {
+            await fs.mkdir(lockDir);
+            await fs.writeFile(path.join(lockDir, "owner.json"), JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }, null, 2), "utf8");
+            break;
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "EEXIST")
+                throw error;
+            if (Date.now() - started > waitMs)
+                throw new Error(`Timed out waiting for lock: ${lockDir}`);
+            await sleep(pollMs);
+        }
+    }
+    heartbeat = setInterval(() => {
+        void touchLock(lockDir);
+    }, heartbeatMs);
+    try {
+        return await fn();
+    }
+    finally {
+        if (heartbeat)
+            clearInterval(heartbeat);
+        await fs.rm(lockDir, { recursive: true, force: true }).catch(() => undefined);
+    }
+}

package/dist/mesh.d.ts

@@ -0,0 +1,3 @@
+import type { MeshPaths } from "./types.js";
+export declare function resolveMesh(): Promise<MeshPaths>;
+export declare function ensureMesh(mesh: MeshPaths): Promise<void>;

package/dist/mesh.js

@@ -0,0 +1,22 @@
+import path from "node:path";
+import { ensureDir, piAgentDir } from "./utils.js";
+export async function resolveMesh() {
+    const baseDir = path.join(piAgentDir(), "pi-mesh");
+    const mesh = {
+        id: "local",
+        baseDir,
+        registryFile: path.join(baseDir, "registry.jsonl"),
+        inboxDir: path.join(baseDir, "inbox"),
+        locksDir: path.join(baseDir, "locks"),
+        socketDirFile: path.join(baseDir, "socket-dir"),
+    };
+    await ensureMesh(mesh);
+    return mesh;
+}
+export async function ensureMesh(mesh) {
+    await Promise.all([
+        ensureDir(mesh.baseDir),
+        ensureDir(mesh.inboxDir),
+        ensureDir(mesh.locksDir),
+    ]);
+}

package/dist/model-list.d.ts

@@ -0,0 +1,48 @@
+import { type AgentSessionServices } from "@earendil-works/pi-coding-agent";
+import { type ThinkingLevel } from "./types.js";
+export type ModelListServices = Pick<AgentSessionServices, "cwd" | "diagnostics" | "modelRegistry" | "settingsManager">;
+export interface ListModelsOptions {
+    cwd: string;
+    search?: string;
+    includeAll?: boolean;
+    scopedOnly?: boolean;
+}
+export interface ListedModel {
+    provider: string;
+    model: string;
+    ref: string;
+    name?: string;
+    available: boolean;
+    scoped: boolean;
+    matchedScopedPatterns: string[];
+    default: boolean;
+    contextWindow: number;
+    maxTokens: number;
+    thinking: boolean;
+    images: boolean;
+}
+export interface ModelListResult {
+    ok: true;
+    folder: string;
+    search?: string;
+    includeAll: boolean;
+    scopedOnly: boolean;
+    enabledModelPatterns: string[];
+    defaultModel?: {
+        provider?: string;
+        model?: string;
+        thinkingLevel?: ThinkingLevel;
+    };
+    scopedResolution: {
+        approximate: boolean;
+        note?: string;
+    };
+    diagnostics: Array<{
+        type: string;
+        message: string;
+    }>;
+    models: ListedModel[];
+}
+export declare function listModelsFromServices(services: ModelListServices, options: ListModelsOptions): ModelListResult;
+export declare function listModels(options: ListModelsOptions): Promise<ModelListResult>;
+export declare function printModelList(result: ModelListResult): void;

package/dist/model-list.js

@@ -0,0 +1,208 @@
+import { createAgentSessionServices } from "@earendil-works/pi-coding-agent";
+import { THINKING_LEVELS } from "./types.js";
+const SCOPED_RESOLUTION_NOTE = "Pi does not currently export stable public helpers for CLI-equivalent model or scoped-model resolution; pi-mesh approximates enabledModels matching against Pi available models.";
+function formatModelRef(model) {
+    return `${model.provider}/${model.id}`;
+}
+function modelKey(model) {
+    return `${model.provider}\0${model.model}`;
+}
+function isThinkingLevel(value) {
+    return typeof value === "string" && THINKING_LEVELS.includes(value);
+}
+function stripThinkingSuffix(pattern) {
+    const colonIndex = pattern.lastIndexOf(":");
+    if (colonIndex <= 0)
+        return pattern;
+    return isThinkingLevel(pattern.slice(colonIndex + 1)) ? pattern.slice(0, colonIndex) : pattern;
+}
+function hasGlob(pattern) {
+    return /[*?[]/.test(pattern);
+}
+function globToRegExp(pattern) {
+    let source = "^";
+    for (const char of pattern) {
+        if (char === "*")
+            source += ".*";
+        else if (char === "?")
+            source += ".";
+        else
+            source += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+    }
+    return new RegExp(`${source}$`, "i");
+}
+function isDatedModelId(id) {
+    return /\d{4}[-_]\d{2}[-_]\d{2}|\d{8}/.test(id);
+}
+function chooseBestModel(matches) {
+    if (matches.length === 0)
+        return undefined;
+    const aliases = matches.filter((model) => !isDatedModelId(model.id));
+    const candidates = aliases.length ? aliases : matches;
+    return [...candidates].sort((a, b) => b.id.localeCompare(a.id))[0];
+}
+function findExactScopedModelReferenceMatch(pattern, models) {
+    const lower = pattern.toLowerCase();
+    const canonicalMatches = models.filter((model) => formatModelRef(model).toLowerCase() === lower);
+    if (canonicalMatches.length === 1)
+        return canonicalMatches[0];
+    if (canonicalMatches.length > 1)
+        return undefined;
+    const slashIndex = pattern.indexOf("/");
+    if (slashIndex !== -1) {
+        const provider = pattern.slice(0, slashIndex).trim().toLowerCase();
+        const modelId = pattern.slice(slashIndex + 1).trim().toLowerCase();
+        if (provider && modelId) {
+            const providerMatches = models.filter((model) => model.provider.toLowerCase() === provider && model.id.toLowerCase() === modelId);
+            if (providerMatches.length === 1)
+                return providerMatches[0];
+            if (providerMatches.length > 1)
+                return undefined;
+        }
+    }
+    const idMatches = models.filter((model) => model.id.toLowerCase() === lower);
+    return idMatches.length === 1 ? idMatches[0] : undefined;
+}
+function resolveScopedPattern(rawPattern, models) {
+    const pattern = stripThinkingSuffix(rawPattern.trim());
+    if (!pattern)
+        return [];
+    if (hasGlob(pattern)) {
+        const regex = globToRegExp(pattern);
+        return models.filter((model) => regex.test(formatModelRef(model)) || regex.test(model.id));
+    }
+    const exact = findExactScopedModelReferenceMatch(pattern, models);
+    if (exact)
+        return [exact];
+    const lower = pattern.toLowerCase();
+    const partial = models.filter((model) => model.id.toLowerCase().includes(lower) || Boolean(model.name?.toLowerCase().includes(lower)));
+    return [chooseBestModel(partial)].filter((model) => Boolean(model));
+}
+function matchesSearch(model, search) {
+    if (!search)
+        return true;
+    const lower = search.toLowerCase();
+    return [model.provider, model.model, model.ref, model.name]
+        .filter(Boolean)
+        .some((value) => String(value).toLowerCase().includes(lower));
+}
+export function listModelsFromServices(services, options) {
+    const allModels = services.modelRegistry.getAll();
+    const availableModels = services.modelRegistry.getAvailable();
+    const availableKeys = new Set(availableModels.map((model) => modelKey({ provider: model.provider, model: model.id })));
+    const enabledModelPatterns = services.settingsManager.getEnabledModels() ?? [];
+    const defaultProvider = services.settingsManager.getDefaultProvider();
+    const defaultModel = services.settingsManager.getDefaultModel();
+    const defaultThinkingLevel = services.settingsManager.getDefaultThinkingLevel();
+    const scopedMatches = new Map();
+    for (const pattern of enabledModelPatterns) {
+        for (const model of resolveScopedPattern(pattern, availableModels)) {
+            const key = modelKey({ provider: model.provider, model: model.id });
+            scopedMatches.set(key, [...(scopedMatches.get(key) ?? []), pattern]);
+        }
+    }
+    const sourceModels = options.includeAll ? allModels : availableModels;
+    const rows = sourceModels
+        .map((model) => {
+        const key = modelKey({ provider: model.provider, model: model.id });
+        const matchedScopedPatterns = scopedMatches.get(key) ?? [];
+        return {
+            provider: model.provider,
+            model: model.id,
+            ref: formatModelRef(model),
+            name: model.name,
+            available: availableKeys.has(key),
+            scoped: matchedScopedPatterns.length > 0,
+            matchedScopedPatterns,
+            default: model.provider === defaultProvider && model.id === defaultModel,
+            contextWindow: model.contextWindow,
+            maxTokens: model.maxTokens,
+            thinking: Boolean(model.reasoning),
+            images: model.input.includes("image"),
+        };
+    })
+        .filter((model) => !options.scopedOnly || model.scoped)
+        .filter((model) => matchesSearch(model, options.search))
+        .sort((a, b) => a.provider.localeCompare(b.provider) || a.model.localeCompare(b.model));
+    const diagnostics = [...services.diagnostics];
+    const loadError = services.modelRegistry.getError();
+    if (loadError)
+        diagnostics.push({ type: "warning", message: `errors loading models.json: ${loadError}` });
+    if (options.scopedOnly && enabledModelPatterns.length === 0) {
+        diagnostics.push({ type: "info", message: "No Pi enabledModels patterns are configured for this folder." });
+    }
+    return {
+        ok: true,
+        folder: services.cwd,
+        search: options.search,
+        includeAll: Boolean(options.includeAll),
+        scopedOnly: Boolean(options.scopedOnly),
+        enabledModelPatterns,
+        defaultModel: defaultProvider || defaultModel || defaultThinkingLevel
+            ? { provider: defaultProvider, model: defaultModel, thinkingLevel: defaultThinkingLevel }
+            : undefined,
+        scopedResolution: {
+            approximate: enabledModelPatterns.length > 0,
+            note: enabledModelPatterns.length > 0 ? SCOPED_RESOLUTION_NOTE : undefined,
+        },
+        diagnostics,
+        models: rows,
+    };
+}
+export async function listModels(options) {
+    return listModelsFromServices(await createAgentSessionServices({ cwd: options.cwd }), options);
+}
+function formatTokenCount(count) {
+    if (count >= 1_000_000) {
+        const millions = count / 1_000_000;
+        return millions % 1 === 0 ? `${millions}M` : `${millions.toFixed(1)}M`;
+    }
+    if (count >= 1_000) {
+        const thousands = count / 1_000;
+        return thousands % 1 === 0 ? `${thousands}K` : `${thousands.toFixed(1)}K`;
+    }
+    return String(count);
+}
+function pad(value, width) {
+    return value.padEnd(width);
+}
+export function printModelList(result) {
+    for (const diagnostic of result.diagnostics) {
+        const prefix = diagnostic.type === "error" ? "Error" : diagnostic.type === "warning" ? "Warning" : "Info";
+        console.error(`${prefix}: ${diagnostic.message}`);
+    }
+    if (result.scopedOnly && result.scopedResolution.note)
+        console.error(`Note: ${result.scopedResolution.note}`);
+    if (!result.models.length) {
+        console.log(result.search ? `No models matching ${JSON.stringify(result.search)}` : "No models found");
+        return;
+    }
+    const rows = result.models.map((model) => ({
+        provider: model.provider,
+        model: model.model,
+        available: model.available ? "yes" : "no",
+        scoped: model.scoped ? "yes" : "no",
+        default: model.default ? "yes" : "no",
+        context: formatTokenCount(model.contextWindow),
+        maxOut: formatTokenCount(model.maxTokens),
+        thinking: model.thinking ? "yes" : "no",
+        images: model.images ? "yes" : "no",
+    }));
+    const headers = {
+        provider: "provider",
+        model: "model",
+        available: "auth",
+        scoped: "scoped",
+        default: "default",
+        context: "context",
+        maxOut: "max-out",
+        thinking: "thinking",
+        images: "images",
+    };
+    const order = Object.keys(headers);
+    const widths = Object.fromEntries(order.map((key) => [key, Math.max(headers[key].length, ...rows.map((row) => row[key].length))]));
+    const formatRow = (row) => order.map((key) => pad(row[key], widths[key])).join("  ");
+    console.log(formatRow(headers));
+    for (const row of rows)
+        console.log(formatRow(row));
+}

package/dist/model-selection.d.ts

@@ -0,0 +1,47 @@
+import type { createAgentSession, SessionManager } from "@earendil-works/pi-coding-agent";
+import { type ModelSelection, type ThinkingLevel } from "./types.js";
+type AgentSessionInstance = Awaited<ReturnType<typeof createAgentSession>>["session"];
+type ModelRegistry = AgentSessionInstance["modelRegistry"];
+type PiModel = ReturnType<ModelRegistry["getAll"]>[number];
+export interface SessionContextSnapshot {
+    messages: unknown[];
+    model: {
+        provider: string;
+        modelId: string;
+    } | null;
+    thinkingLevel: string;
+    hasThinkingEntry: boolean;
+}
+export interface ResolvedModelSelection {
+    model?: PiModel;
+    thinkingLevel?: ThinkingLevel;
+    explicitModel: boolean;
+    explicitThinking: boolean;
+}
+export declare function isThinkingLevel(value: string | undefined): value is ThinkingLevel;
+export declare function hasModelSelection(selection: ModelSelection | undefined): selection is ModelSelection;
+export declare function formatModelRef(model: {
+    provider: string;
+    id: string;
+}): string;
+export declare function modelMatches(model: {
+    provider: string;
+    id: string;
+} | undefined, other: {
+    provider: string;
+    id: string;
+}): boolean;
+export declare function splitModelThinking(modelRef: string): {
+    modelRef: string;
+    thinkingLevel?: ThinkingLevel;
+};
+export declare function modelRefHasThinkingSuffix(modelRef: string | undefined): boolean;
+export declare function mergeModelSelection(base: ModelSelection | undefined, override: ModelSelection | undefined): ModelSelection | undefined;
+export declare function resolveModelRef(modelRegistry: ModelRegistry, requested: string, providerInput: string | undefined): PiModel;
+export declare function resolveRequestedModelSelection(modelRegistry: ModelRegistry, selection: ModelSelection | undefined): ResolvedModelSelection;
+export declare function getSessionContextSnapshot(sessionManager: SessionManager): SessionContextSnapshot;
+export declare function restoreModelFromSession(modelRegistry: ModelRegistry, snapshot: SessionContextSnapshot): PiModel | undefined;
+export declare function resolveSessionModelSelection(modelRegistry: ModelRegistry, snapshot: SessionContextSnapshot, selection: ModelSelection | undefined): ResolvedModelSelection;
+export declare function persistThinkingLevelIfNeeded(session: AgentSessionInstance, thinkingLevel: ThinkingLevel): void;
+export declare function persistExplicitSelectionIfNeeded(session: AgentSessionInstance, snapshot: SessionContextSnapshot, resolved: ResolvedModelSelection): Promise<void>;
+export {};