@underlingscloud/cli 0.1.0

package/dist/commands/login.d.ts

@@ -0,0 +1,3 @@
+export declare const login: () => Promise<void>;
+export declare const whoami: () => Promise<void>;
+export declare const logout: () => Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logout = exports.whoami = exports.login = void 0;
+const open_1 = __importDefault(require("open"));
+const prompts_1 = __importDefault(require("prompts"));
+const chalk_1 = __importDefault(require("chalk"));
+const axios_1 = __importDefault(require("axios"));
+const constants_1 = require("../constants");
+const auth_1 = require("../utils/auth");
+const login = async () => {
+    console.log(chalk_1.default.blue('Initiating login...'));
+    console.log('Opening browser to authenticate...');
+    await (0, open_1.default)((0, constants_1.getAuthUrl)());
+    const response = await (0, prompts_1.default)({
+        type: 'password',
+        name: 'token',
+        message: 'Please paste the authentication token from the browser:',
+        validate: (value) => value ? true : 'Token is required'
+    });
+    if (!response.token) {
+        console.log(chalk_1.default.red('Login cancelled.'));
+        return;
+    }
+    const token = response.token.trim();
+    try {
+        const userQuery = `
+            query Me {
+                me {
+                    id
+                    email
+                    name
+                }
+            }
+        `;
+        const result = await axios_1.default.post((0, constants_1.getApiUrl)(), { query: userQuery }, {
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${token}`
+            }
+        });
+        if (result.data.errors) {
+            throw new Error(result.data.errors[0].message);
+        }
+        const user = result.data.data.me;
+        (0, auth_1.setAuthToken)(token);
+        (0, auth_1.setUserInfo)(user);
+        console.log(chalk_1.default.green(`Successfully logged in as ${user.email || user.name}!`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Failed to verify token:'), error.message || error);
+    }
+};
+exports.login = login;
+const whoami = async () => {
+    const user = (0, auth_1.getUserInfo)();
+    if (user) {
+        console.log(chalk_1.default.green(`Logged in as: ${user.name || 'Unknown'} <${user.email}>`));
+    }
+    else {
+        console.log(chalk_1.default.yellow('Not logged in. Run "underlings auth login" to authenticate.'));
+    }
+};
+exports.whoami = whoami;
+const logout = async () => {
+    (0, auth_1.clearAuth)();
+    console.log(chalk_1.default.green('Logged out successfully.'));
+};
+exports.logout = logout;

package/dist/commands/project.d.ts

@@ -0,0 +1,2 @@
+export declare const initProject: () => Promise<void>;
+export declare const initService: () => Promise<void>;

package/dist/commands/project.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initService = exports.initProject = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+const axios_1 = __importDefault(require("axios"));
+const constants_1 = require("../constants");
+const auth_1 = require("../utils/auth");
+const config_1 = require("../utils/config");
+const initProject = async () => {
+    if (!(0, auth_1.isAuthenticated)()) {
+        console.error(chalk_1.default.red('Error: You are not logged in.'));
+        console.log('Run "underlings auth login" to authenticate.');
+        return;
+    }
+    const token = (0, auth_1.getAuthToken)();
+    const existingConfigPath = (0, config_1.findProjectConfigPath)();
+    if (existingConfigPath) {
+        console.log(chalk_1.default.yellow(`Found existing project config at ${existingConfigPath}`));
+        const response = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'proceed',
+            message: 'You are already inside a project. Initialize a new project config here?',
+            initial: false
+        });
+        if (!response.proceed)
+            return;
+    }
+    const projectsQuery = `query { projects { id name slug } }`;
+    try {
+        const result = await axios_1.default.post((0, constants_1.getApiUrl)(), { query: projectsQuery }, {
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        if (result.data.errors)
+            throw new Error(result.data.errors[0].message);
+        const projects = result.data.data.projects;
+        if (!projects?.length) {
+            console.log(chalk_1.default.red('No projects found. Please create one on the dashboard first.'));
+            return;
+        }
+        const response = await (0, prompts_1.default)({
+            type: 'select',
+            name: 'project',
+            message: 'Select a project:',
+            choices: projects.map((p) => ({ title: `${p.name} (${p.slug})`, value: p }))
+        });
+        if (!response.project)
+            return;
+        (0, config_1.writeProjectConfig)({ project: response.project.slug });
+        console.log(chalk_1.default.green(`Successfully initialized ulproject.json for project "${response.project.slug}"`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Failed to fetch projects:'), error.message);
+    }
+};
+exports.initProject = initProject;
+const initService = async () => {
+    if (!(0, auth_1.isAuthenticated)()) {
+        console.error(chalk_1.default.red('Error: You are not logged in.'));
+        console.log('Run "underlings auth login" to authenticate.');
+        return;
+    }
+    const token = (0, auth_1.getAuthToken)();
+    const projectConfigPath = (0, config_1.findProjectConfigPath)();
+    if (!projectConfigPath) {
+        console.error(chalk_1.default.red('Error: No project config found. Run "underlings project init" at the repo root first.'));
+        return;
+    }
+    const projectConfig = (0, config_1.readProjectConfig)();
+    const servicesQuery = `
+        query Services($projectSlug: String!) {
+            services(projectSlug: $projectSlug) {
+                id name slug
+            }
+        }
+    `;
+    try {
+        const result = await axios_1.default.post((0, constants_1.getApiUrl)(), {
+            query: servicesQuery,
+            variables: { projectSlug: projectConfig.project }
+        }, {
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        if (result.data.errors)
+            throw new Error(result.data.errors[0].message);
+        const services = result.data.data.services;
+        if (!services?.length) {
+            console.log(chalk_1.default.red('No services found for this project.'));
+            return;
+        }
+        const response = await (0, prompts_1.default)({
+            type: 'select',
+            name: 'service',
+            message: 'Select a service to link to this directory:',
+            choices: services.map((s) => ({ title: `${s.name} (${s.slug})`, value: s }))
+        });
+        if (!response.service)
+            return;
+        (0, config_1.writeServiceConfig)({
+            project: projectConfig.project,
+            service: response.service.slug
+        });
+        console.log(chalk_1.default.green(`Successfully initialized ulservice.json for service "${response.service.slug}"`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Failed to fetch services:'), error.message);
+    }
+};
+exports.initService = initService;

package/dist/commands/run.d.ts

@@ -0,0 +1,2 @@
+export declare const run: (commandParts: string[]) => Promise<void>;
+export declare const env: () => Promise<void>;

package/dist/commands/run.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.env = exports.run = void 0;
+const cross_spawn_1 = __importDefault(require("cross-spawn"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const axios_1 = __importDefault(require("axios"));
+const constants_1 = require("../constants");
+const config_1 = require("../utils/config");
+const auth_1 = require("../utils/auth");
+const run = async (commandParts) => {
+    if (commandParts.length === 0) {
+        console.error(chalk_1.default.red('Error: No command provided to run.'));
+        console.log('Usage: underlings run <command>');
+        return;
+    }
+    if (!(0, auth_1.isAuthenticated)()) {
+        console.error(chalk_1.default.red('Error: You are not logged in.'));
+        console.log('Run "underlings auth login" to authenticate.');
+        return;
+    }
+    const token = (0, auth_1.getAuthToken)();
+    // Read service config
+    if (!(0, config_1.hasServiceConfig)()) {
+        console.error(chalk_1.default.red('Error: No ulservice.json (or ccservice.json) found in the current directory.'));
+        console.log('Please run "underlings service init" to configure this directory as a service.');
+        return;
+    }
+    let config;
+    try {
+        config = (0, config_1.readServiceConfig)();
+    }
+    catch (e) {
+        console.error(chalk_1.default.red('Error reading service config file.'));
+        return;
+    }
+    if (!config.service) {
+        console.error(chalk_1.default.red('Error: Invalid service config. Missing "service" identifier.'));
+        return;
+    }
+    // Get git branch
+    let branch;
+    try {
+        branch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD').toString().trim();
+    }
+    catch (e) {
+        console.error(chalk_1.default.red('Error: Could not determine git branch. Are you in a git repository?'));
+        return;
+    }
+    if (!branch) {
+        console.error(chalk_1.default.red('Error: Current branch is empty.'));
+        return;
+    }
+    console.log(chalk_1.default.dim(`Detected branch: ${branch}`));
+    // Fetch service variables
+    console.log(chalk_1.default.blue('Fetching service variables...'));
+    let envVars = {};
+    try {
+        envVars = await fetchServiceVariables(config.service, branch, token);
+        console.log(chalk_1.default.green(`Successfully loaded ${Object.keys(envVars).length} variables for service: ${config.service}`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Failed to fetch variables:'), error.message);
+        return;
+    }
+    // Execute command
+    const [cmd, ...args] = commandParts;
+    console.log(chalk_1.default.dim(`> Executing: ${cmd} ${args.join(' ')}`));
+    const child = (0, cross_spawn_1.default)(cmd, args, {
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            ...envVars
+        }
+    });
+    child.on('exit', (code) => {
+        process.exit(code || 0);
+    });
+};
+exports.run = run;
+const env = async () => {
+    if (!(0, auth_1.isAuthenticated)()) {
+        console.error(chalk_1.default.red('Error: You are not logged in.'));
+        return;
+    }
+    const token = (0, auth_1.getAuthToken)();
+    if (!(0, config_1.hasServiceConfig)()) {
+        console.error(chalk_1.default.red('Error: No service config found in the current directory.'));
+        return;
+    }
+    const config = (0, config_1.readServiceConfig)();
+    let branch;
+    try {
+        branch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD').toString().trim();
+    }
+    catch {
+        console.error(chalk_1.default.red('Error: Could not determine git branch.'));
+        return;
+    }
+    console.log(chalk_1.default.blue(`Variables for ${config.service} on branch "${branch}":\n`));
+    const envVars = await fetchServiceVariables(config.service, branch, token);
+    for (const [key, value] of Object.entries(envVars).sort(([a], [b]) => a.localeCompare(b))) {
+        console.log(`${chalk_1.default.cyan(key)}=${value}`);
+    }
+};
+exports.env = env;
+async function fetchServiceVariables(serviceSlug, branch, token) {
+    const query = `
+        query GetServiceVariables($serviceSlug: String!, $branch: String!) {
+            serviceVariables(serviceSlug: $serviceSlug, branch: $branch, includeSystem: true) {
+                key
+                value
+                isSecret
+            }
+        }
+    `;
+    const result = await axios_1.default.post((0, constants_1.getApiUrl)(), {
+        query,
+        variables: { serviceSlug, branch }
+    }, {
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`
+        }
+    });
+    if (result.data.errors) {
+        throw new Error(result.data.errors[0].message);
+    }
+    const variables = result.data.data.serviceVariables;
+    const envMap = {};
+    variables.forEach((v) => {
+        envMap[v.key] = v.value;
+    });
+    return envMap;
+}

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const setLocalMode: (local: boolean) => void;
+export declare const getApiUrl: () => string;
+export declare const getAuthUrl: () => string;

