npm - puter-cli - Versions diffs - 1.0.0 - Mend

puter-cli 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/commands/init.js ADDED Viewed

@@ -0,0 +1,67 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { generateAppName } from './commons.js';
+export async function init() {
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'What is your app name?',
+      default: `${generateAppName()}`
+    },
+    {
+      type: 'list',
+      name: 'template',
+      message: 'Select a template:',
+      choices: ['basic', 'static-site', 'full-stack']
+    }
+  ]);
+  const spinner = ora('Creating Puter app...').start();
+  try {
+    // Create basic app structure
+    await createAppStructure(answers);
+    spinner.succeed(chalk.green('Successfully created Puter app!'));
+    console.log('\nNext steps:');
+    console.log(chalk.cyan('1. cd'), answers.name);
+    console.log(chalk.cyan('2. npm install'));
+    console.log(chalk.cyan('3. npm start'));
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to create app'));
+    console.error(error);
+  }
+}
+async function createAppStructure({ name, template }) {
+  // Create project directory
+  await fs.mkdir(name, { recursive: true });
+  // Create basic files
+  const files = {
+    '.env': `APP_NAME=${name}\PUTER_API_KEY=`,
+    'index.html': `<!DOCTYPE html>
+<html>
+<head>
+    <title>${name}</title>
+</head>
+<body>
+    <h1>Welcome to ${name}</h1>
+    <script src="https://js.puter.com/v2/"></script>
+    <script src="app.js"></script>
+</body>
+</html>`,
+    'app.js': `// Initialize Puter app
+console.log('Puter app initialized!');`,
+    'README.md': `# ${name}\n\nA Puter app created with puter-cli`
+  };
+  for (const [filename, content] of Object.entries(files)) {
+    await fs.writeFile(path.join(name, filename), content);
+  }
+}

package/commands/shell.js ADDED Viewed

