@rancher/create-extension 0.1.0

package/app/app.package.json

@@ -0,0 +1,14 @@
+{
+  "name": "NAME",
+  "version": "0.1.0",
+  "private": false,
+  "engines": {
+    "node": ">=12"
+  },
+  "dependencies": {},
+  "resolutions": {
+    "**/webpack": "4",
+    "@types/node": "^16",
+    "glob": "7.2.3"
+  }  
+}

package/app/files/.eslintignore

@@ -0,0 +1,16 @@
+assets/fonts
+coverage
+.nyc_output
+node_modules/
+.npm
+.eslintcache
+.env
+.cache
+.next
+dist
+dist-pkg
+.DS_Store
+dynamic-importer.js
+ksconfig.json
+shell/utils/dynamic-importer.js
+shell/assets/fonts

package/app/files/.eslintrc.js

@@ -0,0 +1,175 @@
+module.exports = {
+  root: true,
+  env:  {
+    browser: true,
+    node:    true
+  },
+  globals: { NodeJS: true, Timer: true },
+  extends: [
+    'standard',
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+    '@vue/standard',
+    '@vue/typescript/recommended',
+    'plugin:vue/recommended',
+    'plugin:cypress/recommended',
+  ],
+  // add your custom rules here
+  rules: {
+    'dot-notation':             'off',
+    'generator-star-spacing':   'off',
+    'guard-for-in':             'off',
+    'linebreak-style':          'off',
+    'new-cap':                  'off',
+    'no-empty':                 'off',
+    'no-extra-boolean-cast':    'off',
+    'no-new':                   'off',
+    'no-plusplus':              'off',
+    'no-useless-escape':        'off',
+    'semi-spacing':             'off',
+    'space-in-parens':          'off',
+    strict:                     'off',
+    'unicorn/no-new-buffer':    'off',
+    'vue/html-self-closing':    'off',
+    'vue/no-unused-components': 'warn',
+    'vue/no-v-html':            'error',
+    'wrap-iife':                'off',
+
+    'array-bracket-spacing':             'warn',
+    'arrow-parens':                      'warn',
+    'arrow-spacing':                     ['warn', { before: true, after: true }],
+    'block-spacing':                     ['warn', 'always'],
+    'brace-style':                       ['warn', '1tbs'],
+    'comma-dangle':                      ['warn', 'only-multiline'],
+    'comma-spacing':                     'warn',
+    curly:                               'warn',
+    eqeqeq:                              'warn',
+    'func-call-spacing':                 ['warn', 'never'],
+    'implicit-arrow-linebreak':          'warn',
+    indent:                              ['warn', 2],
+    'keyword-spacing':                   'warn',
+    'lines-between-class-members':       ['warn', 'always', { exceptAfterSingleLine: true }],
+    'multiline-ternary':                 ['warn', 'never'],
+    'newline-per-chained-call':          ['warn', { ignoreChainWithDepth: 4 }],
+    'no-caller':                         'warn',
+    'no-cond-assign':                    ['warn', 'except-parens'],
+    'no-console':                        'warn',
+    'no-debugger':                       'warn',
+    'no-eq-null':                        'warn',
+    'no-eval':                           'warn',
+    'no-trailing-spaces':                'warn',
+    'no-undef':                          'warn',
+    'no-unused-vars':                    'warn',
+    'no-whitespace-before-property':     'warn',
+    'object-curly-spacing':              ['warn', 'always'],
+    'object-property-newline':           'warn',
+    'object-shorthand':                  'warn',
+    'padded-blocks':                     ['warn', 'never'],
+    'prefer-arrow-callback':             'warn',
+    'prefer-template':                   'warn',
+    'quote-props':                       'warn',
+    'rest-spread-spacing':               'warn',
+    semi:                                ['warn', 'always'],
+    'space-before-function-paren':       ['warn', 'never'],
+    'space-infix-ops':                   'warn',
+    'spaced-comment':                    'warn',
+    'switch-colon-spacing':              'warn',
+    'template-curly-spacing':            ['warn', 'always'],
+    'yield-star-spacing':                ['warn', 'both'],
+
+    'key-spacing':              ['warn', {
+      align: {
+        beforeColon: false,
+        afterColon:  true,
+        on:          'value',
+        mode:        'minimum'
+      },
+      multiLine: {
+        beforeColon: false,
+        afterColon:  true
+      },
+    }],
+
+    'object-curly-newline':          ['warn', {
+      ObjectExpression:  {
+        multiline:     true,
+        minProperties: 3
+      },
+      ObjectPattern:     {
+        multiline:     true,
+        minProperties: 4
+      },
+      ImportDeclaration: {
+        multiline:     true,
+        minProperties: 5
+      },
+      ExportDeclaration: {
+        multiline:     true,
+        minProperties: 3
+      }
+    }],
+
+    'padding-line-between-statements': [
+      'warn',
+      {
+        blankLine: 'always',
+        prev:      '*',
+        next:      'return',
+      },
+      {
+        blankLine: 'always',
+        prev:      'function',
+        next:      'function',
+      },
+      // This configuration would require blank lines after every sequence of variable declarations
+      {
+        blankLine: 'always',
+        prev:      ['const', 'let', 'var'],
+        next:      '*'
+      },
+      {
+        blankLine: 'any',
+        prev:      ['const', 'let', 'var'],
+        next:      ['const', 'let', 'var']
+      }
+    ],
+
+    quotes: [
+      'warn',
+      'single',
+      {
+        avoidEscape:           true,
+        allowTemplateLiterals: true
+      },
+    ],
+
+    'space-unary-ops': [
+      'warn',
+      {
+        words:    true,
+        nonwords: false,
+      }
+    ],
+
+    // FIXME: The following is disabled due to new linter and old JS code. These should all be enabled and underlying issues fixed
+    'vue/order-in-components':              'off',
+    'vue/no-lone-template':                 'off',
+    'vue/v-slot-style':                     'off',
+    'vue/component-tags-order':             'off',
+    'vue/no-mutating-props':                'off',
+    '@typescript-eslint/no-unused-vars':    'off',
+    'array-callback-return':                'off',
+  },
+  overrides: [
+    {
+      files: ['*.js'],
+      rules: {
+        // FIXME: The following is disabled due to new linter and old JS code. These should all be enabled and underlying issues fixed
+        'prefer-regex-literals':                'off',
+        'vue/component-definition-name-casing': 'off',
+        'no-unreachable-loop':                  'off',
+        'computed-property-spacing':            'off',
+      }
+    }
+  ]
+};

