@tea-agent/loop-agent 0.10.0-alpha.0 → 0.11.0

package/dist/cli/update/npm-client.js

@@ -0,0 +1,151 @@
+import { spawn } from "node:child_process";
+import { lstat, readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+import semver from "semver";
+const PACKAGE_NAME = "@tea-agent/loop-agent";
+export function createNpmUpdateClient(options) {
+    const npmCommand = options.npmCommand ?? "npm";
+    const loopAgentCommand = options.loopAgentCommand ?? "loop-agent";
+    const runner = options.runner ?? runCommand;
+    const timeoutMs = options.timeoutMs ?? 1500;
+    const env = options.env;
+    return {
+        async latestVersion() {
+            const result = await runner(npmCommand, ["view", PACKAGE_NAME, "dist-tags.latest", "--json"], { timeoutMs, env });
+            if (result.exitCode !== 0 || result.timedOut)
+                return undefined;
+            return parseNpmViewLatest(result.stdout);
+        },
+        async canAutoInstall() {
+            return proveGlobalNpmInstall({
+                currentVersion: options.currentVersion,
+                packageRoot: options.packageRoot,
+                npmCommand,
+                runner,
+                env,
+                timeoutMs,
+            });
+        },
+        async installExact(version) {
+            if (!isStrictRelease(version))
+                return { ok: false, reason: "invalid-version" };
+            const result = await runner(npmCommand, buildExactInstallArgs(version), { timeoutMs: Math.max(timeoutMs, 120000), env });
+            if (result.exitCode !== 0 || result.timedOut)
+                return { ok: false, reason: "install-failed" };
+            return { ok: true };
+        },
+        async verifyInstalled(version) {
+            const list = await runner(npmCommand, ["list", "-g", PACKAGE_NAME, "--depth=0", "--json"], { timeoutMs, env });
+            if (list.exitCode !== 0 || !verifyNpmListVersion(list.stdout, version)) {
+                return { ok: false, reason: "npm-list-version-mismatch" };
+            }
+            const pathVersion = await runner(loopAgentCommand, ["--version"], { timeoutMs, env });
+            if (pathVersion.exitCode !== 0 || !verifyPathVersion(pathVersion.stdout, version)) {
+                return { ok: false, reason: "path-version-mismatch" };
+            }
+            return { ok: true };
+        },
+    };
+}
+export function parseNpmViewLatest(stdout) {
+    const trimmed = stdout.trim();
+    let value = trimmed;
+    try {
+        value = JSON.parse(trimmed);
+    }
+    catch {
+        // npm may emit a bare value under older versions or mocked tests.
+    }
+    if (typeof value !== "string")
+        return undefined;
+    return isStrictRelease(value) ? value : undefined;
+}
+export function buildExactInstallArgs(version) {
+    if (!isStrictRelease(version))
+        throw new Error(`invalid release version: ${version}`);
+    return ["install", "-g", `${PACKAGE_NAME}@${version}`, "--no-fund", "--no-audit"];
+}
+export function verifyNpmListVersion(stdout, expectedVersion) {
+    try {
+        const parsed = JSON.parse(stdout);
+        return parsed.dependencies?.[PACKAGE_NAME]?.version === expectedVersion;
+    }
+    catch {
+        return false;
+    }
+}
+export function verifyPathVersion(stdout, expectedVersion) {
+    return stdout.trim() === expectedVersion;
+}
+async function proveGlobalNpmInstall(options) {
+    const root = await options.runner(options.npmCommand, ["root", "-g"], {
+        timeoutMs: options.timeoutMs,
+        env: options.env,
+    });
+    if (root.exitCode !== 0 || root.timedOut)
+        return { ok: false, reason: "npm-root-failed" };
+    const globalPackageRoot = path.join(root.stdout.trim(), "@tea-agent", "loop-agent");
+    try {
+        const [expectedReal, currentReal, expectedStat] = await Promise.all([
+            realpath(globalPackageRoot),
+            realpath(options.packageRoot),
+            lstat(globalPackageRoot),
+        ]);
+        if (expectedStat.isSymbolicLink())
+            return { ok: false, reason: "linked-global-package" };
+        if (expectedReal !== currentReal)
+            return { ok: false, reason: "not-global" };
+        const pkg = JSON.parse(await readFile(path.join(options.packageRoot, "package.json"), "utf-8"));
+        if (pkg.name !== PACKAGE_NAME)
+            return { ok: false, reason: "wrong-package" };
+        if (pkg.version !== options.currentVersion)
+            return { ok: false, reason: "version-mismatch" };
+        return { ok: true };
+    }
+    catch {
+        return { ok: false, reason: "source-proof-failed" };
+    }
+}
+function isStrictRelease(version) {
+    const parsed = semver.parse(version);
+    return Boolean(parsed && parsed.prerelease.length === 0);
+}
+async function runCommand(command, args, options) {
+    return new Promise((resolve) => {
+        const child = spawn(command, [...args], {
+            env: options.env ? { ...process.env, ...options.env } : process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+            shell: false,
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const timer = setTimeout(() => {
+            settled = true;
+            child.kill("SIGTERM");
+            resolve({ exitCode: null, stdout, stderr, timedOut: true });
+        }, options.timeoutMs);
+        child.stdout.setEncoding("utf-8");
+        child.stderr.setEncoding("utf-8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ exitCode: null, stdout, stderr: `${stderr}${error.message}`, timedOut: false });
+        });
+        child.on("close", (exitCode) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ exitCode, stdout, stderr, timedOut: false });
+        });
+    });
+}

