@terros-inc/cli 1.0.0

package/cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import './dist/index.js'

package/dist/api/auth.js

@@ -0,0 +1,13 @@
+import { getTokens } from "../auth/tokens.js";
+const API_KEY_ENV = 'TERROS_API_KEY';
+export async function getAuthorizationHeader() {
+    const apiKeyEnv = process.env[API_KEY_ENV];
+    if (apiKeyEnv) {
+        return `ApiKey ${apiKeyEnv}`;
+    }
+    const tokens = await getTokens();
+    if (tokens !== null) {
+        return `Bearer ${tokens.access_token}`;
+    }
+    throw new Error(`CLI not authorized. Run \`terros auth login\` to authenticate or provide an API key in the \`${API_KEY_ENV}\` environment variable.`);
+}

package/dist/api/query.js

@@ -0,0 +1,13 @@
+import { getAuthorizationHeader } from "./auth.js";
+export async function queryTerrosAPI(path, input) {
+    const authorization = await getAuthorizationHeader();
+    const res = await fetch(`https://api.terros.com${path}`, {
+        method: 'POST',
+        headers: {
+            Authorization: authorization,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(input)
+    });
+    return await res.json();
+}

package/dist/auth/auth0.js

@@ -0,0 +1,68 @@
+import { AUTH0_CLIENT_ID, AUTH0_DOMAIN } from "./constants.js";
+import open from "open";
+import { DateTime } from "luxon";
+export async function signInToAuth0() {
+    const res = await fetch(`${AUTH0_DOMAIN}/oauth/device/code`, {
+        method: 'POST',
+        headers: {
+            "Content-Type": 'application/json'
+        },
+        body: JSON.stringify({
+            client_id: AUTH0_CLIENT_ID,
+            scope: 'offline_access'
+        })
+    });
+    if (!res.ok)
+        throw new Error('Failed to get OAuth device code');
+    const body = await res.json();
+    const deadline = DateTime.now().plus({ seconds: body.expires_in });
+    await open(body.verification_uri_complete);
+    console.log(`Confirm that the code in your browser matches: ${body.user_code}`);
+    console.log(`If your browser did not open, visit ${body.verification_uri} and enter the code`);
+    return await pollForToken(deadline, body.interval, body.device_code);
+}
+function sleep(seconds) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, seconds * 1000);
+    });
+}
+async function pollForToken(deadline, interval, deviceCode) {
+    await sleep(interval);
+    if (deadline < DateTime.now())
+        throw new Error('Token was not approved in time');
+    const res = await fetch(`${AUTH0_DOMAIN}/oauth/token`, {
+        method: 'POST',
+        headers: {
+            "Content-Type": 'application/json',
+        },
+        body: JSON.stringify({
+            client_id: AUTH0_CLIENT_ID,
+            grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+            device_code: deviceCode
+        })
+    });
+    if (!res.ok) {
+        const body = await res.json();
+        if (body.error === 'access_denied')
+            throw new Error('Authorization request denied');
+        return pollForToken(deadline, interval, deviceCode);
+    }
+    return await res.json();
+}
+export async function refreshTokens(refreshToken) {
+    const res = await fetch(`${AUTH0_DOMAIN}/oauth/token`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            client_id: AUTH0_CLIENT_ID,
+            grant_type: 'refresh_token',
+            refresh_token: refreshToken
+        })
+    });
+    if (res.ok) {
+        return await res.json();
+    }
+    throw new Error('Unable to refresh token, it may be expired. Run `terros auth login` to sign in again');
+}

package/dist/auth/constants.js

@@ -0,0 +1,2 @@
+export const AUTH0_CLIENT_ID = 'Aj2tDQZgcN8de0k4jvsndHILsLvyDh5o';
+export const AUTH0_DOMAIN = 'https://auth.terros.com';

package/dist/auth/tokens.js

