@notis_ai/cli 0.2.0-beta.32.1 → 0.2.0-beta.41.1

package/src/command-specs/tools.js

@@ -1,4 +1,6 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { accessSync, constants as fsConstants, createReadStream, existsSync, readFileSync, statSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { basename } from 'node:path';
 import { usageError } from '../runtime/errors.js';
 import {
   fetchToolkits,
@@ -42,6 +44,89 @@ const LONG_RUNNING_TOOL_NAMES = new Set([
   'notis-default-edit_image_gemini',
 ]);
 
+const EXTENSION_CONTENT_TYPES = new Map([
+  ['.pdf', 'application/pdf'],
+  ['.png', 'image/png'],
+  ['.jpg', 'image/jpeg'],
+  ['.jpeg', 'image/jpeg'],
+  ['.gif', 'image/gif'],
+  ['.webp', 'image/webp'],
+  ['.txt', 'text/plain'],
+  ['.csv', 'text/csv'],
+  ['.json', 'application/json'],
+  ['.md', 'text/markdown'],
+]);
+
+function guessContentType(filePath) {
+  const lower = filePath.toLowerCase();
+  const dotIndex = lower.lastIndexOf('.');
+  if (dotIndex === -1) return 'application/octet-stream';
+  return EXTENSION_CONTENT_TYPES.get(lower.slice(dotIndex)) || 'application/octet-stream';
+}
+
+async function hashFileSha256(localPath) {
+  const hash = createHash('sha256');
+  for await (const chunk of createReadStream(localPath)) {
+    hash.update(chunk);
+  }
+  return hash.digest('hex');
+}
+
+async function parseFileBindingSpec(spec, index) {
+  if (typeof spec !== 'string' || !spec.trim()) {
+    throw usageError('--file must be formatted as <argument-path>=<local-path>');
+  }
+
+  const equalsIndex = spec.indexOf('=');
+  if (equalsIndex <= 0 || equalsIndex === spec.length - 1) {
+    throw usageError('--file must be formatted as <argument-path>=<local-path>');
+  }
+
+  const argumentPath = spec.slice(0, equalsIndex).trim();
+  const localPath = spec.slice(equalsIndex + 1).trim();
+  if (!argumentPath) {
+    throw usageError('--file argument path is required');
+  }
+  if (!localPath) {
+    throw usageError('--file local path is required');
+  }
+  if (!existsSync(localPath)) {
+    throw usageError(`File not found: ${localPath}`);
+  }
+
+  let stats;
+  try {
+    stats = statSync(localPath);
+    accessSync(localPath, fsConstants.R_OK);
+  } catch {
+    throw usageError(`File is not readable: ${localPath}`);
+  }
+  if (!stats.isFile()) {
+    throw usageError(`File is not a regular file: ${localPath}`);
+  }
+
+  const sha256 = await hashFileSha256(localPath);
+  const fileBasename = basename(localPath);
+  const fieldName = `file_${index}`;
+
+  return {
+    argument_path: argumentPath,
+    field_name: fieldName,
+    basename: fileBasename,
+    size: stats.size,
+    sha256,
+    contentType: guessContentType(fileBasename),
+    localPath,
+  };
+}
+
+async function parseFileBindings(rawFileOptions) {
+  const values = Array.isArray(rawFileOptions)
+    ? rawFileOptions
+    : (rawFileOptions ? [rawFileOptions] : []);
+  return Promise.all(values.map((value, index) => parseFileBindingSpec(value, index)));
+}
+
 function ensureLongRunningToolTimeout(ctx, toolNames) {
   const names = Array.isArray(toolNames) ? toolNames : [toolNames];
   if (!names.some((name) => LONG_RUNNING_TOOL_NAMES.has(name))) {
@@ -124,6 +209,7 @@ async function toolsDescribeHandler(ctx) {
 async function toolsExecHandler(ctx) {
   ensureLongRunningToolTimeout(ctx, ctx.args.toolName);
   const toolkits = normalizeToolkits(ctx.options.toolkits);
+  const fileBindings = await parseFileBindings(ctx.options.file);
 
   if (ctx.options.getSchema) {
     const tool = await fetchToolSchema(ctx.runtime, ctx.args.toolName, ctx.options.toolkits);
@@ -144,6 +230,9 @@ async function toolsExecHandler(ctx) {
     : parseMaybeJson(rawArguments, 'arguments') || {};
 
   if (ctx.options.dryRun) {
+    if (fileBindings.length) {
+      throw usageError('--file is only supported when executing a tool, not with --dry-run');
+    }
     const tool = await fetchToolSchema(ctx.runtime, ctx.args.toolName, ctx.options.toolkits);
     const errors = validateArguments(tool.parameters, args);
 
@@ -171,37 +260,6 @@ 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,
-            ...(toolkits.length ? { toolkits } : {}),
-          },
-          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',
@@ -212,6 +270,7 @@ async function toolsExecHandler(ctx) {
     },
     mutating: true,
     idempotencyKey,
+    fileBindings,
   });
 
   return ctx.output.emitSuccess({
@@ -224,6 +283,10 @@ async function toolsExecHandler(ctx) {
 }
 
 async function toolsExecParallelHandler(ctx) {
+  const parallelFileBindings = await parseFileBindings(ctx.options.file);
+  if (parallelFileBindings.length) {
+    throw usageError('--file is supported by `notis tools exec` only; exec-parallel accepts JSON calls without file uploads.');
+  }
   const calls = parseMaybeJson(ctx.args.calls, 'calls');
   if (!Array.isArray(calls) || !calls.length) {
     throw usageError('calls must be a non-empty JSON array of {tool_name, arguments} objects');
@@ -357,19 +420,20 @@ export const toolsCommandSpecs = [
       arguments: [{ token: '<tool-name>', description: 'Tool name returned by `notis tools search`.' }],
       options: [
         { flags: '--arguments <json>', description: 'JSON object, @file path, or - for stdin.' },
+        { 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: '--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":{}}\'',
+      'notis tools exec composio-dropbox-default-upload_file --arguments \'{"path":"/target/in/dropbox.pdf"}\' --file content=./Invoice.pdf',
     ],
     output_schema: 'Returns the raw tool execution payload.',
     mutates: true,
@@ -386,7 +450,9 @@ export const toolsCommandSpecs = [
       arguments: [
         { token: '<calls>', description: 'JSON array of {tool_name, arguments} objects.' },
       ],
-      options: [],
+      options: [
+        { flags: '--file <argument-path=local-path>', description: 'Unsupported for exec-parallel; use tools exec for file uploads.', collect: true },
+      ],
     },
     examples: [
       'notis tools exec-parallel \'[{"tool_name":"notis-default-query","arguments":{"database_slug":"tasks","query":{}}},{"tool_name":"notis-default-list_databases","arguments":{}}]\'',

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

@@ -23,6 +23,7 @@ import {
   exportNameFromPath,
   getBundleDir,
   loadAppConfig,
+  prepareArtifactBuild,
   readManifest,
 } from './app-platform.js';
 
@@ -77,6 +78,14 @@ function scriptJson(value) {
     .replace(/\u2029/g, '\\u2029');
 }
 
+function timingMs(startedAt) {
+  return Number(process.hrtime.bigint() - startedAt) / 1_000_000;
+}
+
+function formatTimingMs(value) {
+  return value.toFixed(value < 10 ? 2 : 1);
+}
+
 function readJsonFile(path) {
   if (!existsSync(path)) {
     return null;
@@ -105,8 +114,8 @@ function reactVersionFromPeer(peerRange) {
 function resolveHarnessReactVersion(projectDir) {
   const candidates = [
     join(projectDir, 'node_modules', '@notis', 'sdk', 'package.json'),
-    join(REPO_ROOT, 'packages', 'notis-sdk', 'package.json'),
-    join(CLI_ROOT, 'template', 'packages', 'notis-sdk', 'package.json'),
+    join(REPO_ROOT, 'packages', 'sdk', 'package.json'),
+    join(CLI_ROOT, 'template', 'packages', 'sdk', 'package.json'),
   ];
   for (const candidate of candidates) {
     const pkg = readJsonFile(candidate);
@@ -234,7 +243,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}>, 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, 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,
@@ -254,6 +263,7 @@ export async function startAppDevServer({
       slug: app.slug,
       projectDir: app.projectDir,
       appId: app.appId || null,
+      userId: app.userId || null,
       canonicalBundleDir: getBundleDir(app.projectDir),
       bundleDir: null,
       jsPath: null,
@@ -381,11 +391,21 @@ export async function startAppDevServer({
     }
 
     if (url.pathname === '/healthz') {
+      const now = new Date().toISOString();
+      const sessions = Array.from(appState.values()).map((state) => ({
+        appId: state.appId,
+        userId: state.userId,
+        devSlug: state.slug,
+        bundleBaseUrl: `http://127.0.0.1:${port}/a/${state.slug}`,
+        projectDir: state.projectDir,
+        lastHeartbeatAt: now,
+        status: 'connected',
+      }));
       res.writeHead(200, {
         ...headers,
         'Content-Type': 'application/json; charset=utf-8',
       });
-      res.end(JSON.stringify({ ok: true, apps: Array.from(appState.keys()) }));
+      res.end(JSON.stringify({ ok: true, apps: Array.from(appState.keys()), sessions }));
       return;
     }
 
@@ -454,17 +474,20 @@ export async function startAppDevServer({
     }
 
     if (routed.rest.startsWith('bundle/')) {
+      const startedAt = process.hrtime.bigint();
       updateBundleDir(state, resolveBundleDir(state));
       const rel = routed.rest.slice('bundle/'.length);
       if (!state.bundleDir) {
         res.writeHead(404, headers);
         res.end('not found');
+        log(`[notis apps timing] ${state.slug}: GET bundle/${rel} -> 404 in ${formatTimingMs(timingMs(startedAt))}ms`);
         return;
       }
       const full = safeJoin(state.bundleDir, rel);
       if (!full || !existsSync(full)) {
         res.writeHead(404, headers);
         res.end('not found');
+        log(`[notis apps timing] ${state.slug}: GET bundle/${rel} -> 404 in ${formatTimingMs(timingMs(startedAt))}ms`);
         return;
       }
       const ext = extFor(rel);
@@ -480,6 +503,10 @@ export async function startAppDevServer({
       } else {
         res.end(content);
       }
+      log(
+        `[notis apps timing] ${state.slug}: GET bundle/${rel} -> 200 ` +
+        `${content.byteLength}B in ${formatTimingMs(timingMs(startedAt))}ms`,
+      );
       return;
     }
 
@@ -527,6 +554,7 @@ export async function startAppDevServer({
 
   for (const state of appState.values()) {
     if (watch) {
+      await prepareArtifactBuild(state.projectDir);
       pollForBundleAndWatch(state);
 
       state.buildProcess = spawn('npm', ['run', 'build', '--', '--watch'], {