@notis_ai/cli 0.2.13 → 0.2.15

package/src/runtime/sync-skills.js

@@ -0,0 +1,215 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+import { reconcileBaseSkills } from './base-skills.js';
+
+const DEFAULT_LOCK_TIMEOUT_MS = 30_000;
+const DEFAULT_LOCK_STALE_MS = 10 * 60_000;
+const DEFAULT_LOCK_POLL_MS = 50;
+
+async function lockSnapshot(lockDirectory) {
+  try {
+    const [raw, metadata] = await Promise.all([
+      readFile(join(lockDirectory, 'owner'), 'utf8').catch(() => ''),
+      stat(lockDirectory),
+    ]);
+    let owner = {};
+    try {
+      owner = raw ? JSON.parse(raw) : {};
+    } catch {
+      // A process can die between mkdir and the atomic owner write. Preserve
+      // the directory mtime as a reclaimable ownerless lease.
+    }
+    return {
+      id: typeof owner.id === 'string' ? owner.id : null,
+      pid: Number.isInteger(Number(owner.pid)) ? Number(owner.pid) : null,
+      at: Number.isFinite(Number(owner.at)) ? Number(owner.at) : metadata.mtimeMs,
+      mtimeMs: metadata.mtimeMs,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function sameLockSnapshot(left, right) {
+  return Boolean(
+    left
+    && right
+    && left.id === right.id
+    && left.pid === right.pid
+    && left.at === right.at
+    && left.mtimeMs === right.mtimeMs,
+  );
+}
+
+function processIsAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === 'EPERM';
+  }
+}
+
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+async function quarantineStaleLock(lockDirectory, snapshot) {
+  const quarantineRoot = join(dirname(lockDirectory), '.stale-operation-locks');
+  const snapshotToken = createHash('sha256')
+    .update(JSON.stringify(snapshot))
+    .digest('hex');
+  await mkdir(quarantineRoot, { recursive: true, mode: 0o700 });
+  try {
+    // The deterministic destination is the compare-and-swap guard. If two
+    // waiters observed the same stale owner, only one can move it here. The
+    // retained non-empty tombstone prevents the loser from ever moving a new
+    // live lock that appeared at the shared pathname in the meantime.
+    await rename(lockDirectory, join(quarantineRoot, snapshotToken));
+    return true;
+  } catch (error) {
+    if (['EEXIST', 'ENOTEMPTY', 'ENOENT'].includes(error?.code)) return false;
+    throw error;
+  }
+}
+
+async function writeLockOwnerAtomically(lockDirectory, owner) {
+  const temporaryOwnerPath = join(lockDirectory, `.owner.${owner.id}.tmp`);
+  const ownerPath = join(lockDirectory, 'owner');
+  await writeFile(temporaryOwnerPath, JSON.stringify(owner), { mode: 0o600 });
+  await rename(temporaryOwnerPath, ownerPath);
+}
+
+/** Serialize Desktop and terminal skill sync across processes on one Mac. */
+export async function withSkillSyncLock(callback, {
+  home = homedir(),
+  timeoutMs = DEFAULT_LOCK_TIMEOUT_MS,
+  staleMs = DEFAULT_LOCK_STALE_MS,
+  pollMs = DEFAULT_LOCK_POLL_MS,
+  now = () => Date.now(),
+} = {}) {
+  const lockDirectory = join(home, '.notis', 'skills', '.operation-lock');
+  const ownerId = `${process.pid}.${randomUUID()}`;
+  const deadline = now() + timeoutMs;
+  await mkdir(dirname(lockDirectory), { recursive: true, mode: 0o700 });
+
+  for (;;) {
+    try {
+      await mkdir(lockDirectory, { mode: 0o700 });
+      try {
+        await writeLockOwnerAtomically(lockDirectory, {
+          id: ownerId,
+          pid: process.pid,
+          at: now(),
+        });
+      } catch (error) {
+        // This process exclusively created the directory and has not yet
+        // published an owner, so it is safe to undo a failed acquisition.
+        await rm(lockDirectory, { recursive: true, force: true });
+        throw error;
+      }
+      break;
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error;
+    }
+
+    const observed = await lockSnapshot(lockDirectory);
+    if (
+      observed
+      && now() - observed.at > staleMs
+      && !processIsAlive(observed.pid)
+    ) {
+      // Require an unchanged observation interval before stealing. This avoids
+      // racing a holder that is publishing or refreshing its owner lease.
+      await delay(Math.max(pollMs, 10));
+      const current = await lockSnapshot(lockDirectory);
+      if (sameLockSnapshot(observed, current) && !processIsAlive(current?.pid)) {
+        if (await quarantineStaleLock(lockDirectory, current)) continue;
+      }
+    }
+    if (now() >= deadline) {
+      throw new Error('Timed out waiting for another Notis skill sync to finish.');
+    }
+    await delay(pollMs);
+  }
+
+  const heartbeatMs = Math.max(10, Math.min(30_000, Math.floor(staleMs / 3)));
+  let heartbeatStopped = false;
+  let heartbeatInFlight = Promise.resolve();
+  const refreshHeartbeat = async () => {
+      if (heartbeatStopped) return;
+      const temporaryOwnerPath = join(lockDirectory, `.owner.${ownerId}.tmp`);
+      await writeFile(
+        temporaryOwnerPath,
+        JSON.stringify({ id: ownerId, pid: process.pid, at: now() }),
+        { mode: 0o600 },
+      );
+      const owner = await lockSnapshot(lockDirectory);
+      if (owner?.id !== ownerId) {
+        await rm(temporaryOwnerPath, { force: true });
+        return;
+      }
+      // If a stale-lock reclaimer moved this directory after the ownership
+      // check, the source path disappears and rename fails instead of
+      // overwriting the owner of a newly acquired lock at the shared path.
+      await rename(temporaryOwnerPath, join(lockDirectory, 'owner'));
+  };
+  const heartbeat = setInterval(() => {
+    // Serialize refreshes and retain the active promise so cleanup cannot race
+    // a temporary owner write that was already in flight when the interval was
+    // cleared.
+    heartbeatInFlight = heartbeatInFlight
+      .then(refreshHeartbeat)
+      .catch(() => undefined);
+  }, heartbeatMs);
+  heartbeat.unref?.();
+
+  try {
+    return await callback();
+  } finally {
+    heartbeatStopped = true;
+    clearInterval(heartbeat);
+    await heartbeatInFlight;
+    const owner = await lockSnapshot(lockDirectory);
+    if (owner?.id === ownerId) {
+      await rm(lockDirectory, { recursive: true, force: true });
+    }
+  }
+}
+
+/**
+ * Shared CLI-owned orchestration for base-skill installation plus account sync.
+ * Desktop injects the source engine that webpack bundles; the CLI command
+ * injects the generated dist engine used by the published package.
+ */
+export async function reconcileAllSkills({
+  serverUrl,
+  jwt,
+  honorSyncEnabled,
+  userId = null,
+  home,
+  runAccountSync,
+  reconcileBase = reconcileBaseSkills,
+  lockOptions = {},
+}) {
+  return withSkillSyncLock(async () => {
+    const base = reconcileBase({ userId, ...(home ? { home } : {}) });
+    const account = await runAccountSync(
+      serverUrl,
+      jwt,
+      {},
+      { honorSyncEnabled },
+    );
+    return {
+      ...account,
+      baseSkills: base.skills,
+      baseInstalled: base.installed,
+      baseLinked: base.linked,
+      baseBackups: base.backups,
+    };
+  }, { ...lockOptions, ...(home ? { home } : {}) });
+}

package/src/runtime/transport.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { createReadStream } from 'node:fs';
 import { dirname } from 'node:path';
 import { CliError, EXIT_CODES } from './errors.js';
+import { delegatedContextReason } from './delegated-context.js';
 import {
   credentialIsExpired,
   getJwtExpiration,
@@ -327,9 +328,11 @@ export async function httpRequest({
     });
 
     let payload = null;
+    let payloadReadError = null;
     try {
       payload = await response.json();
-    } catch {
+    } catch (error) {
+      payloadReadError = error;
       payload = null;
     }
 
@@ -350,9 +353,11 @@ export async function httpRequest({
           signal: controller.signal,
           ...(requestBody.duplex ? { duplex: requestBody.duplex } : {}),
         });
+        payloadReadError = null;
         try {
           payload = await response.json();
-        } catch {
+        } catch (error) {
+          payloadReadError = error;
           payload = null;
         }
       }
@@ -376,6 +381,14 @@ export async function httpRequest({
       throw normalizeBackendError(response.status, payload, runtime);
     }
 
+    // A successful status is not a successful tool call until its response
+    // body has been read. Mutations may already have committed before a socket
+    // reset truncates the JSON; surface that as an ambiguous network failure
+    // so callers never persist an undefined result or attempt a second write.
+    if (response.status !== 204 && payloadReadError) {
+      throw payloadReadError;
+    }
+
     return {
       requestId,
       payload: payload || {},
@@ -428,6 +441,10 @@ export async function callTool({
       cwd: process.cwd(),
       agent_mode: runtime.agentMode,
       cli_version: runtime.cliVersion,
+      // Reported so the server can refuse work-handing tools from a run Notis
+      // is itself driving. Advisory -- a determined agent can unset the markers
+      // -- so the server treats it as one layer, not the whole guard.
+      ...(delegatedContextReason() ? { delegated_context: true } : {}),
       ...(runtime.debugEntitlementOverride
         ? { debug_entitlement_override: runtime.debugEntitlementOverride }
         : {}),

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

@@ -164,8 +164,35 @@
       });
     });
 
+    /**
+     * Records one runtime call and hands back the entry so the caller can
+     * stamp its outcome once the promise settles. Verify reads `ok` to tell a
+     * route that rendered from real data apart from one that only rendered its
+     * error states, so every runtime path must settle its own entry.
+     */
     function record(op, args) {
-      window.__harness.runtimeCalls.push({ op, args });
+      const entry = { op, args, ok: null, error: null, durationMs: null };
+      entry.startedAt = Date.now();
+      window.__harness.runtimeCalls.push(entry);
+      return entry;
+    }
+
+    function settle(entry, error) {
+      entry.durationMs = Date.now() - entry.startedAt;
+      delete entry.startedAt;
+      entry.ok = !error;
+      entry.error = error ? (error.message ? String(error.message) : String(error)) : null;
+    }
+
+    async function tracked(entry, run) {
+      try {
+        const value = await run();
+        settle(entry, null);
+        return value;
+      } catch (error) {
+        settle(entry, error);
+        throw error;
+      }
     }
 
     async function readJsonOrSnippet(response) {
@@ -214,29 +241,58 @@
         app: descriptor.app,
         route: descriptor.route,
         context: descriptor.context || {},
-        navigate: (args) => record('navigate', args),
+        navigate: (args) => {
+          settle(record('navigate', args), null);
+        },
+        // There is no manager chat here, so the handover is recorded and
+        // reported as drafted without any UI.
+        handover: async (payload) => {
+          settle(record('handover', payload), null);
+          return { status: 'drafted' };
+        },
         registerTopBarSearch: () => {},
         setTopBarSearchValue: () => {},
         setTopBarSearchLoading: () => {},
-        listTools: async () => {
-          record('listTools', {});
-          return descriptor.tools || [];
-        },
-        callTool: async (name, args) => {
-          record('callTool', { name, arguments: args || {} });
-          const fixture = lookupToolFixture(name, args || {});
-          if (fixture !== undefined) {
-            return structuredClone(fixture);
-          }
-          return { ok: true, result: null };
-        },
-        request: async (path, options) => {
-          record('request', { path, options });
-          if (fixtures && fixtures.requests && Object.prototype.hasOwnProperty.call(fixtures.requests, path)) {
-            return structuredClone(fixtures.requests[path]);
-          }
-          return null;
-        },
+        // No change feed here, so `useDatabaseSubscription` reports live=false
+        // and the app keeps whatever manual refresh it offers.
+        subscribeDatabase: () => () => {},
+        // There is no cloud computer behind the harness. Answering "not
+        // available" rather than throwing keeps `useCloudComputer` on the same
+        // fallback branch a user without a cloud computer would see.
+        cloudComputerFacts: async () => tracked(
+          record('cloudComputerFacts', {}),
+          async () => ({
+            available: false,
+            reason: 'unsupported_host',
+            sandbox: null,
+            cli_auth: {
+              gh: { authenticated: null, account: null, checked_at: null, reason: 'unsupported_host' },
+            },
+          }),
+        ),
+        listTools: async () => tracked(
+          record('listTools', {}),
+          async () => descriptor.tools || [],
+        ),
+        callTool: async (name, args) => tracked(
+          record('callTool', { name, arguments: args || {} }),
+          async () => {
+            const fixture = lookupToolFixture(name, args || {});
+            if (fixture !== undefined) {
+              return structuredClone(fixture);
+            }
+            return { ok: true, result: null };
+          },
+        ),
+        request: async (path, options) => tracked(
+          record('request', { path, options }),
+          async () => {
+            if (fixtures && fixtures.requests && Object.prototype.hasOwnProperty.call(fixtures.requests, path)) {
+              return structuredClone(fixtures.requests[path]);
+            }
+            return null;
+          },
+        ),
       };
     }
 
