@tea-agent/loop-agent 0.10.0 → 0.11.0

package/dist/cli/command-definitions.js

@@ -10,6 +10,7 @@ import { runInstructions } from "../commands/instructions.js";
 import { runNewTask } from "../commands/new-task.js";
 import { runImportPrd } from "../commands/import-prd.js";
 import { runPlanList } from "../commands/plan-list.js";
+import { runPlanCheck, runPlanComplete, runPlanCreate } from "../commands/plan.js";
 import { runPromoteRun } from "../commands/promote-run.js";
 import { runSpine } from "../commands/spine.js";
 import { runStats } from "../commands/stats.js";
@@ -36,7 +37,6 @@ import { runDagDoctor, runDagStatus } from "../workflows/dag/lifecycle.js";
 import { runDagRunTask } from "../commands/dag-run-task.js";
 import { runDagCloseoutDraft, runDagReport } from "../commands/dag-report.js";
 import { runDagFinalVerification } from "../commands/dag-final-verification.js";
-import { runCursorWorker } from "../commands/cursor-worker.js";
 import { runKnowledge } from "../commands/knowledge.js";
 import { runLoopBenchmark } from "../commands/loop-benchmark.js";
 import { runPiReuseBenchmark } from "../commands/pi-reuse-benchmark.js";
