@clioplaylists/clio 0.1.6 → 0.1.7

package/dist/.env

@@ -0,0 +1,7 @@
+NODE_ENV='development'
+CLIO_VERSION=v0.1.0
+CLIO_PORT=8000
+DID_PLC_URL='https://plc.directory'
+LOG_ENABLED=true
+LOG_DESTINATION=
+LEG_LEVEL=debug

package/dist/api/health.js

@@ -1,12 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRouter = void 0;
-const express_1 = __importDefault(require("express"));
-const createRouter = (ctx) => {
-    const router = express_1.default.Router();
+import express from 'express';
+export const createRouter = (ctx) => {
+    const router = express.Router();
     router.get('/', function (req, res) {
         res.type('text/plain');
         res.send(`
@@ -29,4 +23,3 @@ Most API routes are under /xrpc/
     });
     return router;
 };
-exports.createRouter = createRouter;

package/dist/api/index.js

@@ -1,43 +1,6 @@
-"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.health = void 0;
-exports.default = default_1;
 // import getSongs from './com/clioplaylists/alpha/feed/getSongs'
-exports.health = __importStar(require("./health"));
-function default_1(server, ctx) {
+export * as health from './health';
+export default function (server, ctx) {
     // getSongs(server, ctx)
     return server;
 }

package/dist/api/util.js

@@ -1,17 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resHeaders = exports.ATPROTO_REPO_REV = exports.ATPROTO_CONTENT_LABELERS = void 0;
-const util_1 = require("../util");
-exports.ATPROTO_CONTENT_LABELERS = 'Atproto-Content-Labelers';
-exports.ATPROTO_REPO_REV = 'Atproto-Repo-Rev';
-const resHeaders = (opts) => {
+import { formatLabelerHeader } from '../util';
+export const ATPROTO_CONTENT_LABELERS = 'Atproto-Content-Labelers';
+export const ATPROTO_REPO_REV = 'Atproto-Repo-Rev';
+export const resHeaders = (opts) => {
     const headers = {};
     if (opts.labelers) {
-        headers[exports.ATPROTO_CONTENT_LABELERS] = (0, util_1.formatLabelerHeader)(opts.labelers);
+        headers[ATPROTO_CONTENT_LABELERS] = formatLabelerHeader(opts.labelers);
     }
     if (opts.repoRev) {
-        headers[exports.ATPROTO_REPO_REV] = opts.repoRev;
+        headers[ATPROTO_REPO_REV] = opts.repoRev;
     }
     return headers;
 };
-exports.resHeaders = resHeaders;

package/dist/auth-verifier.js

@@ -1,181 +1,125 @@
-"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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifySignatureWithKey = exports.createPublicKeyObject = exports.buildBasicAuth = exports.parseBasicAuth = exports.AuthVerifier = exports.RoleStatus = void 0;
-const xrpc_server_1 = require("@atproto/xrpc-server");
-const jose = __importStar(require("jose"));
-const key_encoder_1 = __importDefault(require("key-encoder"));
-const node_crypto_1 = __importDefault(require("node:crypto"));
-const ui8 = __importStar(require("uint8arrays"));
+import { AuthRequiredError, cryptoVerifySignatureWithKey, } from '@atproto/xrpc-server';
+import * as jose from 'jose';
+import KeyEncoder from 'key-encoder';
+import crypto from 'node:crypto';
+import * as ui8 from 'uint8arrays';
 // import { GetIdentityByDidResponse } from './proto/bsky_pb'
-const crypto_1 = require("@atproto/crypto");
-var RoleStatus;
+import { parseDidKey, SECP256K1_JWT_ALG } from '@atproto/crypto';
+export var RoleStatus;
 (function (RoleStatus) {
     RoleStatus[RoleStatus["Valid"] = 0] = "Valid";
     RoleStatus[RoleStatus["Invalid"] = 1] = "Invalid";
     RoleStatus[RoleStatus["Missing"] = 2] = "Missing";
-})(RoleStatus || (exports.RoleStatus = RoleStatus = {}));
+})(RoleStatus || (RoleStatus = {}));
 const ALLOWED_AUTH_SCOPES = new Set([
     'com.atproto.access',
     'com.atproto.appPass',
     'com.atproto.appPassPrivileged',
 ]);
-class AuthVerifier {
+export class AuthVerifier {
+    dataplane;
+    ownDid;
+    standardAudienceDids;
+    modServiceDid;
+    adminPasses;
+    entrywayJwtPublicKey;
     constructor(dataplane, opts) {
-        Object.defineProperty(this, "dataplane", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: dataplane
-        });
-        Object.defineProperty(this, "ownDid", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "standardAudienceDids", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "modServiceDid", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "adminPasses", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "entrywayJwtPublicKey", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        // verifiers (arrow fns to preserve scope)
-        Object.defineProperty(this, "standardOptionalParameterized", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (opts) => async (ctx) => {
-                // @TODO remove! basic auth + did supported just for testing.
-                if (isBasicToken(ctx.req)) {
-                    const aud = this.ownDid;
-                    const iss = ctx.req.headers['appview-as-did'];
-                    if (typeof iss !== 'string' || !iss.startsWith('did:')) {
-                        throw new xrpc_server_1.AuthRequiredError('bad issuer');
-                    }
-                    if (!this.parseRoleCreds(ctx.req).admin) {
-                        throw new xrpc_server_1.AuthRequiredError('bad credentials');
-                    }
-                    return {
-                        credentials: { type: 'standard', iss, aud },
-                    };
-                }
-                else if (isBearerToken(ctx.req)) {
-                    // @NOTE temporarily accept entryway session tokens to shed load from PDS instances
-                    const token = bearerTokenFromReq(ctx.req);
-                    const header = token ? jose.decodeProtectedHeader(token) : undefined;
-                    if (header?.typ === 'at+jwt') {
-                        // we should never use entryway session tokens in the case of flexible auth audiences (namely in the case of getFeed)
-                        if (opts.skipAudCheck) {
-                            throw new xrpc_server_1.AuthRequiredError('Malformed token', 'InvalidToken');
-                        }
-                        return this.entrywaySession(ctx);
-                    }
-                    // const { iss, aud } = await this.verifyServiceJwt(ctx, {
-                    //   lxmCheck: opts.lxmCheck,
-                    //   iss: null,
-                    //   aud: null,
-                    // })
-                    const { aud } = {
-                        // iss: '',
-                        aud: '',
-                    };
-                    if (!opts.skipAudCheck && !this.standardAudienceDids.has(aud)) {
-                        throw new xrpc_server_1.AuthRequiredError('jwt audience does not match service did', 'BadJwtAudience');
-                    }
-                    return {
-                        credentials: {
-                            type: 'standard',
-                            iss: '',
-                            aud: '',
-                        },
-                    };
-                }
-                else {
-                    return this.nullCreds();
-                }
+        this.dataplane = dataplane;
+        this.ownDid = opts.ownDid;
+        this.standardAudienceDids = new Set([
+            opts.ownDid,
+            ...opts.alternateAudienceDids,
+        ]);
+        this.modServiceDid = opts.modServiceDid;
+        this.adminPasses = new Set(opts.adminPasses);
+        this.entrywayJwtPublicKey = opts.entrywayJwtPublicKey;
+    }
+    // verifiers (arrow fns to preserve scope)
+    standardOptionalParameterized = (opts) => async (ctx) => {
+        // @TODO remove! basic auth + did supported just for testing.
+        if (isBasicToken(ctx.req)) {
+            const aud = this.ownDid;
+            const iss = ctx.req.headers['appview-as-did'];
+            if (typeof iss !== 'string' || !iss.startsWith('did:')) {
+                throw new AuthRequiredError('bad issuer');
             }
-        });
-        Object.defineProperty(this, "standardOptional", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.standardOptionalParameterized({})
-        });
-        Object.defineProperty(this, "standard", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: async (ctx) => {
-                const output = await this.standardOptional(ctx);
-                if (output.credentials.type === 'none') {
-                    throw new xrpc_server_1.AuthRequiredError(undefined, 'AuthMissing');
-                }
-                return output;
+            if (!this.parseRoleCreds(ctx.req).admin) {
+                throw new AuthRequiredError('bad credentials');
             }
-        });
-        Object.defineProperty(this, "role", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (ctx) => {
-                const creds = this.parseRoleCreds(ctx.req);
-                if (creds.status !== RoleStatus.Valid) {
-                    throw new xrpc_server_1.AuthRequiredError();
+            return {
+                credentials: { type: 'standard', iss, aud },
+            };
+        }
+        else if (isBearerToken(ctx.req)) {
+            // @NOTE temporarily accept entryway session tokens to shed load from PDS instances
+            const token = bearerTokenFromReq(ctx.req);
+            const header = token ? jose.decodeProtectedHeader(token) : undefined;
+            if (header?.typ === 'at+jwt') {
+                // we should never use entryway session tokens in the case of flexible auth audiences (namely in the case of getFeed)
+                if (opts.skipAudCheck) {
+                    throw new AuthRequiredError('Malformed token', 'InvalidToken');
                 }
+                return this.entrywaySession(ctx);
+            }
+            // const { iss, aud } = await this.verifyServiceJwt(ctx, {
+            //   lxmCheck: opts.lxmCheck,
+            //   iss: null,
+            //   aud: null,
+            // })
+            const { aud } = {
+                // iss: '',
+                aud: '',
+            };
+            if (!opts.skipAudCheck && !this.standardAudienceDids.has(aud)) {
+                throw new AuthRequiredError('jwt audience does not match service did', 'BadJwtAudience');
+            }
+            return {
+                credentials: {
+                    type: 'standard',
+                    iss: '',
+                    aud: '',
+                },
+            };
+        }
+        else {
+            return this.nullCreds();
+        }
+    };
+    standardOptional = this.standardOptionalParameterized({});
+    standard = async (ctx) => {
+        const output = await this.standardOptional(ctx);
+        if (output.credentials.type === 'none') {
+            throw new AuthRequiredError(undefined, 'AuthMissing');
+        }
+        return output;
+    };
+    role = (ctx) => {
+        const creds = this.parseRoleCreds(ctx.req);
+        if (creds.status !== RoleStatus.Valid) {
+            throw new AuthRequiredError();
+        }
+        return {
+            credentials: {
+                ...creds,
+                type: 'role',
+            },
+        };
+    };
+    standardOrRole = async (ctx) => {
+        if (isBearerToken(ctx.req)) {
+            return this.standard(ctx);
+        }
+        else {
+            return this.role(ctx);
+        }
+    };
+    optionalStandardOrRole = async (ctx) => {
+        if (isBearerToken(ctx.req)) {
+            return await this.standard(ctx);
+        }
+        else {
+            const creds = this.parseRoleCreds(ctx.req);
+            if (creds.status === RoleStatus.Valid) {
                 return {
                     credentials: {
                         ...creds,
@@ -183,101 +127,54 @@ class AuthVerifier {
                     },
                 };
             }
-        });
-        Object.defineProperty(this, "standardOrRole", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: async (ctx) => {
-                if (isBearerToken(ctx.req)) {
-                    return this.standard(ctx);
-                }
-                else {
-                    return this.role(ctx);
-                }
+            else if (creds.status === RoleStatus.Missing) {
+                return this.nullCreds();
             }
-        });
-        Object.defineProperty(this, "optionalStandardOrRole", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: async (ctx) => {
-                if (isBearerToken(ctx.req)) {
-                    return await this.standard(ctx);
-                }
-                else {
-                    const creds = this.parseRoleCreds(ctx.req);
-                    if (creds.status === RoleStatus.Valid) {
-                        return {
-                            credentials: {
-                                ...creds,
-                                type: 'role',
-                            },
-                        };
-                    }
-                    else if (creds.status === RoleStatus.Missing) {
-                        return this.nullCreds();
-                    }
-                    else {
-                        throw new xrpc_server_1.AuthRequiredError();
-                    }
-                }
+            else {
+                throw new AuthRequiredError();
             }
-        });
-        // @NOTE this auth verifier method is not recommended to be implemented by most appviews
-        // this is a short term fix to remove proxy load from Bluesky's PDS and in line with possible
-        // future plans to have the client talk directly with the appview
-        Object.defineProperty(this, "entrywaySession", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: async (reqCtx) => {
-                const token = bearerTokenFromReq(reqCtx.req);
-                if (!token) {
-                    throw new xrpc_server_1.AuthRequiredError(undefined, 'AuthMissing');
-                }
-                // if entryway jwt key not configured then do not parsed these tokens
-                if (!this.entrywayJwtPublicKey) {
-                    throw new xrpc_server_1.AuthRequiredError('Malformed token', 'InvalidToken');
-                }
-                const res = await jose
-                    .jwtVerify(token, this.entrywayJwtPublicKey)
-                    .catch((err) => {
-                    if (err?.['code'] === 'ERR_JWT_EXPIRED') {
-                        throw new xrpc_server_1.AuthRequiredError('Token has expired', 'ExpiredToken');
-                    }
-                    throw new xrpc_server_1.AuthRequiredError('Token could not be verified', 'InvalidToken');
-                });
-                const { sub, aud, scope } = res.payload;
-                if (typeof sub !== 'string' || !sub.startsWith('did:')) {
-                    throw new xrpc_server_1.AuthRequiredError('Malformed token', 'InvalidToken');
-                }
-                else if (typeof aud !== 'string' ||
-                    !aud.startsWith('did:web:') ||
-                    !aud.endsWith('.bsky.network')) {
-                    throw new xrpc_server_1.AuthRequiredError('Bad token aud', 'InvalidToken');
-                }
-                else if (typeof scope !== 'string' || !ALLOWED_AUTH_SCOPES.has(scope)) {
-                    throw new xrpc_server_1.AuthRequiredError('Bad token scope', 'InvalidToken');
-                }
-                return {
-                    credentials: {
-                        type: 'standard',
-                        aud: this.ownDid,
-                        iss: sub,
-                    },
-                };
+        }
+    };
+    // @NOTE this auth verifier method is not recommended to be implemented by most appviews
+    // this is a short term fix to remove proxy load from Bluesky's PDS and in line with possible
+    // future plans to have the client talk directly with the appview
+    entrywaySession = async (reqCtx) => {
+        const token = bearerTokenFromReq(reqCtx.req);
+        if (!token) {
+            throw new AuthRequiredError(undefined, 'AuthMissing');
+        }
+        // if entryway jwt key not configured then do not parsed these tokens
+        if (!this.entrywayJwtPublicKey) {
+            throw new AuthRequiredError('Malformed token', 'InvalidToken');
+        }
+        const res = await jose
+            .jwtVerify(token, this.entrywayJwtPublicKey)
+            .catch((err) => {
+            if (err?.['code'] === 'ERR_JWT_EXPIRED') {
+                throw new AuthRequiredError('Token has expired', 'ExpiredToken');
             }
+            throw new AuthRequiredError('Token could not be verified', 'InvalidToken');
         });
-        this.ownDid = opts.ownDid;
-        this.standardAudienceDids = new Set([
-            opts.ownDid,
-            ...opts.alternateAudienceDids,
-        ]);
-        this.modServiceDid = opts.modServiceDid;
-        this.adminPasses = new Set(opts.adminPasses);
-        this.entrywayJwtPublicKey = opts.entrywayJwtPublicKey;
-    }
+        const { sub, aud, scope } = res.payload;
+        if (typeof sub !== 'string' || !sub.startsWith('did:')) {
+            throw new AuthRequiredError('Malformed token', 'InvalidToken');
+        }
+        else if (typeof aud !== 'string' ||
+            !aud.startsWith('did:web:') ||
+            !aud.endsWith('.bsky.network')) {
+            throw new AuthRequiredError('Bad token aud', 'InvalidToken');
+        }
+        else if (typeof scope !== 'string' || !ALLOWED_AUTH_SCOPES.has(scope)) {
+            throw new AuthRequiredError('Bad token scope', 'InvalidToken');
+        }
+        return {
+            credentials: {
+                type: 'standard',
+                aud: this.ownDid,
+                iss: sub,
+            },
+        };
+    };
     // modService = async (reqCtx: ReqCtx): Promise<ModServiceOutput> => {
     //   const { iss, aud } = await this.verifyServiceJwt(reqCtx, {
     //     aud: this.ownDid,
@@ -295,7 +192,7 @@ class AuthVerifier {
     //   }
     // }
     parseRoleCreds(req) {
-        const parsed = (0, exports.parseBasicAuth)(req.headers.authorization || '');
+        const parsed = parseBasicAuth(req.headers.authorization || '');
         const { Missing, Valid, Invalid } = RoleStatus;
         if (!parsed) {
             return { status: Missing, admin: false, moderator: false, triage: false };
@@ -406,7 +303,6 @@ class AuthVerifier {
         };
     }
 }
-exports.AuthVerifier = AuthVerifier;
 // HELPERS
 // ---------
 const BEARER = 'Bearer ';
@@ -423,7 +319,7 @@ const bearerTokenFromReq = (req) => {
         return null;
     return header.slice(BEARER.length).trim();
 };
-const parseBasicAuth = (token) => {
+export const parseBasicAuth = (token) => {
     if (!token.startsWith(BASIC))
         return null;
     const b64 = token.slice(BASIC.length);
@@ -439,35 +335,31 @@ const parseBasicAuth = (token) => {
         return null;
     return { username, password };
 };
-exports.parseBasicAuth = parseBasicAuth;
-const buildBasicAuth = (username, password) => {
+export const buildBasicAuth = (username, password) => {
     return (BASIC +
         ui8.toString(ui8.fromString(`${username}:${password}`, 'utf8'), 'base64pad'));
 };
-exports.buildBasicAuth = buildBasicAuth;
-const keyEncoder = new key_encoder_1.default('secp256k1');
-const createPublicKeyObject = (publicKeyHex) => {
+const keyEncoder = new KeyEncoder('secp256k1');
+export const createPublicKeyObject = (publicKeyHex) => {
     const key = keyEncoder.encodePublic(publicKeyHex, 'raw', 'pem');
-    return node_crypto_1.default.createPublicKey({ format: 'pem', key });
+    return crypto.createPublicKey({ format: 'pem', key });
 };
-exports.createPublicKeyObject = createPublicKeyObject;
 const verifySig = (publicKey, data, sig) => {
-    const keyEncoder = new key_encoder_1.default('secp256k1');
+    const keyEncoder = new KeyEncoder('secp256k1');
     const pemKey = keyEncoder.encodePublic(ui8.toString(publicKey, 'hex'), 'raw', 'pem');
-    const key = node_crypto_1.default.createPublicKey({ format: 'pem', key: pemKey });
-    return node_crypto_1.default.verify('sha256', data, {
+    const key = crypto.createPublicKey({ format: 'pem', key: pemKey });
+    return crypto.verify('sha256', data, {
         key,
         dsaEncoding: 'ieee-p1363',
     }, sig);
 };
-const verifySignatureWithKey = async (didKey, msgBytes, sigBytes, alg) => {
-    if (alg === crypto_1.SECP256K1_JWT_ALG) {
-        const parsed = (0, crypto_1.parseDidKey)(didKey);
+export const verifySignatureWithKey = async (didKey, msgBytes, sigBytes, alg) => {
+    if (alg === SECP256K1_JWT_ALG) {
+        const parsed = parseDidKey(didKey);
         if (alg !== parsed.jwtAlg) {
             throw new Error(`Expected key alg ${alg}, got ${parsed.jwtAlg}`);
         }
         return verifySig(parsed.keyBytes, msgBytes, sigBytes);
     }
-    return (0, xrpc_server_1.cryptoVerifySignatureWithKey)(didKey, msgBytes, sigBytes, alg);
+    return cryptoVerifySignatureWithKey(didKey, msgBytes, sigBytes, alg);
 };
-exports.verifySignatureWithKey = verifySignatureWithKey;

package/dist/client.js

@@ -1,25 +1,18 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBaseClient = void 0;
-const connect_1 = require("@connectrpc/connect");
-const connect_node_1 = require("@connectrpc/connect-node");
-const node_assert_1 = __importDefault(require("node:assert"));
-const clio_connect_1 = require("./rpc/clio_connect");
-const createBaseClient = (baseUrl, opts) => {
+import { createClient } from '@connectrpc/connect';
+import { createGrpcTransport } from '@connectrpc/connect-node';
+import assert from 'node:assert';
+import { ClioService } from './rpc/clio_connect';
+export const createBaseClient = (baseUrl, opts) => {
     const { httpVersion = '2', rejectUnauthorized = true } = opts;
-    const transport = (0, connect_node_1.createGrpcTransport)({
+    const transport = createGrpcTransport({
         baseUrl,
         acceptCompression: [],
         httpVersion,
         nodeOptions: { rejectUnauthorized },
     });
-    (0, node_assert_1.default)(validateUrl(baseUrl));
-    return (0, connect_1.createClient)(clio_connect_1.ClioService, transport);
+    assert(validateUrl(baseUrl));
+    return createClient(ClioService, transport);
 };
-exports.createBaseClient = createBaseClient;
 const validateUrl = (urlStr) => {
     let url;
     try {