aegisnode 0.0.1

package/src/cli/commands/startproject.js

@@ -0,0 +1,72 @@
+import crypto from 'crypto';
+import path from 'path';
+import { ensureDir, ensureValidName, exists, isDirectoryEmpty, writeFile } from '../utils/fs.js';
+import {
+  renderEnvExample,
+  renderProjectEnv,
+  renderProjectAppJs,
+  renderProjectGitIgnore,
+  renderProjectLoaderCjs,
+  renderProjectPackageJson,
+  renderProjectRoutes,
+  renderProjectSettings,
+} from '../utils/scaffolds.js';
+
+async function createSecret() {
+  try {
+    const jliveModule = await import('jlive');
+    const JliveEncrypt = jliveModule?.JliveEncrypt;
+    if (JliveEncrypt && typeof JliveEncrypt.generate === 'function') {
+      return JliveEncrypt.generate(64);
+    }
+  } catch {
+    // Fallback when jlive is not installed or not compatible.
+  }
+
+  return crypto.randomBytes(32).toString('hex');
+}
+
+async function assertCanCreateProject(projectDir) {
+  if (!(await exists(projectDir))) {
+    return;
+  }
+
+  const empty = await isDirectoryEmpty(projectDir);
+  if (!empty) {
+    throw new Error(`Directory already exists and is not empty: ${projectDir}`);
+  }
+}
+
+async function createBaseProjectFiles(projectRoot, projectName) {
+  const apps = [];
+  const appSecret = await createSecret();
+
+  await ensureDir(projectRoot);
+  await Promise.all([
+    ensureDir(path.join(projectRoot, 'apps')),
+  ]);
+
+  await writeFile(path.join(projectRoot, 'app.js'), renderProjectAppJs());
+  await writeFile(path.join(projectRoot, 'loader.cjs'), renderProjectLoaderCjs());
+  await writeFile(path.join(projectRoot, 'package.json'), renderProjectPackageJson(projectName));
+  await writeFile(path.join(projectRoot, '.gitignore'), renderProjectGitIgnore());
+  await writeFile(path.join(projectRoot, '.env'), renderProjectEnv(appSecret));
+  await writeFile(path.join(projectRoot, '.env.example'), renderEnvExample());
+
+  await writeFile(path.join(projectRoot, 'settings.js'), renderProjectSettings(projectName, apps));
+  await writeFile(path.join(projectRoot, 'routes.js'), renderProjectRoutes());
+}
+
+export async function startProject({ projectName, cwd }) {
+  ensureValidName(projectName, 'project');
+
+  const projectRoot = path.resolve(cwd, projectName);
+  await assertCanCreateProject(projectRoot);
+  await createBaseProjectFiles(projectRoot, projectName);
+
+  console.log(`AegisNode project created at ${projectRoot}`);
+  console.log('Next steps:');
+  console.log(`  cd ${projectName}`);
+  console.log('  npm install');
+  console.log('  aegisnode runserver');
+}

package/src/cli/commands/updatedeps.js

