@joe-broadhead/messaging 0.0.0-stage → 0.7.0

package/dist/types/core/schema/roster.d.ts

@@ -0,0 +1,347 @@
+/**
+ * The team roster: an append-only, hash-chained log of signed entries.
+ * The relay sequences appends; every machine verifies the whole chain itself.
+ *
+ *   hash(entry) = SHA-256(UTF-8(JCS(entry))), base64url, over the full entry including sig
+ *   sig         = Ed25519(by, DOMAIN.roster + JCS(entry without sig))
+ *   team id     = hash(genesis)
+ *   proof       = Ed25519(invite seed, DOMAIN.invite + JCS({team, inviteId, member}))   (invite.redeem)
+ *
+ * Authority rules (enforced by `Roster.apply`):
+ *   genesis        seq 0, prev null, by = founder.machine, founder.role = admin
+ *   member.add     by a current admin; machine not already a member; (person, label) not used by a current member
+ *   member.remove  by a current admin, or by the member itself (leave); never the last admin
+ *   member.role    by a current admin; never demotes the last admin
+ *   member.rekey   by the member itself or a current admin; the machine is a current member (never a
+ *                  removed one); replaces only that member's `enc`
+ *   invite.create  by a current admin; expires − ts ≤ LIMITS.ttlMs
+ *   invite.redeem  by the joining machine (by = member.machine); invite open and unexpired at entry ts;
+ *                  proof verifies under the invite's invitePub; member.person and role match the invite;
+ *                  (person, label) not used by a current member. Single use.
+ *   invite.revoke  by a current admin
+ * Every admitted member key (genesis founder, member.add, redeem member) and every invitePub must be a
+ * canonical Ed25519 encoding of a point that is not of small order.
+ * A removed machine can never rejoin with the same key; it must generate a new identity.
+ * Inviting or adding an existing person adds another machine for that person, under another label.
+ */
+import { z } from "zod";
+export declare const Member: z.ZodObject<{
+    machine: z.ZodString;
+    enc: z.ZodString;
+    person: z.ZodString;
+    role: z.ZodEnum<{
+        admin: "admin";
+        member: "member";
+    }>;
+    label: z.ZodString;
+}, z.core.$strip>;
+export type Member = z.infer<typeof Member>;
+export declare const GenesisEntry: z.ZodObject<{
+    prev: z.ZodNull;
+    kind: z.ZodLiteral<"genesis">;
+    body: z.ZodObject<{
+        name: z.ZodString;
+        founder: z.ZodObject<{
+            machine: z.ZodString;
+            enc: z.ZodString;
+            person: z.ZodString;
+            role: z.ZodEnum<{
+                admin: "admin";
+                member: "member";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    v: z.ZodLiteral<"messaging/1">;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strip>;
+export declare const MemberAddEntry: z.ZodObject<{
+    kind: z.ZodLiteral<"member.add">;
+    body: z.ZodObject<{
+        machine: z.ZodString;
+        enc: z.ZodString;
+        person: z.ZodString;
+        role: z.ZodEnum<{
+            admin: "admin";
+            member: "member";
+        }>;
+        label: z.ZodString;
+    }, z.core.$strip>;
+    team: z.ZodString;
+    prev: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strip>;
+export declare const MemberRemoveEntry: z.ZodObject<{
+    kind: z.ZodLiteral<"member.remove">;
+    body: z.ZodObject<{
+        machine: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    team: z.ZodString;
+    prev: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strip>;
+export declare const MemberRoleEntry: z.ZodObject<{
+    kind: z.ZodLiteral<"member.role">;
+    body: z.ZodObject<{
+        machine: z.ZodString;
+        role: z.ZodEnum<{
+            admin: "admin";
+            member: "member";
+        }>;
+    }, z.core.$strip>;
+    team: z.ZodString;
+    prev: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Replaces a member's X25519 encryption key. Senders seal to the new `enc` once they have
+ * applied this entry; the member keeps its previous key long enough to open what was sealed before (spec §4).
+ */
+export declare const MemberRekeyEntry: z.ZodObject<{
+    kind: z.ZodLiteral<"member.rekey">;
+    body: z.ZodObject<{
+        machine: z.ZodString;
+        enc: z.ZodString;
+    }, z.core.$strip>;
+    team: z.ZodString;
+    prev: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strip>;
+export declare const InviteCreateEntry: z.ZodObject<{
+    kind: z.ZodLiteral<"invite.create">;
+    body: z.ZodObject<{
+        inviteId: z.ZodString;
+        invitePub: z.ZodString;
+        person: z.ZodString;
+        expires: z.ZodNumber;
+    }, z.core.$strip>;
+    team: z.ZodString;
+    prev: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strip>;
+export declare const InviteRedeemEntry: z.ZodObject<{
+    kind: z.ZodLiteral<"invite.redeem">;
+    body: z.ZodObject<{
+        inviteId: z.ZodString;
+        proof: z.ZodString;
+        member: z.ZodObject<{
+            machine: z.ZodString;
+            enc: z.ZodString;
+            person: z.ZodString;
+            role: z.ZodEnum<{
+                admin: "admin";
+                member: "member";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    team: z.ZodString;
+    prev: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strip>;
+export declare const InviteRevokeEntry: z.ZodObject<{
+    kind: z.ZodLiteral<"invite.revoke">;
+    body: z.ZodObject<{
+        inviteId: z.ZodString;
+    }, z.core.$strip>;
+    team: z.ZodString;
+    prev: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strip>;
+export declare const RosterEntry: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    prev: z.ZodNull;
+    kind: z.ZodLiteral<"genesis">;
+    body: z.ZodObject<{
+        name: z.ZodString;
+        founder: z.ZodObject<{
+            machine: z.ZodString;
+            enc: z.ZodString;
+            person: z.ZodString;
+            role: z.ZodEnum<{
+                admin: "admin";
+                member: "member";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    v: z.ZodLiteral<"messaging/1">;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"member.add">;
+    body: z.ZodObject<{
+        machine: z.ZodString;
+        enc: z.ZodString;
+        person: z.ZodString;
+        role: z.ZodEnum<{
+            admin: "admin";
+            member: "member";
+        }>;
+        label: z.ZodString;
+    }, z.core.$strip>;
+    team: z.ZodString;
+    prev: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"member.remove">;
+    body: z.ZodObject<{
+        machine: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    team: z.ZodString;
+    prev: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"member.role">;
+    body: z.ZodObject<{
+        machine: z.ZodString;
+        role: z.ZodEnum<{
+            admin: "admin";
+            member: "member";
+        }>;
+    }, z.core.$strip>;
+    team: z.ZodString;
+    prev: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"member.rekey">;
+    body: z.ZodObject<{
+        machine: z.ZodString;
+        enc: z.ZodString;
+    }, z.core.$strip>;
+    team: z.ZodString;
+    prev: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"invite.create">;
+    body: z.ZodObject<{
+        inviteId: z.ZodString;
+        invitePub: z.ZodString;
+        person: z.ZodString;
+        expires: z.ZodNumber;
+    }, z.core.$strip>;
+    team: z.ZodString;
+    prev: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"invite.redeem">;
+    body: z.ZodObject<{
+        inviteId: z.ZodString;
+        proof: z.ZodString;
+        member: z.ZodObject<{
+            machine: z.ZodString;
+            enc: z.ZodString;
+            person: z.ZodString;
+            role: z.ZodEnum<{
+                admin: "admin";
+                member: "member";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    team: z.ZodString;
+    prev: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"invite.revoke">;
+    body: z.ZodObject<{
+        inviteId: z.ZodString;
+    }, z.core.$strip>;
+    team: z.ZodString;
+    prev: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type RosterEntry = z.infer<typeof RosterEntry>;
+export type GenesisEntry = z.infer<typeof GenesisEntry>;
+export type MemberAddEntry = z.infer<typeof MemberAddEntry>;
+export type MemberRemoveEntry = z.infer<typeof MemberRemoveEntry>;
+export type MemberRoleEntry = z.infer<typeof MemberRoleEntry>;
+export type MemberRekeyEntry = z.infer<typeof MemberRekeyEntry>;
+export type InviteCreateEntry = z.infer<typeof InviteCreateEntry>;
+export type InviteRedeemEntry = z.infer<typeof InviteRedeemEntry>;
+export type InviteRevokeEntry = z.infer<typeof InviteRevokeEntry>;
+export type RosterKind = RosterEntry["kind"];
+export declare const RosterHead: z.ZodObject<{
+    seq: z.ZodNumber;
+    hash: z.ZodString;
+}, z.core.$strip>;
+export type RosterHead = z.infer<typeof RosterHead>;
+/**
+ * Invite ticket, shared out of band. Encoded as `messaging1.` + base64url(UTF-8(JCS(ticket))).
+ * `secret` is the invite seed: a 32-byte Ed25519 private key (RFC 8032 seed) whose public key is the
+ * invite's `invitePub`. The joiner signs its redeem proof with it; the seed never leaves the ticket.
+ */
+export declare const InviteTicket: z.ZodObject<{
+    v: z.ZodLiteral<"messaging/1">;
+    team: z.ZodString;
+    name: z.ZodString;
+    relay: z.ZodString;
+    inviteId: z.ZodString;
+    secret: z.ZodString;
+    person: z.ZodString;
+    expires: z.ZodNumber;
+}, z.core.$strip>;
+export type InviteTicket = z.infer<typeof InviteTicket>;
+export declare const TICKET_PREFIX: "messaging1.";

package/dist/types/core/sign.d.ts

@@ -0,0 +1,13 @@
+import { type KeyObject } from "node:crypto";
+import type { Identity } from "./identity.js";
+import type { MachineId } from "./schema/common.js";
+/** The exact bytes signed: UTF-8(domain) || UTF-8(JCS(value)). Throws `invalid_request` for non-I-JSON. */
+export declare function signingInput(domain: string, value: unknown): Uint8Array;
+/** Ed25519 signature (base64url) over `domain` + JCS(value). Use a `DOMAIN` prefix. Throws only MessagingError. */
+export declare function sign(identity: Identity, domain: string, value: unknown): string;
+/** `sign` with a bare Ed25519 private key, such as an invite seed. */
+export declare function signWith(key: KeyObject, domain: string, value: unknown): string;
+/** True only for a valid signature by `machine`. Never throws: malformed keys, values or signatures are false. */
+export declare function verify(machine: MachineId, domain: string, value: unknown, sig: string): boolean;
+/** `verify` over bytes from `signingInput`. Never throws. */
+export declare function verifyInput(machine: MachineId, input: Uint8Array, sig: string): boolean;

package/dist/types/core/task.d.ts

@@ -0,0 +1,6 @@
+import { type TaskState } from "./schema/a2a.js";
+/** The task state machine in spec §6.3. Unknown states never transition. */
+export declare function canTransition(from: TaskState, to: TaskState): boolean;
+export declare function isTerminal(state: TaskState): boolean;
+/** INPUT_REQUIRED or AUTH_REQUIRED: waiting on the requester. */
+export declare function isInterrupted(state: TaskState): boolean;

package/dist/types/core/testing.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `@messaging/core/testing`: helpers for test vectors and tests that need fixed randomness or envelopes a
+ * conforming sender never makes. Never import this from production code.
+ */
+export { sealEnvelopeWith, sealPlaintext, type SealRandomness } from "./envelope.js";
+export { encodeTicket } from "./roster.js";
+export { grantHash } from "./delegation.js";
+export { signJellyToken } from "./directory/jelly-issuer.js";
+export { jellyHostDouble, type JellyHostDouble } from "./jelly-host-double.js";
+/**
+ * Narrows a result whose `kind` tells its shape (`item.read`, `conv.read`) to the expected kind, and
+ * throws with both kinds named otherwise: `client.call("item.read", p).then(asKind("received"))`.
+ */
+export declare function asKind<K extends string>(kind: K): <T extends {
+    kind: string;
+}>(result: T) => Extract<T, {
+    kind: K;
+}>;

package/dist/types/core/ulid.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A ULID for `now` (default `Date.now()`), with 80 fresh random bits per id. Ids sort by millisecond,
+ * but ids from one millisecond are in random order, so no id predicts another (spec §2).
+ */
+export declare function ulid(now?: number): string;

package/dist/types/core/version.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The release version every Messaging package ships at (they release together). A daemon names it in
+ * its IPC hello and a client compares it with its own (spec §8.2). A test keeps it equal to the
+ * root package.json.
+ */
+export declare const VERSION = "0.7.0";

package/dist/types/core/wire.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Parses JSON text that came from outside the process: a relay frame, an IPC line, a decrypted body,
+ * an invite ticket. It returns exactly what `JSON.parse` returns, after a single linear, iterative
+ * (never recursive) scan that throws `invalid_request` for:
+ * - text that is not RFC 8259 JSON;
+ * - an object with two members of the same name, compared after unescaping;
+ * - arrays and objects nested deeper than `LIMITS.jsonDepth`, before anything is built;
+ * - a string or member name with a lone surrogate, raw or escaped;
+ * - more than `maxBytes` UTF-8 bytes, when `maxBytes` is given.
+ * Error messages give the reason and an offset, never the text, and chain no `cause`.
+ */
+export declare function parseWire(text: string, options?: {
+    maxBytes?: number;
+}): unknown;

package/dist/types/ipc/client.d.ts

@@ -0,0 +1,85 @@
+import { IpcEvent, IpcHello, MessagingError, type IpcMethod, type IpcParams, type IpcResult } from "../core/index.js";
+import { type SocketTier } from "./paths.js";
+export interface ClientOptions {
+    /** Explicit socket path (on Windows, the pipe pointer file). Defaults to the `tier` socket of `home`. */
+    socketPath?: string;
+    home?: string;
+    /** Which of the daemon's sockets to use without `socketPath`; default `agent` (spec §8.2). */
+    tier?: SocketTier;
+    /**
+     * The daemon's own uid, trusted besides this user to own `run/` and the socket, when `messagingd` runs
+     * as its own user. Defaults to `MESSAGING_DAEMON_UID`.
+     */
+    daemonUid?: number;
+    connectTimeoutMs?: number;
+    /** Default per-call timeout. */
+    callTimeoutMs?: number;
+    /** The release the daemon must be; this build's `VERSION` unless a test says otherwise. */
+    version?: string;
+    /**
+     * How long to wait for the hello once connected; at least 5 s by default, apart from the connect
+     * timeout, so a daemon that is only busy is not taken for another version.
+     */
+    helloTimeoutMs?: number;
+}
+/**
+ * `daemon_mismatch`: the daemon on the socket is another release or IPC protocol, or did not say
+ * which (spec §8.2). `hello` is what it said, when it said anything this client can read.
+ */
+export declare class DaemonMismatchError extends MessagingError {
+    readonly hello?: IpcHello | undefined;
+    constructor(message: string, hello?: IpcHello | undefined);
+}
+export interface CallOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    /** An action grant (`jelly-act+jwt`) for a daemon under a Jelly host (spec §8.11), sent as the request's `grant`. */
+    grant?: string;
+}
+/** Non-Messaging JSON-RPC failure (schema, unknown method, internal). */
+export declare class IpcRpcError extends Error {
+    readonly rpcCode: number;
+    constructor(rpcCode: number, message: string);
+}
+/**
+ * One connection to the local daemon. It does not reconnect; watch `onClose` and connect again.
+ * Results are validated against the contract; malformed events are dropped.
+ */
+export declare class MessagingClient {
+    private readonly socket;
+    private readonly callTimeoutMs;
+    private readonly pending;
+    private readonly eventListeners;
+    private readonly closeListeners;
+    private nextId;
+    private isClosed;
+    private greeting?;
+    /** The daemon's hello: the first line on the connection (spec §8.2). */
+    private readonly greeted;
+    private daemonHello?;
+    private constructor();
+    /**
+     * Connects to the daemon and reads its hello before anything else. A daemon of another release or
+     * IPC protocol, or one that does not say which within `helloTimeoutMs`, fails with
+     * `daemon_mismatch` (`DaemonMismatchError`, with the remedy in its message) and the connection is
+     * closed. The socket's directory must be private (a real directory owned by this
+     * user, or by the configured daemon uid, that no group or other user can write) and the socket owned
+     * by one of them; otherwise this fails with `forbidden`, because whoever can write that directory can
+     * stand in for the daemon.
+     *
+     * On Windows (spec §8.2, "Windows") `socketPath` is the pointer file that names the daemon's pipe. It and its
+     * directory must be private by ACL; the client connects to the pipe it names, and refuses (`forbidden`) a
+     * hello whose `pid` is not the pointer's.
+     */
+    static connect(options?: ClientOptions): Promise<MessagingClient>;
+    /** What the daemon said when this connection opened: its release, IPC protocol and pid. */
+    get daemon(): IpcHello;
+    get closed(): boolean;
+    call<M extends IpcMethod>(method: M, params: IpcParams<M>, options?: CallOptions): Promise<IpcResult<M>>;
+    onEvent(listener: (event: IpcEvent) => void): () => void;
+    onClose(listener: (error?: Error) => void): () => void;
+    close(): void;
+    private receive;
+    private settle;
+    private shutdown;
+}

package/dist/types/ipc/framing.d.ts

@@ -0,0 +1,12 @@
+/** Splits a byte stream into newline-delimited lines, enforcing a per-line byte limit. */
+export declare class LineDecoder {
+    private readonly maxBytes;
+    private pending;
+    constructor(maxBytes: number);
+    /** Returns complete lines. Throws `LineTooLongError` once a line exceeds the limit. */
+    push(chunk: string): string[];
+}
+export declare class LineTooLongError extends Error {
+    constructor(maxBytes: number);
+}
+export declare function encodeLine(value: unknown): string;

package/dist/types/ipc/index.d.ts

@@ -0,0 +1,6 @@
+export { DaemonMismatchError, MessagingClient, IpcRpcError, type CallOptions } from "./client.js";
+export { createIpcServer, type AuthorizeCall, type CallAuthority, type IpcServer, type Handlers, type Handler, type ConnectionContext } from "./server.js";
+export { configuredDaemonUid, daemonEnv, IS_WINDOWS, messagingHome, socketPath, type SocketTier } from "./paths.js";
+export { RPC } from "./rpc.js";
+export { adoptPrivateDir, openNoFollow, privacyProblem, trustedOwners } from "./trust.js";
+export { aclProblem } from "./windows-acl.js";

package/dist/types/ipc/paths.d.ts

@@ -0,0 +1,39 @@
+/** macOS limits sun_path to 104 bytes including the terminator. */
+export declare const MAX_SOCKET_PATH_BYTES = 103;
+/**
+ * Windows: the daemon's endpoints are named pipes found through pointer files (`pipes.ts`), its directories
+ * and files are private by ACL (`windows-acl.ts`), and there are no POSIX signals.
+ */
+export declare const IS_WINDOWS: boolean;
+/** `$MESSAGING_HOME`, else `~/.messaging`. */
+export declare function messagingHome(env?: NodeJS.ProcessEnv): string;
+/**
+ * The daemon's two sockets (spec §8.2, "Two sockets"): `agent` (`run/agent.sock`) serves only
+ * `AGENT_METHODS`, for agent-facing clients (the plugin's server part, MCP); `admin`
+ * (`run/admin.sock`) serves every method, for people (the `messaging` CLI and the `/messaging` TUI).
+ */
+export type SocketTier = "agent" | "admin";
+/**
+ * Where a client finds the `tier` endpoint of the daemon of `home`: the socket `run/<tier>.sock`, or on Windows
+ * the pointer file `run\<tier>.pipe` that names the tier's pipe (spec §8.2, "Windows").
+ */
+export declare function socketPath(home: string, tier: SocketTier): string;
+/**
+ * `MESSAGING_DAEMON_UID`: the uid a client also trusts to own the daemon's `run/` directory and socket,
+ * when `messagingd` runs as its own user (spec §8.2). Unset: only this process's own user. POSIX only: on
+ * Windows a set value is `invalid_request`.
+ */
+export declare function configuredDaemonUid(env?: NodeJS.ProcessEnv, windows?: boolean): number | undefined;
+/**
+ * Environment variables a client passes through when it starts the long-lived daemon (`messaging daemon
+ * start`, the OpenCode plugin's autostart). Provider API keys, cloud credentials, tokens and
+ * NODE_OPTIONS, which could preload code into the daemon, stay behind.
+ */
+export declare const DAEMON_ENV: readonly string[];
+/**
+ * Also passed on Windows: the variables Windows programs need to run at all (`SystemRoot`: Winsock and the
+ * crypto provider fail without it), find the user's profile and temp directories, and run system tools.
+ */
+export declare const DAEMON_ENV_WINDOWS: readonly string[];
+/** The daemon environment: the `DAEMON_ENV` part of `env` (and on Windows `DAEMON_ENV_WINDOWS`), plus `MESSAGING_HOME`. */
+export declare function daemonEnv(env: Readonly<Record<string, string | undefined>>, home: string, windows?: boolean): Record<string, string>;

package/dist/types/ipc/pipes.d.ts

@@ -0,0 +1,16 @@
+import type { SocketTier } from "./paths.js";
+/** The only pipe names a client connects to. */
+export declare const PIPE_NAME: RegExp;
+export interface PipePointer {
+    pipe: string;
+    pid: number;
+}
+/** A fresh, unpredictable pipe name for one server of `tier`. */
+export declare function newPipeName(tier: SocketTier): string;
+/** Writes the pointer atomically: a temp file beside it (inheriting the directory's ACL), renamed over it. */
+export declare function writePointer(path: string, pointer: PipePointer): void;
+/**
+ * Reads a pointer file: `daemon_unavailable` when it is missing, `forbidden` when it is not exactly
+ * `{pipe, pid}` with a pipe name of the shape `newPipeName` makes.
+ */
+export declare function readPointer(path: string): PipePointer;

package/dist/types/ipc/rpc.d.ts

@@ -0,0 +1,13 @@
+/** Standard JSON-RPC 2.0 error codes. Messaging errors use MESSAGING_ERROR_RPC_CODE from @messaging/core. */
+export declare const RPC: {
+    readonly parseError: -32700;
+    readonly invalidRequest: -32600;
+    readonly methodNotFound: -32601;
+    readonly invalidParams: -32602;
+    readonly internalError: -32603;
+};
+export interface RpcErrorObject {
+    code: number;
+    message: string;
+    data?: unknown;
+}