@notis_ai/cli 0.2.0-beta.161.1 → 0.2.0-beta.164.1

package/dist/skill-sync-worker.mjs

@@ -2365,11 +2365,24 @@ async function syncSymlinks(skills, skillsDir = LEGACY_AGENTS_SKILLS_DIR, option
   }
   return result;
 }
-function getPushCandidates(localSkills, syncState, cloudCuratedSkillNames = /* @__PURE__ */ new Set(), cloudSkillNames) {
+function selectCloudSkillsToApply(skills) {
+  const winners = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    const current = winners.get(skill.name);
+    if (!current || (skill.updated_at || "") >= (current.updated_at || "")) {
+      winners.set(skill.name, skill);
+    }
+  }
+  return [...winners.values()];
+}
+function getPushCandidates(localSkills, syncState, cloudCuratedSkillNames = /* @__PURE__ */ new Set(), cloudSkillNames, cloudAppOwnedSkillNames = /* @__PURE__ */ new Set()) {
   return localSkills.filter((skill) => {
     if (cloudCuratedSkillNames.has(skill.name)) {
       return false;
     }
+    if (cloudAppOwnedSkillNames.has(skill.name)) {
+      return false;
+    }
     const previous = syncState.skills[skill.name];
     if (!previous) {
       return true;
@@ -2482,17 +2495,28 @@ function shouldWriteCloudSkill(cloudSkill, localSkills, previousState) {
   }
   const previous = previousState.skills[skillName];
   if (previous?.folderHash === localSkill.folderHash && previous.cloudContentHash === cloudContentHash(cloudSkill)) return false;
+  if (previous && previous.cloudContentHash === void 0 && previous.cloudId === cloudSkill.id && previous.appliedCloudFolderHash !== void 0 && previous.appliedCloudFolderHash === cloudHash && previous.cloudUpdatedAt === cloudSkill.updated_at && previous.folderHash === localSkill.folderHash) {
+    return false;
+  }
   if (cloudSkill.source === "curated") {
     return cloudHash ? cloudHash !== localSkill.folderHash : true;
   }
   const localChangedSinceLastSync = !previous || previous.folderHash !== localSkill.folderHash;
   return !localChangedSinceLastSync && (Boolean(cloudHash) && cloudHash !== localSkill.folderHash || Boolean(previous?.cloudContentHash && previous.cloudContentHash !== cloudContentHash(cloudSkill)));
 }
-function buildSyncState(pullResponse, localSkills, lastSyncedAt, verifiedAgentLinks = {}, failedContentNames = /* @__PURE__ */ new Set()) {
+function collectAppliedCloudRevisions(pullResponse, previousState, writtenSkillNames) {
+  const applied = {};
+  for (const skill of selectCloudSkillsToApply(pullResponse.skills)) {
+    applied[skill.name] = writtenSkillNames.has(skill.name) ? skill.skill_folder_hash || "" : previousState.skills[skill.name]?.appliedCloudFolderHash;
+  }
+  return applied;
+}
+function buildSyncState(pullResponse, localSkills, lastSyncedAt, verifiedAgentLinks = {}, failedContentNames = /* @__PURE__ */ new Set(), appliedRevisions = {}) {
   const localSkillMap = toSkillMap(localSkills);
   const skills = Object.fromEntries(
-    pullResponse.skills.map((skill) => {
+    selectCloudSkillsToApply(pullResponse.skills).map((skill) => {
       const localSkill = localSkillMap.get(skill.name);
+      const appliedCloudFolderHash = appliedRevisions[skill.name];
       return [
         skill.name,
         {
@@ -2502,6 +2526,7 @@ function buildSyncState(pullResponse, localSkills, lastSyncedAt, verifiedAgentLi
           verifiedAgentLinks: skill.status === "active" ? verifiedAgentLinks[skill.name] ?? {} : {},
           cloudUpdatedAt: skill.updated_at,
           ...!failedContentNames.has(skill.name) && !skill.skill_source_url ? { cloudContentHash: cloudContentHash(skill) } : {},
+          ...appliedCloudFolderHash !== void 0 ? { appliedCloudFolderHash } : {},
           syncedAt: lastSyncedAt || (/* @__PURE__ */ new Date()).toISOString()
         }
       ];
@@ -2563,7 +2588,7 @@ async function writePulledSkillsToScopedMirror(pullResponse, localSkills, previo
     console.warn(`[Notis] ${message}`, error);
   };
   let downloaded = 0;
-  for (const cloudSkill of pullResponse.skills) {
+  for (const cloudSkill of selectCloudSkillsToApply(pullResponse.skills)) {
     if (!shouldWriteCloudSkill(cloudSkill, localSkillMap, previousState)) {
       continue;
     }
@@ -2718,7 +2743,8 @@ async function runSkillSync(serverUrl, jwt, dependencies = {}, options = {}) {
     localSkills,
     previousState,
     cloudCuratedSkillNames,
-    new Set(pullResponse.skills.map((skill) => skill.name))
+    new Set(pullResponse.skills.map((skill) => skill.name)),
+    new Set(pullResponse.skills.filter((skill) => skill.owner_app_id).map((skill) => skill.name))
   );
   const failedPushes = [];
   if (pushCandidates.length > 0) {
@@ -2742,13 +2768,15 @@ async function runSkillSync(serverUrl, jwt, dependencies = {}, options = {}) {
     }
   }
   const failedDownloads = [];
+  const writtenSkillNames = /* @__PURE__ */ new Set();
   const downloaded = await writePulledSkillsToScopedMirror(
     pullResponse,
     localSkills,
     previousState,
     syncPaths,
     deps,
-    failedDownloads
+    failedDownloads,
+    writtenSkillNames
   );
   const finalLocalSkills = (await deps.scanLocalSkills(syncPaths)).filter((skill) => !BASE_SKILL_NAMES.has(skill.name));
   const symlinkResult = await deps.syncSymlinks(
@@ -2759,7 +2787,14 @@ async function runSkillSync(serverUrl, jwt, dependencies = {}, options = {}) {
   for (const failure of failedDownloads) delete verifiedLinks[failure.name];
   const lastSyncedAt = pullResponse.last_synced_at || (/* @__PURE__ */ new Date()).toISOString();
   await deps.writeSyncState(
-    buildSyncState(pullResponse, finalLocalSkills, lastSyncedAt, verifiedLinks, new Set(failedDownloads.map((item) => item.name))),
+    buildSyncState(
+      pullResponse,
+      finalLocalSkills,
+      lastSyncedAt,
+      verifiedLinks,
+      new Set(failedDownloads.map((item) => item.name)),
+      collectAppliedCloudRevisions(pullResponse, previousState, writtenSkillNames)
+    ),
     syncPaths
   );
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@notis_ai/cli",
-  "version": "0.2.0-beta.161.1",
+  "version": "0.2.0-beta.164.1",
   "description": "Agent-first Notis CLI for apps and generic tool execution",
   "type": "module",
   "bin": {

package/src/runtime/app-platform.js

@@ -126,12 +126,12 @@ export function resolveBuiltBundleDir(projectDir) {
 
 function normalizeShadowScopedCss(css) {
   return css
-    // Tailwind preflight emits `html,:host` in v3. Inside a shadow tree we want
-    // the shadow host itself to carry those defaults.
-    .replace(/html\s*,\s*:host\s*\{/g, ':host{')
-    .replace(/:root\s*,\s*:host\s*\{/g, ':host{')
-    .replace(/:root\s*\{/g, ':host{')
-    .replace(/html\s*\{/g, ':host{')
+    // Keep defaults on both the Portal shadow host and the app root used
+    // by the standalone harness. Removing :root erases Tailwind v4 theme
+    // variables in previews, collapsing spacing, type sizes and controls.
+    .replace(/(?:html|:root)\s*,\s*:host\s*\{/g, '[data-notis-app-root],:host{')
+    .replace(/:root\s*\{/g, '[data-notis-app-root],:host{')
+    .replace(/html\s*\{/g, '[data-notis-app-root],:host{')
     // Shadow trees do not contain a body element. Route those defaults to the
     // app root contract instead so authors still get the expected reset.
     .replace(/body\s*\{/g, '[data-notis-app-root]{');

package/src/runtime/oauth.js

@@ -407,7 +407,7 @@ function connectedCallbackHtml({ portalOrigin }) {
           <button class="button button-primary" id="download-desktop" type="button">Download Notis Desktop</button>
           <a class="button" href="${escapeHtml(webAppUrl)}">Open Web App</a>
         </div>
-        <p class="helper">The CLI stays connected even if you continue in the web app.</p>
+        <p class="helper">Desktop is available for macOS and Windows. The CLI stays connected even if you continue in the web app.</p>
       </section>
       <section class="next-step" id="desktop-ready-view" aria-labelledby="desktop-ready-title" hidden>
         <div class="status"><span class="status-dot"></span> Download started</div>
@@ -433,7 +433,6 @@ function connectedCallbackHtml({ portalOrigin }) {
         const resolveDownload = async () => {
           const ua = navigator.userAgent || '';
           if (/Windows/i.test(ua)) return downloads.base + '/win32/x64/notis-x64.exe';
-          if (/Linux/i.test(ua) && !/Android/i.test(ua)) return downloads.base + '/linux/x64/notis-linux-x64.zip';
           if (/Macintosh|Mac OS X/i.test(ua)) {
             let architecture = '';
             try {
@@ -450,6 +449,7 @@ function connectedCallbackHtml({ portalOrigin }) {
         const startDownload = async () => {
           const downloadUrl = await resolveDownload();
           window.open(downloadUrl, '_blank', 'noopener,noreferrer');
+          if (downloadUrl === downloads.fallback) return;
           connectedView.hidden = true;
           readyView.hidden = false;
           document.title = 'Quick login to Notis Desktop';

package/src/runtime/skill-sync/index.ts

@@ -32,7 +32,7 @@ import {
   syncSymlinks,
   type DeletedAgentSymlink,
 } from "./symlink-manager";
-import { getPushCandidates } from "./sync-plan";
+import { getPushCandidates, selectCloudSkillsToApply } from "./sync-plan";
 import { writeCloudSkillWithBundleFallback } from "./write-cloud-skill";
 export { fetchSyncSettings } from './cloud-client';
 
@@ -179,6 +179,24 @@ export function shouldWriteCloudSkill(
   if (previous?.folderHash === localSkill.folderHash
     && previous.cloudContentHash === cloudContentHash(cloudSkill)) return false;
 
+  // Without a stored content baseline (skills served through a signed source URL keep
+  // none, because that URL changes on every pull) the only other signal is
+  // `skill_folder_hash`, which the server does NOT always compute the way the local
+  // folder hash is computed. An app-published skill hashes its bundle entries, so that
+  // value can never equal the hash of the extracted directory, and comparing the two
+  // replaced the folder on every sync tick, deleting whatever a running skill had
+  // written inside it. Compare cloud against cloud instead: rewrite when the cloud
+  // revision we last applied has actually moved.
+  if (previous
+    && previous.cloudContentHash === undefined
+    && previous.cloudId === cloudSkill.id
+    && previous.appliedCloudFolderHash !== undefined
+    && previous.appliedCloudFolderHash === cloudHash
+    && previous.cloudUpdatedAt === cloudSkill.updated_at
+    && previous.folderHash === localSkill.folderHash) {
+    return false;
+  }
+
   if (cloudSkill.source === "curated") {
     return cloudHash ? cloudHash !== localSkill.folderHash : true;
   }
@@ -192,17 +210,42 @@ export function shouldWriteCloudSkill(
   );
 }
 
+type AppliedCloudRevisions = Record<string, string | undefined>;
+
+/**
+ * The cloud revision each folder's last successful write applied: this run's revision
+ * for the skills we just wrote, the previously recorded one otherwise. A failed write
+ * records nothing, so the next sync retries it.
+ */
+function collectAppliedCloudRevisions(
+  pullResponse: SyncPullResponse,
+  previousState: NotisSyncState,
+  writtenSkillNames: ReadonlySet<string>,
+): AppliedCloudRevisions {
+  const applied: AppliedCloudRevisions = {};
+  for (const skill of selectCloudSkillsToApply(pullResponse.skills)) {
+    applied[skill.name] = writtenSkillNames.has(skill.name)
+      ? skill.skill_folder_hash || ""
+      : previousState.skills[skill.name]?.appliedCloudFolderHash;
+  }
+  return applied;
+}
+
 function buildSyncState(
   pullResponse: SyncPullResponse,
   localSkills: LocalSkill[],
   lastSyncedAt: string | null,
   verifiedAgentLinks: Record<string, Partial<AgentTargets>> = {},
   failedContentNames: ReadonlySet<string> = new Set(),
+  appliedRevisions: AppliedCloudRevisions = {},
 ): NotisSyncState {
   const localSkillMap = toSkillMap(localSkills);
+  // The same row selection the writer used, so the state describes the revision that
+  // is actually on disk rather than whichever duplicate row the server listed last.
   const skills = Object.fromEntries(
-    pullResponse.skills.map((skill) => {
+    selectCloudSkillsToApply(pullResponse.skills).map((skill) => {
       const localSkill = localSkillMap.get(skill.name);
+      const appliedCloudFolderHash = appliedRevisions[skill.name];
       return [
         skill.name,
         {
@@ -213,6 +256,7 @@ function buildSyncState(
           cloudUpdatedAt: skill.updated_at,
           ...(!failedContentNames.has(skill.name) && !skill.skill_source_url
             ? { cloudContentHash: cloudContentHash(skill) } : {}),
+          ...(appliedCloudFolderHash !== undefined ? { appliedCloudFolderHash } : {}),
           syncedAt: lastSyncedAt || new Date().toISOString(),
         },
       ];
@@ -305,7 +349,7 @@ async function writePulledSkillsToScopedMirror(
   };
 
   let downloaded = 0;
-  for (const cloudSkill of pullResponse.skills) {
+  for (const cloudSkill of selectCloudSkillsToApply(pullResponse.skills)) {
     if (!shouldWriteCloudSkill(cloudSkill, localSkillMap, previousState)) {
       continue;
     }
@@ -420,6 +464,7 @@ export async function materializeCloudSkillsForLocalShell(
   const materializedState = buildSyncState(
     pullResponse, finalLocalSkills, lastSyncedAt, verifiedLinks,
     new Set(failedDownloads.map(item => item.name)),
+    collectAppliedCloudRevisions(pullResponse, previousState, writtenSkillNames),
   );
   // Pull-only refresh is not an upload acknowledgement. Keep content baselines
   // unless we actually wrote cloud content, and retain cloud-missing entries so
@@ -626,6 +671,7 @@ export async function runSkillSync(
     previousState,
     cloudCuratedSkillNames,
     new Set(pullResponse.skills.map((skill) => skill.name)),
+    new Set(pullResponse.skills.filter((skill) => skill.owner_app_id).map((skill) => skill.name)),
   );
 
   const failedPushes: SkillSyncFailure[] = [];
@@ -654,6 +700,7 @@ export async function runSkillSync(
   }
 
   const failedDownloads: SkillSyncFailure[] = [];
+  const writtenSkillNames = new Set<string>();
   const downloaded = await writePulledSkillsToScopedMirror(
     pullResponse,
     localSkills,
@@ -661,6 +708,7 @@ export async function runSkillSync(
     syncPaths,
     deps,
     failedDownloads,
+    writtenSkillNames,
   );
 
   const finalLocalSkills = (await deps.scanLocalSkills(syncPaths))
@@ -674,7 +722,14 @@ export async function runSkillSync(
   const lastSyncedAt = pullResponse.last_synced_at || new Date().toISOString();
 
   await deps.writeSyncState(
-    buildSyncState(pullResponse, finalLocalSkills, lastSyncedAt, verifiedLinks, new Set(failedDownloads.map(item => item.name))),
+    buildSyncState(
+      pullResponse,
+      finalLocalSkills,
+      lastSyncedAt,
+      verifiedLinks,
+      new Set(failedDownloads.map(item => item.name)),
+      collectAppliedCloudRevisions(pullResponse, previousState, writtenSkillNames),
+    ),
     syncPaths,
   );
 

package/src/runtime/skill-sync/sync-plan.ts

@@ -1,15 +1,40 @@
-import type { LocalSkill, NotisSyncState } from "./types";
+import type { CloudSkill, LocalSkill, NotisSyncState } from "./types";
+
+/**
+ * One cloud row per local folder. Several active rows can carry the same skill name
+ * (an app's source skill plus its installed clone, or duplicates created by earlier
+ * pushes), and every one of them writes to the same directory. Applying them all in
+ * one pass replaced that directory several times per sync and left whichever row came
+ * last on disk. The newest revision wins, deterministically.
+ */
+export function selectCloudSkillsToApply(skills: CloudSkill[]): CloudSkill[] {
+  const winners = new Map<string, CloudSkill>();
+  for (const skill of skills) {
+    const current = winners.get(skill.name);
+    if (!current || (skill.updated_at || "") >= (current.updated_at || "")) {
+      winners.set(skill.name, skill);
+    }
+  }
+  return [...winners.values()];
+}
 
 export function getPushCandidates(
   localSkills: LocalSkill[],
   syncState: NotisSyncState,
   cloudCuratedSkillNames: ReadonlySet<string> = new Set(),
   cloudSkillNames?: ReadonlySet<string>,
+  cloudAppOwnedSkillNames: ReadonlySet<string> = new Set(),
 ): LocalSkill[] {
   return localSkills.filter((skill) => {
     if (cloudCuratedSkillNames.has(skill.name)) {
       return false;
     }
+    // App-owned content belongs to the installed app's release, not to this account.
+    // Pushing it created a second row with the same name on every local difference,
+    // and each new row then fought over the same folder.
+    if (cloudAppOwnedSkillNames.has(skill.name)) {
+      return false;
+    }
     const previous = syncState.skills[skill.name];
     if (!previous) {
       return true;

package/src/runtime/skill-sync/types.ts

@@ -14,6 +14,11 @@ export interface SyncedSkill {
   cloudUpdatedAt?: string;
   /** Content accepted on disk; independent of server-specific folder hash formats. */
   cloudContentHash?: string;
+  /** `skill_folder_hash` of the cloud revision a successful write actually applied.
+   * The server may compute that hash with a different construction than the local
+   * folder hash (app-published skills do), so only cloud-to-cloud comparison tells
+   * "the cloud moved" apart from "the two sides hash differently". */
+  appliedCloudFolderHash?: string;
   syncedAt: string;
 }
 
@@ -49,6 +54,9 @@ export interface CloudSkill {
   skill_source_url?: string | null;
   bundle_files?: BundleFile[] | null;
   bundle_hydration_failed?: boolean | null;
+  /** Set when the skill's content is owned by an installed Notis app. Its folder is
+   * republished by the app, never by a local push. */
+  owner_app_id?: string | null;
   source: string;
   status: string;
 }

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

@@ -99,7 +99,7 @@
 </head>
 <body>
   <div id="harness-status">harness: booting</div>
-  <div id="root"></div>
+  <div id="root" data-notis-app-root></div>
   <script type="module">
     const routeExport = {{ROUTE_EXPORT}};
     const descriptor = {{RUNTIME_DESCRIPTOR}};