pi-sessions 0.8.0 → 0.10.0

package/README.md

@@ -8,7 +8,21 @@
 
 ![session picker](images/session_picker.png)
 
-### Handoffs
+### Handoff board
+
+![handoff board showing subagents](images/handoff-board-subagents.png)
+
+![handoff board showing user sessions](images/handoff-board-user-sessions.png)
+
+### Subagent report
+
+![subagent report card in the parent session](images/handoff-subagent-report.png)
+
+### Session handoff
+
+![session handoff tool call](images/session-handoff-tool.png)
+
+### Handoff prompt review
 
 ![handoff preview](images/handoff.png)
 
@@ -20,7 +34,7 @@
 
 ## Install
 
-Requires Pi `0.80.2` or newer and Node `>=24 <26`.
+Requires Pi `0.80.10` or newer and Node `>=24 <26`.
 
 **From npm** (recommended):
 
@@ -46,20 +60,36 @@ What session did I implement the db layer?
 ```
 
 ```text
-/handoff i want to implement the frontend component now
+Open the frontend implementation task in a session to the right.
 ```
 
 ## Features
 
-| Extension          | Surface                               | What it does                                            |
-| ------------------ | ------------------------------------- | ------------------------------------------------------- |
-| Session Search     | `session_search` pi tool              | Search through old sessions                             |
-| Session Ask        | `session_ask` pi tool                 | Ask questions about old sessions                        |
-| Session Handoff    | `/handoff`, `session_handoff` pi tool | Start a focused new session; alternative to compaction  |
-| Session Messaging  | `session_send_message` pi tool        | Send messages between running Pi sessions               |
-| Session Picker     | `Alt+O`                               | Reference old sessions in your prompt                   |
-| Session Index      | `/session-index` slash command        | Shows index status and rebuilds the local session index |
-| Session Auto Title | in background, `/title` slash command | Give sessions titles                                    |
+| Extension          | Surface                                           | What it does                                            |
+| ------------------ | ------------------------------------------------- | ------------------------------------------------------- |
+| Session Search     | `session_search` pi tool                          | Search through old sessions                             |
+| Session Ask        | `session_ask` pi tool                             | Ask questions about old sessions                        |
+| Session Handoff    | `session_handoff` pi tool, `/handoff` board       | Start and manage focused child sessions                 |
+| Session Messaging  | `session_send_message`, `session_cancel` pi tools | Coordinate between live Pi sessions and own subagents   |
+| Session Picker     | `Alt+O`                                           | Reference old sessions in your prompt                   |
+| Session Index      | `/session-index` slash command                    | Shows index status and rebuilds the local session index |
+| Session Auto Title | in background, `/title` slash command             | Give sessions titles                                    |
+
+Every feature is on by default. Turn one off with `enable: false` under its own settings namespace, which unregisters its tools and hooks.
+
+```json
+{
+  "sessions": {
+    "messaging": { "enable": true },
+    "subagents": { "enable": true },
+    "handoff": { "enable": true },
+    "search": { "enable": true },
+    "ask": { "enable": true },
+    "autoTitle": { "enable": true },
+    "hooks": { "enable": true }
+  }
+}
+```
 
 ## Session Search
 
@@ -72,40 +102,25 @@ File filters distinguish read-or-write evidence from write-only evidence:
 - `files.touched`: sessions that read or changed a path
 - `files.changed`: sessions that changed a path
 
-## Session Handoff
-
-`/handoff <goal>` starts a focused new session. Give pi a goal, and it will generate a prompt for you to review before kicking it off.
+Use `kind: "user"` or `kind: "subagent"` to filter by session type across the whole index. Use `relationScope: "branch"` to search subagents launched from the current conversation branch, or `relationScope: "tree"` to include subagents launched from abandoned branches as well.
 
-You can either start a new session directly in your current one, or if you have Ghostty on macOS, you can spawn a new one in a split-pane and continue in your current:
-
-- `/handoff --left <goal>`
-- `/handoff --right <goal>`
-- `/handoff --up <goal>`
-- `/handoff --down <goal>`
-
-The flag indicates the Ghostty split direction.
-
-Flow:
-
-- run `/handoff [--<direction>] <goal>`
-- review the generated prompt preview
-- optionally edit the prompt
-- start the new session
+## Session Handoff
 
-If you do nothing, the preview autostarts after a short countdown.
+The `session_handoff` tool lets the agent create a child session with a self-contained task. Ask for a direction when you want a visible split, ask for a deferred handoff when you only want the prepared session, or let the agent delegate suitable independent work to a background subagent.
 
-When running in Ghostty on macOS, pi-sessions also exposes a `session_handoff` tool. This lets the agent start a background handoff after you choose a split direction. The current session keeps running, while the child session opens in the requested split, gathers context, and shows the same review countdown before starting.
+Directional launches use tmux when the current terminal is inside tmux, or Ghostty on macOS. Deferred launches create the child without starting it and copy its resume command to the clipboard. A background subagent runs in a detached tmux window and reports back when finished.
 
-If background handoffs ever target the wrong pane, run `/handoff --identify` from the intended source pane to refresh the in-memory Ghostty terminal binding.
+Run `/handoff` to open the **Handoffs** board. The Subagents and User sessions tabs show status, age, launch details, and the actions currently available: stop, copy an observation command, or copy a resume command.
 
 ## Session Messaging
 
-Agents can coordinate with other currently running Pi sessions:
+Agents can coordinate with live Pi sessions and their own subagents:
 
 - `session_search` with `live: true` lists live sessions
-- `session_send_message` sends a message to another live session
+- `session_send_message` sends a message to a live session or own subagent
+- `session_cancel` aborts another live session's current turn
 
-Incoming messages start the recipient agent when idle and steer it when already running. Inactive sessions cannot receive messages, but you can still use `session_search` and `session_ask` with them.
+Incoming messages start the recipient agent when idle and steer it when already running. Messaging a dormant owned subagent resumes it automatically; other inactive sessions cannot receive messages, but you can still use `session_search` and `session_ask` with them.
 
 ## Session picker
 
@@ -124,7 +139,28 @@ If you want to override the shortcut, put this in your `~/.pi/agent/settings.jso
 {
   "sessions": {
     "handoff": {
-      "pickerShortcut": "alt+p"
+      "pickerShortcut": "alt+p",
+      "model": "openai-codex/gpt-5.6-terra",
+      "thinkingLevel": "low",
+      "deferred": {
+        "copyToClipboard": true
+      }
+    }
+  }
+}
+```
+
+`model` and `thinkingLevel` configure the agent that builds handoff prompts. They default to the new session's values when absent.
+
+`deferred.copyToClipboard` (default `true`) controls whether deferred handoffs copy the resume command to the clipboard. When off, the resume command is only shown in the tool call.
+
+Subagents require the handoff and messaging features. Limit recursive delegation depth with `sessions.subagents.maxDepth` (default `2`):
+
+```json
+{
+  "sessions": {
+    "subagents": {
+      "maxDepth": 2
     }
   }
 }
