@riocrypto/common-server 1.0.2930 → 1.0.2932

package/build/helpers/get-order-from-reference.js

@@ -61,8 +61,8 @@ const getOrderFromReference = (reference, mongoose) => __awaiter(void 0, void 0,
     const newFormatCandidates = hexWindows(reference, NEW_FORMAT_LENGTH).map((window) => window.toUpperCase());
     const oldFormatWindows = hexWindows(reference, OLD_FORMAT_LENGTH);
     // A reference is a run of hex, so text without one cannot contain any order's
-    // token in either format. Static references (SPR…) and free text end here
-    // instead of walking the active orders to confirm what is already known.
+    // token in either format. Free text ends here instead of walking the active
+    // orders to confirm what is already known.
     if (!newFormatCandidates.length && !oldFormatWindows.length) {
         throw new Error("Order not found");
     }

package/build/index.d.ts

@@ -132,6 +132,11 @@ export * from "./models/liquidity-sourcing-exclusion";
 export * from "./models/liquidity-sourcing-settings";
 export * from "./models/compliance-session";
 export * from "./models/compliance-bot-chat";
+export * from "./models/internal-support-session";
+export * from "./models/internal-support-chat-message";
+export * from "./models/internal-support-audit-event";
+export * from "./models/internal-support-case";
+export * from "./models/internal-support-security";
 export * from "./models/compliance-bot-rule";
 export * from "./models/compliance-bot-rule-result";
 export * from "./models/compliance-rule-set";

package/build/index.js

@@ -148,6 +148,11 @@ __exportStar(require("./models/liquidity-sourcing-exclusion"), exports);
 __exportStar(require("./models/liquidity-sourcing-settings"), exports);
 __exportStar(require("./models/compliance-session"), exports);
 __exportStar(require("./models/compliance-bot-chat"), exports);
+__exportStar(require("./models/internal-support-session"), exports);
+__exportStar(require("./models/internal-support-chat-message"), exports);
+__exportStar(require("./models/internal-support-audit-event"), exports);
+__exportStar(require("./models/internal-support-case"), exports);
+__exportStar(require("./models/internal-support-security"), exports);
 __exportStar(require("./models/compliance-bot-rule"), exports);
 __exportStar(require("./models/compliance-bot-rule-result"), exports);
 __exportStar(require("./models/compliance-rule-set"), exports);

package/build/models/internal-support-audit-event.d.ts

@@ -0,0 +1,18 @@
+import mongoose from "mongoose";
+import { InternalSupportAuditType } from "@riocrypto/common";
+export interface InternalSupportAuditEventDoc extends mongoose.Document {
+    sessionId: string;
+    adminAuthId: string;
+    adminAuthEmail: string;
+    type: InternalSupportAuditType;
+    toolName?: string;
+    toolInput?: any;
+    detail?: string;
+    redactionCounts?: Record<string, number>;
+    inputTokens?: number;
+    outputTokens?: number;
+    createdAt: Date;
+}
+export type InternalSupportAuditEventModel = mongoose.Model<InternalSupportAuditEventDoc>;
+declare const buildInternalSupportAuditEvent: (mongoose: typeof mongoose) => InternalSupportAuditEventModel;
+export { buildInternalSupportAuditEvent };

package/build/models/internal-support-audit-event.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInternalSupportAuditEvent = void 0;
+const common_1 = require("@riocrypto/common");
+const buildInternalSupportAuditEvent = (mongoose) => {
+    if (mongoose.models.InternalSupportAuditEvent) {
+        return mongoose.model("InternalSupportAuditEvent");
+    }
+    const schema = new mongoose.Schema({
+        sessionId: { type: String, required: true },
+        adminAuthId: { type: String, required: true },
+        adminAuthEmail: { type: String, required: true },
+        type: { type: String, enum: Object.values(common_1.InternalSupportAuditType), required: true },
+        toolName: { type: String },
+        toolInput: { type: mongoose.Schema.Types.Mixed },
+        detail: { type: String },
+        redactionCounts: { type: mongoose.Schema.Types.Mixed },
+        inputTokens: { type: Number },
+        outputTokens: { type: Number },
+    }, {
+        timestamps: { createdAt: true, updatedAt: false },
+        collection: "internalSupportAuditEvents",
+    });
+    // Daily caps count and sum per admin, type and time window on every new
+    // question, so that query is index-only. The per-session index is in
+    // event order for reviewing one conversation's trail.
+    schema.index({ adminAuthId: 1, type: 1, createdAt: -1 });
+    schema.index({ sessionId: 1, createdAt: 1 });
+    schema.index({ type: 1, createdAt: -1 });
+    return mongoose.model("InternalSupportAuditEvent", schema);
+};
+exports.buildInternalSupportAuditEvent = buildInternalSupportAuditEvent;

package/build/models/internal-support-case.d.ts

@@ -0,0 +1,19 @@
+import mongoose from "mongoose";
+import { InternalSupportCaseConfidence } from "@riocrypto/common";
+export interface InternalSupportCaseDoc extends mongoose.Document {
+    sessionId: string;
+    adminAuthEmail: string;
+    symptom: string;
+    services: string[];
+    rootCause: string;
+    evidence: string;
+    resolution: string;
+    confidence: InternalSupportCaseConfidence;
+    tags: string[];
+    questions: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export type InternalSupportCaseModel = mongoose.Model<InternalSupportCaseDoc>;
+declare const buildInternalSupportCase: (mongoose: typeof mongoose) => InternalSupportCaseModel;
+export { buildInternalSupportCase };

package/build/models/internal-support-case.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInternalSupportCase = void 0;
+const buildInternalSupportCase = (mongoose) => {
+    if (mongoose.models.InternalSupportCase) {
+        return mongoose.model("InternalSupportCase");
+    }
+    const schema = new mongoose.Schema({
+        sessionId: { type: String, required: true, unique: true },
+        adminAuthEmail: { type: String, required: true },
+        symptom: { type: String, required: true },
+        services: { type: [String], default: [] },
+        rootCause: { type: String, default: "" },
+        evidence: { type: String, default: "" },
+        resolution: { type: String, default: "" },
+        confidence: { type: String, enum: ["low", "medium", "high"], default: "low" },
+        tags: { type: [String], default: [] },
+        questions: { type: Number, default: 1 },
+    }, {
+        timestamps: true,
+        collection: "internalSupportCases",
+        toJSON: {
+            transform(_doc, ret) {
+                ret.id = ret._id;
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    // Weighted text index so a new question matches on the symptom and the
+    // services first, then on the cause and the tags.
+    schema.index({ symptom: "text", tags: "text", services: "text", rootCause: "text", resolution: "text" }, {
+        weights: { symptom: 10, tags: 8, services: 6, rootCause: 4, resolution: 2 },
+        name: "case_text",
+    });
+    schema.index({ updatedAt: -1 });
+    return mongoose.model("InternalSupportCase", schema);
+};
+exports.buildInternalSupportCase = buildInternalSupportCase;

package/build/models/internal-support-chat-message.d.ts

@@ -0,0 +1,13 @@
+import mongoose from "mongoose";
+import { InternalSupportChatKind } from "@riocrypto/common";
+export interface InternalSupportChatMessageDoc extends mongoose.Document {
+    sessionId: string;
+    sequenceNumber: number;
+    kind: InternalSupportChatKind;
+    text: string;
+    toolName?: string;
+    createdAt: Date;
+}
+export type InternalSupportChatMessageModel = mongoose.Model<InternalSupportChatMessageDoc>;
+declare const buildInternalSupportChatMessage: (mongoose: typeof mongoose) => InternalSupportChatMessageModel;
+export { buildInternalSupportChatMessage };

package/build/models/internal-support-chat-message.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInternalSupportChatMessage = void 0;
+const common_1 = require("@riocrypto/common");
+const buildInternalSupportChatMessage = (mongoose) => {
+    if (mongoose.models.InternalSupportChatMessage) {
+        return mongoose.model("InternalSupportChatMessage");
+    }
+    const schema = new mongoose.Schema({
+        sessionId: { type: String, required: true, index: true },
+        sequenceNumber: { type: Number, required: true },
+        kind: { type: String, enum: Object.values(common_1.InternalSupportChatKind), required: true },
+        text: { type: String, required: true },
+        toolName: { type: String },
+    }, {
+        timestamps: { createdAt: true, updatedAt: false },
+        collection: "internalSupportChatMessages",
+        toJSON: {
+            transform(_doc, ret) {
+                ret.id = ret._id;
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    schema.index({ sessionId: 1, sequenceNumber: 1 }, { unique: true });
+    return mongoose.model("InternalSupportChatMessage", schema);
+};
+exports.buildInternalSupportChatMessage = buildInternalSupportChatMessage;

package/build/models/internal-support-security.d.ts

@@ -0,0 +1,36 @@
+import mongoose from "mongoose";
+import { InternalSupportSecuritySignalType } from "@riocrypto/common";
+export interface InternalSupportSecuritySignalDoc extends mongoose.Document {
+    adminAuthId: string;
+    adminAuthEmail: string;
+    adminAuthName: string;
+    sessionId?: string;
+    type: InternalSupportSecuritySignalType;
+    detail: string;
+    createdAt: Date;
+}
+export type InternalSupportSecuritySignalModel = mongoose.Model<InternalSupportSecuritySignalDoc>;
+declare const buildInternalSupportSecuritySignal: (mongoose: typeof mongoose) => InternalSupportSecuritySignalModel;
+export interface InternalSupportLockoutDoc extends mongoose.Document {
+    adminAuthId: string;
+    adminAuthEmail: string;
+    adminAuthName: string;
+    reason: string;
+    lockedAt: Date;
+    lockedUntil: Date;
+    unlockedAt?: Date;
+    unlockedBy?: string;
+}
+export type InternalSupportLockoutModel = mongoose.Model<InternalSupportLockoutDoc>;
+declare const buildInternalSupportLockout: (mongoose: typeof mongoose) => InternalSupportLockoutModel;
+export declare const INTERNAL_SUPPORT_CONTROLS_KEY = "global";
+export interface InternalSupportControlsDoc extends mongoose.Document {
+    key: string;
+    disabled: boolean;
+    disabledAt?: Date;
+    disabledBy?: string;
+    reason?: string;
+}
+export type InternalSupportControlsModel = mongoose.Model<InternalSupportControlsDoc>;
+declare const buildInternalSupportControls: (mongoose: typeof mongoose) => InternalSupportControlsModel;
+export { buildInternalSupportSecuritySignal, buildInternalSupportLockout, buildInternalSupportControls };

package/build/models/internal-support-security.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInternalSupportControls = exports.buildInternalSupportLockout = exports.buildInternalSupportSecuritySignal = exports.INTERNAL_SUPPORT_CONTROLS_KEY = void 0;
+const common_1 = require("@riocrypto/common");
+const buildInternalSupportSecuritySignal = (mongoose) => {
+    if (mongoose.models.InternalSupportSecuritySignal) {
+        return mongoose.model("InternalSupportSecuritySignal");
+    }
+    const schema = new mongoose.Schema({
+        adminAuthId: { type: String, required: true, index: true },
+        adminAuthEmail: { type: String, required: true },
+        adminAuthName: { type: String, default: "" },
+        sessionId: { type: String },
+        type: {
+            type: String,
+            enum: Object.values(common_1.InternalSupportSecuritySignalType),
+            required: true,
+        },
+        detail: { type: String, default: "" },
+    }, {
+        timestamps: { createdAt: true, updatedAt: false },
+        collection: "internalSupportSecuritySignals",
+    });
+    schema.index({ createdAt: -1 });
+    schema.index({ adminAuthId: 1, createdAt: -1 });
+    return mongoose.model("InternalSupportSecuritySignal", schema);
+};
+exports.buildInternalSupportSecuritySignal = buildInternalSupportSecuritySignal;
+const buildInternalSupportLockout = (mongoose) => {
+    if (mongoose.models.InternalSupportLockout) {
+        return mongoose.model("InternalSupportLockout");
+    }
+    const schema = new mongoose.Schema({
+        adminAuthId: { type: String, required: true, index: true },
+        adminAuthEmail: { type: String, required: true },
+        adminAuthName: { type: String, default: "" },
+        reason: { type: String, default: "" },
+        lockedAt: { type: Date, required: true },
+        lockedUntil: { type: Date, required: true },
+        unlockedAt: { type: Date },
+        unlockedBy: { type: String },
+    }, {
+        collection: "internalSupportLockouts",
+        toJSON: {
+            transform(_doc, ret) {
+                ret.id = ret._id;
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    return mongoose.model("InternalSupportLockout", schema);
+};
+exports.buildInternalSupportLockout = buildInternalSupportLockout;
+// Singleton (key "global"). Read on every write request so the switch works
+// without a redeploy; flipped by a super admin or by the monitor when a
+// global trip condition is met.
+exports.INTERNAL_SUPPORT_CONTROLS_KEY = "global";
+const buildInternalSupportControls = (mongoose) => {
+    if (mongoose.models.InternalSupportControls) {
+        return mongoose.model("InternalSupportControls");
+    }
+    const schema = new mongoose.Schema({
+        key: { type: String, required: true, unique: true },
+        disabled: { type: Boolean, default: false },
+        disabledAt: { type: Date },
+        disabledBy: { type: String },
+        reason: { type: String },
+    }, {
+        collection: "internalSupportControls",
+        toJSON: {
+            transform(_doc, ret) {
+                delete ret._id;
+                delete ret.__v;
+                delete ret.key;
+            },
+        },
+    });
+    return mongoose.model("InternalSupportControls", schema);
+};
+exports.buildInternalSupportControls = buildInternalSupportControls;

package/build/models/internal-support-session.d.ts

@@ -0,0 +1,18 @@
+import mongoose from "mongoose";
+import { InternalSupportSessionStatus } from "@riocrypto/common";
+export interface InternalSupportSessionDoc extends mongoose.Document {
+    sessionId: string;
+    adminAuthId: string;
+    adminAuthEmail: string;
+    adminAuthName: string;
+    title: string;
+    status: InternalSupportSessionStatus;
+    modelId: string;
+    apiMessages: any[];
+    sequenceNumber: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export type InternalSupportSessionModel = mongoose.Model<InternalSupportSessionDoc>;
+declare const buildInternalSupportSession: (mongoose: typeof mongoose) => InternalSupportSessionModel;
+export { buildInternalSupportSession };

package/build/models/internal-support-session.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInternalSupportSession = void 0;
+const common_1 = require("@riocrypto/common");
+const buildInternalSupportSession = (mongoose) => {
+    if (mongoose.models.InternalSupportSession) {
+        return mongoose.model("InternalSupportSession");
+    }
+    const schema = new mongoose.Schema({
+        sessionId: { type: String, required: true, unique: true, index: true },
+        adminAuthId: { type: String, required: true, index: true },
+        adminAuthEmail: { type: String, required: true },
+        adminAuthName: { type: String, default: "" },
+        title: { type: String, default: "" },
+        status: {
+            type: String,
+            enum: Object.values(common_1.InternalSupportSessionStatus),
+            default: common_1.InternalSupportSessionStatus.Idle,
+        },
+        modelId: { type: String, default: "" },
+        apiMessages: { type: Array, default: [] },
+        sequenceNumber: { type: Number, default: 0 },
+    }, {
+        timestamps: true,
+        collection: "internalSupportSessions",
+        toJSON: {
+            transform(_doc, ret) {
+                ret.id = ret._id;
+                delete ret._id;
+                delete ret.__v;
+                delete ret.apiMessages;
+            },
+        },
+    });
+    return mongoose.model("InternalSupportSession", schema);
+};
+exports.buildInternalSupportSession = buildInternalSupportSession;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common-server",
-  "version": "1.0.2930",
+  "version": "1.0.2932",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -28,7 +28,7 @@
     "@google-cloud/secret-manager": "^5.6.0",
     "@google-cloud/storage": "^7.19.0",
     "@hyperdx/node-opentelemetry": "^0.10.3",
-    "@riocrypto/common": "1.0.2728",
+    "@riocrypto/common": "1.0.2729",
     "@slack/web-api": "^7.15.0",
     "@types/express": "^4.17.25",
     "axios": "1.18.1",