@heyputer/shell 2.1.0

package/src/commands/init.js

@@ -0,0 +1,322 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { generateAppName, getDefaultHomePage } from '../commons.js';
+import { getProfileModule } from '../modules/ProfileModule.js';
+
+const JS_BUNDLERS = ['Vite', 'Webpack', 'Parcel', 'esbuild', 'Farm'];
+const FULLSTACK_FRAMEWORKS = ['Next', 'Nuxt', 'SvelteKit', 'Astro'];
+const JS_LIBRARIES = ['React', 'Vue', 'Angular', 'Svelte', 'jQuery'];
+const CSS_LIBRARIES = ['Bootstrap', 'Bulma', 'shadcn', 'Tailwind', 'Material-UI', 'Semantic UI', 'AntDesign', 'Element-Plus', 'PostCSS', 'AutoPrefixer'];
+
+export async function init() {
+  const profileModule = getProfileModule();
+  await profileModule.checkLogin();
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'What is your app name?',
+      default: `${generateAppName()}`
+    },
+    {
+      type: 'list',
+      name: 'useBundler',
+      message: 'Do you want to use a JavaScript bundler?',
+      choices: ['Yes', 'No (Use CDN)']
+    }
+  ]);
+
+  let jsFiles = [];
+  let jsDevFiles = [];
+  let cssFiles = [];
+  let jsExtraLibraries = [];
+  let extraFiles = [];
+  let bundlerAnswers = null;
+  let frameworkAnswers = null;
+
+  if (answers.useBundler === 'Yes') {
+    bundlerAnswers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'bundler',
+        message: 'Select a JavaScript bundler:',
+        choices: JS_BUNDLERS
+      },
+      {
+        type: 'list',
+        name: 'frameworkType',
+        message: 'Do you want to use a full-stack framework or custom libraries?',
+        choices: ['Full-stack framework', 'Custom libraries']
+      }
+    ]);
+
+    if (bundlerAnswers.frameworkType === 'Full-stack framework') {
+      frameworkAnswers = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'framework',
+          message: 'Select a full-stack framework:',
+          choices: FULLSTACK_FRAMEWORKS
+        }
+      ]);
+
+      switch (frameworkAnswers.framework) {
+        case FULLSTACK_FRAMEWORKS[0]:
+          jsFiles.push('next@latest');
+          extraFiles.push({
+            path: 'src/index.tsx',
+            content: `export default function Home() { return (<h1>${answers.name}</h1>) }`
+          });
+          break;
+        case FULLSTACK_FRAMEWORKS[1]:
+          jsFiles.push('nuxt@latest');
+          extraFiles.push({
+            path: 'src/app.vue',
+            content: `<template><h1>${answers.name}</h1></template>`
+          });
+          break;
+        case FULLSTACK_FRAMEWORKS[2]:
+            jsFiles.push('svelte@latest', 'sveltekit@latest');
+            extraFiles.push({
+              path: 'src/app.vue',
+              content: `<template><h1>${answers.name}</h1></template>`
+            });
+            break;
+        case FULLSTACK_FRAMEWORKS[3]:
+              jsFiles.push('astro@latest', 'astro@latest');
+              extraFiles.push({
+                path: 'src/pages/index.astro',
+                content: `---\n\n<Layout title="Welcome to ${answers.name}."><h1>${answers.name}</h1></Layout>`
+              });
+          break;
+      }
+    } else {
+      const libraryAnswers = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'library',
+          message: 'Select a JavaScript library/framework:',
+          choices: JS_LIBRARIES
+        }
+      ]);
+
+      switch (libraryAnswers.library) {
+        case JS_LIBRARIES[0]:
+          jsFiles.push('react@latest', 'react-dom@latest');
+          const reactLibs = await inquirer.prompt([
+            {
+              type: 'checkbox',
+              name: 'reactLibraries',
+              message: 'Select React libraries:',
+              choices: CSS_LIBRARIES.concat(['react-router-dom', 'react-redux', 'react-bootstrap', '@chakra-ui/react', 'semantic-ui-react'])
+            }
+          ]);
+          jsFiles.push(...reactLibs.reactLibraries);
+          extraFiles.push({
+            path: 'src/App.jsx',
+            content: `export default function Home() { return (<h1>${answers.name}</h1>) }`
+          });
+          break;
+        case JS_LIBRARIES[1]:
+          jsFiles.push('vue@latest');
+          jsDevFiles.push('@vitejs/plugin-vue');
+          const vueLibs = await inquirer.prompt([
+            {
+              type: 'checkbox',
+              name: 'vueLibraries',
+              message: 'Select Vue libraries:',
+              choices: CSS_LIBRARIES.concat(['shadcn-vue', 'UnoCSS', 'NaiveUI', 'bootstrap-vue-next', 'buefy', 'vue-router', 'pinia'])
+            }
+          ]);
+          jsFiles.push(...vueLibs.vueLibraries);
+          extraFiles.push(
+            {
+            path: 'src/App.vue',
+            content: `<template><h1>${answers.name}</h1></template>`
+            },
+            {
+            path: 'vite.config.js',
+            content: `import { defineConfig } from 'vite';
+import vue from '@vitejs/plugin-vue';
+
+export default defineConfig({
+  plugins: [vue()]
+})
+`},
+            {
+            path: 'main.js',
+            content: `import { createApp } from 'vue'
+import './style.css';
+import App from './App.vue';
+
+const app = createApp(App);
+app.mount('#app');
+            `},
+          );
+          break;
+        case JS_LIBRARIES[2]:
+          jsFiles.push('@angular/core@latest');
+          extraFiles.push({
+            path: 'src/index.controller.js',
+            content: `(function () { angular.module('app', [])})`
+          });
+          break;
+        case JS_LIBRARIES[3]:
+          jsFiles.push('svelte@latest');
+          break;
+        case JS_LIBRARIES[4]:
+          jsFiles.push('jquery@latest');
+          extraFiles.push({
+            path: 'src/main.js',
+            content: `$(function(){})`
+          });
+          break;
+      }
+    }
+  } else {
+
+    const cdnAnswers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'jsFramework',
+        message: 'Select a JavaScript framework/library (CDN):',
+        choices: JS_LIBRARIES
+      },
+      {
+        type: 'list',
+        name: 'cssFramework',
+        message: 'Select a CSS framework/library (CDN):',
+        choices: CSS_LIBRARIES //'Tailwind', 'Bootstrap', 'Bulma'...
+      }
+    ]);
+
+    switch (cdnAnswers.jsFramework) {
+      case JS_LIBRARIES[0]:
+        jsFiles.push('https://unpkg.com/react@latest/umd/react.production.min.js');
+        jsFiles.push('https://unpkg.com/react-dom@latest/umd/react-dom.production.min.js');
+        break;
+      case JS_LIBRARIES[1]:
+        jsFiles.push('https://unpkg.com/vue@latest/dist/vue.global.js');
+        break;
+      case JS_LIBRARIES[2]:
+        jsFiles.push('https://unpkg.com/@angular/core@latest/bundles/core.umd.js');
+        break;
+      case JS_LIBRARIES[3]:
+        jsFiles.push('https://unpkg.com/svelte@latest/compiled/svelte.js');
+        break;
+      case JS_LIBRARIES[4]:
+        jsFiles.push('https://code.jquery.com/jquery-latest.min.js');
+        break;
+    }
+
+    switch (cdnAnswers.cssFramework) {
+      case CSS_LIBRARIES[0]:
+        cssFiles.push('https://cdn.jsdelivr.net/npm/bootstrap@latest/dist/css/bootstrap.min.css');
+        break;
+        case CSS_LIBRARIES[1]:
+          cssFiles.push('https://cdn.jsdelivr.net/npm/bulma@latest/css/bulma.min.css');
+          break;
+      case CSS_LIBRARIES[2]:
+        cssFiles.push('https://cdn.tailwindcss.com');
+        break;
+    }    
+  }
+
+  
+  const spinner = ora('Creating Puter app...').start();
+
+  try {
+    const useBundler = answers.useBundler === 'Yes';
+    // Create basic app structure
+    await createAppStructure(answers.name, useBundler, bundlerAnswers, frameworkAnswers, jsFiles, jsDevFiles, cssFiles, extraFiles);
+    spinner.succeed(chalk.green('Successfully created Puter app!'));
+
+    console.log('\nNext steps:');
+    console.log(chalk.cyan('1. cd'), answers.name);
+    if (useBundler) {
+      console.log(chalk.cyan('2. npm install'));
+      console.log(chalk.cyan('3. npm start'));
+    } else {
+      console.log(chalk.cyan('2. Open index.html in your browser'));
+    }
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to create app'));
+    console.error(error);
+  }
+}
+
+async function createAppStructure(name, useBundler, bundlerAnswers, frameworkAnswers, jsFiles, jsDevFiles, cssFiles, extraFiles) {
+  // Create project directory
+  await fs.mkdir(name, { recursive: true });
+
+  // Generate default home page
+  const homePage = useBundler?getDefaultHomePage(name): getDefaultHomePage(name, jsFiles, cssFiles);
+
+  // Create basic files
+  const files = {
+    '.env': `APP_NAME=${name}\nPUTER_API_KEY=`,
+    'index.html': homePage,
+    'styles.css': `body {
+    font-family: 'Segoe UI', Roboto, sans-serif;
+    margin: 0 auto;
+    padding: 10px;
+  }`,
+    '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);
+  }
+
+  // If using a bundler, create a package.json
+  // if (jsFiles.some(file => !file.startsWith('http'))) {
+  if (useBundler) {
+
+    const useFullStackFramework = bundlerAnswers.frameworkType === 'Full-stack framework';
+    const bundler = bundlerAnswers.bundler.toString().toLowerCase();
+    const framework = useFullStackFramework?frameworkAnswers.framework.toLowerCase():null;
+
+    const scripts = {
+      start: `${useFullStackFramework?`${framework} dev`:bundler} dev`,
+      build: `${useFullStackFramework?`${framework} build`:bundler} build`,
+    };
+    
+    const packageJson = {
+      name: name,
+      version: '1.0.0',
+      type: 'module',
+      scripts,
+      dependencies: {},
+      devDependencies: {}
+    };
+
+    
+    jsFiles.forEach(lib => {
+      if (!lib.startsWith('http')) {
+        packageJson.dependencies[lib.split('@')[0].toString().toLowerCase()] = lib.split('@')[1] || 'latest';
+      }
+    });
+
+    jsDevFiles.forEach(lib => {
+      packageJson.devDependencies[lib] = 'latest';
+    });
+
+    packageJson.devDependencies[bundler] = 'latest';
+
+    await fs.writeFile(path.join(name, 'package.json'), JSON.stringify(packageJson, null, 2));
+
+    extraFiles.forEach(async (extraFile) => {
+      const fullPath = path.join(name, extraFile.path);
+      // Create directories recursively if they don't exist
+      await fs.mkdir(path.dirname(fullPath), { recursive: true });
+      await fs.writeFile(fullPath, extraFile.content);
+    });
+
+  }
+}

