@notis_ai/cli 0.2.18 → 0.2.20

package/src/runtime/profiles.js

@@ -1,18 +1,17 @@
-import { randomUUID } from 'node:crypto';
 import {
   existsSync,
   mkdirSync,
   readFileSync,
   renameSync,
-  rmSync,
-  statSync,
   writeFileSync,
 } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, parse, resolve } from 'node:path';
 import { CliError, EXIT_CODES } from './errors.js';
+import { withConfigFileWriteLock } from './config-lock.js';
 import { getAuthRecovery, quoteShellArgument } from './auth-recovery.js';
 import { channelFromProfile, cliCommandForChannel, isReleaseChannel } from './channel.js';
+import { resolveRetryEnabled } from './retry.js';
 
 export const CONFIG_DIR = join(homedir(), '.notis');
 export const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
@@ -34,14 +33,6 @@ const WORKTREE_RUNTIME_FILENAME = join('.context', 'notis-runtime.json');
 const WORKTREE_ROUTING_FILENAME = join('.context', 'notis-routing.json');
 const LOCAL_API_HOSTS = new Set(['localhost', '127.0.0.1', '::1']);
 const LIVE_API_HOSTS = new Set(['api.notis.ai', 'api-beta.notis.ai']);
-// Cross-process write lock over ~/.notis/config.json. Independent `notis`
-// processes (a `login` in one terminal and a `tools exec` in another) all
-// rewrite this file, so the lock directory name and these three timings are the
-// whole coordination protocol. Guarded by the concurrency test in
-// packages/cli/test/runtime-auth.test.js.
-const CONFIG_WRITE_LOCK_TIMEOUT_MS = 5_000;
-const CONFIG_WRITE_LOCK_STALE_MS = 2_000;
-const CONFIG_WRITE_LOCK_POLL_MS = 10;
 
 function clone(value) {
   return JSON.parse(JSON.stringify(value));
@@ -206,7 +197,7 @@ function readJsonFile(path) {
   }
 }
 