package/app/files/.github/workflows/build-extension-catalog.yml

@@ -0,0 +1,24 @@
+name: Build and Release Extension Catalog
+
+on:
+  workflow_dispatch:
+  release:
+    types: [released]
+
+defaults:
+  run:
+    shell: bash
+    working-directory: ./
+
+jobs:
+  build-extension-catalog:
+    uses: rancher/dashboard/.github/workflows/build-extension-catalog.yml@master
+    permissions:
+      actions: write
+      contents: read
+      packages: write
+    with:
+      registry_target: ghcr.io
+      registry_user: ${{ github.actor }}
+    secrets: 
+      registry_token: ${{ secrets.GITHUB_TOKEN }}

package/app/files/.github/workflows/build-extension-charts.yml

@@ -0,0 +1,22 @@
+name: Build and Release Extension Charts
+
+on:
+  workflow_dispatch:
+  release:
+    types: [released]
+
+defaults:
+  run:
+    shell: bash
+    working-directory: ./
+
+jobs:
+  build-extension-charts:
+    uses: rancher/dashboard/.github/workflows/build-extension-charts.yml@master
+    permissions:
+      actions: write
+      contents: write
+      deployments: write
+      pages: write
+    with:
+      target_branch: gh-pages

package/app/files/.gitignore

@@ -0,0 +1,70 @@
+# compiled output
+/dist
+/tmp
+/out-tsc
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# nyc test coverage
+.nyc_output
+
+# IDEs and editors
+.idea
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+
+# IDE - VSCode
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+# misc
+.sass-cache
+connect.lock
+typings
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+
+# System Files
+.DS_Store
+Thumbs.db

package/app/files/.gitlab-ci.yml

@@ -0,0 +1,14 @@
+image: registry.suse.com/bci/bci-base:latest
+
+stages:
+  - check_version
+  - build_catalog
+
+variables:
+  REGISTRY: $CI_REGISTRY
+  REGISTRY_USER: $CI_REGISTRY_USER
+  REGISTRY_PASSWORD: $CI_REGISTRY_PASSWORD
+  IMAGE_NAMESPACE: $CI_PROJECT_NAMESPACE/$CI_PROJECT_NAME
+
+include:
+  - remote: 'https://raw.githubusercontent.com/rancher/dashboard/master/shell/scripts/.gitlab/workflows/build-extension-catalog.gitlab-ci.yml'

package/app/files/.vscode/settings.json