@@ -270,32 +326,45 @@
     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;
-        },
+        listTools: async () => tracked(
+          record('listTools', {}),
+          async () => {
+            const result = await runtimeQuery({ method: 'tools/list' });
+            return result.tools || [];
+          },
+        ),
+        callTool: async (name, args) => tracked(
+          record('callTool', { name, arguments: args || {} }),
+          async () => runtimeQuery({ method: 'tools/call', name, arguments: args || {} }),
+        ),
+        // Live mode must not inherit the stub's canned answer: it would settle
+        // ok: true with fake data and soften the all-calls-failed assertion.
+        cloudComputerFacts: async (options) => tracked(
+          record('cloudComputerFacts', options || {}),
+          async () => runtimeQuery({
+            method: 'cloud_computer/facts',
+            ...(options && options.refresh ? { refresh: true } : {}),
+          }),
+        ),
+        request: async (path, options) => tracked(
+          record('request', { path, options }),
+          async () => {
+            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;
+          },
+        ),
       };
     }
 

package/template/app/layout.tsx

@@ -1,6 +1,10 @@
 import '@notis/sdk/styles.css';
+import { ShortcutProvider } from '@notis/sdk/interactions';
 import './globals.css';
 
 export default function AppShell({ children }: { children: React.ReactNode }) {
-  return children;
+  // NotisProvider supplies this in the product host. Keeping the shell-level
+  // provider makes the same scope arbitration available in the local harness;
+  // ShortcutProvider is nesting-safe, so the hosted app still has one registry.
+  return <ShortcutProvider>{children}</ShortcutProvider>;
 }