@@ -192,6 +228,7 @@ To change auto-titling settings, edit `~/.pi/agent/settings.json`:
       "refreshTurns": 4,
       "timeoutSecs": 15,
       "model": "anthropic/claude-haiku-4-5",
+      "thinkingLevel": "off",
       "prompt": "Custom prompt that overrides the default."
     }
   }

package/dist/session-messaging/broker/process.js

@@ -0,0 +1,234 @@
+import { mkdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { createServer } from "node:net";
+import { join } from "node:path";
+import { readFrames, writeFrame } from "../../shared/session-broker/framing.js";
+import { CLIENT_FRAME_SCHEMA, } from "../../shared/session-broker/protocol.js";
+import { getSessionMessagingDir, getSessionMessagingSocketPath, } from "../../shared/session-broker/socket-path.js";
+const SEND_TIMEOUT_MS = 10_000;
+const EXIT_IDLE_MS = 5_000;
+const KEEPALIVE_DELAY_MS = 5_000;
+const messagingDir = getSessionMessagingDir();
+const socketPath = getSessionMessagingSocketPath();
+const pidPath = join(messagingDir, "broker.pid");
+const sessions = new Map();
+const pendingSends = new Map();
+let idleTimer;
+let server;
+function closeWithError(socket, message) {
+    try {
+        writeFrame(socket, { type: "error", message });
+    }
+    catch { }
+    socket.destroy();
+}
+function scheduleIdleExit() {
+    if (idleTimer)
+        clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+        if (sessions.size === 0)
+            shutdown();
+    }, EXIT_IDLE_MS);
+}
+function clearIdleExit() {
+    if (!idleTimer)
+        return;
+    clearTimeout(idleTimer);
+    idleTimer = undefined;
+}
+function unregister(sessionId) {
+    if (!sessionId)
+        return;
+    sessions.delete(sessionId);
+    failPendingSendsTo(sessionId);
+    if (sessions.size === 0)
+        scheduleIdleExit();
+}
+function resolveTarget(target) {
+    const socket = sessions.get(target);
+    if (socket)
+        return { sessionId: target, socket };
+    return { error: `No live session found for id: ${target}` };
+}
+function handleFrame(socket, message, getSessionId, setSessionId) {
+    const currentSessionId = getSessionId();
+    if (!currentSessionId && message.type !== "register") {
+        closeWithError(socket, `Received ${message.type} before register.`);
+        return;
+    }
+    switch (message.type) {
+        case "register": {
+            const existing = sessions.get(message.sessionId);
+            if (existing && existing !== socket && !existing.destroyed) {
+                writeFrame(socket, {
+                    type: "register_failed",
+                    reason: "Session messaging unavailable: this session is already registered by another live Pi process.",
+                });
+                socket.end();
+                return;
+            }
+            clearIdleExit();
+            setSessionId(message.sessionId);
+            sessions.set(message.sessionId, socket);
+            socket.setKeepAlive(true, KEEPALIVE_DELAY_MS);
+            writeFrame(socket, { type: "registered", sessionId: message.sessionId });
+            break;
+        }
+        case "unregister":
+            unregister(currentSessionId);
+            setSessionId(undefined);
+            socket.end();
+            break;
+        case "list":
+            writeFrame(socket, {
+                type: "sessions",
+                requestId: message.requestId,
+                sessionIds: [...sessions.keys()],
+            });
+            break;
+        case "send":
+            handleSend(socket, currentSessionId, message);
+            break;
+        case "incoming_ack":
+            handleIncomingAck(socket, message);
+            break;
+    }
+}
+function handleSend(socket, currentSessionId, message) {
+    const source = currentSessionId ? sessions.get(currentSessionId) : undefined;
+    if (!currentSessionId || !source) {
+        writeFrame(socket, {
+            type: "send_result",
+            requestId: message.requestId,
+            delivered: false,
+            error: "Sender session is not registered.",
+        });
+        return;
+    }
+    const resolved = resolveTarget(message.target);
+    if ("error" in resolved) {
+        writeFrame(socket, {
+            type: "send_result",
+            requestId: message.requestId,
+            delivered: false,
+            reason: "no_session",
+            error: resolved.error,
+        });
+        return;
+    }
+    if (resolved.sessionId === currentSessionId) {
+        writeFrame(socket, {
+            type: "send_result",
+            requestId: message.requestId,
+            delivered: false,
+            error: "Cannot send a session envelope to the current session.",
+        });
+        return;
+    }
+    const timeout = setTimeout(() => {
+        pendingSends.delete(message.requestId);
+        writeFrame(socket, {
+            type: "send_result",
+            requestId: message.requestId,
+            delivered: false,
+            error: "Timed out waiting for target session to accept the envelope.",
+        });
+    }, SEND_TIMEOUT_MS);
+    pendingSends.set(message.requestId, {
+        source: socket,
+        target: resolved.socket,
+        timeout,
+        targetSessionId: resolved.sessionId,
+    });
+    writeFrame(resolved.socket, {
+        type: "incoming",
+        requestId: message.requestId,
+        envelope: stampEnvelope(message.envelope, currentSessionId, resolved.sessionId),
+    });
+}
+function failPendingSendsTo(targetSessionId) {
+    for (const [requestId, pending] of pendingSends) {
+        if (pending.targetSessionId !== targetSessionId) {
+            continue;
+        }
+        clearTimeout(pending.timeout);
+        pendingSends.delete(requestId);
+        writeFrame(pending.source, {
+            type: "send_result",
+            requestId,
+            delivered: false,
+            reason: "disconnected",
+            error: "Target disconnected before accepting the envelope.",
+        });
+    }
+}
+function handleIncomingAck(socket, message) {
+    const pending = pendingSends.get(message.requestId);
+    if (!pending || pending.target !== socket)
+        return;
+    clearTimeout(pending.timeout);
+    pendingSends.delete(message.requestId);
+    writeFrame(pending.source, {
+        type: "send_result",
+        requestId: message.requestId,
+        delivered: message.delivered,
+        ...(message.error === undefined ? {} : { error: message.error }),
+    });
+}
+function stampEnvelope(envelope, source, target) {
+    return { ...envelope, source, target };
+}
+function handleConnection(socket) {
+    let sessionId;
+    socket.setKeepAlive(true, KEEPALIVE_DELAY_MS);
+    void readConnection(socket, () => sessionId, (nextSessionId) => {
+        sessionId = nextSessionId;
+    });
+    socket.on("close", () => {
+        unregister(sessionId);
+    });
+    socket.on("error", () => { });
+}
+async function readConnection(socket, getSessionId, setSessionId) {
+    try {
+        for await (const frame of readFrames(socket, CLIENT_FRAME_SCHEMA, "Invalid session messaging client frame")) {
+            handleFrame(socket, frame, getSessionId, setSessionId);
+        }
+    }
+    catch (error) {
+        closeWithError(socket, error instanceof Error ? error.message : String(error));
+    }
+}
+function shutdown() {
+    for (const socket of sessions.values())
+        socket.end();
+    sessions.clear();
+    for (const pending of pendingSends.values())
+        clearTimeout(pending.timeout);
+    pendingSends.clear();
+    if (server)
+        server.close();
+    if (process.platform !== "win32") {
+        try {
+            unlinkSync(socketPath);
+        }
+        catch { }
+    }
+    try {
+        unlinkSync(pidPath);
+    }
+    catch { }
+    process.exit(0);
+}
+mkdirSync(messagingDir, { recursive: true, mode: 0o700 });
+if (process.platform !== "win32") {
+    try {
+        unlinkSync(socketPath);
+    }
+    catch { }
+}
+server = createServer(handleConnection);
+server.listen(socketPath, () => {
+    writeFileSync(pidPath, String(process.pid));
+});
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);