@@ -0,0 +1,355 @@
+import fs from 'fs/promises';
+import http from 'http';
+import https from 'https';
+import path from 'path';
+import { spawn } from 'child_process';
+import { resolveProjectRoot } from '../utils/project.js';
+import { exists, writeFile } from '../utils/fs.js';
+
+const DEFAULT_REGISTRY_BASE_URL = 'https://registry.npmjs.org/';
+const DEPENDENCY_SECTIONS = ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies'];
+const UNSUPPORTED_SPEC_PREFIXES = [
+  'file:',
+  'link:',
+  'workspace:',
+  'git:',
+  'git+',
+  'github:',
+  'http:',
+  'https:',
+];
+const MAX_REDIRECTS = 5;
+
+function ensureTrailingSlash(value) {
+  return value.endsWith('/') ? value : `${value}/`;
+}
+
+function encodePackageName(name) {
+  return name.replace(/\//g, '%2f');
+}
+
+function getVersionPrefix(spec) {
+  if (typeof spec !== 'string' || spec.length === 0) {
+    return '';
+  }
+
+  if (spec.startsWith('^') || spec.startsWith('~')) {
+    return spec[0];
+  }
+
+  return '';
+}
+
+function isRegistryDependencySpec(spec) {
+  if (typeof spec !== 'string' || spec.trim().length === 0) {
+    return false;
+  }
+
+  const normalized = spec.trim();
+  if (normalized.startsWith('npm:')) {
+    return parseNpmAliasSpec(normalized) !== null;
+  }
+
+  return !UNSUPPORTED_SPEC_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+
+function parseNpmAliasSpec(spec) {
+  if (typeof spec !== 'string' || !spec.startsWith('npm:')) {
+    return null;
+  }
+
+  const remainder = spec.slice(4);
+  const versionDelimiter = remainder.lastIndexOf('@');
+  if (versionDelimiter <= 0) {
+    return null;
+  }
+
+  const targetPackageName = remainder.slice(0, versionDelimiter);
+  const targetVersionSpec = remainder.slice(versionDelimiter + 1);
+  if (targetPackageName.trim().length === 0 || targetVersionSpec.trim().length === 0) {
+    return null;
+  }
+
+  return {
+    targetPackageName,
+    targetVersionSpec,
+  };
+}
+
+function resolveRegistryPackageName(packageName, versionSpec) {
+  const aliasSpec = parseNpmAliasSpec(versionSpec);
+  if (aliasSpec) {
+    return aliasSpec.targetPackageName;
+  }
+
+  return packageName;
+}
+
+function buildNextVersionSpec(versionSpec, latestVersion) {
+  const aliasSpec = parseNpmAliasSpec(versionSpec);
+  if (aliasSpec) {
+    return `npm:${aliasSpec.targetPackageName}@${getVersionPrefix(aliasSpec.targetVersionSpec)}${latestVersion}`;
+  }
+
+  return `${getVersionPrefix(String(versionSpec))}${latestVersion}`;
+}
+
+function parsePackageManager(packageJson) {
+  const declared = packageJson?.packageManager;
+  if (typeof declared === 'string' && declared.includes('@')) {
+    const [manager] = declared.split('@');
+    if (manager === 'npm' || manager === 'pnpm' || manager === 'yarn' || manager === 'bun') {
+      return manager;
+    }
+  }
+
+  return null;
+}
+
+async function detectPackageManager(projectRoot, packageJson) {
+  const declared = parsePackageManager(packageJson);
+  if (declared) {
+    return declared;
+  }
+
+  if (await exists(path.join(projectRoot, 'pnpm-lock.yaml'))) {
+    return 'pnpm';
+  }
+
+  if (await exists(path.join(projectRoot, 'yarn.lock'))) {
+    return 'yarn';
+  }
+
+  if (await exists(path.join(projectRoot, 'bun.lockb')) || await exists(path.join(projectRoot, 'bun.lock'))) {
+    return 'bun';
+  }
+
+  return 'npm';
+}
+
+async function requestJson(url, redirectCount = 0) {
+  const target = new URL(url);
+  const transport = target.protocol === 'https:' ? https : http;
+
+  return new Promise((resolve, reject) => {
+    const request = transport.get(target, {
+      headers: {
+        accept: 'application/json',
+      },
+    }, (response) => {
+      const status = response.statusCode || 0;
+
+      if (status >= 300 && status < 400 && response.headers.location) {
+        if (redirectCount >= MAX_REDIRECTS) {
+          reject(new Error(`Registry request exceeded redirect limit for ${url}.`));
+          return;
+        }
+
+        response.resume();
+        const nextUrl = new URL(response.headers.location, target).toString();
+        requestJson(nextUrl, redirectCount + 1).then(resolve, reject);
+        return;
+      }
+
+      let body = '';
+      response.setEncoding('utf8');
+      response.on('data', (chunk) => {
+        body += chunk;
+      });
+      response.on('end', () => {
+        if (status < 200 || status >= 300) {
+          const detail = body.trim().slice(0, 200);
+          reject(new Error(`Registry request failed for ${url}: ${status}${detail ? ` ${detail}` : ''}`));
+          return;
+        }
+
+        try {
+          resolve(JSON.parse(body));
+        } catch (error) {
+          reject(new Error(`Registry returned invalid JSON for ${url}: ${error.message}`));
+        }
+      });
+    });
+
+    request.on('error', reject);
+  });
+}
+
+function createLatestVersionResolver({
+  registryBaseUrl = DEFAULT_REGISTRY_BASE_URL,
+  fetchJson = requestJson,
+} = {}) {
+  const cache = new Map();
+  const baseUrl = ensureTrailingSlash(registryBaseUrl);
+
+  return async function resolveLatestVersion(packageName) {
+    if (!cache.has(packageName)) {
+      cache.set(packageName, (async () => {
+        const url = new URL(encodePackageName(packageName), baseUrl).toString();
+        const metadata = await fetchJson(url);
+        const latestVersion = metadata?.['dist-tags']?.latest;
+
+        if (typeof latestVersion !== 'string' || latestVersion.trim().length === 0) {
+          throw new Error(`Package "${packageName}" is missing dist-tags.latest in ${url}.`);
+        }
+
+        return latestVersion.trim();
+      })());
+    }
+
+    return cache.get(packageName);
+  };
+}
+
+function getInstallCommand(packageManager) {
+  const binary = process.platform === 'win32' ? `${packageManager}.cmd` : packageManager;
+  return {
+    command: binary,
+    args: ['install'],
+  };
+}
+
+async function runInstall(projectRoot, packageManager, output) {
+  const { command, args } = getInstallCommand(packageManager);
+  output.log(`Running ${packageManager} install...`);
+
+  await new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: projectRoot,
+      stdio: 'inherit',
+    });
+
+    child.on('error', reject);
+    child.on('exit', (code, signal) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+
+      if (signal) {
+        reject(new Error(`${packageManager} install terminated by signal ${signal}.`));
+        return;
+      }
+
+      reject(new Error(`${packageManager} install failed with exit code ${code}.`));
+    });
+  });
+}
+
+export async function runUpdateDependencies({
+  projectRoot,
+  registryBaseUrl = DEFAULT_REGISTRY_BASE_URL,
+  installDependencies = true,
+  output = console,
+} = {}) {
+  const resolvedRoot = await resolveProjectRoot(projectRoot || process.cwd());
+  const packageJsonPath = path.join(resolvedRoot, 'package.json');
+  let packageJsonRaw;
+
+  try {
+    packageJsonRaw = await fs.readFile(packageJsonPath, 'utf8');
+  } catch (error) {
+    throw new Error(`Could not read package.json from ${packageJsonPath}: ${error.message}`);
+  }
+
+  let packageJson;
+  try {
+    packageJson = JSON.parse(packageJsonRaw);
+  } catch (error) {
+    throw new Error(`Invalid package.json at ${packageJsonPath}: ${error.message}`);
+  }
+
+  const resolveLatestVersion = createLatestVersionResolver({ registryBaseUrl });
+  const updatedEntries = [];
+  const unchangedEntries = [];
+  const skippedEntries = [];
+  let totalDependencyEntries = 0;
+
+  for (const section of DEPENDENCY_SECTIONS) {
+    const dependencies = packageJson?.[section];
+    if (!dependencies || typeof dependencies !== 'object' || Array.isArray(dependencies)) {
+      continue;
+    }
+
+    const entries = Object.entries(dependencies);
+
+    await Promise.all(entries.map(async ([packageName, versionSpec]) => {
+      totalDependencyEntries += 1;
+
+      if (!isRegistryDependencySpec(versionSpec)) {
+        skippedEntries.push({
+          section,
+          packageName,
+          versionSpec,
+          reason: `unsupported source spec "${String(versionSpec)}"`,
+        });
+        return;
+      }
+
+      const latestVersion = await resolveLatestVersion(resolveRegistryPackageName(packageName, versionSpec));
+      const nextVersionSpec = buildNextVersionSpec(versionSpec, latestVersion);
+
+      if (String(versionSpec) === nextVersionSpec) {
+        unchangedEntries.push({
+          section,
+          packageName,
+          versionSpec: String(versionSpec),
+        });
+        return;
+      }
+
+      dependencies[packageName] = nextVersionSpec;
+      updatedEntries.push({
+        section,
+        packageName,
+        from: String(versionSpec),
+        to: nextVersionSpec,
+      });
+    }));
+  }
+
+  if (totalDependencyEntries === 0) {
+    output.log(`No dependencies found in ${packageJsonPath}.`);
+    return {
+      rootDir: resolvedRoot,
+      packageManager: null,
+      updatedEntries,
+      unchangedEntries,
+      skippedEntries,
+    };
+  }
+
+  if (updatedEntries.length > 0) {
+    await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+
+    for (const entry of updatedEntries) {
+      output.log(`Updated ${entry.section}.${entry.packageName}: ${entry.from} -> ${entry.to}`);
+    }
+  } else {
+    output.log('All registry-backed dependency specs are already on the current latest version.');
+  }
+
+  for (const entry of skippedEntries) {
+    output.log(`Skipped ${entry.section}.${entry.packageName}: ${entry.reason}`);
+  }
+
+  const packageManager = updatedEntries.length > 0 && installDependencies
+    ? await detectPackageManager(resolvedRoot, packageJson)
+    : null;
+
+  if (packageManager) {
+    await runInstall(resolvedRoot, packageManager, output);
+  }
+
+  output.log(
+    `updatedeps summary: ${updatedEntries.length} updated, ${unchangedEntries.length} unchanged, ${skippedEntries.length} skipped.`,
+  );
+
+  return {
+    rootDir: resolvedRoot,
+    packageManager,
+    updatedEntries,
+    unchangedEntries,
+    skippedEntries,
+  };
+}