package/src/commands/shell.js

@@ -0,0 +1,61 @@
+import readline from 'node:readline';
+import chalk from 'chalk';
+import Conf from 'conf';
+import { execCommand, getPrompt } from '../executor.js';
+import { PROJECT_NAME } from '../commons.js';
+import { getProfileModule } from '../modules/ProfileModule.js';
+
+const config = new Conf({ projectName: PROJECT_NAME });
+
+export let rl;
+
+/**
+ * Update the current shell prompt
+ */
+export function updatePrompt(currentPath) {
+  config.set('cwd', currentPath);
+  rl.setPrompt(getPrompt());
+}
+
+/**
+ * Start the interactive shell
+ */
+export async function startShell(command) {
+  const profileModule = getProfileModule();
+  await profileModule.checkLogin();
+
+  // This argument enables the `puter <subcommand>` commands
+  if (command) {
+    await execCommand(command);
+    process.exit(0);
+  }
+
+  rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: null
+  })
+
+  try {
+    console.log(chalk.green('Welcome to Puter-CLI! Type "help" for available commands.'));
+    rl.setPrompt(getPrompt());
+    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/src/commands/sites.js

@@ -0,0 +1,169 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { getCurrentUserName, getCurrentDirectory } from './auth.js';
+import { resolveRemotePath, isValidAppName } from '../commons.js';
+import { displayNonNullValues, formatDate, isValidAppUuid } from '../utils.js';
+import { getSubdomains, createSubdomain, deleteSubdomain, updateSubdomain } from './subdomains.js';
+import { getPuter } from '../modules/PuterModule.js';
+import { report } from '../modules/ErrorModule.js';
+
+/**
+ * Listing subdomains
+ */
+export async function listSites(args = {}) {
+    try {
+      const result = await getSubdomains(args);
+  
+      // 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;
+      result.forEach(domain => {
+        let appDir = domain?.root_dir?.path.split('/').pop().split('-');
+        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'],
+          appDir && (isValidAppUuid(appDir.join('-'))?`${appDir[0]}-...-${appDir.slice(-1)}`:appDir.join('-'))
+        ]);
+      });
+  
+      // Print table
+      if (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: ${result.length}`));
+      }
+  
+    } catch (error) {
+      report(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;
+    }
+    const puter = getPuter();
+    for (const subdomain of args)
+      try {
+        const result = await puter.hosting.get(subdomain);
+        displayNonNullValues(result);
+      } catch (error) {
+        console.error(chalk.red('Error getting site info:'), error.message);
+      }
+  }
+  
+ /**
+  * Delete hosted web site
+  * @param {any[]} args Array of subdomain
+  */
+  export async function deleteSite(args = []) {
+    if (args.length < 1){
+        console.log(chalk.red('Usage: site:delete <subdomain>'));
+        return false;
+    }
+    await deleteSubdomain(args);
+    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
+    const remoteDirArg = (args[1] && !args[1].startsWith('--')) ? args[1] : '.';
+    
+    // Use the current directory as the root directory if none specified
+    const remoteDir = resolveRemotePath(getCurrentDirectory(), remoteDirArg);
+  
+    console.log(chalk.dim(`Creating site ${chalk.green(appName)} from: ${chalk.green(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 subdomains = await getSubdomains();;
+        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(`Updating this subdomain directory...`));
+                    const result = await updateSubdomain(subdomain, remoteDir);
+                    if (result) {
+                        console.log(chalk.green('Updating subdomain directory successful.'));
+                        return;
+                    } else {
+                        console.log(chalk.red('Could not update this subdomain directory.'));
+                        return;
+                    }
+                }
+            }
+        } 
+            
+        // Use the chosen "subdomain"
+        console.log(chalk.cyan(`New generated subdomain: "${subdomain}" will be used if its not already in use.`));
+
+        // Step 3: Host the current directory under the subdomain
+        console.log(chalk.cyan(`Hosting site "${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(`Site ${chalk.dim(appName)} created successfully and accessible at:`));
+        console.log(chalk.cyan(`https://${site.subdomain}.puter.site`));
+        return site;
+    } catch (error) {
+        console.error(chalk.red('Failed to create site.'));
+        console.error(chalk.red(`Error: ${error.message}`));
+        return null;
+    }
+  }