@@ -0,0 +1,21 @@
+{
+  "files.exclude": {
+    ".ackrc": true,
+    ".dockerignore": true,
+    ".drone.yml": true,
+    ".editorconfig": true,
+    ".eslintcache": true,
+    ".eslintignore": true,
+    ".eslintrc.js": true,
+    ".gitignore": true,
+    ".nyc_output": true,
+    ".vscode": true,
+    "LICENSE": true,
+    "node_modules": true,
+    "babel.config.js": true,
+    "jsconfig.json": true,
+    "yarn-error.log": true,
+    "pkg/**/.shell": true,
+    "pkg/**/node_modules": true,
+  }
+}

package/app/files/babel.config.js

@@ -0,0 +1 @@
+module.exports = require('@rancher/shell/babel.config.js');

package/app/files/tsconfig.json

@@ -0,0 +1,42 @@
+{
+  "compilerOptions": {
+    "target": "ES2018",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "lib": [
+      "ESNext",
+      "ESNext.AsyncIterable",
+      "DOM"
+    ],
+    "esModuleInterop": true,
+    "allowJs": true,
+    "sourceMap": true,
+    "strict": true,
+    "noEmit": true,
+    "baseUrl": ".",
+    "paths": {
+      "~/*": [
+        "./*"
+      ],
+      "@/*": [
+        "./*"
+      ],
+      "@shell/*": [
+        "./node_modules/@rancher/shell/*"
+      ]
+    },
+    "typeRoots": [
+      "./node_modules",
+      "./node_modules/@rancher/shell/types"
+    ],    
+    "types": [
+      "@types/node",
+      "cypress",
+      "rancher",
+      "shell"
+    ]
+  },
+  "exclude": [
+    "node_modules"
+  ]
+}

package/app/files/vue.config.js

@@ -0,0 +1,6 @@
+const config = require('@rancher/shell/vue.config'); // eslint-disable-line @typescript-eslint/no-var-requires
+
+module.exports = config(__dirname, {
+  excludes: [],
+  // excludes: ['fleet', 'example']
+});

package/app/init

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs-extra');
+
+const targets = {
+  dev:   'NODE_ENV=dev ./node_modules/.bin/vue-cli-service serve',
+  build: './node_modules/.bin/vue-cli-service build',
+  clean: './node_modules/@rancher/shell/scripts/clean'
+};
+
+const files = [
+  'tsconfig.json',
+  'vue.config.js',
+  '.gitignore',
+  '.eslintignore',
+  '.eslintrc.js',
+  'babel.config.js',
+  '.vscode/settings.json'
+];
+
+console.log('');
+console.log('Creating Skeleton Application');
+
+const args = process.argv;
+let appFolder = path.resolve('.');
+
+if ( args.length > 2 ) {
+  const name = args[2];
+  const folder = path.resolve('.');
+
+  appFolder = path.join(folder, name);
+  console.log(`  Creating application folder: ${ appFolder }`);
+  fs.ensureDirSync(appFolder);
+}
+
+let addGitlabWorkflow = false;
+let addWorkflowFolder = true;
+
+// Check for Gitlab integration option
+if ( args.length > 3 ) {
+  for (let i = 3; i < args.length; i++) {
+    switch (args[i]) {
+    case '-l':
+      addGitlabWorkflow = true;
+      break;
+    case '--skip-workflow':
+    case '-w':
+      addWorkflowFolder = false;
+      break;
+    default:
+      break;
+    }
+  }
+}
+
+if ( addGitlabWorkflow ) {
+  files.push('.gitlab-ci.yml');
+}
+
+let setName = false;
+
+// Check that there is a package file
+if (!fs.existsSync(path.join(appFolder, './package.json'))) {
+  console.log('  Adding package.json');
+  fs.copySync(path.join(__dirname, 'app.package.json'), path.join(appFolder, 'package.json'));
+  setName = true;
+}
+
+const rawdata = fs.readFileSync(path.join(appFolder, 'package.json'));
+const pkg = JSON.parse(rawdata);
+
+if (!pkg.scripts) {
+  pkg.scripts = {};
+}
+
+if (setName) {
+  const dirName = path.basename(appFolder);
+
+  pkg.name = dirName;
+}
+
+Object.keys(targets).forEach((target) => {
+  if (!pkg.scripts[target]) {
+    pkg.scripts[target] = targets[target];
+    console.log(`  Adding script '${ target }' to package.json`);
+  }
+});
+
+// Add dependencies
+// Use the same shell version as this app creator
+
+const creatorPkgData = fs.readFileSync(path.join(__dirname, 'package.json'));
+const creatorPkg = JSON.parse(creatorPkgData);
+
+// Fetch the latest version of @rancher/shell
+const shellVersion = execSync('npm view @rancher/shell version').toString().trim();
+
+// Set the latest version of @rancher/shell in the dependencies
+pkg.dependencies['@rancher/shell'] = `^${ shellVersion }`;
+
+// Rest of dependencies are in the _pkgs property of package.json - copy then across
+if (creatorPkg._pkgs) {
+  Object.keys(creatorPkg._pkgs).forEach((pkgName) => {
+    pkg.dependencies[pkgName] = creatorPkg._pkgs[pkgName];
+  });
+}
+
+fs.writeFileSync(path.join(appFolder, 'package.json'), JSON.stringify(pkg, null, 2));
+
+// Add workflow folder if needed
+if ( addWorkflowFolder ) {
+  // Point to the workflow directory inside the skeleton application
+  const workflowDir = path.join(appFolder, '.github/workflows');
+
+  if ( !fs.existsSync(workflowDir) ) {
+    console.log('  Creating folder: .github/workflows');
+    fs.mkdirSync(workflowDir, { recursive: true });
+  }
+
+  const workflowFiles = [
+    'build-extension-catalog.yml',
+    'build-extension-charts.yml'
+  ];
+
+  workflowFiles.forEach((fileName) => {
+    const dest = path.join(workflowDir, fileName); // Destination in the skeleton application
+    const src = path.join(__dirname, 'files/.github/workflows', fileName); // Source in the package
+
+    if ( !fs.existsSync(dest) ) {
+      console.log(`  Adding file ${ fileName } to root workflows`);
+      fs.copySync(src, dest);
+    }
+  });
+}
+
+// Copy base files
+files.forEach((file) => {
+  const src = path.join(__dirname, 'files', file);
+  const dest = path.join(appFolder, file);
+
+  if (!fs.existsSync(dest)) {
+    console.log(`  Adding file: ${ file }`);
+
+    const folder = path.dirname(dest);
+
+    fs.ensureDirSync(folder);
+
+    // Create the folder if needed
+    fs.copySync(src, dest);
+  }
+});
+
+console.log('Skeleton Application creation complete.\n');
+
+/* eslint-enable no-console */

