@phnx-labs/agents-cli 1.20.8 → 1.20.10

package/dist/lib/log-follow.js

@@ -0,0 +1,65 @@
+/**
+ * Cross-platform `tail -f`.
+ *
+ * Replaces spawning the POSIX `tail` binary (absent on Windows) with a poll-based
+ * follower that behaves identically on every platform and needs no external
+ * dependency. Reads bytes appended since the last position every `intervalMs`;
+ * resets to 0 if the file shrinks (truncation / log rotation). The active timer
+ * keeps the event loop alive, so callers just register a SIGINT handler that
+ * calls the returned stop().
+ */
+import * as fs from 'fs';
+export function followFile(filePath, onChunk, opts = {}) {
+    const intervalMs = opts.intervalMs ?? 500;
+    let pos = 0;
+    if (opts.fromEnd) {
+        try {
+            pos = fs.statSync(filePath).size;
+        }
+        catch {
+            pos = 0;
+        }
+    }
+    else {
+        try {
+            const initial = fs.readFileSync(filePath);
+            if (initial.length > 0)
+                onChunk(initial.toString('utf-8'));
+            pos = initial.length;
+        }
+        catch { /* file may not exist yet — start at 0 and wait for it to appear */ }
+    }
+    const poll = () => {
+        let size;
+        try {
+            size = fs.statSync(filePath).size;
+        }
+        catch {
+            return; /* gone / not yet created */
+        }
+        if (size < pos)
+            pos = 0; // truncated or rotated — re-read from the top
+        if (size <= pos)
+            return;
+        let fd;
+        try {
+            fd = fs.openSync(filePath, 'r');
+            const buf = Buffer.alloc(size - pos);
+            const bytes = fs.readSync(fd, buf, 0, buf.length, pos);
+            pos += bytes;
+            if (bytes > 0)
+                onChunk(buf.subarray(0, bytes).toString('utf-8'));
+        }
+        catch { /* transient read error — retry next tick */ }
+        finally {
+            if (fd !== undefined) {
+                try {
+                    fs.closeSync(fd);
+                }
+                catch { /* noop */ }
+            }
+        }
+    };
+    const timer = setInterval(poll, intervalMs);
+    return () => clearInterval(timer);
+}

package/dist/lib/platform/index.d.ts

@@ -18,3 +18,4 @@ export declare const IS_LINUX: boolean;
 export * from './paths.js';
 export * from './exec.js';
 export * from './process.js';
+export * from './ipc.js';

package/dist/lib/platform/index.js

@@ -18,3 +18,4 @@ export const IS_LINUX = process.platform === 'linux';
 export * from './paths.js';
 export * from './exec.js';
 export * from './process.js';
+export * from './ipc.js';

package/dist/lib/platform/ipc.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Resolve the address a local daemon listens on / clients connect to.
+ *
+ * POSIX: the AF_UNIX socket file path itself.
+ * Windows: a named pipe (`\\.\pipe\agents-<hash>`). Filesystem socket files
+ * aren't supported there, and named pipes are NOT filesystem objects — derive a
+ * stable name from a hash of the socket path so client and server agree without
+ * touching disk, and never probe the result with fs.existsSync (it always reports
+ * false). Both forms are accepted by net.createServer / net.createConnection.
+ */
+export declare function ipcEndpoint(socketPath: string, platform?: NodeJS.Platform): string;

package/dist/lib/platform/ipc.js

@@ -0,0 +1,21 @@
+/**
+ * Local-daemon IPC endpoint, platform-aware.
+ */
+import * as crypto from 'crypto';
+/**
+ * Resolve the address a local daemon listens on / clients connect to.
+ *
+ * POSIX: the AF_UNIX socket file path itself.
+ * Windows: a named pipe (`\\.\pipe\agents-<hash>`). Filesystem socket files
+ * aren't supported there, and named pipes are NOT filesystem objects — derive a
+ * stable name from a hash of the socket path so client and server agree without
+ * touching disk, and never probe the result with fs.existsSync (it always reports
+ * false). Both forms are accepted by net.createServer / net.createConnection.
+ */
+export function ipcEndpoint(socketPath, platform = process.platform) {
+    if (platform === 'win32') {
+        const hash = crypto.createHash('sha1').update(socketPath).digest('hex').slice(0, 16);
+        return `\\\\.\\pipe\\agents-${hash}`;
+    }
+    return socketPath;
+}