@@ -0,0 +1,56 @@
+import readline from 'node:readline';
+import chalk from 'chalk';
+import Conf from 'conf';
+import { execCommand, getPrompt } from './executor.js';
+import { getAuthToken } from './auth.js';
+import { PROJECT_NAME } from './commons.js';
+const config = new Conf({ projectName: PROJECT_NAME });
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  prompt: null
+});
+/**
+ * Update the current shell prompt
+ */
+export function updatePrompt(currentPath) {
+  config.set('cwd', currentPath);
+  rl.setPrompt(getPrompt());
+}
+/**
+ * Start the interactive shell
+ */
+export function startShell() {
+  if (!getAuthToken()) {
+    console.log(chalk.red('Please login first using: puter login'));
+    process.exit(1);
+  }
+  rl.setPrompt(getPrompt());
+  try {
+    console.log(chalk.green('Welcome to Puter-CLI! Type "help" for available commands.'));
+    rl.prompt();
+    rl.on('line', async (line) => {
+      const trimmedLine = line.trim();
+      if (trimmedLine) {
+        try {
+          await execCommand(trimmedLine);
+        } catch (error) {
+          console.error(chalk.red(error.message));
+        }
+      }
+      rl.prompt();
+    }).on('close', () => {
+      console.log(chalk.yellow('\nGoodbye!'));
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error(chalk.red('Error starting shell:', error));
+  }
+}

package/commands/sites.js ADDED Viewed

@@ -0,0 +1,214 @@
+import chalk from 'chalk';
+import fetch from 'node-fetch';
+import Table from 'cli-table3';
+import { getCurrentUserName, getCurrentDirectory } from './auth.js';
+import { API_BASE, getHeaders, generateAppName, resolvePath, isValidAppName } from './commons.js';
+import { displayNonNullValues, formatDate, formatDateTime } from './utils.js';
+import { getSubdomains, createSubdomain, deleteSubdomain } from './subdomains.js';
+/**
+ * Listing subdomains
+ */
+export async function listSites(args = {}) {
+    try {
+      const data = await getSubdomains(args);
+      if (!data.success || !Array.isArray(data.result)) {
+        throw new Error('Failed to fetch subdomains');
+      }
+      // Create table instance
+      const table = new Table({
+        head: [
+          chalk.cyan('#'),
+          chalk.cyan('UID'),
+          chalk.cyan('Subdomain'),
+          chalk.cyan('Created'),
+          chalk.cyan('Protected'),
+        //   chalk.cyan('Owner'),
+          chalk.cyan('Directory')
+        ],
+        wordWrap: false
+      });
+      // Format and add data to table
+      let i = 0;
+      data.result.forEach(domain => {
+        table.push([
+          i++,
+          domain.uid,
+          chalk.green(`${chalk.dim(domain.subdomain)}.puter.site`),
+          formatDate(domain.created_at).split(',')[0],
+          domain.protected ? chalk.red('Yes') : chalk.green('No'),
+        //   domain.owner['username'],
+          domain?.root_dir?.path.split('/').pop()
+        ]);
+      });
+      // Print table
+      if (data.result.length === 0) {
+        console.log(chalk.yellow('No subdomains found'));
+      } else {
+        console.log(chalk.bold('\nYour Sites:'));
+        console.log(table.toString());
+        console.log(chalk.dim(`Total Sites: ${data.result.length}`));
+      }
+    } catch (error) {
+      console.error(chalk.red('Error listing sites:'), error.message);
+      throw error;
+    }
+}
+/**
+ * Get Site info
+ * @param {any[]} args Array of site uuid
+ */
+export async function infoSite(args = []) {
+    if (args.length < 1){
+        console.log(chalk.red('Usage: site <siteUID>'));
+        return;
+    }
+    for (const subdomainId of args)
+      try {
+        const response = await fetch(`${API_BASE}/drivers/call`, {
+          method: 'POST',
+          headers: getHeaders(),
+          body: JSON.stringify({
+              interface: 'puter-subdomains',
+              method: 'read',
+              args: { uid: subdomainId }
+          })
+        });
+        if (!response.ok) {
+            throw new Error('Failed to fetch subdomains.');
+        }
+        const data = await response.json();
+        if (!data.success || !data.result) {
+          throw new Error(`Failed to get site info: ${data.error?.message}`);
+        }
+        displayNonNullValues(data.result);
+      } catch (error) {
+        console.error(chalk.red('Error getting site info:'), error.message);
+      }
+  }
+  /**
+  * Delete hosted web site
+  * @param {any[]} args Array of site uuid
+  */
+  export async function deleteSite(args = []) {
+    if (args.length < 1){
+        console.log(chalk.red('Usage: site:delete <siteUUID>'));
+        return false;
+    }
+    for (const uuid of args)
+        try {
+        // The uuid must be prefixed with: 'subdomainObj-'
+        const response = await fetch(`${API_BASE}/delete-site`, {
+            headers: getHeaders(),
+            method: 'POST',
+            body: JSON.stringify({
+                site_uuid: uuid
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to delete site (Status: ${response.status})`);
+        }
+        const data = await response.json();
+        const result = await deleteSubdomain(uuid);
+        if (result){
+            // check if data is empty object
+            if (Object.keys(data).length === 0){
+                console.log(chalk.green(`Site ID: "${uuid}" should be deleted.`));
+            }
+        }
+        console.log(chalk.yellow(`Site ID: "${uuid}" may already be deleted!`));
+    } catch (error) {
+        console.error(chalk.red('Error deleting site:'), error.message);
+        return false;
+    }
+    return true;
+  }
+  /**
+  * Create a static web app from the current directory to Puter cloud.
+  * @param {string[]} args - Command-line arguments (e.g., [name, --subdomain=<subdomain>]).
+  */
+  export async function createSite(args = []) {
+    if (args.length < 1 || !isValidAppName(args[0])) {
+        console.log(chalk.red('Usage: site:create <valid_name_app> [<remote_dir>] [--subdomain=<subdomain>]'));
+        console.log(chalk.yellow('Example: site:create mysite'));
+        console.log(chalk.yellow('Example: site:create mysite ./mysite'));
+        console.log(chalk.yellow('Example: site:create mysite --subdomain=mysite'));
+        return;
+    }
+    const appName = args[0]; // Site name (required)
+    const subdomainOption = args.find(arg => arg.toLocaleLowerCase().startsWith('--subdomain='))?.split('=')[1]; // Optional subdomain
+    // Use the current directory as the root directory if none specified
+    const remoteDir = resolvePath(getCurrentDirectory(), (args[1] && !args[1].startsWith('--'))?args[1]:'.');
+    console.log(chalk.green(`Creating site "${appName}" from "${remoteDir}"...\n`));
+    try {
+        // Step 1: Determine the subdomain
+        let subdomain;
+        if (subdomainOption) {
+            subdomain = subdomainOption; // Use the provided subdomain
+        } else {
+            subdomain = appName; // Default to the app name as the subdomain
+        }
+        // Step 2: Check if the subdomain already exists
+        const data = await getSubdomains();
+        if (!data.success || !Array.isArray(data.result)) {
+          throw new Error('Failed to fetch subdomains');
+        }
+        const subdomains = data.result;
+        const subdomainObj = subdomains.find(sd => sd.subdomain === subdomain);
+        if (subdomainObj) {
+            console.error(chalk.cyan(`The subdomain "${subdomain}" is already in use and owned by: "${subdomainObj.owner['username']}"`));
+            if (subdomainObj.owner['username'] === getCurrentUserName()){
+                console.log(chalk.green(`It's yours, and linked to: ${subdomainObj.root_dir?.path}`));
+                if (subdomainObj.root_dir?.path === remoteDir){
+                    console.log(chalk.cyan(`Which is already the selected directory, and created at:`));
+                    console.log(chalk.green(`https://${subdomain}.puter.site`));
+                    return;
+                } else {
+                    console.log(chalk.yellow(`However, It's linked to different directory at: ${subdomainObj.root_dir?.path}`));
+                    console.log(chalk.cyan(`We'll try to unlink this subdomain from that directory...`));
+                    const result = await deleteSubdomain(subdomainObj.uid);
+                    if (result) {
+                        console.log(chalk.green('Looks like this subdomain is free again, please try again.'));
+                        return;
+                    } else {
+                        console.log(chalk.red('Could not release this subdomain.'));
+                    }
+                }
+            }
+        } else {
+            console.log(chalk.yellow(`The subdomain: "${subdomain}" is already taken, so let's generate a new random one:`));
+            subdomain = generateAppName(); // Generate a random subdomain
+            console.log(chalk.cyan(`New generated subdomain: "${subdomain}" will be used.`));
+        }
+        // Step 3: Host the current directory under the subdomain
+        console.log(chalk.cyan(`Hosting app "${appName}" under subdomain "${subdomain}"...`));
+        const site = await createSubdomain(subdomain, remoteDir);
+        if (!site){
+            console.error(chalk.red(`Failed to create subdomain: "${chalk.red(subdomain)}"`));
+            return;
+        }
+        console.log(chalk.green(`App "${chalk.red(appName)}" created successfully at:`));
+        console.log(chalk.dim(`https://${site.subdomain}.puter.site`));
+    } catch (error) {
+        console.error(chalk.red('Failed to create site.'));
+        console.error(chalk.red(`Error: ${error.message}`));
+    }
+  }

package/commands/subdomains.js ADDED Viewed

@@ -0,0 +1,103 @@
+import chalk from 'chalk';
+import fetch from 'node-fetch';
+import { API_BASE, getHeaders } from './commons.js';
+/**
+ * Get list of subdomains.
+ * @param {Object} args - Options for the query.
+ * @returns {Array} - Array of subdomains.
+ */
+export async function getSubdomains(args = {}) {
+    const response = await fetch(`${API_BASE}/drivers/call`, {
+        method: 'POST',
+        headers: getHeaders(),
+        body: JSON.stringify({
+            interface: 'puter-subdomains',
+            method: 'select',
+            args: args
+        })
+    });
+    if (!response.ok) {
+        throw new Error('Failed to fetch subdomains.');
+    }
+    return await response.json();
+}
+/**
+ * Delete a subdomain by id
+ * @param {Array} subdomain IDs
+ * @return {boolean} Result of the operation
+ */
+export async function deleteSubdomain(args = []) {
+    if (args.length < 1){
+        console.log(chalk.red('Usage: domain:delete <subdomain_id>'));
+        return false;
+    }
+    const subdomains = args;
+    for (const subdomainId of subdomains)
+        try {
+        const response = await fetch(`${API_BASE}/drivers/call`, {
+            headers: getHeaders(),
+            method: 'POST',
+            body: JSON.stringify({
+            interface: 'puter-subdomains',
+            method: 'delete',
+            args: {
+                id: { subdomain: subdomainId }
+            }
+            })
+        });
+        const data = await response.json();
+        if (!data.success) {
+            if (data.error?.code === 'entity_not_found') {
+                console.log(chalk.red(`Subdomain ID: "${subdomainId}" not found`));
+                return false;
+            }
+            console.log(chalk.red(`Failed to delete subdomain: ${data.error?.message}`));
+            return false;
+        }
+        console.log(chalk.green('Subdomain deleted successfully'));
+        } catch (error) {
+            console.error(chalk.red('Error deleting subdomain:'), error.message);
+        }
+        return true;
+}
+/**
+ * Create a new subdomain into remote directory
+ * @param {string} subdomain - Subdomain name.
+ * @param {string} remoteDir - Remote directory path.
+ * @returns {Object} - Hosting details (e.g., subdomain).
+ */
+export async function createSubdomain(subdomain, remoteDir) {
+    const response = await fetch(`${API_BASE}/drivers/call`, {
+        method: 'POST',
+        headers: getHeaders(),
+        body: JSON.stringify({
+            interface: 'puter-subdomains',
+            method: 'create',
+            args: {
+                object: {
+                    subdomain: subdomain,
+                    root_dir: remoteDir
+                }
+            }
+        })
+    });
+    if (!response.ok) {
+        throw new Error('Failed to host directory.');
+    }
+    const data = await response.json();
+    if (!data.success || !data.result) {
+        if (data.error?.code === 'already_in_use') {
+            console.log(chalk.yellow(`Subdomain already taken!\nMessage: ${data?.error?.message}`));
+            return false;
+        }
+        console.log(chalk.red(`Error when creating "${subdomain}".\nError: ${data?.error?.message}\nCode: ${data.error?.code}`));
+        return false;
+    }
+    return data.result;
+}

package/commands/utils.js ADDED Viewed

@@ -0,0 +1,92 @@
+import chalk from 'chalk';
+/**
+ * Convert "2024-10-07T15:03:53.000Z" to "10/7/2024, 15:03:53"
+ * @param {Date} value date value
+ * @returns formatted date string
+ */
+export function formatDate(value) {
+    const date = new Date(value);
+    return date.toLocaleString("en-US", {
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false
+    });
+}
+/**
+ * Format timestamp to date or time
+ * @param {number} timestamp value
+ * @returns string
+ */
+export function formatDateTime(timestamp) {
+    const date = new Date(timestamp * 1000); // Convert to milliseconds
+    const now = new Date();
+    const diff = now - date;
+    if (diff < 86400000) { // Less than 24 hours
+        return date.toLocaleTimeString();
+    } else {
+        return date.toLocaleDateString();
+    }
+}
+/**
+ * Format file size in human readable format
+ * @param {number} size File size value
+ * @returns string formatted in human readable format
+ */
+export function formatSize(size) {
+    if (size === null || size === undefined) return '0';
+    if (size === 0) return '0';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    let unit = 0;
+    while (size >= 1024 && unit < units.length - 1) {
+        size /= 1024;
+        unit++;
+    }
+    return `${size.toFixed(1)} ${units[unit]}`;
+}
+/**
+ * Display non null values in formatted table
+ * @param {Object} data Object to display
+ * @returns null
+ */
+export function displayNonNullValues(data) {
+    if (typeof data !== 'object' || data === null) {
+      console.error("Invalid input: Input must be a non-null object.");
+      return;
+    }
+    const tableData = [];
+    function flattenObject(obj, parentKey = '') {
+      for (const key in obj) {
+        const value = obj[key];
+        const newKey = parentKey ? `${parentKey}.${key}` : key;
+        if (value !== null) {
+          if (typeof value === 'object') {
+            flattenObject(value, newKey);
+          } else {
+            tableData.push({ key: newKey, value: value });
+          }
+        }
+      }
+    }
+    flattenObject(data);
+    // Determine max key length for formatting
+    const maxKeyLength = tableData.reduce((max, item) => Math.max(max, item.key.length), 0);
+    // Format and output the table
+    console.log(chalk.cyan('-'.repeat(maxKeyLength*3)));
+    console.log(chalk.cyan(`| ${'Key'.padEnd(maxKeyLength)} | Value`));
+    console.log(chalk.cyan('-'.repeat(maxKeyLength*3)));
+    tableData.forEach(item => {
+        const key = item.key.padEnd(maxKeyLength);
+        const value = String(item.value);
+        console.log(chalk.green(`| ${chalk.dim(key)} | ${value}`));
+    });
+    console.log(chalk.cyan('-'.repeat(maxKeyLength*3)));
+    console.log(chalk.cyan(`You have ${chalk.green(tableData.length)} key/value pair(s).`));
+  }

package/package.json ADDED Viewed

@@ -0,0 +1,37 @@
+{
+  "name": "puter-cli",
+  "version": "1.0.0",
+  "description": "Command line interface for Puter cloud platform",
+  "main": "index.js",
+  "bin": {
+    "puter": "./bin/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "start": "node bin/index.js",
+    "test": "vitest run tests/*",
+    "test:watch": "vitest --watch tests/*"
+  },
+  "keywords": [
+    "puter",
+    "cli",
+    "cloud"
+  ],
+  "author": "Ibrahim.H",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "cli-table3": "^0.6.5",
+    "commander": "^11.1.0",
+    "conf": "^12.0.0",
+    "cross-spawn": "^7.0.3",
+    "glob": "^11.0.0",
+    "inquirer": "^9.2.12",
+    "minimatch": "^10.0.1",
+    "node-fetch": "^3.3.2",
+    "ora": "^8.0.1"
+  },
+  "devDependencies": {
+    "vitest": "^2.1.8"
+  }
+}