@fonoster/common 0.27.0 → 0.31.0

package/dist/registry/workspaceKeys.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { PrismaLike } from "./prisma";
+export type WorkspaceKeysOptions = {
+    /** How long a looked-up key (or its absence) is reused (default 30 s). */
+    cacheMs?: number;
+    now?: () => number;
+};
+export declare class PrismaWorkspaceKeys {
+    private readonly prisma;
+    private readonly options;
+    private cache;
+    constructor(prisma: PrismaLike, options?: WorkspaceKeysOptions);
+    private now;
+    /** The workspace's key for a provider, or undefined (then the platform key applies). */
+    get(workspaceRef: string, providerId: string): Promise<string | undefined>;
+    /**
+     * The workspace's key for a credentialRef: the providers that use that ref (from the catalog)
+     * are tried in order.
+     */
+    forCredentialRef(workspaceRef: string, credentialRef: string, providers: {
+        id: string;
+        credentialRef: string;
+    }[]): Promise<string | undefined>;
+}

package/dist/registry/workspaceKeys.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaWorkspaceKeys = void 0;
+class PrismaWorkspaceKeys {
+    constructor(prisma, options = {}) {
+        this.prisma = prisma;
+        this.options = options;
+        this.cache = new Map();
+    }
+    now() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.options).now) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : Date.now();
+    }
+    /** The workspace's key for a provider, or undefined (then the platform key applies). */
+    get(workspaceRef, providerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!workspaceRef || !providerId)
+                return undefined;
+            const id = `${workspaceRef}\u0000${providerId}`;
+            const hit = this.cache.get(id);
+            if (hit && this.now() - hit.at < ((_a = this.options.cacheMs) !== null && _a !== void 0 ? _a : 30000))
+                return hit.key;
+            const binding = yield this.prisma.workspaceProviderKey.findUnique({
+                where: {
+                    accessKeyId_providerId: { accessKeyId: workspaceRef, providerId }
+                }
+            });
+            let key;
+            if (binding) {
+                const secret = yield this.prisma.secret.findUnique({
+                    where: { ref: binding.secretRef }
+                });
+                key = (secret === null || secret === void 0 ? void 0 : secret.secret) || undefined;
+            }
+            this.cache.set(id, { at: this.now(), key });
+            return key;
+        });
+    }
+    /**
+     * The workspace's key for a credentialRef: the providers that use that ref (from the catalog)
+     * are tried in order.
+     */
+    forCredentialRef(workspaceRef, credentialRef, providers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const p of providers.filter((x) => x.credentialRef === credentialRef)) {
+                const key = yield this.get(workspaceRef, p.id);
+                if (key)
+                    return key;
+            }
+            return undefined;
+        });
+    }
+}
+exports.PrismaWorkspaceKeys = PrismaWorkspaceKeys;

package/dist/roomr/health.d.ts

@@ -0,0 +1,9 @@
+/** How long one health check may take. */
+export declare const HEALTH_CHECK_TIMEOUT_MS = 2000;
+/**
+ * Whether `address` (host:port) answers the standard gRPC health check (grpc.health.v1) with
+ * SERVING for the server as a whole. False on any error, a timeout or any other status (a Roomr
+ * node or AppBridge replica draining after SIGTERM reports NOT_SERVING). Through a Kubernetes
+ * Service or a Compose service name the check reaches one ready replica.
+ */
+export declare function checkGrpcHealth(address: string, timeoutMs?: number): Promise<boolean>;

package/dist/{assistants/eventsHookSchema.js → roomr/health.js}