package/dist/lib/platform/paths.d.ts

@@ -20,3 +20,10 @@ export declare function toComparablePath(p: string, platform?: NodeJS.Platform):
  * correctly on all three platforms.
  */
 export declare function homeDir(): string;
+/**
+ * Is this a Windows absolute path — a drive-letter root (`C:\`, `C:/`) or a UNC
+ * share (`\\server\share`)? Used by local-source parsing to recognize a native
+ * Windows path that the POSIX `/`, `./`, `../` prefixes miss. Caller decides
+ * whether to apply it (typically gated on win32).
+ */
+export declare function isWindowsAbsolutePath(p: string): boolean;

package/dist/lib/platform/paths.js

@@ -47,3 +47,12 @@ export function toComparablePath(p, platform = process.platform) {
 export function homeDir() {
     return os.homedir();
 }
+/**
+ * Is this a Windows absolute path — a drive-letter root (`C:\`, `C:/`) or a UNC
+ * share (`\\server\share`)? Used by local-source parsing to recognize a native
+ * Windows path that the POSIX `/`, `./`, `../` prefixes miss. Caller decides
+ * whether to apply it (typically gated on win32).
+ */
+export function isWindowsAbsolutePath(p) {
+    return WIN_DRIVE_RE.test(p) || p.startsWith('\\\\');
+}

package/dist/lib/platform/process.d.ts

@@ -1,6 +1,14 @@
 /**
- * Process liveness / control, platform-aware.
+ * Forcefully terminate a process AND its descendant tree.
+ *
+ * Windows: `taskkill /F /T /PID` — the only reliable way to take down the whole
+ * tree (a bare TerminateProcess leaves children orphaned, which is exactly the
+ * "stop reported success but the tree is still alive" bug). POSIX: SIGKILL to the
+ * pid (matching the existing hard-kill behavior; callers that own a process group
+ * can pass the negative pid). Best-effort — never throws; an already-exited
+ * process counts as success.
  */
+export declare function killTree(pid: number): void;
 /**
  * Is a process with this PID currently alive?
  *

package/dist/lib/platform/process.js

@@ -1,6 +1,33 @@
 /**
  * Process liveness / control, platform-aware.
  */
+import { execFileSync } from 'child_process';
+/**
+ * Forcefully terminate a process AND its descendant tree.
+ *
+ * Windows: `taskkill /F /T /PID` — the only reliable way to take down the whole
+ * tree (a bare TerminateProcess leaves children orphaned, which is exactly the
+ * "stop reported success but the tree is still alive" bug). POSIX: SIGKILL to the
+ * pid (matching the existing hard-kill behavior; callers that own a process group
+ * can pass the negative pid). Best-effort — never throws; an already-exited
+ * process counts as success.
+ */
+export function killTree(pid) {
+    if (!pid || pid <= 0)
+        return;
+    if (process.platform === 'win32') {
+        try {
+            execFileSync('taskkill', ['/F', '/T', '/PID', String(pid)], { stdio: 'ignore' });
+        }
+        catch { /* already gone, or no such pid */ }
+    }
+    else {
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch { /* already gone */ }
+    }
+}
 /**
  * Is a process with this PID currently alive?
  *

package/dist/lib/plugins.js

@@ -12,6 +12,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { execFileSync } from 'child_process';
 import { getPluginsDir, getTrashPluginsDir, getExtraPluginsDir, getProjectPluginsDir } from './state.js';
+import { IS_WINDOWS, isWindowsAbsolutePath, homeDir } from './platform/index.js';
 import { listInstalledVersions, getVersionHomePath } from './versions.js';
 import { AGENTS, agentConfigDirName } from './agents.js';
 import { capableAgents, isCapable } from './capabilities.js';
@@ -1007,9 +1008,10 @@ export function parseInstallSpec(spec) {
 export async function installPlugin(spec) {
     const { name: specName, source } = parseInstallSpec(spec);
     // Resolve local path (handle ~)
-    const isLocalPath = source.startsWith('/') || source.startsWith('./') || source.startsWith('../') || source.startsWith('~');
+    const isLocalPath = source.startsWith('/') || source.startsWith('./') || source.startsWith('../') || source.startsWith('~')
+        || (IS_WINDOWS && isWindowsAbsolutePath(source));
     const resolvedSource = isLocalPath
-        ? source.replace(/^~/, process.env.HOME || '~')
+        ? source.replace(/^~/, homeDir())
         : source;
     const pluginsDir = getPluginsDir();
     fs.mkdirSync(pluginsDir, { recursive: true });
@@ -1085,7 +1087,7 @@ export async function updatePlugin(name) {
             execFileSync('git', ['-C', plugin.root, 'pull', '--ff-only'], { stdio: 'pipe' });
         }
         else {
-            const resolvedSource = sourceInfo.source.replace(/^~/, process.env.HOME || '~');
+            const resolvedSource = sourceInfo.source.replace(/^~/, homeDir());
             if (!fs.existsSync(resolvedSource)) {
                 return { success: false, error: `Source path no longer exists: ${resolvedSource}` };
             }

package/dist/lib/self-update.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Self-update install plumbing.
+ *
+ * The hard requirement: an upgrade must replace the copy that is currently
+ * running. A bare `npm install -g` writes into the global prefix of whatever
+ * `npm` PATH happens to resolve — on machines with more than one node
+ * installation (nvm + Homebrew + vendored runtimes) that prefix can belong to
+ * a different node than the one this copy lives under. The install then
+ * "succeeds" while the running copy stays stale and re-prompts forever.
+ *
+ * So every step here is anchored to the running package root on disk, never
+ * to PATH resolution.
+ */
+export declare const NPM_PACKAGE_NAME = "@phnx-labs/agents-cli";
+export interface UpdateCheckCache {
+    lastCheck: number;
+    latestVersion: string;
+    dismissed?: string;
+}
+/** Read the cached update-check state from disk. Returns null if the file is missing or corrupt. */
+export declare function readUpdateCache(file: string): UpdateCheckCache | null;
+/**
+ * Persist the latest known version and current timestamp. Preserves an
+ * existing `dismissed` marker — the background refresh must not erase a
+ * user's "Skip this version" choice, or they get re-prompted for the exact
+ * version they dismissed.
+ */
+export declare function saveUpdateCheck(file: string, latestVersion: string): void;
+/** Record that the user chose to skip `version`; suppresses prompts until a newer version appears. */
+export declare function dismissUpdateVersion(file: string, version: string): void;
+/** Whether the cached state warrants an upgrade prompt for a copy running `currentVersion`. */
+export declare function shouldPromptUpgrade(cache: UpdateCheckCache | null, currentVersion: string): boolean;
+/**
+ * Derive the npm global prefix that owns the install at `packageRoot`.
+ *
+ * npm's global layout for a scoped package:
+ *   POSIX:   <prefix>/lib/node_modules/@phnx-labs/agents-cli
+ *   Windows: <prefix>/node_modules/@phnx-labs/agents-cli
+ *
+ * Throws when `packageRoot` is not inside a node_modules tree (e.g. running
+ * from a source checkout) — there is no prefix to install into, and guessing
+ * one is exactly the bug this module exists to prevent.
+ */
+export declare function deriveGlobalPrefix(packageRoot: string): string;
+/**
+ * Install `spec` into an explicit global prefix. `--prefix` pins the
+ * destination no matter which npm binary PATH resolves. `--ignore-scripts`
+ * skips lifecycle scripts; the caller refreshes alias shims afterwards via
+ * refreshAliasShims().
+ */
+export declare function installPackageIntoPrefix(spec: string, prefix: string): Promise<void>;
+/** Read the version field of the package.json at `packageRoot`, fresh from disk. */
+export declare function readInstalledVersion(packageRoot: string): string;
+/**
+ * Assert that the install at `packageRoot` now carries `expectedVersion`.
+ * npm exiting 0 only proves it wrote *somewhere*; this proves it wrote *here*.
+ */
+export declare function verifyInstalledVersion(packageRoot: string, expectedVersion: string): void;
+/**
+ * Re-run the freshly installed copy's postinstall in shims-only mode so the
+ * bare-command aliases (secrets, sessions, ...) pick up the new entrypoint
+ * and any aliases added in the new version. Best-effort: a failure here
+ * leaves the previous shims in place, which still point at the (now
+ * upgraded) package root.
+ */
+export declare function refreshAliasShims(packageRoot: string): void;
+export interface AgentsCliInstall {
+    /** The PATH entry (`<dir>/agents`) that resolves to this install. */
+    binPath: string;
+    /** Package root containing package.json and dist/. */
+    packageRoot: string;
+    version: string;
+}
+/**
+ * Scan PATH for `agents` entrypoints and resolve each to the agents-cli
+ * package root it executes. More than one distinct root means upgrades,
+ * shims, and the command the user types can act on different copies — the
+ * divergence behind silently-failing self-updates.
+ *
+ * npm bin entries are symlinks that resolve to `<packageRoot>/dist/index.js`
+ * (the dev install's `~/.local/bin/agents` chains through the dev prefix to
+ * the same shape). Anything that doesn't resolve to a dist/index.js inside a
+ * package named @phnx-labs/agents-cli is some other tool and is skipped.
+ * POSIX-only: Windows npm bins are .cmd wrappers, not symlinks.
+ */
+export declare function findAgentsCliInstalls(pathEnv: string): AgentsCliInstall[];

package/dist/lib/self-update.js

@@ -0,0 +1,178 @@
+/**
+ * Self-update install plumbing.
+ *
+ * The hard requirement: an upgrade must replace the copy that is currently
+ * running. A bare `npm install -g` writes into the global prefix of whatever
+ * `npm` PATH happens to resolve — on machines with more than one node
+ * installation (nvm + Homebrew + vendored runtimes) that prefix can belong to
+ * a different node than the one this copy lives under. The install then
+ * "succeeds" while the running copy stays stale and re-prompts forever.
+ *
+ * So every step here is anchored to the running package root on disk, never
+ * to PATH resolution.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { spawnSync } from 'child_process';
+import { compareVersions } from './versions.js';
+export const NPM_PACKAGE_NAME = '@phnx-labs/agents-cli';
+/** Read the cached update-check state from disk. Returns null if the file is missing or corrupt. */
+export function readUpdateCache(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        /* cache file missing or corrupt */
+        return null;
+    }
+}
+/**
+ * Persist the latest known version and current timestamp. Preserves an
+ * existing `dismissed` marker — the background refresh must not erase a
+ * user's "Skip this version" choice, or they get re-prompted for the exact
+ * version they dismissed.
+ */
+export function saveUpdateCheck(file, latestVersion) {
+    try {
+        const dir = path.dirname(file);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        const dismissed = readUpdateCache(file)?.dismissed;
+        fs.writeFileSync(file, JSON.stringify({ lastCheck: Date.now(), latestVersion, ...(dismissed ? { dismissed } : {}) }));
+    }
+    catch {
+        /* best-effort cache update */
+    }
+}
+/** Record that the user chose to skip `version`; suppresses prompts until a newer version appears. */
+export function dismissUpdateVersion(file, version) {
+    try {
+        const dir = path.dirname(file);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        const existing = readUpdateCache(file);
+        fs.writeFileSync(file, JSON.stringify({
+            lastCheck: existing?.lastCheck ?? Date.now(),
+            latestVersion: version,
+            dismissed: version,
+        }));
+    }
+    catch {
+        /* best-effort */
+    }
+}
+/** Whether the cached state warrants an upgrade prompt for a copy running `currentVersion`. */
+export function shouldPromptUpgrade(cache, currentVersion) {
+    if (!cache?.latestVersion)
+        return false;
+    return (cache.latestVersion !== currentVersion &&
+        compareVersions(cache.latestVersion, currentVersion) > 0 &&
+        cache.latestVersion !== cache.dismissed);
+}
+/**
+ * Derive the npm global prefix that owns the install at `packageRoot`.
+ *
+ * npm's global layout for a scoped package:
+ *   POSIX:   <prefix>/lib/node_modules/@phnx-labs/agents-cli
+ *   Windows: <prefix>/node_modules/@phnx-labs/agents-cli
+ *
+ * Throws when `packageRoot` is not inside a node_modules tree (e.g. running
+ * from a source checkout) — there is no prefix to install into, and guessing
+ * one is exactly the bug this module exists to prevent.
+ */
+export function deriveGlobalPrefix(packageRoot) {
+    const resolved = path.resolve(packageRoot);
+    // Two levels up from the package root: the scope dir, then node_modules.
+    const nodeModulesDir = path.dirname(path.dirname(resolved));
+    if (path.basename(nodeModulesDir) !== 'node_modules') {
+        throw new Error(`${resolved} is not an npm-managed install; reinstall with: npm install -g ${NPM_PACKAGE_NAME}`);
+    }
+    const parent = path.dirname(nodeModulesDir);
+    return path.basename(parent) === 'lib' ? path.dirname(parent) : parent;
+}
+/**
+ * Install `spec` into an explicit global prefix. `--prefix` pins the
+ * destination no matter which npm binary PATH resolves. `--ignore-scripts`
+ * skips lifecycle scripts; the caller refreshes alias shims afterwards via
+ * refreshAliasShims().
+ */
+export async function installPackageIntoPrefix(spec, prefix) {
+    const { execFile } = await import('child_process');
+    const { promisify } = await import('util');
+    const execFileAsync = promisify(execFile);
+    await execFileAsync('npm', ['install', '-g', '--prefix', prefix, spec, '--ignore-scripts']);
+}
+/** Read the version field of the package.json at `packageRoot`, fresh from disk. */
+export function readInstalledVersion(packageRoot) {
+    return JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf-8')).version;
+}
+/**
+ * Assert that the install at `packageRoot` now carries `expectedVersion`.
+ * npm exiting 0 only proves it wrote *somewhere*; this proves it wrote *here*.
+ */
+export function verifyInstalledVersion(packageRoot, expectedVersion) {
+    const actual = readInstalledVersion(packageRoot);
+    if (actual !== expectedVersion) {
+        throw new Error(`npm reported success but ${packageRoot} is still ${actual} (expected ${expectedVersion}). ` +
+            `Run manually: npm install -g --prefix ${deriveGlobalPrefix(packageRoot)} ${NPM_PACKAGE_NAME}@${expectedVersion}`);
+    }
+}
+/**
+ * Re-run the freshly installed copy's postinstall in shims-only mode so the
+ * bare-command aliases (secrets, sessions, ...) pick up the new entrypoint
+ * and any aliases added in the new version. Best-effort: a failure here
+ * leaves the previous shims in place, which still point at the (now
+ * upgraded) package root.
+ */
+export function refreshAliasShims(packageRoot) {
+    spawnSync(process.execPath, [path.join(packageRoot, 'scripts', 'postinstall.js')], {
+        env: { ...process.env, AGENTS_POSTINSTALL_SHIMS_ONLY: '1' },
+        stdio: 'ignore',
+    });
+}
+/**
+ * Scan PATH for `agents` entrypoints and resolve each to the agents-cli
+ * package root it executes. More than one distinct root means upgrades,
+ * shims, and the command the user types can act on different copies — the
+ * divergence behind silently-failing self-updates.
+ *
+ * npm bin entries are symlinks that resolve to `<packageRoot>/dist/index.js`
+ * (the dev install's `~/.local/bin/agents` chains through the dev prefix to
+ * the same shape). Anything that doesn't resolve to a dist/index.js inside a
+ * package named @phnx-labs/agents-cli is some other tool and is skipped.
+ * POSIX-only: Windows npm bins are .cmd wrappers, not symlinks.
+ */
+export function findAgentsCliInstalls(pathEnv) {
+    if (process.platform === 'win32')
+        return [];
+    const installs = [];
+    const seenRoots = new Set();
+    for (const dir of pathEnv.split(path.delimiter).filter(Boolean)) {
+        const candidate = path.join(dir, 'agents');
+        let real;
+        try {
+            real = fs.realpathSync(candidate);
+        }
+        catch {
+            continue; // missing or dangling symlink
+        }
+        if (path.basename(real) !== 'index.js' || path.basename(path.dirname(real)) !== 'dist') {
+            continue;
+        }
+        const packageRoot = path.dirname(path.dirname(real));
+        if (seenRoots.has(packageRoot))
+            continue;
+        let pkg;
+        try {
+            pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf-8'));
+        }
+        catch {
+            continue;
+        }
+        if (pkg.name !== NPM_PACKAGE_NAME || typeof pkg.version !== 'string')
+            continue;
+        seenRoots.add(packageRoot);
+        installs.push({ binPath: candidate, packageRoot, version: pkg.version });
+    }
+    return installs;
+}

