@notis_ai/cli 0.2.1 → 0.2.3

package/src/command-specs/helpers.js

@@ -1,13 +1,34 @@
-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 const COMPOSIO_SEARCH_TOOLS = 'COMPOSIO_SEARCH_TOOLS';
+export const COMPOSIO_GET_TOOL_SCHEMAS = 'COMPOSIO_GET_TOOL_SCHEMAS';
+export const COMPOSIO_MULTI_EXECUTE_TOOL = 'COMPOSIO_MULTI_EXECUTE_TOOL';
+
+const NOTIS_DATABASE_CORE_NAMES = new Set([
+  'query',
+  'get_database',
+  'get_document',
+  'list_databases',
+  'upsert_database',
+]);
+
+function isNotisDatabaseCoreName(coreName) {
+  // Mirrors server is_database_tool_name: canonical database ops plus generated
+  // upsert_<db> tools. Database tools live in the NOTIS_DATABASE toolkit so their
+  // public slug carries the DATABASE segment.
+  return NOTIS_DATABASE_CORE_NAMES.has(coreName) || coreName.startsWith('upsert_');
+}
+
+export function localNotisToolSlug(toolName) {
+  if (typeof toolName !== 'string' || !toolName.startsWith('notis-')) {
+    return toolName;
+  }
+  const coreName = toolName.slice('notis-'.length);
+  const prefix = isNotisDatabaseCoreName(coreName) ? 'LOCAL_NOTIS_DATABASE_' : 'LOCAL_NOTIS_';
+  return `${prefix}${coreName.replace(/-/g, '_').toUpperCase()}`;
+}
 
 export function parseJson(value, label) {
   try {
@@ -24,33 +45,6 @@ export function parseMaybeJson(value, label) {
   return parseJson(value, label);
 }
 
-export function normalizeToolkits(value) {
-  if (!value) {
-    return [];
-  }
-  if (value.startsWith('[')) {
-    const parsed = parseJson(value, 'toolkits');
-    if (!Array.isArray(parsed)) {
-      throw usageError('toolkits JSON must be an array of toolkit strings');
-    }
-    return parsed;
-  }
-  return value
-    .split(',')
-    .map((entry) => entry.trim())
-    .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();
 }
@@ -61,39 +55,32 @@ export async function runToolCommand({
   arguments_ = {},
   mutating = false,
   idempotencyKey,
+  fileBindings = [],
 }) {
   const result = await callTool({
     runtime: { ...runtime, mutating },
     toolName,
     arguments_,
     idempotencyKey: mutating ? idempotencyKey : null,
+    fileBindings,
   });
   return result;
 }
 
 export async function fetchToolkits(runtime) {
-  const result = await runToolCommand({
-    runtime,
-    toolName: 'notis_find_toolkits',
-  });
-  return result.payload.toolkits || [];
-}
-
-export async function resolveSearchToolkits(runtime, rawToolkits) {
-  const toolkits = normalizeToolkits(rawToolkits);
-  if (toolkits.length) {
-    return toolkits;
-  }
-  const availableToolkits = await fetchToolkits(runtime);
-  return availableToolkits.map((entry) => entry.id);
+  const payload = await fetchToolDiscovery(runtime, 'List available toolkit namespaces and connection statuses');
+  return (payload.toolkit_connection_statuses || []).map((entry) => ({
+    id: entry.toolkit,
+    provider: typeof entry.toolkit === 'string' ? entry.toolkit.split('-', 1)[0] : undefined,
+    description: entry.description || entry.status_message || entry.toolkit,
+    has_active_connection: Boolean(entry.has_active_connection),
+    status_message: entry.status_message || '',
+    connection_details: entry.connection_details || {},
+  }));
 }
 
 export async function probeAuth(runtime) {
-  const result = await runToolCommand({
-    runtime,
-    toolName: 'notis_find_toolkits',
-  });
-  return result.payload;
+  return fetchToolDiscovery(runtime, 'List available toolkit namespaces and connection statuses');
 }
 
 export async function healthCheck(runtime) {
@@ -105,65 +92,46 @@ export async function healthCheck(runtime) {
   });
 }
 
-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;
+export async function fetchToolSchema(runtime, toolName) {
+  const result = await runToolCommand({
+    runtime,
+    toolName: COMPOSIO_GET_TOOL_SCHEMAS,
+    arguments_: {
+      tool_slugs: [toolName],
+    },
+  });
+  const payload = result.payload || {};
+  const schema = (
+    payload.tool_schemas?.[toolName] ||
+    payload.schemas?.[toolName] ||
+    payload.tools?.find?.((tool) => tool?.tool_slug === toolName || tool?.name === toolName)
+  );
+  if (!schema) {
+    throw usageError(`Tool "${toolName}" not found.`);
   }
-  saveConfig(config);
-  return config;
-}
-
-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;
+  return {
+    name: toolName,
+    toolkit_id: schema.toolkit,
+    description: schema.description || '',
+    parameters: schema.input_schema || { type: 'object', properties: {} },
+    output_schema: schema.output_schema || {},
+    schema_available: Boolean(schema.hasFullSchema),
+  };
 }
 
