@phnx-labs/agents-cli 1.22.42 → 1.22.44

package/dist/lib/hosts/registry.js

@@ -24,7 +24,7 @@ import { normalizeHost } from '../machine-id.js';
 import { readMeta } from '../state.js';
 import { isSshConfigHost } from './ssh-config.js';
 import { resolveRemoteOsSync } from './remote-os.js';
-import { loadDevices, isControlDevice } from '../devices/registry.js';
+import { loadDevices } from '../devices/registry.js';
 import { resolveDeviceProfile } from '../devices/resolve-profile.js';
 import { isDeviceAuto, resolveDeviceAffinity } from '../smart-launch.js';
 import { localMachineId } from '../session/origin-machine.js';
@@ -148,7 +148,7 @@ function literalHost(token, host, user) {
  * all resolve the same way regardless of which subcommand called.
  *
  * Non-throwing: returns null on an injection-guard failure or an unresolved bare
- * token. Device-only refusals (control device, password auth) are NOT applied
+ * token. The device-only refusal (password auth) is NOT applied
  * here — that is the dispatch wrapper's job ({@link resolveHost}), so the fan-out
  * and `agents ssh` paths, which handle those cases differently, aren't forced
  * into a dispatch verdict.
@@ -240,8 +240,7 @@ export async function listAllHosts() {
  * caller consumes (`run --device`, the generic passthrough, teams placement, the
  * cloud host provider, doctor, funnel, remote secrets). Grammar and merge come
  * from {@link matchHost}; on top, this layer applies the device-only dispatch
- * refusals so they hold even when an inline overlay shadows the device:
- *   - a control device (a paired iPhone) can never be a dispatch target;
+ * refusal so it holds even when an inline overlay shadows the device:
  *   - a password-auth device throws the typed {@link DeviceOffloadUnsupportedError}
  *     (offload rides `BatchMode=yes` ssh, which can't answer a prompt);
  *   - an addressless device has nothing to dial.
@@ -254,9 +253,6 @@ export async function resolveHost(name) {
     if (!host)
         return null;
     if (host.device) {
-        if (isControlDevice(host.device)) {
-            throw new Error(`Device "${host.device.name}" is a control device (a cockpit), not an executor — it can't run agents. Dispatch to a worker device instead.`);
-        }
         if (host.device.auth.method === 'password') {
             throw new DeviceOffloadUnsupportedError(host.device.name);
         }

package/dist/lib/hosts/session-index.js

@@ -21,7 +21,7 @@ import { upsertSession } from '../session/db.js';
 import { isSessionTrackedAgent } from '../session/types.js';
 import { localLogPath, updateTask } from './tasks.js';
 import { parseSessionIdMarker } from './session-marker.js';
-import { deriveShortId } from '../session/short-id.js';
+import { deriveShortId } from '../text/short-id.js';
 import { normalizeHost } from '../machine-id.js';
 /**
  * Build the SessionMeta for a host-dispatched run. Returns null when the run has

package/dist/lib/installations/shims.js

@@ -2015,7 +2015,7 @@ export function pruneOrphanedCommandShim(fileName) {
         return false;
     }
     if (content.includes('# Alias shim:'))
-        return false; // a user `agents alias` — leave it
+        return false; // a user `agents setup alias` shim — leave it
     const bin = readAgentsBinFromShim(shimPath);
     if (!bin)
         return false; // not an AGENTS_BIN-baked shim

package/dist/lib/installations/versions.d.ts

@@ -230,6 +230,46 @@ export declare function printTrashFooter(moved: Array<{
  * containing only `home/`) remain under the agent dir.
  */
 export declare function removeAllVersions(agent: AgentId): number;
+export interface HealedVersionPointers {
+    /** Global default reassigned off a not-installed version (`to: null` = cleared). */
+    globalDefault?: {
+        from: string;
+        to: string | null;
+    };
+    /** Isolated default (bare `agents run <agent>`) reassigned off a not-installed version. */
+    isolatedDefault?: {
+        from: string;
+        to: string | null;
+    };
+    /** `~/.<agent>` config symlink repointed off a not-installed version. */
+    configSymlink?: {
+        from: string;
+        to: string;
+    };
+}
+/**
+ * Repoint an agent's version pointers — the global/isolated default and the
+ * `~/.<agent>` config symlink — off any version that is no longer installed, so
+ * neither `agents sync`/`agents run` resolution nor the conventional-path home
+ * can land on a dead version (RUSH-2471).
+ *
+ * How a pointer goes dangling: {@link removeVersion} reassigns the defaults and
+ * clears the config symlink only when IT removes the pointed-at version. A
+ * version-home whose launch binary disappears by any other route — grok
+ * self-updated its per-version binary out from under the old dir, a manual
+ * delete, a half-finished install that seeded the home but never landed the
+ * binary — leaves the default and/or the symlink pointing at something
+ * {@link isVersionInstalled} reports as gone.
+ *
+ * Called from the sync resolve path so the invariant self-heals. Mirrors
+ * {@link removeVersion}'s reassignment: the global default prefers the newest
+ * NON-isolated survivor else clears; the isolated default prefers the newest
+ * remaining isolated copy else clears. The symlink is repointed at the now-healed
+ * resolved default, else the newest installed non-isolated version. A symlink
+ * already on an installed version, a real (non-symlink) config dir, and an
+ * isolated-only agent are left untouched.
+ */
+export declare function healDanglingVersionPointers(agent: AgentId, cwd: string): Promise<HealedVersionPointers>;
 /**
  * Normalize a user-supplied @version token across CLI subcommands.
  *

package/dist/lib/installations/versions.js

@@ -32,9 +32,9 @@ import { VERSION_RE, compareVersions } from '../agent-spec/primitives.js';
 import { AGENTS, agentConfigDirName, getAccountEmail, resolveAgentName, formatAgentError, findInPath, isSelfUpdatingAgent, isAgentHardDeprecated, hardDeprecationError } from '../agents.js';
 import { discoverPermissionGroups, getActivePermissionPresetName, readPermissionPresetRecipe, PERMISSION_PRESET_ENV_VAR } from '../permissions.js';
 import { parseMcpConfigForScan, isProjectMcpTrusted } from '../mcp.js';
-import { createVersionedAlias, removeVersionedAlias, getConfigSymlinkVersion, ensureClaudeInsideSymlink, assertIsolationBoundary, } from './shims.js';
+import { createVersionedAlias, removeVersionedAlias, switchConfigSymlink, getConfigSymlinkVersion, ensureClaudeInsideSymlink, assertIsolationBoundary, isIsolationProtected, } from './shims.js';
 import { importInstallScriptBinary } from '../import.js';
-import { createInstallation, getBinaryPath, getCliVersionFromPath, getGlobalDefault, getIsolatedDefault, getLiveVersion, getVersionDir, getVersionHomePath, invalidateInstalledVersionsCache, invalidateLiveVersionCache, isGlobalBinaryAgent, isVersionInstalled, isVersionIsolated, listInstalledVersions, pickCanonicalGlobalBinaryVersion, } from './store.js';
+import { createInstallation, getBinaryPath, getCliVersionFromPath, getGlobalDefault, getIsolatedDefault, getLiveVersion, getVersionDir, getVersionHomePath, invalidateInstalledVersionsCache, invalidateLiveVersionCache, isGlobalBinaryAgent, isVersionInstalled, isVersionIsolated, listInstalledVersions, pickCanonicalGlobalBinaryVersion, resolveVersion, } from './store.js';
 export * from './store.js';
 import { INSTALLATION_RECORD_FILE } from './types.js';
 import { composeWin32CommandLine } from '../platform/index.js';
@@ -1745,6 +1745,61 @@ export function removeAllVersions(agent) {
     }
     return removed;
 }
+/**
+ * Repoint an agent's version pointers — the global/isolated default and the
+ * `~/.<agent>` config symlink — off any version that is no longer installed, so
+ * neither `agents sync`/`agents run` resolution nor the conventional-path home
+ * can land on a dead version (RUSH-2471).
+ *
+ * How a pointer goes dangling: {@link removeVersion} reassigns the defaults and
+ * clears the config symlink only when IT removes the pointed-at version. A
+ * version-home whose launch binary disappears by any other route — grok
+ * self-updated its per-version binary out from under the old dir, a manual
+ * delete, a half-finished install that seeded the home but never landed the
+ * binary — leaves the default and/or the symlink pointing at something
+ * {@link isVersionInstalled} reports as gone.
+ *
+ * Called from the sync resolve path so the invariant self-heals. Mirrors
+ * {@link removeVersion}'s reassignment: the global default prefers the newest
+ * NON-isolated survivor else clears; the isolated default prefers the newest
+ * remaining isolated copy else clears. The symlink is repointed at the now-healed
+ * resolved default, else the newest installed non-isolated version. A symlink
+ * already on an installed version, a real (non-symlink) config dir, and an
+ * isolated-only agent are left untouched.
+ */
+export async function healDanglingVersionPointers(agent, cwd) {
+    const healed = {};
+    const installed = listInstalledVersions(agent);
+    const globalDefault = getGlobalDefault(agent);
+    if (globalDefault !== null && !isVersionInstalled(agent, globalDefault)) {
+        const promotable = installed.filter((v) => !isVersionIsolated(agent, v));
+        const to = promotable.length > 0 ? promotable[promotable.length - 1] : undefined;
+        setGlobalDefault(agent, to);
+        healed.globalDefault = { from: globalDefault, to: to ?? null };
+    }
+    const isolatedDefault = getIsolatedDefault(agent);
+    if (isolatedDefault !== null && !isVersionInstalled(agent, isolatedDefault)) {
+        const survivors = installed.filter((v) => isVersionIsolated(agent, v));
+        const to = survivors.length > 0 ? survivors[survivors.length - 1] : undefined;
+        setIsolatedDefault(agent, to);
+        healed.isolatedDefault = { from: isolatedDefault, to: to ?? null };
+    }
+    const current = getConfigSymlinkVersion(agent);
+    const nonIsolated = installed.filter((v) => !isVersionIsolated(agent, v));
+    if (current !== null &&
+        !isVersionInstalled(agent, current) &&
+        !isIsolationProtected(agent) &&
+        nonIsolated.length > 0) {
+        const pinned = resolveVersion(agent, cwd);
+        const target = pinned && isVersionInstalled(agent, pinned) && !isVersionIsolated(agent, pinned)
+            ? pinned
+            : nonIsolated[nonIsolated.length - 1];
+        const result = await switchConfigSymlink(agent, target);
+        if (result.success)
+            healed.configSymlink = { from: current, to: target };
+    }
+    return healed;
+}
 /**
  * Normalize a user-supplied @version token across CLI subcommands.
  *
@@ -2436,6 +2491,10 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
     const commandsAlsoAsSkills = shouldAlsoInstallCommandAsSkill(agent, version);
     const commandsInstallAsSkills = commandsAsSkills || commandsAlsoAsSkills;
     let writtenCommands = [];
+    // Artifact paths the writers report (WriteResult.paths), persisted to the
+    // manifest as `writtenTargets` after a full sync so isStale can flag a
+    // deleted artifact as stale (#2398).
+    const writtenTargets = [];
     if (commandsToSync.length > 0 && commandsWriter) {
         // Agents that replace native command files with skills (codex >= 0.117.0,
         // kimi) must have their legacy command dir removed, or files written by an
@@ -2448,6 +2507,8 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
         }
         const r = commandsWriter.write({ version, versionHome, selection: commandsToSync, cwd });
         writtenCommands = r.synced;
+        if (r.paths)
+            writtenTargets.push(...r.paths);
         result.commands = r.synced.length > 0;
     }
     // Orphan-sweep stale top-level command files from previous syncs under a
@@ -2455,8 +2516,9 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
     // not pass an explicit `selection`. Callers that pass explicit selections
     // are using the incremental/additive API (sync exactly these; leave others
     // alone), so the sweep would be a contract violation there. The
-    // cross-project leak always comes from the no-selection shim auto-sync at
-    // launch.
+    // cross-project leak comes from no-selection full syncs run under different
+    // cwds (`agents sync` / `agents refresh`; the shim's `agents sync --launch`
+    // skips version-home reconciliation and never reaches this path).
     if (!userPassedSelection && commandsWriter && !shouldInstallCommandAsSkill(agent, version)) {
         const commandsTargetSweep = path.join(agentDir, agentConfig.commandsSubdir);
         if (fs.existsSync(commandsTargetSweep)) {
@@ -2515,6 +2577,8 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
     else if (skillsWriter) {
         if (skillsToSync.length > 0) {
             const r = skillsWriter.write({ version, versionHome, selection: skillsToSync, cwd });
+            if (r.paths)
+                writtenTargets.push(...r.paths);
             result.skills = r.synced.length > 0;
         }
         // Orphan-sweep stale skill directories from previous syncs under a
@@ -2570,6 +2634,8 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
                         }
                     }
                 }
+                if (r.paths)
+                    writtenTargets.push(...r.paths);
                 result.hooks = r.synced.length > 0;
                 hookManifest = selectHookManifest(parseHookManifest(), hooksToSync);
             }
@@ -2596,6 +2662,8 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
                 : null;
             const preset = overridePreset || activeRulesPreset() || getActiveRulesPreset(agent, version);
             const r = rulesWriter.write({ version, versionHome, selection: { preset }, cwd });
+            if (r.paths)
+                writtenTargets.push(...r.paths);
             result.memory.push(...r.synced);
             // rulesPreset is tracked separately via setActiveRulesPreset.
         }
@@ -2673,6 +2741,8 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
     const mcpToSync = mcpToSyncAll.filter(n => !untrustedProjectMcpNames.has(n));
     if (mcpToSync.length > 0 && mcpWriter) {
         const r = mcpWriter.write({ version, versionHome, selection: mcpToSync, cwd });
+        if (r.paths)
+            writtenTargets.push(...r.paths);
         result.mcp = r.synced;
         if (r.errors?.length)
             result.declined.push(...r.errors.map((e) => `mcp: ${e}`));
@@ -2694,6 +2764,8 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
     }
     if (subagentsToSync.length > 0 && subagentsWriter) {
         const r = subagentsWriter.write({ version, versionHome, selection: subagentsToSync, cwd });
+        if (r.paths)
+            writtenTargets.push(...r.paths);
         result.subagents.push(...r.synced);
         // Orphan-sweep for Claude only — see comment on commands/skills sweep
         // for the no-selection guard. OpenClaw stores subagents as siblings of
@@ -2800,6 +2872,8 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
         const previous = loadManifest(agent, version);
         const manifest = buildSyncManifest(agent, version, cwd, previous);
         manifest.writtenCommands = writtenCommands;
+        // Deduped + sorted so repeated full syncs write byte-identical manifests.
+        manifest.writtenTargets = Array.from(new Set(writtenTargets)).sort();
         saveManifest(agent, version, manifest);
     }
     return result;

package/dist/lib/menubar/MenubarHelper.app/Contents/Info.plist

@@ -7,11 +7,7 @@
     <key>CFBundleIdentifier</key>
     <string>com.phnx-labs.agents-menubar</string>
     <key>CFBundleName</key>
-    <string>AGI Menu</string>
-    <key>CFBundleDisplayName</key>
-    <string>AGI Menu</string>
-    <key>CFBundleIconFile</key>
-    <string>AppIcon</string>
+    <string>Agents Menu Bar</string>
     <key>CFBundlePackageType</key>
     <string>APPL</string>
     <key>CFBundleShortVersionString</key>

package/dist/lib/menubar/MenubarHelper.app/Contents/_CodeSignature/CodeResources

@@ -3,22 +3,9 @@
 <plist version="1.0">
 <dict>
 	<key>files</key>
-	<dict>
-		<key>Resources/AppIcon.icns</key>
-		<data>
-		jOjZVimcFRHoP2VPzgn8uM8mjkA=
-		</data>
-	</dict>
+	<dict/>
 	<key>files2</key>
-	<dict>
-		<key>Resources/AppIcon.icns</key>
-		<dict>
-			<key>hash2</key>
-			<data>
-			GFvSLeNYJ3ASxW3OzcuiB4aID0gZUBkpozmWZkbTFNw=
-			</data>
-		</dict>
-	</dict>
+	<dict/>
 	<key>rules</key>
 	<dict>
 		<key>^Resources/</key>

package/dist/lib/menubar/install-menubar.d.ts

@@ -75,6 +75,33 @@ export declare function generateServicePlist(execPath: string): string;
 export declare function restartMenubarLaunchAgent(uid: number, plist: string, exec?: (cmd: string, args: readonly string[], opts: {
     stdio: ['ignore', 'ignore', 'ignore'];
 }) => Buffer): void;
+/**
+ * Force a running helper off the binary that was just swapped underneath it.
+ *
+ * `installMenubarLaunchAgentOnUpgrade()` calls this after a heal actually
+ * replaces the on-disk bundle (a version bump or the ad-hoc -> Developer ID
+ * transition — see `menubarHealReplacedBundle`). `restartMenubarLaunchAgent`
+ * (run moments earlier via `installAndStartService`) already attempts
+ * bootout+bootstrap+kickstart, but that targets the GUI launchd domain and
+ * fails silently — `launchctl kickstart -k gui/<uid>/<label>` prints "Could not
+ * find service ... in domain for user gui" — from a shell with no Aqua session,
+ * which is the ordinary case for `agents` invoked from a terminal/tmux/ssh
+ * session rather than literally the login item (verified live). When that
+ * happens the plist and on-disk bundle are current but the LIVE process is
+ * still the old binary, so it requests Accessibility under the OLD code
+ * identity and the grant never sticks.
+ *
+ * `kickstart -k` (force-restart, unlike the bare kickstart already tried) is
+ * attempted first since it is the clean launchd-native path when it works. If
+ * launchd has no record of the service in this context either, fall back to
+ * ending the specific pid(s) already confirmed to be running the installed
+ * bundle (`ownProcesses`, resolved by the caller via `liveMenubarProcesses`) —
+ * never a broad pkill. The launchd plist has `KeepAlive=true`, so the ended
+ * process is relaunched from the swapped binary within seconds.
+ */
+export declare function restartMenubarHelperAfterSwap(uid: number, ownProcesses: readonly MenubarProcess[], exec?: (cmd: string, args: readonly string[], opts: {
+    stdio: ['ignore', 'ignore', 'ignore'];
+}) => Buffer, kill?: (pid: number) => void): void;
 /**
  * Install + start the menu-bar helper as a launchd user service (idempotent).
  * Clears the sticky opt-out, installs the .app, writes the plist, and
@@ -97,6 +124,23 @@ export declare function isMenubarStale(opts: {
     currentVersion: string;
     execExists: boolean;
 }): boolean;
+/**
+ * Pure decision (no I/O): did THIS heal actually replace bundle content a live
+ * process could be running stale, as opposed to a plist-only repoint?
+ *
+ * `stale` (version bump or missing exec) and `needsDevIdHeal` (ad-hoc ->
+ * Developer ID) both mean the shipped `.app` differs from what is already
+ * installed — the exact condition under which a running helper can be left on
+ * an old code identity after `enableMenubarService` swaps the bundle. A
+ * repoint-only heal (`menubarSetupNeedsRepoint()` alone, same version, same
+ * signing identity) does NOT count: RUSH-3005 already owns the churn from
+ * mixed-Node-interpreter repoints, and restarting the helper on every one of
+ * those would double that churn rather than fix this bug.
+ */
+export declare function menubarHealReplacedBundle(opts: {
+    stale: boolean;
+    needsDevIdHeal: boolean;
+}): boolean;
 /**
  * Pure re-point decision (no I/O): the plist's baked interpreter/entry no longer
  * match the install that is now running `agents`. This catches DUAL-INSTALL skew
@@ -110,6 +154,7 @@ export declare function isMenubarStale(opts: {
 export declare function menubarPlistNeedsRepoint(opts: {
     plistEntry: string | null;
     plistNode: string | null;
+    plistNodeExists: boolean;
     activeEntry: string | null;
     activeNode: string | null;
 }): boolean;
@@ -185,6 +230,31 @@ export declare function mayInstallMenubarHelper(opts: {
  * throws into startup.
  */
 export declare function installMenubarLaunchAgentOnUpgrade(): void;
+/**
+ * Pure decision (no I/O): run the one-time `tccutil reset Accessibility` only
+ * on a real ad-hoc -> Developer ID transition, and only once ever. A machine
+ * that was always Developer ID never accumulated a dead TCC row under an
+ * ad-hoc identity, so resetting there would just force a needless re-prompt;
+ * a machine that already migrated must not be reset again on every heal.
+ */
+export declare function shouldMigrateMenubarTcc(opts: {
+    needsDevIdHeal: boolean;
+    alreadyMigrated: boolean;
+}): boolean;
+/**
+ * Reset the stale Accessibility grant TCC recorded against the pre-migration
+ * ad-hoc identity, then stamp the marker so this never runs again on this
+ * machine. Targets `SERVICE_LABEL_BASE` — the bundle's actual
+ * `CFBundleIdentifier`/codesign `--identifier` (menubar/scripts/build.sh) that
+ * TCC keys grants to — not the namespaced `serviceLabel()`, which exists only
+ * to keep launchd job labels apart under a redirected HOME (RUSH-2639) and is
+ * never the app's real identity. Best-effort: a missing/failing `tccutil`
+ * (older macOS, a sandboxed test HOME) must never block the heal that just
+ * fixed the signing identity itself.
+ */
+export declare function resetMenubarAccessibilityTcc(exec?: (cmd: string, args: readonly string[], opts: {
+    stdio: ['ignore', 'ignore', 'ignore'];
+}) => Buffer): void;
 /** One step of `agents menubar setup`, and how it came out. */
 export interface SetupStep {
     /** What was configured. */
@@ -272,3 +342,42 @@ export interface MenubarStatus {
     disabledByUser: boolean;
 }
 export declare function getMenubarStatus(): MenubarStatus;
+/** Read-only diagnostic for `agents menubar doctor` — probes, never mutates. */
+export interface MenubarDoctorReport {
+    platform: string;
+    installPath: string | null;
+    installedVersion: string | null;
+    currentVersion: string;
+    versionMatches: boolean;
+    /** `unknown` on non-darwin or when nothing is installed to inspect. */
+    signingIdentity: 'developer-id' | 'ad-hoc' | 'unknown';
+    running: boolean;
+    /** A live helper pid started before the installed bundle's on-disk mtime —
+     *  it is running the binary that has since been swapped underneath it. */
+    staleRunningProcess: PidStaleness[];
+    /** Grant likely needs to be re-made: an ad-hoc identity breaks on every
+     *  update, or a live process is confirmed to predate the current bundle. */
+    accessibilityHintNeeded: boolean;
+}
+/** One live pid checked against the bundle's on-disk mtime. */
+export interface PidStaleness {
+    pid: number;
+    stale: boolean;
+}
+/**
+ * Pure comparison (no I/O) behind the stale-process check: a helper pid that
+ * started before the bundle on disk was last written is still running the
+ * PREVIOUS binary — the exact condition `restartMenubarHelperAfterSwap` exists
+ * to fix. Millisecond epoch timestamps in, so the truth table is unit-testable
+ * without a live process or filesystem.
+ */
+export declare function isMenubarProcessStaleAgainstBundle(pidStartedAtMs: number, bundleMtimeMs: number): boolean;
+/**
+ * `agents menubar doctor` — everything a human needs to tell "why did
+ * Accessibility ask again" apart from "the helper is genuinely broken":
+ * install path, version skew, whether the signing identity is update-stable,
+ * and whether a live process predates the bundle it's supposed to be running.
+ * Read-only: no install, no restart, no TCC reset — `agents menubar setup`
+ * remains the command that fixes what this reports.
+ */
+export declare function buildMenubarDoctorReport(): MenubarDoctorReport;