package/dist/shared/session-broker/framing.js

@@ -0,0 +1,58 @@
+import { createInterface } from "node:readline";
+import { parseTypeBoxValue } from "../typebox.js";
+const MAX_FRAME_BYTES = 256 * 1024;
+export function writeFrame(socket, frame) {
+    socket.write(`${JSON.stringify(frame)}\n`);
+}
+export async function* readFrames(socket, schema, context) {
+    const reader = createInterface({ input: socket, crlfDelay: Number.POSITIVE_INFINITY });
+    const lines = [];
+    const waiters = [];
+    let error;
+    let closed = false;
+    const wake = () => {
+        const waiter = waiters.shift();
+        waiter?.();
+    };
+    reader.on("line", (line) => {
+        lines.push(line);
+        wake();
+    });
+    reader.on("error", (nextError) => {
+        error = nextError instanceof Error ? nextError : new Error(String(nextError));
+        closed = true;
+        wake();
+    });
+    reader.on("close", () => {
+        closed = true;
+        wake();
+    });
+    try {
+        while (true) {
+            while (lines.length === 0 && !closed) {
+                await new Promise((resolve) => waiters.push(resolve));
+            }
+            const line = lines.shift();
+            if (line === undefined) {
+                if (error) {
+                    throw error;
+                }
+                return;
+            }
+            if (Buffer.byteLength(line, "utf8") > MAX_FRAME_BYTES) {
+                throw new Error("Session messaging frame exceeds maximum size.");
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch (parseError) {
+                throw parseError instanceof Error ? parseError : new Error(String(parseError));
+            }
+            yield parseTypeBoxValue(schema, parsed, context);
+        }
+    }
+    finally {
+        reader.close();
+    }
+}

package/dist/shared/session-broker/protocol.js

@@ -0,0 +1,163 @@
+import { Type } from "typebox";
+export const TASK_REPORT_REFERENCE_SCHEMA = Type.Object({
+    reference: Type.String({
+        description: "A precise reference such as a file path and line range, symbol name, command, URL, session id, or external artifact.",
+    }),
+    description: Type.Optional(Type.String({
+        description: "Why this reference matters or what evidence the parent should take from it.",
+    })),
+});
+export const TASK_REPORT_SCHEMA = Type.Object({
+    status: Type.Union([
+        Type.Literal("done", {
+            description: "The delegated task or requested follow-up is complete.",
+        }),
+        Type.Literal("blocked", {
+            description: "The task cannot continue without a specific decision, clarification, permission, dependency, or other action outside the scope of the task.",
+        }),
+        Type.Literal("incomplete", {
+            description: "Useful work was performed, but the requested result could not be completed and it's uncertain what should be done to reach completion.",
+        }),
+    ], { description: "The subagent's assessment of the task at the end of this turn." }),
+    summary: Type.String({
+        description: "A concise, 3-4 sentence self-contained account of the outcome and its most important evidence.",
+    }),
+    details: Type.Optional(Type.String({
+        description: "Optional supporting context such as reasoning, implementation notes, validation performed, limitations, unexpected behavior or roadblocks, or failed approaches.",
+    })),
+    references: Type.Optional(Type.Array(TASK_REPORT_REFERENCE_SCHEMA, {
+        description: "Supporting material for the report.",
+    })),
+    nextSteps: Type.Optional(Type.Array(Type.String(), {
+        description: "Optional concrete actions that would extend or build on the state of the work. If blocked or incomplete, call out specifically what is causing the early return.",
+    })),
+});
+const OUTBOUND_MESSAGE_ENVELOPE_SCHEMA = Type.Object({
+    kind: Type.Literal("message"),
+    messageId: Type.String(),
+    body: Type.String(),
+    requestResponse: Type.Optional(Type.Boolean()),
+    sentAt: Type.String(),
+    sourceToolCallId: Type.Optional(Type.String()),
+});
+const OUTBOUND_CANCEL_ENVELOPE_SCHEMA = Type.Object({
+    kind: Type.Literal("cancel"),
+    cancelId: Type.String(),
+    sentAt: Type.String(),
+});
+const OUTBOUND_SUBAGENT_REPORT_ENVELOPE_SCHEMA = Type.Intersect([
+    Type.Object({
+        kind: Type.Literal("subagent_report"),
+        reportId: Type.String(),
+        sentAt: Type.String(),
+    }),
+    TASK_REPORT_SCHEMA,
+]);
+export const OUTBOUND_SESSION_ENVELOPE_SCHEMA = Type.Union([
+    OUTBOUND_MESSAGE_ENVELOPE_SCHEMA,
+    OUTBOUND_CANCEL_ENVELOPE_SCHEMA,
+    OUTBOUND_SUBAGENT_REPORT_ENVELOPE_SCHEMA,
+]);
+export const SESSION_MESSAGE_ENVELOPE_SCHEMA = Type.Object({
+    kind: Type.Literal("message"),
+    messageId: Type.String(),
+    source: Type.String(),
+    target: Type.String(),
+    body: Type.String(),
+    requestResponse: Type.Optional(Type.Boolean()),
+    sentAt: Type.String(),
+    sourceToolCallId: Type.Optional(Type.String()),
+});
+export const SESSION_CANCEL_ENVELOPE_SCHEMA = Type.Object({
+    kind: Type.Literal("cancel"),
+    cancelId: Type.String(),
+    source: Type.String(),
+    target: Type.String(),
+    sentAt: Type.String(),
+});
+export const SESSION_SUBAGENT_REPORT_ENVELOPE_SCHEMA = Type.Intersect([
+    Type.Object({
+        kind: Type.Literal("subagent_report"),
+        reportId: Type.String(),
+        source: Type.String(),
+        target: Type.String(),
+        sentAt: Type.String(),
+    }),
+    TASK_REPORT_SCHEMA,
+]);
+export const SESSION_ENVELOPE_SCHEMA = Type.Union([
+    SESSION_MESSAGE_ENVELOPE_SCHEMA,
+    SESSION_CANCEL_ENVELOPE_SCHEMA,
+    SESSION_SUBAGENT_REPORT_ENVELOPE_SCHEMA,
+]);
+const REGISTER_CLIENT_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("register"),
+    sessionId: Type.String(),
+});
+const UNREGISTER_CLIENT_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("unregister"),
+});
+const LIST_CLIENT_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("list"),
+    requestId: Type.String(),
+});
+const SEND_CLIENT_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("send"),
+    requestId: Type.String(),
+    target: Type.String(),
+    envelope: OUTBOUND_SESSION_ENVELOPE_SCHEMA,
+});
+const INCOMING_ACK_CLIENT_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("incoming_ack"),
+    requestId: Type.String(),
+    delivered: Type.Boolean(),
+    error: Type.Optional(Type.String()),
+});
+const REGISTERED_BROKER_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("registered"),
+    sessionId: Type.String(),
+});
+const REGISTER_FAILED_BROKER_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("register_failed"),
+    reason: Type.String(),
+});
+const SESSIONS_BROKER_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("sessions"),
+    requestId: Type.String(),
+    sessionIds: Type.Array(Type.String()),
+});
+const INCOMING_BROKER_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("incoming"),
+    requestId: Type.String(),
+    envelope: SESSION_ENVELOPE_SCHEMA,
+});
+export const SESSION_ENVELOPE_SEND_FAILURE_REASON_SCHEMA = Type.Union([
+    Type.Literal("no_session"),
+    Type.Literal("disconnected"),
+]);
+const SEND_RESULT_BROKER_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("send_result"),
+    requestId: Type.String(),
+    delivered: Type.Boolean(),
+    reason: Type.Optional(SESSION_ENVELOPE_SEND_FAILURE_REASON_SCHEMA),
+    error: Type.Optional(Type.String()),
+});
+const ERROR_BROKER_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("error"),
+    message: Type.String(),
+});
+export const CLIENT_FRAME_SCHEMA = Type.Union([
+    REGISTER_CLIENT_FRAME_SCHEMA,
+    UNREGISTER_CLIENT_FRAME_SCHEMA,
+    LIST_CLIENT_FRAME_SCHEMA,
+    SEND_CLIENT_FRAME_SCHEMA,
+    INCOMING_ACK_CLIENT_FRAME_SCHEMA,
+]);
+export const BROKER_FRAME_SCHEMA = Type.Union([
+    REGISTERED_BROKER_FRAME_SCHEMA,
+    REGISTER_FAILED_BROKER_FRAME_SCHEMA,
+    SESSIONS_BROKER_FRAME_SCHEMA,
+    INCOMING_BROKER_FRAME_SCHEMA,
+    SEND_RESULT_BROKER_FRAME_SCHEMA,
+    ERROR_BROKER_FRAME_SCHEMA,
+]);