@@ -51,6 +51,23 @@ export function formatSubcommandUsage(name, subcommands) {
 export function formatSubcommandUsageError(name, subcommands) {
     return `usage: ${formatSubcommandUsage(name, subcommands)}`;
 }
+/**
+ * Parse a `--summary "..."` flag from a token list. Supports both
+ * `--summary <value>` and `--summary=<value>` forms. Returns undefined when
+ * the flag is absent so callers can emit their own usage error.
+ */
+export function parseSummaryFlag(tokens) {
+    for (let i = 0; i < tokens.length; i += 1) {
+        const token = tokens[i];
+        if (token === "--summary") {
+            return tokens[i + 1];
+        }
+        if (token?.startsWith("--summary=")) {
+            return token.slice("--summary=".length);
+        }
+    }
+    return undefined;
+}
 const DOCS_SUBCOMMANDS = ["audit", "archive"];
 const INIT_SUBCOMMANDS = [
     "instructions",
@@ -60,7 +77,7 @@ const INIT_SUBCOMMANDS = [
 ];
 const EXAMPLES_SUBCOMMANDS = ["list", "show", "copy"];
 const CLOSEOUT_SUBCOMMANDS = ["task"];
-const PLAN_SUBCOMMANDS = ["list"];
+const PLAN_SUBCOMMANDS = ["list", "create", "complete", "check"];
 const SPINE_SUBCOMMANDS = ["audit"];
 const HANDOFF_SUBCOMMANDS = ["check", "coverage"];
 const HANDOFF_USAGE = "handoff <check|coverage> [taskId]";
@@ -251,14 +268,35 @@ export const COMMAND_DEFINITIONS = [
         name: "plan",
         adapter: "required",
         tier: "operator",
-        intent: "List repo execution plans.",
-        usage: formatSubcommandUsage("plan", PLAN_SUBCOMMANDS),
+        intent: "Manage repo execution plans: list, create, complete, and index check.",
+        usage: "plan <list|create|complete|check> [plan-id] [title|--summary <summary>]",
         subcommands: [...PLAN_SUBCOMMANDS],
-        handler: async ({ repoRoot, subcommand }) => {
-            if (subcommand === "list") {
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            if (subcommand === "list" || subcommand === undefined) {
                 await runPlanList(repoRoot);
                 return;
             }
+            if (subcommand === "create") {
+                const [planId, ...titleParts] = rest;
+                if (!planId)
+                    throw new Error("usage: plan create <plan-id> \"<title>\"");
+                await runPlanCreate(repoRoot, planId, titleParts.join(" "));
+                return;
+            }
+            if (subcommand === "complete") {
+                const [planId, ...summaryParts] = rest;
+                if (!planId)
+                    throw new Error("usage: plan complete <plan-id> --summary \"<summary>\"");
+                const summary = parseSummaryFlag(summaryParts);
+                if (!summary)
+                    throw new Error("usage: plan complete <plan-id> --summary \"<summary>\"");
+                await runPlanComplete(repoRoot, planId, { summary });
+                return;
+            }
+            if (subcommand === "check") {
+                await runPlanCheck(repoRoot);
+                return;
+            }
             throw new Error(formatSubcommandUsageError("plan", PLAN_SUBCOMMANDS));
         },
     },
@@ -393,16 +431,6 @@ export const COMMAND_DEFINITIONS = [
             await runHarvest(repoRoot, harvestArgs);
         },
     },
-    {
-        name: "cursor-worker",
-        adapter: "required",
-        tier: "escape-hatch",
-        intent: "Inspect or control the optional Cursor SDK worker process.",
-        usage: "cursor-worker <status|stop|ping>",
-        handler: async ({ repoRoot, subcommand, rest }) => {
-            await runCursorWorker(repoRoot, [subcommand, ...rest].filter((arg) => Boolean(arg)));
-        },
-    },
     {
         name: "knowledge",
         adapter: "required",

package/dist/cli/program.js

@@ -1,10 +1,10 @@
-import { readFileSync } from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { Command } from "commander";
+import { readPackageVersion } from "../shared/package-metadata.js";
 import { resolveAdapter } from "../adapters/index.js";
 import { runCloseout } from "../commands/closeout.js";
 import { runCoverageAudit } from "../commands/coverage-audit.js";
-import { runCursorWorker } from "../commands/cursor-worker.js";
 import { parseCursorPromptArgs, printCursorPromptUsage, runCursorPrompt, } from "../commands/cursor-prompt.js";
 import { runDagApprove } from "../commands/dag-approve.js";
 import { runDagFinalVerification } from "../commands/dag-final-verification.js";
@@ -38,6 +38,7 @@ import { runImportPrd } from "../commands/import-prd.js";
 import { runPiReuseBenchmark } from "../commands/pi-reuse-benchmark.js";
 import { parsePiPromptArgs, printPiPromptUsage, runPiPrompt, } from "../commands/pi-prompt.js";
 import { runPlanList } from "../commands/plan-list.js";
+import { runPlanCheck, runPlanComplete, runPlanCreate } from "../commands/plan.js";
 import { runPromoteRun } from "../commands/promote-run.js";
 import { runReferenceIndex } from "../commands/reference-index.js";
 import { runRunDag } from "../commands/run-dag.js";
@@ -53,18 +54,6 @@ import { handleStandaloneOneShotCommandError } from "../shared/one-shot-prompt-a
 import { runDagDecisionInspect, runDagDecisionValidate, } from "../workflows/dag/decision-envelope.js";
 import { runDagDoctor, runDagStatus } from "../workflows/dag/lifecycle.js";
 import { CODE_AGENT_COMMAND_MANIFEST } from "./catalog.js";
-function readPackageVersion() {
-    try {
-        const raw = readFileSync(new URL("../../package.json", import.meta.url), "utf-8");
-        const parsed = JSON.parse(raw);
-        if (typeof parsed.version === "string")
-            return parsed.version;
-    }
-    catch {
-        // Fall back only if the package metadata is unexpectedly unavailable.
-    }
-    return "0.0.0";
-}
 function resolveRepoRootOnly(command, defaultRepoRoot, behavior) {
     const options = collectGlobalOptions(command);
     const repoRoot = path.resolve(options.repoRoot ?? defaultRepoRoot);
@@ -167,11 +156,32 @@ async function runCommanderAction(ctx, command, subcommand, rest) {
             await runStats(ctx.repoRoot);
             return;
         case "plan":
-            if (subcommand === "list") {
+            if (subcommand === "list" || subcommand === undefined) {
                 await runPlanList(ctx.repoRoot);
                 return;
             }
-            throw new Error("usage: plan <list>");
+            if (subcommand === "create") {
+                const [planId, ...titleParts] = rest;
+                if (!planId)
+                    throw new Error("usage: plan create <plan-id> \"<title>\"");
+                await runPlanCreate(ctx.repoRoot, planId, titleParts.join(" "));
+                return;
+            }
+            if (subcommand === "complete") {
+                const [planId, ...summaryParts] = rest;
+                if (!planId)
+                    throw new Error("usage: plan complete <plan-id> --summary \"<summary>\"");
+                const summary = parsePlanSummaryFlag(summaryParts);
+                if (!summary)
+                    throw new Error("usage: plan complete <plan-id> --summary \"<summary>\"");
+                await runPlanComplete(ctx.repoRoot, planId, { summary });
+                return;
+            }
+            if (subcommand === "check") {
+                await runPlanCheck(ctx.repoRoot);
+                return;
+            }
+            throw new Error("usage: plan <list|create|complete|check> ...");
         case "spine":
             await runSpine(ctx.repoRoot, compactArgs([subcommand, ...rest]));
             return;
@@ -231,9 +241,6 @@ async function runCommanderAction(ctx, command, subcommand, rest) {
         case "harvest":
             await runHarvest(ctx.repoRoot, compactArgs([subcommand, ...rest]));
             return;
-        case "cursor-worker":
-            await runCursorWorker(ctx.repoRoot, compactArgs([subcommand, ...rest]));
-            return;
         case "knowledge":
             await runKnowledge(ctx.repoRoot, compactArgs([subcommand, ...rest]));
             return;
@@ -329,6 +336,18 @@ async function runDagAction(repoRoot, subcommand, rest) {
 function compactArgs(args) {
     return args.filter((arg) => Boolean(arg));
 }
+function parsePlanSummaryFlag(tokens) {
+    for (let i = 0; i < tokens.length; i += 1) {
+        const token = tokens[i];
+        if (token === "--summary") {
+            return tokens[i + 1];
+        }
+        if (token?.startsWith("--summary=")) {
+            return token.slice("--summary=".length);
+        }
+    }
+    return undefined;
+}
 function createRawArgsCommand(name, description, defaultRepoRoot) {
     return new Command(name)
         .description(description)
@@ -375,7 +394,6 @@ function configureRunDag(command) {
         .option("--dry-run", "validate and plan without executing")
         .option("--max-concurrent <n>", "maximum concurrent nodes")
         .option("--run-id <id>", "run id")
-        .option("--no-cursor", "disable Cursor execution")
         .option("--canvas-path <path>", "absolute canvas output path")
         .option("--canvas <name>", "canvas name")
         .option("--canvases-dir <dir>", "canvas output directory")
@@ -387,7 +405,6 @@ function configureDagRunTask(command) {
         .option("-o, --output <path>", "output DAG path")
         .option("--profile <profile>", "auto|minimal|standard|reviewed|supervised")
         .option("--strict-models", "fail on model routing warnings")
-        .option("--no-cursor", "disable Cursor execution")
         .option("--execute", "execute after creating the DAG")
         .option("--init-only", "initialize run artifacts without executing")
         .option("--dry-run", "validate and plan without executing")
@@ -507,7 +524,7 @@ export function buildLoopAgentProgram(options) {
     program
         .name("loop-agent")
         .description("Loop Agent task and DAG automation CLI")
-        .version(readPackageVersion(), "-V, --version", "display version")
+        .version(readPackageVersion(path.dirname(path.dirname(path.dirname(fileURLToPath(import.meta.url))))) ?? "0.0.0", "-V, --version", "display version")
         .showHelpAfterError()
         .option("--repo-root <path>", "repository root")
         .option("--adapter <name>", "harness adapter name")
@@ -544,7 +561,7 @@ export function buildLoopAgentProgram(options) {
                 .allowExcessArguments(true)
                 .argument("[args...]", "init arguments")
                 .option("--project-name <name>", "target project name")
-                .option("--governance-root <path>", "governance root", "docs")
+                .option("--governance-root <path>", "governance root")
                 .option("--profile <profile>", "full|minimal", "full")
                 .option("--merge", "merge existing files")
                 .option("--no-merge", "skip existing files")

package/dist/cli/update/notifier.js

@@ -0,0 +1,117 @@
+import { createInterface } from "node:readline/promises";
+import { evaluateLatestVersion, shouldCheckForUpdates } from "./policy.js";
+import { acquireUpdateLock, readUpdateState, updateLockPath, updateStatePath, writeUpdateState, } from "./state.js";
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const FAILURE_COOLDOWN_MS = 10 * 60 * 1000;
+export async function runSelfUpdateNotifier(options) {
+    if (!shouldCheckForUpdates(options))
+        return;
+    const now = options.now ?? (() => new Date());
+    const writeStderr = options.writeStderr ?? ((chunk) => process.stderr.write(chunk));
+    void options.writeStdout;
+    try {
+        const statePath = updateStatePath(options.homeDir);
+        let state = await readUpdateState(statePath);
+        if (state.retryAfter && Date.parse(state.retryAfter) > now().getTime())
+            return;
+        let latestVersion = cachedLatest(state, now());
+        if (!latestVersion) {
+            latestVersion = await options.client.latestVersion();
+            state = {
+                ...state,
+                lastCheckedAt: now().toISOString(),
+                latestVersion,
+            };
+            await safeWriteState(statePath, state);
+        }
+        const decision = evaluateLatestVersion({
+            currentVersion: options.currentVersion,
+            latestVersion,
+            dismissedVersion: state.dismissedVersion,
+            now: now(),
+            retryAfter: state.retryAfter,
+        });
+        if (!decision.shouldPrompt)
+            return;
+        const release = await acquireUpdateLock(updateLockPath(options.homeDir), { now });
+        if (!release)
+            return;
+        try {
+            state = await readUpdateState(statePath);
+            if (state.dismissedVersion === decision.targetVersion)
+                return;
+            const answer = await ask(options, `loop-agent 有新版本：${options.currentVersion} → ${decision.targetVersion}\n现在更新到 ${decision.targetVersion}？[y/N] `);
+            if (!isYes(answer)) {
+                await safeWriteState(statePath, {
+                    ...state,
+                    latestVersion: decision.targetVersion,
+                    dismissedVersion: decision.targetVersion,
+                });
+                return;
+            }
+            const proof = await options.client.canAutoInstall();
+            if (!proof.ok) {
+                writeStderr(`当前 loop-agent 不是由此 npm 的正式全局安装管理，无法自动升级。\n请运行：npm install -g @tea-agent/loop-agent@${decision.targetVersion}\n`);
+                await safeWriteState(statePath, cooldownState(state, now()));
+                return;
+            }
+            const install = await options.client.installExact(decision.targetVersion);
+            if (!install.ok) {
+                writeStderr(`loop-agent 更新失败：${install.reason}\n`);
+                await safeWriteState(statePath, cooldownState(state, now()));
+                return;
+            }
+            const verified = await options.client.verifyInstalled(decision.targetVersion);
+            if (!verified.ok) {
+                writeStderr(`loop-agent 已尝试安装，但验证失败：${verified.reason}\n`);
+                await safeWriteState(statePath, cooldownState(state, now()));
+                return;
+            }
+            writeStderr(`loop-agent 已更新到 ${decision.targetVersion}；新版本将在下一次调用时生效。\n`);
+            await safeWriteState(statePath, {
+                schemaVersion: 1,
+                lastCheckedAt: now().toISOString(),
+                latestVersion: decision.targetVersion,
+            });
+        }
+        finally {
+            await release().catch(() => undefined);
+        }
+    }
+    catch (error) {
+        writeStderr(`loop-agent 更新检查已跳过：${error instanceof Error ? error.message : String(error)}\n`);
+    }
+}
+function cachedLatest(state, now) {
+    if (!state.lastCheckedAt || !state.latestVersion)
+        return undefined;
+    const checkedAt = Date.parse(state.lastCheckedAt);
+    if (!Number.isFinite(checkedAt))
+        return undefined;
+    return now.getTime() - checkedAt <= CHECK_INTERVAL_MS ? state.latestVersion : undefined;
+}
+async function ask(options, prompt) {
+    if (options.readLine) {
+        options.writeStderr?.(prompt);
+        return options.readLine(prompt);
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        return await rl.question(prompt);
+    }
+    finally {
+        rl.close();
+    }
+}
+function isYes(answer) {
+    return /^(y|yes)$/i.test(answer.trim());
+}
+function cooldownState(state, now) {
+    return {
+        ...state,
+        retryAfter: new Date(now.getTime() + FAILURE_COOLDOWN_MS).toISOString(),
+    };
+}
+async function safeWriteState(path, state) {
+    await writeUpdateState(path, state).catch(() => undefined);
+}

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;
+}