@notis_ai/cli 0.2.0 → 0.2.2

package/src/runtime/cli-mode.generated.js

@@ -0,0 +1,4 @@
+// Auto-generated on npm publish.
+// Committed value is 'local' so in-repo runs target localhost.
+// scripts/set-cli-mode.js rewrites this to 'published' before the npm publish step.
+export const MODE = 'local';

package/src/runtime/cli-mode.js

@@ -0,0 +1,29 @@
+/**
+ * CLI mode detection for `notis apps dev`.
+ *
+ * The repo-local CLI package targets localhost; the published npm CLI package
+ * targets app.notis.ai. Mode is baked into `cli-mode.generated.js` at publish
+ * time — no runtime flag is needed (and none is exposed to end users, so a
+ * crafted env var can't trick a published CLI into opening a localhost portal
+ * that isn't running).
+ *
+ * The `NOTIS_CLI_MODE` env var is honored for internal testing only.
+ */
+
+import { MODE as BAKED_MODE } from './cli-mode.generated.js';
+
+export function getCliMode() {
+  const override = process.env.NOTIS_CLI_MODE;
+  if (override === 'local' || override === 'published') {
+    return override;
+  }
+  return BAKED_MODE === 'published' ? 'published' : 'local';
+}
+
+export function getDefaultApiBase(mode = getCliMode()) {
+  return mode === 'local' ? 'http://localhost:3001' : 'https://api.notis.ai';
+}
+
+export function getDefaultPortalOrigin(mode = getCliMode()) {
+  return mode === 'local' ? 'http://localhost:3000' : 'https://app.notis.ai';
+}

package/src/runtime/output.js

