@notis_ai/cli 0.2.0-beta.35.1 → 0.2.0-beta.41.1

package/src/runtime/transport.js

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { createReadStream } from 'node:fs';
 import { CliError, EXIT_CODES } from './errors.js';
 import {
   DEFAULT_PROFILE,
@@ -35,6 +36,73 @@ function canonicalizeToolName(toolName) {
   return toolName;
 }
 
+function escapeMultipartHeaderValue(value) {
+  return String(value ?? '')
+    .replace(/"/g, '%22')
+    .replace(/\r/g, '%0D')
+    .replace(/\n/g, '%0A');
+}
+
+function multipartTextPart(boundary, name, value) {
+  return [
+    `--${boundary}`,
+    `Content-Disposition: form-data; name="${escapeMultipartHeaderValue(name)}"`,
+    '',
+    value,
+    '',
+  ].join('\r\n');
+}
+
+function multipartFileHeader(boundary, binding) {
+  const filename = escapeMultipartHeaderValue(binding.basename || binding.field_name);
+  return [
+    `--${boundary}`,
+    `Content-Disposition: form-data; name="${escapeMultipartHeaderValue(binding.field_name)}"; filename="${filename}"`,
+    `Content-Type: ${binding.contentType || 'application/octet-stream'}`,
+    '',
+    '',
+  ].join('\r\n');
+}
+
+async function* multipartFileBody(boundary, payload, bindingMetadata, fileBindings) {
+  yield Buffer.from(multipartTextPart(boundary, 'payload', JSON.stringify(payload)));
+  yield Buffer.from(multipartTextPart(boundary, 'file_bindings', JSON.stringify(bindingMetadata)));
+  for (const binding of fileBindings) {
+    yield Buffer.from(multipartFileHeader(boundary, binding));
+    for await (const chunk of createReadStream(binding.localPath)) {
+      yield chunk;
+    }
+    yield Buffer.from('\r\n');
+  }
+  yield Buffer.from(`--${boundary}--\r\n`);
+}
+
+function createMultipartFileUpload(payload, bindingMetadata, fileBindings) {
+  const boundary = `----notis-cli-${randomUUID().replace(/-/g, '')}`;
+  const textParts = [
+    multipartTextPart(boundary, 'payload', JSON.stringify(payload)),
+    multipartTextPart(boundary, 'file_bindings', JSON.stringify(bindingMetadata)),
+  ];
+  const fileHeaderParts = fileBindings.map((binding) => multipartFileHeader(boundary, binding));
+  const closingPart = `--${boundary}--\r\n`;
+  const contentLength = [
+    ...textParts,
+    ...fileHeaderParts,
+    ...fileBindings.map(() => '\r\n'),
+    closingPart,
+  ].reduce((total, part) => total + Buffer.byteLength(part), 0)
+    + fileBindings.reduce((total, binding) => total + binding.size, 0);
+
+  return {
+    body: multipartFileBody(boundary, payload, bindingMetadata, fileBindings),
+    headers: {
+      'Content-Type': `multipart/form-data; boundary=${boundary}`,
+      'Content-Length': String(contentLength),
+    },
+    duplex: 'half',
+  };
+}
+
 function normalizeBackendError(status, payload) {
   const backendError = payload?.error;
   const message =
@@ -197,6 +265,7 @@ export async function httpRequest({
   method = 'POST',
   path,
   body,
+  multipart = false,
   requireAuth = true,
 }) {
   await maybeRefreshDevPortalAuth(runtime);
@@ -211,21 +280,41 @@ export async function httpRequest({
   };
 
   const headers = {
-    'Content-Type': 'application/json',
     'X-Notis-CLI-Version': runtime.cliVersion,
     'X-Notis-Request-Id': requestId,
   };
+  if (!multipart) {
+    headers['Content-Type'] = 'application/json';
+  }
 
   if (requireAuth && runtime.jwt) {
     headers.Authorization = `Bearer ${runtime.jwt}`;
   }
 
+  const resolveBody = () => {
+    if (!multipart) {
+      return {
+        body: body ? JSON.stringify(body) : undefined,
+        headers: {},
+      };
+    }
+    if (typeof body === 'function') {
+      return body();
+    }
+    return {
+      body,
+      headers: {},
+    };
+  };
+
   try {
+    let requestBody = resolveBody();
     let response = await fetch(`${runtime.apiBase}${path}`, {
       method,
-      headers,
-      body: body ? JSON.stringify(body) : undefined,
+      headers: { ...headers, ...requestBody.headers },
+      body: requestBody.body,
       signal: controller.signal,
+      ...(requestBody.duplex ? { duplex: requestBody.duplex } : {}),
     });
 
     let payload = null;
@@ -243,11 +332,13 @@ export async function httpRequest({
           headers.Authorization = `Bearer ${runtime.jwt}`;
         }
         resetTimeout();
+        requestBody = resolveBody();
         response = await fetch(`${runtime.apiBase}${path}`, {
           method,
-          headers,
-          body: body ? JSON.stringify(body) : undefined,
+          headers: { ...headers, ...requestBody.headers },
+          body: requestBody.body,
           signal: controller.signal,
+          ...(requestBody.duplex ? { duplex: requestBody.duplex } : {}),
         });
         try {
           payload = await response.json();
@@ -302,22 +393,43 @@ export async function callTool({
   toolName,
   arguments_: argumentsPayload = {},
   idempotencyKey,
+  fileBindings = [],
 }) {
   const requestId = idempotencyKey || (runtime.mutating ? randomUUID() : null);
+  const payload = {
+    tool_name: canonicalizeToolName(toolName),
+    arguments: argumentsPayload,
+    idempotency_key: requestId,
+    cli_context: {
+      output_mode: runtime.outputMode,
+      profile: runtime.profileName,
+      cwd: process.cwd(),
+      agent_mode: runtime.agentMode,
+      cli_version: runtime.cliVersion,
+    },
+  };
+
+  if (Array.isArray(fileBindings) && fileBindings.length) {
+    const bindingMetadata = fileBindings.map((binding) => {
+      const {
+        contentType,
+        localPath,
+        ...metadata
+      } = binding;
+      return metadata;
+    });
+
+    return httpRequest({
+      runtime,
+      path: '/cli_tools',
+      body: () => createMultipartFileUpload(payload, bindingMetadata, fileBindings),
+      multipart: true,
+    });
+  }
+
   return httpRequest({
     runtime,
     path: '/cli_tools',
-    body: {
-      tool_name: canonicalizeToolName(toolName),
-      arguments: argumentsPayload,
-      idempotency_key: requestId,
-      cli_context: {
-        output_mode: runtime.outputMode,
-        profile: runtime.profileName,
-        cwd: process.cwd(),
-        agent_mode: runtime.agentMode,
-        cli_version: runtime.cliVersion,
-      },
-    },
+    body: payload,
   });
 }

package/template/packages/sdk/package.json

@@ -14,6 +14,9 @@
     "src",
     "template"
   ],
+  "scripts": {
+    "type-check": "tsc --noEmit"
+  },
   "peerDependencies": {
     "react": ">=18.0.0",
     "react-dom": ">=18.0.0",
@@ -21,6 +24,9 @@
     "@vitejs/plugin-react": ">=4.0.0"
   },
   "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
     "typescript": "^5.0.0"
   }
 }

package/template/packages/sdk/src/hooks/useDatabase.ts

@@ -0,0 +1,76 @@
+'use client';
+
+import { useCallback, useEffect, useState } from 'react';
+import { useNotisRuntime } from '../provider';
+import type { DocumentRecord, QueryFilter } from '../runtime';
+
+interface UseDatabaseOptions {
+  filter?: QueryFilter;
+  pageSize?: number;
+  offset?: number;
+  enabled?: boolean;
+}
+
+interface UseDatabaseResult {
+  documents: DocumentRecord[];
+  loading: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+
+export function useDatabase(
+  databaseSlug: string,
+  options: UseDatabaseOptions = {},
+): UseDatabaseResult {
+  const runtime = useNotisRuntime();
+  const [documents, setDocuments] = useState<DocumentRecord[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+  const [fetchKey, setFetchKey] = useState(0);
+
+  const enabled = options.enabled !== false;
+  const filterKey = JSON.stringify(options.filter ?? null);
+
+  const refetch = useCallback(() => {
+    setFetchKey((key) => key + 1);
+  }, []);
+
+  useEffect(() => {
+    if (!runtime || !enabled) {
+      setLoading(false);
+      return;
+    }
+
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+
+    runtime
+      .queryDatabase({
+        databaseSlug,
+        query: {
+          ...options.filter,
+          page_size: options.pageSize,
+        },
+        offset: options.offset,
+      })
+      .then((result) => {
+        if (!cancelled) {
+          setDocuments(result.documents);
+          setLoading(false);
+        }
+      })
+      .catch((err) => {
+        if (!cancelled) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+          setLoading(false);
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [runtime, databaseSlug, fetchKey, enabled, filterKey, options.offset, options.pageSize]);
+
+  return { documents, loading, error, refetch };
+}

package/template/packages/sdk/src/hooks/useNotis.ts

@@ -1,22 +1,25 @@
 'use client';
 
 import { useNotisRuntime } from '../provider';
-import type { AppDescriptor, NotisRuntimeContext, RouteDescriptor } from '../runtime';
+import type { AppDescriptor, CollectionItemDetail, DatabaseDescriptor, RouteDescriptor } from '../runtime';
 
 interface NotisContext {
   /** App metadata (id, name, icon, description). Null before runtime loads. */
   app: AppDescriptor | null;
   /** Current route descriptor. Null before runtime loads. */
   route: RouteDescriptor | null;
-  /** Generic route/app context supplied by the portal. */
-  context: NotisRuntimeContext;
+  /** Databases declared by this app. Empty before runtime loads. */
+  databases: DatabaseDescriptor[];
+  /** Selected collection item for the current route, when applicable. */
+  collectionItem: CollectionItemDetail | null;
   /** Whether the runtime is loaded and available. */
   ready: boolean;
 }
 
 /**
- * Access app-level metadata, the current route, and generic portal context.
- * Returns safe defaults when the portal runtime is not available.
+ * Access app-level metadata, the current route, declared databases, and the
+ * selected collection item. Returns safe defaults when the portal runtime is
+ * not available.
  */
 export function useNotis(): NotisContext {
   const runtime = useNotisRuntime();
@@ -24,7 +27,8 @@ export function useNotis(): NotisContext {
   return {
     app: runtime?.app ?? null,
     route: runtime?.route ?? null,
-    context: runtime?.context ?? {},
+    databases: runtime?.databases ?? [],
+    collectionItem: runtime?.context?.collectionItem ?? null,
     ready: runtime !== null,
   };
 }

package/template/packages/sdk/src/hooks/useUpsertDocument.ts

@@ -0,0 +1,50 @@
+'use client';
+
+import { useCallback, useState } from 'react';
+import { useNotisRuntime } from '../provider';
+import type { DocumentRecord } from '../runtime';
+
+interface UpsertArgs {
+  databaseSlug: string;
+  documentId?: string;
+  title?: string;
+  properties?: Record<string, unknown>;
+  contentBlocknote?: Array<Record<string, unknown>> | null;
+}
+
+interface UseUpsertDocumentResult {
+  upsert: (args: UpsertArgs) => Promise<DocumentRecord>;
+  loading: boolean;
+  error: Error | null;
+}
+
+export function useUpsertDocument(): UseUpsertDocumentResult {
+  const runtime = useNotisRuntime();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const upsert = useCallback(
+    async (args: UpsertArgs): Promise<DocumentRecord> => {
+      if (!runtime) {
+        throw new Error('Notis runtime not available. Ensure NotisProvider is mounted.');
+      }
+
+      setLoading(true);
+      setError(null);
+
+      try {
+        const result = await runtime.upsertDocument(args);
+        return result.document;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [runtime],
+  );
+
+  return { upsert, loading, error };
+}

package/template/packages/sdk/src/index.ts

@@ -7,10 +7,12 @@
  */
 
 // Provider
-export { NotisProvider } from './provider';
+export { NotisProvider, useNotisRuntime } from './provider';
 
 // Hooks
 export { useNotis } from './hooks/useNotis';
+export { useDatabase } from './hooks/useDatabase';
+export { useUpsertDocument } from './hooks/useUpsertDocument';
 export { useTool } from './hooks/useTool';
 export type { ToolCallState, UseToolResult } from './hooks/useTool';
 export { useTools } from './hooks/useTools';
@@ -38,8 +40,14 @@ export type { MultiSelectDragOverlayProps } from './components/MultiSelectDragOv
 // Types (re-exported for convenience)
 export type {
   AppDescriptor,
+  CollectionItem,
+  CollectionItemDetail,
+  DatabaseDescriptor,
+  DatabaseProperty,
+  DocumentRecord,
   NotisRuntime,
   NotisRuntimeContext,
+  QueryFilter,
   RouteDescriptor,
   ToolDescriptor,
   ToolInputSchema,

package/template/packages/sdk/src/runtime.ts

@@ -7,6 +7,39 @@
  * (useTool, useNotis, etc.) which read from the NotisProvider context.
  */
 
+// ---------------------------------------------------------------------------
+// Database types
+// ---------------------------------------------------------------------------
+
+export interface DatabaseProperty {
+  name: string;
+  type: 'title' | 'rich_text' | 'number' | 'checkbox' | 'date' | 'select' | 'multi_select' | 'status' | 'relation' | 'formula' | 'files';
+  description?: string;
+  options?: Array<{ name: string; id?: string }>;
+}
+
+export interface DatabaseDescriptor {
+  slug: string;
+  title: string;
+  description?: string | null;
+  icon?: string | null;
+  properties: DatabaseProperty[];
+}
+
+export interface DocumentRecord {
+  id: string;
+  title: string;
+  properties: Record<string, unknown>;
+  icon?: string | null;
+  cover?: string | null;
+  databaseSlug?: string;
+  contentBlocknote?: Array<Record<string, unknown>> | null;
+  contentMarkdown?: string | null;
+  plainText?: string | null;
+  createdAt?: string | null;
+  lastEditedTime?: string | null;
+}
+
 // ---------------------------------------------------------------------------
 // Tool types
 // ---------------------------------------------------------------------------
@@ -30,7 +63,25 @@ export interface RouteDescriptor {
   icon?: string | null;
   parentSlug?: string | null;
   default?: boolean;
-  collection?: Record<string, unknown> | null;
+  collection?: {
+    database: string;
+    titleProperty: string;
+    parentProperty?: string | null;
+    sidebar?: {
+      mode: 'flat-list' | 'tree';
+      allowCreate: boolean;
+    } | null;
+  } | null;
+}
+
+export interface CollectionItem {
+  id: string;
+  title: string;
+  icon?: string | null;
+}
+
+export interface CollectionItemDetail extends CollectionItem {
+  properties: Record<string, unknown>;
 }
 
 // ---------------------------------------------------------------------------
@@ -44,7 +95,22 @@ export interface AppDescriptor {
   description?: string | null;
 }
 
-export type NotisRuntimeContext = Record<string, unknown>;
+export interface QueryFilter {
+  filters?: Array<{
+    property: string;
+    operator: string;
+    value: unknown;
+  }>;
+  sorts?: Array<{
+    property: string;
+    direction: 'asc' | 'desc';
+  }>;
+  page_size?: number;
+}
+
+export interface NotisRuntimeContext {
+  collectionItem?: CollectionItemDetail | null;
+}
 
 // ---------------------------------------------------------------------------
 // NotisRuntime
@@ -53,6 +119,7 @@ export type NotisRuntimeContext = Record<string, unknown>;
 export interface NotisRuntime {
   app: AppDescriptor;
   route: RouteDescriptor;
+  databases: DatabaseDescriptor[];
   context: NotisRuntimeContext;
 
   navigate?: (payload: { kind: string; [key: string]: unknown }) => void;
@@ -72,6 +139,20 @@ export interface NotisRuntime {
   listTools(): Promise<ToolDescriptor[]>;
   callTool<TResult = unknown>(name: string, args?: Record<string, unknown>): Promise<TResult>;
 
+  queryDatabase(args: {
+    databaseSlug: string;
+    query?: QueryFilter;
+    offset?: number;
+  }): Promise<{ documents: DocumentRecord[] }>;
+
+  upsertDocument(args: {
+    databaseSlug: string;
+    documentId?: string;
+    title?: string;
+    properties?: Record<string, unknown>;
+    contentBlocknote?: Array<Record<string, unknown>> | null;
+  }): Promise<{ status: string; document: DocumentRecord }>;
+
   request(path: string, options?: {
     method?: string;
     headers?: Record<string, string>;