@@ -33,7 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventsHookAllowedEvents = exports.eventsHookSchema = void 0;
+exports.HEALTH_CHECK_TIMEOUT_MS = void 0;
+exports.checkGrpcHealth = checkGrpcHealth;
 /**
  * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
  * http://github.com/fonoster/fonoster
@@ -52,20 +53,23 @@ exports.EventsHookAllowedEvents = exports.eventsHookSchema = void 0;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const zod_1 = require("zod");
-const Messages = __importStar(require("../messages"));
-var EventsHookAllowedEvents;
-(function (EventsHookAllowedEvents) {
-    EventsHookAllowedEvents["ALL"] = "all";
-    EventsHookAllowedEvents["CONVERSATION_STARTED"] = "conversation.started";
-    EventsHookAllowedEvents["CONVERSATION_ENDED"] = "conversation.ended";
-})(EventsHookAllowedEvents || (exports.EventsHookAllowedEvents = EventsHookAllowedEvents = {}));
-const eventsHookSchema = zod_1.z.object({
-    url: zod_1.z.string().url({ message: Messages.VALID_URL }),
-    headers: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
-    events: zod_1.z
-        .array(zod_1.z.nativeEnum(EventsHookAllowedEvents))
-        .min(1)
-        .default([EventsHookAllowedEvents.ALL])
-});
-exports.eventsHookSchema = eventsHookSchema;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const grpc_health_check_1 = require("grpc-health-check");
+/** How long one health check may take. */
+exports.HEALTH_CHECK_TIMEOUT_MS = 2000;
+/**
+ * Whether `address` (host:port) answers the standard gRPC health check (grpc.health.v1) with
+ * SERVING for the server as a whole. False on any error, a timeout or any other status (a Roomr
+ * node or AppBridge replica draining after SIGTERM reports NOT_SERVING). Through a Kubernetes
+ * Service or a Compose service name the check reaches one ready replica.
+ */
+function checkGrpcHealth(address, timeoutMs = exports.HEALTH_CHECK_TIMEOUT_MS) {
+    const Health = grpc.makeGenericClientConstructor(grpc_health_check_1.service, "Health");
+    const client = new Health(address, grpc.credentials.createInsecure());
+    return new Promise((resolve) => {
+        client.Check({ service: "" }, { deadline: Date.now() + timeoutMs }, (error, res) => {
+            client.close();
+            resolve(!error && ((res === null || res === void 0 ? void 0 : res.status) === "SERVING" || (res === null || res === void 0 ? void 0 : res.status) === 1));
+        });
+    });
+}

package/dist/roomr/index.d.ts

@@ -0,0 +1,75 @@
+import * as grpc from "@grpc/grpc-js";
+/** The proto file this package loads. */
+export declare const ROOMR_PROTO: string;
+export type SipAuth = {
+    username: string;
+    password: string;
+};
+export type SipTarget = {
+    uri: string;
+    proxy?: string;
+    headers?: Record<string, string>;
+    auth?: SipAuth;
+};
+export type CreateCallRequest = {
+    callRef?: string;
+    to: SipTarget;
+    from?: string;
+    roomRef?: string;
+    session?: string;
+    ringTimeoutS?: number;
+    /** Passed through untouched in the events for this call (e.g. { app_ref }). */
+    metadata?: Record<string, string>;
+    maxDurationS?: number;
+};
+export type Call = {
+    callRef: string;
+    roomRef: string;
+    state: "RINGING" | "ANSWERED" | "ENDED";
+    participantRef: string;
+};
+export type CreateRoomRequest = {
+    roomRef?: string;
+    maxDurationS?: number;
+    /** Overrides the node's emptyRoomTimeout for this room (0: the node's). */
+    emptyTimeoutS?: number;
+    /** Overrides the node's maxParticipants for this room (0: the node's). */
+    maxParticipants?: number;
+};
+export type Room = {
+    roomRef: string;
+};
+/** The RPCs the control plane uses, each against one node's control address. */
+export type RoomrCalls = {
+    createCall(addr: string, request: CreateCallRequest): Promise<Call>;
+    createRoom(addr: string, request: CreateRoomRequest): Promise<Room>;
+    endCall(addr: string, request: {
+        callRef: string;
+    }): Promise<void>;
+    endRoom(addr: string, request: {
+        roomRef: string;
+    }): Promise<void>;
+};
+/** A failed RPC, with its gRPC status code. */
+export declare class RoomrError extends Error {
+    readonly code: grpc.status;
+    constructor(code: grpc.status, message: string);
+}
+/** The roomr.v1 package (protoLoader options as for the other Fonoster services). */
+export declare function roomrPackage(): grpc.GrpcObject;
+/** The Roomr service definition (fakes serve it). */
+export declare function roomrService(): grpc.ServiceDefinition;
+/** Each call's deadline (ms). */
+export declare const ROOMR_DEADLINE_MS = 2000;
+/**
+ * One gRPC channel per node address, reused by every call to it, with HTTP/2 keepalive and a
+ * deadline per call. Plaintext: the control port is reachable only inside the deployment's
+ * network. `close()` closes every channel.
+ */
+export declare function createRoomrPool(options?: {
+    deadlineMs?: number;
+}): RoomrCalls & {
+    close(): void;
+};
+export * from "./health";
+export * from "./session";

