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

package/src/runtime/transport.js

@@ -1,5 +1,12 @@
 import { randomUUID } from 'node:crypto';
 import { CliError, EXIT_CODES } from './errors.js';
+import {
+  DEFAULT_PROFILE,
+  ensureProfile,
+  getProfile,
+  loadConfig,
+  saveConfig,
+} from './profiles.js';
 
 const META_TOOL_NAMES = new Set([
   'notis_find_toolkits',
@@ -97,6 +104,94 @@ function normalizeBackendError(status, payload) {
   });
 }
 
+function shouldAttemptDevPortalRefresh(runtime, { force = false } = {}) {
+  if (runtime.authMode !== 'dev_portal' || !runtime.refreshToken || !runtime.apiBase) {
+    return false;
+  }
+
+  if (force) {
+    return true;
+  }
+
+  if (typeof runtime.accessExpiresAt !== 'number' || runtime.accessExpiresAt <= 0) {
+    return false;
+  }
+
+  const thresholdSeconds = 60;
+  return runtime.accessExpiresAt - Math.floor(Date.now() / 1000) <= thresholdSeconds;
+}
+
+function persistDevPortalRuntimeAuth(runtime, session) {
+  const config = ensureProfile(loadConfig(), runtime.profileName || DEFAULT_PROFILE);
+  const profileName = runtime.profileName || DEFAULT_PROFILE;
+  config.current_profile = profileName;
+  config.profiles[profileName] = {
+    ...config.profiles[profileName],
+    jwt: session.access_token,
+    api_base: runtime.apiBase,
+    auth_mode: 'dev_portal',
+    refresh_token: session.refresh_token,
+    access_expires_at: session.access_expires_at,
+    refresh_expires_at: session.refresh_expires_at,
+  };
+  saveConfig(config);
+
+  runtime.jwt = session.access_token;
+  runtime.authMode = 'dev_portal';
+  runtime.refreshToken = session.refresh_token;
+  runtime.accessExpiresAt = session.access_expires_at;
+  runtime.refreshExpiresAt = session.refresh_expires_at;
+}
+
+function reloadJwtFromConfig(runtime) {
+  const profileName = runtime.profileName || DEFAULT_PROFILE;
+  let profile;
+  try {
+    profile = getProfile(loadConfig(), profileName);
+  } catch {
+    return false;
+  }
+  const nextJwt = typeof profile.jwt === 'string' && profile.jwt ? profile.jwt : null;
+  if (!nextJwt || nextJwt === runtime.jwt) {
+    return false;
+  }
+  runtime.jwt = nextJwt;
+  runtime.authMode = profile.auth_mode;
+  runtime.refreshToken = profile.refresh_token;
+  runtime.accessExpiresAt = profile.access_expires_at;
+  runtime.refreshExpiresAt = profile.refresh_expires_at;
+  return true;
+}
+
+async function maybeRefreshDevPortalAuth(runtime, { force = false } = {}) {
+  if (!shouldAttemptDevPortalRefresh(runtime, { force })) {
+    return false;
+  }
+
+  const response = await fetch(`${runtime.apiBase}/portal_auth/dev-refresh`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'X-Notis-CLI-Version': runtime.cliVersion,
+    },
+    body: JSON.stringify({ refresh_token: runtime.refreshToken }),
+  });
+
+  let payload = null;
+  try {
+    payload = await response.json();
+  } catch {
+    payload = null;
+  }
+
+  if (!response.ok || !payload?.session?.access_token || !payload?.session?.refresh_token) {
+    throw normalizeBackendError(response.status, payload);
+  }
+
+  persistDevPortalRuntimeAuth(runtime, payload.session);
+  return true;
+}
+
 export async function httpRequest({
   runtime,
   method = 'POST',
@@ -104,9 +199,16 @@ export async function httpRequest({
   body,
   requireAuth = true,
 }) {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), runtime.timeoutMs);
+  await maybeRefreshDevPortalAuth(runtime);
+
+  let controller = new AbortController();
+  let timeout = setTimeout(() => controller.abort(), runtime.timeoutMs);
   const requestId = `req_${randomUUID().replace(/-/g, '')}`;
+  const resetTimeout = () => {
+    clearTimeout(timeout);
+    controller = new AbortController();
+    timeout = setTimeout(() => controller.abort(), runtime.timeoutMs);
+  };
 
   const headers = {
     'Content-Type': 'application/json',
@@ -119,13 +221,12 @@ export async function httpRequest({
   }
 
   try {
-    const response = await fetch(`${runtime.apiBase}${path}`, {
+    let response = await fetch(`${runtime.apiBase}${path}`, {
       method,
       headers,
       body: body ? JSON.stringify(body) : undefined,
       signal: controller.signal,
     });
-    clearTimeout(timeout);
 
     let payload = null;
     try {
@@ -134,6 +235,30 @@ export async function httpRequest({
       payload = null;
     }
 
+    if (response.status === 401) {
+      const refreshed = (await maybeRefreshDevPortalAuth(runtime, { force: true }))
+        || reloadJwtFromConfig(runtime);
+      if (refreshed) {
+        if (requireAuth && runtime.jwt) {
+          headers.Authorization = `Bearer ${runtime.jwt}`;
+        }
+        resetTimeout();
+        response = await fetch(`${runtime.apiBase}${path}`, {
+          method,
+          headers,
+          body: body ? JSON.stringify(body) : undefined,
+          signal: controller.signal,
+        });
+        try {
+          payload = await response.json();
+        } catch {
+          payload = null;
+        }
+      }
+    }
+
+    clearTimeout(timeout);
+
     if (!response.ok) {
       throw normalizeBackendError(response.status, payload);
     }

package/template/.harness/index.html.tmpl

@@ -0,0 +1,260 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Notis App Harness</title>
+  <link rel="stylesheet" href="./bundle/app.css">
+  <script type="importmap">
+  {
+    "imports": {
+      "react": "https://esm.sh/react@{{REACT_VERSION}}",
+      "react-dom": "https://esm.sh/react-dom@{{REACT_VERSION}}",
+      "react/jsx-runtime": "https://esm.sh/react@{{REACT_VERSION}}/jsx-runtime",
+      "react-dom/client": "https://esm.sh/react-dom@{{REACT_VERSION}}/client"
+    }
+  }
+  </script>
+  <style>
+    body { margin: 0; font-family: system-ui, sans-serif; }
+    #harness-status { position: fixed; top: 0; left: 0; right: 0; padding: 4px 8px; font-size: 11px; background: #111; color: #0f0; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; z-index: 9999; }
+    #root { padding-top: 24px; min-height: 100vh; }
+  </style>
+</head>
+<body>
+  <div id="harness-status">harness: booting</div>
+  <div id="root"></div>
+  <script type="module">
+    const routeExport = {{ROUTE_EXPORT}};
+    const descriptor = {{RUNTIME_DESCRIPTOR}};
+    const mode = {{MODE}};
+    const apiBase = {{API_BASE}};
+    const jwt = {{JWT}};
+    const status = document.getElementById('harness-status');
+    const setStatus = (msg, color = '#0f0') => {
+      status.textContent = `harness: ${msg}`;
+      status.style.color = color;
+    };
+
+    window.__harness = {
+      errors: [],
+      runtimeCalls: [],
+      renderStarted: false,
+      mounted: false,
+      mode,
+      route: descriptor.route && descriptor.route.slug,
+    };
+
+    window.addEventListener('error', (event) => {
+      window.__harness.errors.push({
+        type: 'window.error',
+        message: event.message,
+        stack: event.error && event.error.stack,
+      });
+    });
+    window.addEventListener('unhandledrejection', (event) => {
+      window.__harness.errors.push({
+        type: 'unhandledrejection',
+        reason: String((event.reason && event.reason.stack) || event.reason),
+      });
+    });
+
+    function record(op, args) {
+      window.__harness.runtimeCalls.push({ op, args });
+    }
+
+    async function readJsonOrSnippet(response) {
+      const text = await response.text().catch(() => '');
+      if (!text) return { payload: null, snippet: null };
+      try {
+        return { payload: JSON.parse(text), snippet: null };
+      } catch {
+        const trimmed = text.trim();
+        return { payload: null, snippet: trimmed.length > 120 ? `${trimmed.slice(0, 120)}...` : trimmed };
+      }
+    }
+
+    async function runtimeQuery(body) {
+      if (!apiBase || !jwt || !descriptor.app || !descriptor.app.id) {
+        throw new Error('live harness mode requires apiBase, jwt, and app id');
+      }
+      const response = await fetch(`${String(apiBase).replace(/\/$/, '')}/portal_views/runtime_query`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${jwt}`,
+        },
+        body: JSON.stringify({
+          app_id: descriptor.app.id,
+          route_slug: descriptor.route && descriptor.route.slug,
+          ...body,
+        }),
+      });
+      const { payload, snippet } = await readJsonOrSnippet(response);
+      if (!response.ok) {
+        const message = (payload && (payload.error || payload.message)) || snippet || `status ${response.status}`;
+        throw new Error(`Runtime request failed: ${message}`);
+      }
+      if (!payload) {
+        throw new Error(snippet ? `Runtime response was not JSON: ${snippet}` : 'Runtime response was empty');
+      }
+      if (payload.status === 'error' || payload.error) {
+        throw new Error(payload.message || payload.error || 'Runtime request failed');
+      }
+      return payload;
+    }
+
+    function stubRuntime() {
+      return {
+        app: descriptor.app,
+        route: descriptor.route,
+        databases: descriptor.databases || [],
+        context: descriptor.context || { collectionItem: null },
+        navigate: (args) => record('navigate', args),
+        registerTopBarSearch: () => {},
+        setTopBarSearchValue: () => {},
+        setTopBarSearchLoading: () => {},
+        listTools: async () => {
+          record('listTools', {});
+          return descriptor.tools || [];
+        },
+        callTool: async (name, args) => {
+          record('callTool', { name, arguments: args || {} });
+          return { ok: true, result: null };
+        },
+        queryDatabase: async (args) => {
+          record('queryDatabase', args || {});
+          return { documents: [], next_offset: null };
+        },
+        getDocument: async (args) => {
+          record('getDocument', args || {});
+          return null;
+        },
+        upsertDocument: async (args) => {
+          record('upsertDocument', args || {});
+          return {
+            status: 'ok',
+            document: {
+              id: (args && args.documentId) || 'mock-doc',
+              title: (args && args.title) || '',
+              properties: (args && args.properties) || {},
+              databaseSlug: args && args.databaseSlug,
+            },
+          };
+        },
+        listCollectionItems: async (args) => {
+          record('listCollectionItems', args || {});
+          return { items: [] };
+        },
+        listCollectionTree: async (args) => {
+          record('listCollectionTree', args || {});
+          return { items: [] };
+        },
+        request: async (path, options) => {
+          record('request', { path, options });
+          return null;
+        },
+      };
+    }
+
+    function liveRuntime() {
+      return {
+        ...stubRuntime(),
+        listTools: async () => {
+          record('listTools', {});
+          const result = await runtimeQuery({ method: 'tools/list' });
+          return result.tools || [];
+        },
+        callTool: async (name, args) => {
+          record('callTool', { name, arguments: args || {} });
+          return runtimeQuery({ method: 'tools/call', name, arguments: args || {} });
+        },
+        queryDatabase: async (args) => {
+          record('queryDatabase', args || {});
+          const result = await runtimeQuery({ method: 'tools/call', name: 'notis_query_database', arguments: args || {} });
+          return result.result || result;
+        },
+        getDocument: async (args) => {
+          record('getDocument', args || {});
+          const result = await runtimeQuery({ method: 'tools/call', name: 'notis_get_document', arguments: args || {} });
+          return result.result || result;
+        },
+        upsertDocument: async (args) => {
+          record('upsertDocument', args || {});
+          const result = await runtimeQuery({ method: 'tools/call', name: 'notis_upsert_document', arguments: args || {} });
+          return result.result || result;
+        },
+        listCollectionItems: async (args) => {
+          record('listCollectionItems', args || {});
+          const result = await runtimeQuery({ method: 'tools/call', name: 'notis_list_collection_items', arguments: args || {} });
+          return result.result || result;
+        },
+        request: async (path, options) => {
+          record('request', { path, options });
+          const response = await fetch(`${String(apiBase).replace(/\/$/, '')}${path}`, {
+            method: (options && options.method) || 'GET',
+            headers: {
+              Authorization: `Bearer ${jwt}`,
+              ...((options && options.body) ? { 'Content-Type': 'application/json' } : {}),
+              ...((options && options.headers) || {}),
+            },
+            body: options && options.body ? JSON.stringify(options.body) : undefined,
+          });
+          const { payload, snippet } = await readJsonOrSnippet(response);
+          if (!response.ok) {
+            throw new Error((payload && (payload.error || payload.message)) || snippet || `Request failed with status ${response.status}`);
+          }
+          return payload;
+        },
+      };
+    }
+
+    try {
+      setStatus('loading react');
+      const React = await import('react');
+      const { createRoot } = await import('react-dom/client');
+
+      setStatus('loading bundle');
+      const bundle = await import('./bundle/app.js');
+
+      setStatus('binding runtime context');
+      const RuntimeContext = globalThis[Symbol.for('notis.sdk.runtime_context')];
+      if (!RuntimeContext) {
+        throw new Error('runtime context Symbol not initialized by bundle');
+      }
+
+      const Page = bundle[routeExport];
+      if (!Page) {
+        throw new Error(`bundle has no ${routeExport} export`);
+      }
+      const Shell = bundle.__AppShell;
+      const runtime = mode === 'live' ? liveRuntime() : stubRuntime();
+      const Root = () =>
+        React.createElement(
+          RuntimeContext.Provider,
+          { value: runtime },
+          Shell
+            ? React.createElement(Shell, null, React.createElement(Page, null))
+            : React.createElement(Page, null),
+        );
+
+      setStatus('mounting');
+      window.__harness.renderStarted = true;
+      createRoot(document.getElementById('root')).render(React.createElement(Root));
+
+      requestAnimationFrame(() => requestAnimationFrame(() => {
+        window.__harness.mounted = true;
+        const errors = window.__harness.errors.length;
+        const calls = window.__harness.runtimeCalls.length;
+        setStatus(`mounted (errors=${errors}, runtimeCalls=${calls})`, errors ? '#f55' : '#0f0');
+      }));
+    } catch (error) {
+      window.__harness.errors.push({
+        type: 'boot',
+        message: error && error.message ? error.message : String(error),
+        stack: error && error.stack,
+      });
+      setStatus(`boot failed: ${error && error.message ? error.message : String(error)}`, '#f55');
+    }
+  </script>
+</body>
+</html>

package/template/app/layout.tsx

@@ -1,7 +1,6 @@
-import { NotisProvider } from '@notis/sdk';
 import '@notis/sdk/styles.css';
 import './globals.css';
 
 export default function AppShell({ children }: { children: React.ReactNode }) {
-  return <NotisProvider>{children}</NotisProvider>;
+  return children;
 }

package/template/notis.config.ts

@@ -8,7 +8,22 @@ export default defineNotisApp({
   databases: ['items'],
 
   routes: [
-    { path: '/', name: 'Home', icon: 'lucide:home', default: true },
+    { path: '/', slug: 'home', name: 'Home', icon: 'lucide:home', default: true },
+    // Example collection tree route:
+    // {
+    //   path: '/notes',
+    //   slug: 'notes',
+    //   name: 'Notes',
+    //   collection: {
+    //     database: 'notes',
+    //     titleProperty: 'Name',
+    //     parentProperty: 'Parent',
+    //     sidebar: {
+    //       mode: 'tree',
+    //       allowCreate: true,
+    //     },
+    //   },
+    // },
   ],
 
   tools: [

package/template/package.json

@@ -5,8 +5,7 @@
   "type": "module",
   "scripts": {
     "dev": "vite",
-    "build": "vite build",
-    "preview": "vite preview"
+    "build": "vite build"
   },
   "dependencies": {
     "@notis/sdk": "file:./packages/notis-sdk",