@notis_ai/cli 0.2.7 → 0.2.9

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

@@ -1,6 +1,5 @@
 import { randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { dirname, join, parse as parsePath } from 'node:path';
 import { CONFIG_DIR } from './profiles.js';
 
@@ -9,37 +8,6 @@ export const APP_DEV_SESSIONS_FILE = DEFAULT_APP_DEV_SESSIONS_FILE;
 export const APP_DEV_SESSIONS_VERSION = 1;
 export const APP_DEV_SESSION_MOUNT_ACKS_VERSION = 1;
 
-/**
- * Walk up from `startDir` looking for a workspace-scoped dev-sessions registry.
- *
- * The Notis desktop (and Conductor) reads a PER-WORKSPACE registry at
- * `<workspace>/.context/app-dev-sessions.json` (it points its own `apps dev`
- * at it via `NOTIS_APP_DEV_SESSIONS_FILE`). When a coding agent runs
- * `apps dev` manually it does not inherit that env var, so its session would
- * otherwise land in the global `~/.notis` registry and never appear in the
- * desktop's Local development sidebar. Resolving the nearest `.context`
- * registry keeps agent-run and desktop-run sessions in the same file.
- *
- * Returns the registry path if a `.context/` directory is found in `startDir`
- * or an ancestor (stopping at the home directory / filesystem root), else null.
- */
-export function findWorkspaceAppDevSessionsFile(startDir = process.cwd()) {
-  let dir = startDir;
-  const home = homedir();
-  const { root } = parsePath(dir);
-  // Bounded walk; `.context` lives at the workspace root, never above $HOME.
-  for (let depth = 0; depth < 64; depth += 1) {
-    if (existsSync(join(dir, '.context'))) {
-      return join(dir, '.context', 'app-dev-sessions.json');
-    }
-    if (dir === home || dir === root) break;
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-}
-
 export function getAppDevSessionsFile(filePath) {
   if (filePath) {
     return filePath;
@@ -48,10 +16,6 @@ export function getAppDevSessionsFile(filePath) {
   if (typeof envPath === 'string' && envPath.trim()) {
     return envPath.trim();
   }
-  const workspaceFile = findWorkspaceAppDevSessionsFile();
-  if (workspaceFile) {
-    return workspaceFile;
-  }
   return DEFAULT_APP_DEV_SESSIONS_FILE;
 }
 
@@ -173,7 +137,7 @@ function normalizeMountAcknowledgements(raw) {
     typeof acknowledgement.devSlug === 'string' &&
     typeof acknowledgement.mountNonce === 'string' &&
     typeof acknowledgement.acknowledgedAt === 'string' &&
-    acknowledgement.stage === 'listed',
+    ['listed', 'rendered'].includes(acknowledgement.stage),
   );
 }
 
@@ -218,12 +182,13 @@ export function removeAppDevSessionMountAcknowledgements(sessionId, sessionsFile
   return writeAppDevSessionMountAcknowledgements(registry, sessionsFilePath);
 }
 
-function mountAcknowledgementKey(value) {
-  return `${value.sessionId}:${value.appId}:${value.devSlug}:${value.mountNonce}`;
+function mountAcknowledgementKey(value, fallbackStage = 'listed') {
+  return `${value.sessionId}:${value.appId}:${value.devSlug}:${value.mountNonce}:${value.stage || fallbackStage}`;
 }
 
 export async function waitForAppDevSessionMountAcknowledgements(expectedSessions, options = {}) {
   const expected = Array.isArray(expectedSessions) ? expectedSessions : [expectedSessions];
+  const stage = options.stage === 'rendered' ? 'rendered' : 'listed';
   const timeoutMs = Number.isFinite(options.timeoutMs) ? Math.max(0, options.timeoutMs) : 15_000;
   const pollIntervalMs = Number.isFinite(options.pollIntervalMs)
     ? Math.max(1, options.pollIntervalMs)
@@ -237,7 +202,9 @@ export async function waitForAppDevSessionMountAcknowledgements(expectedSessions
   while (true) {
     const registry = readAppDevSessionMountAcknowledgements(options.sessionsFilePath);
     const acknowledgedKeys = new Set(registry.acknowledgements.map(mountAcknowledgementKey));
-    const missing = expected.filter((session) => !acknowledgedKeys.has(mountAcknowledgementKey(session)));
+    const missing = expected.filter(
+      (session) => !acknowledgedKeys.has(mountAcknowledgementKey(session, stage)),
+    );
     if (missing.length === 0) {
       return { mounted: true, missing: [], acknowledgements: registry.acknowledgements };
     }
@@ -249,3 +216,10 @@ export async function waitForAppDevSessionMountAcknowledgements(expectedSessions
     await sleep(Math.min(pollIntervalMs, timeoutMs - elapsedMs));
   }
 }
+
+export function waitForAppDevSessionRenderAcknowledgements(expectedSessions, options = {}) {
+  return waitForAppDevSessionMountAcknowledgements(expectedSessions, {
+    ...options,
+    stage: 'rendered',
+  });
+}

package/src/runtime/app-platform.js

@@ -231,7 +231,13 @@ export function detectProjectWarnings(projectDir, appConfig = null) {
     warnings.push('Missing Tailwind config.');
   }
 
-  if (appConfig && (!Array.isArray(appConfig.databases) || appConfig.databases.length === 0)) {
+  const readsWorkspaceDatabases =
+    appConfig?.capabilities?.workspaceDatabases === 'read';
+  if (
+    appConfig
+    && !readsWorkspaceDatabases
+    && (!Array.isArray(appConfig.databases) || appConfig.databases.length === 0)
+  ) {
     warnings.push('No database references declared in notis.config.ts.');
   }
 
@@ -490,13 +496,24 @@ export async function runProjectScript({ projectDir, scriptName, env = {}, stdio
       stdio,
       env: { ...process.env, ...env },
     });
+    let capturedOutput = '';
+    for (const stream of [child.stdout, child.stderr]) {
+      stream?.on('data', (chunk) => {
+        capturedOutput += chunk.toString();
+      });
+    }
     child.on('error', rejectPromise);
     child.on('exit', (code) => {
       if (code === 0) {
         resolvePromise();
         return;
       }
-      rejectPromise(new Error(`npm run ${scriptName} failed with exit code ${code}`));
+      const detail = capturedOutput.trim();
+      rejectPromise(
+        new Error(
+          `npm run ${scriptName} failed with exit code ${code}${detail ? `:\n${detail}` : ''}`,
+        ),
+      );
     });
   });
 }
@@ -707,7 +724,14 @@ export function generateManifest(appConfig, projectDir) {
     return entry;
   });
 
-  const databases = appConfig.databases || [];
+  // Database entries may be a bare slug (structure only) or an object opting
+  // into shipping rows to installers. Normalize to the manifest's snake_case.
+  const databases = (appConfig.databases || []).map((entry) => {
+    if (typeof entry === 'string') return entry;
+    if (!entry || typeof entry !== 'object' || !entry.slug) return entry;
+    const seedDocuments = entry.seedDocuments ?? entry.seed_documents;
+    return seedDocuments === true ? { slug: entry.slug, seed_documents: true } : entry.slug;
+  });
   const categories = normalizeCategories(appConfig.categories || []);
   const metadata = { screenshots: resolveListingScreenshots(projectDir, appConfig) };
   const appSlug = safeKebab(appConfig.name);
@@ -786,12 +810,29 @@ export function generateManifest(appConfig, projectDir) {
       css: 'bundle/app.css',
     },
     databases,
+    capabilities: normalizeAppCapabilities(appConfig.capabilities),
     tools: appConfig.tools || [],
     skills,
     onboarding: appConfig.onboarding || null,
   };
 }
 
+/**
+ * Keeps only capabilities the platform actually understands, at the exact
+ * values it accepts. An unknown key or value is dropped rather than passed
+ * through, so a typo can never reach the server as a permission grant.
+ */
+export function normalizeAppCapabilities(capabilities) {
+  if (!capabilities || typeof capabilities !== 'object') {
+    return {};
+  }
+  const normalized = {};
+  if (capabilities.workspaceDatabases === 'read') {
+    normalized.workspaceDatabases = 'read';
+  }
+  return normalized;
+}
+
 export function resolveConfiguredAppSkills(appConfig, projectDir) {
   const configured = Array.isArray(appConfig.skills) ? appConfig.skills : [];
   const projectRoot = resolve(projectDir);
@@ -831,13 +872,14 @@ export function resolveConfiguredAppSkills(appConfig, projectDir) {
 /**
  * Build the app bundle: generate entry file, run `vite build`, package into .notis/output/.
  */
-export async function buildArtifact(projectDir) {
+export async function buildArtifact(projectDir, { stdio = 'inherit' } = {}) {
   await prepareArtifactBuild(projectDir);
 
   // Run Vite build
   await runProjectScript({
     projectDir,
     scriptName: 'build',
+    stdio,
   });
 
   // Verify the canonical `.notis/output/bundle` packaging contract.
@@ -948,8 +990,13 @@ export function scaffoldProject({ projectDir, appName, fromSlug = null }) {
   if (existsSync(pkgPath)) {
     const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
     pkg.name = appName.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+    // A scaffold creates a new app identity, even when its source comes from a
+    // versioned Store example. New apps must therefore start their own release
+    // history instead of inheriting the example app's registry version.
+    pkg.notisAppVersion = '0.1.0';
     ensureScaffoldLocalSdk(projectDir, pkg);
     writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    normalizeScaffoldLockfile(projectDir, pkg);
   }
 
   // Update notis.config.ts with the app name
@@ -983,6 +1030,20 @@ export function scaffoldProject({ projectDir, appName, fromSlug = null }) {
   return { projectDir };
 }
 
+function normalizeScaffoldLockfile(projectDir, pkg) {
+  const lockPath = join(projectDir, 'package-lock.json');
+  if (!existsSync(lockPath)) {
+    return;
+  }
+
+  const lockfile = JSON.parse(readFileSync(lockPath, 'utf-8'));
+  lockfile.name = pkg.name;
+  if (lockfile.packages?.['']) {
+    lockfile.packages[''].name = pkg.name;
+  }
+  writeFileSync(lockPath, JSON.stringify(lockfile, null, 2) + '\n');
+}
+
 function ensureScaffoldLocalSdk(projectDir, pkg) {
   let shouldInstallLocalSdk = false;
   for (const dependencyGroup of ['dependencies', 'devDependencies']) {

package/src/runtime/desktop-auth.js

@@ -24,7 +24,15 @@ function defaultDesktopAppName(apiBase) {
   }
 }
 
-export function getDesktopAuthRecovery(runtime) {
+/**
+ * Recovery hints for an unusable desktop-managed credential.
+ *
+ * `mode` distinguishes the two cases an agent has to act on differently:
+ * "expired" means a session existed and the desktop app can renew it, while
+ * "missing" means this machine was never signed in — telling that caller to
+ * renew something is misleading.
+ */
+export function getDesktopAuthRecovery(runtime, { mode = 'expired' } = {}) {
   const desktopRunning = isPidRunning(runtime.desktopPid);
   const appName = runtime.desktopAppName || defaultDesktopAppName(runtime.apiBase);
   let command = 'Start the Notis desktop app';
@@ -32,25 +40,78 @@ export function getDesktopAuthRecovery(runtime) {
     command = `open -a ${quoteShellArgument(appName)}`;
   }
 
-  return {
-    desktopRunning,
-    appName,
-    hints: [
-      {
-        command,
-        reason: desktopRunning
-          ? `Bring ${appName} forward so it can renew CLI authentication, then retry`
-          : `Start ${appName} to renew expired CLI authentication, then retry`,
-      },
-      {
-        command: 'notis doctor',
-        reason: 'Retry the auth and API checks after the desktop app is ready',
-      },
-    ],
-  };
+  let reason;
+  if (mode === 'missing') {
+    reason = desktopRunning
+      ? `Sign in to ${appName} to authenticate the CLI on this machine, then retry`
+      : `Install and sign in to ${appName} to authenticate the CLI on this machine, then retry`;
+  } else {
+    reason = desktopRunning
+      ? `Bring ${appName} forward so it can renew CLI authentication, then retry`
+      : `Start ${appName} to renew expired CLI authentication, then retry`;
+  }
+
+  const hints = [{ command, reason }];
+  if (mode === 'missing') {
+    // Leads the list: a machine that was never signed in may not even have an
+    // account yet, and `notis start` covers both cases.
+    hints.unshift({
+      command: 'notis login',
+      reason: 'Sign in or create an account in the browser and authorize this machine',
+    });
+  }
+  hints.push({
+    command: 'notis doctor',
+    reason: 'Retry the auth and API checks after the desktop app is ready',
+  });
+
+  return { desktopRunning, appName, hints };
+}
+
+/**
+ * Block until the desktop app writes an unexpired JWT into the CLI profile.
+ *
+ * Polls the local config file only — never the server. The desktop app is what
+ * mints the credential, and `transport.js` re-reads the profile before every
+ * request, so this loop exists purely so the caller's process can wait rather
+ * than fail and make the user re-run the command.
+ */
+export async function waitForDesktopAuth({
+  loadConfig,
+  getJwt,
+  isJwtExpired,
+  profileName = 'default',
+  timeoutMs = 300_000,
+  intervalMs = 2_000,
+  onTick,
+} = {}) {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const jwt = getJwt(loadConfig(), profileName);
+    if (jwt && !isJwtExpired(jwt)) {
+      return jwt;
+    }
+    if (Date.now() >= deadline) {
+      return null;
+    }
+    if (onTick) onTick(Math.max(0, deadline - Date.now()));
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
 }
 
 export function createExpiredAuthError(runtime) {
+  if (runtime.credentialKind === 'oauth') {
+    return new CliError({
+      code: 'auth_expired',
+      message: 'Notis CLI OAuth authentication has expired',
+      exitCode: EXIT_CODES.auth,
+      details: { credential_source: 'oauth' },
+      hints: [
+        { command: 'notis login', reason: 'Authorize a new scoped CLI credential' },
+        { command: 'notis doctor', reason: 'Inspect the active credential state' },
+      ],
+    });
+  }
   if (runtime.credentialSource === 'env') {
     return new CliError({
       code: 'auth_expired',
@@ -81,6 +142,14 @@ export function createExpiredAuthError(runtime) {
 }
 
 export function createInvalidAuthHints(runtime) {
+  if (runtime?.credentialKind === 'oauth') {
+    return [
+      {
+        command: 'notis login',
+        reason: 'Authorize a new scoped CLI credential',
+      },
+    ];
+  }
   if (runtime?.credentialSource === 'env') {
     return [
       {

package/src/runtime/errors.js

@@ -6,6 +6,7 @@ export const EXIT_CODES = {
   conflict: 5,
   backend: 6,
   unexpected: 7,
+  payment: 8,
 };
 
 export class CliError extends Error {