package/src/cli/index.js

@@ -0,0 +1,151 @@
+import { startProject } from './commands/startproject.js';
+import { createApp } from './commands/createapp.js';
+import { runServer } from './commands/runserver.js';
+import { generateArtifact } from './commands/generate.js';
+import { runDoctor } from './commands/doctor.js';
+import { runUpdateDependencies } from './commands/updatedeps.js';
+
+function printHelp() {
+  console.log(`AegisNode CLI
+
+Usage:
+  aegisnode startproject <project-name>
+  aegisnode createapp <app-name> [--project <path>] [--mount </path>]
+  aegisnode generate <type> <name> --app <app-name> [--project <path>]
+  aegisnode runserver [--project <path>] [--port <number>]
+  aegisnode doctor [--project <path>]
+  aegisnode updatedeps [--project <path>]
+
+Examples:
+  aegisnode startproject blog
+  cd blog
+  npm install
+  aegisnode runserver
+  aegisnode createapp users
+  aegisnode generate view user --app users
+  aegisnode generate validator user --app users
+  aegisnode updatedeps --project blog
+`);
+}
+
+function parseFlags(tokens) {
+  const flags = {};
+  const positional = [];
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token.startsWith('-')) {
+      positional.push(token);
+      continue;
+    }
+
+    if (token === '-p' || token === '--port') {
+      flags.port = tokens[index + 1];
+      index += 1;
+      continue;
+    }
+
+    if (token === '--project') {
+      flags.project = tokens[index + 1];
+      index += 1;
+      continue;
+    }
+
+    if (token === '--mount') {
+      flags.mount = tokens[index + 1];
+      index += 1;
+      continue;
+    }
+
+    if (token === '--app') {
+      flags.app = tokens[index + 1];
+      index += 1;
+      continue;
+    }
+
+    if (token === '-h' || token === '--help') {
+      flags.help = true;
+      continue;
+    }
+
+    throw new Error(`Unknown flag: ${token}`);
+  }
+
+  return { flags, positional };
+}
+
+export async function runCli(argv) {
+  if (!argv.length) {
+    printHelp();
+    return;
+  }
+
+  const [command, ...rest] = argv;
+  const { flags, positional } = parseFlags(rest);
+
+  if (flags.help || command === 'help') {
+    printHelp();
+    return;
+  }
+
+  switch (command) {
+    case 'startproject': {
+      const [projectName] = positional;
+      if (!projectName) {
+        throw new Error('Missing project name. Usage: aegisnode startproject <project-name>');
+      }
+      await startProject({ projectName, cwd: process.cwd() });
+      return;
+    }
+
+    case 'createapp': {
+      const [appName] = positional;
+      if (!appName) {
+        throw new Error('Missing app name. Usage: aegisnode createapp <app-name>');
+      }
+      await createApp({
+        appName,
+        projectRoot: flags.project ? String(flags.project) : process.cwd(),
+        mount: flags.mount ? String(flags.mount) : undefined,
+      });
+      return;
+    }
+
+    case 'runserver': {
+      await runServer({
+        projectRoot: flags.project ? String(flags.project) : process.cwd(),
+        port: flags.port ? Number(flags.port) : undefined,
+      });
+      return;
+    }
+
+    case 'doctor': {
+      await runDoctor({
+        projectRoot: flags.project ? String(flags.project) : process.cwd(),
+      });
+      return;
+    }
+
+    case 'updatedeps': {
+      await runUpdateDependencies({
+        projectRoot: flags.project ? String(flags.project) : process.cwd(),
+      });
+      return;
+    }
+
+    case 'generate':
+    case 'g': {
+      const [type, name] = positional;
+      await generateArtifact({
+        type,
+        name,
+        appName: flags.app ? String(flags.app) : undefined,
+        projectRoot: flags.project ? String(flags.project) : process.cwd(),
+      });
+      return;
+    }
+
+    default:
+      throw new Error(`Unknown command: ${command}`);
+  }
+}

