@streichsbaer/pi-mesh 0.1.2 → 0.1.4

package/README.md

@@ -12,10 +12,10 @@
 ## Installation
 
 ```bash
-npm install -g @streichsbaer/pi-mesh
+npm install -g @streichsbaer/pi-mesh --ignore-scripts
 ```
 
-The package installs the `pi-mesh` binary.
+The package installs the `pi-mesh` binary and does not require npm install scripts.
 
 ## Goals
 
@@ -33,6 +33,7 @@ pi-mesh sessions list --include-pi  # include recent unmanaged Pi sessions
 pi-mesh sessions find auth
 pi-mesh sessions list --folder ./api
 pi-mesh sessions list --label pi-mesh-development
+pi-mesh sessions delete worker-api
 pi-mesh models list sonnet --folder ./api --scoped
 pi-mesh transcript <session> --last 3
 pi-mesh state <session>
@@ -76,7 +77,6 @@ State is stored outside the repo:
 ```text
 ~/.pi/agent/pi-mesh/
   registry.jsonl
-  inbox/
   locks/
   socket-dir
 ```
@@ -87,6 +87,8 @@ Live control sockets use short hashed paths under a private randomized runtime d
 
 Already-running normal Pi sessions can be discovered and read from their JSONL files. `pi-mesh sessions list` shows managed sessions by default; pass `--include-pi` or `--all` to include recent unmanaged Pi sessions. To message one, close the original process first and attach/resume it through `pi-mesh attach` so pi-mesh can own the live control socket.
 