package/dist/cli/update/policy.js

@@ -0,0 +1,58 @@
+import semver from "semver";
+const CONTROLLER_SENSITIVE_COMMANDS = new Set([
+    "run-dag",
+    "dag",
+    "loop",
+    "delegate",
+    "pi-prompt",
+    "cursor-prompt",
+]);
+const MACHINE_OUTPUT_FLAGS = new Set(["--json", "--markdown"]);
+export function isStrictReleaseVersion(version) {
+    if (!version)
+        return false;
+    const parsed = semver.parse(version);
+    return Boolean(parsed && parsed.prerelease.length === 0);
+}
+export function shouldCheckForUpdates(input) {
+    if (!input.stdinIsTTY || !input.stdoutIsTTY || !input.stderrIsTTY)
+        return false;
+    if (input.env.CI || input.env.LOOP_AGENT_DISABLE_UPDATE_CHECK === "1")
+        return false;
+    const args = input.argv;
+    if (args.some((arg) => arg === "--help" || arg === "-h" || arg === "--version" || arg === "-V")) {
+        return false;
+    }
+    if (args.some((arg) => MACHINE_OUTPUT_FLAGS.has(arg)))
+        return false;
+    const command = firstCommand(args);
+    if (command && CONTROLLER_SENSITIVE_COMMANDS.has(command))
+        return false;
+    return true;
+}
+export function evaluateLatestVersion(input) {
+    const now = input.now ?? new Date();
+    if (input.retryAfter && Date.parse(input.retryAfter) > now.getTime()) {
+        return { shouldPrompt: false, reason: "retry-after" };
+    }
+    if (!isStrictReleaseVersion(input.currentVersion)) {
+        return { shouldPrompt: false, reason: "invalid-current-version" };
+    }
+    if (!isStrictReleaseVersion(input.latestVersion)) {
+        return { shouldPrompt: false, reason: "invalid-latest-version" };
+    }
+    if (!semver.gt(input.latestVersion, input.currentVersion)) {
+        return { shouldPrompt: false, reason: "not-newer" };
+    }
+    if (input.dismissedVersion === input.latestVersion) {
+        return { shouldPrompt: false, reason: "dismissed-version" };
+    }
+    return { shouldPrompt: true, targetVersion: input.latestVersion };
+}
+function firstCommand(argv) {
+    for (const arg of argv) {
+        if (!arg.startsWith("-"))
+            return arg;
+    }
+    return undefined;
+}

package/dist/cli/update/state.js

