@notis_ai/cli 0.2.4 → 0.2.6

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

@@ -25,13 +25,17 @@ import {
   loadAppConfig,
   prepareArtifactBuild,
   readManifest,
+  readLinkedState,
+  writeLinkedState,
 } from './app-platform.js';
+import { linkAppDevSessionTarget } from './app-dev-sessions.js';
 
 const CONTENT_TYPES = {
   '.js': 'application/javascript; charset=utf-8',
   '.css': 'text/css; charset=utf-8',
   '.map': 'application/json; charset=utf-8',
 };
+const MAX_JSON_BODY_BYTES = 64 * 1024;
 const RUNTIME_DIR = dirname(fileURLToPath(import.meta.url));
 const CLI_ROOT = resolve(RUNTIME_DIR, '../..');
 const REPO_ROOT = resolve(RUNTIME_DIR, '../../../..');
@@ -59,7 +63,7 @@ function corsHeaders(origin) {
   const allowOrigin = origin && isAllowedOrigin(origin) ? origin : '*';
   return {
     'Access-Control-Allow-Origin': allowOrigin,
-    'Access-Control-Allow-Methods': 'GET, OPTIONS',
+    'Access-Control-Allow-Methods': 'GET, HEAD, POST, OPTIONS',
     'Access-Control-Allow-Headers': 'Content-Type, Cache-Control',
     'Cache-Control': 'no-store',
   };
@@ -97,6 +101,32 @@ function readJsonFile(path) {
   }
 }
 
