@streichsbaer/pi-mesh 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,142 @@
+export type DeliveryMode = "auto" | "prompt" | "steer" | "follow-up";
+export declare const THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh"];
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+export interface ModelSelection {
+    provider?: string;
+    model?: string;
+    thinkingLevel?: ThinkingLevel;
+}
+export interface SessionSummary {
+    path: string;
+    rawSessionId: string;
+    cwd: string;
+    repoName: string;
+    timestamp: string | null;
+    updatedAt: number;
+    sessionName: string;
+    dashboardSessionId: string;
+    workflowId: string;
+    providerId: string;
+    laneId: string;
+    firstUser: string;
+    lastUser: string;
+    lastAssistant: string;
+}
+export interface TranscriptHeader {
+    id: string;
+    version?: number;
+    cwd?: string;
+    timestamp?: string;
+}
+export interface TranscriptEntry {
+    type: string;
+    id?: string;
+    parentId?: string | null;
+    timestamp?: string;
+    message?: AgentMessageLike;
+    [key: string]: unknown;
+}
+export interface AgentMessageLike {
+    role?: string;
+    content?: string | ContentPartLike[];
+    toolName?: string;
+    toolCallId?: string | null;
+    isError?: boolean;
+    details?: unknown;
+    [key: string]: unknown;
+}
+export type ContentPartLike = {
+    type: "text";
+    text?: string;
+} | {
+    type: "thinking";
+    thinking?: string;
+} | {
+    type: "toolCall";
+    id?: string;
+    name?: string;
+    arguments?: Record<string, unknown>;
+} | {
+    type: string;
+    [key: string]: unknown;
+};
+export interface TranscriptEvent {
+    kind: "message" | "tool_call" | "tool_result";
+    role: string;
+    id: string | null;
+    parentId?: string | null;
+    parentMessageId?: string | null;
+    timestamp: string | null;
+    timestampMs: number | null;
+    text?: string;
+    thinkingParts?: number;
+    toolName?: string;
+    toolCallId?: string | null;
+    args?: Record<string, unknown>;
+    isError?: boolean;
+    details?: unknown;
+}
+export interface ToolInvocation {
+    toolCallId: string | null;
+    toolName: string;
+    startedAt: string | null;
+    startedAtMs: number | null;
+    endedAt?: string | null;
+    endedAtMs?: number | null;
+    args: Record<string, unknown>;
+    argsSummary: string;
+    callEvent: TranscriptEvent | null;
+    resultEvent: TranscriptEvent | null;
+    status: "pending" | "ok" | "error";
+    failed: boolean;
+    exitCode: number | null;
+}
+export interface Turn {
+    index: number;
+    startedAt: string | null;
+    startedAtMs: number | null;
+    endedAt: string | null;
+    endedAtMs: number | null;
+    events: TranscriptEvent[];
+    user: TranscriptEvent;
+    assistantMessages: TranscriptEvent[];
+    toolInvocations: ToolInvocation[];
+    failures: ToolInvocation[];
+    finalAssistant: TranscriptEvent | null;
+}
+export interface SessionData {
+    session: SessionSummary;
+    transcript: {
+        header: TranscriptHeader;
+        entries: TranscriptEntry[];
+    };
+    events: TranscriptEvent[];
+    toolInvocations: ToolInvocation[];
+    turns: Turn[];
+}
+export type ManagedSessionKind = "interactive" | "sleeping" | "attached";
+export type ManagedSessionStatus = "offline" | "starting" | "running" | "idle" | "busy" | "error";
+export interface ManagedSessionRecord {
+    meshId: string;
+    name?: string;
+    labels?: string[];
+    kind: ManagedSessionKind;
+    status: ManagedSessionStatus;
+    folder: string;
+    sessionFile: string;
+    rawSessionId?: string;
+    pid?: number;
+    socketPath?: string;
+    createdAt: string;
+    updatedAt: string;
+    lastError?: string;
+    pendingModelSelection?: ModelSelection;
+}
+export interface MeshPaths {
+    id: "local";
+    baseDir: string;
+    registryFile: string;
+    inboxDir: string;
+    locksDir: string;
+    socketDirFile: string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];

package/dist/utils.d.ts

@@ -0,0 +1,17 @@
+export declare function homeDir(): string;
+export declare function expandHome(value: string): string;
+export declare function piAgentDir(): string;
+export declare function exists(filePath: string): Promise<boolean>;
+export declare function ensureDir(dir: string): Promise<void>;
+export declare function ensurePrivateDir(dir: string): Promise<void>;
+export declare function userRuntimeId(): string;
+export declare function socketRuntimePrefix(): string;
+export declare function readJson<T>(filePath: string, fallback: T): Promise<T>;
+export declare function safeJson<T = unknown>(line: string, fallback: T): T;
+export declare function walkFiles(root: string, predicate?: (filePath: string) => boolean, out?: string[]): Promise<string[]>;
+export declare function compactWhitespace(text: string): string;
+export declare function truncate(text: string, max?: number): string;
+export declare function formatTimestamp(msOrIso: number | string | null | undefined): string;
+export declare function stableId(value: string, length?: number): string;
+export declare function parseDuration(value: string): number | null;
+export declare function parseTimeSpec(value: string, now?: number): number | null;

package/dist/utils.js