package/app/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@rancher/create-app",
+  "description": "Rancher UI Application generator",
+  "version": "0.0.0",
+  "license": "Apache-2.0",
+  "author": "SUSE",
+  "private": false,
+  "bin": "./init",
+  "files": [
+    "**/*.*",
+    "init"
+  ],
+  "engines": {
+    "node": ">=12"
+  },
+  "_requires": [
+    "core-js",
+    "css-loader",
+    "@types/lodash",
+    "@rancher/components"
+  ],
+  "dependencies": {
+    "fs-extra": "^10.0.0"
+  }
+}

package/init

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const args = process.argv.slice(2);
+let extensionName = '';
+let appName = '';
+let updateOnly = false;
+let skeletonOnly = false;
+let ignoreShellDepCheck = false;
+
+args.forEach((arg, index) => {
+  switch (arg) {
+  case '--update':
+  case '-u':
+    updateOnly = true;
+    break;
+  case '--app-name':
+  case '-a':
+    if ( args[index + 1] && !args[index + 1].startsWith('-') ) {
+      appName = args[index + 1];
+    } else {
+      console.error('Error: Missing value for --app-name or -a option.');
+      process.exit(1);
+    }
+    break;
+  case '--skeleton-only':
+  case '-s':
+    skeletonOnly = true;
+    break;
+  case '-i':
+    ignoreShellDepCheck = true;
+    break;
+  default:
+    if ( !arg.startsWith('-') && extensionName === '' ) {
+      extensionName = arg;
+      appName = appName || extensionName;
+    }
+  }
+});
+
+if ( !extensionName && !updateOnly && !skeletonOnly ) {
+  console.error('Please provide an extension name.');
+  process.exit(1);
+}
+
+const basePath = process.cwd();
+let skeletonPath;
+let isInsideSkeleton = false;
+let directoryExists = false;
+
+// Check if we are inside a skeleton application by looking for package.json
+if ( fs.existsSync(path.join(basePath, 'package.json')) ) {
+  // Check for @rancher/shell dependency
+  const packageJsonPath = path.join(basePath, 'package.json');
+  const packageJson = require(packageJsonPath);
+
+  if ( !ignoreShellDepCheck && (!packageJson.dependencies || !packageJson.dependencies['@rancher/shell']) ) {
+    throw new Error('@rancher/shell dependency is missing in package.json.');
+  } else {
+    isInsideSkeleton = true;
+    skeletonPath = basePath;
+  }
+} else {
+  // If not inside a skeleton, check if a directory with the appName already exists
+  skeletonPath = path.join(basePath, appName);
+
+  if ( fs.existsSync(skeletonPath) ) {
+    directoryExists = true;
+  }
+}
+
+const pkgPath = path.join(skeletonPath, 'pkg', extensionName);
+const updatePath = path.join(__dirname, 'update');
+
+const skeletonExists = fs.existsSync(skeletonPath);
+const pkgExists = fs.existsSync(pkgPath);
+
+try {
+  if ( updateOnly ) {
+    // Run the update script directly
+    console.log('Updating applications...');
+    execSync(`node ${ path.join(updatePath, 'init') }`, { stdio: 'inherit' });
+
+    console.log('Update completed successfully.');
+    process.exit(0);
+  }
+
+  // If the directory exists but we're not inside a skeleton, we should exit to prevent overwriting
+  if ( directoryExists && !isInsideSkeleton ) {
+    throw new Error(`A directory named "${ appName }" already exists. Aborting.`);
+  }
+
+  // Create skeleton application if it doesn't exist
+  if ( !isInsideSkeleton && !skeletonExists ) {
+    console.log(`Creating skeleton application: ${ appName }...`);
+    // Pass all arguments to the app/init script
+    execSync(`node ${ path.join(__dirname, 'app', 'init') } ${ appName } ${ args.join(' ') }`, { stdio: 'inherit' });
+
+    // Ensure the skeleton path directory is created before attempting to change directory
+    if ( !fs.existsSync(skeletonPath) ) {
+      throw new Error(`Failed to create skeleton application directory: ${ skeletonPath }`);
+    }
+
+    // Change working directory to the newly created skeleton app
+    process.chdir(skeletonPath);
+  } else if ( isInsideSkeleton ) {
+    // If skeleton exists, ensure the working directory is set correctly
+    process.chdir(skeletonPath);
+  }
+
+  if ( skeletonOnly ) {
+    console.log('Skeleton application created successfully. No additional packages will be installed.');
+    process.exit(0);
+  }
+
+  if ( pkgExists ) {
+    throw new Error(`A package directory for "${ extensionName }" already exists.`);
+  }
+
+  // Check for package existence and create it if necessary
+  if ( !pkgExists ) {
+    console.log(`Creating package: ${ extensionName }...`);
+    execSync(`node ${ path.join(__dirname, 'pkg', 'init') } ${ extensionName } ${ args.join(' ') }`, { stdio: 'inherit' });
+  }
+
+  if ( args.includes('--update') || args.includes('-u') ) {
+    // Run the update script
+    console.log('Updating applications...');
+    execSync(`node ${ path.join(updatePath, 'init') } ${ extensionName }`, { stdio: 'inherit' });
+  }
+
+  console.log('Extension created successfully.');
+
+  if ( skeletonOnly || !isInsideSkeleton ) {
+    console.log(`To begin, run: \n\n\tcd ${ appName } && yarn install\n`);
+  }
+} catch (error) {
+  console.error('Error creating extension:', error);
+  process.exit(1);
+}
+
+/* eslint-enable no-console */

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@rancher/create-extension",
+  "description": "Rancher UI Extension generator",
+  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "author": "SUSE",
+  "private": false,
+  "bin": "./init",
+  "files": [
+    "**/*",
+    "init"
+  ],
+  "engines": {
+    "node": ">=12"
+  },
+  "dependencies": {
+    "fs-extra": "^10.0.0"
+  },
+  "_pkgs": {
+    "core-js": "3.21.1",
+    "css-loader": "6.7.3",
+    "@types/lodash": "4.14.184",
+    "@rancher/components": "0.2.1-alpha.0"
+  }
+}

