@qlever-llc/trellis 0.7.0-rc.5 → 0.7.0

package/script/js/packages/trellis/npm/src/contract_support/schema_pointers.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSubschemaAtDataPointer = getSubschemaAtDataPointer;
+exports.assertDataPointersExistAndAreTokenable = assertDataPointersExistAndAreTokenable;
+const json_schema_library_1 = require("json-schema-library");
+function isTokenableSchema(schema) {
+    if (schema === true || schema === false)
+        return false;
+    if (!schema || typeof schema !== "object")
+        return false;
+    const s = schema;
+    const allOf = s.allOf;
+    if (Array.isArray(allOf) && allOf.length > 0) {
+        return allOf.every(isTokenableSchema);
+    }
+    const anyOf = s.anyOf;
+    if (Array.isArray(anyOf) && anyOf.length > 0) {
+        return anyOf.every(isTokenableSchema);
+    }
+    const oneOf = s.oneOf;
+    if (Array.isArray(oneOf) && oneOf.length > 0) {
+        return oneOf.every(isTokenableSchema);
+    }
+    const constant = s.const;
+    if (typeof constant === "string" || typeof constant === "number")
+        return true;
+    const enumValues = s.enum;
+    if (Array.isArray(enumValues)) {
+        if (enumValues.length === 0)
+            return false;
+        return enumValues.every((v) => typeof v === "string" || typeof v === "number");
+    }
+    const type = s.type;
+    if (type === "string" || type === "number" || type === "integer")
+        return true;
+    if (Array.isArray(type)) {
+        return type.every((t) => t === "string" || t === "number" || t === "integer");
+    }
+    return false;
+}
+function getSubschemaAtDataPointer(schema, pointer) {
+    const root = (0, json_schema_library_1.compileSchema)(schema);
+    const { node, error } = root.getNode(pointer, undefined, {
+        withSchemaWarning: true,
+    });
+    if (error || !node)
+        return undefined;
+    return node.schema;
+}
+function assertDataPointersExistAndAreTokenable(name, schema, pointers) {
+    const root = (0, json_schema_library_1.compileSchema)(schema);
+    for (const pointer of pointers) {
+        const { node, error } = root.getNode(pointer, undefined, {
+            withSchemaWarning: true,
+        });
+        if (error || !node) {
+            throw new Error(`Invalid event subject param pointer '${pointer}' for event '${name}' (path not found in schema)`);
+        }
+        if (!isTokenableSchema(node.schema)) {
+            throw new Error(`Invalid event subject param pointer '${pointer}' for event '${name}' (must resolve to string/number schema)`);
+        }
+    }
+}

package/script/js/packages/trellis/npm/src/contracts.d.ts

@@ -0,0 +1,5 @@
+import "./_dnt.polyfills.js";
+export * from "./contract_support/mod.js";
+export { defineAppContract, defineCliContract, defineDeviceContract, definePortalContract, defineServiceContract, } from "./contract.js";
+export type { DefinedContract } from "./contract.js";
+//# sourceMappingURL=contracts.d.ts.map

package/script/js/packages/trellis/npm/src/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../../../../src/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAC7B,cAAc,2BAA2B,CAAC;AAC1C,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC"}

package/script/js/packages/trellis/npm/src/contracts.js

@@ -0,0 +1,25 @@
+"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 __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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineServiceContract = exports.definePortalContract = exports.defineDeviceContract = exports.defineCliContract = exports.defineAppContract = void 0;
+require("./_dnt.polyfills.js");
+__exportStar(require("./contract_support/mod.js"), exports);
+var contract_js_1 = require("./contract.js");
+Object.defineProperty(exports, "defineAppContract", { enumerable: true, get: function () { return contract_js_1.defineAppContract; } });
+Object.defineProperty(exports, "defineCliContract", { enumerable: true, get: function () { return contract_js_1.defineCliContract; } });
+Object.defineProperty(exports, "defineDeviceContract", { enumerable: true, get: function () { return contract_js_1.defineDeviceContract; } });
+Object.defineProperty(exports, "definePortalContract", { enumerable: true, get: function () { return contract_js_1.definePortalContract; } });
+Object.defineProperty(exports, "defineServiceContract", { enumerable: true, get: function () { return contract_js_1.defineServiceContract; } });

