@notis_ai/cli 0.2.17 → 0.2.19

package/src/command-specs/tools.js

@@ -2,7 +2,15 @@ import { accessSync, constants as fsConstants, createReadStream, existsSync, rea
 import { createHash } from 'node:crypto';
 import { basename } from 'node:path';
 import { usageError } from '../runtime/errors.js';
-import { assertToolNotDelegated } from '../runtime/delegated-context.js';
+import {
+  canPrompt,
+  createStderrPrompter,
+  extractToolResult,
+  findConfirmationPreview,
+  renderPreview,
+  resolveConfirmation,
+} from '../runtime/tool-confirmation.js';
+import { findUpsell, renderUpsell } from '../runtime/upsell.js';
 import {
   COMPOSIO_GET_TOOL_SCHEMAS,
   COMPOSIO_MULTI_EXECUTE_TOOL,
@@ -174,6 +182,11 @@ function classifySqlMutation(query) {
 
 export function classifyToolMutation(toolName, args = {}) {
   const normalized = localNotisToolSlug(toolName).toUpperCase();
+  if (normalized === 'LOCAL_NOTIS_SANDBOX_PREVIEW') {
+    if (args.action === 'status') return false;
+    if (['register', 'open', 'heartbeat', 'stop'].includes(args.action)) return true;
+    return null;
+  }
   if (normalized.includes('EXECUTE_SQL') && typeof args.query === 'string') {
     const query = args.query
       .replace(/\/\*[\s\S]*?\*\//g, ' ')
@@ -293,18 +306,19 @@ function ensureLongRunningToolTimeout(ctx, toolNames) {
 }
 
 async function toolsToolkitsHandler(ctx) {
-  const toolkits = await fetchToolkits(ctx.runtime);
+  const { toolkits, coverage, warnings } = await fetchToolkits(ctx.runtime);
   return ctx.output.emitSuccess({
     command: ctx.spec.command_path.join(' '),
-    data: { toolkits },
-    humanSummary: `Found ${toolkits.length} toolkits`,
+    data: { toolkits, coverage },
+    warnings,
+    humanSummary: `Found ${toolkits.length} toolkits${coverage.complete ? '' : ' (incomplete inventory)'}`,
     hints: [
       { command: 'notis tools search <query>', reason: 'Search canonical tools and schemas' },
     ],
     renderHuman: () =>
       toolkits
         .map((entry) => {
-          const status = entry.has_active_connection ? 'connected' : 'needs auth';
+          const status = entry.availability === 'not_probed' ? 'configured' : entry.has_active_connection ? 'connected' : 'needs auth';
           return `${entry.id}  ${status}  ${entry.description}`;
         })
         .join('\n'),
@@ -381,9 +395,6 @@ async function toolsDescribeHandler(ctx) {
 
 async function toolsExecHandler(ctx) {
   const requestedToolName = localNotisToolSlug(ctx.args.toolName);
-  // `tools exec` is the escape hatch around every first-class command, so the
-  // hand-over guard has to live here too or it guards nothing.
-  assertToolNotDelegated(requestedToolName);
   let targetMutating = classifyToolMutation(requestedToolName);
   ensureLongRunningToolTimeout(ctx, requestedToolName);
   ctx.output.emitProgress({
@@ -471,17 +482,94 @@ async function toolsExecHandler(ctx) {
     requestId: result.requestId,
   });
 
+  const meta = {
+    mutating: targetMutating,
+    mutation_classification: targetMutating === null ? 'unknown' : 'name_hint_only',
+    idempotency_key: result.idempotencyKey ?? idempotencyKey,
+    attempts: result.attempts ?? 1,
+  };
+  const preview = findConfirmationPreview(result.payload);
+  if (preview) {
+    return confirmAndApply(ctx, { requestedToolName, args, preview, result, idempotencyKey, fileBindings, meta });
+  }
+  return emitToolResult(ctx, { requestedToolName, result, meta });
+}
+
+function toolResultUpsell(payload) {
+  const toolResult = extractToolResult(payload);
+  return toolResult ? findUpsell(toolResult) : null;
+}
+
+function emitToolResult(ctx, { requestedToolName, result, meta, humanSummary }) {
+  const upsellBody = toolResultUpsell(result.payload);
+  const rendered = upsellBody ? renderUpsell(upsellBody, { apiBase: ctx.runtime.apiBase }) : null;
   return ctx.output.emitSuccess({
     command: ctx.spec.command_path.join(' '),
     data: result.payload,
-    humanSummary: `Executed tool ${requestedToolName}`,
+    humanSummary: rendered ? rendered.message : (humanSummary || `Executed tool ${requestedToolName}`),
     requestId: result.requestId,
-    meta: {
-      mutating: targetMutating,
-      mutation_classification: targetMutating === null ? 'unknown' : 'name_hint_only',
-      idempotency_key: idempotencyKey,
-    },
-    renderHuman: () => JSON.stringify(result.payload, null, 2),
+    hints: rendered ? rendered.hints : [],
+    meta: rendered ? { ...meta, upsell: rendered.upsell } : meta,
+    renderHuman: () => (rendered ? rendered.text : JSON.stringify(result.payload, null, 2)),
+  });
+}
+
+function confirmationKey(idempotencyKey, globalOptions) {
+  // A key the caller chose must not replay the preview, so the confirming call
+  // gets a derived key; a generated key is simply replaced by a fresh one.
+  return globalOptions.idempotencyKey ? `${idempotencyKey}.confirm` : nextIdempotencyKey({});
+}
+
+async function confirmAndApply(ctx, { requestedToolName, args, preview, result, idempotencyKey, fileBindings, meta }) {
+  const yes = Boolean(ctx.options.yes);
+  const interactive = canPrompt({ runtime: ctx.runtime, output: ctx.output });
+  const previewText = renderPreview(preview);
+  if (interactive && !yes) {
+    process.stderr.write(`${previewText}\n`);
+  }
+  const prompter = interactive && !yes ? createStderrPrompter() : null;
+  let decision;
+  try {
+    decision = await resolveConfirmation({ preview, args, yes, interactive, ask: (question) => prompter.ask(question) });
+  } finally {
+    prompter?.close();
+  }
+
+  if (decision.decision !== 'apply') {
+    const reason = decision.decision === 'not_interactive'
+      ? 'Nothing has changed. Run the same command with --yes to apply it.'
+      : decision.reason;
+    const rerunArgs = decision.decision === 'needs_input' ? { ...args, [decision.field]: '<value>' } : args;
+    return ctx.output.emitSuccess({
+      command: ctx.spec.command_path.join(' '),
+      data: result.payload,
+      humanSummary: reason,
+      requestId: result.requestId,
+      hints: decision.decision === 'declined' ? [] : [{
+        command: `notis tools exec ${requestedToolName} --arguments '${JSON.stringify(rerunArgs)}' --yes`,
+        reason: 'Apply this change',
+      }],
+      meta: { ...meta, confirmation: decision.decision, applied: false },
+      renderHuman: () => (interactive && !yes ? reason : `${previewText}\n\n${reason}`),
+    });
+  }
+
+  const confirmKey = confirmationKey(idempotencyKey, ctx.globalOptions);
+  ctx.output.emitProgress({ phase: 'execute', message: `Applying ${requestedToolName}` });
+  const applied = await runToolCommand({
+    runtime: ctx.runtime,
+    toolName: COMPOSIO_MULTI_EXECUTE_TOOL,
+    arguments_: { tools: [{ tool_slug: requestedToolName, arguments: decision.arguments }] },
+    mutating: true,
+    idempotencyKey: confirmKey,
+    fileBindings,
+  });
+  ctx.output.emitProgress({ phase: 'complete', message: `Finished ${requestedToolName}`, requestId: applied.requestId });
+  return emitToolResult(ctx, {
+    requestedToolName,
+    result: applied,
+    humanSummary: `Applied ${requestedToolName}`,
+    meta: { ...meta, idempotency_key: applied.idempotencyKey ?? confirmKey, attempts: applied.attempts ?? 1, preview_idempotency_key: result.idempotencyKey ?? idempotencyKey, confirmation: 'confirmed', applied: true },
   });
 }
 
@@ -499,8 +587,6 @@ async function toolsExecParallelHandler(ctx) {
     if (!call.tool_name || typeof call.tool_name !== 'string') {
       throw usageError(`calls[${i}] missing required "tool_name" string`);
     }
-    // A batch is just as good an escape hatch as a single exec.
-    assertToolNotDelegated(localNotisToolSlug(call.tool_name));
   }
   ensureLongRunningToolTimeout(ctx, calls.map((call) => localNotisToolSlug(call.tool_name)));
 
@@ -515,8 +601,18 @@ async function toolsExecParallelHandler(ctx) {
         mutating: true,
         idempotencyKey: nextIdempotencyKey(ctx.globalOptions),
       })
-        .then((r) => ({ tool_name: call.tool_name, status: 'ok', payload: r.payload }))
-        .catch((e) => ({ tool_name: call.tool_name, status: 'error', error: e.message }))
+        .then((r) => ({
+          tool_name: call.tool_name,
+          status: 'ok',
+          payload: r.payload,
+          attempts: r.attempts ?? 1,
+        }))
+        .catch((e) => ({
+          tool_name: call.tool_name,
+          status: 'error',
+          error: e.message,
+          attempts: e?.details?.attempts ?? 1,
+        }))
     )
   );
 
@@ -582,11 +678,11 @@ export const toolsCommandSpecs = [
     when_to_use: 'Use this to inspect connection state before searching or executing generic tools.',
     args_schema: { arguments: [], options: [] },
     examples: ['notis tools toolkits', 'notis tools toolkits --json'],
-    output_schema: 'Returns toolkit_connection_statuses from COMPOSIO_SEARCH_TOOLS, rendered as toolkit rows.',
+    output_schema: 'Returns deterministic toolkit namespaces, connection statuses and explicit completeness coverage.',
     mutates: false,
     idempotent: true,
     related_commands: ['notis tools search <query>', 'notis tools describe <tool-name>'],
-    backend_call: { type: 'tool', name: COMPOSIO_SEARCH_TOOLS },
+    backend_call: { type: 'toolkit_inventory', method: 'POST', path: '/cli_tools' },
     handler: toolsToolkitsHandler,
   },
   {
@@ -633,6 +729,7 @@ export const toolsCommandSpecs = [
         { flags: '--file <argument-path=local-path>', description: 'Upload a local file into a file-uploadable tool argument. Repeatable.', collect: true },
         { flags: '--get-schema', description: 'Display the tool parameter schema without executing.' },
         { flags: '--dry-run', description: 'Validate arguments against the tool schema without executing.' },
+        { flags: '--yes', description: 'Apply a change that asks for confirmation without the Continue? [y/N] prompt.' },
       ],
     },
     examples: [

package/src/command-specs/version-history.js

@@ -0,0 +1,20 @@
+import { usageError } from '../runtime/errors.js';
+
+/** The human output of a version comparison: the unified diff text, then its totals. */
+export function unifiedDiffSummary(payload) {
+  const diff = payload && typeof payload === 'object' ? payload : {};
+  const text = typeof diff.unified_diff === 'string' ? diff.unified_diff.replace(/\n$/, '') : '';
+  const files = Array.isArray(diff.files) ? diff.files.length : 0;
+  const count = Number.isInteger(diff.file_count) ? diff.file_count : files;
+  const totals = `${count} ${count === 1 ? 'file' : 'files'} changed, +${diff.additions ?? 0} -${diff.deletions ?? 0}`
+    + (diff.truncated ? ' (comparison cut short; narrow it with --path or use --json)' : '');
+  return text ? `${text}\n\n${totals}` : `No changes. ${totals}`;
+}
+
+/** `--name <name>` sets a version name, `--clear` removes it; exactly one of the two. */
+export function versionName(options) {
+  const hasName = typeof options.name === 'string';
+  if (hasName === Boolean(options.clear)) throw usageError('Pass --name <name>, or --clear to remove the name.');
+  if (hasName && !options.name.trim()) throw usageError('Pass a non-empty --name, or --clear to remove the name.');
+  return hasName ? options.name : null;
+}

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: true });
+    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()];