@notis_ai/cli 0.2.0 → 0.2.2

package/src/command-specs/helpers.js

@@ -1,13 +1,6 @@
-import { createInterface } from 'node:readline/promises';
 import { randomUUID } from 'node:crypto';
 import { CliError, EXIT_CODES, usageError } from '../runtime/errors.js';
 import { callTool, httpRequest } from '../runtime/transport.js';
-import {
-  DEFAULT_PROFILE,
-  ensureProfile,
-  loadConfig,
-  saveConfig,
-} from '../runtime/profiles.js';
 
 export function parseJson(value, label) {
   try {
@@ -41,16 +34,6 @@ export function normalizeToolkits(value) {
     .filter(Boolean);
 }
 
-export async function promptForJwt() {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    const jwt = await rl.question('Paste your Notis JWT: ');
-    return jwt.trim();
-  } finally {
-    rl.close();
-  }
-}
-
 export function nextIdempotencyKey(globalOptions) {
   return globalOptions.idempotencyKey || randomUUID();
 }
@@ -105,33 +88,15 @@ export async function healthCheck(runtime) {
   });
 }
 
-export function updateStoredProfile({ profileName, jwt, apiBase, setCurrent = true }) {
-  let config = ensureProfile(loadConfig(), profileName || DEFAULT_PROFILE);
-  const resolvedName = profileName || DEFAULT_PROFILE;
-  config.profiles[resolvedName] = {
-    ...config.profiles[resolvedName],
-    ...(jwt ? { jwt } : {}),
-    ...(apiBase ? { api_base: apiBase } : {}),
-  };
-  if (setCurrent) {
-    config.current_profile = resolvedName;
-  }
-  saveConfig(config);
-  return config;
-}
-
-export function clearStoredJwt(profileName) {
-  const config = ensureProfile(loadConfig(), profileName || DEFAULT_PROFILE);
-  delete config.profiles[profileName || DEFAULT_PROFILE].jwt;
-  saveConfig(config);
-  return config;
-}
-
-export async function fetchToolSchema(runtime, toolName) {
+export async function fetchToolSchema(runtime, toolName, rawToolkits) {
+  const toolkits = normalizeToolkits(rawToolkits);
   const result = await runToolCommand({
     runtime,
     toolName: 'notis_find_tools',
-    arguments_: { query: toolName },
+    arguments_: {
+      query: toolName,
+      ...(toolkits.length ? { toolkits } : {}),
+    },
   });
   const tools = result.payload.tools || [];
   const match = tools.find((t) => t.name === toolName);

package/src/command-specs/index.js

@@ -1,20 +1,14 @@
-import { authCommandSpecs } from './auth.js';
 import { appsCommandSpecs } from './apps.js';
-import { dbCommandSpecs } from './db.js';
 import { toolsCommandSpecs } from './tools.js';
 import { metaCommandSpecs } from './meta.js';
 
 export const GROUP_SUMMARIES = {
-  auth: 'Authentication and profile management.',
-  apps: 'Build, preview, and deploy Notis Apps.',
-  db: 'List, query, and update native Notis Databases.',
+  apps: 'Develop, build, and deploy Notis Apps.',
   tools: 'Discover and execute generic tools exposed through Notis.',
 };
 
 export const COMMAND_SPECS = [
-  ...authCommandSpecs,
   ...appsCommandSpecs,
-  ...dbCommandSpecs,
   ...toolsCommandSpecs,
   ...metaCommandSpecs,
 ];

package/src/command-specs/meta.js

@@ -29,10 +29,10 @@ async function doctorHandler(ctx) {
 
   const hints = [];
   if (checks.auth === 'missing') {
-    hints.push({ command: 'notis auth login --jwt <token>', reason: 'Configure credentials' });
+    hints.push({ command: 'Open the Notis desktop app and sign in', reason: 'Configure CLI credentials' });
   }
   if (checks.health === 'error') {
-    hints.push({ command: 'notis auth status', reason: 'Check API base URL configuration' });
+    hints.push({ command: 'Open the Notis desktop app and sign in again', reason: 'Refresh local CLI configuration' });
   }
   if (checks.tool_roundtrip === 'error') {
     hints.push({ command: 'notis whoami', reason: 'Verify your account and permissions' });
@@ -117,7 +117,7 @@ export const metaCommandSpecs = [
     output_schema: 'Returns profile, api_base, user_id, toolkit count, and CLI version.',
     mutates: false,
     idempotent: true,
-    related_commands: ['notis auth status --verify', 'notis doctor'],
+    related_commands: ['notis doctor'],
     backend_call: { type: 'tool', name: 'notis_find_toolkits' },
     handler: whoamiHandler,
   },
@@ -130,7 +130,8 @@ export const metaCommandSpecs = [
     output_schema: 'Returns config, auth, health, and roundtrip check statuses.',
     mutates: false,
     idempotent: true,
-    related_commands: ['notis auth status --verify', 'notis tools toolkits'],
+    require_auth: false,
+    related_commands: ['notis tools toolkits'],
     backend_call: { type: 'health+tool_roundtrip' },
     handler: doctorHandler,
   },
@@ -139,10 +140,10 @@ export const metaCommandSpecs = [
     summary: 'Describe a first-class CLI command in detail.',
     when_to_use: 'Use this when an agent or human needs the exact shape, examples, and semantics of a command.',
     args_schema: {
-      arguments: [{ token: '<command...>', key: 'commandPath', description: 'Command path to describe, such as "apps push".' }],
+      arguments: [{ token: '<command...>', key: 'commandPath', description: 'Command path to describe, such as "apps deploy".' }],
       options: [],
     },
-    examples: ['notis describe apps push', 'notis describe db query'],
+    examples: ['notis describe apps deploy', 'notis describe tools exec'],
     output_schema: 'Returns the command spec metadata for the requested command.',
     mutates: false,
     idempotent: true,

package/src/command-specs/tools.js

@@ -6,6 +6,7 @@ import {
   nextIdempotencyKey,
   parseJson,
   parseMaybeJson,
+  normalizeToolkits,
   resolveSearchToolkits,
   runToolCommand,
   validateArguments,
@@ -33,6 +34,22 @@ async function resolveJsonInput(value, label) {
   return parseJson(value, label);
 }
 
+const LONG_RUNNING_TOOL_TIMEOUT_MS = 600000;
+const LONG_RUNNING_TOOL_NAMES = new Set([
+  'notis-default-generate_image_openai',
+  'notis-default-edit_image_openai',
+  'notis-default-generate_image_gemini',
+  'notis-default-edit_image_gemini',
+]);
+
+function ensureLongRunningToolTimeout(ctx, toolNames) {
+  const names = Array.isArray(toolNames) ? toolNames : [toolNames];
+  if (!names.some((name) => LONG_RUNNING_TOOL_NAMES.has(name))) {
+    return;
+  }
+  ctx.runtime.timeoutMs = Math.max(ctx.runtime.timeoutMs || 0, LONG_RUNNING_TOOL_TIMEOUT_MS);
+}
+
 async function toolsToolkitsHandler(ctx) {
   const toolkits = await fetchToolkits(ctx.runtime);
   return ctx.output.emitSuccess({
@@ -105,11 +122,14 @@ async function toolsDescribeHandler(ctx) {
 }
 
 async function toolsExecHandler(ctx) {
+  ensureLongRunningToolTimeout(ctx, ctx.args.toolName);
+  const toolkits = normalizeToolkits(ctx.options.toolkits);
+
   if (ctx.options.getSchema) {
-    const tool = await fetchToolSchema(ctx.runtime, ctx.args.toolName);
+    const tool = await fetchToolSchema(ctx.runtime, ctx.args.toolName, ctx.options.toolkits);
     return ctx.output.emitSuccess({
       command: ctx.spec.command_path.join(' '),
-      data: { tool },
+      data: { tool, toolkits },
       humanSummary: `Schema for ${ctx.args.toolName}`,
       hints: [
         { command: `notis tools exec ${ctx.args.toolName} --dry-run --arguments '{}'`, reason: 'Validate arguments before executing' },
@@ -124,13 +144,13 @@ async function toolsExecHandler(ctx) {
     : parseMaybeJson(rawArguments, 'arguments') || {};
 
   if (ctx.options.dryRun) {
-    const tool = await fetchToolSchema(ctx.runtime, ctx.args.toolName);
+    const tool = await fetchToolSchema(ctx.runtime, ctx.args.toolName, ctx.options.toolkits);
     const errors = validateArguments(tool.parameters, args);
 
     if (errors.length) {
       return ctx.output.emitSuccess({
         command: ctx.spec.command_path.join(' '),
-        data: { valid: false, errors, tool: ctx.args.toolName },
+        data: { valid: false, errors, tool: ctx.args.toolName, toolkits },
         humanSummary: `Dry run failed: ${errors.length} validation error(s)`,
         hints: [
           { command: `notis tools exec ${ctx.args.toolName} --get-schema`, reason: 'Review the full parameter schema' },
@@ -141,7 +161,7 @@ async function toolsExecHandler(ctx) {
 
     return ctx.output.emitSuccess({
       command: ctx.spec.command_path.join(' '),
-      data: { valid: true, tool: ctx.args.toolName, arguments: args },
+      data: { valid: true, tool: ctx.args.toolName, arguments: args, toolkits },
       humanSummary: `Dry run passed for ${ctx.args.toolName}`,
       hints: [
         { command: `notis tools exec ${ctx.args.toolName} --arguments '${JSON.stringify(args)}'`, reason: 'Execute with these arguments' },
@@ -151,39 +171,13 @@ async function toolsExecHandler(ctx) {
 
   const idempotencyKey = nextIdempotencyKey(ctx.globalOptions);
 
-  if (ctx.options.watch) {
-    const intervalSec = Math.max(1, parseInt(ctx.options.watch, 10));
-    const intervalMs = intervalSec * 1000;
-    process.on('SIGINT', () => process.exit(0));
-
-    while (true) {
-      try {
-        const result = await runToolCommand({
-          runtime: ctx.runtime,
-          toolName: 'notis_execute_tool',
-          arguments_: { tool_name: ctx.args.toolName, arguments: args },
-          mutating: true,
-          idempotencyKey: nextIdempotencyKey(ctx.globalOptions),
-        });
-        ctx.output.emitSuccess({
-          command: ctx.spec.command_path.join(' '),
-          data: result.payload,
-          humanSummary: `[${new Date().toISOString()}] ${ctx.args.toolName}`,
-          renderHuman: () => JSON.stringify(result.payload, null, 2),
-        });
-      } catch (error) {
-        process.stderr.write(`[${new Date().toISOString()}] Error: ${error.message}\n`);
-      }
-      await new Promise((r) => setTimeout(r, intervalMs));
-    }
-  }
-
   const result = await runToolCommand({
     runtime: ctx.runtime,
     toolName: 'notis_execute_tool',
     arguments_: {
       tool_name: ctx.args.toolName,
       arguments: args,
+      ...(toolkits.length ? { toolkits } : {}),
     },
     mutating: true,
     idempotencyKey,
@@ -209,6 +203,7 @@ async function toolsExecParallelHandler(ctx) {
       throw usageError(`calls[${i}] missing required "tool_name" string`);
     }
   }
+  ensureLongRunningToolTimeout(ctx, calls.map((call) => call.tool_name));
 
   const data = await Promise.all(
     calls.map((call) =>
@@ -333,16 +328,16 @@ export const toolsCommandSpecs = [
         { flags: '--arguments <json>', description: 'JSON object, @file path, or - for stdin.' },
         { flags: '--get-schema', description: 'Display the tool parameter schema without executing.' },
         { flags: '--dry-run', description: 'Validate arguments against the tool schema without executing.' },
-        { flags: '--watch <seconds>', description: 'Re-execute on an interval and stream results.' },
+        { flags: '--toolkits <csv-or-json>', description: 'Optional toolkit namespace(s) to use when resolving the tool.' },
       ],
     },
     examples: [
       'notis tools exec notis-default-query --arguments \'{"database_slug":"tasks","query":{}}\'',
+      'notis tools exec notis-default-get_database --arguments \'{"database_slug":"tasks"}\'',
       'notis tools exec notis-default-query --get-schema',
       'notis tools exec notis-default-query --dry-run --arguments \'{"database_slug":"tasks","query":{}}\'',
       'notis tools exec notis-default-query --arguments @query.json',
       'notis tools exec notis-default-query --arguments - < query.json',
-      'notis tools exec notis-default-query --watch 10 --arguments \'{"database_slug":"tasks","query":{}}\'',
     ],
     output_schema: 'Returns the raw tool execution payload.',
     mutates: true,

package/src/runtime/agent-browser.js

@@ -0,0 +1,192 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+function delay(ms) {
+  return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
+
+function commandError(phase, result) {
+  return {
+    phase,
+    exit_code: result.exitCode,
+    stdout: result.stdout.trim(),
+    stderr: result.stderr.trim(),
+  };
+}
+
+function runAgentBrowser(args, { timeoutMs = 30_000 } = {}) {
+  return new Promise((resolvePromise) => {
+    const child = spawn('agent-browser', args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+    });
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill('SIGTERM');
+    }, timeoutMs);
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on('error', (error) => {
+      clearTimeout(timer);
+      resolvePromise({
+        exitCode: 1,
+        stdout,
+        stderr: stderr || error.message,
+        timedOut,
+      });
+    });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      resolvePromise({
+        exitCode: timedOut ? 124 : (code ?? 1),
+        stdout,
+        stderr,
+        timedOut,
+      });
+    });
+  });
+}
+
+function parseAgentBrowserJson(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) {
+    return null;
+  }
+  return JSON.parse(trimmed);
+}
+
+function parseHarnessFromEval(stdout) {
+  const payload = parseAgentBrowserJson(stdout);
+  const rawResult = payload?.data?.result ?? payload?.result ?? payload?.data ?? null;
+  if (rawResult == null || rawResult === 'null') {
+    return null;
+  }
+  return typeof rawResult === 'string' ? JSON.parse(rawResult) : rawResult;
+}
+
+async function readHarness(sessionName, timeoutMs) {
+  const result = await runAgentBrowser(
+    [
+      '--session',
+      sessionName,
+      '--json',
+      'eval',
+      'JSON.stringify(window.__harness || null)',
+    ],
+    { timeoutMs },
+  );
+  if (result.exitCode !== 0) {
+    return { ok: false, toolError: commandError('eval', result) };
+  }
+
+  try {
+    return { ok: true, harness: parseHarnessFromEval(result.stdout) };
+  } catch (error) {
+    return {
+      ok: false,
+      toolError: {
+        phase: 'eval_parse',
+        message: error instanceof Error ? error.message : String(error),
+        stdout: result.stdout.trim(),
+        stderr: result.stderr.trim(),
+      },
+    };
+  }
+}
+
+export function isAgentBrowserAvailable() {
+  const result = spawnSync('agent-browser', ['--version'], {
+    stdio: 'ignore',
+    env: process.env,
+  });
+  return result.status === 0;
+}
+
+export async function runHarnessRoute({
+  url,
+  sessionName,
+  timeoutMs = 10_000,
+  snapshotPath = null,
+}) {
+  const opened = await runAgentBrowser(['--session', sessionName, 'open', url], {
+    timeoutMs: Math.min(Math.max(timeoutMs, 5000), 30_000),
+  });
+  if (opened.exitCode !== 0) {
+    return {
+      mounted: false,
+      renderStarted: false,
+      errors: [],
+      runtimeCalls: [],
+      snapshotPath: null,
+      tool_error: commandError('open', opened),
+    };
+  }
+
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const lastRead = await readHarness(sessionName, 5000);
+    if (!lastRead.ok) {
+      await delay(250);
+      continue;
+    }
+    const harness = lastRead.harness;
+    if (harness?.mounted || (Array.isArray(harness?.errors) && harness.errors.length > 0)) {
+      await delay(250);
+      break;
+    }
+    await delay(250);
+  }
+
+  const finalRead = await readHarness(sessionName, 5000);
+  if (!finalRead.ok) {
+    return {
+      mounted: false,
+      renderStarted: false,
+      errors: [],
+      runtimeCalls: [],
+      snapshotPath: null,
+      tool_error: finalRead.toolError,
+    };
+  }
+
+  const harness = finalRead.harness || {};
+  let savedSnapshotPath = null;
+  if (snapshotPath) {
+    const snapshot = await runAgentBrowser(['--session', sessionName, 'snapshot', '-i'], {
+      timeoutMs: 10_000,
+    });
+    if (snapshot.exitCode === 0) {
+      mkdirSync(dirname(snapshotPath), { recursive: true });
+      writeFileSync(snapshotPath, snapshot.stdout);
+      savedSnapshotPath = snapshotPath;
+    }
+  }
+
+  const timedOut = !harness.mounted && Date.now() >= deadline;
+  return {
+    mounted: Boolean(harness.mounted),
+    renderStarted: Boolean(harness.renderStarted),
+    errors: Array.isArray(harness.errors) ? harness.errors : [],
+    runtimeCalls: Array.isArray(harness.runtimeCalls) ? harness.runtimeCalls : [],
+    snapshotPath: savedSnapshotPath,
+    timed_out: timedOut,
+    tool_error: null,
+    raw: harness,
+  };
+}
+
+export async function closeAgentBrowserSession(sessionName) {
+  const result = await runAgentBrowser(['--session', sessionName, 'close'], {
+    timeoutMs: 5000,
+  });
+  return result.exitCode === 0;
+}

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

@@ -0,0 +1,132 @@
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { dirname, extname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { usageError } from './errors.js';
+
+const RULES_PATH = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  '../../../../server/config/notis_app_boundary_rules.json',
+);
+
+const SOURCE_FILE_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.css', '.scss', '.sass', '.pcss']);
+const IGNORED_SOURCE_DIRS = new Set([
+  'node_modules',
+  '.git',
+  '.next',
+  '.notis',
+  'dist',
+  'build',
+  'coverage',
+]);
+
+function loadBoundaryRules() {
+  return JSON.parse(readFileSync(RULES_PATH, 'utf-8'));
+}
+
+function compileRules(entries) {
+  return (entries || []).map((entry) => ({
+    regex: new RegExp(entry.pattern, 'm'),
+    message: entry.message,
+  }));
+}
+
+const boundaryRules = loadBoundaryRules();
+const javascriptRules = compileRules(boundaryRules.javascript);
+const cssRules = compileRules(boundaryRules.css);
+
+function collectProjectFiles(projectDir, dir, results) {
+  if (!existsSync(dir)) {
+    return;
+  }
+
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith('.')) {
+      if (entry.name !== '.storybook') {
+        continue;
+      }
+    }
+
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (IGNORED_SOURCE_DIRS.has(entry.name)) {
+        continue;
+      }
+      collectProjectFiles(projectDir, fullPath, results);
+      continue;
+    }
+
+    if (!SOURCE_FILE_EXTENSIONS.has(extname(entry.name))) {
+      continue;
+    }
+
+    results.push({
+      path: fullPath,
+      relPath: fullPath.slice(projectDir.length + 1),
+      content: readFileSync(fullPath, 'utf-8'),
+    });
+  }
+}
+
+function applyRules(content, rules, relPath) {
+  const errors = [];
+  for (const rule of rules) {
+    if (rule.regex.test(content)) {
+      errors.push(`${relPath}: ${rule.message}`);
+    }
+  }
+  return errors;
+}
+
+function validateTextFile(relPath, content) {
+  const extension = extname(relPath);
+  if (extension === '.css' || extension === '.scss' || extension === '.sass' || extension === '.pcss') {
+    return applyRules(content, cssRules, relPath);
+  }
+  if (extension === '.js' || extension === '.jsx' || extension === '.ts' || extension === '.tsx') {
+    return applyRules(content, javascriptRules, relPath);
+  }
+  return [];
+}
+
+export function collectProjectBoundaryViolations(projectDir) {
+  const files = [];
+  collectProjectFiles(projectDir, projectDir, files);
+  return files.flatMap((file) => validateTextFile(file.relPath, file.content));
+}
+
+export function collectArtifactBoundaryViolations(files) {
+  return Object.entries(files).flatMap(([relPath, rawContent]) => {
+    const extension = extname(relPath);
+    if (!['.js', '.css', '.scss', '.sass', '.pcss'].includes(extension)) {
+      return [];
+    }
+
+    const content = Buffer.isBuffer(rawContent)
+      ? rawContent.toString('utf-8')
+      : typeof rawContent === 'string'
+        ? rawContent
+        : String(rawContent ?? '');
+
+    return validateTextFile(relPath, content);
+  });
+}
+
+export function validateProjectBoundary(projectDir) {
+  const violations = collectProjectBoundaryViolations(projectDir);
+  if (violations.length > 0) {
+    throw usageError(
+      `Project violates the Notis app portal boundary:\n${violations.map((error) => `  - ${error}`).join('\n')}`,
+    );
+  }
+}
+
+export function validateArtifactBoundary(files) {
+  const violations = collectArtifactBoundaryViolations(files);
+  if (violations.length > 0) {
+    throw usageError(
+      `Built app violates the Notis app portal boundary:\n${violations.map((error) => `  - ${error}`).join('\n')}`,
+    );
+  }
+}