@opentdf/ctl 0.1.0-beta.1701

package/README.md

@@ -0,0 +1,34 @@
+# OpenTDF command line tool (for node)
+
+A sample application using node & ESM to import and test a project
+
+## Usage
+
+```sh
+opentdf.mjs <auth options> <policy options> [encrypt|decrypt] [input file]
+```
+
+Sample round trip execution:
+
+```sh
+echo hello-world >sample.txt
+bin/opentdf.mjs encrypt \
+  --kasEndpoint http://localhost:65432/api/kas \
+  --oidcEndpoint http://localhost:65432/auth/realms/tdf \
+  --auth tdf-client:123-456 \
+  --containerType tdf3 \
+  --output sample.tdf \
+  sample.txt
+bin/opentdf.mjs \
+  --kasEndpoint http://localhost:65432/api/kas \
+  --oidcEndpoint http://localhost:65432/auth/realms/tdf \
+  --auth tdf-client:123-456 \
+  --containerType tdf3 \
+  --userId alice@somewhere.there \
+  decrypt sample.tdf
+```
+
+### References
+
+- [yargs](http://yargs.js.org)
+- [typescript CLI starter](https://github.com/khalidx/typescript-cli-starter)

package/bin/opentdf.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+// To debug, add `--inspect-brk` to the above line and open chrome://inspect
+
+import '../dist/src/cli.js';

package/dist/src/cli.js

@@ -0,0 +1,511 @@
+import './polyfills.js';
+import { createWriteStream, openAsBlob } from 'node:fs';
+import { readFile, stat, writeFile } from 'node:fs/promises';
+import { Writable } from 'node:stream';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { AuthProviders, NanoTDFClient, NanoTDFDatasetClient, TDF3Client, version, EncryptParamsBuilder, DecryptParamsBuilder, } from '@opentdf/sdk';
+import { CLIError, log } from './logger.js';
+import * as assertions from '@opentdf/sdk/assertions';
+import { attributeFQNsAsValues } from '@opentdf/sdk/nano';
+import { base64 } from '@opentdf/sdk/encodings';
+const bindingTypes = ['ecdsa', 'gmac'];
+const containerTypes = ['tdf3', 'nano', 'dataset', 'ztdf'];
+const parseJwt = (jwt, field = 1) => {
+    return JSON.parse(base64.decode(jwt.split('.')[field]));
+};
+const parseJwtComplete = (jwt) => {
+    return { header: parseJwt(jwt, 0), payload: parseJwt(jwt) };
+};
+async function processAuth({ auth, clientId, clientSecret, oidcEndpoint, userId, }) {
+    log('DEBUG', 'Processing auth params');
+    if (auth) {
+        log('DEBUG', 'Processing an auth string');
+        const authParts = auth.split(':');
+        if (authParts.length !== 2) {
+            throw new CLIError('CRITICAL', `Auth expects <clientId>:<clientSecret>, received ${auth}`);
+        }
+        [clientId, clientSecret] = authParts;
+    }
+    else if (!clientId || !clientSecret) {
+        throw new CLIError('CRITICAL', 'Auth expects clientId and clientSecret, or combined auth param');
+    }
+    const actual = await AuthProviders.clientSecretAuthProvider({
+        clientId,
+        oidcOrigin: oidcEndpoint,
+        exchange: 'client',
+        clientSecret,
+    });
+    const requestLog = [];
+    return {
+        requestLog,
+        updateClientPublicKey: async (signingKey) => {
+            actual.updateClientPublicKey(signingKey);
+            log('DEBUG', `updateClientPublicKey: [${signingKey?.publicKey}]`);
+        },
+        withCreds: async (httpReq) => {
+            const credible = await actual.withCreds(httpReq);
+            if (userId) {
+                const url = new URL(credible.url);
+                url.searchParams.set('userId', userId);
+                credible.url = url.href;
+            }
+            log('DEBUG', `HTTP Requesting: ${JSON.stringify(credible)}`);
+            requestLog.push(credible);
+            return credible;
+        },
+    };
+}
+const rstrip = (str, suffix = ' ') => {
+    while (str && suffix && str.endsWith(suffix)) {
+        str = str.slice(0, -suffix.length);
+    }
+    return str;
+};
+function addParams(client, argv) {
+    if (argv.attributes?.length) {
+        client.dataAttributes = argv.attributes.split(',');
+    }
+    if (argv.usersWithAccess?.length) {
+        client.dissems = argv.usersWithAccess.split(',');
+    }
+    log('SILLY', `Built encrypt params dissems: ${client.dissems}, attrs: ${client.dataAttributes}`);
+}
+async function tdf3DecryptParamsFor(argv) {
+    const c = new DecryptParamsBuilder();
+    if (argv.noVerifyAssertions) {
+        c.withNoVerifyAssertions(true);
+    }
+    c.setFileSource(await openAsBlob(argv.file));
+    return c.build();
+}
+function parseAssertionConfig(s) {
+    const u = JSON.parse(s);
+    // if u is null or empty, return an empty array
+    if (!u) {
+        return [];
+    }
+    const a = Array.isArray(u) ? u : [u];
+    for (const assertion of a) {
+        if (!assertions.isAssertionConfig(assertion)) {
+            throw new CLIError('CRITICAL', `invalid assertion config ${JSON.stringify(assertion)}`);
+        }
+    }
+    return a;
+}
+async function tdf3EncryptParamsFor(argv) {
+    const c = new EncryptParamsBuilder();
+    if (argv.assertions?.length) {
+        c.withAssertions(parseAssertionConfig(argv.assertions));
+    }
+    if (argv.attributes?.length) {
+        c.setAttributes(argv.attributes.split(','));
+    }
+    if (argv.usersWithAccess?.length) {
+        c.setUsersWithAccess(argv.usersWithAccess.split(','));
+    }
+    if (argv.mimeType?.length) {
+        c.setMimeType(argv.mimeType);
+    }
+    if (argv.autoconfigure) {
+        c.withAutoconfigure();
+    }
+    // use offline mode, we do not have upsert for v2
+    c.setOffline();
+    // FIXME TODO must call file.close() after we are done
+    const buffer = await processDataIn(argv.file);
+    c.setBufferSource(buffer);
+    return c.build();
+}
+async function processDataIn(file) {
+    if (!file) {
+        throw new CLIError('CRITICAL', 'Must specify file or pipe');
+    }
+    try {
+        const stats = await stat(file);
+        if (!stats?.isFile()) {
+            throw new CLIError('CRITICAL', `File does not exist [${file}]`);
+        }
+    }
+    catch (e) {
+        throw new CLIError('CRITICAL', `File is not accessable [${file}]`);
+    }
+    log('DEBUG', `Using input from file [${file}]`);
+    return readFile(file);
+}
+export const handleArgs = (args) => {
+    return (yargs(args)
+        .middleware((argv) => {
+        if (argv.silent) {
+            log.level = 'CRITICAL';
+        }
+        else if (argv.logLevel) {
+            const ll = argv.logLevel;
+            log.level = ll.toUpperCase();
+        }
+    })
+        .fail((msg, err, yargs) => {
+        if (err instanceof CLIError) {
+            log(err);
+            process.exit(1);
+        }
+        else if (err) {
+            log(err);
+            process.exit(2);
+        }
+        else {
+            console.error(`${msg}\n\n${yargs.help()}`);
+            process.exit(1);
+        }
+    })
+        // AUTH OPTIONS
+        .option('kasEndpoint', {
+        demandOption: true,
+        group: 'Server Endpoints:',
+        type: 'string',
+        description: 'URL to non-default KAS instance (https://mykas.net)',
+    })
+        .option('oidcEndpoint', {
+        demandOption: true,
+        group: 'Server Endpoints:',
+        type: 'string',
+        description: 'URL to non-default OIDC IdP (https://myidp.net)',
+    })
+        .option('policyEndpoint', {
+        group: 'Server Endpoints:',
+        type: 'string',
+        description: 'Attribute and key grant service endpoint',
+    })
+        .option('allowList', {
+        group: 'Security:',
+        desc: 'allowed KAS origins, comma separated; defaults to [kasEndpoint]',
+        type: 'string',
+        validate: (uris) => uris.split(','),
+    })
+        .option('ignoreAllowList', {
+        group: 'Security:',
+        desc: 'disable KAS allowlist feature for decrypt',
+        type: 'boolean',
+    })
+        .option('noVerifyAssertions', {
+        alias: 'no-verify-assertions',
+        group: 'Security',
+        desc: 'Do not verify assertions',
+        type: 'boolean',
+    })
+        .option('auth', {
+        group: 'OAuth and OIDC:',
+        type: 'string',
+        description: 'Combined OAuth Client Credentials (<clientId>:<clientSecret>)',
+    })
+        .option('dpop', {
+        group: 'Security:',
+        desc: 'Use DPoP for token binding',
+        type: 'boolean',
+    })
+        .implies('auth', '--no-clientId')
+        .implies('auth', '--no-clientSecret')
+        .option('clientId', {
+        group: 'OAuth and OIDC:',
+        alias: 'cid',
+        type: 'string',
+        description: 'OAuth Client Credentials: IdP-issued Client ID',
+    })
+        .implies('clientId', 'clientSecret')
+        .option('clientSecret', {
+        group: 'OAuth and OIDC:',
+        alias: 'cs',
+        type: 'string',
+        description: 'OAuth Client Credentials: IdP-issued Client Secret',
+    })
+        .implies('clientSecret', 'clientId')
+        .option('exchangeToken', {
+        group: 'OAuth and OIDC:',
+        alias: 'et',
+        type: 'string',
+        description: 'OAuth Token Exchange: Token issued by trusted external IdP',
+    })
+        .implies('exchangeToken', 'clientId')
+        // Examples
+        .example('$0 --auth ClientID123:Cli3nt$ecret', '# OIDC client credentials')
+        .example('$0 --clientId ClientID123 --clientSecret Cli3nt$ecret', '# OIDC client credentials')
+        // Policy, encryption, and container options
+        .options({
+        assertions: {
+            group: 'Encrypt Options:',
+            desc: 'ZTDF assertion config objects',
+            type: 'string',
+            default: '',
+            validate: parseAssertionConfig,
+        },
+        attributes: {
+            group: 'Encrypt Options:',
+            desc: 'Data attributes for the policy',
+            type: 'string',
+            default: '',
+            validate: (attributes) => attributes.split(','),
+        },
+        autoconfigure: {
+            group: 'Encrypt Options:',
+            desc: 'Enable automatic configuration from attributes using policy service',
+            type: 'boolean',
+            default: false,
+        },
+        containerType: {
+            group: 'Encrypt Options:',
+            alias: 't',
+            choices: containerTypes,
+            description: 'Container format',
+            default: 'nano',
+        },
+        policyBinding: {
+            group: 'Encrypt Options:',
+            choices: bindingTypes,
+            description: 'Policy Binding Type (nano only)',
+            default: 'gmac',
+        },
+        mimeType: {
+            group: 'Encrypt Options:',
+            desc: 'Mime type for the plain text file (only supported for ztdf)',
+            type: 'string',
+            default: '',
+        },
+        userId: {
+            group: 'Encrypt Options:',
+            type: 'string',
+            description: 'Owner email address',
+        },
+        usersWithAccess: {
+            alias: 'users-with-access',
+            group: 'Encrypt Options:',
+            desc: 'Add users to the policy',
+            type: 'string',
+            default: '',
+            validate: (users) => users.split(','),
+        },
+    })
+        // COMMANDS
+        .options({
+        logLevel: {
+            group: 'Verbosity:',
+            alias: 'log-level',
+            type: 'string',
+            default: 'info',
+            desc: 'Set logging level',
+        },
+        silent: {
+            group: 'Verbosity:',
+            type: 'boolean',
+            default: false,
+            desc: 'Disable logging',
+        },
+    })
+        .option('output', {
+        type: 'string',
+        description: 'output file',
+    })
+        .command('attrs', 'Look up defintions of attributes', (yargs) => {
+        yargs.strict();
+    }, async (argv) => {
+        log('DEBUG', 'attribute value lookup');
+        const authProvider = await processAuth(argv);
+        const signingKey = await crypto.subtle.generateKey({
+            name: 'RSASSA-PKCS1-v1_5',
+            hash: 'SHA-256',
+            modulusLength: 2048,
+            publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+        }, true, ['sign', 'verify']);
+        authProvider.updateClientPublicKey(signingKey);
+        log('DEBUG', `Initialized auth provider ${JSON.stringify(authProvider)}`);
+        const policyUrl = guessPolicyUrl(argv);
+        const defs = await attributeFQNsAsValues(policyUrl, authProvider, ...argv.attributes.split(','));
+        console.log(JSON.stringify(defs, null, 2));
+    })
+        .command('decrypt [file]', 'Decrypt TDF to string', 
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    (yargs) => {
+        yargs.strict().positional('file', {
+            describe: 'path to plain text file',
+            type: 'string',
+        });
+    }, async (argv) => {
+        log('DEBUG', 'Running decrypt command');
+        const allowedKases = argv.allowList?.split(',');
+        const ignoreAllowList = !!argv.ignoreAllowList;
+        const authProvider = await processAuth(argv);
+        log('DEBUG', `Initialized auth provider ${JSON.stringify(authProvider)}`);
+        const kasEndpoint = argv.kasEndpoint;
+        if (argv.containerType === 'tdf3' || argv.containerType == 'ztdf') {
+            log('DEBUG', `TDF3 Client`);
+            const client = new TDF3Client({
+                allowedKases,
+                ignoreAllowList,
+                authProvider,
+                kasEndpoint,
+                dpopEnabled: argv.dpop,
+            });
+            log('SILLY', `Initialized client ${JSON.stringify(client)}`);
+            log('DEBUG', `About to decrypt [${argv.file}]`);
+            const ct = await client.decrypt(await tdf3DecryptParamsFor(argv));
+            if (argv.output) {
+                const destination = createWriteStream(argv.output);
+                await ct.stream.pipeTo(Writable.toWeb(destination));
+            }
+            else {
+                console.log(await ct.toString());
+            }
+        }
+        else {
+            const dpopEnabled = !!argv.dpop;
+            const client = argv.containerType === 'nano'
+                ? new NanoTDFClient({
+                    allowedKases,
+                    ignoreAllowList,
+                    authProvider,
+                    kasEndpoint,
+                    dpopEnabled,
+                })
+                : new NanoTDFDatasetClient({
+                    allowedKases,
+                    ignoreAllowList,
+                    authProvider,
+                    kasEndpoint,
+                    dpopEnabled,
+                });
+            const buffer = await processDataIn(argv.file);
+            log('DEBUG', 'Decrypt data.');
+            const plaintext = await client.decrypt(buffer);
+            log('DEBUG', 'Handle output.');
+            if (argv.output) {
+                await writeFile(argv.output, new Uint8Array(plaintext));
+            }
+            else {
+                console.log(new TextDecoder().decode(plaintext));
+            }
+        }
+        const lastRequest = authProvider.requestLog[authProvider.requestLog.length - 1];
+        let accessToken = null;
+        let dpopToken = null;
+        for (const h of Object.keys(lastRequest.headers)) {
+            switch (h.toLowerCase()) {
+                case 'dpop':
+                    console.assert(!dpopToken, 'Multiple dpop headers found');
+                    dpopToken = parseJwtComplete(lastRequest.headers[h]);
+                    log('INFO', `dpop: ${JSON.stringify(dpopToken)}`);
+                    break;
+                case 'authorization':
+                    console.assert(!accessToken, 'Multiple authorization headers found');
+                    accessToken = parseJwt(lastRequest.headers[h].split(' ')[1]);
+                    log('INFO', `Access Token: ${JSON.stringify(accessToken)}`);
+                    if (argv.dpop) {
+                        console.assert(accessToken.cnf?.jkt, 'Access token must have a cnf.jkt');
+                    }
+                    break;
+            }
+        }
+        console.assert(accessToken, 'No access_token found');
+        console.assert(!argv.dpop || dpopToken, 'DPoP requested but absent');
+    })
+        .command('encrypt [file]', 'Encrypt file or pipe to a TDF', 
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    (yargs) => {
+        yargs.strict().positional('file', {
+            describe: 'path to plain text file',
+            type: 'string',
+        });
+    }, async (argv) => {
+        log('DEBUG', 'Running encrypt command');
+        const authProvider = await processAuth(argv);
+        log('DEBUG', `Initialized auth provider ${JSON.stringify(authProvider)}`);
+        const kasEndpoint = argv.kasEndpoint;
+        const ignoreAllowList = !!argv.ignoreAllowList;
+        const allowedKases = argv.allowList?.split(',');
+        if ('tdf3' === argv.containerType || 'ztdf' === argv.containerType) {
+            log('DEBUG', `TDF3 Client`);
+            const policyEndpoint = guessPolicyUrl(argv);
+            const client = new TDF3Client({
+                allowedKases,
+                ignoreAllowList,
+                authProvider,
+                kasEndpoint,
+                policyEndpoint,
+                dpopEnabled: argv.dpop,
+            });
+            log('SILLY', `Initialized client ${JSON.stringify(client)}`);
+            const ct = await client.encrypt(await tdf3EncryptParamsFor(argv));
+            if (!ct) {
+                throw new CLIError('CRITICAL', 'Encrypt configuration error: No output?');
+            }
+            if (argv.output) {
+                const destination = createWriteStream(argv.output);
+                await ct.stream.pipeTo(Writable.toWeb(destination));
+            }
+            else {
+                console.log(await ct.toString());
+            }
+        }
+        else {
+            const dpopEnabled = !!argv.dpop;
+            const ecdsaBinding = argv.policyBinding.toLowerCase() == 'ecdsa';
+            const client = argv.containerType === 'nano'
+                ? new NanoTDFClient({ allowedKases, authProvider, dpopEnabled, kasEndpoint })
+                : new NanoTDFDatasetClient({
+                    allowedKases,
+                    authProvider,
+                    dpopEnabled,
+                    kasEndpoint,
+                });
+            log('SILLY', `Initialized client ${JSON.stringify(client)}`);
+            addParams(client, argv);
+            const buffer = await processDataIn(argv.file);
+            const cyphertext = await client.encrypt(buffer, { ecdsaBinding });
+            log('DEBUG', `Handle cyphertext output ${JSON.stringify(cyphertext)}`);
+            if (argv.output) {
+                await writeFile(argv.output, new Uint8Array(cyphertext));
+            }
+            else {
+                console.log(base64.encodeArrayBuffer(cyphertext));
+            }
+        }
+    })
+        .usage('openTDF CLI\n\nUsage: $0 [options]')
+        .alias('help', 'h')
+        .demandCommand()
+        .recommendCommands()
+        .help('help')
+        .options({
+        env: {
+            desc: 'Set the environment',
+        },
+    })
+        .version('version', JSON.stringify({
+        '@opentdf/ctl': process.env.npm_package_version || 'UNRELEASED',
+        '@opentdf/sdk': version,
+    }))
+        .alias('version', 'V')
+        .strict()
+        .parseAsync());
+};
+export const main = async (argsPromise) => {
+    argsPromise;
+};
+handleArgs(hideBin(process.argv))
+    .then(main)
+    .then(() => {
+    // Nothing;
+})
+    .catch((err) => {
+    console.error(err);
+});
+function guessPolicyUrl({ kasEndpoint, policyEndpoint, }) {
+    let policyUrl;
+    if (policyEndpoint) {
+        policyUrl = rstrip(policyEndpoint, '/');
+    }
+    else {
+        const uNoSlash = rstrip(kasEndpoint, '/');
+        policyUrl = uNoSlash.endsWith('/kas') ? uNoSlash.slice(0, -4) : uNoSlash;
+    }
+    return policyUrl;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"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"}

package/dist/src/logger.js

@@ -0,0 +1,64 @@
+export const Levels = ['CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG', 'SILLY'];
+export class CLIError extends Error {
+    constructor(prefix, message, cause) {
+        super(message, { cause });
+        this.prefix = prefix;
+        this.message = message;
+    }
+}
+export const log = Object.assign((thing, message) => {
+    let e;
+    let m;
+    let l;
+    if (thing instanceof CLIError) {
+        l = thing.prefix;
+        m = thing.message;
+        e = thing;
+    }
+    else if (thing instanceof Error) {
+        l = 'CRITICAL';
+        m = thing.message;
+        e = thing;
+    }
+    else {
+        l = thing;
+        m = message || '';
+        e = null;
+    }
+    const prefixed = `[${l}] ${m}`;
+    const i = Levels.indexOf(l);
+    if (i <= Levels.indexOf(log.level)) {
+        switch (l) {
+            case 'CRITICAL':
+            case 'ERROR':
+                if (e && !(e instanceof CLIError)) {
+                    console.error(prefixed, e);
+                }
+                else {
+                    console.error(prefixed);
+                }
+                break;
+            case 'WARNING':
+                if (e) {
+                    console.warn(prefixed, e);
+                }
+                else {
+                    console.warn(prefixed);
+                }
+                break;
+            case 'INFO':
+                console.info(prefixed);
+                break;
+            default:
+                console.log(prefixed);
+                break;
+        }
+    }
+    if (log.level === 'SILLY') {
+        console.error(e);
+    }
+    if (l === 'CRITICAL') {
+        process.exit(1);
+    }
+}, { level: 'INFO' });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/polyfills.js

@@ -0,0 +1,6 @@
+if (!('document' in globalThis)) {
+    // @ts-expect-error // document is either undefined or readonly
+    globalThis.document = { documentElement: { style: {} } };
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9seWZpbGxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3BvbHlmaWxscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFJLENBQUMsQ0FBQyxVQUFVLElBQUksVUFBVSxDQUFDLEVBQUUsQ0FBQztJQUNoQywrREFBK0Q7SUFDL0QsVUFBVSxDQUFDLFFBQVEsR0FBRyxFQUFFLGVBQWUsRUFBRSxFQUFFLEtBQUssRUFBRSxFQUFFLEVBQUUsRUFBRSxDQUFDO0FBQzNELENBQUMifQ==

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@opentdf/ctl",
+  "version": "0.1.0-beta.1701",
+  "description": "Node based CLI for opentdf",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/opentdf/web-sdk.git",
+    "directory": "cli"
+  },
+  "license": "BSD-3-Clause-Clear",
+  "author": "Virtru",
+  "main": "dist/src/cli.js",
+  "type": "module",
+  "files": [
+    "dist/src/**",
+    "bin/opentdf.mjs"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "prepack": "npm run build",
+    "test": "npm run build && mocha dist/**/*.spec.js",
+    "watch": "(trap 'kill 0' SIGINT; npm run build && (npm run build:watch & npm run test -- --watch))",
+    "format": "prettier --write \"{src,tests}/**/*.ts\"",
+    "license-check": "license-checker-rseidelsohn --production --onlyAllow 'Apache-2.0; BSD; CC-BY-4.0; ISC; MIT'",
+    "lint": "eslint ./{src,tests}/**/*.ts"
+  },
+  "bin": {
+    "opentdf": "./bin/opentdf.mjs"
+  },
+  "devDependencies": {
+    "@esm-bundle/chai": "4.3.4-fix.0",
+    "@types/mocha": "10.0.9",
+    "@types/node": "^22.9.0",
+    "@types/readable-stream": "^4.0.18",
+    "@types/sinon": "^17.0.3",
+    "@types/yargs": "^17.0.33",
+    "@typescript-eslint/eslint-plugin": "^6.2.1",
+    "@typescript-eslint/parser": "^6.2.1",
+    "chai": "^5.1.2",
+    "eslint": "^8.9.0",
+    "eslint-config-prettier": "^8.9.0",
+    "license-checker-rseidelsohn": "^4.4.2",
+    "mocha": "^10.8.2",
+    "prettier": "^3.3.3",
+    "sinon": "^19.0.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "@opentdf/sdk": "^0.1.0-beta.1701",
+    "yargs": "^17.7.2"
+  }
+}