@notis_ai/cli 0.2.1 → 0.2.3

package/src/runtime/app-dev-server.js

@@ -23,6 +23,7 @@ import {
   exportNameFromPath,
   getBundleDir,
   loadAppConfig,
+  prepareArtifactBuild,
   readManifest,
 } from './app-platform.js';
 
@@ -77,6 +78,14 @@ function scriptJson(value) {
     .replace(/\u2029/g, '\\u2029');
 }
 
+function timingMs(startedAt) {
+  return Number(process.hrtime.bigint() - startedAt) / 1_000_000;
+}
+
+function formatTimingMs(value) {
+  return value.toFixed(value < 10 ? 2 : 1);
+}
+
 function readJsonFile(path) {
   if (!existsSync(path)) {
     return null;
@@ -105,8 +114,8 @@ function reactVersionFromPeer(peerRange) {
 function resolveHarnessReactVersion(projectDir) {
   const candidates = [
     join(projectDir, 'node_modules', '@notis', 'sdk', 'package.json'),
-    join(REPO_ROOT, 'packages', 'notis-sdk', 'package.json'),
-    join(CLI_ROOT, 'template', 'packages', 'notis-sdk', 'package.json'),
+    join(REPO_ROOT, 'packages', 'sdk', 'package.json'),
+    join(CLI_ROOT, 'template', 'packages', 'sdk', 'package.json'),
   ];
   for (const candidate of candidates) {
     const pkg = readJsonFile(candidate);
@@ -234,7 +243,7 @@ function renderHarnessHtml({ state, manifest, appConfig, route, harnessOptions }
 /**
  * Start the dev server for one or more apps.
  *
- * @param {{apps: Array<{slug: string, projectDir: string, appId?: string}>, port: number, watch?: boolean, harness?: { mode?: string, apiBase?: string, jwt?: string }, log?: (m: string) => void, logError?: (m: string) => void}} options
+ * @param {{apps: Array<{slug: string, projectDir: string, appId?: string, userId?: string}>, port: number, watch?: boolean, harness?: { mode?: string, apiBase?: string, jwt?: string }, log?: (m: string) => void, logError?: (m: string) => void}} options
  */
 export async function startAppDevServer({
   apps,
@@ -254,6 +263,7 @@ export async function startAppDevServer({
       slug: app.slug,
       projectDir: app.projectDir,
       appId: app.appId || null,
+      userId: app.userId || null,
       canonicalBundleDir: getBundleDir(app.projectDir),
       bundleDir: null,
       jsPath: null,
@@ -381,11 +391,21 @@ export async function startAppDevServer({
     }
 
     if (url.pathname === '/healthz') {
+      const now = new Date().toISOString();
+      const sessions = Array.from(appState.values()).map((state) => ({
+        appId: state.appId,
+        userId: state.userId,
+        devSlug: state.slug,
+        bundleBaseUrl: `http://127.0.0.1:${port}/a/${state.slug}`,
+        projectDir: state.projectDir,
+        lastHeartbeatAt: now,
+        status: 'connected',
+      }));
       res.writeHead(200, {
         ...headers,
         'Content-Type': 'application/json; charset=utf-8',
       });
-      res.end(JSON.stringify({ ok: true, apps: Array.from(appState.keys()) }));
+      res.end(JSON.stringify({ ok: true, apps: Array.from(appState.keys()), sessions }));
       return;
     }
 
@@ -454,17 +474,20 @@ export async function startAppDevServer({
     }
 
     if (routed.rest.startsWith('bundle/')) {
+      const startedAt = process.hrtime.bigint();
       updateBundleDir(state, resolveBundleDir(state));
       const rel = routed.rest.slice('bundle/'.length);
       if (!state.bundleDir) {
         res.writeHead(404, headers);
         res.end('not found');
+        log(`[notis apps timing] ${state.slug}: GET bundle/${rel} -> 404 in ${formatTimingMs(timingMs(startedAt))}ms`);
         return;
       }
       const full = safeJoin(state.bundleDir, rel);
       if (!full || !existsSync(full)) {
         res.writeHead(404, headers);
         res.end('not found');
+        log(`[notis apps timing] ${state.slug}: GET bundle/${rel} -> 404 in ${formatTimingMs(timingMs(startedAt))}ms`);
         return;
       }
       const ext = extFor(rel);
@@ -480,6 +503,10 @@ export async function startAppDevServer({
       } else {
         res.end(content);
       }
+      log(
+        `[notis apps timing] ${state.slug}: GET bundle/${rel} -> 200 ` +
+        `${content.byteLength}B in ${formatTimingMs(timingMs(startedAt))}ms`,
+      );
       return;
     }
 
@@ -527,6 +554,7 @@ export async function startAppDevServer({
 
   for (const state of appState.values()) {
     if (watch) {
+      await prepareArtifactBuild(state.projectDir);
       pollForBundleAndWatch(state);
 
       state.buildProcess = spawn('npm', ['run', 'build', '--', '--watch'], {

package/src/runtime/app-platform.js

@@ -7,7 +7,7 @@
  */
 
 import { spawn } from 'node:child_process';
-import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, rmSync } from 'node:fs';
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, rmSync, statSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -21,15 +21,34 @@ const STATE_FILE = join(NOTIS_DIR, 'state.json');
 const OUTPUT_DIR = join(NOTIS_DIR, 'output');
 const BUNDLE_DIR = join(OUTPUT_DIR, 'bundle');
 const MANIFEST_FILE = join(OUTPUT_DIR, 'manifest.json');
+const METADATA_DIR = 'metadata';
+const CLI_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
+const MONOREPO_APPS_DIR = resolve(CLI_ROOT, '../..', 'apps');
+const DIST_DIR = join(CLI_ROOT, 'dist');
+const SCAFFOLD_CATALOG_FILE = join(DIST_DIR, 'scaffolds.json');
+const SCAFFOLD_SOURCE_DIR = join(DIST_DIR, 'scaffolds');
+const TEMPLATE_SDK_DIR = join(CLI_ROOT, 'template', 'packages', 'sdk');
+export const NOTIS_APP_CATEGORIES = [
+  'Productivity',
+  'Sales & Marketing',
+  'Operations',
+  'Product & Engineering',
+  'Personal',
+];
 const SOURCE_COPY_EXCLUDES = new Set([
   'node_modules',
   '.notis',
   '.git',
   'dist',
-  'package-lock.json',
   'tsconfig.tsbuildinfo',
   '.DS_Store',
 ]);
+const SCAFFOLD_COPY_EXCLUDES = new Set([
+  ...SOURCE_COPY_EXCLUDES,
+  'coverage',
+  '.next',
+  '.turbo',
+]);
 let appConfigImportNonce = 0;
 
 // ---------------------------------------------------------------------------
@@ -214,9 +233,160 @@ export function detectProjectWarnings(projectDir, appConfig = null) {
     warnings.push('No database references declared in notis.config.ts.');
   }
 
+  if (appConfig) {
+    try {
+      const listing = inspectListingReadiness(projectDir, appConfig);
+      warnings.push(...listing.warnings);
+    } catch (error) {
+      warnings.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+
   return warnings;
 }
 
+function safeKebab(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/(^-|-$)+/g, '');
+}
+
+function jsStringLiteral(value) {
+  return `'${String(value).replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+
+function normalizeCategories(categories = []) {
+  if (!Array.isArray(categories)) {
+    return [];
+  }
+  const allowed = new Set(NOTIS_APP_CATEGORIES);
+  const normalized = [];
+  for (const category of categories) {
+    if (typeof category !== 'string' || !category.trim()) {
+      continue;
+    }
+    const trimmed = category.trim();
+    if (!allowed.has(trimmed)) {
+      throw usageError(
+        `Invalid Notis app category "${trimmed}". Use one of: ${NOTIS_APP_CATEGORIES.join(', ')}.`,
+      );
+    }
+    if (!normalized.includes(trimmed)) {
+      normalized.push(trimmed);
+    }
+  }
+  return normalized;
+}
+
+function pngDimensions(buffer) {
+  const signature = '89504e470d0a1a0a';
+  if (!Buffer.isBuffer(buffer) || buffer.length < 24 || buffer.subarray(0, 8).toString('hex') !== signature) {
+    return null;
+  }
+  return {
+    width: buffer.readUInt32BE(16),
+    height: buffer.readUInt32BE(20),
+  };
+}
+
+function imageAssetMeta(projectDir, relPath, { maxBytes, recommendedRatio = 1.6 }) {
+  const fullPath = join(projectDir, relPath);
+  const content = readFileSync(fullPath);
+  const dimensions = pngDimensions(content);
+  const ratio = dimensions?.height ? dimensions.width / dimensions.height : null;
+  const errors = [];
+  const warnings = [];
+
+  if (!relPath.toLowerCase().endsWith('.png')) {
+    errors.push(`${relPath} must be a PNG file.`);
+  }
+  if (content.length > maxBytes) {
+    errors.push(`${relPath} must be ${Math.round(maxBytes / 1024 / 1024)} MB or smaller.`);
+  }
+  if (ratio !== null && (ratio < 1.3 || ratio > 1.9)) {
+    errors.push(`${relPath} should be close to a 16:10 aspect ratio.`);
+  } else if (ratio !== null && Math.abs(ratio - recommendedRatio) > 0.08) {
+    warnings.push(`${relPath} is not 2000x1250; 16:10 PNG is recommended.`);
+  }
+
+  return {
+    path: relPath,
+    content_type: 'image/png',
+    bytes: content.length,
+    width: dimensions?.width ?? null,
+    height: dimensions?.height ?? null,
+    errors,
+    warnings,
+  };
+}
+
+export function discoverMetadataAssets(projectDir) {
+  const metadataDir = join(projectDir, METADATA_DIR);
+  const coverPath = join(METADATA_DIR, 'cover.png');
+  const cover = existsSync(join(projectDir, coverPath))
+    ? imageAssetMeta(projectDir, coverPath, { maxBytes: 5 * 1024 * 1024 })
+    : null;
+  const screenshots = [];
+
+  if (existsSync(metadataDir)) {
+    for (const entry of readdirSync(metadataDir, { withFileTypes: true })) {
+      if (!entry.isFile()) continue;
+      const match = /^screenshot-(\d+)\.png$/i.exec(entry.name);
+      if (!match) continue;
+      screenshots.push({
+        index: Number.parseInt(match[1], 10),
+        ...imageAssetMeta(projectDir, join(METADATA_DIR, entry.name), {
+          maxBytes: 2 * 1024 * 1024,
+        }),
+      });
+    }
+  }
+
+  screenshots.sort((a, b) => a.index - b.index);
+  return {
+    cover,
+    screenshots: screenshots.slice(0, 6),
+  };
+}
+
+export function inspectListingReadiness(projectDir, appConfig = null) {
+  const config = appConfig || {};
+  const warnings = [];
+  const errors = [];
+  const metadata = discoverMetadataAssets(projectDir);
+  const categories = normalizeCategories(config.categories || []);
+
+  if (!String(config.tagline || '').trim()) {
+    warnings.push('Listing tagline missing in notis.config.ts.');
+  }
+  if (categories.length === 0) {
+    warnings.push(`Listing category missing in notis.config.ts. Use one of: ${NOTIS_APP_CATEGORIES.join(', ')}.`);
+  }
+  if (!metadata.cover) {
+    warnings.push('Listing cover missing at metadata/cover.png.');
+  } else {
+    errors.push(...metadata.cover.errors);
+    warnings.push(...metadata.cover.warnings);
+  }
+  if (metadata.screenshots.length < 3) {
+    warnings.push(`Listing screenshots: ${metadata.screenshots.length}/3 minimum in metadata/screenshot-N.png.`);
+  }
+  for (const screenshot of metadata.screenshots) {
+    errors.push(...screenshot.errors);
+    warnings.push(...screenshot.warnings);
+  }
+
+  return {
+    ready: errors.length === 0 && Boolean(config.tagline) && categories.length > 0 && Boolean(metadata.cover) && metadata.screenshots.length >= 1,
+    warnings,
+    errors,
+    metadata,
+    categories,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Build
 // ---------------------------------------------------------------------------
@@ -409,6 +579,21 @@ function generateEntryFile(projectDir, routes) {
   return entryPath;
 }
 
+export async function prepareArtifactBuild(projectDir) {
+  validateProjectBoundary(projectDir);
+  const appConfig = await loadAppConfig(projectDir);
+  const detectedRoutes = resolveConfiguredRoutes(appConfig, projectDir);
+
+  generateEntryFile(projectDir, detectedRoutes);
+
+  const manifest = generateManifest(appConfig, projectDir);
+  const manifestPath = join(projectDir, MANIFEST_FILE);
+  mkdirSync(dirname(manifestPath), { recursive: true });
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+
+  return { appConfig, manifest, routes: detectedRoutes };
+}
+
 /**
  * Generate the manifest from app config and build output.
  */
@@ -431,15 +616,52 @@ export function generateManifest(appConfig, projectDir) {
   });
 
   const databases = appConfig.databases || [];
+  const categories = normalizeCategories(appConfig.categories || []);
+  const metadata = discoverMetadataAssets(projectDir);
+  const appSlug = safeKebab(appConfig.name);
+  const displayTitle = appConfig.title || appConfig.displayName || appConfig.name;
+  const listingMedia = {
+    cover: metadata.cover
+      ? {
+          path: metadata.cover.path,
+          content_type: metadata.cover.content_type,
+          width: metadata.cover.width,
+          height: metadata.cover.height,
+          bytes: metadata.cover.bytes,
+        }
+      : null,
+    screenshots: metadata.screenshots.map((screenshot) => ({
+      path: screenshot.path,
+      content_type: screenshot.content_type,
+      width: screenshot.width,
+      height: screenshot.height,
+      bytes: screenshot.bytes,
+    })),
+  };
 
   return {
     version: 1,
-    spec_version: 3,
+    spec_version: 4,
     app: {
-      name: appConfig.name,
+      name: displayTitle,
+      slug: appSlug || null,
       description: appConfig.description || null,
       icon: appConfig.icon || null,
+      title: displayTitle,
+      tagline: appConfig.tagline || null,
+      categories,
+      author: appConfig.author || null,
+      version_notes: appConfig.versionNotes || appConfig.version_notes || null,
     },
+    listing: {
+      title: displayTitle,
+      tagline: appConfig.tagline || null,
+      categories,
+      author: appConfig.author || null,
+      version_notes: appConfig.versionNotes || appConfig.version_notes || null,
+      media: listingMedia,
+    },
+    metadata: listingMedia,
     routes,
     bundle: {
       js: 'bundle/app.js',
@@ -454,14 +676,7 @@ export function generateManifest(appConfig, projectDir) {
  * Build the app bundle: generate entry file, run `vite build`, package into .notis/output/.
  */
 export async function buildArtifact(projectDir) {
-  validateProjectBoundary(projectDir);
-  const appConfig = await loadAppConfig(projectDir);
-
-  // Auto-detect or use configured routes
-  const detectedRoutes = resolveConfiguredRoutes(appConfig, projectDir);
-
-  // Generate the entry file that re-exports all route page components
-  generateEntryFile(projectDir, detectedRoutes);
+  await prepareArtifactBuild(projectDir);
 
   // Run Vite build
   await runProjectScript({
@@ -477,14 +692,11 @@ export async function buildArtifact(projectDir) {
     );
   }
   normalizeBundleStylesheets(projectDir);
+  copyMetadataAssets(projectDir);
 
   validateArtifactBoundary(readArtifactFiles(projectDir));
 
-  // Generate manifest
-  const manifest = generateManifest(appConfig, projectDir);
-  const manifestPath = join(projectDir, MANIFEST_FILE);
-  mkdirSync(dirname(manifestPath), { recursive: true });
-  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+  const manifest = readManifest(projectDir);
 
   return { manifest, outputDir: join(projectDir, OUTPUT_DIR) };
 }
@@ -500,6 +712,22 @@ export function readManifest(projectDir) {
   return JSON.parse(readFileSync(manifestPath, 'utf-8'));
 }
 
+function copyMetadataAssets(projectDir) {
+  const metadataDir = join(projectDir, METADATA_DIR);
+  if (!existsSync(metadataDir)) {
+    return;
+  }
+  const outputMetadataDir = join(projectDir, OUTPUT_DIR, METADATA_DIR);
+  mkdirSync(outputMetadataDir, { recursive: true });
+  for (const entry of readdirSync(metadataDir, { withFileTypes: true })) {
+    if (!entry.isFile()) continue;
+    if (entry.name !== 'cover.png' && !/^screenshot-\d+\.png$/i.test(entry.name)) {
+      continue;
+    }
+    cpSync(join(metadataDir, entry.name), join(outputMetadataDir, entry.name));
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Linking
 // ---------------------------------------------------------------------------
@@ -530,24 +758,37 @@ export function requireLinkedAppId(projectDir, explicitAppId) {
 /**
  * Scaffold a new Notis app project from the SDK template.
  */
-export function scaffoldProject({ projectDir, appName }) {
-  const templateDir = resolve(
-    dirname(fileURLToPath(import.meta.url)),
-    '../../template',
-  );
+export function loadScaffoldCatalog() {
+  if (existsSync(SCAFFOLD_CATALOG_FILE)) {
+    const parsed = JSON.parse(readFileSync(SCAFFOLD_CATALOG_FILE, 'utf-8'));
+    const scaffolds = Array.isArray(parsed?.scaffolds) ? parsed.scaffolds : parsed;
+    return Array.isArray(scaffolds)
+      ? scaffolds.filter((entry) => entry && typeof entry.slug === 'string')
+      : [];
+  }
+  return loadMonorepoScaffoldCatalog();
+}
+
+export function scaffoldProject({ projectDir, appName, fromSlug = null }) {
+  const templateDir = fromSlug ? resolveScaffoldSourceDir(fromSlug) : join(CLI_ROOT, 'template');
 
   if (!existsSync(templateDir)) {
+    if (fromSlug) {
+      const known = loadScaffoldCatalog().map((entry) => entry.slug).join(', ') || 'none';
+      throw usageError(`Unknown scaffold "${fromSlug}". Available scaffolds: ${known}.`);
+    }
     throw usageError(`SDK template not found at ${templateDir}. Ensure @notis_ai/cli is installed correctly.`);
   }
 
   mkdirSync(projectDir, { recursive: true });
-  cpSync(templateDir, projectDir, { recursive: true });
+  copyScaffoldSource(templateDir, projectDir);
 
   // Update package.json with the app name
   const pkgPath = join(projectDir, 'package.json');
   if (existsSync(pkgPath)) {
     const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
     pkg.name = appName.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+    ensureScaffoldLocalSdk(projectDir, pkg);
     writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
   }
 
@@ -555,13 +796,141 @@ export function scaffoldProject({ projectDir, appName }) {
   const configPath = join(projectDir, 'notis.config.ts');
   if (existsSync(configPath)) {
     let config = readFileSync(configPath, 'utf-8');
-    config = config.replace(/'My Notis App'/, `'${appName.replace(/'/g, "\\'")}'`);
+    const displayName = jsStringLiteral(appName);
+    const slugName = jsStringLiteral(safeKebab(appName) || 'my-notis-app');
+    if (fromSlug) {
+      if (/name\s*:/.test(config)) {
+        config = config.replace(/name\s*:\s*(['"`])[\s\S]*?\1/, `name: ${slugName}`);
+      }
+      if (/title\s*:/.test(config)) {
+        config = config.replace(/title\s*:\s*(['"`])[\s\S]*?\1/, `title: ${displayName}`);
+      } else {
+        config = config.replace(/name\s*:\s*(['"`])[\s\S]*?\1/, `name: ${slugName},\n  title: ${displayName}`);
+      }
+    } else {
+      if (/name\s*:/.test(config)) {
+        config = config.replace(/name\s*:\s*(['"`])[\s\S]*?\1/, `name: ${slugName}`);
+      }
+      if (/title\s*:/.test(config)) {
+        config = config.replace(/title\s*:\s*(['"`])[\s\S]*?\1/, `title: ${displayName}`);
+      } else {
+        config = config.replace(/'My Notis App'/, displayName);
+      }
+    }
     writeFileSync(configPath, config);
   }
 
   return { projectDir };
 }
 
+function ensureScaffoldLocalSdk(projectDir, pkg) {
+  let shouldInstallLocalSdk = false;
+  for (const dependencyGroup of ['dependencies', 'devDependencies']) {
+    const dependencyValue = pkg[dependencyGroup]?.['@notis/sdk'];
+    if (typeof dependencyValue === 'string' && dependencyValue.startsWith('file:')) {
+      pkg[dependencyGroup]['@notis/sdk'] = 'file:./packages/sdk';
+      shouldInstallLocalSdk = true;
+    }
+  }
+
+  if (!shouldInstallLocalSdk) {
+    return;
+  }
+
+  const localSdkDir = join(projectDir, 'packages', 'sdk');
+  if (existsSync(join(localSdkDir, 'package.json'))) {
+    return;
+  }
+  if (!existsSync(join(TEMPLATE_SDK_DIR, 'package.json'))) {
+    throw usageError(`SDK template not found at ${TEMPLATE_SDK_DIR}. Ensure @notis_ai/cli is installed correctly.`);
+  }
+
+  mkdirSync(dirname(localSdkDir), { recursive: true });
+  cpSync(TEMPLATE_SDK_DIR, localSdkDir, { recursive: true, dereference: true });
+}
+
+function resolveScaffoldSourceDir(fromSlug) {
+  const bundledDir = join(SCAFFOLD_SOURCE_DIR, fromSlug);
+  if (existsSync(bundledDir)) {
+    return bundledDir;
+  }
+  const monorepoDir = join(MONOREPO_APPS_DIR, fromSlug);
+  if (existsSync(join(monorepoDir, 'notis.config.ts'))) {
+    return monorepoDir;
+  }
+  return bundledDir;
+}
+
+function loadMonorepoScaffoldCatalog() {
+  if (!existsSync(MONOREPO_APPS_DIR)) {
+    return [];
+  }
+  const scaffolds = [];
+  for (const entry of readdirSync(MONOREPO_APPS_DIR, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name.startsWith('_')) {
+      continue;
+    }
+    const configPath = join(MONOREPO_APPS_DIR, entry.name, 'notis.config.ts');
+    if (!existsSync(configPath)) {
+      continue;
+    }
+    const configSource = readFileSync(configPath, 'utf-8');
+    const description = readTsStringProperty(configSource, 'description') || '';
+    scaffolds.push({
+      slug: entry.name,
+      name: readTsStringProperty(configSource, 'title') || readTsStringProperty(configSource, 'name') || entry.name,
+      description,
+      icon: readTsStringProperty(configSource, 'icon') || 'phosphor:squares-four',
+      categories: readTsStringArrayProperty(configSource, 'categories'),
+      tagline: readTsStringProperty(configSource, 'tagline') || description,
+    });
+  }
+  return scaffolds.sort((a, b) => a.slug.localeCompare(b.slug));
+}
+
+function readTsStringProperty(source, propertyName) {
+  const match = source.match(new RegExp(`\\b${propertyName}\\s*:\\s*(['"\`])([\\s\\S]*?)\\1`));
+  return match ? match[2] : null;
+}
+
+function readTsStringArrayProperty(source, propertyName) {
+  const match = source.match(new RegExp(`\\b${propertyName}\\s*:\\s*\\[([\\s\\S]*?)\\]`));
+  if (!match) {
+    return [];
+  }
+  return Array.from(match[1].matchAll(/(['"`])([\s\S]*?)\1/g), (entry) => entry[2].trim()).filter(Boolean);
+}
+
+function copyScaffoldSource(sourceDir, targetDir) {
+  function shouldCopy(path) {
+    const name = path.split(/[\\/]/).pop();
+    if (!name) return true;
+    return !SCAFFOLD_COPY_EXCLUDES.has(name)
+      && !name.startsWith('.env')
+      && !/\.(test|spec)\.[cm]?[jt]sx?$/i.test(name);
+  }
+
+  function walk(src, dest) {
+    if (!shouldCopy(src)) {
+      return;
+    }
+    const stat = statSync(src);
+    if (stat.isDirectory()) {
+      mkdirSync(dest, { recursive: true });
+      for (const entry of readdirSync(src)) {
+        walk(join(src, entry), join(dest, entry));
+      }
+      return;
+    }
+    if (stat.isFile()) {
+      mkdirSync(dirname(dest), { recursive: true });
+      cpSync(src, dest);
+    }
+  }
+
+  walk(sourceDir, targetDir);
+}
+
 // ---------------------------------------------------------------------------
 // Deploy helpers
 // ---------------------------------------------------------------------------
@@ -700,8 +1069,14 @@ export async function pullAppSource({
   const versionMatch = /-v(\d+)\.tar\.gz/i.exec(contentDisposition);
   const pulledVersion = versionMatch ? Number.parseInt(versionMatch[1], 10) : null;
   extractTarGz(Buffer.from(await response.arrayBuffer()), targetDir);
+  const linkedVersion = pulledVersion || (
+    String(version || 'latest') === 'latest'
+      ? undefined
+      : Number.parseInt(String(version), 10)
+  );
   writeLinkedState(targetDir, {
     app_id: appId,
+    ...(Number.isFinite(linkedVersion) ? { version: linkedVersion } : {}),
     linked_at: new Date().toISOString(),
   });
 
@@ -898,6 +1273,9 @@ const CONTENT_TYPE_MAP = {
   '.css': 'text/css',
   '.json': 'application/json',
   '.html': 'text/html',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
 };
 
 /**
@@ -952,6 +1330,8 @@ export async function directDeploy(projectDir, appId) {
     version: newVersion,
     storage_bucket: bucket,
     storage_prefix: storagePrefix,
+    source_storage_bucket: 'app-source',
+    source_storage_prefix: storagePrefix,
   };
   await updateAppVersion(supabaseUrl, supabaseKey, appId, newVersion, deployManifest);
 

package/src/runtime/profiles.js

@@ -205,22 +205,28 @@ export function resolveRuntimeProfile(globalOptions = {}, { requireAuth = true }
       exitCode: EXIT_CODES.auth,
       hints: [
         {
-          command: 'notis auth login --jwt <token>',
-          reason: 'Configure a token for non-interactive use',
+          command: 'Open the Notis desktop app and sign in',
+          reason: 'Set NOTIS_JWT or sign in through the Notis desktop app',
         },
       ],
     });
   }
 
+  // An explicit NOTIS_JWT is a complete credential override: use it verbatim and do
+  // NOT attempt a stored-profile dev_portal token refresh (whose refresh_token may be
+  // stale or belong to a different session). Without this, a long-lived shell with an
+  // expired profile refresh_token fails every command with invalid_grant even though
+  // the supplied NOTIS_JWT is valid.
+  const usingEnvJwt = Boolean(process.env.NOTIS_JWT);
   return {
     config,
     profileName,
     apiBase,
     jwt,
-    authMode: profile.auth_mode,
-    refreshToken: profile.refresh_token,
-    accessExpiresAt: profile.access_expires_at,
-    refreshExpiresAt: profile.refresh_expires_at,
+    authMode: usingEnvJwt ? 'jwt' : profile.auth_mode,
+    refreshToken: usingEnvJwt ? undefined : profile.refresh_token,
+    accessExpiresAt: usingEnvJwt ? undefined : profile.access_expires_at,
+    refreshExpiresAt: usingEnvJwt ? undefined : profile.refresh_expires_at,
     agentMode,
     nonInteractive,
     outputMode,