package/script/js/packages/trellis/npm/src/device.d.ts

@@ -0,0 +1,48 @@
+import { type NatsConnection } from "@nats-io/nats-core";
+import type { TrellisAPI } from "./contracts.js";
+import { ServiceHealth } from "./health.js";
+import { Trellis } from "./trellis.js";
+type DeviceContract<TApi extends TrellisAPI = TrellisAPI> = {
+    CONTRACT_ID: string;
+    CONTRACT_DIGEST: string;
+    CONTRACT?: {
+        displayName?: string;
+    };
+    API: {
+        trellis: TApi;
+    };
+};
+export type TrellisDeviceConnection<TApi extends TrellisAPI = TrellisAPI> = Trellis<TApi> & {
+    health: ServiceHealth;
+};
+type DeviceConnectTransport = {
+    connect(options: {
+        servers: string | string[];
+        token?: string;
+        authenticator?: unknown;
+        inboxPrefix?: string;
+    }): Promise<NatsConnection>;
+};
+type DeviceConnectDeps = {
+    loadTransport(): Promise<DeviceConnectTransport>;
+    now(): number;
+};
+export type DeviceActivationController = {
+    url: string;
+    waitForOnlineApproval(opts?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    acceptConfirmationCode(code: string): Promise<void>;
+};
+export type TrellisDeviceConnectArgs<TApi extends TrellisAPI = TrellisAPI> = {
+    trellisUrl: string;
+    contract: DeviceContract<TApi>;
+    rootSecret: Uint8Array | string;
+    onActivationRequired?(activation: DeviceActivationController): Promise<void>;
+};
+export declare function connectDeviceWithDeps<TApi extends TrellisAPI>(args: TrellisDeviceConnectArgs<TApi>, deps: DeviceConnectDeps): Promise<TrellisDeviceConnection<TApi>>;
+export declare const TrellisDevice: {
+    connect<TApi extends TrellisAPI>(args: TrellisDeviceConnectArgs<TApi>): Promise<TrellisDeviceConnection<TApi>>;
+};
+export {};
+//# sourceMappingURL=device.d.ts.map

package/script/js/packages/trellis/npm/src/device.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device.d.ts","sourceRoot":"","sources":["../../../../../../src/device.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwC,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAiB/F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGjD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,KAAK,cAAc,CAAC,IAAI,SAAS,UAAU,GAAG,UAAU,IAAI;IAC1D,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE;QACT,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC;IACF,GAAG,EAAE;QACH,OAAO,EAAE,IAAI,CAAC;KACf,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,uBAAuB,CAAC,IAAI,SAAS,UAAU,GAAG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG;IAC1F,MAAM,EAAE,aAAa,CAAC;CACvB,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,OAAO,CAAC,OAAO,EAAE;QACf,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;QAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CAC7B,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACvB,aAAa,IAAI,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACjD,GAAG,IAAI,MAAM,CAAC;CACf,CAAC;AAWF,MAAM,MAAM,0BAA0B,GAAG;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,qBAAqB,CAAC,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtE,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACrD,CAAC;AAEF,MAAM,MAAM,wBAAwB,CAAC,IAAI,SAAS,UAAU,GAAG,UAAU,IAAI;IAC3E,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC;IAC/B,UAAU,EAAE,UAAU,GAAG,MAAM,CAAC;IAChC,oBAAoB,CAAC,CAAC,UAAU,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9E,CAAC;AAsIF,wBAAsB,qBAAqB,CAAC,IAAI,SAAS,UAAU,EACjE,IAAI,EAAE,wBAAwB,CAAC,IAAI,CAAC,EACpC,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC,CAmLxC;AAED,eAAO,MAAM,aAAa;YAChB,IAAI,SAAS,UAAU,QACvB,wBAAwB,CAAC,IAAI,CAAC,GACnC,OAAO,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;CAG1C,CAAC"}

package/script/js/packages/trellis/npm/src/device.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrellisDevice = void 0;
+exports.connectDeviceWithDeps = connectDeviceWithDeps;
+const nats_core_1 = require("@nats-io/nats-core");
+const node_buffer_1 = require("node:buffer");
+const node_crypto_1 = require("node:crypto");
+const device_activation_js_1 = require("./auth/device_activation.js");
+const keys_js_1 = require("./auth/keys.js");
+const utils_js_1 = require("./auth/utils.js");
+const runtime_transport_js_1 = require("./runtime_transport.js");
+const runtime_transport_js_2 = require("./runtime_transport.js");
+const health_js_1 = require("./health.js");
+const trellis_js_1 = require("./trellis.js");
+const typebox_1 = require("typebox");
+const value_1 = require("typebox/value");
+const ClientTransportEndpointsSchema = typebox_1.Type.Object({
+    natsServers: typebox_1.Type.Array(typebox_1.Type.String({ minLength: 1 }), { minItems: 1 }),
+});
+const ClientTransportsSchema = typebox_1.Type.Object({
+    native: typebox_1.Type.Optional(ClientTransportEndpointsSchema),
+    websocket: typebox_1.Type.Optional(ClientTransportEndpointsSchema),
+});
+const DeviceBootstrapReadySchema = typebox_1.Type.Object({
+    status: typebox_1.Type.Literal("ready"),
+    connectInfo: typebox_1.Type.Object({
+        instanceId: typebox_1.Type.String({ minLength: 1 }),
+        profileId: typebox_1.Type.String({ minLength: 1 }),
+        contractId: typebox_1.Type.String({ minLength: 1 }),
+        contractDigest: typebox_1.Type.String({ minLength: 1 }),
+        transports: ClientTransportsSchema,
+        transport: typebox_1.Type.Object({
+            sentinel: typebox_1.Type.Object({
+                jwt: typebox_1.Type.String({ minLength: 1 }),
+                seed: typebox_1.Type.String({ minLength: 1 }),
+            }),
+        }),
+        auth: typebox_1.Type.Object({
+            mode: typebox_1.Type.Literal("device_identity"),
+            iatSkewSeconds: typebox_1.Type.Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const DeviceBootstrapActivationRequiredSchema = typebox_1.Type.Object({
+    status: typebox_1.Type.Literal("activation_required"),
+});
+const DeviceBootstrapNotReadySchema = typebox_1.Type.Object({
+    status: typebox_1.Type.Literal("not_ready"),
+    reason: typebox_1.Type.String({ minLength: 1 }),
+});
+function normalizeRootSecret(rootSecret) {
+    if (typeof rootSecret === "string") {
+        const decoded = (0, utils_js_1.base64urlDecode)(rootSecret.trim());
+        if (decoded.length === 0)
+            throw new Error("rootSecret must not be empty");
+        return decoded;
+    }
+    if (rootSecret.length === 0)
+        throw new Error("rootSecret must not be empty");
+    return rootSecret;
+}
+async function signIdentityBytes(identitySeed, data) {
+    const privateKey = await (0, keys_js_1.importEd25519PrivateKeyFromSeedBase64url)((0, utils_js_1.base64urlEncode)(identitySeed));
+    return new Uint8Array(await crypto.subtle.sign("Ed25519", privateKey, (0, utils_js_1.toArrayBuffer)(data)));
+}
+function createDeviceNatsAuthTokenAuthenticator(args) {
+    const reconnectKey = (0, node_crypto_1.createPrivateKey)({
+        key: node_buffer_1.Buffer.from((0, keys_js_1.pkcs8FromEd25519Seed)(args.identitySeed)),
+        format: "der",
+        type: "pkcs8",
+    });
+    return () => {
+        const iat = Math.floor(args.now() / 1_000);
+        const digest = (0, node_crypto_1.createHash)("sha256").update(`nats-connect:${iat}`, "utf8").digest();
+        const sig = (0, node_crypto_1.sign)(null, digest, reconnectKey);
+        return {
+            auth_token: JSON.stringify({
+                v: 1,
+                sessionKey: args.publicIdentityKey,
+                iat,
+                sig: (0, utils_js_1.base64urlEncode)(new Uint8Array(sig)),
+                contractDigest: args.contractDigest,
+            }),
+        };
+    };
+}
+const defaultDeps = {
+    loadTransport: runtime_transport_js_1.loadDefaultRuntimeTransport,
+    now: () => Date.now(),
+};
+function activationRequiredError() {
+    return new Error("Device activation required but no activation handler was provided");
+}
+function isConnectInfoUnavailable(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("404") || message.includes("unknown_device") || message.includes("activation_required");
+}
+async function fetchDeviceBootstrap(args) {
+    const request = await (0, device_activation_js_1.signDeviceWaitRequest)({
+        publicIdentityKey: args.publicIdentityKey,
+        nonce: "connect-info",
+        identitySeed: args.identitySeed,
+        contractDigest: args.contractDigest,
+        iat: args.iat,
+    });
+    const bootstrapRequest = {
+        publicIdentityKey: request.publicIdentityKey,
+        contractDigest: request.contractDigest,
+        iat: request.iat,
+        sig: request.sig,
+    };
+    const response = await fetch(new URL("/bootstrap/device", args.trellisUrl), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(bootstrapRequest),
+    });
+    if (!response.ok) {
+        throw new Error(`Device bootstrap failed: ${response.status} ${await response.text()}`);
+    }
+    const payload = await response.json();
+    if (value_1.Value.Check(DeviceBootstrapReadySchema, payload))
+        return payload;
+    if (value_1.Value.Check(DeviceBootstrapActivationRequiredSchema, payload))
+        return payload;
+    if (value_1.Value.Check(DeviceBootstrapNotReadySchema, payload))
+        return payload;
+    throw new Error("Device bootstrap returned an invalid response");
+}
+async function connectDeviceWithDeps(args, deps) {
+    const rootSecret = normalizeRootSecret(args.rootSecret);
+    const identity = await (0, device_activation_js_1.deriveDeviceIdentity)(rootSecret);
+    const contractDigest = args.contract.CONTRACT_DIGEST;
+    let connectInfo = null;
+    try {
+        const bootstrap = await fetchDeviceBootstrap({
+            trellisUrl: args.trellisUrl,
+            publicIdentityKey: identity.publicIdentityKey,
+            identitySeed: identity.identitySeed,
+            contractDigest,
+        });
+        if (bootstrap.status === "ready") {
+            connectInfo = bootstrap.connectInfo;
+        }
+        else if (bootstrap.status === "not_ready") {
+            throw new Error(bootstrap.reason);
+        }
+    }
+    catch (error) {
+        if (!isConnectInfoUnavailable(error))
+            throw error;
+    }
+    if (!connectInfo) {
+        if (!args.onActivationRequired)
+            throw activationRequiredError();
+        const nonce = crypto.randomUUID();
+        const payload = await (0, device_activation_js_1.buildDeviceActivationPayload)({
+            activationKey: identity.activationKey,
+            publicIdentityKey: identity.publicIdentityKey,
+            nonce,
+        });
+        const activationUrl = (await (0, device_activation_js_1.startDeviceActivationRequest)({
+            trellisUrl: args.trellisUrl,
+            payload,
+        })).activationUrl;
+        let activationCompleted = false;
+        let onlineConnectInfo = null;
+        await args.onActivationRequired({
+            url: activationUrl,
+            waitForOnlineApproval: async (opts) => {
+                if (activationCompleted)
+                    return;
+                const activation = await (0, device_activation_js_1.waitForDeviceActivation)({
+                    trellisUrl: args.trellisUrl,
+                    publicIdentityKey: identity.publicIdentityKey,
+                    nonce,
+                    identitySeed: identity.identitySeed,
+                    contractDigest,
+                    signal: opts?.signal,
+                });
+                onlineConnectInfo = activation.connectInfo;
+                activationCompleted = true;
+            },
+            acceptConfirmationCode: async (code) => {
+                if (activationCompleted)
+                    return;
+                const ok = await (0, device_activation_js_1.verifyDeviceConfirmationCode)({
+                    activationKey: identity.activationKey,
+                    publicIdentityKey: identity.publicIdentityKey,
+                    nonce,
+                    confirmationCode: code,
+                });
+                if (!ok) {
+                    throw new Error("Invalid device confirmation code");
+                }
+                activationCompleted = true;
+            },
+        });
+        if (!activationCompleted) {
+            throw new Error("Device activation did not complete");
+        }
+        if (onlineConnectInfo) {
+            connectInfo = onlineConnectInfo;
+        }
+        else {
+            const bootstrap = await fetchDeviceBootstrap({
+                trellisUrl: args.trellisUrl,
+                publicIdentityKey: identity.publicIdentityKey,
+                identitySeed: identity.identitySeed,
+                contractDigest,
+            });
+            if (bootstrap.status !== "ready") {
+                throw new Error(`Device bootstrap is not ready: ${bootstrap.status}`);
+            }
+            connectInfo = bootstrap.connectInfo;
+        }
+    }
+    if (!connectInfo) {
+        throw new Error("Device bootstrap did not return runtime connect info");
+    }
+    const transport = await deps.loadTransport();
+    const nc = await transport.connect({
+        servers: (0, runtime_transport_js_2.selectRuntimeTransportServers)(connectInfo.transports),
+        inboxPrefix: `_INBOX.${identity.publicIdentityKey.slice(0, 16)}`,
+        authenticator: [
+            createDeviceNatsAuthTokenAuthenticator({
+                publicIdentityKey: identity.publicIdentityKey,
+                identitySeed: identity.identitySeed,
+                contractDigest,
+                now: deps.now,
+            }),
+            (0, nats_core_1.jwtAuthenticator)(connectInfo.transport.sentinel.jwt, new TextEncoder().encode(connectInfo.transport.sentinel.seed)),
+        ],
+    });
+    const trellis = new trellis_js_1.Trellis(args.contract.CONTRACT_ID, nc, {
+        sessionKey: identity.publicIdentityKey,
+        sign: (data) => signIdentityBytes(identity.identitySeed, data),
+    }, {
+        api: args.contract.API.trellis,
+    });
+    const health = new health_js_1.ServiceHealth({
+        serviceName: args.contract.CONTRACT?.displayName ?? args.contract.CONTRACT_ID,
+        kind: "device",
+        instanceId: connectInfo.instanceId,
+        contractId: connectInfo.contractId,
+        contractDigest: connectInfo.contractDigest,
+        publishIntervalMs: 30_000,
+    });
+    health.setInfo({
+        info: {
+            profileId: connectInfo.profileId,
+        },
+    });
+    health.add("nats", () => ({
+        status: nc.isClosed() ? "failed" : "ok",
+        ...(nc.isClosed() ? { summary: "NATS connection closed" } : {}),
+    }));
+    const heartbeatEventEnabled = Boolean(args.contract.API.trellis.events?.["Health.Heartbeat"]);
+    let heartbeatTimer;
+    let publishingHeartbeat = false;
+    const stopHeartbeat = () => {
+        if (heartbeatTimer !== undefined) {
+            clearInterval(heartbeatTimer);
+            heartbeatTimer = undefined;
+        }
+    };
+    const publishHeartbeat = async () => {
+        if (!heartbeatEventEnabled || publishingHeartbeat) {
+            return;
+        }
+        publishingHeartbeat = true;
+        try {
+            const heartbeat = await health.heartbeat();
+            await trellis.publish("Health.Heartbeat", heartbeat);
+        }
+        finally {
+            publishingHeartbeat = false;
+        }
+    };
+    if (heartbeatEventEnabled) {
+        await publishHeartbeat();
+        heartbeatTimer = setInterval(() => {
+            void publishHeartbeat();
+        }, health.publishIntervalMs);
+        void nc.closed().finally(stopHeartbeat);
+    }
+    return Object.assign(trellis, { health });
+}
+exports.TrellisDevice = {
+    connect(args) {
+        return connectDeviceWithDeps(args, defaultDeps);
+    },
+};

package/script/js/packages/trellis/npm/src/env.d.ts

@@ -0,0 +1,2 @@
+export { getEnv } from "./telemetry/env.js";
+//# sourceMappingURL=env.d.ts.map

package/script/js/packages/trellis/npm/src/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../../../../src/env.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC"}

package/script/js/packages/trellis/npm/src/env.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnv = void 0;
+var env_js_1 = require("./telemetry/env.js");
+Object.defineProperty(exports, "getEnv", { enumerable: true, get: function () { return env_js_1.getEnv; } });

package/script/js/packages/trellis/npm/src/errors/AuthError.d.ts

@@ -0,0 +1,30 @@
+import Type, { type Static } from "typebox";
+import { TrellisError } from "./TrellisError.js";
+export declare const AuthErrorDataSchema: Type.TObject<{
+    id: Type.TString;
+    type: Type.TLiteral<"AuthError">;
+    message: Type.TString;
+    reason: Type.TUnion<[Type.TLiteral<"invalid_request">, Type.TLiteral<"missing_session_key">, Type.TLiteral<"missing_proof">, Type.TLiteral<"session_not_found">, Type.TLiteral<"session_expired">, Type.TLiteral<"invalid_signature">, Type.TLiteral<"user_not_found">, Type.TLiteral<"user_inactive">, Type.TLiteral<"unknown_device">, Type.TLiteral<"device_profile_not_found">, Type.TLiteral<"device_profile_disabled">, Type.TLiteral<"device_activation_revoked">, Type.TLiteral<"unknown_service">, Type.TLiteral<"service_disabled">, Type.TLiteral<"iat_out_of_range">, Type.TLiteral<"invalid_binding_token">, Type.TLiteral<"session_corrupted">, Type.TLiteral<"session_already_bound">, Type.TLiteral<"authtoken_already_used">, Type.TLiteral<"oauth_session_key_mismatch">, Type.TLiteral<"service_role_on_user">, Type.TLiteral<"reply_subject_mismatch">, Type.TLiteral<"insufficient_permissions">, Type.TLiteral<"forbidden">, Type.TLiteral<"missing_flow_id">, Type.TLiteral<"missing_profile_id">, Type.TLiteral<"device_activation_flow_not_found">, Type.TLiteral<"device_activation_flow_expired">, Type.TLiteral<"device_activation_rejected">, Type.TLiteral<"device_identity_key_mismatch">, Type.TLiteral<"invalid_device_qr_mac">]>;
+    context: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    traceId: Type.TOptional<Type.TString>;
+}>;
+export type AuthErrorData = Static<typeof AuthErrorDataSchema>;
+/**
+ * Error for authentication and authorization failures.
+ */
+export declare class AuthError extends TrellisError<AuthErrorData> {
+    readonly name: "AuthError";
+    readonly reason: AuthErrorData["reason"];
+    constructor(options: ErrorOptions & {
+        reason: AuthErrorData["reason"];
+        context?: Record<string, unknown>;
+        id?: string;
+    });
+    /**
+     * Serializes error to a plain object.
+     *
+     * @returns Plain object representation of the error
+     */
+    toSerializable(): AuthErrorData;
+}
+//# sourceMappingURL=AuthError.d.ts.map

package/script/js/packages/trellis/npm/src/errors/AuthError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthError.d.ts","sourceRoot":"","sources":["../../../../../../../src/errors/AuthError.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,eAAO,MAAM,mBAAmB;;;;;;;EAuC9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAE/D;;GAEG;AACH,qBAAa,SAAU,SAAQ,YAAY,CAAC,aAAa,CAAC;IACxD,SAAkB,IAAI,cAAwB;IAC9C,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;gBAGvC,OAAO,EAAE,YAAY,GAAG;QACtB,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;QAChC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAClC,EAAE,CAAC,EAAE,MAAM,CAAC;KACb;IAOH;;;;OAIG;IACM,cAAc,IAAI,aAAa;CAOzC"}

package/script/js/packages/trellis/npm/src/errors/AuthError.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthError = exports.AuthErrorDataSchema = void 0;
+const typebox_1 = __importDefault(require("typebox"));
+const TrellisError_js_1 = require("./TrellisError.js");
+exports.AuthErrorDataSchema = typebox_1.default.Object({
+    id: typebox_1.default.String(),
+    type: typebox_1.default.Literal("AuthError"),
+    message: typebox_1.default.String(),
+    reason: typebox_1.default.Union([
+        typebox_1.default.Literal("invalid_request"),
+        typebox_1.default.Literal("missing_session_key"),
+        typebox_1.default.Literal("missing_proof"),
+        typebox_1.default.Literal("session_not_found"),
+        typebox_1.default.Literal("session_expired"),
+        typebox_1.default.Literal("invalid_signature"),
+        typebox_1.default.Literal("user_not_found"),
+        typebox_1.default.Literal("user_inactive"),
+        typebox_1.default.Literal("unknown_device"),
+        typebox_1.default.Literal("device_profile_not_found"),
+        typebox_1.default.Literal("device_profile_disabled"),
+        typebox_1.default.Literal("device_activation_revoked"),
+        typebox_1.default.Literal("unknown_service"),
+        typebox_1.default.Literal("service_disabled"),
+        typebox_1.default.Literal("iat_out_of_range"),
+        typebox_1.default.Literal("invalid_binding_token"),
+        typebox_1.default.Literal("session_corrupted"),
+        typebox_1.default.Literal("session_already_bound"),
+        typebox_1.default.Literal("authtoken_already_used"),
+        typebox_1.default.Literal("oauth_session_key_mismatch"),
+        typebox_1.default.Literal("service_role_on_user"),
+        typebox_1.default.Literal("reply_subject_mismatch"),
+        typebox_1.default.Literal("insufficient_permissions"),
+        typebox_1.default.Literal("forbidden"),
+        typebox_1.default.Literal("missing_flow_id"),
+        typebox_1.default.Literal("missing_profile_id"),
+        typebox_1.default.Literal("device_activation_flow_not_found"),
+        typebox_1.default.Literal("device_activation_flow_expired"),
+        typebox_1.default.Literal("device_activation_rejected"),
+        typebox_1.default.Literal("device_identity_key_mismatch"),
+        typebox_1.default.Literal("invalid_device_qr_mac"),
+    ]),
+    context: typebox_1.default.Optional(typebox_1.default.Record(typebox_1.default.String(), typebox_1.default.Unknown())),
+    traceId: typebox_1.default.Optional(typebox_1.default.String()),
+});
+/**
+ * Error for authentication and authorization failures.
+ */
+class AuthError extends TrellisError_js_1.TrellisError {
+    constructor(options) {
+        const { reason, ...baseOptions } = options;
+        super(`Auth failed: ${reason}`, baseOptions);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "AuthError"
+        });
+        Object.defineProperty(this, "reason", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.reason = reason;
+    }
+    /**
+     * Serializes error to a plain object.
+     *
+     * @returns Plain object representation of the error
+     */
+    toSerializable() {
+        return {
+            ...this.baseSerializable(),
+            type: this.name,
+            reason: this.reason,
+        };
+    }
+}
+exports.AuthError = AuthError;

package/script/js/packages/trellis/npm/src/errors/KVError.d.ts

@@ -0,0 +1,31 @@
+import Type, { type Static } from "typebox";
+import { TrellisError } from "./TrellisError.js";
+export declare const KVErrorDataSchema: Type.TObject<{
+    id: Type.TString;
+    type: Type.TLiteral<"KVError">;
+    message: Type.TString;
+    operation: Type.TOptional<Type.TString>;
+    context: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    traceId: Type.TOptional<Type.TString>;
+}>;
+export type KVErrorData = Static<typeof KVErrorDataSchema>;
+/**
+ * Error for KV storage operations.
+ * Used when key-value store operations fail.
+ */
+export declare class KVError extends TrellisError<KVErrorData> {
+    readonly name: "KVError";
+    readonly operation?: string;
+    constructor(options: ErrorOptions & {
+        operation?: string;
+        context?: Record<string, unknown>;
+        id?: string;
+    });
+    /**
+     * Serializes error to a plain object.
+     *
+     * @returns Plain object representation of the error
+     */
+    toSerializable(): KVErrorData;
+}
+//# sourceMappingURL=KVError.d.ts.map

package/script/js/packages/trellis/npm/src/errors/KVError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KVError.d.ts","sourceRoot":"","sources":["../../../../../../../src/errors/KVError.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,EAAE,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,eAAO,MAAM,iBAAiB;;;;;;;EAO5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE3D;;;GAGG;AACH,qBAAa,OAAQ,SAAQ,YAAY,CAAC,WAAW,CAAC;IACpD,SAAkB,IAAI,YAAsB;IAC5C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;gBAG1B,OAAO,EAAE,YAAY,GAAG;QACtB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAClC,EAAE,CAAC,EAAE,MAAM,CAAC;KACb;IAQH;;;;OAIG;IACM,cAAc,IAAI,WAAW;CAOvC"}