-export async function fetchToolSchema(runtime, toolName, rawToolkits) {
-  const toolkits = normalizeToolkits(rawToolkits);
+export async function fetchToolDiscovery(runtime, useCase, knownFields = '') {
+  const query = { use_case: useCase };
+  if (knownFields) {
+    query.known_fields = knownFields;
+  }
   const result = await runToolCommand({
     runtime,
-    toolName: 'notis_find_tools',
+    toolName: COMPOSIO_SEARCH_TOOLS,
     arguments_: {
-      query: toolName,
-      ...(toolkits.length ? { toolkits } : {}),
+      queries: [query],
     },
   });
-  const tools = result.payload.tools || [];
-  const match = tools.find((t) => t.name === toolName);
-  if (!match) {
-    throw usageError(`Tool "${toolName}" not found.`);
-  }
-  return match;
+  return result.payload || {};
 }
 
 export function validateArguments(schema, args) {

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: 'Develop, build, and deploy Notis Apps.',
-  db: 'List, query, and update native Notis Databases.',
   tools: 'Discover and execute generic tools exposed through Notis.',
 };
 
 export const COMMAND_SPECS = [
-  ...authCommandSpecs,
   ...appsCommandSpecs,
-  ...dbCommandSpecs,
   ...toolsCommandSpecs,
   ...metaCommandSpecs,
 ];

package/src/command-specs/meta.js

@@ -1,4 +1,4 @@
-import { healthCheck, probeAuth } from './helpers.js';
+import { COMPOSIO_SEARCH_TOOLS, healthCheck, probeAuth } from './helpers.js';
 import { findCommandSpec, formatDescribe } from '../runtime/help.js';
 
 async function doctorHandler(ctx) {
@@ -21,7 +21,7 @@ async function doctorHandler(ctx) {
   if (ctx.runtime.jwt) {
     try {
       const payload = await probeAuth(ctx.runtime);
-      checks.tool_roundtrip = Array.isArray(payload.toolkits) ? 'ok' : 'error';
+      checks.tool_roundtrip = Array.isArray(payload.toolkit_connection_statuses) ? 'ok' : 'error';
     } catch {
       checks.tool_roundtrip = 'error';
     }
@@ -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' });
@@ -68,7 +68,7 @@ function decodeJwtUserId(jwt) {
 
 async function whoamiHandler(ctx) {
   const payload = await probeAuth(ctx.runtime);
-  const toolkits = payload.toolkits || [];
+  const toolkits = payload.toolkit_connection_statuses || [];
   const userId = decodeJwtUserId(ctx.runtime.jwt);
 
   return ctx.output.emitSuccess({
@@ -78,7 +78,7 @@ async function whoamiHandler(ctx) {
       api_base: ctx.runtime.apiBase,
       user_id: userId,
       toolkit_count: toolkits.length,
-      toolkits: toolkits.map((t) => t.id),
+      toolkits: toolkits.map((t) => t.toolkit),
       cli_version: ctx.runtime.cliVersion,
     },
     humanSummary: `Logged in as ${userId || 'unknown'} via profile "${ctx.runtime.profileName}"`,
@@ -91,7 +91,7 @@ async function whoamiHandler(ctx) {
         `Version:   ${ctx.runtime.cliVersion}`,
       ].join('\n'),
     hints: [
-      { command: 'notis tools toolkits', reason: 'List available toolkit namespaces' },
+      { command: 'notis tools toolkits', reason: 'List available toolkit namespaces and connection statuses' },
       { command: 'notis doctor', reason: 'Run a full health check' },
     ],
   });
@@ -110,15 +110,15 @@ async function describeHandler(ctx) {
 export const metaCommandSpecs = [
   {
     command_path: ['whoami'],
-    summary: 'Display the active profile, user, and available toolkits.',
+    summary: 'Display the active profile, user, and available toolkit connection statuses.',
     when_to_use: 'Use this to quickly confirm which account and environment a command will target.',
     args_schema: { arguments: [], options: [] },
     examples: ['notis whoami', 'notis whoami --json'],
     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'],
-    backend_call: { type: 'tool', name: 'notis_find_toolkits' },
+    related_commands: ['notis doctor'],
+    backend_call: { type: 'tool', name: COMPOSIO_SEARCH_TOOLS },
     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,