@@ -0,0 +1,50 @@
+import { DateTime } from 'luxon';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { mkdir, writeFile, readFile } from 'node:fs/promises';
+import { refreshTokens } from "./auth0.js";
+export async function getTokens() {
+    const tokens = await readTokens();
+    if (tokens === null) {
+        return null;
+    }
+    if (areTokensValid(tokens))
+        return tokens;
+    const updated = await refreshTokens(tokens.refresh_token);
+    return await saveTokens(updated);
+}
+function areTokensValid(tokens) {
+    return tokens.expires_at > DateTime.now().minus({ minute: 5 }).toMillis();
+}
+async function readTokens() {
+    try {
+        const path = await getAuthFilePath();
+        const file = await readFile(path, 'utf-8');
+        return JSON.parse(file);
+    }
+    catch (e) {
+        return null;
+    }
+}
+export async function saveTokens(tokenResponse) {
+    const expiresAt = DateTime.now().plus({ second: tokenResponse.expires_in }).toMillis();
+    const savedTokens = {
+        access_token: tokenResponse.access_token,
+        refresh_token: tokenResponse.refresh_token,
+        id_token: tokenResponse.id_token,
+        token_type: tokenResponse.token_type,
+        expires_at: expiresAt,
+    };
+    const authFile = await getAuthFilePath();
+    await writeFile(authFile, JSON.stringify(savedTokens));
+    return savedTokens;
+}
+async function getAuthFilePath() {
+    const home = homedir();
+    const configPath = join(home, '.config', 'terros');
+    if (!existsSync(configPath)) {
+        await mkdir(configPath, { recursive: true });
+    }
+    return join(configPath, 'auth.json');
+}

package/dist/auth/types.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/auth.js

@@ -0,0 +1,12 @@
+import { signInToAuth0 } from "../auth/auth0.js";
+import { saveTokens } from "../auth/tokens.js";
+export const authCommands = {
+    login: {
+        description: 'Sign in to Terros',
+        async run() {
+            const tokens = await signInToAuth0();
+            await saveTokens(tokens);
+            console.log('Signed in successfully');
+        },
+    },
+};

package/dist/commands/index.js

@@ -0,0 +1,22 @@
+import { authCommands } from "./auth.js";
+export const commandRegistry = {
+    auth: {
+        description: 'Manage authentication',
+        subcommands: authCommands,
+    },
+};
+export function getCommandGroup(command) {
+    return commandRegistry[command];
+}
+export function getSubcommand(command, subcommand) {
+    return getCommandGroup(command)?.subcommands[subcommand];
+}
+export function getCommandNames() {
+    return Object.keys(commandRegistry).sort();
+}
+export function getSubcommandNames(command) {
+    const commandGroup = getCommandGroup(command);
+    if (!commandGroup)
+        return [];
+    return Object.keys(commandGroup.subcommands).sort();
+}

package/dist/commands/types.js

@@ -0,0 +1 @@
+export {};

package/dist/crud/endpoint.js

@@ -0,0 +1 @@
+export {};

package/dist/crud/index.js

@@ -0,0 +1,21 @@
+import { readFileSync } from 'node:fs';
+import { parse } from 'yaml';
+import { getPathParts } from "./util.js";
+import { getEndpointParameters } from "./parameters.js";
+export function loadEndpoints() {
+    const file = readFileSync('./terros.yml', 'utf-8');
+    const data = parse(file);
+    const entries = Object.entries(data.paths);
+    const endpoints = {};
+    entries.forEach(([path, config]) => {
+        const { group, alias } = getPathParts(path);
+        endpoints[group] ??= {};
+        const schema = config.post.requestBody.content['application/json'].schema;
+        endpoints[group][alias] = {
+            path,
+            properties: schema,
+            parameters: getEndpointParameters(schema, data.components),
+        };
+    });
+    return endpoints;
+}

package/dist/crud/input.js

