@notis_ai/cli 0.2.18 → 0.2.20

package/src/command-specs/helpers.js

@@ -1,3 +1,5 @@
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
 import { randomUUID } from 'node:crypto';
 import { CliError, EXIT_CODES, usageError } from '../runtime/errors.js';
 import { callTool, httpRequest } from '../runtime/transport.js';
@@ -12,6 +14,8 @@ const NOTIS_DATABASE_CORE_NAMES = new Set([
   'get_document',
   'list_databases',
   'upsert_database',
+  'upload_file',
+  'delete_database',
 ]);
 
 function isNotisDatabaseCoreName(coreName) {
@@ -74,19 +78,35 @@ export async function runToolCommand({
 }
 
 export async function fetchToolkits(runtime) {
-  const payload = await fetchToolDiscovery(runtime, 'List available toolkit namespaces and connection statuses');
-  return (payload.toolkit_connection_statuses || []).map((entry) => ({
+  const payload = await probeAuth(runtime);
+  const toolkits = payload.toolkit_connection_statuses.map((entry) => ({
     id: entry.toolkit,
-    provider: typeof entry.toolkit === 'string' ? entry.toolkit.split('-', 1)[0] : undefined,
+    provider: entry.provider,
     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 || {},
+    availability: entry.availability,
   }));
+  return { toolkits, coverage: payload.coverage, warnings: payload.warnings };
 }
 
 export async function probeAuth(runtime) {
-  return fetchToolDiscovery(runtime, 'List available toolkit namespaces and connection statuses');
+  const result = await httpRequest({ runtime, path: '/cli_tools', body: { operation: 'toolkit_inventory' } });
+  const payload = result.payload;
+  if (payload?.success !== true || !Array.isArray(payload.toolkit_connection_statuses)
+      || typeof payload.coverage?.complete !== 'boolean'
+      || !payload.coverage.families || typeof payload.coverage.families !== 'object'
+      || Array.isArray(payload.coverage.families)
+      || payload.toolkit_connection_statuses.some((row) => !row || typeof row.toolkit !== 'string' || !row.toolkit
+        || typeof row.provider !== 'string' || !row.provider)) {
+    throw new CliError({ code: 'invalid_toolkit_inventory', message: 'The server did not return a valid toolkit inventory.', exitCode: EXIT_CODES.backend });
+  }
+  return {
+    ...payload,
+    toolkit_connection_statuses: [...payload.toolkit_connection_statuses].sort((a, b) => a.toolkit.localeCompare(b.toolkit)),
+    warnings: [...(Array.isArray(payload.warnings) ? payload.warnings.filter((v) => typeof v === 'string') : []),
+      ...(!payload.coverage.complete ? ['Toolkit inventory is incomplete; some connections could not be checked.'] : [])],
+  };
 }
 
 export async function healthCheck(runtime) {
@@ -143,45 +163,35 @@ export async function fetchToolDiscovery(runtime, useCase, knownFields = '') {
   return result.payload || {};
 }
 
-export function validateArguments(schema, args) {
-  const errors = [];
-  if (!schema || schema.type !== 'object') return errors;
-
-  const properties = schema.properties || {};
-  const required = schema.required || [];
+// Tool schemas are the dry-run contract, including nested branches and constraints.
+const toolArgumentsAjv = new Ajv({
+  allErrors: true, strict: false, strictSchema: true, strictNumbers: true, logger: false,
+  coerceTypes: false, useDefaults: false, removeAdditional: false,
+});
+addFormats(toolArgumentsAjv);
+// Native tool schemas mark uploadable fields with this annotation.
+toolArgumentsAjv.addKeyword({ keyword: 'file_uploadable', schemaType: 'boolean', valid: true });
 
-  for (const field of required) {
-    if (!(field in args)) {
-      errors.push(`Missing required field: "${field}"`);
-    }
-  }
-
-  if (schema.additionalProperties === false) {
-    for (const key of Object.keys(args)) {
-      if (!(key in properties)) {
-        errors.push(`Unknown field: "${key}"`);
-      }
-    }
+export function validateArguments(schema, args) {
+  if (schema == null) return [];
+  let validate;
+  try {
+    validate = toolArgumentsAjv.compile(schema);
+  } catch {
+    // A malformed or unsupported schema cannot establish a valid dry run.
+    return ['Tool schema could not be validated; inspect the current schema.'];
   }
-
-  for (const [key, value] of Object.entries(args)) {
-    const prop = properties[key];
-    if (!prop) continue;
-    if (prop.type === 'string' && typeof value !== 'string') {
-      errors.push(`Field "${key}" should be a string, got ${typeof value}`);
-    }
-    if (prop.type === 'integer' && !Number.isInteger(value)) {
-      errors.push(`Field "${key}" should be an integer, got ${typeof value}`);
+  if (validate(args)) return [];
+  return (validate.errors || []).map((error) => {
+    const path = error.instancePath ? ` at "${error.instancePath}"` : '';
+    if (error.keyword === 'required') {
+      return `Missing required field: "${error.params.missingProperty}"${path}`;
     }
-    if (prop.type === 'array' && !Array.isArray(value)) {
-      errors.push(`Field "${key}" should be an array, got ${typeof value}`);
+    if (error.keyword === 'additionalProperties') {
+      return `Unknown field: "${error.params.additionalProperty}"${path}`;
     }
-    if (prop.type === 'object' && (typeof value !== 'object' || value === null || Array.isArray(value))) {
-      errors.push(`Field "${key}" should be an object, got ${typeof value}`);
-    }
-  }
-
-  return errors;
+    return `Invalid arguments${path}: ${error.message || error.keyword}`;
+  });
 }
 
 export function toolConflictToError(payload, defaultMessage) {

package/src/command-specs/index.js

@@ -1,4 +1,3 @@
-import { appsCommandSpecs } from './apps.js';
 import { toolsCommandSpecs } from './tools.js';
 import { metaCommandSpecs } from './meta.js';
 import { onboardingCommandSpecs } from './onboarding.js';
@@ -9,13 +8,20 @@ import { profileCommandSpecs } from './profile.js';
 import { handoverCommandSpecs } from './handover.js';
 import { agentsCommandSpecs } from './agents.js';
 import { skillsCommandSpecs } from './skills.js';
+import { spacesCommandSpecs } from './spaces.js';
+import { documentsCommandSpecs } from './documents.js';
+import { viewsCommandSpecs } from './views.js';
+import { filesCommandSpecs } from './files.js';
 
 export const GROUP_SUMMARIES = {
-  apps: 'Develop, deploy, and submit Notis Apps.',
+  files: 'Upload local files for native records with verified byte receipts.',
+  views: 'Discover and render the views you can open.',
+  spaces: 'Build independent Spaces and their declared capabilities.',
+  documents: 'Read, compare and restore saved document versions, and manage the documents Bin.',
   agents: 'Install Notis context into local coding agents.',
-  handover: 'Hand the branch you are on to a Notis agent, hosted or your own Codex/Claude.',
+  handover: 'Hand the branch you are on to a Notis agent, hosted or Codex/Claude in the cloud.',
   tools: 'Discover and execute generic tools exposed through Notis.',
-  skills: 'Keep Notis and local-agent skills synchronized.',
+  skills: 'List, edit and link Notis Skills, and keep local-agent skills synchronized.',
   profile: 'Switch between signed-in accounts and their API endpoints.',
   debug: 'Inspect effective runtime context, worker identity, and trace costs.',
   smoke: 'Run deterministic connected-service smoke tests with guaranteed cleanup.',
@@ -27,7 +33,10 @@ export const COMMAND_SPECS = [
   ...onboardingCommandSpecs,
   ...agentsCommandSpecs,
   ...skillsCommandSpecs,
-  ...appsCommandSpecs,
+  ...spacesCommandSpecs,
+  ...documentsCommandSpecs,
+  ...viewsCommandSpecs,
+  ...filesCommandSpecs,
   ...handoverCommandSpecs,
   ...toolsCommandSpecs,
   ...diagnosticCommandSpecs,

package/src/command-specs/meta.js

@@ -1,7 +1,7 @@
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { COMPOSIO_SEARCH_TOOLS, healthCheck, probeAuth } from './helpers.js';
+import { healthCheck, probeAuth } from './helpers.js';
 import { findCommandSpec, formatDescribe } from '../runtime/help.js';
 import { createExpiredAuthError, getAuthRecovery } from '../runtime/auth-recovery.js';
 import { cliCommandForChannel, resolveChannelSwitch } from '../runtime/channel.js';
@@ -51,6 +51,9 @@ export function doctorChannelSummary(
 }
 
 async function doctorHandler(ctx) {
+  let toolkitCoverage = null;
+  let toolkitWarnings = [];
+  let authenticatedUserId = null;
   const checks = {
     config: 'ok',
     auth: 'missing',
@@ -58,6 +61,7 @@ async function doctorHandler(ctx) {
     routing: 'ok',
     health: 'unknown',
     tool_roundtrip: 'unknown',
+    identity: 'unknown',
   };
 
   if (ctx.runtime.credentialKind === 'oauth') {
@@ -100,7 +104,12 @@ async function doctorHandler(ctx) {
       // cold local backend. A diagnostic must not report a false failure just
       // because that legitimate roundtrip exceeds the general 30s default.
       const payload = await probeAuth(doctorToolRoundtripRuntime(ctx.runtime));
-      checks.tool_roundtrip = Array.isArray(payload.toolkit_connection_statuses) ? 'ok' : 'error';
+      toolkitCoverage = payload.coverage;
+      const identity = serverAccountIdentity(ctx.runtime, payload);
+      authenticatedUserId = identity.verified ? identity.userId : null;
+      checks.identity = identity.verified ? (identity.mismatch ? 'mismatch' : 'ok') : 'unverified';
+      toolkitWarnings = [...payload.warnings, ...identity.warnings];
+      checks.tool_roundtrip = payload.coverage.complete ? 'ok' : 'partial';
       profile = getProfile(loadConfig(), ctx.runtime.profileName);
       checks.auth = ctx.runtime.jwt
         ? (credentialIsExpired(ctx.runtime, profile) ? 'expired' : 'configured')
@@ -158,6 +167,7 @@ async function doctorHandler(ctx) {
       release_channel: releaseChannel || null,
       cli_version: ctx.runtime.cliVersion || null,
       credential_source: ctx.runtime.credentialKind || null,
+      user_id: authenticatedUserId,
       ...(ctx.runtime.credentialKind === 'oauth'
         ? {
             oauth_client_id: profile.oauth_client_id || null,
@@ -167,7 +177,9 @@ async function doctorHandler(ctx) {
           }
         : {}),
       checks,
+      toolkit_coverage: toolkitCoverage,
     },
+    warnings: toolkitWarnings,
     humanSummary: `Doctor checks completed for profile ${ctx.runtime.profileName}`,
     hints,
     renderHuman: () =>
@@ -195,10 +207,22 @@ export function activeRuntimeUserId(runtime) {
     : decodeJwtUserId(runtime.jwt);
 }
 
+function serverAccountIdentity(runtime, payload) {
+  const canonical = typeof payload.user_id === 'string' && payload.user_id.trim() ? payload.user_id : null;
+  const cached = activeRuntimeUserId(runtime);
+  // Portal JWT subjects can be linked Auth IDs rather than canonical Notis IDs.
+  const mismatch = Boolean(canonical && runtime.credentialKind === 'oauth' && cached && cached !== canonical);
+  return { userId: canonical || cached, verified: Boolean(canonical), mismatch,
+    warnings: canonical
+      ? (mismatch ? ['The saved OAuth account differs from the account authenticated by the server.'] : [])
+      : ['Account identity is not verified by this server; the displayed identity comes from this profile.'] };
+}
+
 async function whoamiHandler(ctx) {
   const payload = await probeAuth(ctx.runtime);
   const toolkits = payload.toolkit_connection_statuses || [];
-  const userId = activeRuntimeUserId(ctx.runtime);
+  const identity = serverAccountIdentity(ctx.runtime, payload);
+  const userId = identity.userId;
 
   return ctx.output.emitSuccess({
     command: ctx.spec.command_path.join(' '),
@@ -208,17 +232,22 @@ async function whoamiHandler(ctx) {
       api_base: ctx.runtime.apiBase,
       credential_source: ctx.runtime.credentialKind || null,
       user_id: userId,
-      toolkit_count: toolkits.length,
+      identity_source: identity.verified ? 'server' : 'profile_unverified',
+      toolkit_count: payload.coverage.complete ? toolkits.length : null,
+      observed_toolkit_count: toolkits.length,
+      coverage: payload.coverage,
       toolkits: toolkits.map((t) => t.toolkit),
       cli_version: ctx.runtime.cliVersion,
     },
-    humanSummary: `Logged in as ${userId || 'unknown'} via profile "${ctx.runtime.profileName}"`,
+    humanSummary: `${identity.verified ? 'Logged in as' : 'Unverified saved identity'} ${userId || 'unknown'} via profile "${ctx.runtime.profileName}"`,
+    warnings: [...payload.warnings, ...identity.warnings],
     renderHuman: () =>
       [
         `Profile:   ${ctx.runtime.profileName}`,
         `API:       ${ctx.runtime.apiBase}`,
         `User:      ${userId || 'unknown'}`,
-        `Toolkits:  ${toolkits.length}`,
+        `Identity:  ${identity.verified ? 'verified by server' : 'unverified saved profile'}`,
+        `Toolkits:  ${toolkits.length}${payload.coverage.complete ? '' : ' observed (inventory incomplete)'}`,
         `Version:   ${ctx.runtime.cliVersion}`,
       ].join('\n'),
     hints: [
@@ -249,7 +278,7 @@ export const metaCommandSpecs = [
     mutates: false,
     idempotent: true,
     related_commands: ['notis doctor'],
-    backend_call: { type: 'tool', name: COMPOSIO_SEARCH_TOOLS },
+    backend_call: { type: 'toolkit_inventory', method: 'POST', path: '/cli_tools' },
     handler: whoamiHandler,
   },
   {
@@ -271,10 +300,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 deploy".' }],
+      arguments: [{ token: '<command...>', key: 'commandPath', description: 'Command path to describe, such as "spaces deploy".' }],
       options: [],
     },
-    examples: ['notis describe apps deploy', 'notis describe tools exec'],
+    examples: ['notis describe spaces deploy', 'notis describe tools exec'],
     output_schema: 'Returns the command spec metadata for the requested command.',
     mutates: false,
     idempotent: true,

package/src/command-specs/onboarding.js

@@ -157,7 +157,7 @@ async function authenticatedResult(ctx) {
   }
 
   if (onboardingComplete) {
-    const name = state?.settings?.full_name;
+    const name = state?.settings?.first_name;
     const setupSummary = renderAgentSetup(base.agent_setup);
     return ctx.output.emitSuccess({
       command: 'start',

package/src/command-specs/profile.js

@@ -1,3 +1,5 @@
+import { spawn } from 'node:child_process';
+import { CHANNEL_SWITCH_ENV } from '../runtime/channel.js';
 import { CliError, EXIT_CODES } from '../runtime/errors.js';
 import { quoteShellArgument } from '../runtime/auth-recovery.js';
 import {
@@ -114,6 +116,44 @@ async function listHandler(ctx) {
   });
 }
 
+const SKILL_SYNC_API_BASE_PATTERN = /^https:\/\/api(?:-beta)?\.notis\.ai\/?$/;
+
+// Overrides that belong to this `profile use` run. Inherited, a NOTIS_JWT would
+// sync its own account into the agent folders under the named profile.
+const RELINK_DROPPED_ENV = ['NOTIS_JWT', 'NOTIS_API_BASE', 'NOTIS_PROFILE', CHANNEL_SWITCH_ENV];
+
+// The new default's skills take over the agent folders (Claude Code, Codex,
+// Cursor) now rather than at the next automatic sync. Detached, so the switch
+// itself stays instant; a failure waits for that next sync.
+export function relinkSkillsInBackground(name, profile, {
+  env = process.env,
+  argv = process.argv,
+  execPath = process.execPath,
+  spawnImpl = spawn,
+} = {}) {
+  // Never from a test run: a detached sync would outlive it and reach the real API.
+  if (env.NODE_ENV === 'test' || env.NODE_TEST_CONTEXT || !argv[1]) return false;
+  if (!profile?.oauth_access_token && !profile?.oauth_refresh_token) return false;
+  if (!SKILL_SYNC_API_BASE_PATTERN.test(String(profile.api_base || ''))) return false;
+  // Like the automatic sync, the relink runs as the named profile alone: its
+  // credential, its endpoint and the CLI build for its channel.
+  const childEnv = { ...env };
+  for (const key of RELINK_DROPPED_ENV) delete childEnv[key];
+  try {
+    const child = spawnImpl(
+      execPath,
+      [argv[1], 'skills', 'sync', '--json', '--profile', name],
+      { detached: true, stdio: 'ignore', env: childEnv },
+    );
+    child.on('error', () => {});
+    child.unref();
+    return true;
+  } catch {
+    // The next automatic sync relinks.
+    return false;
+  }
+}
+
 async function useHandler(ctx) {
   const requested = ctx.args.name;
   const config = loadConfig();
@@ -132,6 +172,7 @@ async function useHandler(ctx) {
   const worktreeOverride = Boolean(worktreeRuntime);
   const worktreeBlocked = Boolean(worktreeUnavailable);
   const authenticated = profileHasCredential(profile);
+  if (authenticated) relinkSkillsInBackground(requested, profile);
 
   return ctx.output.emitSuccess({
     command: ctx.spec.command_path.join(' '),
@@ -298,7 +339,7 @@ export const profileCommandSpecs = [
     command_path: ['profile', 'use'],
     summary: 'Switch the default profile without signing any profile out.',
     when_to_use:
-      'Use this to change which account and API subsequent commands target. Every other profile keeps its credential.',
+      'Use this to change which account and API subsequent commands target. Every other profile keeps its credential. Its skills replace the previous default\'s in the agent folders (Claude Code, Codex, Cursor) straight away.',
     args_schema: {
       arguments: [{ token: '<name>', key: 'name', description: 'Profile to make active.' }],
       options: [],