@notis_ai/cli 0.2.0-beta.16.1

package/src/command-specs/apps.js

@@ -0,0 +1,496 @@
+/**
+ * Notis apps CLI commands.
+ *
+ * Clean command set for the Vercel-like Notis app workflow:
+ *   init -> dev -> build -> preview -> deploy
+ *
+ * Supporting commands: list, link, doctor.
+ */
+
+import { EXIT_CODES, usageError } from '../runtime/errors.js';
+import { formatTable } from '../runtime/output.js';
+import {
+  resolveProjectDir,
+  loadAppConfig,
+  detectProjectProblems,
+  detectProjectWarnings,
+  buildArtifact,
+  readManifest,
+  readLinkedState,
+  writeLinkedState,
+  requireLinkedAppId,
+  scaffoldProject,
+  collectArtifactFiles,
+  runProjectScript,
+  directDeploy,
+} from '../runtime/app-platform.js';
+import { startPreviewServer } from '../runtime/app-preview-server.js';
+import {
+  nextIdempotencyKey,
+  runToolCommand,
+  toolConflictToError,
+} from './helpers.js';
+
+// ---------------------------------------------------------------------------
+// Formatters
+// ---------------------------------------------------------------------------
+
+function appsTable(apps) {
+  return formatTable(apps, [
+    { label: 'ID', value: (app) => app.app_id || app.id || '' },
+    { label: 'Name', value: (app) => app.name || 'Untitled' },
+    { label: 'Version', value: (app) => app.current_version || app.manifest?.version || 0 },
+    { label: 'Status', value: (app) => app.status || '' },
+  ]);
+}
+
+async function assertDirectDeployAccess(runtime, appId) {
+  const result = await runToolCommand({
+    runtime,
+    toolName: 'notis_list_apps',
+  });
+  const apps = result.payload.apps || [];
+  const hasAccess = apps.some((app) => (app.app_id || app.id) === appId);
+  if (!hasAccess) {
+    throw usageError(`Direct deploy requires access to app ${appId}.`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+
+async function appsListHandler(ctx) {
+  const result = await runToolCommand({
+    runtime: ctx.runtime,
+    toolName: 'notis_list_apps',
+  });
+  const apps = result.payload.apps || [];
+  return ctx.output.emitSuccess({
+    command: ctx.spec.command_path.join(' '),
+    data: { apps },
+    humanSummary: apps.length ? `Found ${apps.length} apps` : 'No apps found.',
+    renderHuman: () => (apps.length ? appsTable(apps) : 'No apps found.'),
+  });
+}
+
+async function appsInitHandler(ctx) {
+  const projectDir = resolveProjectDir(ctx.args.dir || ctx.args.name.toLowerCase().replace(/[^a-z0-9]+/g, '-'));
+
+  scaffoldProject({ projectDir, appName: ctx.args.name });
+
+  return ctx.output.emitSuccess({
+    command: ctx.spec.command_path.join(' '),
+    data: { project_dir: projectDir, app_name: ctx.args.name },
+    humanSummary: `Scaffolded "${ctx.args.name}" in ${projectDir}`,
+    hints: [
+      { command: `cd ${projectDir} && npm install`, reason: 'Install dependencies' },
+      { command: 'npm run dev', reason: 'Start the Vite dev server' },
+    ],
+  });
+}
+
+async function appsCreateHandler(ctx) {
+  const projectDir = ctx.args.dir ? resolveProjectDir(ctx.args.dir) : null;
+  const idempotencyKey = nextIdempotencyKey(ctx.globalOptions);
+  const icon = ctx.options.icon
+    ? (ctx.options.icon.startsWith('lucide:') ? ctx.options.icon : `lucide:${ctx.options.icon}`)
+    : undefined;
+  const result = await runToolCommand({
+    runtime: ctx.runtime,
+    toolName: 'notis_create_app',
+    arguments_: {
+      name: ctx.args.name,
+      description: ctx.options.description || undefined,
+      icon,
+    },
+    mutating: true,
+    idempotencyKey,
+  });
+
+  const app = result.payload.app || result.payload;
+  if (!app?.id) {
+    throw usageError('Create app did not return an app id.');
+  }
+
+  if (projectDir) {
+    writeLinkedState(projectDir, {
+      app_id: app.id,
+      linked_at: new Date().toISOString(),
+    });
+  }
+
+  return ctx.output.emitSuccess({
+    command: ctx.spec.command_path.join(' '),
+    data: {
+      app,
+      project_dir: projectDir,
+      linked: Boolean(projectDir),
+      idempotency_key: idempotencyKey,
+    },
+    humanSummary: projectDir
+      ? `Created app ${app.name || ctx.args.name} (${app.id}) and linked ${projectDir}`
+      : `Created app ${app.name || ctx.args.name} (${app.id})`,
+    hints: projectDir
+      ? [{ command: `cd ${projectDir} && notis apps deploy .`, reason: 'Deploy the linked project' }]
+      : [{ command: `notis apps link ${app.id} .`, reason: 'Link a local project before deploying' }],
+    meta: { mutating: true, idempotency_key: idempotencyKey },
+  });
+}
+
+async function appsDevHandler(ctx) {
+  const projectDir = resolveProjectDir(ctx.args.dir || '.');
+  const problems = detectProjectProblems(projectDir);
+  if (problems.length) {
+    throw usageError(`Project has problems:\n${problems.map((p) => `  - ${p}`).join('\n')}`);
+  }
+
+  await runProjectScript({
+    projectDir,
+    scriptName: 'dev',
+    env: { NOTIS_DEV: '1' },
+  });
+
+  return EXIT_CODES.ok;
+}
+
+async function appsBuildHandler(ctx) {
+  const projectDir = resolveProjectDir(ctx.args.dir || '.');
+  const problems = detectProjectProblems(projectDir);
+  if (problems.length) {
+    throw usageError(`Project has problems:\n${problems.map((p) => `  - ${p}`).join('\n')}`);
+  }
+
+  const { manifest } = await buildArtifact(projectDir);
+
+  return ctx.output.emitSuccess({
+    command: ctx.spec.command_path.join(' '),
+    data: { manifest },
+    humanSummary: `Built ${manifest.routes.length} routes into .notis/output/`,
+  });
+}
+
+async function appsPreviewHandler(ctx) {
+  const projectDir = resolveProjectDir(ctx.args.dir || '.');
+  const port = ctx.options.port ? Number.parseInt(ctx.options.port, 10) : 8787;
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+    throw usageError('Port must be between 1 and 65535.');
+  }
+
+  const manifest = readManifest(projectDir);
+  const defaultRoute = (manifest.routes || []).find((r) => r.default) || manifest.routes?.[0];
+  const url = `http://localhost:${port}${defaultRoute?.path || '/'}`;
+
+  ctx.output.emitSuccess({
+    command: ctx.spec.command_path.join(' '),
+    data: { port, url, routes: manifest.routes.length },
+    humanSummary: `Preview at ${url} -- press Ctrl+C to stop.`,
+  });
+
+  await startPreviewServer({ projectDir, port });
+  return EXIT_CODES.ok;
+}
+
+async function appsLinkHandler(ctx) {
+  const projectDir = resolveProjectDir(ctx.args.dir || '.');
+  const appId = ctx.args.appId;
+
+  writeLinkedState(projectDir, {
+    app_id: appId,
+    linked_at: new Date().toISOString(),
+  });
+
+  return ctx.output.emitSuccess({
+    command: ctx.spec.command_path.join(' '),
+    data: { app_id: appId, project_dir: projectDir },
+    humanSummary: `Linked to app ${appId}`,
+    hints: [
+      { command: 'notis apps deploy .', reason: 'Deploy the app' },
+    ],
+  });
+}
+
+async function appsDeployHandler(ctx) {
+  const projectDir = resolveProjectDir(ctx.args.dir || '.');
+  const appId = requireLinkedAppId(projectDir, ctx.options.appId);
+  const idempotencyKey = nextIdempotencyKey(ctx.globalOptions);
+
+  // Build if needed
+  if (!ctx.options.skipBuild) {
+    await buildArtifact(projectDir);
+  }
+
+  // Direct deploy mode: upload to Supabase storage directly
+  if (ctx.options.direct) {
+    await assertDirectDeployAccess(ctx.runtime, appId);
+    const { version } = await directDeploy(projectDir, appId);
+    return ctx.output.emitSuccess({
+      command: ctx.spec.command_path.join(' '),
+      data: { app_id: appId, version, mode: 'direct' },
+      humanSummary: `Deployed to app ${appId} (version ${version}) via direct upload`,
+      meta: { mutating: true },
+    });
+  }
+
+  // Standard deploy via backend server, with auto-fallback to direct
+  const files = collectArtifactFiles(projectDir);
+  const manifest = readManifest(projectDir);
+
+  let result;
+  try {
+    result = await runToolCommand({
+      runtime: ctx.runtime,
+      toolName: 'notis_save_app_files',
+      arguments_: {
+        app_id: appId,
+        files,
+        manifest,
+      },
+      mutating: true,
+      idempotencyKey,
+    });
+  } catch (error) {
+    if (error.code === 'conflict') {
+      throw toolConflictToError(error.details, 'Deploy conflict');
+    }
+
+    // Auto-fallback to direct deploy on network errors
+    const isNetworkError = error.code === 'network_error'
+      || error.code === 'network_timeout'
+      || (error.message && /fetch failed|ECONNREFUSED|network/i.test(error.message));
+
+    if (isNetworkError) {
+      try {
+        await assertDirectDeployAccess(ctx.runtime, appId);
+      } catch (accessError) {
+        throw usageError(
+          `Backend deploy failed (${error.message}) and direct fallback was blocked because app access ` +
+          `could not be verified (${accessError.message}).`,
+        );
+      }
+
+      try {
+        const { version } = await directDeploy(projectDir, appId);
+        return ctx.output.emitSuccess({
+          command: ctx.spec.command_path.join(' '),
+          data: { app_id: appId, version, mode: 'direct-fallback' },
+          humanSummary: `Backend unavailable -- deployed to app ${appId} (version ${version}) via direct upload`,
+          warnings: ['Backend server was unreachable. Used direct Supabase upload as fallback.'],
+          meta: { mutating: true },
+        });
+      } catch (directError) {
+        throw usageError(
+          `Backend deploy failed (${error.message}) and direct fallback also failed (${directError.message}). ` +
+          'Check server/.env for Supabase credentials or start the backend server.',
+        );
+      }
+    }
+
+    throw error;
+  }
+
+  return ctx.output.emitSuccess({
+    command: ctx.spec.command_path.join(' '),
+    data: {
+      app_id: appId,
+      version: result.payload.version,
+      idempotency_key: idempotencyKey,
+    },
+    humanSummary: `Deployed to app ${appId} (version ${result.payload.version})`,
+    meta: { mutating: true, idempotency_key: idempotencyKey },
+  });
+}
+
+async function appsDoctorHandler(ctx) {
+  const projectDir = resolveProjectDir(ctx.args.dir || '.');
+  const problems = detectProjectProblems(projectDir);
+
+  let appConfig = null;
+  try {
+    appConfig = await loadAppConfig(projectDir);
+  } catch {
+    problems.push('Failed to load notis.config.ts');
+  }
+  const warnings = detectProjectWarnings(projectDir, appConfig);
+
+  const linkedState = readLinkedState(projectDir);
+  const status = problems.length ? 'unhealthy' : warnings.length ? 'warnings' : 'healthy';
+
+  return ctx.output.emitSuccess({
+    command: ctx.spec.command_path.join(' '),
+    data: { status, problems, warnings, linked: linkedState, config: appConfig },
+    humanSummary: problems.length
+      ? `Found ${problems.length} problems:\n${problems.map((p) => `  - ${p}`).join('\n')}`
+      : warnings.length
+        ? `Healthy with ${warnings.length} warnings:\n${warnings.map((w) => `  - ${w}`).join('\n')}`
+        : `Project is healthy.${linkedState ? ` Linked to ${linkedState.app_id}.` : ' Not linked.'}`,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Command specs
+// ---------------------------------------------------------------------------
+
+export const appsCommandSpecs = [
+  {
+    command_path: ['apps', 'list'],
+    summary: 'List apps the current profile can access.',
+    when_to_use: 'Discover existing apps before linking or deploying.',
+    args_schema: { arguments: [], options: [] },
+    examples: ['notis apps list', 'notis apps list --json'],
+    mutates: false,
+    idempotent: true,
+    backend_call: { type: 'tool', name: 'notis_list_apps' },
+    handler: appsListHandler,
+  },
+  {
+    command_path: ['apps', 'init'],
+    summary: 'Scaffold a new Notis app project.',
+    when_to_use: 'Start a new Notis app. Creates a Vite + React project with @notis/sdk pre-configured.',
+    args_schema: {
+      arguments: [
+        { token: '<name>', description: 'Display name for the app.' },
+        { token: '[dir]', key: 'dir', description: 'Target directory (defaults to kebab-case of name).' },
+      ],
+      options: [],
+    },
+    examples: ['notis apps init "Mind the Flo"', 'notis apps init "My App" ./my-app'],
+    mutates: true,
+    idempotent: false,
+    require_auth: false,
+    backend_call: { type: 'local', name: 'scaffold_project' },
+    handler: appsInitHandler,
+  },
+  {
+    command_path: ['apps', 'create'],
+    summary: 'Create a new remote Notis app and optionally link a local project to it.',
+    when_to_use: 'Provision a fresh remote app before the first deploy. Pass a project directory to link it immediately.',
+    args_schema: {
+      arguments: [
+        { token: '<name>', description: 'Display name for the remote app.' },
+        { token: '[dir]', key: 'dir', description: 'Project directory to link after creation (default: do not link).' },
+      ],
+      options: [
+        { flags: '--description <text>', description: 'Optional app description.' },
+        { flags: '--icon <lucide:icon>', description: 'Optional Lucide icon, for example lucide:dices.' },
+      ],
+    },
+    examples: [
+      'notis apps create "My App"',
+      'notis apps create "My App" . --description "Internal tool" --icon lucide:layout-dashboard',
+    ],
+    mutates: true,
+    idempotent: false,
+    backend_call: { type: 'tool', name: 'notis_create_app' },
+    handler: appsCreateHandler,
+  },
+  {
+    command_path: ['apps', 'dev'],
+    summary: 'Run the Vite dev server for local development.',
+    when_to_use: 'Iterate on app UI with hot reload. SDK hooks return mock data.',
+    args_schema: {
+      arguments: [
+        { token: '[dir]', key: 'dir', description: 'Project directory (default: current dir).' },
+      ],
+      options: [],
+    },
+    examples: ['notis apps dev', 'notis apps dev ./my-app'],
+    mutates: false,
+    idempotent: true,
+    require_auth: false,
+    backend_call: { type: 'local', name: 'next_dev' },
+    handler: appsDevHandler,
+  },
+  {
+    command_path: ['apps', 'build'],
+    summary: 'Build and package the app into .notis/output/.',
+    when_to_use: 'Prepare the app for preview or deployment.',
+    args_schema: {
+      arguments: [
+        { token: '[dir]', key: 'dir', description: 'Project directory (default: current dir).' },
+      ],
+      options: [],
+    },
+    examples: ['notis apps build', 'notis apps build ./my-app'],
+    mutates: true,
+    idempotent: true,
+    require_auth: false,
+    backend_call: { type: 'local', name: 'next_build_and_package' },
+    handler: appsBuildHandler,
+  },
+  {
+    command_path: ['apps', 'preview'],
+    summary: 'Serve the built bundle locally for testing.',
+    when_to_use: 'Smoke-test the exact bundle that will be deployed. Databases use seed data.',
+    args_schema: {
+      arguments: [
+        { token: '[dir]', key: 'dir', description: 'Project directory (default: current dir).' },
+      ],
+      options: [
+        { flags: '--port <number>', description: 'Server port (default: 8787).' },
+      ],
+    },
+    examples: ['notis apps preview', 'notis apps preview --port 3000'],
+    mutates: false,
+    idempotent: true,
+    require_auth: false,
+    backend_call: { type: 'local', name: 'preview_server' },
+    handler: appsPreviewHandler,
+  },
+  {
+    command_path: ['apps', 'link'],
+    summary: 'Link a local project to a remote Notis app.',
+    when_to_use: 'Connect a local project to an existing app for deployment.',
+    args_schema: {
+      arguments: [
+        { token: '<app-id>', description: 'Remote app ID to link to.' },
+        { token: '[dir]', key: 'dir', description: 'Project directory (default: current dir).' },
+      ],
+      options: [],
+    },
+    examples: ['notis apps link abc123', 'notis apps link abc123 ./my-app'],
+    mutates: true,
+    idempotent: true,
+    require_auth: false,
+    backend_call: { type: 'local', name: 'write_link_state' },
+    handler: appsLinkHandler,
+  },
+  {
+    command_path: ['apps', 'deploy'],
+    summary: 'Build and upload the app to the linked Notis app.',
+    when_to_use:
+      'Ship the installed app to production for the linked user/team app. Requires a linked app (notis apps link). This command does not publish to the app store.',
+    args_schema: {
+      arguments: [
+        { token: '[dir]', key: 'dir', description: 'Project directory (default: current dir).' },
+      ],
+      options: [
+        { flags: '--app-id <id>', description: 'Override linked app ID.' },
+        { flags: '--skip-build', description: 'Skip the build step (use existing .notis/output/).' },
+        { flags: '--direct', description: 'Upload directly to Supabase storage, bypassing the backend server. Auto-fallback on network errors.' },
+      ],
+    },
+    examples: ['notis apps deploy', 'notis apps deploy --skip-build', 'notis apps deploy --app-id abc123', 'notis apps deploy --direct'],
+    mutates: true,
+    idempotent: true,
+    backend_call: { type: 'tool', name: 'notis_save_app_files' },
+    handler: appsDeployHandler,
+  },
+  {
+    command_path: ['apps', 'doctor'],
+    summary: 'Check project health and readiness.',
+    when_to_use: 'Diagnose issues with a Notis app project.',
+    args_schema: {
+      arguments: [
+        { token: '[dir]', key: 'dir', description: 'Project directory (default: current dir).' },
+      ],
+      options: [],
+    },
+    examples: ['notis apps doctor', 'notis apps doctor ./my-app'],
+    mutates: false,
+    idempotent: true,
+    require_auth: false,
+    backend_call: { type: 'local', name: 'project_health_check' },
+    handler: appsDoctorHandler,
+  },
+];

package/src/command-specs/auth.js

@@ -0,0 +1,178 @@
+import { CliError, EXIT_CODES } from '../runtime/errors.js';
+import {
+  clearStoredJwt,
+  probeAuth,
+  promptForJwt,
+  updateStoredProfile,
+} from './helpers.js';
+
+async function authLoginHandler(ctx) {
+  let jwt = ctx.options.jwt || process.env.NOTIS_JWT;
+  if (!jwt) {
+    if (ctx.runtime.nonInteractive) {
+      throw new CliError({
+        code: 'auth_missing',
+        message: `No JWT configured for profile ${ctx.runtime.profileName}`,
+        exitCode: EXIT_CODES.auth,
+        hints: [
+          {
+            command: 'notis auth login --jwt <token>',
+            reason: 'Provide a token explicitly in non-interactive mode',
+          },
+        ],
+      });
+    }
+    jwt = await promptForJwt();
+  }
+
+  updateStoredProfile({
+    profileName: ctx.runtime.profileName,
+    jwt,
+    apiBase: ctx.globalOptions.apiBase,
+    setCurrent: true,
+  });
+
+  return ctx.output.emitSuccess({
+    command: ctx.spec.command_path.join(' '),
+    data: {
+      profile: ctx.runtime.profileName,
+      api_base: ctx.globalOptions.apiBase || ctx.runtime.apiBase,
+    },
+    humanSummary: `Stored credentials for profile ${ctx.runtime.profileName}`,
+    hints: [
+      { command: 'notis whoami', reason: 'Verify your identity and available toolkits' },
+    ],
+    meta: { mutating: true },
+  });
+}
+
+async function authLogoutHandler(ctx) {
+  clearStoredJwt(ctx.runtime.profileName);
+  return ctx.output.emitSuccess({
+    command: ctx.spec.command_path.join(' '),
+    data: { profile: ctx.runtime.profileName },
+    humanSummary: `Removed stored JWT for profile ${ctx.runtime.profileName}`,
+    meta: { mutating: true },
+  });
+}
+
+async function authStatusHandler(ctx) {
+  const hasJwt = Boolean(ctx.runtime.jwt);
+  let verified = false;
+  let toolkits = [];
+  if (hasJwt && ctx.options.verify) {
+    const payload = await probeAuth(ctx.runtime);
+    toolkits = payload.toolkits || [];
+    verified = true;
+  }
+
+  return ctx.output.emitSuccess({
+    command: ctx.spec.command_path.join(' '),
+    data: {
+      profile: ctx.runtime.profileName,
+      api_base: ctx.runtime.apiBase,
+      has_jwt: hasJwt,
+      verified,
+      toolkits,
+    },
+    humanSummary: hasJwt
+      ? `Profile ${ctx.runtime.profileName} is configured`
+      : `Profile ${ctx.runtime.profileName} is missing a JWT`,
+    hints: hasJwt
+      ? []
+      : [{ command: 'notis auth login --jwt <token>', reason: 'Configure credentials for this profile' }],
+    meta: { mutating: false },
+  });
+}
+
+export const authCommandSpecs = [
+  {
+    command_path: ['auth', 'login'],
+    summary: 'Store credentials for a named CLI profile.',
+    when_to_use: 'Use this before authenticated commands, especially in fresh environments or CI profiles.',
+    args_schema: {
+      arguments: [],
+      options: [
+        { flags: '--jwt <token>', description: 'JWT token to store for the profile.' },
+      ],
+    },
+    examples: ['notis auth login --jwt <token>', 'notis auth login --profile staging --api-base http://localhost:3001'],
+    output_schema: 'Returns the active profile name and API base.',
+    mutates: true,
+    idempotent: true,
+    require_auth: false,
+    related_commands: ['notis auth status --verify', 'notis auth logout'],
+    backend_call: { type: 'local' },
+    handler: authLoginHandler,
+  },
+  {
+    command_path: ['auth', 'logout'],
+    summary: 'Remove the stored JWT for the active profile.',
+    when_to_use: 'Use this to clear local credentials without touching other profiles.',
+    args_schema: { arguments: [], options: [] },
+    examples: ['notis auth logout', 'notis auth logout --profile staging'],
+    output_schema: 'Returns the profile that was updated.',
+    mutates: true,
+    idempotent: true,
+    require_auth: false,
+    related_commands: ['notis auth login --jwt <token>', 'notis auth status'],
+    backend_call: { type: 'local' },
+    handler: authLogoutHandler,
+  },
+  {
+    command_path: ['auth', 'status'],
+    summary: 'Inspect local auth configuration and optionally verify it against the API.',
+    when_to_use: 'Use this before automating commands to confirm the active profile and token health.',
+    args_schema: {
+      arguments: [],
+      options: [
+        { flags: '--verify', description: 'Perform a live authenticated roundtrip to the API.' },
+      ],
+    },
+    examples: ['notis auth status', 'notis auth status --verify --json'],
+    output_schema: 'Returns profile, api_base, local auth presence, and optional verification data.',
+    mutates: false,
+    idempotent: true,
+    require_auth: false,
+    related_commands: ['notis doctor', 'notis auth login --jwt <token>'],
+    backend_call: { type: 'notis_find_toolkits' },
+    handler: authStatusHandler,
+  },
+  {
+    command_path: ['login'],
+    display_name: 'login',
+    summary: 'Deprecated alias for `notis auth login`.',
+    when_to_use: 'Use only for backward compatibility with older scripts.',
+    args_schema: {
+      arguments: [],
+      options: [
+        { flags: '--jwt <token>', description: 'JWT token to store for the profile.' },
+      ],
+    },
+    examples: ['notis login --jwt <token>'],
+    output_schema: 'Same output as `notis auth login`.',
+    mutates: true,
+    idempotent: true,
+    require_auth: false,
+    related_commands: ['notis auth login --jwt <token>'],
+    backend_call: { type: 'local', alias_for: 'auth login' },
+    deprecated_alias_for: 'notis auth login',
+    handler: authLoginHandler,
+  },
+  {
+    command_path: ['logout'],
+    display_name: 'logout',
+    summary: 'Deprecated alias for `notis auth logout`.',
+    when_to_use: 'Use only for backward compatibility with older scripts.',
+    args_schema: { arguments: [], options: [] },
+    examples: ['notis logout'],
+    output_schema: 'Same output as `notis auth logout`.',
+    mutates: true,
+    idempotent: true,
+    require_auth: false,
+    related_commands: ['notis auth logout'],
+    backend_call: { type: 'local', alias_for: 'auth logout' },
+    deprecated_alias_for: 'notis auth logout',
+    handler: authLogoutHandler,
+  },
+];