+Use `pi-mesh sessions delete <session>` to remove a stopped managed session from the local registry. Active sessions, including records with a live process or socket, must be stopped first. The Pi JSONL session file is kept unless `--delete-file` is passed and confirmed; pass `--force` to skip that file-delete confirmation.
+
 ## Install for development
 
 ```bash

package/dist/cli.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import { promises as fs } from "node:fs";
 import path from "node:path";
+import { createInterface } from "node:readline/promises";
 import { exists } from "./utils.js";
 import { formatTimestamp, truncate, compactWhitespace } from "./utils.js";
 import { loadSessionData, loadSessionDataForSession, renderToolLine, resolveSessionSpec, searchSessions, tail } from "./pi-session-parser.js";
-import { createMeshId, filterManagedSessions, findManagedSessions, listManagedSessions, lockPathFor, normalizeLabels, socketPathFor, upsertManagedSession } from "./registry.js";
+import { createMeshId, deleteManagedSession, filterManagedSessions, findManagedSessionById, findManagedSessions, listManagedSessions, lockPathFor, normalizeLabels, socketPathFor, upsertManagedSession } from "./registry.js";
 import { resolveMesh } from "./mesh.js";
 import { withDirectoryLock } from "./lock.js";
 import { mergeModelSelection } from "./model-selection.js";
@@ -137,6 +138,15 @@ async function getSessionSelector(args, spec) {
 function isLiveStatus(status) {
     return status === "running" || status === "idle" || status === "busy" || status === "starting";
 }
+async function activeSessionReason(record) {
+    if (isLiveStatus(record.status))
+        return `status=${record.status}`;
+    if (record.socketPath && await exists(record.socketPath))
+        return `socket=${record.socketPath}`;
+    if (record.status === "error" && isProcessAlive(record.pid))
+        return `pid=${record.pid}`;
+    return undefined;
+}
 function formatMatches(records) {
     return records.map((record) => `- ${record.meshId}${record.name ? ` name=${JSON.stringify(record.name)}` : ""} folder=${record.folder} status=${record.status}`).join("\n");
 }
@@ -147,14 +157,44 @@ function isProcessAlive(pid) {
         process.kill(pid, 0);
         return true;
     }
-    catch {
-        return false;
+    catch (error) {
+        return error.code === "EPERM";
     }
 }
 function isStaleSocketError(error) {
     const code = error?.code;
     return code === "ECONNREFUSED" || code === "ENOENT" || code === "EPIPE" || code === "ECONNRESET";
 }
+async function confirmDeleteSessionFile(sessionFile) {
+    if (!process.stdin.isTTY || !process.stderr.isTTY) {
+        throw new Error("--delete-file requires an interactive terminal. Pass --force to delete the session file without confirmation.");
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        for (;;) {
+            const answer = (await rl.question(`Delete session file ${sessionFile}? [Y/n] `)).trim().toLowerCase();
+            if (answer === "" || answer === "y" || answer === "yes")
+                return true;
+            if (answer === "n" || answer === "no")
+                return false;
+            console.error("Please answer y or n.");
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+async function removeExistingFile(filePath) {
+    try {
+        await fs.rm(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
 async function refreshStaleManagedSessions(mesh, records) {
     const refreshed = [];
     for (const record of records) {
@@ -178,6 +218,7 @@ function printHelp() {
 Usage:
   pi-mesh sessions list [--folder <dir>] [--name <name>] [--label <label>] [--limit 25] [--json] [--include-pi|--all]
   pi-mesh sessions find <query> [--folder <dir>] [--name <name>] [--label <label>] [--limit 25] [--json] [--include-pi|--all]
+  pi-mesh sessions delete <session> [--folder <dir>] [--name <name>] [--label <label>] [--delete-file] [--force] [--json]
   pi-mesh transcript <session> [--folder <dir>] [--name <name>] [--label <label>] [--last 3] [--json] [--show-tools]
   pi-mesh state <session> [--folder <dir>] [--name <name>] [--label <label>] [--json]
   pi-mesh models list [search] [--folder <dir>] [--json] [--all] [--scoped]
@@ -256,6 +297,51 @@ async function cmdSessions(parsed) {
         }
         return;
     }
+    if (sub === "delete" || sub === "remove" || sub === "forget") {
+        const spec = parsed.positionals[2];
+        if (!spec)
+            throw new Error("Usage: pi-mesh sessions delete <session>");
+        const selector = await getSessionSelector(parsed, spec);
+        const matches = await findManagedSessions(mesh, selector);
+        if (matches.length === 0)
+            throw new Error(`No managed session matches ${JSON.stringify(spec)}.`);
+        if (matches.length > 1)
+            throw new Error(`Multiple managed sessions match ${JSON.stringify(spec)}; refine with --folder, --name, or --label:\n${formatMatches(matches)}`);
+        const deleteFileRequested = getBool(parsed, "delete-file");
+        const force = getBool(parsed, "force");
+        const confirmedSessionFile = matches[0].sessionFile;
+        await assertNotAlreadyActive(matches[0], "deleting it");
+        const deleteFileApproved = deleteFileRequested && (force || await confirmDeleteSessionFile(confirmedSessionFile));
+        const result = await withDirectoryLock(lockPathFor(mesh, matches[0].meshId), async () => {
+            const record = await findManagedSessionById(mesh, matches[0].meshId);
+            if (!record)
+                throw new Error(`Session ${matches[0].meshId} was deleted concurrently.`);
+            await assertNotAlreadyActive(record, "deleting it");
+            let deletedFile = false;
+            if (deleteFileApproved) {
+                if (!force && record.sessionFile !== confirmedSessionFile) {
+                    throw new Error(`Session file changed from ${confirmedSessionFile} to ${record.sessionFile}; rerun delete to confirm the new file.`);
+                }
+                deletedFile = await removeExistingFile(record.sessionFile);
+            }
+            if (record.socketPath)
+                await fs.rm(record.socketPath, { force: true }).catch(() => undefined);
+            await deleteManagedSession(mesh, record.meshId);
+            return { record, deletedFile };
+        });
+        if (asJson) {
+            console.log(JSON.stringify({ ok: true, deleted: result.record, deletedFile: result.deletedFile }, null, 2));
+            return;
+        }
+        console.log(`Deleted managed session ${result.record.meshId} from the pi-mesh registry.`);
+        if (result.deletedFile)
+            console.log(`Deleted session file ${result.record.sessionFile}.`);
+        else if (deleteFileRequested)
+            console.log(`Kept session file ${result.record.sessionFile}.`);
+        else
+            console.log(`Kept session file ${result.record.sessionFile}. Pass --delete-file to remove it too.`);
+        return;
+    }
     if (sub === "find") {
         const query = parsed.positionals.slice(2).join(" ").trim();
         if (!query)
@@ -443,8 +529,8 @@ async function registerSession(mesh, input) {
         folder: input.folder,
         sessionFile: input.sessionFile,
         rawSessionId: input.rawSessionId,
-        pid: process.pid,
-        socketPath: input.socketPath,
+        pid: input.status === "offline" ? undefined : process.pid,
+        socketPath: input.status === "offline" ? undefined : input.socketPath,
         createdAt: now,
         updatedAt: now,
         lastError: input.lastError,
@@ -453,12 +539,29 @@ async function registerSession(mesh, input) {
 }
 async function upsertManagedStatus(mesh, record, patch) {
     const pendingModelSelection = record.pendingModelSelection && (await exists(record.sessionFile)) ? undefined : record.pendingModelSelection;
-    return upsertManagedSession(mesh, { ...record, pendingModelSelection, ...patch });
+    const next = { ...record, pendingModelSelection, ...patch };
+    if (next.status === "offline") {
+        next.pid = undefined;
+        next.socketPath = undefined;
+    }
+    return upsertManagedSession(mesh, next);
 }
-function assertNotAlreadyLive(record, action) {
-    if (!record || !isLiveStatus(record.status) || !isProcessAlive(record.pid))
+async function assertNotAlreadyActive(record, action) {
+    if (!record)
+        return;
+    const activeReason = await activeSessionReason(record);
+    if (!activeReason)
         return;
-    throw new Error(`Session ${record.meshId} is already live (${record.status}); use pi-mesh send or stop that TUI before ${action}.`);
+    throw new Error(`Session ${record.meshId} is already active (${activeReason}); use pi-mesh send or stop that TUI before ${action}.`);
+}
+async function claimManagedSessionForActivation(mesh, record, patch, action) {
+    return withDirectoryLock(lockPathFor(mesh, record.meshId), async () => {
+        const latest = await findManagedSessionById(mesh, record.meshId);
+        if (!latest)
+            throw new Error(`Session ${record.meshId} was deleted concurrently.`);
+        await assertNotAlreadyActive(latest, action);
+        return upsertManagedSession(mesh, { ...latest, ...patch });
+    });
 }
 async function cmdSpawn(parsed) {
     const folder = await resolveFolder(getString(parsed, "folder") || process.cwd());
@@ -524,6 +627,8 @@ async function cmdSpawn(parsed) {
             sessionFile: result.sessionFile || record.sessionFile,
             rawSessionId: result.rawSessionId,
             status: "offline",
+            pid: undefined,
+            socketPath: undefined,
             pendingModelSelection: undefined,
         });
     }
@@ -549,15 +654,26 @@ async function cmdRun(parsed) {
             throw new Error(`Multiple sessions named ${JSON.stringify(name)} match this folder/label selection; use a session id or --new:\n${formatMatches(matches)}`);
         existing = matches[0];
     }
-    assertNotAlreadyLive(existing, "opening another live TUI");
-    const sessionFile = existing?.sessionFile;
+    await assertNotAlreadyActive(existing, "opening another live TUI");
     const pendingModelSelection = existing && !(await exists(existing.sessionFile)) ? existing.pendingModelSelection : undefined;
     const seedModelSelection = mergeModelSelection(pendingModelSelection, rawModelSelection);
     const runFolder = existing?.folder || folder;
     const modelSelection = await validateCliModelSelection(runFolder, seedModelSelection);
-    const meshId = existing?.meshId || createMeshId({ folder: runFolder, sessionFile });
+    const meshId = existing?.meshId || createMeshId({ folder: runFolder, sessionFile: existing?.sessionFile });
     const socketPath = await socketPathFor(mesh, meshId);
     let record = existing;
+    if (record) {
+        record = await claimManagedSessionForActivation(mesh, record, {
+            name,
+            labels: labels.length ? labels : record.labels,
+            kind: "interactive",
+            status: "starting",
+            pid: process.pid,
+            socketPath,
+            pendingModelSelection: modelSelection && !(await exists(record.sessionFile)) ? modelSelection : undefined,
+        }, "opening another live TUI");
+    }
+    const sessionFile = record?.sessionFile;
     const { runInteractive } = await import("./pi-runner.js");
     await runInteractive({
         cwd: runFolder,
@@ -602,7 +718,7 @@ async function cmdAttach(parsed) {
     const mesh = await getMesh();
     await refreshStaleManagedSessions(mesh, await listManagedSessions(mesh));
     const resolved = await resolveSessionFile(mesh, spec);
-    assertNotAlreadyLive(resolved.managed, "attaching it again");
+    await assertNotAlreadyActive(resolved.managed, "attaching it again");
     const folder = getString(parsed, "folder") ? await resolveFolder(getString(parsed, "folder")) : resolved.folder;
     const pendingModelSelection = resolved.managed && !(await exists(resolved.managed.sessionFile)) ? resolved.managed.pendingModelSelection : undefined;
     const seedModelSelection = mergeModelSelection(pendingModelSelection, rawModelSelection);
@@ -612,13 +728,25 @@ async function cmdAttach(parsed) {
     const meshId = resolved.managed?.meshId || createMeshId({ folder, sessionFile: resolved.sessionFile });
     const socketPath = await socketPathFor(mesh, meshId);
     let record = resolved.managed;
+    if (record) {
+        record = await claimManagedSessionForActivation(mesh, record, {
+            name,
+            labels: labels.length ? labels : record.labels,
+            folder,
+            kind: "attached",
+            status: "starting",
+            pid: process.pid,
+            socketPath,
+            pendingModelSelection: modelSelection && !(await exists(record.sessionFile)) ? modelSelection : undefined,
+        }, "attaching it again");
+    }
     if (!resolved.managed) {
         console.error("Note: attaching an unmanaged Pi session. Close any other Pi process using the same JSONL file first.");
     }
     const { runInteractive } = await import("./pi-runner.js");
     await runInteractive({
         cwd: folder,
-        sessionFile: resolved.sessionFile,
+        sessionFile: record?.sessionFile || resolved.sessionFile,
         name,
         socketPath,
         modelSelection,
@@ -696,6 +824,8 @@ async function deliverToManagedSession(mesh, managed, message, delivery, rawMode
                 sessionFile: result.sessionFile || managed.sessionFile,
                 rawSessionId: result.rawSessionId,
                 status: "offline",
+                pid: undefined,
+                socketPath: undefined,
                 lastError: undefined,
                 pendingModelSelection: undefined,
             });

package/dist/mesh.js

@@ -6,7 +6,6 @@ export async function resolveMesh() {
         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"),
     };
@@ -16,7 +15,6 @@ export async function resolveMesh() {
 export async function ensureMesh(mesh) {
     await Promise.all([
         ensureDir(mesh.baseDir),
-        ensureDir(mesh.inboxDir),
         ensureDir(mesh.locksDir),
     ]);
 }

package/dist/registry.d.ts

@@ -17,8 +17,10 @@ export declare function listManagedSessions(mesh: MeshPaths): Promise<ManagedSes
 export declare function sessionMatchesSelector(record: ManagedSessionRecord, selector: SessionSelector): boolean;
 export declare function filterManagedSessions(records: ManagedSessionRecord[], selector: SessionSelector): ManagedSessionRecord[];
 export declare function findManagedSessions(mesh: MeshPaths, selector: SessionSelector): Promise<ManagedSessionRecord[]>;
+export declare function findManagedSessionById(mesh: MeshPaths, meshId: string): Promise<ManagedSessionRecord | undefined>;
 export declare function findManagedSession(mesh: MeshPaths, spec: string): Promise<ManagedSessionRecord | undefined>;
 export declare function upsertManagedSession(mesh: MeshPaths, record: ManagedSessionRecord): Promise<ManagedSessionRecord>;
+export declare function deleteManagedSession(mesh: MeshPaths, meshId: string): Promise<void>;
 export declare function markManagedSession(mesh: MeshPaths, meshId: string, patch: Partial<ManagedSessionRecord>): Promise<ManagedSessionRecord | undefined>;
 export declare function socketPathFor(mesh: MeshPaths, meshId: string): Promise<string>;
 export declare function lockPathFor(mesh: MeshPaths, meshId: string): string;

package/dist/registry.js

@@ -77,6 +77,9 @@ export function filterManagedSessions(records, selector) {
 export async function findManagedSessions(mesh, selector) {
     return filterManagedSessions(await listManagedSessions(mesh), selector);
 }
+export async function findManagedSessionById(mesh, meshId) {
+    return (await listManagedSessions(mesh)).find((record) => record.meshId === meshId);
+}
 export async function findManagedSession(mesh, spec) {
     return (await findManagedSessions(mesh, { spec }))[0];
 }
@@ -97,6 +100,9 @@ export async function upsertManagedSession(mesh, record) {
     await appendRegistryEvent(mesh, { type: "upsert", record: next, timestamp: now });
     return next;
 }
+export async function deleteManagedSession(mesh, meshId) {
+    await appendRegistryEvent(mesh, { type: "delete", meshId, timestamp: new Date().toISOString() });
+}
 export async function markManagedSession(mesh, meshId, patch) {
     const current = await findManagedSession(mesh, meshId);
     if (!current)

package/dist/types.d.ts

@@ -136,7 +136,6 @@ export interface MeshPaths {
     id: "local";
     baseDir: string;
     registryFile: string;
-    inboxDir: string;
     locksDir: string;
     socketDirFile: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@streichsbaer/pi-mesh",
-	"version": "0.1.2",
+	"version": "0.1.4",
 	"description": "CLI and skill for coordinating Pi sessions through a local file/socket mesh",
 	"type": "module",
 	"packageManager": "npm@11.17.0",
@@ -35,7 +35,7 @@
 		"@earendil-works/pi-coding-agent": "^0.80.2"
 	},
 	"devDependencies": {
-		"@types/node": "^24.12.4",
+		"@types/node": "^22.19.0",
 		"node-pty": "^1.1.0",
 		"shx": "^0.4.0",
 		"tsx": "^4.20.6",
@@ -63,10 +63,10 @@
 		"access": "public"
 	},
 	"engines": {
-		"node": ">=24.18.0"
+		"node": ">=22.19.0"
 	},
 	"volta": {
-		"node": "24.18.0",
+		"node": "22.19.0",
 		"npm": "11.17.0"
 	}
 }