-function findUp(filename, startDir = process.cwd()) {
+function findUp(filename, startDir = process.cwd(), boundary = null) {
   let current = resolve(startDir);
   const root = parse(current).root;
   while (true) {
@@ -214,7 +205,7 @@ function findUp(filename, startDir = process.cwd()) {
     if (existsSync(candidate)) {
       return candidate;
     }
-    if (current === root) {
+    if (current === root || current === boundary) {
       return null;
     }
     current = dirname(current);
@@ -228,8 +219,11 @@ function processIsAlive(pid) {
   try {
     process.kill(pid, 0);
     return true;
-  } catch {
-    return false;
+  } catch (error) {
+    // Sandboxed children may be allowed to observe the worktree lease but not
+    // signal its dev.sh supervisor. POSIX EPERM proves that the PID exists;
+    // ESRCH (and every other probe failure) does not.
+    return error?.code === 'EPERM';
   }
 }
 
@@ -240,8 +234,11 @@ export function resolveWorktreeRuntime(startDir = process.cwd()) {
   ) {
     return null;
   }
-  const runtimePath = findUp(WORKTREE_RUNTIME_FILENAME, startDir);
   const routingPath = findUp(WORKTREE_ROUTING_FILENAME, startDir);
+  // A nested worktree's persistent policy survives its lease. Never cross that
+  // boundary and borrow a still-running ancestor worktree's credential/route.
+  const boundary = routingPath ? dirname(dirname(routingPath)) : null;
+  const runtimePath = findUp(WORKTREE_RUNTIME_FILENAME, startDir, boundary);
   const routing = routingPath ? readJsonFile(routingPath) : null;
 
   if (!runtimePath) {
@@ -369,103 +366,11 @@ function writeRawConfig(configFile, config) {
   renameSync(temporaryFile, configFile);
 }
 
-// The lock records who holds it and when they took it. Reclaiming a stale lock
-// by mtime alone is not safe: the reclaimer cannot tell an abandoned lock from
-// one it is about to steal from a live writer, and the victim's own release
-// would then delete the thief's lock and admit a third writer. Both sides are
-// on the same host, so the stored timestamp and Date.now() share a clock.
-function readLockOwner(lockDirectory) {
-  try {
-    return JSON.parse(readFileSync(join(lockDirectory, 'owner'), 'utf-8'));
-  } catch {
-    return null;
-  }
-}
-
-function lockDirectoryMtime(lockDirectory) {
-  try {
-    return statSync(lockDirectory).mtimeMs;
-  } catch {
-    return null;
-  }
-}
-
-function publishConfigWriteLock(lockDirectory, ownerId) {
-  const candidateDirectory = `${lockDirectory}.candidate-${ownerId}`;
-  try {
-    mkdirSync(candidateDirectory);
-    writeFileSync(
-      join(candidateDirectory, 'owner'),
-      JSON.stringify({ id: ownerId, at: Date.now() }),
-      { mode: 0o600 },
-    );
-    try {
-      renameSync(candidateDirectory, lockDirectory);
-      return true;
-    } catch (error) {
-      if (!existsSync(lockDirectory)) throw error;
-      return false;
-    }
-  } finally {
-    rmSync(candidateDirectory, { recursive: true, force: true });
-  }
-}
-
+// Independent `notis` processes and Desktop all rewrite this file. The lock
+// protocol lives in config-lock.js, shared with computer.json and mirrored by
+// Desktop.
 function withConfigWriteLock(callback) {
-  const configFile = resolveConfigFile();
-  const lockDirectory = `${configFile}.write-lock`;
-  const ownerId = `${process.pid}.${randomUUID()}`;
-  const deadline = Date.now() + CONFIG_WRITE_LOCK_TIMEOUT_MS;
-  mkdirSync(dirname(configFile), { recursive: true });
-  for (;;) {
-    if (!existsSync(lockDirectory) && publishConfigWriteLock(lockDirectory, ownerId)) {
-      break;
-    }
-
-    const owner = readLockOwner(lockDirectory);
-    const observedMtime = lockDirectoryMtime(lockDirectory);
-    const ownerIsStale =
-      owner?.id && Date.now() - Number(owner.at) > CONFIG_WRITE_LOCK_STALE_MS;
-    const ownerlessIsStale =
-      !owner
-      && observedMtime !== null
-      && Date.now() - observedMtime > CONFIG_WRITE_LOCK_STALE_MS;
-    if (ownerIsStale || ownerlessIsStale) {
-      try {
-        const currentOwner = readLockOwner(lockDirectory);
-        const ownerUnchanged = owner?.id
-          ? currentOwner?.id === owner.id
-          : !currentOwner && lockDirectoryMtime(lockDirectory) === observedMtime;
-        if (ownerUnchanged) {
-          rmSync(lockDirectory, { recursive: true, force: true });
-          continue;
-        }
-      } catch {
-        // Losing the reclaim race is normal; fall through and keep waiting.
-      }
-    }
-    if (Date.now() >= deadline) {
-      throw new Error(`Timed out waiting to update ${configFile}`);
-    }
-    Atomics.wait(
-      new Int32Array(new SharedArrayBuffer(4)),
-      0,
-      0,
-      CONFIG_WRITE_LOCK_POLL_MS,
-    );
-  }
-  try {
-    return callback(configFile);
-  } finally {
-    try {
-      // Never release a lock that was reclaimed from us while we worked.
-      if (readLockOwner(lockDirectory)?.id === ownerId) {
-        rmSync(lockDirectory, { recursive: true, force: true });
-      }
-    } catch {
-      // The lock may already have been removed after an interrupted write.
-    }
-  }
+  return withConfigFileWriteLock(resolveConfigFile(), callback);
 }
 
 export function saveConfig(config) {
@@ -967,6 +872,8 @@ export function resolveRuntimeProfile(
     nonInteractive,
     outputMode,
     timeoutMs,
+    // Automatic retries of interrupted calls that are safe to repeat.
+    retry: resolveRetryEnabled(globalOptions),
     debugEntitlementOverride,
     worktreeRuntime: devRuntime,
     detachedWorktreeRuntime: devRuntime ? null : worktreeRuntime,

package/src/runtime/retired-sdk-files.js

@@ -0,0 +1,24 @@
+/** Exact canonical files retired from the embedded SDK (one-Shadow-runtime cutover, toolkit move).
+ * Modified or additional source is retained for explicit reconciliation. */
+// Host mounting code stays in the canonical SDK and CLI host bundle, not in
+// authored apps' public SDK mirror. It is not a public package export.
+export const HOST_ONLY_SDK_FILES = Object.freeze(['src/presentation.tsx']);
+
+export const RETIRED_SDK_FILES = Object.freeze({
+  "src/presentation.tsx": [
+    "d29022f92e1e96b451b62cc8a561878a1c0cf8a3b4c0419181de7266f8a1b525"
+  ],
+  "src/isolatedHost.tsx": [
+    "7f59049281a9533d39c557ca75635073c2f404f1eb0a528b274323d61db776cd"
+  ],
+  "src/frameProtocol.ts": [
+    "f32337ddb507718be04289a4acf50cf2485698bc716556230f35f06a6f633f19"
+  ],
+  "src/frameIsolation.ts": [
+    "8b57cb38f618eefc4133ae50fbf2b37bbdef5be02e44b39758d8328fb2a59ab6"
+  ],
+  // Moved to src/ui/charts/RenderChartData.tsx with the Spaces toolkit.
+  "src/components/RenderChartData.tsx": [
+    "a3a8ab3ffe4cd7807e0591b6dace77c24dd08cb556e4170595783e986a513808"
+  ]
+});

package/src/runtime/retry.js

@@ -0,0 +1,150 @@
+import { CliError } from './errors.js';
+
+/**
+ * Safe automatic retries for tool calls.
+ *
+ * A call is replayed only when the replay is provably harmless:
+ * - A read the server proves read-only. Keyless writes are refused before
+ *   they run, so replaying a keyless call never repeats an effect.
+ * - A call with an idempotency key. The server stores the first outcome under
+ *   that key, so the same key and the same body either join the running call,
+ *   or return its stored answer.
+ * - A native write that answered "outcome unknown" and carries its own
+ *   `request_id`. Its stored answer is that unknown outcome, so the replay
+ *   sends identical arguments under a fresh idempotency key and the native
+ *   receipt for the `request_id` decides whether it already happened.
+ *
+ * Every other failure is returned after the first attempt.
+ */
+
+export const RETRY_MAX_ATTEMPTS = 3;
+export const RETRY_BASE_DELAY_MS = 250;
+export const RETRY_MAX_DELAY_MS = 2000;
+const RETRY_MIN_ATTEMPT_WINDOW_MS = 1000;
+
+const TRANSIENT_HTTP_STATUSES = new Set([502, 503, 504]);
+const TRANSIENT_NETWORK_CODES = new Set(['network_error', 'network_timeout']);
+
+// Native tool results that end with an unknown outcome and dedupe a replay by
+// the caller's `request_id`.
+export const TOOL_OUTCOME_UNKNOWN_CODES = new Set([
+  'document_outcome_unknown',
+  'record_file_outcome_unknown',
+]);
+
+const FALSE_VALUES = new Set(['', '0', 'false', 'no', 'off']);
+
+/** `--no-retry` or a truthy NOTIS_NO_RETRY turns automatic retries off. */
+export function resolveRetryEnabled(globalOptions = {}, env = process.env) {
+  if (globalOptions.retry === false) return false;
+  const raw = env.NOTIS_NO_RETRY;
+  if (raw === undefined || raw === null) return true;
+  return FALSE_VALUES.has(String(raw).trim().toLowerCase());
+}
+
+export function retriesEnabled(runtime) {
+  return runtime?.retry !== false;
+}
+
+function backendErrorCode(details) {
+  const error = details?.error;
+  if (error && typeof error === 'object' && typeof error.code === 'string') return error.code;
+  return typeof error === 'string' ? error : null;
+}
+
+/** Whether the failure is temporary, so the same request may succeed. */
+export function isTransientFailure(error) {
+  if (!(error instanceof CliError)) return false;
+  if (TRANSIENT_NETWORK_CODES.has(error.code)) return true;
+  const code = backendErrorCode(error.details);
+  // An unknown outcome is a final answer for this key, never a transport blip.
+  if (typeof code === 'string' && code.endsWith('_outcome_unknown')) return false;
+  if (TRANSIENT_HTTP_STATUSES.has(error.httpStatus)) return true;
+  return error.httpStatus === 409 && code === 'idempotency_in_progress';
+}
+
+/** Whether sending the identical request again can never repeat an effect. */
+export function canReplayRequest({ mutating, idempotencyKey }) {
+  return Boolean(idempotencyKey) || !mutating;
+}
+
+/**
+ * The native outcome-unknown code a tool answer carries, if any. The answer
+ * may be the tool output itself or a multi-execute envelope around it.
+ */
+export function findToolOutcomeUnknown(payload, depth = 0) {
+  if (!payload || typeof payload !== 'object' || depth > 6) return null;
+  if (Array.isArray(payload)) {
+    for (const item of payload) {
+      const code = findToolOutcomeUnknown(item, depth + 1);
+      if (code) return code;
+    }
+    return null;
+  }
+  const own = backendErrorCode(payload);
+  if (own && TOOL_OUTCOME_UNKNOWN_CODES.has(own)) return own;
+  for (const value of Object.values(payload)) {
+    if (value && typeof value === 'object') {
+      const code = findToolOutcomeUnknown(value, depth + 1);
+      if (code) return code;
+    }
+  }
+  return null;
+}
+
+function hasRequestId(args) {
+  return Boolean(args) && typeof args === 'object' && typeof args.request_id === 'string'
+    && args.request_id.trim().length > 0;
+}
+
+/**
+ * Whether the call names exactly one tool whose arguments carry a stable
+ * `request_id`. A batch of several tools is never resent: its other items
+ * might not deduplicate a second run.
+ */
+export function callCarriesToolRequestId(argumentsPayload) {
+  if (!argumentsPayload || typeof argumentsPayload !== 'object') return false;
+  if (Array.isArray(argumentsPayload.tools)) {
+    return argumentsPayload.tools.length === 1 && hasRequestId(argumentsPayload.tools[0]?.arguments);
+  }
+  return hasRequestId(argumentsPayload);
+}
+
+export function retryDelayMs(attempt, random = Math.random) {
+  const ceiling = Math.min(RETRY_MAX_DELAY_MS, RETRY_BASE_DELAY_MS * (2 ** (attempt - 1)));
+  return Math.round(ceiling / 2 + random() * (ceiling / 2));
+}
+
+/**
+ * Wait before the next attempt when it still fits in the overall time budget.
+ * Returns false when no attempt is left or the budget is spent.
+ */
+export async function waitForNextAttempt({ attempt, deadline, budgetMs, now = Date.now, sleep = defaultSleep }) {
+  if (attempt >= RETRY_MAX_ATTEMPTS) return false;
+  const delay = retryDelayMs(attempt);
+  const window = Math.min(RETRY_MIN_ATTEMPT_WINDOW_MS, Math.floor(budgetMs / 4));
+  if (deadline - now() - delay < window) return false;
+  await sleep(delay);
+  return true;
+}
+
+function defaultSleep(ms) {
+  return new Promise((resolve) => { setTimeout(resolve, ms); });
+}
+
+/** Record how many attempts a failed call made, without changing its shape. */
+export function withAttempts(error, attempts) {
+  if (error instanceof CliError) {
+    const details = error.details && typeof error.details === 'object' && !Array.isArray(error.details)
+      ? error.details
+      : {};
+    error.details = { ...details, attempts };
+    if (attempts > 1) {
+      error.hints = [
+        ...(Array.isArray(error.hints) ? error.hints : []),
+        { reason: `The CLI already tried this call ${attempts} times. Check the cause before running it again.` },
+      ];
+    }
+  }
+  return error;
+}

package/src/runtime/skill-sync/cloud-client.ts

@@ -1,5 +1,7 @@
-import { createSkillBundleBase64 } from './local-scanner';
-import type { AgentTargets, LocalSkill, SyncPullResponse, SyncPushResponse, SyncSettings } from './types';
+import { captureNativeSkillFiles, createSkillBundleBase64 } from './local-scanner';
+import { createHash } from 'node:crypto';
+import { checkedNativeReference } from './native-identity';
+import type { AgentTargets, LocalSkill, NativeSkillReference, SyncPullResponse, SyncPushResponse, SyncSettings } from './types';
 
 type JsonBody = Record<string, unknown> | undefined;
 
@@ -9,6 +11,7 @@ async function requestJson<T>(
   options: { method?: string; body?: JsonBody } = {},
 ): Promise<T> {
   const response = await fetch(url, {
+    signal: AbortSignal.timeout(90_000),
     method: options.method || 'POST',
     headers: {
       'Content-Type': 'application/json',
@@ -33,7 +36,7 @@ export async function fetchSyncSettings(serverUrl: string, jwt: string): Promise
 
 export async function pullSkills(serverUrl: string, jwt: string): Promise<SyncPullResponse> {
   return requestJson<SyncPullResponse>(`${serverUrl}/portal_skills/sync-pull`, jwt, {
-    body: {},
+    body: { skill_sync_protocol: 2 },
   });
 }
 
@@ -48,18 +51,23 @@ export async function pushChangedSkills(
     skill_md: skill.skillMd,
     source_url: skill.sourceUrl,
     folder_hash: skill.folderHash,
-    bundle_base64: await createSkillBundleBase64(skill),
+    ...(skill.nativeReference ? { bundle_files: await captureNativeSkillFiles(skill) }
+      : { bundle_base64: await createSkillBundleBase64(skill) }),
+    ...(skill.cloudId ? { cloud_id: skill.cloudId } : {}),
+    ...(skill.nativeReference ? { native_reference: skill.nativeReference, display_name: skill.displayName,
+      native_scope: skill.nativeScope } : {}),
   })));
 
   return requestJson<SyncPushResponse>(`${serverUrl}/portal_skills/sync-push`, jwt, {
     body: {
+      skill_sync_protocol: 2,
       skills: payloadSkills,
     },
   });
 }
 
 export async function downloadSkillBundle(bundleUrl: string): Promise<Buffer> {
-  const response = await fetch(bundleUrl);
+  const response = await fetch(bundleUrl, { signal: AbortSignal.timeout(90_000) });
   if (!response.ok) {
     const text = await response.text();
     throw new Error(`GET ${bundleUrl} → ${response.status}: ${text}`);
@@ -72,13 +80,30 @@ export async function updateAgentTargets(
   serverUrl: string,
   jwt: string,
   skillId: string,
-  targets: AgentTargets,
-): Promise<{ success: boolean; agent_targets: AgentTargets }> {
-  return requestJson<{ success: boolean; agent_targets: AgentTargets }>(`${serverUrl}/portal_skills/agent-targets`, jwt, {
+  targets: Partial<AgentTargets>,
+  expectedUpdatedAt?: string,
+  native?: { reference: NativeSkillReference; settingsRevision: number },
+): Promise<{ success: boolean; agent_targets: AgentTargets; updated_at?: string }> {
+  if (native) {
+    checkedNativeReference(native.reference, skillId);
+    if (!Number.isSafeInteger(native.settingsRevision) || native.settingsRevision < 0) throw new Error('Refresh native Skill settings before changing assignments.');
+    const payload = { operation: 'update', target: { skill_id: skillId, access_revision: native.reference.access_revision },
+      revision: native.settingsRevision, patch: { agent_targets: Object.fromEntries(Object.entries(targets).sort(([a], [b]) => a.localeCompare(b))) } };
+    const requestId = 'sync-settings-' + createHash('sha256').update(JSON.stringify(payload)).digest('hex');
+    const saved = await requestJson<{ receipt_id: string; skill_id: string; target: { skill_id: string }; settings: { agent_targets: AgentTargets; updated_at: string };
+      current?: { target: { skill_id: string }; settings: { agent_targets: AgentTargets; updated_at: string } } }>(`${serverUrl}/portal_skills/native-settings`, jwt,
+      { body: { ...payload, request_id: requestId } });
+    const current = saved.current || saved;
+    if (saved.skill_id !== skillId || typeof saved.receipt_id !== 'string' || !saved.receipt_id
+        || current.target?.skill_id !== skillId || !current.settings) throw new Error('Native assignment update was not confirmed.');
+    return { success: true, agent_targets: current.settings.agent_targets, updated_at: current.settings.updated_at };
+  }
+  return requestJson<{ success: boolean; agent_targets: AgentTargets; updated_at?: string }>(`${serverUrl}/portal_skills/agent-targets`, jwt, {
     method: 'PATCH',
     body: {
       skill_id: skillId,
       agent_targets: targets,
+      ...(expectedUpdatedAt ? { expected_updated_at: expectedUpdatedAt } : {}),
     },
   });
 }