@ilanalimanjs/open_pack 2.4.3 → 2.4.4

package/bin/index.js

@@ -8,34 +8,37 @@ import { parseArgs } from 'node:util';
 import { spawn } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
 import { setTimeout as sleep } from 'node:timers/promises';
-import { downloadTemplate } from 'giget';
 import * as prompts from '@clack/prompts';
 import fse from 'fs-extra';
 import chalk from 'chalk';
 import ora from 'ora';
 
+process.noDeprecation = true;
+
 const { version: CLI_VERSION } = createRequire(import.meta.url)('../package.json');
 
 const TEMPLATE_SOURCE = 'github:DevIlannn/open_pack/Source';
 const REGISTRY_URL = 'https://registry.npmjs.org/@ilanalimanjs%2Fopen_pack/latest';
 const PACKAGE_COMMAND = 'npx @ilanalimanjs/open_pack@latest';
 const NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
-const DATABASE_URL_PATTERN = /^postgres(ql)?:\/\/.+/;
 const ANSI_PATTERN = /\u001B\[[0-9;]*m/g;
 const ENV_EXAMPLE_FILE = '.env.examples';
 const ENV_FILE = '.env';
+const LINUX_CHASSIS_FILE = '/sys/class/dmi/id/chassis_type';
+const LINUX_POWER_SUPPLY_DIRECTORY = '/sys/class/power_supply';
+const WINDOWS_CHASSIS_SCRIPT = '(Get-CimInstance -ClassName Win32_SystemEnclosure).ChassisTypes';
 const DEFAULT_PORT = 3000;
-const DEFAULT_DATABASE_PORT = 5432;
 const MAX_PORT = 65535;
 const PORT_SEARCH_RANGE = 50;
 const MIN_NODE_VERSION = { major: 20, minor: 11 };
 const BANNER_DELAY_MS = 70;
 const STEP_MIN_DURATION_MS = 450;
 const DETECT_TIMEOUT_MS = 4000;
-const DATABASE_TIMEOUT_MS = 2500;
 const UPDATE_TIMEOUT_MS = 2500;
 const EXIT_INTERRUPTED = 130;
 const GRADIENT = ['#22d3ee', '#38bdf8', '#60a5fa', '#818cf8', '#a78bfa'];
+const CHASSIS_LAPTOP = new Set([8, 9, 10, 14, 31, 32]);
+const CHASSIS_PC = new Set([3, 4, 5, 6, 7, 13, 15, 16, 24, 35, 36]);
 
 const GLYPHS = [
   [String.raw`  ___  `, String.raw` / _ \ `, String.raw`| | | |`, String.raw`| |_| |`, String.raw` \___/ `],
@@ -60,7 +63,15 @@ const PACKAGE_MANAGERS = {
 const PLATFORM_LABELS = {
   darwin: 'macOS',
   win32: 'Windows',
-  linux: 'Linux'
+  linux: 'Linux',
+  android: 'Android'
+};
+
+const DEVICE_TYPES = {
+  phone: 'Phone',
+  laptop: 'Laptop',
+  pc: 'PC',
+  other: 'Other'
 };
 
 const MODES = {
@@ -72,11 +83,9 @@ const MODES = {
 const CLI_OPTIONS = {
   yes: { type: 'boolean', short: 'y' },
   pm: { type: 'string' },
-  'database-url': { type: 'string' },
   port: { type: 'string' },
   'no-install': { type: 'boolean' },
   'no-run': { type: 'boolean' },
-  'no-db-check': { type: 'boolean' },
   'no-update-check': { type: 'boolean' },
   help: { type: 'boolean', short: 'h' },
   version: { type: 'boolean', short: 'v' }
@@ -85,11 +94,9 @@ const CLI_OPTIONS = {
 const HELP_OPTIONS = [
   ['-y, --yes', 'Skip prompts and use defaults'],
   ['--pm <name>', 'Package manager: npm, pnpm, yarn, bun'],
-  ['--database-url <url>', 'PostgreSQL connection string'],
   ['--port <number>', `Development server port (default ${DEFAULT_PORT})`],
   ['--no-install', 'Create the project without installing dependencies'],
   ['--no-run', 'Install dependencies without starting the server'],
-  ['--no-db-check', 'Skip the database reachability check'],
   ['--no-update-check', 'Skip the CLI update check'],
   ['-h, --help', 'Show this help'],
   ['-v, --version', 'Show the CLI version']
@@ -99,6 +106,7 @@ const accent = chalk.hex('#38bdf8');
 const muted = chalk.gray;
 const isWindows = process.platform === 'win32';
 const isTTY = Boolean(process.stdout.isTTY && process.stdin.isTTY);
+const SHELL_TOOLS = new Set(Object.keys(PACKAGE_MANAGERS));
 
 const STATE_ICONS = {
   done: chalk.green('✔'),
@@ -113,6 +121,11 @@ const pause = (ms) => (isTTY ? sleep(ms) : Promise.resolve());
 
 const visibleLength = (value) => value.replace(ANSI_PATTERN, '').length;
 
+const spawnTool = (command, args, options) =>
+  isWindows && SHELL_TOOLS.has(command)
+    ? spawn([command, ...args].join(' '), { ...options, shell: true })
+    : spawn(command, args, options);
+
 const renderCard = (title, rows) => {
   const labelWidth = Math.max(...rows.map((row) => visibleLength(row.label)));
   const lines = rows.map((row) => `${row.label}${' '.repeat(labelWidth - visibleLength(row.label))}  ${row.value}`);
@@ -141,9 +154,6 @@ const validateProjectName = (value) => {
   return undefined;
 };
 
-const validateDatabaseUrl = (value) =>
-  DATABASE_URL_PATTERN.test(value ?? '') ? undefined : 'Use the format postgresql://user:password@host:port/db';
-
 const validatePort = (value) => {
   const port = Number(value);
   return /^\d+$/.test(String(value ?? '')) && port >= 1 && port <= MAX_PORT
@@ -155,8 +165,7 @@ const validateFlags = ({ values, positionals }) => {
   const checks = [
     positionals[0] === undefined ? undefined : validateProjectName(positionals[0]),
     values.pm === undefined || PACKAGE_MANAGERS[values.pm] ? undefined : '--pm must be one of npm, pnpm, yarn, bun',
-    values.port === undefined ? undefined : validatePort(values.port),
-    values['database-url'] === undefined ? undefined : validateDatabaseUrl(values['database-url'])
+    values.port === undefined ? undefined : validatePort(values.port)
   ];
   return checks.find(Boolean);
 };
@@ -170,26 +179,23 @@ const resolveFixedMode = (values) => {
 const readFixedOptions = ({ values, positionals }) => ({
   name: positionals[0],
   packageManager: values.pm,
-  databaseUrl: values['database-url'],
   port: values.port === undefined ? undefined : Number(values.port),
   mode: resolveFixedMode(values)
 });
 
 const captureCommand = (command, args) =>
   new Promise((resolve) => {
-    const child = spawn(command, args, {
-      shell: isWindows,
-      stdio: ['ignore', 'pipe', 'ignore'],
-      timeout: DETECT_TIMEOUT_MS
-    });
+    const child = spawnTool(command, args, { stdio: ['ignore', 'pipe', 'ignore'], timeout: DETECT_TIMEOUT_MS });
     let output = '';
     child.stdout.on('data', (chunk) => {
       output += chunk.toString();
     });
     child.on('error', () => resolve(null));
-    child.on('close', (code) => resolve(code === 0 ? (output.trim().split('\n')[0] ?? null) : null));
+    child.on('close', (code) => resolve(code === 0 ? output.trim() : null));
   });
 
+const captureFirstLine = async (command, args) => (await captureCommand(command, args))?.split('\n')[0].trim() ?? null;
+
 const isPortFree = (port) =>
   new Promise((resolve) => {
     const server = net.createServer();
@@ -205,20 +211,6 @@ const findFreePort = async (start) => {
   throw new Error(`No free port found from ${start}`);
 };
 
-const isTcpReachable = (host, port) =>
-  new Promise((resolve) => {
-    const socket = net.connect({ host, port, timeout: DATABASE_TIMEOUT_MS });
-    socket.once('connect', () => {
-      socket.destroy();
-      resolve(true);
-    });
-    socket.once('timeout', () => {
-      socket.destroy();
-      resolve(false);
-    });
-    socket.once('error', () => resolve(false));
-  });
-
 const fetchLatestVersion = async () => {
   try {
     const response = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(UPDATE_TIMEOUT_MS) });
@@ -241,27 +233,82 @@ const isNodeSupported = () => {
   return major > MIN_NODE_VERSION.major || (major === MIN_NODE_VERSION.major && minor >= MIN_NODE_VERSION.minor);
 };
 
+const classifyChassis = (code) => {
+  if (CHASSIS_LAPTOP.has(code)) return DEVICE_TYPES.laptop;
+  if (CHASSIS_PC.has(code)) return DEVICE_TYPES.pc;
+  return DEVICE_TYPES.other;
+};
+
+const isAndroid = () =>
+  process.platform === 'android' || Boolean(process.env.TERMUX_VERSION) || (process.env.PREFIX ?? '').includes('com.termux');
+
+const readLinuxChassis = async () => {
+  try {
+    return Number((await fse.readFile(LINUX_CHASSIS_FILE, 'utf8')).trim());
+  } catch {
+    return null;
+  }
+};
+
+const hasLinuxBattery = async () => {
+  try {
+    return (await fse.readdir(LINUX_POWER_SUPPLY_DIRECTORY)).some((entry) => /^BAT/i.test(entry));
+  } catch {
+    return false;
+  }
+};
+
+const detectDeviceType = async () => {
+  if (isAndroid()) return DEVICE_TYPES.phone;
+
+  if (process.platform === 'win32') {
+    const output = await captureCommand('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', WINDOWS_CHASSIS_SCRIPT]);
+    return classifyChassis(Number((output ?? '').split(/\s+/).find((token) => /^\d+$/.test(token))));
+  }
+
+  if (process.platform === 'darwin') {
+    const output = await captureCommand('pmset', ['-g', 'batt']);
+    return output?.includes('InternalBattery') ? DEVICE_TYPES.laptop : DEVICE_TYPES.pc;
+  }
+
+  if (process.platform === 'linux') {
+    const code = await readLinuxChassis();
+    if (code !== null) return classifyChassis(code);
+    return (await hasLinuxBattery()) ? DEVICE_TYPES.laptop : DEVICE_TYPES.other;
+  }
+
+  return DEVICE_TYPES.other;
+};
+
+const detectIpAddress = () => {
+  const [entry] = Object.values(os.networkInterfaces())
+    .flat()
+    .filter((item) => item && item.family === 'IPv4' && !item.internal);
+  return entry?.address ?? null;
+};
+
 const detectEnvironment = async ({ port, checkUpdate }) => {
   const managerNames = Object.keys(PACKAGE_MANAGERS);
-  const [gitOutput, portFree, latestVersion, ...managerVersions] = await Promise.all([
-    captureCommand('git', ['--version']),
+  const [gitVersion, portFree, latestVersion, device, ...managerVersions] = await Promise.all([
+    captureFirstLine('git', ['--version']),
     isPortFree(port),
     checkUpdate ? fetchLatestVersion() : Promise.resolve(null),
-    ...managerNames.map((name) => captureCommand(name, ['--version']))
+    detectDeviceType(),
+    ...managerNames.map((name) => captureFirstLine(name, ['--version']))
   ]);
   const managers = Object.fromEntries(
     managerNames.map((name, index) => [name, managerVersions[index]]).filter(([, version]) => version)
   );
-  const cpus = os.cpus();
 
   return {
     system: `${PLATFORM_LABELS[process.platform] ?? process.platform} ${os.release()} (${os.arch()})`,
-    device: `${(cpus[0]?.model ?? 'Unknown CPU').replace(/\s+/g, ' ').trim()} (${cpus.length} cores, ${Math.round(os.totalmem() / 1024 ** 3)} GB RAM)`,
+    device,
+    ipAddress: detectIpAddress(),
     node: process.versions.node,
     nodeSupported: isNodeSupported(),
     launcher: parseLauncher(),
     managers,
-    git: gitOutput ? gitOutput.replace(/^git version\s*/, '') : null,
+    git: gitVersion ? gitVersion.replace(/^git version\s*/, '') : null,
     port,
     portFree,
     latestVersion
@@ -269,36 +316,25 @@ const detectEnvironment = async ({ port, checkUpdate }) => {
 };
 
 const printEnvironmentCard = (environment) => {
-  const managerList = Object.entries(environment.managers).map(([name, version]) => `${name} ${version}`);
-  const nodeStatus = environment.nodeSupported
-    ? chalk.green('✔')
-    : chalk.red(`✖ requires >=${MIN_NODE_VERSION.major}.${MIN_NODE_VERSION.minor}`);
   const hasUpdate = environment.latestVersion && compareVersions(environment.latestVersion, CLI_VERSION) > 0;
+  const nodeValue = environment.nodeSupported
+    ? `v${environment.node}`
+    : chalk.red(`v${environment.node} (requires >=${MIN_NODE_VERSION.major}.${MIN_NODE_VERSION.minor})`);
+  const portValue = environment.portFree
+    ? `${environment.port} available`
+    : chalk.yellow(`${environment.port} in use`);
   const rows = [
     { label: muted('System'), value: environment.system },
     { label: muted('Device'), value: environment.device },
-    { label: muted('Node.js'), value: `v${environment.node} ${nodeStatus}` },
-    {
-      label: muted('Launched with'),
-      value: environment.launcher ? `${environment.launcher.name} ${environment.launcher.version}` : 'node (direct)'
-    },
-    {
-      label: muted('Package managers'),
-      value: managerList.length ? managerList.join(', ') : chalk.yellow('none detected')
-    },
-    {
-      label: muted('Git'),
-      value: environment.git ? `${environment.git} ${chalk.green('✔')}` : muted('not found')
-    },
-    {
-      label: muted('Port'),
-      value: `${environment.port} ${environment.portFree ? `${chalk.green('✔')} free` : chalk.yellow('in use')}`
-    },
+    { label: muted('IP address'), value: environment.ipAddress ?? muted('unavailable') },
+    { label: muted('Node.js'), value: nodeValue },
+    { label: muted('Git'), value: environment.git ?? muted('not found') },
+    { label: muted('Port'), value: portValue },
     {
       label: muted('Openpack'),
       value: hasUpdate
-        ? `v${CLI_VERSION} ${chalk.yellow(`update available: ${environment.latestVersion}`)}`
-        : `v${CLI_VERSION} ${chalk.green('✔')}`
+        ? `v${CLI_VERSION} ${chalk.yellow(`(update available: ${environment.latestVersion})`)}`
+        : `v${CLI_VERSION}`
     }
   ];
   console.log(renderCard('Environment', rows));
@@ -339,7 +375,7 @@ const printHelp = () => {
   });
   console.log();
   console.log(`  ${muted('Example')}`);
-  console.log(`  ${PACKAGE_COMMAND} ${accent('my-project --yes --pm pnpm --database-url postgresql://user:pass@localhost:5432/db --no-run')}`);
+  console.log(`  ${PACKAGE_COMMAND} ${accent('my-project --yes --pm pnpm --no-run')}`);
   console.log();
 };
 
@@ -353,7 +389,7 @@ const printFailure = (title, detail) => {
 
 const runCommand = (command, args, cwd) =>
   new Promise((resolve, reject) => {
-    const child = spawn(command, args, { cwd, shell: isWindows, stdio: ['ignore', 'ignore', 'pipe'] });
+    const child = spawnTool(command, args, { cwd, stdio: ['ignore', 'ignore', 'pipe'] });
     const errors = [];
     child.stderr.on('data', (chunk) => errors.push(chunk.toString()));
     child.on('error', reject);
@@ -366,7 +402,7 @@ const runCommand = (command, args, cwd) =>
 
 const runInteractive = (command, args, cwd) =>
   new Promise((resolve, reject) => {
-    const child = spawn(command, args, { cwd, shell: isWindows, stdio: 'inherit' });
+    const child = spawnTool(command, args, { cwd, stdio: 'inherit' });
     child.on('error', reject);
     child.on('close', () => resolve());
   });
@@ -421,26 +457,19 @@ const askOptions = async (cli, environment) => {
               placeholder: 'my-project',
               validate: validateProjectName
             }),
-      packageManager: () =>
-        fixed.packageManager !== undefined
-          ? Promise.resolve(fixed.packageManager)
-          : prompts.select({
-              message: 'Choose a package manager',
-              initialValue: managers.initial,
-              options: managers.names.map((value) => ({
-                value,
-                label: PACKAGE_MANAGERS[value].label,
-                hint: environment.managers[value] ? `v${environment.managers[value]}` : undefined
-              }))
-            }),
-      databaseUrl: () =>
-        fixed.databaseUrl !== undefined
-          ? Promise.resolve(fixed.databaseUrl)
-          : prompts.text({
-              message: 'PostgreSQL DATABASE_URL',
-              placeholder: 'postgresql://user:password@localhost:5432/mydb',
-              validate: validateDatabaseUrl
-            }),
+      packageManager: () => {
+        if (fixed.packageManager !== undefined) return Promise.resolve(fixed.packageManager);
+        if (managers.names.length === 1) return Promise.resolve(managers.names[0]);
+        return prompts.select({
+          message: 'Choose a package manager',
+          initialValue: managers.initial,
+          options: managers.names.map((value) => ({
+            value,
+            label: PACKAGE_MANAGERS[value].label,
+            hint: environment.managers[value] ? `v${environment.managers[value]}` : undefined
+          }))
+        });
+      },
       mode: () =>
         fixed.mode !== undefined
           ? Promise.resolve(fixed.mode)
@@ -477,7 +506,6 @@ const askOptions = async (cli, environment) => {
 const resolveDefaultOptions = async (cli, environment) => {
   const fixed = readFixedOptions(cli);
   if (fixed.name === undefined) throw new UsageError('Project name is required in non-interactive mode');
-  if (fixed.databaseUrl === undefined) throw new UsageError('--database-url is required in non-interactive mode');
 
   const mode = fixed.mode ?? (process.stdout.isTTY ? MODES.run : MODES.install);
   const desired = fixed.port ?? DEFAULT_PORT;
@@ -491,23 +519,12 @@ const resolveDefaultOptions = async (cli, environment) => {
   return {
     name: fixed.name,
     packageManager: fixed.packageManager ?? resolveManagerChoices(environment).initial,
-    databaseUrl: fixed.databaseUrl,
     mode,
     port
   };
 };
 
-const checkDatabase = async (databaseUrl) => {
-  const url = new URL(databaseUrl);
-  const host = url.hostname.replace(/^\[|\]$/g, '');
-  const port = Number(url.port) || DEFAULT_DATABASE_PORT;
-  const target = `${host}:${port}`;
-  return (await isTcpReachable(host, port))
-    ? { label: `Database reachable at ${target}` }
-    : { state: 'warning', label: `Database unreachable at ${target}` };
-};
-
-const buildSteps = ({ name, packageManager, databaseUrl, mode, port }, { dbCheck }) => {
+const buildSteps = ({ name, packageManager, mode, port }) => {
   const targetDirectory = path.resolve(process.cwd(), name);
   const manager = PACKAGE_MANAGERS[packageManager];
   const customPort = port !== DEFAULT_PORT;
@@ -515,7 +532,10 @@ const buildSteps = ({ name, packageManager, databaseUrl, mode, port }, { dbCheck
     {
       active: 'Fetching template',
       done: 'Template fetched',
-      task: () => downloadTemplate(TEMPLATE_SOURCE, { dir: targetDirectory })
+      task: async () => {
+        const { downloadTemplate } = await import('giget');
+        await downloadTemplate(TEMPLATE_SOURCE, { dir: targetDirectory });
+      }
     },
     {
       active: 'Preparing environment',
@@ -528,31 +548,21 @@ const buildSteps = ({ name, packageManager, databaseUrl, mode, port }, { dbCheck
     },
     {
       active: 'Injecting template configuration',
-      done: customPort ? 'DATABASE_URL, SESSION_SECRET, and PORT injected' : 'DATABASE_URL and SESSION_SECRET injected',
+      done: customPort ? 'SESSION_SECRET and PORT injected' : 'SESSION_SECRET injected',
       task: async () => {
         const envPath = path.join(targetDirectory, ENV_FILE);
         const current = await fse.readFile(envPath, 'utf8');
-        const withDatabase = setEnvValue(current, 'DATABASE_URL', databaseUrl);
-        const withSecret = setEnvValue(withDatabase, 'SESSION_SECRET', randomBytes(32).toString('hex'));
+        const withSecret = setEnvValue(current, 'SESSION_SECRET', randomBytes(32).toString('hex'));
         await fse.writeFile(envPath, customPort ? setEnvValue(withSecret, 'PORT', String(port)) : withSecret);
       }
+    },
+    {
+      active: 'Entering project directory',
+      done: `Entered ${name}`,
+      task: async () => process.chdir(targetDirectory)
     }
   ];
 
-  if (dbCheck) {
-    steps.push({
-      active: 'Checking database connection',
-      done: 'Database reachable',
-      task: () => checkDatabase(databaseUrl)
-    });
-  }
-
-  steps.push({
-    active: 'Entering project directory',
-    done: `Entered ${name}`,
-    task: async () => process.chdir(targetDirectory)
-  });
-
   if (mode !== MODES.none) {
     steps.push({
       active: `Installing dependencies with ${manager.label}`,
@@ -663,7 +673,7 @@ async function main() {
 
   const options = interactive ? await askOptions(cli, environment) : await resolveDefaultOptions(cli, environment);
   const originalCwd = process.cwd();
-  const { steps, targetDirectory, manager } = buildSteps(options, { dbCheck: !cli.values['no-db-check'] });
+  const { steps, targetDirectory, manager } = buildSteps(options);
   const rollback = createRollback(targetDirectory, originalCwd, !(await fse.pathExists(targetDirectory)));
   const results = steps.map((step) => ({ label: step.done, state: 'pending', duration: null }));
   const startedAt = performance.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ilanalimanjs/open_pack",
-  "version": "2.4.3",
+  "version": "2.4.4",
   "description": "Open Pack CLI: create a new project from the Open Pack source template",
   "type": "module",
   "bin": {