package/dist/shared/session-broker/socket-path.js

@@ -0,0 +1,19 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+function sanitizePipeSegment(value) {
+    return (value
+        .replace(/[^a-zA-Z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .toLowerCase() || "default");
+}
+export function getSessionMessagingDir(homeDir = homedir()) {
+    return (process.env.PI_SESSIONS_MESSAGING_DIR ??
+        join(homeDir, ".pi", "agent", "pi-sessions", "messaging"));
+}
+export function getSessionMessagingSocketPath(platform = process.platform, homeDir = homedir()) {
+    const messagingDir = getSessionMessagingDir(homeDir);
+    if (platform === "win32") {
+        return `\\\\.\\pipe\\pi-sessions-messaging-${sanitizePipeSegment(messagingDir)}`;
+    }
+    return join(messagingDir, "broker.sock");
+}

package/dist/shared/typebox.js

@@ -0,0 +1,36 @@
+import { Value } from "typebox/value";
+export function isTypeBoxValue(schema, value) {
+    return Value.Check(schema, value);
+}
+export function parseTypeBoxValue(schema, value, context) {
+    if (Value.Check(schema, value)) {
+        return value;
+    }
+    throw new Error(formatTypeBoxError(schema, value, context));
+}
+export function safeParseTypeBoxValue(schema, value) {
+    return Value.Check(schema, value) ? value : undefined;
+}
+export function parseTypeBoxRows(schema, value, context) {
+    if (!Array.isArray(value)) {
+        throw new Error(`${context}: expected an array of rows.`);
+    }
+    return value.map((row, index) => parseTypeBoxValue(schema, row, `${context} at row ${index + 1}`));
+}
+export function safeParseTypeBoxJson(schema, raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return safeParseTypeBoxValue(schema, parsed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function formatTypeBoxError(schema, value, context) {
+    const firstError = Value.Errors(schema, value)[0];
+    if (!firstError) {
+        return `${context}: invalid value.`;
+    }
+    const path = firstError.instancePath.length > 0 ? firstError.instancePath : "/";
+    return `${context}: ${path} ${firstError.message}`;
+}