talentos 1.1.0 → 1.1.2

package/dist/commands/agent-serve.js

@@ -1,12 +1,16 @@
-import { spawn } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { dirname } from "node:path";
-import { childEnvironment, verifyClaudeCode } from "../agent/adapters.js";
+import { verifyClaudeCode, verifyCodex } from "../agent/adapters.js";
+import { AgentGateway, GatewayError } from "../agent/gateway.js";
 import { serveAgent } from "../agent/serve.js";
-import { agentWorkDir, localAgents } from "../agent-config.js";
-export async function runAgentServe(parsed) {
+import { agentWorkDir, localAgents, storeAgent, } from "../agent-config.js";
+import { AgentHttpError, fetchAgentStatus } from "../agent-http.js";
+import { installAgentService, uninstallAgentService, unloadLaunchAgent, } from "../agent-service.js";
+import { installSharedGateway } from "../gateway-install.js";
+import { ProviderBinaryError, resolveProviderBinary, } from "../provider-binary.js";
+export async function runAgentServe(parsed, options = {}) {
     const id = parsed.options.agent;
-    const agents = await localAgents();
+    const agents = await localAgents(options.home);
     let config = agents.find((agent) => agent.agentId === id);
     if (!id && agents.length === 1) {
         config = agents[0];
@@ -14,29 +18,79 @@ export async function runAgentServe(parsed) {
     if (!config) {
         throw new Error("Choose a linked agent with `talentos agent serve --agent <id>`.");
     }
-    if (config.provider === "claude_code") {
-        await verifyClaudeCode();
+    try {
+        if ((options.platform ?? process.platform) !== "win32") {
+            await installSharedGateway({ home: options.home });
+        }
+        await installAgentService(config, { ...options, reload: false });
     }
+    catch {
+        console.error("Gateway installation unavailable. Serving the loaded version; retry talentos agent repair when the installation is available.");
+    }
+    const agent = config;
     const stop = new AbortController();
     const abort = () => stop.abort();
     process.once("SIGTERM", abort);
     process.once("SIGINT", abort);
     const version = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version;
     try {
-        const updated = await serveAgent(config, dirname(agentWorkDir(config.agentId)), version, stop.signal);
-        if (updated && !stop.signal.aborted) {
-            await new Promise((resolve, reject) => {
-                const child = spawn(process.execPath, [updated, "agent", "serve", "--agent", config.agentId], { env: childEnvironment(), stdio: "inherit", signal: stop.signal });
-                child.once("error", () => reject(new Error("Updated gateway could not start.")));
-                child.once("close", (code) => {
-                    process.exitCode = code ?? 1;
-                    resolve();
-                });
-            });
+        // Authenticate without publishing presence, including when the binary is gone.
+        await fetchAgentStatus(config);
+        await serveAgent(config, dirname(agentWorkDir(config.agentId, options.home)), version, stop.signal, () => verifyAgent(agent, options));
+    }
+    catch (error) {
+        if ((error instanceof GatewayError || error instanceof AgentHttpError) &&
+            (error.status === 401 || error.status === 410)) {
+            await uninstallAgentService(config, options);
+            console.error("Agent access ended. Removed this agent's local service; link it again from TalentOS to reconnect.");
+            return;
         }
+        throw error;
     }
     finally {
         process.removeListener("SIGTERM", abort);
         process.removeListener("SIGINT", abort);
     }
 }
+async function verifyAgent(config, options) {
+    try {
+        let binary;
+        try {
+            binary = resolveProviderBinary(config.provider, config.providerPath);
+        }
+        catch (error) {
+            if (!(error instanceof ProviderBinaryError && config.providerPath)) {
+                throw error;
+            }
+            binary = resolveProviderBinary(config.provider);
+        }
+        config.providerPath = binary;
+        await storeAgent(config, options.home);
+        if (config.provider === "claude_code") {
+            await verifyClaudeCode(binary);
+        }
+        else {
+            await verifyCodex(binary);
+        }
+    }
+    catch (error) {
+        if (error instanceof ProviderBinaryError) {
+            try {
+                await new AgentGateway(config).request("/agent-gateway/provider-unavailable");
+            }
+            catch (reportError) {
+                if (reportError instanceof GatewayError &&
+                    (reportError.status === 401 || reportError.status === 410)) {
+                    throw reportError;
+                }
+                // Older servers may not support diagnostics; local shutdown still applies.
+            }
+            console.error(error.message);
+            // launchd cannot exclude exit 78; unload but retain the plist for repair.
+            if ((options.platform ?? process.platform) === "darwin") {
+                unloadLaunchAgent(config, options);
+            }
+        }
+        throw error;
+    }
+}

package/dist/commands/agent.js

@@ -7,9 +7,12 @@ import { AgentHttpError, fetchAgentStatus, inspectProvider, redeemAgent, setupAp
 import { parseAgentLink, redactAgentOutput } from "../agent-link.js";
 import { installAgentService, uninstallAgentService, } from "../agent-service.js";
 import { emit, emitJson, renderTable, warn } from "../format.js";
+import { installSharedGateway } from "../gateway-install.js";
 import { homeDir } from "../install.js";
 import { defaultDeviceName, hashKey, mintKey } from "../login.js";
-export async function runAgent(parsed) {
+import { resolveProviderBinary } from "../provider-binary.js";
+const MAX_PREVIOUS_AGENT_IDS = 100;
+export async function runAgent(parsed, dependencies = {}) {
     switch (parsed.action) {
         case "link": {
             if (!(parsed.options.yes || (await approveInstall()))) {
@@ -18,7 +21,7 @@ export async function runAgent(parsed) {
             const { agent, service } = await installLinkedAgent(parsed);
             emit(`Linked ${redactAgentOutput(agent.name)} (${agent.agentId}). Waiting for agent service…`);
             if (!service.started) {
-                warn(`Start it in the foreground: npx --yes talentos@1 agent serve --agent ${agent.agentId}`);
+                warn(`Start it in the foreground: npx --yes --prefer-online talentos@latest agent serve --agent ${agent.agentId}`);
             }
             const status = await waitForHeartbeat(agent);
             if (!status) {
@@ -38,6 +41,45 @@ export async function runAgent(parsed) {
             }
             return await command.runAgentServe(parsed);
         }
+        case "repair": {
+            if (process.platform === "win32") {
+                throw new Error("Windows agents run in the foreground. Use talentos agent serve.");
+            }
+            const agents = await selectAgents(parsed, false, dependencies.home);
+            if (!agents.length) {
+                throw new Error("No linked agent matches. Run talentos agent list.");
+            }
+            await installSharedGateway({
+                home: dependencies.home,
+                source: dependencies.gatewaySource,
+            });
+            let failed = 0;
+            for (const agent of agents) {
+                try {
+                    agent.providerPath = (dependencies.resolveBinary ?? resolveProviderBinary)(agent.provider);
+                    (dependencies.probe ?? inspectProvider)(agent.provider, agent.providerPath);
+                    await storeAgent(agent, dependencies.home);
+                    const service = await (dependencies.install ??
+                        ((config) => installAgentService(config, { home: dependencies.home })))(agent);
+                    emit(`Repaired ${redactAgentOutput(agent.name)} (${agent.agentId}).${service.started ? "" : " Start talentos agent serve in the foreground."}`);
+                }
+                catch (error) {
+                    failed++;
+                    const reason = error instanceof Error
+                        ? error.message
+                        : "Check the provider installation and login.";
+                    warn(redactAgentOutput(`Could not repair ${agent.name} (${agent.agentId}): ${reason}`, [agent.apiKey]));
+                }
+            }
+            if (failed) {
+                throw new Error(`${failed} agent${failed === 1 ? "" : "s"} could not be repaired. See the messages above.`);
+            }
+            return;
+        }
+        case "mcp": {
+            await import("../agent/mcp-entry.js");
+            return;
+        }
         case "status":
         case "list":
             return await showAgents(parsed);
@@ -46,7 +88,7 @@ export async function runAgent(parsed) {
         case "logs":
             return await showLogs(parsed);
         default:
-            throw new Error("Use talentos agent link | status | list | unlink | logs.");
+            throw new Error("Use talentos agent link | repair | status | list | unlink | logs.");
     }
 }
 export async function installLinkedAgent(parsed, dependencies = {}) {
@@ -56,12 +98,19 @@ export async function installLinkedAgent(parsed, dependencies = {}) {
     const link = parseAgentLink(parsed.options.url ?? "");
     const home = dependencies.home ?? homeDir();
     const linkHash = hashKey(link.token);
-    let agent = (await localAgents(home)).find((item) => item.linkHash === linkHash && item.provider === link.provider);
+    const providerPath = (dependencies.resolveBinary ?? resolveProviderBinary)(link.provider);
+    const savedAgents = await localAgents(home);
+    let agent = savedAgents.find((item) => item.linkHash === linkHash && item.provider === link.provider);
     if (agent) {
+        agent.providerPath = providerPath;
         await storeAgent(agent, home);
     }
     else {
         const apiUrl = await setupApiOrigin(link, parsed.options["api-url"] ?? process.env.TALENTOS_API_URL);
+        const candidates = savedAgents
+            .filter((item) => item.provider === link.provider && item.apiUrl === apiUrl)
+            .sort((a, b) => b.linkedAt - a.linkedAt)
+            .slice(0, MAX_PREVIOUS_AGENT_IDS);
         const pendingPath = join(agentsDir(home), `.pending-${linkHash}.json`);
         let apiKey;
         let recovered;
@@ -104,9 +153,10 @@ export async function installLinkedAgent(parsed, dependencies = {}) {
         const identity = recovered ??
             (await redeemAgent(apiUrl, {
                 token: link.token,
+                previousAgentIds: candidates.map((item) => item.agentId),
                 keyHash: hashKey(apiKey),
                 provider: link.provider,
-                providerVersion: (dependencies.probe ?? inspectProvider)(link.provider),
+                providerVersion: (dependencies.probe ?? inspectProvider)(link.provider, providerPath),
                 deviceName: parsed.options.name ?? defaultDeviceName(),
                 os: process.platform,
                 cliVersion: packageVersion(),
@@ -115,15 +165,29 @@ export async function installLinkedAgent(parsed, dependencies = {}) {
             agentId: identity.agentId,
             name: identity.name,
             provider: link.provider,
+            providerPath,
             apiKey,
             apiUrl,
             linkHash,
             linkedAt: Date.now(),
         };
         await storeAgent(agent, home);
+        for (const old of candidates) {
+            if (old.agentId !== agent.agentId &&
+                identity.retiredAgentIds?.includes(old.agentId)) {
+                await uninstallAgentService(old, { home });
+                await rm(agentConfigPath(old.agentId, home), { force: true });
+            }
+        }
         await rm(pendingPath, { force: true });
     }
-    const service = await (dependencies.install ?? ((config) => installAgentService(config, { home })))(agent);
+    const service = await (dependencies.install ??
+        (async (config) => {
+            if (process.platform !== "win32") {
+                await installSharedGateway({ home });
+            }
+            return await installAgentService(config, { home });
+        }))(agent);
     return { agent, service };
 }
 async function showAgents(parsed) {
@@ -204,9 +268,9 @@ async function showLogs(parsed) {
         await log.close();
     }
 }
-async function selectAgents(parsed, single = false) {
+async function selectAgents(parsed, single = false, home) {
     const selector = parsed.options.agent ?? parsed.args[0];
-    const agents = (await localAgents()).filter((agent) => !selector || agent.agentId === selector || agent.name === selector);
+    const agents = (await localAgents(home)).filter((agent) => !selector || agent.agentId === selector || agent.name === selector);
     if (single && agents.length > 1) {
         throw new Error("Several agents are linked. Select one by name or --agent <id>.");
     }

package/dist/gateway-install.js

@@ -0,0 +1,343 @@
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { cp, link, mkdir, readdir, readFile, readlink, realpath, rename, rm, stat, symlink, } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { writePrivateFile } from "./agent-config.js";
+import { compareGatewayVersions } from "./gateway-version.js";
+import { homeDir } from "./install.js";
+const exec = promisify(execFile);
+const TRANSIENT_BIN = /(?:\/_npx\/|node_modules\/\.bin|node-gyp-bin|\/Cellar\/|\/\.nvm\/versions\/)/;
+const NPM_ENV = new Set([
+    "HOME",
+    "USER",
+    "LOGNAME",
+    "LANG",
+    "LC_ALL",
+    "TMPDIR",
+    "TEMP",
+    "TMP",
+    "SystemRoot",
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "NO_PROXY",
+    "NODE_EXTRA_CA_CERTS",
+]);
+export function gatewayLauncherPath(home = homeDir()) {
+    return join(home, ".talentos", "bin", "talentos-gateway");
+}
+export function servicePathEnv(home = homeDir()) {
+    return [
+        ...new Set([
+            ...(process.env.PATH ?? "")
+                .split(":")
+                .filter((entry) => entry.startsWith("/") && !TRANSIENT_BIN.test(entry)),
+            join(home, ".local/bin"),
+            join(home, ".npm-global/bin"),
+            "/opt/homebrew/bin",
+            "/usr/local/bin",
+            "/usr/bin",
+            "/bin",
+        ]),
+    ].join(":");
+}
+// No user paths are interpolated into executable shell text. The Node hint is data.
+const LAUNCHER = `#!/bin/sh
+set -f
+root="\${0%/*}/.."
+agent=
+next_agent=
+for argument in "$@"; do
+  if [ "$next_agent" = yes ]; then agent=$argument; break; fi
+  if [ "$argument" = --agent ]; then next_agent=yes; fi
+done
+node_missing=
+case "$agent" in
+  ''|*[!a-zA-Z0-9_-]*) ;;
+  *) node_missing="$root/agents/$agent/.node-missing" ;;
+esac
+qualifies() {
+  [ -n "$1" ] && [ -x "$1" ] && "$1" -e 'process.exit(Number(process.versions.node.split(".")[0]) >= 20 ? 0 : 1)' >/dev/null 2>&1
+}
+start() {
+  if [ -n "$node_missing" ]; then /bin/rm -f "$node_missing"; fi
+  node=$1
+  shift
+  PATH="\${node%/*}:\${PATH:-/usr/bin:/bin}"
+  export PATH
+  exec "$node" "$root/cli/current/node_modules/talentos/dist/index.js" "$@"
+}
+node_hint=
+IFS= read -r node_hint < "$root/cli/node-path" || :
+if qualifies "\${TALENTOS_NODE:-}"; then
+  start "$TALENTOS_NODE" "$@"
+fi
+if qualifies "$node_hint"; then
+  start "$node_hint" "$@"
+fi
+old_ifs=$IFS
+IFS=:
+for dir in \${PATH:-}; do
+  IFS=$old_ifs
+  if qualifies "$dir/node"; then
+    start "$dir/node" "$@"
+  fi
+  IFS=:
+done
+IFS=$old_ifs
+for candidate in /opt/homebrew/bin/node /usr/local/bin/node; do
+  if qualifies "$candidate"; then
+    start "$candidate" "$@"
+  fi
+done
+# nvm has no stable system bin; discover surviving installations at startup.
+set +f
+for candidate in "$root"/../.nvm/versions/node/*/bin/node; do
+  if qualifies "$candidate"; then start "$candidate" "$@"; fi
+done
+message='TalentOS gateway requires Node.js 20 or newer. Install Node, then run talentos agent repair.'
+if [ -z "$node_missing" ]; then
+  echo "$message" >&2
+elif (set -C; : > "$node_missing") 2>/dev/null; then
+  echo "$message" >> "$root/agents/$agent/gateway.log"
+fi
+exit 78
+`;
+async function manifestVersion(root) {
+    return JSON.parse(await readFile(join(root, "package.json"), "utf8")).version;
+}
+async function copyPackage(source, destination) {
+    await mkdir(destination, { recursive: true, mode: 0o700 });
+    for (const name of ["package.json", "dist", "node_modules"]) {
+        try {
+            await cp(join(source, name), join(destination, name), {
+                recursive: true,
+                dereference: true,
+                force: true,
+            });
+        }
+        catch (error) {
+            if (name !== "node_modules" ||
+                error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+}
+async function installed(root, version) {
+    try {
+        if ((await manifestVersion(root)) !== version ||
+            !(await readFile(join(root, "dist/index.js"))).length) {
+            return false;
+        }
+        const { dependencies = {} } = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+        // The SDK has no root entrypoint. Load the same exports the CLI uses;
+        // imports also catch missing transitive dependencies in partial installs.
+        const imports = Object.keys(dependencies).flatMap((name) => name === "@modelcontextprotocol/sdk"
+            ? [
+                `${name}/client/index.js`,
+                `${name}/server/index.js`,
+                `${name}/types.js`,
+            ]
+            : [name]);
+        if (imports.length) {
+            await exec(process.execPath, [
+                "--input-type=module",
+                "--eval",
+                `await Promise.all(${JSON.stringify(imports)}.map(name => import(name)))`,
+            ], { cwd: root, timeout: 15_000 });
+        }
+        return true;
+    }
+    catch (error) {
+        if (error.killed) {
+            throw new Error("Gateway dependency check timed out. Keeping the current version; retry agent repair shortly.");
+        }
+        return false;
+    }
+}
+async function installLock(root, signal) {
+    const path = join(root, ".install-lock");
+    const pending = join(root, `.lock-${randomUUID()}`);
+    const contents = `${process.pid}\n${randomUUID()}`;
+    // Publish a populated lock atomically so a second installer never sees an
+    // empty new lock and mistakes it for one left behind by a crash.
+    await writePrivateFile(pending, contents);
+    try {
+        for (let attempt = 0; attempt < 600; attempt++) {
+            signal?.throwIfAborted();
+            try {
+                await link(pending, path);
+                return async () => {
+                    if ((await readFile(path, "utf8").catch(() => "")) === contents) {
+                        await rm(path, { force: true });
+                    }
+                };
+            }
+            catch (error) {
+                if (error.code !== "EEXIST") {
+                    throw error;
+                }
+                try {
+                    const lock = await readFile(path, "utf8");
+                    const metadata = await stat(path);
+                    const age = Date.now() - metadata.mtimeMs;
+                    const pid = Number(lock.split("\n")[0]);
+                    let stale = !lock.trim() || age > 5 * 60_000;
+                    if (!stale && pid > 0) {
+                        try {
+                            process.kill(pid, 0);
+                        }
+                        catch (failure) {
+                            stale = failure.code === "ESRCH";
+                        }
+                    }
+                    if (stale && (await readFile(path, "utf8")) === lock) {
+                        const latest = await stat(path);
+                        if (latest.dev === metadata.dev && latest.ino === metadata.ino) {
+                            await rm(path, { force: true });
+                            continue;
+                        }
+                    }
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT") {
+                        throw error;
+                    }
+                    continue;
+                }
+                await delay(200, undefined, { signal });
+            }
+        }
+        throw new Error("Another gateway installation is still running. Retry agent repair shortly.");
+    }
+    finally {
+        await rm(pending, { force: true });
+    }
+}
+export async function installSharedGateway(options = {}) {
+    const home = options.home ?? homeDir();
+    const source = options.source ?? fileURLToPath(new URL("../", import.meta.url));
+    const ownVersion = await manifestVersion(source);
+    let version = options.version ?? ownVersion;
+    if (compareGatewayVersions(version, version) === undefined) {
+        throw new Error("Unsupported gateway version.");
+    }
+    const root = join(home, ".talentos/cli");
+    await mkdir(root, { recursive: true, mode: 0o700 });
+    const release = await installLock(root, options.signal);
+    const temporary = join(root, `.install-${randomUUID()}`);
+    const pointer = join(root, `.current-${randomUUID()}`);
+    let stagedVersion;
+    try {
+        const active = await readlink(join(root, "current")).catch(() => "");
+        if ((compareGatewayVersions(active, version) ?? 0) > 0 &&
+            (await installed(join(root, active, "node_modules/talentos"), active))) {
+            version = active;
+        }
+        const destination = join(root, version);
+        const pkg = join(destination, "node_modules/talentos");
+        if (!(await installed(pkg, version))) {
+            await mkdir(temporary, { mode: 0o700 });
+            // Local builds have not been published. Copy resolved dependencies too,
+            // so pnpm's symlinks cannot strand the installed gateway in a worktree.
+            if (version === ownVersion &&
+                !source.includes("/node_modules/talentos")) {
+                await copyPackage(source, join(temporary, "node_modules/talentos"));
+            }
+            else {
+                const npmEnv = {
+                    PATH: `${process.env.PATH ?? servicePathEnv()}:${dirname(process.execPath)}`,
+                };
+                for (const [key, value] of Object.entries(process.env)) {
+                    if ((NPM_ENV.has(key) || key.toLowerCase().startsWith("npm_config_")) &&
+                        value) {
+                        npmEnv[key] = value;
+                    }
+                }
+                try {
+                    await exec("npm", [
+                        "install",
+                        "--prefix",
+                        temporary,
+                        "--omit=dev",
+                        "--ignore-scripts",
+                        "--no-audit",
+                        "--no-fund",
+                        `talentos@${version}`,
+                    ], { env: npmEnv, signal: options.signal, timeout: 90_000 });
+                }
+                catch {
+                    if (version === ownVersion) {
+                        await rm(temporary, { recursive: true, force: true });
+                        await copyPackage(source, join(temporary, "node_modules/talentos"));
+                    }
+                    else {
+                        throw new Error("Gateway update failed. Serving the current version; retrying when the network is available.");
+                    }
+                }
+            }
+            if (!(await installed(join(temporary, "node_modules/talentos"), version))) {
+                throw new Error("Gateway package is incomplete. Restore its runtime dependencies or retry agent repair online.");
+            }
+            await rm(destination, { recursive: true, force: true });
+            await rename(temporary, destination);
+            if (version !== active) {
+                stagedVersion = destination;
+            }
+        }
+        let previous;
+        try {
+            previous = await readlink(join(root, "current"));
+        }
+        catch {
+            /* First install. */
+        }
+        await symlink(version, pointer);
+        await rename(pointer, join(root, "current"));
+        stagedVersion = undefined;
+        const launcher = gatewayLauncherPath(home);
+        await writePrivateFile(launcher, LAUNCHER, 0o700);
+        let nodePath = options.nodePath ?? process.execPath;
+        for (const stable of [
+            "/opt/homebrew/bin/node",
+            "/usr/local/bin/node",
+            "/usr/bin/node",
+        ]) {
+            if ((await realpath(stable).catch(() => "")) === nodePath) {
+                nodePath = stable;
+                break;
+            }
+        }
+        // Preserve the link-time hint during updates and repairs.
+        const hint = join(root, "node-path");
+        try {
+            await readFile(hint);
+        }
+        catch {
+            await writePrivateFile(hint, `${nodePath}\n`);
+        }
+        const keep = new Set([version, previous]);
+        const oldVersions = (await readdir(root))
+            .filter((entry) => compareGatewayVersions(entry, entry) !== undefined && !keep.has(entry))
+            .sort((a, b) => compareGatewayVersions(b, a) ?? 0);
+        // A repeat repair retains the other installed version.
+        if (previous === version) {
+            oldVersions.shift();
+        }
+        for (const old of oldVersions) {
+            await rm(join(root, old), { recursive: true, force: true });
+        }
+        return launcher;
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+        await rm(pointer, { force: true });
+        if (stagedVersion) {
+            await rm(stagedVersion, { recursive: true, force: true });
+        }
+        await release();
+    }
+}

package/dist/gateway-version.js

@@ -0,0 +1,45 @@
+const VERSION = /^(\d+)\.(\d+)\.(\d+)(?:-([\da-zA-Z-]+(?:\.[\da-zA-Z-]+)*))?(?:\+[\da-zA-Z-]+(?:\.[\da-zA-Z-]+)*)?$/;
+const NUMERIC_IDENTIFIER = /^\d+$/;
+export function compareGatewayVersions(a, b) {
+    const left = VERSION.exec(a), right = VERSION.exec(b);
+    if (!(left && right)) {
+        return;
+    }
+    for (let i = 1; i <= 3; i++) {
+        const difference = Number(left[i]) - Number(right[i]);
+        if (difference) {
+            return difference;
+        }
+    }
+    if (left[4] === right[4]) {
+        return 0;
+    }
+    if (!left[4]) {
+        return 1;
+    }
+    if (!right[4]) {
+        return -1;
+    }
+    const l = left[4].split("."), r = right[4].split(".");
+    for (let i = 0; i < Math.max(l.length, r.length); i++) {
+        const x = l[i], y = r[i];
+        if (x === undefined) {
+            return -1;
+        }
+        if (y === undefined) {
+            return 1;
+        }
+        if (x === y) {
+            continue;
+        }
+        const xn = NUMERIC_IDENTIFIER.test(x), yn = NUMERIC_IDENTIFIER.test(y);
+        if (xn && yn) {
+            return Number(x) - Number(y);
+        }
+        if (xn !== yn) {
+            return xn ? -1 : 1;
+        }
+        return x < y ? -1 : 1;
+    }
+    return 0;
+}