+function readRequestJson(req) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    let body = '';
+    req.setEncoding('utf8');
+    req.on('data', (chunk) => {
+      body += chunk;
+      if (Buffer.byteLength(body, 'utf8') > MAX_JSON_BODY_BYTES) {
+        rejectPromise(new Error('request body too large'));
+        req.destroy();
+      }
+    });
+    req.on('end', () => {
+      if (!body.trim()) {
+        resolvePromise({});
+        return;
+      }
+      try {
+        resolvePromise(JSON.parse(body));
+      } catch {
+        rejectPromise(new Error('invalid JSON body'));
+      }
+    });
+    req.on('error', rejectPromise);
+  });
+}
+
 function reactVersionFromPeer(peerRange) {
   if (typeof peerRange !== 'string' || !peerRange) {
     return FALLBACK_REACT_VERSION;
@@ -186,7 +216,7 @@ function findHarnessRoute(manifest, routeSlug) {
   return routes.find((route) => route?.slug === routeSlug) || null;
 }
 
-function buildHarnessDescriptor({ state, manifest, appConfig, route }) {
+function buildHarnessDescriptor({ state, manifest, appConfig, route, scenario = null }) {
   const databases = normalizeDatabaseDescriptors(
     Array.isArray(appConfig?.databases) && appConfig.databases.length
       ? appConfig.databases
@@ -216,14 +246,28 @@ function buildHarnessDescriptor({ state, manifest, appConfig, route }) {
       collection: route.collection || null,
     },
     databases,
-    context: { collectionItem: null },
+    context: { collectionItem: null, screenshotScenario: scenario },
     tools,
   };
 }
 
-function renderHarnessHtml({ state, manifest, appConfig, route, harnessOptions }) {
+function harnessFixtures(projectDir, scenario) {
+  const fixtureConfig = readJsonFile(join(projectDir, 'metadata', 'screenshot-fixtures.json')) || {};
+  const scenarios = fixtureConfig.scenarios && typeof fixtureConfig.scenarios === 'object'
+    ? fixtureConfig.scenarios
+    : {};
+  return {
+    tools: fixtureConfig.tools && typeof fixtureConfig.tools === 'object' ? fixtureConfig.tools : {},
+    requests: fixtureConfig.requests && typeof fixtureConfig.requests === 'object' ? fixtureConfig.requests : {},
+    scenario: scenario && scenarios[scenario] && typeof scenarios[scenario] === 'object'
+      ? scenarios[scenario]
+      : null,
+  };
+}
+
+function renderHarnessHtml({ state, manifest, appConfig, route, harnessOptions, scenario = null }) {
   const template = readFileSync(HARNESS_TEMPLATE_PATH, 'utf-8');
-  const descriptor = buildHarnessDescriptor({ state, manifest, appConfig, route });
+  const descriptor = buildHarnessDescriptor({ state, manifest, appConfig, route, scenario });
   const routeExport = route.export_name || route.exportName || exportNameFromPath(route.path || '/');
   const replacements = {
     '{{REACT_VERSION}}': resolveHarnessReactVersion(state.projectDir),
@@ -232,6 +276,7 @@ function renderHarnessHtml({ state, manifest, appConfig, route, harnessOptions }
     '{{MODE}}': scriptJson(harnessOptions.mode || 'stub'),
     '{{API_BASE}}': scriptJson(harnessOptions.apiBase || null),
     '{{JWT}}': scriptJson(harnessOptions.jwt || null),
+    '{{FIXTURES}}': scriptJson(harnessFixtures(state.projectDir, scenario)),
   };
   let html = template;
   for (const [token, value] of Object.entries(replacements)) {
@@ -243,7 +288,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, userId?: 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, targetAppId?: 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,
@@ -263,6 +308,7 @@ export async function startAppDevServer({
       slug: app.slug,
       projectDir: app.projectDir,
       appId: app.appId || null,
+      targetAppId: app.targetAppId || null,
       userId: app.userId || null,
       canonicalBundleDir: getBundleDir(app.projectDir),
       bundleDir: null,
@@ -339,6 +385,7 @@ export async function startAppDevServer({
     }
 
     const routeSlug = url.searchParams.get('route') || '';
+    const scenario = url.searchParams.get('scenario') || null;
     const route = findHarnessRoute(manifest, routeSlug);
     if (!route) {
       res.writeHead(404, {
@@ -355,6 +402,7 @@ export async function startAppDevServer({
       appConfig,
       route,
       harnessOptions: harness,
+      scenario,
     });
     res.writeHead(200, {
       ...headers,
@@ -385,6 +433,63 @@ export async function startAppDevServer({
     }
 
     if (req.method !== 'GET' && req.method !== 'HEAD') {
+      if (req.method === 'POST') {
+        const routed = matchAppRoute(url.pathname);
+        const state = routed ? appState.get(routed.slug) : null;
+        if (state && routed.rest === 'link') {
+          void (async () => {
+            try {
+              const body = await readRequestJson(req);
+              const appId = typeof body.app_id === 'string' ? body.app_id.trim() : '';
+              if (!appId) {
+                res.writeHead(400, {
+                  ...headers,
+                  'Content-Type': 'application/json; charset=utf-8',
+                });
+                res.end(JSON.stringify({ error: 'app_id is required' }));
+                return;
+              }
+
+              const currentState = readLinkedState(state.projectDir) || {};
+              const now = new Date().toISOString();
+              writeLinkedState(state.projectDir, {
+                ...currentState,
+                app_id: appId,
+                dev_app_id: state.appId || currentState.dev_app_id,
+                linked_at: currentState.linked_at || now,
+                dev_linked_at: currentState.dev_linked_at || now,
+                updated_at: now,
+              });
+              state.targetAppId = appId;
+              linkAppDevSessionTarget({
+                appId: state.appId,
+                devSlug: state.slug,
+                targetAppId: appId,
+                lastHeartbeatAt: now,
+              });
+              const response = {
+                ok: true,
+                app_id: appId,
+                dev_app_id: state.appId || null,
+                target_app_id: appId,
+              };
+              res.writeHead(200, {
+                ...headers,
+                'Content-Type': 'application/json; charset=utf-8',
+              });
+              res.end(JSON.stringify(response));
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              res.writeHead(400, {
+                ...headers,
+                'Content-Type': 'application/json; charset=utf-8',
+              });
+              res.end(JSON.stringify({ error: message }));
+            }
+          })();
+          return;
+        }
+      }
       res.writeHead(405, headers);
       res.end('method not allowed');
       return;
@@ -394,6 +499,7 @@ export async function startAppDevServer({
       const now = new Date().toISOString();
       const sessions = Array.from(appState.values()).map((state) => ({
         appId: state.appId,
+        targetAppId: state.targetAppId || undefined,
         userId: state.userId,
         devSlug: state.slug,
         bundleBaseUrl: `http://127.0.0.1:${port}/a/${state.slug}`,
@@ -446,6 +552,7 @@ export async function startAppDevServer({
         const manifest = readManifest(state.projectDir);
         const payload = {
           app_id: state.appId,
+          target_app_id: state.targetAppId || null,
           dev_slug: state.slug,
           manifest,
           files: collectArtifactFiles(state.projectDir),

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

@@ -1,33 +1,85 @@
 import { randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { dirname, join, parse as parsePath } from 'node:path';
 import { CONFIG_DIR } from './profiles.js';
 
 export const DEFAULT_APP_DEV_SESSIONS_FILE = join(CONFIG_DIR, 'app-dev-sessions.json');
 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;
   }
   const envPath = process.env.NOTIS_APP_DEV_SESSIONS_FILE;
-  return typeof envPath === 'string' && envPath.trim()
-    ? envPath.trim()
-    : DEFAULT_APP_DEV_SESSIONS_FILE;
+  if (typeof envPath === 'string' && envPath.trim()) {
+    return envPath.trim();
+  }
+  const workspaceFile = findWorkspaceAppDevSessionsFile();
+  if (workspaceFile) {
+    return workspaceFile;
+  }
+  return DEFAULT_APP_DEV_SESSIONS_FILE;
+}
+
+export function getAppDevSessionMountAcksFile(sessionsFilePath) {
+  const resolvedSessionsFile = getAppDevSessionsFile(sessionsFilePath);
+  const parsed = parsePath(resolvedSessionsFile);
+  return join(parsed.dir, `${parsed.name}-mount-acks${parsed.ext || '.json'}`);
 }
 
 function normalizeSessions(raw) {
   if (!raw || typeof raw !== 'object' || !Array.isArray(raw.sessions)) {
     return [];
   }
-  return raw.sessions.filter((session) =>
-    session &&
-    typeof session === 'object' &&
-    typeof session.sessionId === 'string' &&
-    typeof session.appId === 'string' &&
-    typeof session.bundleBaseUrl === 'string',
-  );
+  return raw.sessions
+    .filter((session) =>
+      session &&
+      typeof session === 'object' &&
+      typeof session.sessionId === 'string' &&
+      typeof session.appId === 'string' &&
+      typeof session.bundleBaseUrl === 'string',
+    )
+    .map((session) => {
+      if (typeof session.targetAppId === 'string' && session.targetAppId.trim()) {
+        return { ...session, targetAppId: session.targetAppId.trim() };
+      }
+      const { targetAppId: _targetAppId, ...rest } = session;
+      return rest;
+    });
 }
 
 export function readAppDevSessions(filePath) {
@@ -80,8 +132,120 @@ export function heartbeatAppDevSession(sessionId, lastHeartbeatAt, filePath) {
   return writeAppDevSessions(registry, filePath);
 }
 
+export function linkAppDevSessionTarget({ appId, devSlug, targetAppId, lastHeartbeatAt = new Date().toISOString() }, filePath) {
+  const target = typeof targetAppId === 'string' ? targetAppId.trim() : '';
+  if (!target) {
+    return readAppDevSessions(filePath);
+  }
+  const registry = readAppDevSessions(filePath);
+  registry.sessions = registry.sessions.map((session) => {
+    const matchesApp = appId && session.appId === appId;
+    const matchesSlug = devSlug && session.devSlug === devSlug;
+    if (!matchesApp || !matchesSlug) {
+      return session;
+    }
+    return {
+      ...session,
+      targetAppId: target,
+      lastHeartbeatAt,
+    };
+  });
+  return writeAppDevSessions(registry, filePath);
+}
+
 export function removeAppDevSession(sessionId, filePath) {
   const registry = readAppDevSessions(filePath);
   registry.sessions = registry.sessions.filter((session) => session.sessionId !== sessionId);
-  return writeAppDevSessions(registry, filePath);
+  const result = writeAppDevSessions(registry, filePath);
+  removeAppDevSessionMountAcknowledgements(sessionId, filePath);
+  return result;
+}
+
+function normalizeMountAcknowledgements(raw) {
+  if (!raw || typeof raw !== 'object' || !Array.isArray(raw.acknowledgements)) {
+    return [];
+  }
+  return raw.acknowledgements.filter((acknowledgement) =>
+    acknowledgement &&
+    typeof acknowledgement === 'object' &&
+    typeof acknowledgement.sessionId === 'string' &&
+    typeof acknowledgement.appId === 'string' &&
+    typeof acknowledgement.devSlug === 'string' &&
+    typeof acknowledgement.mountNonce === 'string' &&
+    typeof acknowledgement.acknowledgedAt === 'string' &&
+    acknowledgement.stage === 'listed',
+  );
+}
+
+export function readAppDevSessionMountAcknowledgements(sessionsFilePath) {
+  const filePath = getAppDevSessionMountAcksFile(sessionsFilePath);
+  if (!existsSync(filePath)) {
+    return { version: APP_DEV_SESSION_MOUNT_ACKS_VERSION, acknowledgements: [] };
+  }
+  try {
+    const raw = JSON.parse(readFileSync(filePath, 'utf8'));
+    return {
+      version: APP_DEV_SESSION_MOUNT_ACKS_VERSION,
+      acknowledgements: normalizeMountAcknowledgements(raw),
+    };
+  } catch {
+    return { version: APP_DEV_SESSION_MOUNT_ACKS_VERSION, acknowledgements: [] };
+  }
+}
+
+function writeAppDevSessionMountAcknowledgements(registry, sessionsFilePath) {
+  const filePath = getAppDevSessionMountAcksFile(sessionsFilePath);
+  mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 });
+  const normalized = {
+    version: APP_DEV_SESSION_MOUNT_ACKS_VERSION,
+    acknowledgements: normalizeMountAcknowledgements(registry),
+  };
+  const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  writeFileSync(tempPath, JSON.stringify(normalized, null, 2), { mode: 0o600 });
+  renameSync(tempPath, filePath);
+  return normalized;
+}
+
+export function removeAppDevSessionMountAcknowledgements(sessionId, sessionsFilePath) {
+  const filePath = getAppDevSessionMountAcksFile(sessionsFilePath);
+  if (!existsSync(filePath)) {
+    return { version: APP_DEV_SESSION_MOUNT_ACKS_VERSION, acknowledgements: [] };
+  }
+  const registry = readAppDevSessionMountAcknowledgements(sessionsFilePath);
+  registry.acknowledgements = registry.acknowledgements.filter(
+    (acknowledgement) => acknowledgement.sessionId !== sessionId,
+  );
+  return writeAppDevSessionMountAcknowledgements(registry, sessionsFilePath);
+}
+
+function mountAcknowledgementKey(value) {
+  return `${value.sessionId}:${value.appId}:${value.devSlug}:${value.mountNonce}`;
+}
+
+export async function waitForAppDevSessionMountAcknowledgements(expectedSessions, options = {}) {
+  const expected = Array.isArray(expectedSessions) ? expectedSessions : [expectedSessions];
+  const timeoutMs = Number.isFinite(options.timeoutMs) ? Math.max(0, options.timeoutMs) : 15_000;
+  const pollIntervalMs = Number.isFinite(options.pollIntervalMs)
+    ? Math.max(1, options.pollIntervalMs)
+    : 100;
+  const now = typeof options.now === 'function' ? options.now : Date.now;
+  const sleep = typeof options.sleep === 'function'
+    ? options.sleep
+    : (delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs));
+  const startedAt = now();
+
+  while (true) {
+    const registry = readAppDevSessionMountAcknowledgements(options.sessionsFilePath);
+    const acknowledgedKeys = new Set(registry.acknowledgements.map(mountAcknowledgementKey));
+    const missing = expected.filter((session) => !acknowledgedKeys.has(mountAcknowledgementKey(session)));
+    if (missing.length === 0) {
+      return { mounted: true, missing: [], acknowledgements: registry.acknowledgements };
+    }
+
+    const elapsedMs = now() - startedAt;
+    if (elapsedMs >= timeoutMs) {
+      return { mounted: false, missing, acknowledgements: registry.acknowledgements };
+    }
+    await sleep(Math.min(pollIntervalMs, timeoutMs - elapsedMs));
+  }
 }