package/dist/constants.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthUrl = exports.getApiUrl = exports.setLocalMode = void 0;
+// Production URLs
+const PRODUCTION_API_URL = 'https://api.underlings.org/graphql';
+const PRODUCTION_AUTH_URL = 'https://team.underlings.org/cli-login';
+// Local URLs
+const LOCAL_API_URL = 'http://localhost:4000/graphql';
+const LOCAL_AUTH_URL = 'http://localhost:5173/cli-login';
+let isLocalMode = false;
+const setLocalMode = (local) => {
+    isLocalMode = local;
+};
+exports.setLocalMode = setLocalMode;
+const getApiUrl = () => {
+    return isLocalMode ? LOCAL_API_URL : PRODUCTION_API_URL;
+};
+exports.getApiUrl = getApiUrl;
+const getAuthUrl = () => {
+    return isLocalMode ? LOCAL_AUTH_URL : PRODUCTION_AUTH_URL;
+};
+exports.getAuthUrl = getAuthUrl;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+"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 });
+const commander_1 = require("commander");
+const constants_1 = require("./constants");
+const program = new commander_1.Command();
+program
+    .name('underlings')
+    .description('Underlings Developer Utilities CLI')
+    .version('0.1.0')
+    .option('--local', 'Use local development environment')
+    .hook('preAction', (thisCommand) => {
+    if (thisCommand.opts().local) {
+        (0, constants_1.setLocalMode)(true);
+    }
+});
+// ─── Auth ───────────────────────────────────────────────────────────────────
+const auth = program.command('auth').description('Authentication commands');
+auth.command('login')
+    .description('Authenticate with Underlings')
+    .action(async () => {
+    const { login } = await Promise.resolve().then(() => __importStar(require('./commands/login')));
+    await login();
+});
+auth.command('whoami')
+    .description('Check current authenticated user')
+    .action(async () => {
+    const { whoami } = await Promise.resolve().then(() => __importStar(require('./commands/login')));
+    await whoami();
+});
+auth.command('logout')
+    .description('Log out of Underlings')
+    .action(async () => {
+    const { logout } = await Promise.resolve().then(() => __importStar(require('./commands/login')));
+    await logout();
+});
+// ─── Project ────────────────────────────────────────────────────────────────
+const project = program.command('project').description('Project management commands');
+project.command('init')
+    .description('Initialize a project in the current directory')
+    .action(async () => {
+    const { initProject } = await Promise.resolve().then(() => __importStar(require('./commands/project')));
+    await initProject();
+});
+// ─── Service ────────────────────────────────────────────────────────────────
+const service = program.command('service').description('Service management commands');
+service.command('init')
+    .description('Initialize a service in the current directory')
+    .action(async () => {
+    const { initService } = await Promise.resolve().then(() => __importStar(require('./commands/project')));
+    await initService();
+});
+// ─── Run ────────────────────────────────────────────────────────────────────
+program.command('run [command...]')
+    .description('Run a command with injected environment variables')
+    .allowUnknownOption()
+    .action(async (commandParts) => {
+    const { run } = await Promise.resolve().then(() => __importStar(require('./commands/run')));
+    await run(commandParts);
+});
+// ─── Env ────────────────────────────────────────────────────────────────────
+program.command('env')
+    .description('Print resolved environment variables for current service + branch')
+    .action(async () => {
+    const { env } = await Promise.resolve().then(() => __importStar(require('./commands/run')));
+    await env();
+});
+program.parse();