package/pkg/files/babel.config.js

@@ -0,0 +1 @@
+module.exports = require('./.shell/pkg/babel.config.js');

package/pkg/files/index.ts

@@ -0,0 +1,14 @@
+import { importTypes } from '@rancher/auto-import';
+import { IPlugin } from '@shell/core/types';
+
+// Init the package
+export default function(plugin: IPlugin): void {
+  // Auto-import model, detail, edit from the folders
+  importTypes(plugin);
+
+  // Provide plugin metadata from package.json
+  plugin.metadata = require('./package.json');
+
+  // Load a product
+  // plugin.addProduct(require('./product'));
+}

package/pkg/files/tsconfig.json

@@ -0,0 +1,53 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "target": "esnext",
+    "module": "esnext",
+    "strict": true,
+    "jsx": "preserve",
+    "importHelpers": true,
+    "moduleResolution": "node",
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "sourceMap": true,
+    "baseUrl": ".",
+    "preserveSymlinks": true,
+    "typeRoots": [
+      "../../node_modules",
+      "../../node_modules/@rancher/shell/types"
+    ],    
+    "types": [
+      "node",
+      "webpack-env",
+      "@types/node",
+      "@types/jest",
+      "@types/lodash",
+      "rancher",
+      "shell"
+    ],
+    "lib": [
+      "esnext",
+      "dom",
+      "dom.iterable",
+      "scripthost"
+    ],
+    "paths": {
+      "@shell/*": [
+        "../../node_modules/@rancher/shell/*"
+      ],
+      "@components/*": [
+        "@rancher/components/*"
+      ]
+    }
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.d.ts",
+    "**/*.tsx",
+    "**/*.vue"
+  ],
+  "exclude": [
+    "../../node_modules"
+  ]
+}