package/src/cli/utils/fs.js

@@ -0,0 +1,53 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+export async function exists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function isDirectoryEmpty(targetPath) {
+  const entries = await fs.readdir(targetPath);
+  return entries.length === 0;
+}
+
+export async function ensureDir(targetPath) {
+  await fs.mkdir(targetPath, { recursive: true });
+}
+
+export async function writeFile(targetPath, content) {
+  await ensureDir(path.dirname(targetPath));
+  await fs.writeFile(targetPath, content, 'utf8');
+}
+
+export function normalizeMountPath(input) {
+  if (!input || input === '/') {
+    return '/';
+  }
+
+  const normalized = `/${String(input).trim().replace(/^\/+/, '').replace(/\/+$/, '')}`;
+  const segments = normalized.split('/').filter(Boolean);
+
+  if (segments.length === 0) {
+    return '/';
+  }
+
+  const invalidSegment = segments.find((segment) => !/^[a-zA-Z0-9:_-]+$/.test(segment));
+  if (invalidSegment) {
+    throw new Error(
+      `Invalid mount path segment "${invalidSegment}". Use letters, numbers, "_", "-", and optional ":" params only.`,
+    );
+  }
+
+  return `/${segments.join('/')}`;
+}
+
+export function ensureValidName(input, type) {
+  if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(input)) {
+    throw new Error(`Invalid ${type} name \"${input}\". Use letters, numbers, _ and - only.`);
+  }
+}