package/dist/utils/auth.d.ts

@@ -0,0 +1,12 @@
+interface UserInfo {
+    id: string;
+    email: string;
+    name?: string;
+}
+export declare const getAuthToken: () => string | undefined;
+export declare const setAuthToken: (token: string) => void;
+export declare const clearAuth: () => void;
+export declare const setUserInfo: (user: UserInfo) => void;
+export declare const getUserInfo: () => UserInfo | undefined;
+export declare const isAuthenticated: () => boolean;
+export {};

package/dist/utils/auth.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAuthenticated = exports.getUserInfo = exports.setUserInfo = exports.clearAuth = exports.setAuthToken = exports.getAuthToken = void 0;
+const conf_1 = __importDefault(require("conf"));
+const schema = {
+    auth: {
+        type: 'object',
+        properties: {
+            token: { type: 'string' },
+            user: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    email: { type: 'string' },
+                    name: { type: 'string' },
+                },
+            },
+        },
+    },
+};
+const config = new conf_1.default({
+    projectName: 'underlings-cli',
+    schema,
+});
+const getAuthToken = () => {
+    if (process.env.UL_TOKEN) {
+        return process.env.UL_TOKEN;
+    }
+    return config.get('auth.token');
+};
+exports.getAuthToken = getAuthToken;
+const setAuthToken = (token) => {
+    config.set('auth.token', token);
+};
+exports.setAuthToken = setAuthToken;
+const clearAuth = () => {
+    config.delete('auth');
+};
+exports.clearAuth = clearAuth;
+const setUserInfo = (user) => {
+    config.set('auth.user', user);
+};
+exports.setUserInfo = setUserInfo;
+const getUserInfo = () => {
+    return config.get('auth.user');
+};
+exports.getUserInfo = getUserInfo;
+const isAuthenticated = () => {
+    return !!(0, exports.getAuthToken)();
+};
+exports.isAuthenticated = isAuthenticated;