package/pkg/files/vue.config.js

@@ -0,0 +1 @@
+module.exports = require('./.shell/pkg/vue.config')(__dirname);

package/pkg/init

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+
+const { execSync } = require('child_process');
+const fs = require('fs-extra');
+const path = require('path');
+const https = require('https');
+
+const files = [
+  'tsconfig.json',
+  'vue.config.js',
+  'babel.config.js',
+  'index.ts'
+];
+
+const topLevelScripts = {
+  'build-pkg':      './node_modules/@rancher/shell/scripts/build-pkg.sh',
+  'serve-pkgs':     './node_modules/@rancher/shell/scripts/serve-pkgs',
+  'publish-pkgs':   './node_modules/@rancher/shell/scripts/extension/publish',
+  'parse-tag-name': './node_modules/@rancher/shell/scripts/extension/parse-tag-name'
+};
+
+const typeFolders = [
+  'l10n',
+  'models',
+  'edit',
+  'list',
+  'detail'
+];
+
+console.log('');
+console.log('Creating Skeleton UI Package');
+
+const args = process.argv;
+
+const name = args[2];
+const folder = path.resolve('.');
+const pkgFolder = path.join(folder, 'pkg', name);
+
+let addTypeFolders = true;
+
+if ( args.length > 3 ) {
+  for ( let i = 3; i < args.length; i++ ) {
+    switch (args[i]) {
+    case '--skip-templates':
+    case '-t':
+      addTypeFolders = false;
+      break;
+    default:
+      break;
+    }
+  }
+}
+
+const isNodeModulesShell = !fs.existsSync(path.join(folder, 'shell'));
+
+if (!isNodeModulesShell) {
+  Object.keys(topLevelScripts).forEach((script) => {
+    topLevelScripts[script] = topLevelScripts[script].replace('./node_modules/@rancher/shell', './shell');
+  });
+}
+
+console.log(`  Creating package folder: ${ pkgFolder }`);
+
+fs.ensureDirSync(pkgFolder);
+
+console.log('  Creating package.json');
+fs.copySync(path.join(__dirname, 'pkg.package.json'), path.join(pkgFolder, 'package.json'));
+
+const rawdata = fs.readFileSync(path.join(pkgFolder, 'package.json'));
+const pkg = JSON.parse(rawdata);
+
+pkg.name = name;
+pkg.description = `${ name } plugin`;
+
+// Add annotation for the latest Rancher version by default
+function fetchLatestVersion() {
+  console.log('  Fetching latest Rancher Version');
+  const options = { headers: { 'User-Agent': 'nodejs' } };
+
+  https.get('https://api.github.com/repos/rancher/rancher/releases/latest', options, (res) => {
+    const { statusCode } = res;
+    const contentType = res.headers['content-type'];
+
+    let error;
+
+    if ( statusCode !== 200 ) {
+      error = new Error('  Request Failed.\n' +
+                        `  Status Code: ${ statusCode }`);
+    } else if ( !/^application\/json/.test(contentType) ) {
+      error = new Error('  Invalid content-type.\n' +
+                        `  Expected application/json but received ${ contentType }`);
+    }
+
+    if ( error ) {
+      console.log(error.message);
+
+      res.resume();
+
+      return;
+    }
+
+    res.setEncoding('utf8');
+    let rawData = '';
+
+    res.on('data', (chunk) => {
+      rawData += chunk;
+    });
+    res.on('end', () => {
+      try {
+        const release = JSON.parse(rawData);
+
+        if ( release.tag_name ) {
+          console.log(`  Adding rancher-version annotation '>= ${ release.tag_name }' to package.json`);
+
+          pkg.rancher = { annotations: { 'catalog.cattle.io/rancher-version': `>= ${ release.tag_name }` } };
+
+          // Fetch the latest version of @rancher/shell
+          const latestShellVersion = execSync('npm view @rancher/shell version').toString().trim() || null;
+
+          if (!latestShellVersion) {
+            console.log('Could not get a shell version from npm, skipping adding catalog.cattle.io/ui-extensions-version annotation to package.json');
+          } else {
+            const splitShellVersion = latestShellVersion.split('.');
+            const majorVersion = splitShellVersion[0];
+            const minorVersion = splitShellVersion[1];
+            const parsedShellVersion = `${ majorVersion }.${ minorVersion }.0`;
+
+            console.log(`  Adding catalog.cattle.io/ui-extensions-version '>= ${ parsedShellVersion }' to package.json`);
+
+            pkg.rancher.annotations['catalog.cattle.io/ui-extensions-version'] = `>= ${ parsedShellVersion }`;
+          }
+
+          writePackageJson();
+        }
+      } catch (e) {
+        console.log('  Error parsing release data', e);
+      }
+    });
+  }).on('error', (e) => {
+    console.log('  Error fetching latest Rancher Version', e);
+  });
+}
+
+fetchLatestVersion();
+writePackageJson();
+
+function writePackageJson() {
+  fs.writeFileSync(path.join(pkgFolder, 'package.json'), JSON.stringify(pkg, null, 2));
+}
+
+// Create type folders if needed
+if (addTypeFolders) {
+  typeFolders.forEach((dir) => {
+    const dest = path.join(path.join(pkgFolder, dir));
+
+    if (!fs.existsSync(dest)) {
+      console.log(`  Creating folder: ${ dir }`);
+      fs.mkdirSync(dest);
+    }
+  });
+}
+
+// Copy base files
+files.forEach((file) => {
+  const src = path.join(__dirname, 'files', file);
+  const dest = path.join(path.join(pkgFolder, file));
+
+  if (!fs.existsSync(dest)) {
+    console.log(`  Adding file: ${ file }`);
+    fs.copySync(src, dest);
+  }
+});
+
+const topLevelRawdata = fs.readFileSync(path.join(folder, 'package.json'));
+const topLevelPkg = JSON.parse(topLevelRawdata);
+let updated = false;
+
+Object.keys(topLevelScripts).forEach((target) => {
+  if (!topLevelPkg.scripts[target]) {
+    topLevelPkg.scripts[target] = topLevelScripts[target];
+    console.log(`  Adding script '${ target }' to top-level package.json`);
+    updated = true;
+  }
+});
+
+if (updated) {
+  fs.writeFileSync(path.join(folder, 'package.json'), JSON.stringify(topLevelPkg, null, 2));
+}
+
+// Update tsconfig if needed
+if (!isNodeModulesShell) {
+  const tsconfig = require(path.join(pkgFolder, 'tsconfig.json'));
+
+  tsconfig.include = updateArray(tsconfig.include);
+
+  Object.keys(tsconfig.compilerOptions.paths).forEach((p) => {
+    tsconfig.compilerOptions.paths[p] = updateArray(tsconfig.compilerOptions.paths[p]);
+  });
+
+  // Update typeRoots
+  tsconfig.compilerOptions.typeRoots = updateArray(tsconfig.compilerOptions.typeRoots);
+
+  fs.writeFileSync(path.join(pkgFolder, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2));
+  console.log('  Updated tsconfig.json for shell folder location');
+}
+
+console.log('');
+
+function updateArray(data) {
+  const updated = [];
+
+  data.forEach((inc) => {
+    updated.push(inc.replace('../../node_modules/@rancher/shell', '../../shell'));
+  });
+
+  return updated;
+}
+
+/* eslint-enable no-console */