package/dist/roomr/index.js

@@ -0,0 +1,146 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROOMR_DEADLINE_MS = exports.RoomrError = exports.ROOMR_PROTO = void 0;
+exports.roomrPackage = roomrPackage;
+exports.roomrService = roomrService;
+exports.createRoomrPool = createRoomrPool;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const path = __importStar(require("path"));
+const grpc = __importStar(require("@grpc/grpc-js"));
+const protoLoader = __importStar(require("@grpc/proto-loader"));
+// The controller's side of Roomr (roomr.v1.Roomr, redesign-roomr "Roomr is a gRPC service
+// with three nouns"). The proto is fonoster/roomr's api/roomr/v1/roomr.proto; src/protos/roomr.proto
+// is the copy of the pinned release (npm run sync:roomr; the client test checks it).
+/** The proto file this package loads. */
+exports.ROOMR_PROTO = path.join(__dirname, "..", "protos", "roomr.proto");
+/** A failed RPC, with its gRPC status code. */
+class RoomrError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "RoomrError";
+    }
+}
+exports.RoomrError = RoomrError;
+let loaded;
+/** The roomr.v1 package (protoLoader options as for the other Fonoster services). */
+function roomrPackage() {
+    loaded !== null && loaded !== void 0 ? loaded : (loaded = grpc.loadPackageDefinition(protoLoader.loadSync(exports.ROOMR_PROTO, {
+        keepCase: false,
+        longs: String,
+        enums: String,
+        defaults: true,
+        oneofs: true
+    })));
+    return loaded.roomr.v1;
+}
+/** The Roomr service definition (fakes serve it). */
+function roomrService() {
+    return roomrPackage().Roomr.service;
+}
+/** Each call's deadline (ms). */
+exports.ROOMR_DEADLINE_MS = 2000;
+/**
+ * One gRPC channel per node address, reused by every call to it, with HTTP/2 keepalive and a
+ * deadline per call. Plaintext: the control port is reachable only inside the deployment's
+ * network. `close()` closes every channel.
+ */
+function createRoomrPool(options = {}) {
+    const Client = roomrPackage().Roomr;
+    const clients = new Map();
+    const client = (addr) => {
+        let c = clients.get(addr);
+        if (!c) {
+            c = new Client(addr, grpc.credentials.createInsecure(), {
+                "grpc.keepalive_time_ms": 10000,
+                "grpc.keepalive_timeout_ms": 5000,
+                "grpc.keepalive_permit_without_calls": 1
+            });
+            clients.set(addr, c);
+        }
+        return c;
+    };
+    const call = (method) => (addr, request) => new Promise((resolve, reject) => {
+        var _a;
+        const rpc = client(addr)[method].bind(client(addr));
+        rpc(request, { deadline: Date.now() + ((_a = options.deadlineMs) !== null && _a !== void 0 ? _a : exports.ROOMR_DEADLINE_MS) }, (err, res) => err ? reject(new RoomrError(err.code, err.details)) : resolve(res));
+    });
+    const empty = (method) => (addr, request) => __awaiter(this, void 0, void 0, function* () {
+        yield call(method)(addr, request);
+    });
+    return {
+        createCall: call("CreateCall"),
+        createRoom: call("CreateRoom"),
+        endCall: empty("EndCall"),
+        endRoom: empty("EndRoom"),
+        close() {
+            for (const c of clients.values())
+                c.close();
+            clients.clear();
+        }
+    };
+}
+__exportStar(require("./health"), exports);
+__exportStar(require("./session"), exports);

package/dist/roomr/session.d.ts