package/src/commands/subdomains.js

@@ -0,0 +1,95 @@
+import chalk from 'chalk';
+import fetch from 'node-fetch';
+import { API_BASE, getHeaders } from '../commons.js';
+import { getPuter } from '../modules/PuterModule.js';
+
+/**
+ * Get list of subdomains.
+ * @param {Object} args - Options for the query.
+ * @returns {Array} - Array of subdomains.
+ */
+export async function getSubdomains(args = {}) {
+    const puter = getPuter();
+    let result;
+
+    try {
+        result = await puter.hosting.list();    
+    } catch (error) {
+        console.log(chalk.red(`Error when getting subdomains.\nError: ${error?.message}`));
+    }
+
+    return result;
+}
+
+/**
+ * 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 puter = getPuter();
+    const subdomains = args;
+    for (const subdomain of subdomains)
+        try {
+        const success = await puter.hosting.delete(subdomain);
+    
+        if (!success) {
+            console.log(chalk.red(`Failed to delete subdomain: ${data.error?.message}`));
+            return false;
+        }
+        console.log(chalk.green('Subdomain deleted successfully'));
+        } catch (error) {
+            if (error.error?.code === 'entity_not_found') {
+                console.log(chalk.red(`Subdomain: "${subdomain}" not found`));
+                return false;
+            }
+            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 puter = getPuter();
+    let result;
+
+    try {
+        result = await puter.hosting.create(subdomain, remoteDir);
+    } catch (error) {
+        if (error?.error?.code === 'already_in_use') {
+            console.log(chalk.yellow(`Subdomain already taken!\nMessage: ${error?.error?.message}`));
+            return false;
+        }
+        console.log(chalk.red(`Error when creating "${subdomain}".\nError: ${error?.error?.message}\nCode: ${error?.error?.code}`));
+    }
+    return result;
+}
+
+/**
+ * Update a 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 updateSubdomain(subdomain, remoteDir) {
+    const puter = getPuter();
+    let result;
+
+    try {
+        result = await puter.hosting.update(subdomain, remoteDir);
+    } catch (error) {
+        console.log(chalk.red(`Error when updating "${subdomain}".\nError: ${error?.message}`));
+        return null;
+    }
+
+    return result;
+}