@getdashi/cli 0.1.4 → 0.1.7

package/dist/bin.js

@@ -11,6 +11,7 @@ process.on('warning', w => {
 const { Command } = await import('commander');
 const { appCreate } = await import('./commands/app-create.js');
 const { appDev } = await import('./commands/app-dev.js');
+const { appUpgrade } = await import('./commands/app-upgrade.js');
 const { brand, dim, logError } = await import('./utils/ui.js');
 const { default: pkg } = await import('../package.json', { assert: { type: 'json' } });
 // ─── Banner ───────────────────────────────────────────────────────────────────
@@ -56,6 +57,18 @@ ${dim('Examples:')}
         previewPort: parseInt(opts.previewPort, 10),
     });
 });
+app
+    .command('upgrade')
+    .description('⬆   upgrade @getdashi/* packages to latest')
+    .option('-f, --force', 'reinstall even if already at latest')
+    .addHelpText('after', `
+${dim('Examples:')}
+  ${dim('$')} dashi app upgrade
+  ${dim('$')} dashi app upgrade --force
+`)
+    .action(async (opts) => {
+    await appUpgrade({ force: opts.force });
+});
 program.parseAsync(process.argv).catch((err) => {
     logError(err instanceof Error ? err.message : String(err));
     process.exit(1);

package/dist/commands/app-create.js

@@ -5,6 +5,7 @@ import { dirname } from 'node:path';
 import { execSync } from 'node:child_process';
 import prompts from 'prompts';
 import { printBanner, printBox, spinner, logError, logSuccess, logStep, brand, dim, bold, url, } from '../utils/ui.js';
+import { detectPm } from '../utils/detect-pm.js';
 export async function appCreate({ name, port }) {
     printBanner('app create');
     const answers = await prompts([
@@ -49,7 +50,7 @@ export async function appCreate({ name, port }) {
     const manifestPath = join(targetDir, 'public', 'manifest.json');
     const manifest = readFileSync(manifestPath, 'utf8').replace(/\{\{APP_NAME\}\}/g, appName);
     writeFileSync(manifestPath, manifest);
-    const pm = detectPm();
+    const pm = detectPm(targetDir);
     const spin = spinner('Installing dependencies…');
     spin.start();
     try {
@@ -73,18 +74,3 @@ export async function appCreate({ name, port }) {
     ]);
     console.log(`  Open ${url(`http://localhost:${appPort}`)} once the dev server starts.\n`);
 }
-function detectPm() {
-    try {
-        execSync('yarn --version', { stdio: 'ignore' });
-        return 'yarn';
-    }
-    catch {
-        try {
-            execSync('pnpm --version', { stdio: 'ignore' });
-            return 'pnpm';
-        }
-        catch {
-            return 'npm';
-        }
-    }
-}

package/dist/commands/app-upgrade.d.ts

@@ -0,0 +1,5 @@
+interface AppUpgradeOptions {
+    force?: boolean;
+}
+export declare function appUpgrade({ force }?: AppUpgradeOptions): Promise<void>;
+export {};

package/dist/commands/app-upgrade.js

@@ -0,0 +1,113 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { execSync } from 'node:child_process';
+import { printBanner, spinner, logError, logSuccess, logStep, logInfo, dim, bold, } from '../utils/ui.js';
+import { detectPm } from '../utils/detect-pm.js';
+const DASHI_PACKAGES = ['@getdashi/client', '@getdashi/cli'];
+function readPackageJson(cwd) {
+    const pkgPath = join(cwd, 'package.json');
+    if (!existsSync(pkgPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(pkgPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function getInstalledVersion(pkg, cwd) {
+    const pkgJsonPath = join(cwd, 'node_modules', pkg, 'package.json');
+    if (!existsSync(pkgJsonPath))
+        return null;
+    try {
+        const { version } = JSON.parse(readFileSync(pkgJsonPath, 'utf8'));
+        return version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function isDashiApp(pkg) {
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    return DASHI_PACKAGES.some(p => p in allDeps);
+}
+function presentPackages(pkg, cwd) {
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const result = new Map();
+    for (const p of DASHI_PACKAGES) {
+        if (p in allDeps) {
+            result.set(p, getInstalledVersion(p, cwd));
+        }
+    }
+    return result;
+}
+export async function appUpgrade({ force = false } = {}) {
+    printBanner('app upgrade');
+    const cwd = resolve(process.cwd());
+    const pkg = readPackageJson(cwd);
+    if (!pkg) {
+        logError('No package.json found. Run this command from a dashi app directory.');
+        process.exit(1);
+    }
+    if (!isDashiApp(pkg)) {
+        logError('This does not appear to be a dashi app (no @getdashi/* packages found).');
+        process.exit(1);
+    }
+    const before = presentPackages(pkg, cwd);
+    console.log();
+    logStep('Current versions:');
+    for (const [name, version] of before) {
+        logInfo(`${bold(name)}  ${dim(version ?? 'not installed')}`);
+    }
+    console.log();
+    const pm = detectPm(cwd);
+    const packageList = [...before.keys()];
+    const upgradeCmd = buildUpgradeCmd(pm, packageList);
+    logStep(`Running ${dim(upgradeCmd)}`);
+    console.log();
+    const spin = spinner('Upgrading dashi packages…');
+    spin.start();
+    try {
+        execSync(upgradeCmd, { cwd, stdio: 'pipe' });
+        spin.succeed('Packages upgraded');
+    }
+    catch (err) {
+        spin.fail('Upgrade failed');
+        logError(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+    const after = presentPackages(pkg, cwd);
+    console.log();
+    let anyChanged = false;
+    for (const [name, newVersion] of after) {
+        const oldVersion = before.get(name);
+        if (oldVersion !== newVersion) {
+            logSuccess(`${bold(name)}  ${dim(oldVersion ?? '—')} → ${newVersion ?? '—'}`);
+            anyChanged = true;
+        }
+        else if (force) {
+            logSuccess(`${bold(name)}  ${dim('reinstalled')} ${dim(`(${newVersion ?? '—'})`)}`);
+            anyChanged = true;
+        }
+        else {
+            logInfo(`${bold(name)}  ${dim('already up to date')} ${dim(`(${newVersion ?? '—'})`)}`);
+        }
+    }
+    if (anyChanged) {
+        console.log();
+        logStep('All dashi packages are up to date.');
+    }
+    console.log();
+}
+function buildUpgradeCmd(pm, packages) {
+    const pkgArgs = packages.map(p => `${p}@latest`).join(' ');
+    switch (pm) {
+        case 'yarn':
+            // `yarn add` rewrites package.json + lockfile to the resolved latest
+            return `yarn add ${pkgArgs} --ignore-engines`;
+        case 'pnpm':
+            return `pnpm add ${pkgArgs}`;
+        default:
+            return `npm install ${pkgArgs} --engine-strict=false`;
+    }
+}

package/dist/utils/detect-pm.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Infers the package manager to use for a given project directory.
+ * Prefers the lockfile already present in the directory; falls back to
+ * whichever PM is available on PATH (yarn → pnpm → npm).
+ */
+export declare function detectPm(cwd?: string): string;

package/dist/utils/detect-pm.js

@@ -0,0 +1,29 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+/**
+ * Infers the package manager to use for a given project directory.
+ * Prefers the lockfile already present in the directory; falls back to
+ * whichever PM is available on PATH (yarn → pnpm → npm).
+ */
+export function detectPm(cwd = process.cwd()) {
+    if (existsSync(join(cwd, 'yarn.lock')))
+        return 'yarn';
+    if (existsSync(join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (existsSync(join(cwd, 'package-lock.json')))
+        return 'npm';
+    try {
+        execSync('yarn --version', { stdio: 'ignore' });
+        return 'yarn';
+    }
+    catch {
+        try {
+            execSync('pnpm --version', { stdio: 'ignore' });
+            return 'pnpm';
+        }
+        catch {
+            return 'npm';
+        }
+    }
+}

package/dist/utils/serve-preview.js

@@ -27,7 +27,11 @@ export function servePreview(port) {
     const distDir = join(__dirname, '..', '..', 'preview-dist');
     const server = createServer((req, res) => {
         const rawPath = req.url?.split('?')[0] ?? '/';
-        const filePath = rawPath === '/' ? 'index.html' : rawPath.replace(/^\//, '');
+        // The preview bundle is built with --base=/_preview/ for the platform, so
+        // asset URLs are prefixed with /_preview/. Strip that prefix when serving
+        // locally so files resolve to their actual location in preview-dist/.
+        const normalizedPath = rawPath.replace(/^\/_preview\//, '/');
+        const filePath = normalizedPath === '/' ? 'index.html' : normalizedPath.replace(/^\//, '');
         const fullPath = join(distDir, filePath);
         let exists = false;
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getdashi/cli",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "license": "AGPL-3.0-only",
   "description": "Dashi app development CLI",
   "type": "module",

package/templates/dashi-app/app/globals.css

@@ -1,4 +1,9 @@
 @import "tailwindcss";
+/* Tailwind v4's auto-detection doesn't always resolve paths correctly when
+   Next.js's webpack PostCSS loader compiles this file. Explicit @source
+   directives ensure all app and root-level TS/TSX files are scanned. */
+@source ".";
+@source "..";
 
 @keyframes rainbow {
   0%   { color: hsl(0,   70%, 68%); }