@@ -95,6 +95,7 @@ export class OutputManager {
   }
 
   emitSuccess({
+    ok = true,
     command,
     data = {},
     humanSummary,
@@ -105,7 +106,7 @@ export class OutputManager {
     renderHuman,
   }) {
     const envelope = {
-      ok: true,
+      ok: Boolean(ok),
       command,
       data,
       human_summary: humanSummary,
@@ -177,4 +178,3 @@ export class OutputManager {
 }
 
 export { formatTable };
-

package/src/runtime/ports.js

@@ -0,0 +1,15 @@
+import { createServer } from 'node:http';
+
+export async function getAvailablePort() {
+  const server = createServer();
+  await new Promise((resolvePromise, rejectPromise) => {
+    server.once('error', rejectPromise);
+    server.listen(0, '127.0.0.1', () => {
+      server.off('error', rejectPromise);
+      resolvePromise();
+    });
+  });
+  const { port } = server.address();
+  await new Promise((resolvePromise) => server.close(resolvePromise));
+  return port;
+}

package/src/runtime/profiles.js

@@ -12,6 +12,7 @@ const LOCAL_DEFAULT_API_BASES = new Set([
   'http://localhost:3001',
   'http://127.0.0.1:3001',
 ]);
+const LOCAL_API_HOSTS = new Set(['localhost', '127.0.0.1', '::1']);
 
 function clone(value) {
   return JSON.parse(JSON.stringify(value));
@@ -29,6 +30,13 @@ export function normalizeConfig(rawConfig = {}) {
       profiles[name] = {
         jwt: typeof profile.jwt === 'string' ? profile.jwt : undefined,
         api_base: typeof profile.api_base === 'string' ? profile.api_base : undefined,
+        auth_mode: profile.auth_mode === 'dev_portal' ? profile.auth_mode : undefined,
+        refresh_token:
+          typeof profile.refresh_token === 'string' ? profile.refresh_token : undefined,
+        access_expires_at:
+          typeof profile.access_expires_at === 'number' ? profile.access_expires_at : undefined,
+        refresh_expires_at:
+          typeof profile.refresh_expires_at === 'number' ? profile.refresh_expires_at : undefined,
       };
     }
 
@@ -51,6 +59,12 @@ export function normalizeConfig(rawConfig = {}) {
       [DEFAULT_PROFILE]: {
         jwt: typeof raw.jwt === 'string' ? raw.jwt : undefined,
         api_base: typeof raw.api_base === 'string' ? raw.api_base : undefined,
+        auth_mode: raw.auth_mode === 'dev_portal' ? raw.auth_mode : undefined,
+        refresh_token: typeof raw.refresh_token === 'string' ? raw.refresh_token : undefined,
+        access_expires_at:
+          typeof raw.access_expires_at === 'number' ? raw.access_expires_at : undefined,
+        refresh_expires_at:
+          typeof raw.refresh_expires_at === 'number' ? raw.refresh_expires_at : undefined,
       },
     },
   };
@@ -90,6 +104,18 @@ export function ensureProfile(config, profileName) {
   return normalized;
 }
 
+function isLocalApiBase(value) {
+  if (typeof value !== 'string' || !value) {
+    return false;
+  }
+  try {
+    const parsed = new URL(value);
+    return ['http:', 'https:'].includes(parsed.protocol) && LOCAL_API_HOSTS.has(parsed.hostname);
+  } catch {
+    return false;
+  }
+}
+
 export function getApiBase(config, profileName, override) {
   if (override) {
     return override;
@@ -103,12 +129,12 @@ export function getApiBase(config, profileName, override) {
   const conductorPort = Number.parseInt(process.env.CONDUCTOR_PORT || '', 10);
 
   // Conductor assigns dynamic local ports. When a workspace is running under
-  // Conductor, treat the legacy localhost:3001 profile value as stale and
-  // transparently retarget the CLI at the active backend port.
+  // Conductor, treat saved localhost profile values as stale and transparently
+  // retarget the CLI at the active backend port.
   if (
     Number.isInteger(conductorPort) &&
     conductorPort > 0 &&
-    (!profileApiBase || LOCAL_DEFAULT_API_BASES.has(profileApiBase))
+    (!profileApiBase || LOCAL_DEFAULT_API_BASES.has(profileApiBase) || isLocalApiBase(profileApiBase))
   ) {
     return `http://localhost:${conductorPort + 1}`;
   }
@@ -166,6 +192,7 @@ export function resolveRuntimeProfile(globalOptions = {}, { requireAuth = true }
   const profileName = getCurrentProfileName(config, globalOptions.profile);
   const apiBase = getApiBase(config, profileName, globalOptions.apiBase);
   const jwt = getJwt(config, profileName);
+  const profile = getProfile(config, profileName);
   const agentMode = isAgentMode(globalOptions);
   const nonInteractive = isNonInteractive(globalOptions);
   const outputMode = resolveOutputMode(globalOptions);
@@ -178,8 +205,8 @@ export function resolveRuntimeProfile(globalOptions = {}, { requireAuth = true }
       exitCode: EXIT_CODES.auth,
       hints: [
         {
-          command: 'notis auth login --jwt <token>',
-          reason: 'Configure a token for non-interactive use',
+          command: 'Open the Notis desktop app and sign in',
+          reason: 'Set NOTIS_JWT or sign in through the Notis desktop app',
         },
       ],
     });
@@ -190,6 +217,10 @@ export function resolveRuntimeProfile(globalOptions = {}, { requireAuth = true }
     profileName,
     apiBase,
     jwt,
+    authMode: profile.auth_mode,
+    refreshToken: profile.refresh_token,
+    accessExpiresAt: profile.access_expires_at,
+    refreshExpiresAt: profile.refresh_expires_at,
     agentMode,
     nonInteractive,
     outputMode,

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',
@@ -44,8 +51,8 @@ function normalizeBackendError(status, payload) {
       exitCode: EXIT_CODES.auth,
       hints: [
         {
-          command: 'notis auth login --jwt <token>',
-          reason: 'Refresh the stored JWT for this profile',
+          command: 'Open the Notis desktop app and sign in',
+          reason: 'Open the Notis desktop app to refresh CLI auth, or set NOTIS_JWT',
         },
       ],
       details: payload || {},
@@ -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,211 @@
+<!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,
+        context: descriptor.context || {},
+        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 };
+        },
+        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 || {} });
+        },
+        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/globals.css

@@ -0,0 +1,3 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;

package/template/app/layout.tsx

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

package/template/app/page.tsx

@@ -0,0 +1,90 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+import { useNotis, useTool } from '@notis/sdk';
+import { Badge } from '@/components/ui/badge';
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
+
+type ItemDocument = {
+  id?: string;
+  document_id?: string;
+  title?: string;
+  properties?: Record<string, unknown>;
+};
+
+type QueryItemsArgs = {
+  database_slug: string;
+  query: {
+    page_size?: number;
+  };
+};
+
+type QueryItemsResult = {
+  documents?: ItemDocument[];
+};
+
+export default function HomePage() {
+  const { app, ready } = useNotis();
+  const queryItems = useTool<QueryItemsArgs, QueryItemsResult>('notis-default-query');
+  const [documents, setDocuments] = useState<ItemDocument[]>([]);
+
+  useEffect(() => {
+    let cancelled = false;
+    queryItems
+      .call({ database_slug: 'items', query: { page_size: 25 } })
+      .then((result) => {
+        if (!cancelled) setDocuments(result.documents || []);
+      })
+      .catch(() => {
+        if (!cancelled) setDocuments([]);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [queryItems.call]);
+
+  return (
+    <main className="notis-app-shell space-y-6">
+      <Card>
+        <CardHeader className="space-y-3">
+          <Badge variant="secondary" className="w-fit">Installed app</Badge>
+          <div className="space-y-2">
+            <CardTitle>{ready ? app?.name : 'Loading...'}</CardTitle>
+            <CardDescription>
+              {ready ? app?.description : 'Loading app metadata...'}
+            </CardDescription>
+          </div>
+        </CardHeader>
+      </Card>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>Items</CardTitle>
+          <CardDescription>Use shadcn surfaces and portal tokens so the app feels native inside Notis.</CardDescription>
+        </CardHeader>
+        <CardContent>
+          {queryItems.loading ? (
+            <p className="text-sm text-muted-foreground">Loading...</p>
+          ) : documents.length === 0 ? (
+            <div className="rounded-xl border border-dashed border-border px-4 py-10 text-center text-sm text-muted-foreground">
+              No items yet. Deploy the app and create some.
+            </div>
+          ) : (
+            <div className="space-y-3">
+              {documents.map((doc) => (
+                <div key={doc.id || doc.document_id || doc.title} className="rounded-xl border border-border bg-background px-4 py-3">
+                  <div className="flex items-center justify-between gap-3">
+                    <p className="font-medium">{doc.title || 'Untitled'}</p>
+                    {doc.properties?.status ? (
+                      <Badge variant="outline">{String(doc.properties.status)}</Badge>
+                    ) : null}
+                  </div>
+                </div>
+              ))}
+            </div>
+          )}
+        </CardContent>
+      </Card>
+    </main>
+  );
+}