package/pkg/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@rancher/create-pkg",
+  "description": "Rancher UI Package generator",
+  "version": "0.0.1",
+  "license": "Apache-2.0",
+  "author": "SUSE",
+  "private": false,
+  "bin": "./init",
+  "files": [
+    "**/*.*",
+    "init"
+  ],
+  "engines": {
+    "node": ">=12"
+  },
+  "dependencies": {
+    "fs-extra": "^10.0.0"
+  }
+}

package/pkg/pkg.package.json

@@ -0,0 +1,21 @@
+{
+  "name": "NAME",
+  "description": "NAME plugin",
+  "version": "0.1.0",
+  "private": false,
+  "rancher": true,
+  "scripts": {},
+  "engines": {
+    "node": ">=12"
+  },
+  "devDependencies": {
+    "@vue/cli-plugin-babel": "4.5.18",
+    "@vue/cli-service": "4.5.18",
+    "@vue/cli-plugin-typescript": "4.5.18"
+  },
+  "browserslist": [
+    "> 1%",
+    "last 2 versions",
+    "not dead"
+  ]
+}

package/pkg/vue-shim.ts

@@ -0,0 +1,4 @@
+declare module '*.vue' {
+  import Vue from 'vue';
+  export default Vue;
+}

package/update/init

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const fs = require('fs-extra');
+const { spawnSync } = require('child_process');
+
+const scriptFolder = path.resolve(__dirname, '..');
+const dest = path.resolve('.');
+
+// Remove first two args
+const args = process.argv;
+
+args.splice(0, 2);
+
+const res = spawnSync(path.join(__dirname, 'upgrade'), args, {
+  cwd:   dest,
+  shell: false,
+  stdio: ['ignore', process.stdout, process.stderr],
+});
+
+if (res.status !== 0) {
+  process.exit(res.status);
+}
+
+// Read the existing package.json
+let rawdata = fs.readFileSync(path.join(dest, 'package.json'));
+const appPackage = JSON.parse(rawdata);
+
+// Read the package.json from the app creator
+rawdata = fs.readFileSync(path.join(scriptFolder, 'app', 'package.json'));
+const latestPackage = JSON.parse(rawdata);
+
+// Read the package.json from the upgrade creator
+rawdata = fs.readFileSync(path.join(scriptFolder, 'package.json'));
+const upgradePackage = JSON.parse(rawdata);
+
+// Update dependency versions to match the latest from the creator
+if ( latestPackage.dependencies ) {
+  Object.keys(latestPackage.dependencies).forEach((key) => {
+    appPackage.dependencies[key] = latestPackage.dependencies[key];
+  });
+} else {
+  console.warn('No dependencies found in latestPackage.'); // eslint-disable-line no-console
+}
+
+// Add in the webpack resolution
+appPackage.resolutions = appPackage.resolutions || {};
+appPackage.resolutions['**/webpack'] = '4';
+
+// Update the version of @rancher/shell
+const shellVersion = upgradePackage.version;
+
+appPackage.dependencies['@rancher/shell'] = shellVersion;
+
+fs.writeFileSync(path.join(dest, 'package.json'), `${ JSON.stringify(appPackage, null, 2) }\n`);
+
+spawnSync(`yarn`, ['install'], {
+  cwd:   dest,
+  shell: false,
+  stdio: ['ignore', process.stdout, process.stderr],
+});