@@ -0,0 +1,133 @@
+import * as grpc from "@grpc/grpc-js";
+/** The proto file this module loads. */
+export declare const SESSION_PROTO: string;
+/** The port AppBridge serves Session.Connect (and grpc.health.v1) on by default. */
+export declare const SESSION_PORT = 50071;
+/** The gRPC service name, as the health service reports it. */
+export declare const SESSION_SERVICE_NAME = "session.v1.Session";
+/** An RTP endpoint: `codec` is "L16/16000" on app legs; `srtpKey` (SDES, base64) when encrypted. */
+export type MediaEndpoint = {
+    ip: string;
+    port: number;
+    codec?: string;
+    srtpKey?: string;
+};
+export type SessionSipTarget = {
+    uri: string;
+    proxy?: string;
+    headers?: Record<string, string>;
+    auth?: {
+        username: string;
+        password: string;
+    };
+};
+export type SessionStart = {
+    callRef: string;
+    direction: "INBOUND" | "OUTBOUND";
+    from: string;
+    to: string;
+    /** Every INVITE header (inbound) or CreateCall's to.headers (outbound). */
+    headers: Record<string, string>;
+    /** CreateCall's metadata, untouched (outbound calls carry `app_ref`). */
+    metadata: Record<string, string>;
+    roomRef: string;
+    /** The node's RTP endpoint for this call's app leg. */
+    media?: MediaEndpoint;
+    nodeRef: string;
+};
+export type SessionDtmf = {
+    digit: string;
+    source?: string;
+};
+export type SessionEvent = {
+    participantJoined?: {
+        participantRef: string;
+        trackId: number;
+    };
+    participantLeft?: {
+        participantRef: string;
+        cause: string;
+    };
+    transferResult?: {
+        status: string;
+        cause?: string;
+        sipStatus?: number;
+    };
+    ended?: {
+        cause: string;
+        sipStatus?: number;
+    };
+    /** The oneof member that is set (protoLoader `oneofs: true`). */
+    event?: "participantJoined" | "participantLeft" | "transferResult" | "ended";
+};
+/** A message from the node. */
+export type NodeMessage = {
+    start?: SessionStart;
+    dtmf?: SessionDtmf;
+    event?: SessionEvent;
+    msg?: "start" | "dtmf" | "event";
+};
+export type ListenTrack = {
+    trackId: number;
+    rtp: MediaEndpoint;
+};
+/** A message to the node (exactly one member set). */
+export type AppMessage = {
+    answer?: {
+        media: MediaEndpoint;
+        maxDurationS?: number;
+    };
+    ready?: {
+        media: MediaEndpoint;
+    };
+    reject?: {
+        sipStatus: number;
+        reason?: string;
+    };
+    transfer?: {
+        to: SessionSipTarget;
+        mode: "cold" | "warm" | "refer";
+        music?: string;
+        ringTimeoutS?: number;
+    };
+    transferComplete?: Record<string, never>;
+    /** Cuts the caller off from the app; the node loops `music` (a WAV URL) to the caller alone. */
+    hold?: {
+        music?: string;
+    };
+    resume?: Record<string, never>;
+    /** RFC 4733 events on the caller's leg, in order. */
+    sendDtmf?: {
+        digits: string;
+    };
+    addListener?: {
+        listenerRef: string;
+        listen: ListenTrack[];
+    };
+    removeListener?: {
+        listenerRef: string;
+    };
+    hangup?: {
+        sipStatus?: number;
+        reason?: string;
+    };
+    msg?: AppMessageType;
+};
+export type AppMessageType = "answer" | "ready" | "reject" | "transfer" | "transferComplete" | "hold" | "resume" | "sendDtmf" | "addListener" | "removeListener" | "hangup";
+/** The member a message carries (the oneof's name), for logs and fakes. */
+export declare function messageType<T extends Record<string, unknown>>(message: T, members: readonly string[]): string | undefined;
+export declare const APP_MESSAGE_TYPES: readonly AppMessageType[];
+export declare const NODE_MESSAGE_TYPES: readonly ["start", "dtmf", "event"];
+export declare const SESSION_EVENT_TYPES: readonly ["participantJoined", "participantLeft", "transferResult", "ended"];
+/** Ended causes the node sends (media-control "Endings carry a reason"). */
+export declare const ENDED_CAUSES: readonly ["caller_hangup", "callee_hangup", "busy", "no_answer", "rejected", "media_timeout", "node_error", "max_duration", "removed", "app_gone"];
+/** The session.v1 package (protoLoader options as for the other Fonoster services). */
+export declare function sessionPackage(): grpc.GrpcObject;
+/** The Session service definition (AppBridge serves it). */
+export declare function sessionService(): grpc.ServiceDefinition;
+/** The Session client constructor (the node's side; fakes use it). */
+export declare function sessionClient(): grpc.ServiceClientConstructor;
+/** The server side of one control stream. */
+export type SessionServerStream = grpc.ServerDuplexStream<NodeMessage, AppMessage>;
+/** The client side of one control stream. */
+export type SessionClientStream = grpc.ClientDuplexStream<NodeMessage, AppMessage>;