package/dist/utils/config.d.ts

@@ -0,0 +1,20 @@
+export declare const PROJECT_CONFIG_FILE = "ulproject.json";
+export declare const SERVICE_CONFIG_FILE = "ulservice.json";
+interface ProjectConfig {
+    project: string;
+}
+interface ServiceConfig {
+    project: string;
+    service: string;
+}
+/** Search up the directory tree for ulproject.json (or ccproject.json) */
+export declare const findProjectConfigPath: (startDir?: string) => string | null;
+export declare const hasProjectConfig: () => boolean;
+export declare const readProjectConfig: () => ProjectConfig;
+/** Check for ulservice.json or ccservice.json in cwd */
+export declare const findServiceConfigPath: () => string | null;
+export declare const hasServiceConfig: () => boolean;
+export declare const readServiceConfig: () => ServiceConfig;
+export declare const writeProjectConfig: (config: ProjectConfig) => void;
+export declare const writeServiceConfig: (config: ServiceConfig) => void;
+export {};

package/dist/utils/config.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeServiceConfig = exports.writeProjectConfig = exports.readServiceConfig = exports.hasServiceConfig = exports.findServiceConfigPath = exports.readProjectConfig = exports.hasProjectConfig = exports.findProjectConfigPath = exports.SERVICE_CONFIG_FILE = exports.PROJECT_CONFIG_FILE = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.PROJECT_CONFIG_FILE = 'ulproject.json';
+exports.SERVICE_CONFIG_FILE = 'ulservice.json';
+// Also check legacy CC config files for backward compat
+const LEGACY_PROJECT_CONFIG = 'ccproject.json';
+const LEGACY_SERVICE_CONFIG = 'ccservice.json';
+/** Search up the directory tree for ulproject.json (or ccproject.json) */
+const findProjectConfigPath = (startDir = process.cwd()) => {
+    let currentDir = startDir;
+    while (true) {
+        // Check new name first
+        const ulPath = path_1.default.resolve(currentDir, exports.PROJECT_CONFIG_FILE);
+        if (fs_1.default.existsSync(ulPath))
+            return ulPath;
+        // Check legacy name
+        const ccPath = path_1.default.resolve(currentDir, LEGACY_PROJECT_CONFIG);
+        if (fs_1.default.existsSync(ccPath))
+            return ccPath;
+        const parentDir = path_1.default.dirname(currentDir);
+        if (parentDir === currentDir)
+            return null;
+        currentDir = parentDir;
+    }
+};
+exports.findProjectConfigPath = findProjectConfigPath;
+const hasProjectConfig = () => {
+    return !!(0, exports.findProjectConfigPath)();
+};
+exports.hasProjectConfig = hasProjectConfig;
+const readProjectConfig = () => {
+    const configPath = (0, exports.findProjectConfigPath)();
+    if (!configPath) {
+        throw new Error(`Project config file not found in ancestors`);
+    }
+    return JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+};
+exports.readProjectConfig = readProjectConfig;
+/** Check for ulservice.json or ccservice.json in cwd */
+const findServiceConfigPath = () => {
+    const ulPath = path_1.default.resolve(process.cwd(), exports.SERVICE_CONFIG_FILE);
+    if (fs_1.default.existsSync(ulPath))
+        return ulPath;
+    const ccPath = path_1.default.resolve(process.cwd(), LEGACY_SERVICE_CONFIG);
+    if (fs_1.default.existsSync(ccPath))
+        return ccPath;
+    return null;
+};
+exports.findServiceConfigPath = findServiceConfigPath;
+const hasServiceConfig = () => {
+    return !!(0, exports.findServiceConfigPath)();
+};
+exports.hasServiceConfig = hasServiceConfig;
+const readServiceConfig = () => {
+    const configPath = (0, exports.findServiceConfigPath)();
+    if (!configPath) {
+        throw new Error(`Service config file not found in current directory`);
+    }
+    return JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+};
+exports.readServiceConfig = readServiceConfig;
+const writeProjectConfig = (config) => {
+    const configPath = path_1.default.resolve(process.cwd(), exports.PROJECT_CONFIG_FILE);
+    fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+};
+exports.writeProjectConfig = writeProjectConfig;
+const writeServiceConfig = (config) => {
+    const configPath = path_1.default.resolve(process.cwd(), exports.SERVICE_CONFIG_FILE);
+    fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+};
+exports.writeServiceConfig = writeServiceConfig;

package/package.json

@@ -0,0 +1,40 @@
+{
+    "name": "@underlingscloud/cli",
+    "version": "0.1.0",
+    "description": "Underlings Developer Utilities CLI",
+    "main": "dist/index.js",
+    "bin": {
+        "underlings": "dist/index.js"
+    },
+    "scripts": {
+        "build": "tsc",
+        "dev": "tsx src/index.ts"
+    },
+    "dependencies": {
+        "axios": "^1.6.0",
+        "chalk": "^4.1.2",
+        "commander": "^11.1.0",
+        "conf": "^10.2.0",
+        "cross-spawn": "^7.0.3",
+        "open": "^9.1.0",
+        "prompts": "^2.4.2"
+    },
+    "devDependencies": {
+        "@types/cross-spawn": "^6.0.6",
+        "@types/prompts": "^2.4.9",
+        "typescript": "^5.0.0",
+        "tsx": "^4.0.0"
+    },
+    "files": [
+        "dist"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/underlings/ul-mono.git",
+        "directory": "packages/cli"
+    },
+    "license": "MIT"
+}