package/update/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@rancher/create-update",
+  "description": "Rancher UI Update helper",
+  "version": "0.0.0",
+  "license": "Apache-2.0",
+  "author": "SUSE",
+  "private": false,
+  "bin": "./init",
+  "files": [
+    "**/*.*",
+    "init",
+    "upgrade"
+  ],
+  "engines": {
+    "node": ">=12"
+  },
+  "dependencies": {
+    "fs-extra": "^10.0.0"
+  }
+}

package/update/upgrade

@@ -0,0 +1,56 @@
+#!/usr/bin/env sh
+
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )"/.. &> /dev/null && pwd )
+
+echo "Upgrading Rancher Shell"
+
+# Get the version number from the package.json file
+VERSION=$(node -p -e "require('${SCRIPT_DIR}/package.json').version")
+
+echo "Updating to version: ${VERSION}"
+echo ""
+
+FORCE="false"
+
+if [ "$1" == "-f" ]; then
+  FORCE="true"
+fi
+
+# Check for a clean git repository
+if [ ! -d ".git" ] && [ "${FORCE}" == "false" ]; then
+  echo "Not runnning in a git repository. Re-run with -f to ignore this check"
+  echo "Note: This action will update your files - running in a git repository will ensure you have visibility over changes made"
+  exit 1 
+fi
+
+if [[ $(git diff --stat) != '' ]] && [ "${FORCE}" == "false" ]; then
+  echo "Git repository is not clean. Re-run with -f to ignore this check"
+  echo "Note: This action will update your files - running in a clean git repository will ensure you have visibility over changes made"
+  exit 1 
+fi
+
+# Check this is a Rancher Extension
+if [ ! -f "./package.json" ]; then
+  echo "Can't find package.json - check you're running from the correct folder"
+  exit 1 
+fi
+
+HAS_SHELL=$(grep "\"@rancher/shell\"" package.json -c )
+if [ "${HAS_SHELL}" != "1" ]; then
+  echo "package.json does not reference @rancher/shell - check you're running from the correct folder"
+  exit 1 
+fi
+
+# Copy files for the top-level folder (from the app creator)
+rsync ${SCRIPT_DIR}/app/files/* .
+
+# Go through each folder in the pkg folder and update their files
+for pkg in ./pkg/*
+do
+  if [ -d "${pkg}" ]; then
+    pkgName=$(basename $pkg)
+    echo "Updating package ${pkgName}"
+
+    cp ${SCRIPT_DIR}/pkg/files/* ${pkg}
+  fi
+done