package/template/notis.config.ts

@@ -2,6 +2,7 @@ import { defineNotisApp } from '@notis/sdk/config';
 
 export default defineNotisApp({
   name: 'my-notis-app',
+  devSlug: 'my-notis-app',
   title: 'My Notis App',
   description: 'A focused Notis app with one route and one database-backed workflow.',
   icon: 'phosphor:squares-four',

package/template/packages/sdk/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@notis/sdk",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "main": "./src/index.ts",
   "exports": {
     ".": "./src/index.ts",
+    "./interactions": "./src/interactions.ts",
     "./config": "./src/config.ts",
     "./vite": "./src/vite.ts",
     "./ui": "./src/ui.ts",

package/template/packages/sdk/src/components/DocumentEditor.tsx

@@ -51,7 +51,7 @@ function DocumentEditorFallback({ documentId, variant = 'full', className }: Not
     );
   }
 
-  const isMarkdown = document.contentType !== 'file';
+  const isMarkdown = document.contentType === 'markdown' || !document.contentType;
   return (
     <div className={className}>
       {variant === 'full' ? <h1 style={fallbackTitleStyle}>{document.title}</h1> : null}
@@ -62,6 +62,15 @@ function DocumentEditorFallback({ documentId, variant = 'full', className }: Not
             <p style={fallbackNoticeStyle}>Read-only preview — editing is available inside the Notis portal.</p>
           )}
         </>
+      ) : document.contentType === 'view' ? (
+        <div style={fallbackFrameStyle}>
+          {document.viewType === 'report'
+            ? 'Interactive report'
+            : document.viewType === 'html'
+              ? 'Interactive HTML document'
+              : 'View document'} — open it in Notis Documents for
+          the full native experience.
+        </div>
       ) : (
         <div style={fallbackFrameStyle}>
           {document.fileType ? `${document.fileType.toUpperCase()} document` : 'File document'} — open it in
@@ -76,8 +85,9 @@ function DocumentEditorFallback({ documentId, variant = 'full', className }: Not
  * Embeds the document editor for a document anywhere in an app view. The host
  * (portal) provides the implementation through `runtime.ui.DocumentEditor` and
  * dispatches on the document's content type (markdown -> rich text editor,
- * files -> matching viewer). Outside the portal this falls back to a read-only
- * preview.
+ * files -> matching viewer, views -> their trusted native Documents surface).
+ * Outside the portal this falls back to a read-only preview or an explicit
+ * open-in-Documents notice for native views.
  *
  * ```tsx
  * <DocumentEditor documentId={entry.id} variant="body" className="min-h-[320px]" />

package/template/packages/sdk/src/components/MarkdownEditor.tsx

@@ -0,0 +1,121 @@
+import type { ChangeEvent, KeyboardEvent, ReactElement } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useNotisRuntime } from '../provider';
+import type { NotisMarkdownEditorProps } from '../runtime';
+
+function MarkdownEditorFallback({
+  value,
+  revision,
+  readOnly,
+  autosaveMs = 1500,
+  placeholder = 'Write in Markdown…',
+  className,
+  onChange,
+  onSave,
+  onDirtyChange,
+  onSavingChange,
+}: NotisMarkdownEditorProps) {
+  const [draft, setDraft] = useState(value);
+  const [saveAttempt, setSaveAttempt] = useState(0);
+  const draftRef = useRef(value);
+  const dirtyRef = useRef(false);
+  const savingRef = useRef(false);
+  const revisionRef = useRef(revision);
+  const onSaveRef = useRef(onSave);
+  const readOnlyRef = useRef(readOnly);
+  const unmountedRef = useRef(false);
+  const saveRef = useRef<() => Promise<void>>(async () => undefined);
+
+  useEffect(() => {
+    onSaveRef.current = onSave;
+    readOnlyRef.current = readOnly;
+  }, [onSave, readOnly]);
+
+  useEffect(() => {
+    if (dirtyRef.current) return;
+    draftRef.current = value;
+    revisionRef.current = revision;
+    setDraft(value);
+  }, [revision, value]);
+
+  const save = useCallback(async () => {
+    if (!onSave || !dirtyRef.current || readOnly || savingRef.current) return;
+    const markdown = draftRef.current;
+    savingRef.current = true;
+    if (!unmountedRef.current) onSavingChange?.(true);
+    try {
+      const result = await onSave({ markdown, expectedRevision: revisionRef.current });
+      if (result?.revision) revisionRef.current = result.revision;
+      if (draftRef.current === markdown) {
+        dirtyRef.current = false;
+        if (!unmountedRef.current) onDirtyChange?.(false);
+      }
+    } finally {
+      savingRef.current = false;
+      if (!unmountedRef.current) onSavingChange?.(false);
+      if (dirtyRef.current && draftRef.current !== markdown) {
+        if (unmountedRef.current) {
+          void saveRef.current().catch((error) => console.error('Could not save Markdown on unmount', error));
+        } else {
+          setSaveAttempt((attempt) => attempt + 1);
+        }
+      }
+    }
+  }, [onDirtyChange, onSave, onSavingChange, readOnly]);
+  saveRef.current = save;
+
+  useEffect(() => {
+    unmountedRef.current = false;
+    return () => {
+      unmountedRef.current = true;
+      if (!savingRef.current) {
+        void saveRef.current().catch((error) => console.error('Could not save Markdown on unmount', error));
+      }
+    };
+  }, []);
+
+  useEffect(() => {
+    if (!dirtyRef.current || !onSave || readOnly) return;
+    const timer = window.setTimeout(() => void save(), Math.max(250, autosaveMs));
+    return () => window.clearTimeout(timer);
+  }, [autosaveMs, draft, onSave, readOnly, save, saveAttempt]);
+
+  const handleChange = (event: ChangeEvent<HTMLTextAreaElement>) => {
+    const next = event.currentTarget.value;
+    draftRef.current = next;
+    setDraft(next);
+    if (!dirtyRef.current) {
+      dirtyRef.current = true;
+      onDirtyChange?.(true);
+    }
+    onChange?.(next);
+  };
+
+  const handleKeyDown = (event: KeyboardEvent<HTMLTextAreaElement>) => {
+    if ((event.metaKey || event.ctrlKey) && event.key.toLowerCase() === 's') {
+      event.preventDefault();
+      void save();
+    }
+  };
+
+  return (
+    <textarea
+      value={draft}
+      readOnly={readOnly}
+      placeholder={placeholder}
+      className={className}
+      onChange={handleChange}
+      onKeyDown={handleKeyDown}
+      style={{ minHeight: 360, width: '100%', resize: 'vertical' }}
+    />
+  );
+}
+
+/** Use Notis' editor while leaving persistence entirely under app control. */
+export function MarkdownEditor(props: NotisMarkdownEditorProps): ReactElement {
+  const runtime = useNotisRuntime();
+  const HostEditor = runtime?.ui?.MarkdownEditor;
+  return HostEditor
+    ? <HostEditor key={props.resourceKey} {...props} />
+    : <MarkdownEditorFallback key={props.resourceKey} {...props} />;
+}