@notis_ai/cli 0.2.0 → 0.2.1

package/src/command-specs/helpers.js

@@ -105,13 +105,30 @@ export async function healthCheck(runtime) {
   });
 }
 
-export function updateStoredProfile({ profileName, jwt, apiBase, setCurrent = true }) {
+export function updateStoredProfile({
+  profileName,
+  jwt,
+  apiBase,
+  authMode,
+  refreshToken,
+  accessExpiresAt,
+  refreshExpiresAt,
+  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 } : {}),
+    ...(authMode ? { auth_mode: authMode } : {}),
+    ...(refreshToken ? { refresh_token: refreshToken } : {}),
+    ...(typeof accessExpiresAt === 'number'
+      ? { access_expires_at: accessExpiresAt }
+      : {}),
+    ...(typeof refreshExpiresAt === 'number'
+      ? { refresh_expires_at: refreshExpiresAt }
+      : {}),
   };
   if (setCurrent) {
     config.current_profile = resolvedName;
@@ -123,15 +140,23 @@ export function updateStoredProfile({ profileName, jwt, apiBase, setCurrent = tr
 export function clearStoredJwt(profileName) {
   const config = ensureProfile(loadConfig(), profileName || DEFAULT_PROFILE);
   delete config.profiles[profileName || DEFAULT_PROFILE].jwt;
+  delete config.profiles[profileName || DEFAULT_PROFILE].auth_mode;
+  delete config.profiles[profileName || DEFAULT_PROFILE].refresh_token;
+  delete config.profiles[profileName || DEFAULT_PROFILE].access_expires_at;
+  delete config.profiles[profileName || DEFAULT_PROFILE].refresh_expires_at;
   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

@@ -6,7 +6,7 @@ import { metaCommandSpecs } from './meta.js';
 
 export const GROUP_SUMMARIES = {
   auth: 'Authentication and profile management.',
-  apps: 'Build, preview, and deploy Notis Apps.',
+  apps: 'Develop, build, and deploy Notis Apps.',
   db: 'List, query, and update native Notis Databases.',
   tools: 'Discover and execute generic tools exposed through Notis.',
 };

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' },
@@ -161,7 +181,11 @@ async function toolsExecHandler(ctx) {
         const result = await runToolCommand({
           runtime: ctx.runtime,
           toolName: 'notis_execute_tool',
-          arguments_: { tool_name: ctx.args.toolName, arguments: args },
+          arguments_: {
+            tool_name: ctx.args.toolName,
+            arguments: args,
+            ...(toolkits.length ? { toolkits } : {}),
+          },
           mutating: true,
           idempotencyKey: nextIdempotencyKey(ctx.globalOptions),
         });
@@ -184,6 +208,7 @@ async function toolsExecHandler(ctx) {
     arguments_: {
       tool_name: ctx.args.toolName,
       arguments: args,
+      ...(toolkits.length ? { toolkits } : {}),
     },
     mutating: true,
     idempotencyKey,
@@ -209,6 +234,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) =>
@@ -334,6 +360,7 @@ export const toolsCommandSpecs = [
         { 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: [

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')}`,
+    );
+  }
+}