package/src/cli/utils/project.js

@@ -0,0 +1,67 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { exists } from './fs.js';
+
+export async function hasRoutesFile(projectRoot) {
+  return (await exists(path.join(projectRoot, 'routes.js')))
+    || (await exists(path.join(projectRoot, 'routes', 'index.js')));
+}
+
+export async function hasSettingsFile(projectRoot) {
+  return (await exists(path.join(projectRoot, 'settings.js')))
+    || (await exists(path.join(projectRoot, 'settings', 'index.js')))
+    || (await exists(path.join(projectRoot, 'settings', 'apps.js')));
+}
+
+export async function isProjectRoot(projectRoot) {
+  const [hasRoutes, hasSettings] = await Promise.all([
+    hasRoutesFile(projectRoot),
+    hasSettingsFile(projectRoot),
+  ]);
+  return hasRoutes && hasSettings;
+}
+
+export async function resolveProjectRoot(projectRootHint) {
+  const startDir = path.resolve(projectRootHint);
+
+  let cursor = startDir;
+  while (true) {
+    if (await isProjectRoot(cursor)) {
+      return cursor;
+    }
+    const parent = path.dirname(cursor);
+    if (parent === cursor) {
+      break;
+    }
+    cursor = parent;
+  }
+
+  let entries = [];
+  try {
+    entries = await fs.readdir(startDir, { withFileTypes: true });
+  } catch {
+    entries = [];
+  }
+
+  const matches = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const candidate = path.join(startDir, entry.name);
+    if (await isProjectRoot(candidate)) {
+      matches.push(candidate);
+    }
+  }
+
+  if (matches.length === 1) {
+    return matches[0];
+  }
+
+  if (matches.length > 1) {
+    const names = matches.map((item) => path.basename(item)).join(', ');
+    throw new Error(`Multiple AegisNode projects found in ${startDir}: ${names}. Use --project <path>.`);
+  }
+
+  throw new Error(`Could not find an AegisNode project from ${startDir}. Run inside project or use --project <path>.`);
+}