@@ -0,0 +1,68 @@
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+export function updateStatePath(homeDir) {
+    return path.join(homeDir, ".loop-agent", "update-state.json");
+}
+export function updateLockPath(homeDir) {
+    return path.join(homeDir, ".loop-agent", "update.lock");
+}
+export async function readUpdateState(statePath) {
+    try {
+        const raw = await readFile(statePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.schemaVersion !== 1)
+            return emptyState();
+        return {
+            schemaVersion: 1,
+            lastCheckedAt: stringOrUndefined(parsed.lastCheckedAt),
+            latestVersion: stringOrUndefined(parsed.latestVersion),
+            dismissedVersion: stringOrUndefined(parsed.dismissedVersion),
+            retryAfter: stringOrUndefined(parsed.retryAfter),
+        };
+    }
+    catch {
+        return emptyState();
+    }
+}
+export async function writeUpdateState(statePath, state) {
+    await mkdir(path.dirname(statePath), { recursive: true });
+    const tempPath = path.join(path.dirname(statePath), `.${path.basename(statePath)}.${process.pid}.${Date.now()}.tmp`);
+    await writeFile(tempPath, `${JSON.stringify({ ...state, schemaVersion: 1 }, null, 2)}\n`, "utf-8");
+    await rename(tempPath, statePath);
+}
+export async function acquireUpdateLock(lockPath, options = {}) {
+    const now = options.now ?? (() => new Date());
+    const staleMs = options.staleMs ?? 10 * 60 * 1000;
+    await mkdir(path.dirname(lockPath), { recursive: true });
+    try {
+        await mkdir(lockPath);
+        await writeFile(path.join(lockPath, "owner.json"), JSON.stringify({ pid: process.pid, at: now().toISOString() }), "utf-8");
+        return async () => {
+            await rm(lockPath, { recursive: true, force: true });
+        };
+    }
+    catch {
+        try {
+            const ownerRaw = await readFile(path.join(lockPath, "owner.json"), "utf-8");
+            const owner = JSON.parse(ownerRaw);
+            if (owner.at && now().getTime() - Date.parse(owner.at) > staleMs) {
+                await rm(lockPath, { recursive: true, force: true });
+                await mkdir(lockPath);
+                await writeFile(path.join(lockPath, "owner.json"), JSON.stringify({ pid: process.pid, at: now().toISOString() }), "utf-8");
+                return async () => {
+                    await rm(lockPath, { recursive: true, force: true });
+                };
+            }
+        }
+        catch {
+            return undefined;
+        }
+        return undefined;
+    }
+}
+function emptyState() {
+    return { schemaVersion: 1 };
+}
+function stringOrUndefined(value) {
+    return typeof value === "string" ? value : undefined;
+}

package/dist/cli.js

@@ -1,12 +1,45 @@
 #!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { buildLoopAgentProgram } from "./cli/program.js";
+import { createNpmUpdateClient } from "./cli/update/npm-client.js";
+import { runSelfUpdateNotifier } from "./cli/update/notifier.js";
 async function main() {
     const program = buildLoopAgentProgram({
         defaultRepoRoot: process.cwd(),
     });
     await program.parseAsync(process.argv);
+    if (process.exitCode && process.exitCode !== 0)
+        return;
+    const packageRoot = resolvePackageRoot();
+    const currentVersion = readPackageVersion(packageRoot);
+    await runSelfUpdateNotifier({
+        argv: process.argv.slice(2),
+        currentVersion,
+        env: process.env,
+        homeDir: os.homedir(),
+        stdinIsTTY: process.stdin.isTTY === true,
+        stdoutIsTTY: process.stdout.isTTY === true,
+        stderrIsTTY: process.stderr.isTTY === true,
+        client: createNpmUpdateClient({
+            currentVersion,
+            packageRoot,
+            env: process.env,
+        }),
+    });
 }
 main().catch((error) => {
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
 });
+function resolvePackageRoot() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+}
+function readPackageVersion(packageRoot) {
+    const pkg = JSON.parse(readFileSync(path.join(packageRoot, "package.json"), "utf-8"));
+    if (!pkg.version)
+        throw new Error("loop-agent package.json is missing version");
+    return pkg.version;
+}