@notis_ai/cli 0.2.0-beta.191.1 → 0.2.0-beta.197.1

package/src/command-specs/views.js

@@ -0,0 +1,69 @@
+import { httpRequest } from '../runtime/transport.js';
+import { usageError } from '../runtime/errors.js';
+import { renderViewWithCliRuntime } from '../runtime/view-render.js';
+import { resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+export function viewRenderCommandSpec({ screenshotOnly = false } = {}) {
+  const command_path = screenshotOnly ? ['spaces', 'screenshot'] : ['views', 'render'];
+  return {
+    command_path, summary: screenshotOnly ? 'Capture a full-height PNG of a live view with your current access.' : 'Render a live view as Markdown and a full-height PNG with your current access.',
+    when_to_use: 'Check the actual deployed view; writes are blocked and current access is checked again before any output is saved.',
+    args_schema: { arguments: [{ token: '<url>', key: 'url', description: 'Current view-qualified or record link.' }], options: [
+      ...(!screenshotOnly ? [{ flags: '--outputs <kinds>', description: 'Comma-separated markdown,screenshot (default both).' }] : []),
+      { flags: '--width <pixels>', description: '1440 (default) or 390.' },
+      { flags: '--output-dir <path>', description: 'New output directory; defaults to a unique .notis/renders directory. Existing files are never overwritten.' },
+    ] }, examples: [screenshotOnly ? 'notis spaces screenshot <view-link> --width 390' : 'notis views render <view-link> --outputs markdown,screenshot'],
+    mutates: false, idempotent: true, require_auth: true,
+    backend_call: { type: 'http', path: '/portal_view_render/prepare' },
+    async handler(ctx) {
+      const outputs = screenshotOnly ? ['screenshot'] : (ctx.options.outputs || 'markdown,screenshot').split(',');
+      if (!outputs.length || new Set(outputs).size !== outputs.length || outputs.some(value => !['markdown', 'screenshot'].includes(value))) {
+        throw usageError('Choose markdown, screenshot, or markdown,screenshot.');
+      }
+      const width = ctx.options.width === undefined ? 1440 : Number(ctx.options.width);
+      const directory = resolve(ctx.options.outputDir || `.notis/renders/${randomUUID()}`);
+      const controller = new AbortController(), cancel = () => controller.abort();
+      process.once('SIGINT', cancel); process.once('SIGTERM', cancel);
+      try {
+        const { result, artifacts } = await renderViewWithCliRuntime({ runtime: ctx.runtime,
+          url: ctx.args.url, outputs, width, directory, signal: controller.signal });
+        const data = { ...result, artifacts };
+        if (data.screenshot) {
+          const { data_base64: _bytes, ...metadata } = data.screenshot;
+          data.screenshot = { ...metadata, path: artifacts.screenshot };
+        }
+        return ctx.output.emitSuccess({ command: command_path.join(' '), data,
+          humanSummary: `Rendered ${result.url}. Saved ${Object.values(artifacts).join(' and ')}.`, meta: { mutating: false } });
+      } finally { process.removeListener('SIGINT', cancel); process.removeListener('SIGTERM', cancel); }
+    },
+  };
+}
+
+export const viewsCommandSpecs = [{
+  command_path: ['views', 'find'],
+  summary: 'Find the views you can open for a record, database, view link, Space or search.',
+  when_to_use: 'Get fresh view-qualified links and declared URL parameters before citing or opening a view.',
+  args_schema: { options: [
+    { flags: '--record-key <id>', description: 'Find views that show this exact native record.' },
+    { flags: '--database-id <id>', description: 'Find views over this database.' },
+    { flags: '--url <url>', description: 'Resolve this view link and its current parameters.' },
+    { flags: '--space-id <id>', description: 'Describe this Space view.' },
+    { flags: '--query <text>', description: 'Search accessible view names, descriptions and readable context.' },
+  ] },
+  examples: ['notis views find --record-key <record-key>', 'notis views find --url <view-link>', 'notis views find --query inbox'],
+  mutates: false, idempotent: true, require_auth: true,
+  backend_call: { type: 'http', path: '/portal_spaces/find-views' },
+  async handler(ctx) {
+    const options = { record_key: ctx.options.recordKey, database_id: ctx.options.databaseId,
+      url: ctx.options.url, space_id: ctx.options.spaceId, query: ctx.options.query };
+    const selected = Object.entries(options).filter(([, value]) => value !== undefined);
+    if (selected.length !== 1 || typeof selected[0][1] !== 'string' || !selected[0][1].trim()) {
+      throw usageError('Choose exactly one of --record-key, --database-id, --url, --space-id or --query.');
+    }
+    const result = await httpRequest({ runtime: ctx.runtime, method: 'POST', path: '/portal_spaces/find-views',
+      body: Object.fromEntries(selected), spacesProtocol: 1 });
+    return ctx.output.emitSuccess({ command: 'views find', data: result.payload,
+      humanSummary: JSON.stringify(result.payload, null, 2), meta: { mutating: false, request_id: result.requestId } });
+  },
+}, viewRenderCommandSpec()];

package/src/runtime/agent-browser.js

@@ -131,9 +131,11 @@ function runAgentBrowser(args, { timeoutMs = 30_000 } = {}) {
     let stdout = '';
     let stderr = '';
     let timedOut = false;
+    let hardStop;
     const timer = setTimeout(() => {
       timedOut = true;
       child.kill('SIGTERM');
+      hardStop = setTimeout(() => child.kill('SIGKILL'), 2000);
     }, timeoutMs);
 
     child.stdout.on('data', (chunk) => {
@@ -143,7 +145,7 @@ function runAgentBrowser(args, { timeoutMs = 30_000 } = {}) {
       stderr += chunk.toString();
     });
     child.on('error', (error) => {
-      clearTimeout(timer);
+      clearTimeout(timer); clearTimeout(hardStop);
       resolvePromise({
         exitCode: 1,
         stdout,
@@ -152,7 +154,7 @@ function runAgentBrowser(args, { timeoutMs = 30_000 } = {}) {
       });
     });
     child.on('close', (code) => {
-      clearTimeout(timer);
+      clearTimeout(timer); clearTimeout(hardStop);
       resolvePromise({
         exitCode: timedOut ? 124 : (code ?? 1),
         stdout,
@@ -225,10 +227,17 @@ export async function runHarnessRoute({
   snapshotPath = null,
   designViewports = DEFAULT_DESIGN_VIEWPORTS,
   waitForRuntime = false,
+  signal,
 }) {
+  const cancelled = () => ({ mounted: false, renderStarted: false, runtimeCalls: [],
+    errors: [{ phase: 'browser', message: 'Verification cancelled.' }], snapshotPath: null, tool_error: null });
+  if (signal?.aborted) return cancelled();
   const opened = await runAgentBrowser(['--session', sessionName, 'open', url], {
     timeoutMs: Math.min(Math.max(timeoutMs, 5000), 30_000),
   });
+  // Let an in-flight open settle before the owner closes its browser. Closing
+  // concurrently with open can leave a newly launched browser behind.
+  if (signal?.aborted) return cancelled();
   if (opened.exitCode !== 0) {
     return {
       mounted: false,
@@ -242,7 +251,7 @@ export async function runHarnessRoute({
 
   const deadline = Date.now() + timeoutMs;
   let readySince = null;
-  while (Date.now() < deadline) {
+  while (Date.now() < deadline && !signal?.aborted) {
     const lastRead = await readHarness(sessionName, 5000);
     if (!lastRead.ok) {
       readySince = null;
@@ -259,6 +268,8 @@ export async function runHarnessRoute({
     await delay(250);
   }
 
+  if (signal?.aborted) return cancelled();
+
   const finalRead = await readHarness(sessionName, 5000);
   if (!finalRead.ok) {
     return {
@@ -525,10 +536,22 @@ export async function captureHarnessScreenshot({
 }
 
 export async function closeAgentBrowserSession(sessionName) {
-  const result = await runAgentBrowser(['--session', sessionName, 'close'], {
-    timeoutMs: 5000,
-  });
-  return result.exitCode === 0;
+  return (await closeAgentBrowserSessionResult(sessionName)).ok;
+}
+
+export async function closeAgentBrowserSessionResult(sessionName) {
+  const started = Date.now();
+  // agent-browser waits up to 30s for CDP Browser.close and then up to 5s
+  // for its owned Chrome process. Do not kill the client at the start of the
+  // provider's shutdown grace period and lose its actual close acknowledgement.
+  const result = await runAgentBrowser(['--session', sessionName, '--json', 'close'], { timeoutMs: 40_000 });
+  let acknowledged = false;
+  try {
+    const reply = parseAgentBrowserJson(result.stdout);
+    acknowledged = reply?.success === true && reply?.data?.closed === true;
+  } catch { /* Missing acknowledgement is a failed cleanup, never a pass. */ }
+  return { ok: result.exitCode === 0 && acknowledged, exit_code: result.exitCode,
+    timed_out: Boolean(result.timedOut), duration_ms: Date.now() - started };
 }
 
 // ---------------------------------------------------------------------------

package/src/runtime/app-boundary-validator.js

@@ -3,6 +3,7 @@ import { dirname, extname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import { usageError } from './errors.js';
+import { maskSerializedJsonData } from './app-data-literals.js';
 
 const moduleDir = dirname(fileURLToPath(import.meta.url));
 
@@ -136,7 +137,7 @@ function validateTextFile(relPath, content) {
     return applyRules(content, rules.css, relPath);
   }
   if (extension === '.js' || extension === '.jsx' || extension === '.ts' || extension === '.tsx') {
-    return applyRules(content, rules.javascript, relPath);
+    return applyRules(maskSerializedJsonData(content, extension), rules.javascript, relPath);
   }
   return [];
 }
@@ -311,7 +312,9 @@ export function collectDesignViolationsForFile(relPath, content, config = getCom
   if (!matchesAny(normalized, config.include)) return [];
   if (matchesAny(normalized, config.exclude)) return [];
 
-  const lines = content.split('\n');
+  const checked = ['.js', '.jsx', '.ts', '.tsx'].includes(extname(normalized))
+    ? maskSerializedJsonData(content, extname(normalized)) : content;
+  const lines = checked.split('\n');
   const violations = [];
   for (const rule of config.rules) {
     if (rule.include && !matchesAny(normalized, rule.include)) continue;
@@ -319,12 +322,12 @@ export function collectDesignViolationsForFile(relPath, content, config = getCom
 
     const matches = [];
     if (rule.scope === 'file') {
-      const match = rule.regex.exec(content);
+      const match = rule.regex.exec(checked);
       if (match) matches.push(match.index);
     } else {
       rule.regex.lastIndex = 0;
       let match;
-      while ((match = rule.regex.exec(content)) !== null) {
+      while ((match = rule.regex.exec(checked)) !== null) {
         matches.push(match.index);
         if (match[0].length === 0) rule.regex.lastIndex += 1;
       }

package/src/runtime/app-data-literals.js

@@ -0,0 +1,82 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+let babelParse;
+
+function isJsonParse(node) {
+  const callee = node.callee;
+  return node.type === 'CallExpression' && callee?.type === 'MemberExpression' && !callee.computed
+    && callee.object?.type === 'Identifier' && callee.object.name === 'JSON'
+    && callee.property?.type === 'Identifier' && callee.property.name === 'parse';
+}
+
+function dataContext(ancestors) {
+  if (ancestors.some(node => node.type === 'JSXAttribute')) return false;
+  for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+    const node = ancestors[index];
+    if (node.type === 'JSXAttribute' || node.type === 'ImportDeclaration'
+      || node.type === 'ImportExpression' || node.type === 'TSImportType'
+      || node.type === 'ExportAllDeclaration' || node.type === 'ExportNamedDeclaration'
+      || node.type === 'NewExpression' || node.type === 'TaggedTemplateExpression'
+      || node.type === 'MemberExpression' || node.type === 'OptionalMemberExpression') return false;
+    if (node.type === 'CallExpression' || node.type === 'OptionalCallExpression') {
+      if (!isJsonParse(node)) return false;
+    }
+    if (['VariableDeclarator', 'ExportDefaultDeclaration', 'ReturnStatement'].includes(node.type)) return true;
+    if (node.type === 'ExpressionStatement') return false;
+  }
+  return false;
+}
+
+/**
+ * Serialized JSON is data, not source: a review may quote forbidden host code
+ * or historical styles. Mask only complete object/array JSON literal values in
+ * data-expression positions. Keep ordinary strings, import/call/selector and
+ * JSX attribute contexts, and every template expression under the existing
+ * rules. Parsing errors (or a missing parser) retain the original checks.
+ * Source/archive bytes are never rewritten; offsets and line breaks survive.
+ */
+export function maskSerializedJsonData(content, extension = '.js') {
+  let ast;
+  try {
+    babelParse ||= require('@babel/parser').parse;
+    ast = babelParse(content, {
+      sourceType: 'unambiguous',
+      allowReturnOutsideFunction: true,
+      plugins: [...(['.ts', '.tsx'].includes(extension) ? ['typescript'] : []),
+        ...(extension !== '.ts' ? ['jsx'] : [])],
+    });
+  } catch { return content; }
+  const ranges = [];
+  const pending = [[ast, []]];
+  while (pending.length) {
+    const [node, ancestors] = pending.pop();
+    if (!node || typeof node !== 'object') continue;
+    const literal = node.type === 'StringLiteral' ? node.value
+      : node.type === 'TemplateLiteral' && node.expressions.length === 0 ? node.quasis[0]?.value.cooked : null;
+    if (typeof literal === 'string' && dataContext(ancestors)) {
+      try {
+        const value = JSON.parse(literal);
+        if (value !== null && typeof value === 'object') {
+          ranges.push([node.start, node.end]);
+          continue;
+        }
+      } catch { /* Ordinary/non-JSON strings keep their original checks. */ }
+    }
+    const parents = [...ancestors, node];
+    for (const [key, value] of Object.entries(node)) {
+      if (['loc', 'extra', 'tokens', 'comments', 'errors'].includes(key)) continue;
+      if (Array.isArray(value)) {
+        for (const child of value) if (child?.type) pending.push([child, parents]);
+      } else if (value?.type) pending.push([value, parents]);
+    }
+  }
+  let cursor = 0;
+  const result = [];
+  for (const [start, end] of ranges.sort((a, b) => a[0] - b[0])) {
+    result.push(content.slice(cursor, start), content.slice(start, end).replace(/[^\r\n]/g, ' '));
+    cursor = end;
+  }
+  result.push(content.slice(cursor));
+  return result.join('');
+}