@@ -0,0 +1,157 @@
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function homeDir() {
+    return os.homedir();
+}
+export function expandHome(value) {
+    if (value === "~")
+        return homeDir();
+    if (value.startsWith("~/"))
+        return path.join(homeDir(), value.slice(2));
+    return value;
+}
+export function piAgentDir() {
+    return path.join(homeDir(), ".pi", "agent");
+}
+export async function exists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureDir(dir) {
+    await fs.mkdir(dir, { recursive: true });
+}
+export async function ensurePrivateDir(dir) {
+    let stat;
+    try {
+        stat = await fs.lstat(dir);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        await fs.mkdir(dir, { mode: 0o700 });
+        stat = await fs.lstat(dir);
+    }
+    if (stat.isSymbolicLink())
+        throw new Error(`${dir} must not be a symbolic link`);
+    if (!stat.isDirectory())
+        throw new Error(`${dir} is not a directory`);
+    if (typeof process.getuid === "function" && stat.uid !== process.getuid()) {
+        throw new Error(`${dir} is not owned by the current user`);
+    }
+    if ((stat.mode & 0o077) !== 0)
+        await fs.chmod(dir, 0o700);
+}
+export function userRuntimeId() {
+    if (typeof process.getuid === "function")
+        return String(process.getuid());
+    return stableId(homeDir(), 8);
+}
+export function socketRuntimePrefix() {
+    const base = process.platform === "win32" ? os.tmpdir() : "/tmp";
+    return path.join(base, `pi-mesh-${userRuntimeId()}-`);
+}
+export async function readJson(filePath, fallback) {
+    try {
+        return JSON.parse(await fs.readFile(filePath, "utf8"));
+    }
+    catch {
+        return fallback;
+    }
+}
+export function safeJson(line, fallback) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return fallback;
+    }
+}
+export async function walkFiles(root, predicate = () => true, out = []) {
+    let entries = [];
+    try {
+        entries = await fs.readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        const full = path.join(root, entry.name);
+        if (entry.isDirectory())
+            await walkFiles(full, predicate, out);
+        else if (entry.isFile() && predicate(full))
+            out.push(full);
+    }
+    return out;
+}
+export function compactWhitespace(text) {
+    return String(text || "").replace(/\s+/g, " ").trim();
+}
+export function truncate(text, max = 220) {
+    const value = String(text || "").trim();
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, Math.max(0, max - 1))}…`;
+}
+export function formatTimestamp(msOrIso) {
+    if (!msOrIso)
+        return "n/a";
+    if (typeof msOrIso === "string")
+        return msOrIso;
+    try {
+        return new Date(msOrIso).toISOString();
+    }
+    catch {
+        return String(msOrIso);
+    }
+}
+export function stableId(value, length = 16) {
+    return createHash("sha256").update(value).digest("hex").slice(0, length);
+}
+export function parseDuration(value) {
+    const text = String(value || "").trim();
+    if (!text)
+        return null;
+    if (/^\d+$/.test(text))
+        return Number(text);
+    const matches = [...text.matchAll(/(\d+)(ms|s|m|h|d|w)/g)];
+    if (!matches.length || matches.map((m) => m[0]).join("") !== text)
+        return null;
+    let total = 0;
+    for (const [, rawNum, unit] of matches) {
+        const n = Number(rawNum);
+        if (unit === "ms")
+            total += n;
+        if (unit === "s")
+            total += n * 1000;
+        if (unit === "m")
+            total += n * 60 * 1000;
+        if (unit === "h")
+            total += n * 60 * 60 * 1000;
+        if (unit === "d")
+            total += n * 24 * 60 * 60 * 1000;
+        if (unit === "w")
+            total += n * 7 * 24 * 60 * 60 * 1000;
+    }
+    return total;
+}
+export function parseTimeSpec(value, now = Date.now()) {
+    const text = String(value || "").trim();
+    if (!text)
+        return null;
+    const duration = parseDuration(text);
+    if (duration !== null)
+        return now - duration;
+    if (/^\d{10,13}$/.test(text)) {
+        const num = Number(text);
+        return text.length === 10 ? num * 1000 : num;
+    }
+    const parsed = Date.parse(text);
+    return Number.isFinite(parsed) ? parsed : null;
+}

package/package.json

@@ -0,0 +1,72 @@
+{
+	"name": "@streichsbaer/pi-mesh",
+	"version": "0.1.0",
+	"description": "CLI and skill for coordinating Pi sessions through a local file/socket mesh",
+	"type": "module",
+	"packageManager": "npm@11.17.0",
+	"bin": {
+		"pi-mesh": "dist/cli.js"
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"clean": "shx rm -rf dist",
+		"dev": "tsx src/cli.ts",
+		"build": "npm run clean && tsc -p tsconfig.build.json && shx chmod +x dist/cli.js",
+		"check": "tsc -p tsconfig.json --noEmit",
+		"check:test": "tsc -p tsconfig.test.json --noEmit",
+		"test": "vitest --run",
+		"test:watch": "vitest",
+		"test:e2e:real": "tsx test/e2e/real-cli.ts",
+		"test:e2e:interactive": "tsx test/e2e/interactive-cli.ts",
+		"ci": "npm run check && npm run check:test && npm run build && npm test",
+		"prepublishOnly": "npm run clean && npm run ci"
+	},
+	"dependencies": {
+		"@earendil-works/pi-coding-agent": "^0.80.2"
+	},
+	"devDependencies": {
+		"@types/node": "^24.12.4",
+		"node-pty": "^1.1.0",
+		"shx": "^0.4.0",
+		"tsx": "^4.20.6",
+		"typescript": "^5.9.3",
+		"vitest": "^4.1.9"
+	},
+	"keywords": [
+		"pi",
+		"coding-agent",
+		"agents",
+		"cli",
+		"coordination"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/streichsbaer/pi-mesh.git"
+	},
+	"bugs": {
+		"url": "https://github.com/streichsbaer/pi-mesh/issues"
+	},
+	"homepage": "https://github.com/streichsbaer/pi-mesh#readme",
+	"author": "",
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
+	"engines": {
+		"node": ">=24.18.0"
+	},
+	"volta": {
+		"node": "24.18.0",
+		"npm": "11.17.0"
+	}
+}