package/dist/lib/versions.js

@@ -777,9 +777,9 @@ export function parseAgentSpec(spec) {
     if (parts.length > 2) {
         return null;
     }
-    const agentName = parts[0].toLowerCase();
     const version = parts[1] || 'latest';
-    if (!AGENTS[agentName]) {
+    const agent = resolveAgentName(parts[0]);
+    if (!agent) {
         return null;
     }
     // Reject any version string that could escape an exec context or a
@@ -788,7 +788,7 @@ export function parseAgentSpec(spec) {
         return null;
     }
     return {
-        agent: agentName,
+        agent,
         version,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.8",
+  "version": "1.20.10",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",

package/scripts/postinstall.js

@@ -32,6 +32,35 @@ function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 
+// Shorthands that delegate to the installed agents-cli entrypoint.
+const ALIASES = ['sessions', 'secrets', 'browser', 'pty', 'teams'];
+
+function writeAliasShims() {
+  const written = [];
+  for (const name of ALIASES) {
+    const target = path.join(SHIMS_DIR, name);
+    const script = `#!/bin/sh\nAGENTS_BIN=${shellQuote(AGENTS_BIN)}\nif [ -z "$AGENTS_BIN" ] || [ ! -x "$AGENTS_BIN" ]; then\n  echo "agents: agents-cli entrypoint missing or not executable: $AGENTS_BIN" >&2\n  exit 127\nfi\nexec "$AGENTS_BIN" ${name} "$@"\n`;
+    fs.writeFileSync(target, script, { mode: 0o755 });
+    // Windows can't run the POSIX shim; drop a `.cmd` companion that invokes the
+    // entrypoint via node so the bare shorthand works in a Windows shell.
+    if (process.platform === 'win32') {
+      fs.writeFileSync(target + '.cmd', `@echo off\r\nnode "${AGENTS_BIN}" ${name} %*\r\n`);
+    }
+    written.push(name);
+  }
+  return written;
+}
+
+// Self-updater entry: the upgrade installs with --ignore-scripts (skipping
+// this script as an npm lifecycle hook), then re-invokes it with this env var
+// so the alias shims are refreshed from the newly installed copy. Shims only —
+// no prompts, no rc-file edits, no output.
+if (process.env.AGENTS_POSTINSTALL_SHIMS_ONLY === '1') {
+  fs.mkdirSync(SHIMS_DIR, { recursive: true });
+  writeAliasShims();
+  process.exit(0);
+}
+
 // For local installs, create directories and show a message
 const isGlobalInstall = process.env.npm_config_global || process.argv.includes('-g');
 if (!isGlobalInstall) {
@@ -86,25 +115,6 @@ const exportLine = shellName === 'fish'
   ? `fish_add_path ${SHIMS_DIR}`
   : `export PATH="${SHIMS_DIR}:$PATH"`;
 
-// Shorthands that delegate to the installed agents-cli entrypoint.
-const ALIASES = ['sessions', 'secrets', 'browser', 'pty', 'teams'];
-
-function writeAliasShims() {
-  const written = [];
-  for (const name of ALIASES) {
-    const target = path.join(SHIMS_DIR, name);
-    const script = `#!/bin/sh\nAGENTS_BIN=${shellQuote(AGENTS_BIN)}\nif [ -z "$AGENTS_BIN" ] || [ ! -x "$AGENTS_BIN" ]; then\n  echo "agents: agents-cli entrypoint missing or not executable: $AGENTS_BIN" >&2\n  exit 127\nfi\nexec "$AGENTS_BIN" ${name} "$@"\n`;
-    fs.writeFileSync(target, script, { mode: 0o755 });
-    // Windows can't run the POSIX shim; drop a `.cmd` companion that invokes the
-    // entrypoint via node so the bare shorthand works in a Windows shell.
-    if (process.platform === 'win32') {
-      fs.writeFileSync(target + '.cmd', `@echo off\r\nnode "${AGENTS_BIN}" ${name} %*\r\n`);
-    }
-    written.push(name);
-  }
-  return written;
-}
-
 function getVersion() {
   const pkgPath = new URL('../package.json', import.meta.url).pathname;
   try {