@@ -0,0 +1,189 @@
+export function buildEndpointInput(endpoint, params) {
+    const parsedParams = flattenParsedArgs(params);
+    const providedParameterNames = Object.keys(parsedParams);
+    const knownParameterNames = new Set(endpoint.parameters.map((parameter) => parameter.name));
+    const unknownParameterNames = providedParameterNames.filter((name) => !knownParameterNames.has(name));
+    if (unknownParameterNames.length > 0) {
+        throw new Error(`Unknown parameter(s): ${unknownParameterNames.map((name) => `--${name}`).join(', ')}`);
+    }
+    const missingParameters = endpoint.parameters.filter((parameter) => (parameter.required && !Object.hasOwn(parsedParams, parameter.name)));
+    if (missingParameters.length > 0) {
+        throw new Error(`Missing required parameter(s): ${missingParameters.map((parameter) => `--${parameter.name}`).join(', ')}`);
+    }
+    const input = {};
+    const prefix = getHiddenWrapperPrefix(endpoint);
+    for (const parameter of endpoint.parameters) {
+        if (!Object.hasOwn(parsedParams, parameter.name))
+            continue;
+        const value = parseParameterValue(parsedParams[parameter.name], parameter);
+        const path = [...prefix, ...parameter.name.split('.').filter(Boolean)];
+        setNestedValue(input, path, value);
+    }
+    return input;
+}
+function flattenParsedArgs(params) {
+    const flattened = {};
+    for (const [key, value] of Object.entries(params)) {
+        if (key === '_')
+            continue;
+        flattenValue(flattened, key, value);
+    }
+    return flattened;
+}
+function flattenValue(flattened, prefix, value) {
+    if (isRecord(value)) {
+        for (const [key, childValue] of Object.entries(value)) {
+            flattenValue(flattened, `${prefix}.${key}`, childValue);
+        }
+        return;
+    }
+    flattened[prefix] = value;
+}
+function getHiddenWrapperPrefix(endpoint) {
+    const schema = endpoint.properties;
+    if (!('type' in schema) || schema.type !== 'object')
+        return [];
+    const propertyNames = Object.keys(schema.properties);
+    if (propertyNames.length !== 1)
+        return [];
+    const wrapperName = propertyNames[0];
+    return wrapperName ? [wrapperName] : [];
+}
+function setNestedValue(input, path, value) {
+    if (path.length === 0) {
+        throw new Error('Cannot set a parameter without a name');
+    }
+    let current = input;
+    for (const key of path.slice(0, -1)) {
+        const existing = current[key];
+        if (existing === undefined) {
+            const next = {};
+            current[key] = next;
+            current = next;
+            continue;
+        }
+        if (!isRecord(existing)) {
+            throw new Error(`Parameter path conflict at "${key}"`);
+        }
+        current = existing;
+    }
+    const leaf = path.at(-1);
+    if (!leaf)
+        throw new Error('Cannot set a parameter without a name');
+    current[leaf] = value;
+}
+function parseParameterValue(value, parameter) {
+    return parseValue(value, parameter.type, parameter.name);
+}
+function parseValue(value, type, parameterName) {
+    if (type.endsWith('[]')) {
+        return parseArrayValue(value, type.slice(0, -2), parameterName);
+    }
+    if (type.includes('|')) {
+        return parseUnionValue(value, type, parameterName);
+    }
+    switch (type) {
+        case 'string':
+            return parseStringValue(value, parameterName);
+        case 'integer':
+            return parseIntegerValue(value, parameterName);
+        case 'number':
+            return parseNumberValue(value, parameterName);
+        case 'boolean':
+            return parseBooleanValue(value, parameterName);
+        case 'object':
+        case 'unknown':
+            return parseJsonValue(value, parameterName);
+        default:
+            return parseJsonValue(value, parameterName);
+    }
+}
+function parseStringValue(value, parameterName) {
+    if (Array.isArray(value)) {
+        throw new Error(`Parameter --${parameterName} expects a single string value`);
+    }
+    return String(value);
+}
+function parseIntegerValue(value, parameterName) {
+    const numberValue = parseNumberValue(value, parameterName);
+    if (!Number.isInteger(numberValue)) {
+        throw new Error(`Parameter --${parameterName} expects an integer`);
+    }
+    return numberValue;
+}
+function parseNumberValue(value, parameterName) {
+    if (Array.isArray(value)) {
+        throw new Error(`Parameter --${parameterName} expects a single number value`);
+    }
+    const numberValue = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(numberValue)) {
+        throw new Error(`Parameter --${parameterName} expects a number`);
+    }
+    return numberValue;
+}
+function parseBooleanValue(value, parameterName) {
+    if (Array.isArray(value)) {
+        throw new Error(`Parameter --${parameterName} expects a single boolean value`);
+    }
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number') {
+        if (value === 1)
+            return true;
+        if (value === 0)
+            return false;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.toLowerCase();
+        if (['true', '1', 'yes'].includes(normalized))
+            return true;
+        if (['false', '0', 'no'].includes(normalized))
+            return false;
+    }
+    throw new Error(`Parameter --${parameterName} expects a boolean`);
+}
+function parseArrayValue(value, itemType, parameterName) {
+    if (Array.isArray(value)) {
+        return value.map((item) => parseValue(item, itemType, parameterName));
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed.startsWith('[')) {
+            const parsed = parseJsonValue(trimmed, parameterName);
+            if (!Array.isArray(parsed)) {
+                throw new Error(`Parameter --${parameterName} expects an array`);
+            }
+            return parsed.map((item) => parseValue(item, itemType, parameterName));
+        }
+        if (trimmed === '')
+            return [];
+        return trimmed.split(',').map((item) => parseValue(item, itemType, parameterName));
+    }
+    return [parseValue(value, itemType, parameterName)];
+}
+function parseUnionValue(value, type, parameterName) {
+    const types = type.split('|').map((item) => item.trim());
+    const errors = [];
+    for (const itemType of types) {
+        try {
+            return parseValue(value, itemType, parameterName);
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error.message : String(error));
+        }
+    }
+    throw new Error(`Parameter --${parameterName} does not match any supported type: ${types.join(', ')}. ${errors.at(-1)}`);
+}
+function parseJsonValue(value, parameterName) {
+    if (typeof value !== 'string')
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        throw new Error(`Parameter --${parameterName} expects valid JSON`);
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/crud/parameters.js

@@ -0,0 +1,83 @@
+function isRefSchema(schema) {
+    return '$ref' in schema;
+}
+function isAnyOfSchema(schema) {
+    return 'anyOf' in schema;
+}
+function getSchemaType(schema, components) {
+    if (isRefSchema(schema))
+        return getSchemaType(resolveSchema(schema, components), components);
+    if ('oneOf' in schema)
+        return schema.oneOf.map((item) => getSchemaType(item, components)).join(' | ');
+    if (isAnyOfSchema(schema))
+        return schema.anyOf.map((item) => getSchemaType(item, components)).join(' | ');
+    if ('type' in schema) {
+        if (schema.type === 'array')
+            return `${getSchemaType(schema.items, components)}[]`;
+        return schema.type;
+    }
+    return 'unknown';
+}
+function resolveSchema(schema, components, seen = new Set()) {
+    if (!isRefSchema(schema))
+        return schema;
+    const match = schema.$ref.match(/^#\/components\/schemas\/(.+)$/);
+    if (!match)
+        throw new Error(`Unsupported schema ref: ${schema.$ref}`);
+    const schemaName = match[1];
+    if (!schemaName)
+        throw new Error(`Unsupported schema ref: ${schema.$ref}`);
+    if (seen.has(schemaName))
+        throw new Error(`Circular schema ref: ${schema.$ref}`);
+    const resolved = components.schemas[schemaName];
+    if (!resolved)
+        throw new Error(`Unknown schema ref: ${schema.$ref}`);
+    seen.add(schemaName);
+    return resolveSchema(resolved, components, seen);
+}
+function flattenSchema(schema, context) {
+    const resolved = resolveSchema(schema, context.components);
+    if ('type' in resolved
+        && resolved.type === 'object'
+        && resolved.properties) {
+        return Object.entries(resolved.properties).flatMap(([name, childSchema]) => {
+            const required = resolved.required?.includes(name) ?? false;
+            return flattenSchema(childSchema, {
+                components: context.components,
+                path: [...context.path, name],
+                required: context.required && required,
+            });
+        });
+    }
+    return [
+        {
+            name: context.path.join('.'),
+            type: getSchemaType(resolved, context.components),
+            required: context.required,
+            ...(schema.description ?? resolved.description
+                ? { description: schema.description ?? resolved.description }
+                : {}),
+        },
+    ];
+}
+function hideSingleObjectWrapper(parameters) {
+    const wrapperNames = new Set(parameters.map((parameter) => parameter.name.split('.')[0]));
+    if (wrapperNames.size !== 1)
+        return parameters;
+    const wrapperName = [...wrapperNames][0];
+    if (!wrapperName)
+        return parameters;
+    return parameters.map((parameter) => ({
+        ...parameter,
+        name: parameter.name.startsWith(`${wrapperName}.`)
+            ? parameter.name.slice(wrapperName.length + 1)
+            : parameter.name,
+    }));
+}
+export function getEndpointParameters(schema, components) {
+    return hideSingleObjectWrapper(flattenSchema(schema, {
+        components,
+        path: [],
+        required: true,
+    }));
+}

package/dist/crud/types.js

@@ -0,0 +1 @@
+export {};

package/dist/crud/util.js

@@ -0,0 +1,9 @@
+export function getPathParts(path) {
+    const parts = path.substring(1).split('/');
+    if (parts.length < 2)
+        throw new Error('Tried to parse path with fewer than 2 parts');
+    return {
+        group: parts.at(-2),
+        alias: parts.at(-1),
+    };
+}

package/dist/index.js

@@ -0,0 +1,99 @@
+import minimist from 'minimist';
+import { formatCommandsHelp, formatSubcommandParametersHelp, formatSubcommandsHelp, HELP_PARENT_MESSAGE, } from "./messages.js";
+import { loadEndpoints } from "./crud/index.js";
+import { buildEndpointInput } from "./crud/input.js";
+import { queryTerrosAPI } from "./api/query.js";
+import { getCommandGroup, getCommandNames, getSubcommand, getSubcommandNames, } from "./commands/index.js";
+async function main() {
+    const params = minimist(process.argv.slice(2));
+    const commands = params._;
+    if (commands.length === 0) {
+        console.log(HELP_PARENT_MESSAGE);
+        return;
+    }
+    const requestedAlias = commands.at(0);
+    if (!requestedAlias) {
+        console.log(HELP_PARENT_MESSAGE);
+        return;
+    }
+    if (commands.at(-1) === 'help') {
+        showHelp(commands, requestedAlias);
+        return;
+    }
+    const commandGroup = getCommandGroup(requestedAlias);
+    if (commandGroup) {
+        const subcommand = commands.at(1);
+        if (!subcommand) {
+            console.log(formatSubcommandsHelp(requestedAlias, getSubcommandNames(requestedAlias)));
+            return;
+        }
+        const command = getSubcommand(requestedAlias, subcommand);
+        if (!command) {
+            console.error(`Unknown subcommand: ${requestedAlias} ${subcommand}`);
+            console.log(formatSubcommandsHelp(requestedAlias, getSubcommandNames(requestedAlias)));
+            process.exitCode = 1;
+            return;
+        }
+        await command.run({
+            params,
+            args: commands.slice(2),
+        });
+        return;
+    }
+    const endpoints = loadEndpoints();
+    const endpointGroup = endpoints[requestedAlias];
+    if (!endpointGroup) {
+        console.error(`Unknown command: ${requestedAlias}`);
+        const commandList = [...getCommandNames(), ...Object.keys(endpoints)].sort();
+        console.log(formatCommandsHelp(commandList));
+        process.exitCode = 1;
+        return;
+    }
+    const subcommand = commands.at(1);
+    if (!subcommand) {
+        console.log(formatSubcommandsHelp(requestedAlias, Object.keys(endpointGroup).sort()));
+        return;
+    }
+    const endpoint = endpointGroup[subcommand];
+    if (!endpoint) {
+        console.error(`Unknown subcommand: ${requestedAlias} ${subcommand}`);
+        console.log(formatSubcommandsHelp(requestedAlias, Object.keys(endpointGroup).sort()));
+        process.exitCode = 1;
+        return;
+    }
+    const input = buildEndpointInput(endpoint, params);
+    const response = await queryTerrosAPI(endpoint.path, input);
+    console.log(JSON.stringify(response, null, 2));
+}
+function showHelp(commands, requestedAlias) {
+    const commandGroup = getCommandGroup(requestedAlias);
+    if (commandGroup) {
+        const subcommand = commands.at(1);
+        if (subcommand && commands.length >= 3 && getSubcommand(requestedAlias, subcommand)) {
+            console.log(formatSubcommandParametersHelp(requestedAlias, subcommand, []));
+            return;
+        }
+        console.log(formatSubcommandsHelp(requestedAlias, getSubcommandNames(requestedAlias)));
+        return;
+    }
+    const endpoints = loadEndpoints();
+    const endpoint = endpoints[requestedAlias];
+    if (endpoint) {
+        const subcommand = commands.at(1);
+        if (subcommand && commands.length >= 3) {
+            const requestedSubcommand = endpoint[subcommand];
+            if (requestedSubcommand) {
+                console.log(formatSubcommandParametersHelp(requestedAlias, subcommand, requestedSubcommand.parameters));
+                return;
+            }
+        }
+        console.log(formatSubcommandsHelp(requestedAlias, Object.keys(endpoint).sort()));
+        return;
+    }
+    const commandList = [...getCommandNames(), ...Object.keys(endpoints)].sort();
+    console.log(formatCommandsHelp(commandList));
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+});

package/dist/messages.js

@@ -0,0 +1,51 @@
+export const HELP_PARENT_MESSAGE = `
+usage: terros <command> <subcommand> [parameters]
+To see help text, you can run:
+
+  terros help
+  terros <command> help
+  terros <command> <subcommand> help
+`.trim();
+export function formatCommandsHelp(commands) {
+    const lines = [
+        `usage: terros <command> <subcommand> [parameters]`,
+        '',
+        'Commands:',
+        ...commands.map((command) => `  ${command}`),
+        '',
+        `Run "terros <command> help" to see subcommands.`,
+    ];
+    return lines.join('\n');
+}
+export function formatSubcommandsHelp(command, subcommands) {
+    const lines = [
+        `usage: terros ${command} <subcommand> [parameters]`,
+        '',
+        'Subcommands:',
+        ...subcommands.map((subcommand) => `  ${subcommand}`),
+        '',
+        `Run "terros ${command} <subcommand> help" to see subcommand parameters.`,
+    ];
+    return lines.join('\n');
+}
+export function formatSubcommandParametersHelp(command, subcommand, parameters) {
+    const lines = [
+        `usage: terros ${command} ${subcommand} [parameters]`,
+        '',
+        'Parameters:',
+    ];
+    if (parameters.length === 0) {
+        lines.push('  none');
+        return lines.join('\n');
+    }
+    const nameWidth = Math.max(...parameters.map((parameter) => parameter.name.length));
+    const typeWidth = Math.max(...parameters.map((parameter) => parameter.type.length));
+    lines.push(...parameters.map((parameter) => {
+        const name = parameter.name.padEnd(nameWidth);
+        const type = parameter.type.padEnd(typeWidth);
+        const required = parameter.required ? 'required' : 'optional';
+        const description = parameter.description ? `  ${parameter.description}` : '';
+        return `  --${name}  ${type}  ${required}${description}`;
+    }));
+    return lines.join('\n');
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "author": "Terros Inc.",
+  "bin": {
+    "terros": "./cli.js"
+  },
+  "description": "Command-line interface for Terros Sales platform",
+  "devDependencies": {
+    "@types/minimist": "^1.2.5",
+    "@types/node": "^24.13.1",
+    "typescript": "^6.0.3",
+    "@types/luxon": "^3.7.1"
+  },
+  "keywords": [
+    "terros",
+    "cli"
+  ],
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "name": "@terros-inc/cli",
+  "engines": {
+    "node": ">=24"
+  },
+  "files": [
+    "cli.js",
+    "dist"
+  ],
+  "type": "module",
+  "version": "1.0.0",
+  "dependencies": {
+    "luxon": "^3.7.2",
+    "minimist": "^1.2.8",
+    "open": "^11.0.0",
+    "yaml": "^2.9.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node src/index.ts"
+  }
+}