package/dist/roomr/session.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENDED_CAUSES = exports.SESSION_EVENT_TYPES = exports.NODE_MESSAGE_TYPES = exports.APP_MESSAGE_TYPES = exports.SESSION_SERVICE_NAME = exports.SESSION_PORT = exports.SESSION_PROTO = void 0;
+exports.messageType = messageType;
+exports.sessionPackage = sessionPackage;
+exports.sessionService = sessionService;
+exports.sessionClient = sessionClient;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const path = __importStar(require("path"));
+const grpc = __importStar(require("@grpc/grpc-js"));
+const protoLoader = __importStar(require("@grpc/proto-loader"));
+// The per-call control stream (session.v1.Session, redesign-roomr media-control "Each call opens
+// one control stream to the session endpoint"). The Roomr node is the client: it opens one
+// connection per call and sends Start first; the session endpoint (AppBridge) answers with
+// Answer, Ready or Reject and sends the app's commands. Audio never travels here. The proto is
+// fonoster/roomr's api/session/v1/session.proto; src/protos/session.proto is the copy of the
+// pinned release (npm run sync:roomr; the client test checks it).
+/** The proto file this module loads. */
+exports.SESSION_PROTO = path.join(__dirname, "..", "protos", "session.proto");
+/** The port AppBridge serves Session.Connect (and grpc.health.v1) on by default. */
+exports.SESSION_PORT = 50071;
+/** The gRPC service name, as the health service reports it. */
+exports.SESSION_SERVICE_NAME = "session.v1.Session";
+/** The member a message carries (the oneof's name), for logs and fakes. */
+function messageType(message, members) {
+    if (typeof message.msg === "string")
+        return message.msg;
+    return members.find((m) => message[m] !== undefined && message[m] !== null);
+}
+exports.APP_MESSAGE_TYPES = [
+    "answer",
+    "ready",
+    "reject",
+    "transfer",
+    "transferComplete",
+    "hold",
+    "resume",
+    "sendDtmf",
+    "addListener",
+    "removeListener",
+    "hangup"
+];
+exports.NODE_MESSAGE_TYPES = ["start", "dtmf", "event"];
+exports.SESSION_EVENT_TYPES = [
+    "participantJoined",
+    "participantLeft",
+    "transferResult",
+    "ended"
+];
+/** Ended causes the node sends (media-control "Endings carry a reason"). */
+exports.ENDED_CAUSES = [
+    "caller_hangup",
+    "callee_hangup",
+    "busy",
+    "no_answer",
+    "rejected",
+    "media_timeout",
+    "node_error",
+    "max_duration",
+    "removed",
+    "app_gone"
+];
+let loaded;
+/** The session.v1 package (protoLoader options as for the other Fonoster services). */
+function sessionPackage() {
+    loaded !== null && loaded !== void 0 ? loaded : (loaded = grpc.loadPackageDefinition(protoLoader.loadSync(exports.SESSION_PROTO, {
+        keepCase: false,
+        longs: Number,
+        enums: String,
+        defaults: true,
+        oneofs: true
+    })));
+    return loaded.session.v1;
+}
+/** The Session service definition (AppBridge serves it). */
+function sessionService() {
+    return sessionPackage().Session.service;
+}
+/** The Session client constructor (the node's side; fakes use it). */
+function sessionClient() {
+    return sessionPackage().Session;
+}

package/dist/session/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from "./schema";