@lazyingart/agintiflow 0.20.128 → 0.20.129

package/README.md

@@ -103,7 +103,7 @@ Provider signup and key pages:
 | Qwen / DashScope | [https://bailian.console.aliyun.com/](https://bailian.console.aliyun.com/) | `https://dashscope-intl.aliyuncs.com/compatible-mode/v1` |
 | GRS AI image tools | [https://grsai.ai/dashboard/api-keys](https://grsai.ai/dashboard/api-keys) | Configure with `/auxiliary grsai` or `aginti login grsai` |
 
-The CLI quietly auto-starts or reuses the local web UI from the same project. It tries `http://127.0.0.1:3210` first, then `3211`, `3212`, and so on if the port is already occupied by another project. The active URL is shown in the CLI launch header. If startup is blocked, stale, or unavailable, the same header row shows the recovery hint; run `/webapp [port]` inside the CLI to retry, or `/webapp restart [port]` to stop and relaunch the local webapp with the current project and canonical `~/.agintiflow` session home.
+The CLI quietly auto-starts or reuses the local web UI from the same project. It tries `http://127.0.0.1:3210` first, then `3211`, `3212`, and so on if the port is already occupied by another project. The active URL is shown in the CLI launch header. If startup is blocked, stale, or unavailable, the same header row shows the recovery hint; run `/webapp [port]` inside the CLI to retry, or `/webapp restart [port]` to stop and relaunch the local webapp with the current project and canonical `~/.agintiflow` session home. After a successful `aginti update` or accepted startup auto-update, AgInTiFlow also restarts the compatible local webapp so artifact serving uses the updated package.
 
 Package installation also makes a best-effort, non-blocking webapp initialization. Install never fails because the optional local webapp could not start.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.128",
+  "version": "0.20.129",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",

package/references/agintiflow-aaps-slogan-subtext-v3.md

@@ -14,7 +14,7 @@ AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-a
 
 Project-oriented programming for agentic workflows.
 
-AAPS is a project oriented and prompt-native programming language and visual studio for turning prompts into structured, verifiable pipelines. It connects wet and dry experiments, hardware and software, and human intent with executable agent work through tasks, typed inputs, declared outputs, validation gates, recovery steps, and durable artifacts.
+AAPS is a prompt-native programming language and visual studio for turning prompts into structured, verifiable pipelines. It connects wet and dry experiments, hardware and software, and human intent with executable agent work through tasks, typed inputs, declared outputs, validation gates, recovery steps, and durable artifacts.
 
 ## Shorter Version
 

package/scripts/smoke-auto-update.js

@@ -101,4 +101,52 @@ else process.env.AGINTIFLOW_AUTO_UPDATE_STARTUP_INTERVAL_MS = previousStartupInt
 if (previousCi === undefined) delete process.env.CI;
 else process.env.CI = previousCi;
 
+const updateHome = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-auto-update-install-"));
+const previousInstallHome = process.env.AGINTIFLOW_HOME;
+process.env.AGINTIFLOW_HOME = updateHome;
+await fs.writeFile(
+  path.join(updateHome, "update-check.json"),
+  `${JSON.stringify({ checkedAt: Date.now(), latest: "0.20.99" })}\n`,
+  "utf8"
+);
+const hookEvents = [];
+const fakeInstallWrites = [];
+const fakeInstallStdout = {
+  isTTY: true,
+  write(value) {
+    fakeInstallWrites.push(String(value));
+  },
+};
+const fakeInstallStderr = {
+  write(value) {
+    fakeInstallWrites.push(String(value));
+  },
+};
+const installed = await maybeAutoUpdate({
+  argv: ["update"],
+  manual: true,
+  packageDir: scopedGlobalPath,
+  packageName: "@lazyingart/agintiflow",
+  packageVersion: "0.20.38",
+  restart: false,
+  stdout: fakeInstallStdout,
+  stderr: fakeInstallStderr,
+  installPackage: async (packageName) => {
+    hookEvents.push(["install", packageName]);
+    return { ok: true, code: 0 };
+  },
+  afterUpdate: async (context) => {
+    hookEvents.push(["afterUpdate", context.latest]);
+    return { ok: true, restarted: true, url: "http://127.0.0.1:3210" };
+  },
+});
+assert(installed.updated === true, "fake install did not report update success");
+assert(installed.webappRestart?.ok === true && installed.webappRestart.restarted === true, "after-update webapp restart result missing");
+assert(hookEvents.some((event) => event[0] === "install"), "install hook was not called");
+assert(hookEvents.some((event) => event[0] === "afterUpdate"), "after-update hook was not called");
+assert(fakeInstallWrites.join("").includes("webapp restarted after update"), "after-update webapp restart was not reported");
+if (previousInstallHome === undefined) delete process.env.AGINTIFLOW_HOME;
+else process.env.AGINTIFLOW_HOME = previousInstallHome;
+await fs.rm(updateHome, { recursive: true, force: true });
+
 console.log("auto-update smoke ok");

package/scripts/smoke-web-autostart.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import fs from "node:fs/promises";
+import net from "node:net";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -13,6 +14,14 @@ const preferredPort = 44500 + Math.floor(Math.random() * 1000);
 let childPid = 0;
 const originalHome = process.env.AGINTIFLOW_HOME;
 
+function listenOccupier(port) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => resolve(server));
+  });
+}
+
 try {
   process.env.AGINTIFLOW_HOME = inheritedHome;
   const first = await ensureAgintiWebApp({
@@ -55,6 +64,42 @@ try {
     throw new Error(`expected restart on same URL with a new pid, got ${JSON.stringify(restarted)}`);
   }
   childPid = Number(restarted.pid) || childPid;
+  try {
+    process.kill(childPid, "SIGTERM");
+  } catch {
+    // The primary restart target may have already exited.
+  }
+  childPid = 0;
+
+  const occupiedPort = preferredPort + 103;
+  const occupier = await listenOccupier(occupiedPort);
+  try {
+    const fallback = await ensureAgintiWebApp({
+      packageDir: repoRoot,
+      cwd: runtimeDir,
+      home: homeDir,
+      preferredPort: occupiedPort,
+      host: "127.0.0.1",
+    });
+    if (!fallback.ok || !fallback.started || Number(fallback.port) <= occupiedPort) {
+      throw new Error(`expected fallback webapp above occupied port ${occupiedPort}, got ${JSON.stringify(fallback)}`);
+    }
+    const fallbackPid = Number(fallback.pid) || 0;
+    const fallbackRestarted = await ensureAgintiWebApp({
+      packageDir: repoRoot,
+      cwd: runtimeDir,
+      home: homeDir,
+      preferredPort: occupiedPort,
+      host: "127.0.0.1",
+      restart: true,
+    });
+    if (!fallbackRestarted.ok || !fallbackRestarted.restarted || fallbackRestarted.url !== fallback.url || Number(fallbackRestarted.pid) === fallbackPid) {
+      throw new Error(`expected restart of compatible fallback-port webapp, got ${JSON.stringify(fallbackRestarted)}`);
+    }
+    childPid = Number(fallbackRestarted.pid) || 0;
+  } finally {
+    occupier.close();
+  }
   console.log(`web auto-start smoke passed: ${first.url}`);
 } finally {
   if (originalHome === undefined) delete process.env.AGINTIFLOW_HOME;

package/src/auto-update.js

@@ -189,6 +189,24 @@ async function restartCurrentProcess() {
   });
 }
 
+async function runAfterUpdateHook(afterUpdate, context, stdout, stderr) {
+  if (typeof afterUpdate !== "function") return null;
+  try {
+    const result = (await afterUpdate(context)) || { ok: true };
+    if (result.ok && result.url) {
+      const state = result.restarted ? "restarted" : result.reused ? "reused" : result.started ? "started" : "ready";
+      stdout.write(`AgInTiFlow webapp ${state} after update: ${result.url}\n`);
+    } else if (result.ok === false) {
+      stderr.write(`AgInTiFlow webapp restart after update failed: ${result.error || "unknown error"}\n`);
+    }
+    return result;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    stderr.write(`AgInTiFlow webapp restart after update failed: ${message}\n`);
+    return { ok: false, error: message };
+  }
+}
+
 function shouldSkipFailedInstall(cache, currentMs, force) {
   if (force) return false;
   const failedAt = Number(cache.lastInstallFailedAt || 0);
@@ -289,6 +307,9 @@ export async function maybeAutoUpdate({
   packageVersion = "",
   restart = false,
   selectUpdateAction = promptUpdateChoice,
+  installPackage = installLatest,
+  restartProcess = restartCurrentProcess,
+  afterUpdate = null,
   stdout = process.stdout,
   stderr = process.stderr,
 } = {}) {
@@ -369,7 +390,7 @@ export async function maybeAutoUpdate({
 
   stdout.write(`AgInTiFlow update available: ${packageVersion} -> ${latest}\n`);
   stdout.write(`Running: npm install -g ${packageName}@latest\n`);
-  const install = await installLatest(packageName);
+  const install = await installPackage(packageName);
   if (!install.ok) {
     await writeCache({
       ...cache,
@@ -394,12 +415,27 @@ export async function maybeAutoUpdate({
     packageName,
   });
   stdout.write(`AgInTiFlow updated to ${latest}.\n`);
+  const webappRestart = await runAfterUpdateHook(
+    afterUpdate,
+    { current: packageVersion, latest, packageName },
+    stdout,
+    stderr
+  );
 
   if (restart) {
     stdout.write("Restarting AgInTiFlow with the updated package...\n");
-    const restarted = await restartCurrentProcess();
-    return { checked: true, latest, current: packageVersion, updated: true, restarted: true, exitCode: restarted.exitCode, error: restarted.error };
+    const restarted = await restartProcess();
+    return {
+      checked: true,
+      latest,
+      current: packageVersion,
+      updated: true,
+      restarted: true,
+      exitCode: restarted.exitCode,
+      error: restarted.error,
+      webappRestart,
+    };
   }
 
-  return { checked: true, latest, current: packageVersion, updated: true };
+  return { checked: true, latest, current: packageVersion, updated: true, webappRestart };
 }

package/src/cli.js

@@ -869,6 +869,43 @@ function stripLeadingGlobalOptions(argv = []) {
   };
 }
 
+function commandCwdFromArgv(argv = []) {
+  for (let index = 0; index < argv.length; index += 1) {
+    if (argv[index] === "--cwd") {
+      const cwd = readOption(argv, index);
+      if (cwd) return path.resolve(cwd);
+    }
+  }
+  return process.cwd();
+}
+
+function languageFromArgv(argv = []) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--language" || arg === "--lang" || arg === "-L") {
+      const first = readOption(argv, index);
+      const second = argv[index + 2] && !String(argv[index + 2]).startsWith("--") ? argv[index + 2] : "";
+      if (["cn", "zh"].includes(String(first || "").toLowerCase()) && ["s", "t"].includes(String(second || "").toLowerCase())) {
+        return resolveLanguage(`${first}-${second}`);
+      }
+      return resolveLanguage(first);
+    }
+  }
+  return "";
+}
+
+async function restartWebAppAfterUpdate({ commandCwd = process.cwd(), language = "" } = {}) {
+  return await ensureAgintiWebApp({
+    packageDir,
+    cwd: commandCwd,
+    host: process.env.AGINTI_WEB_HOST || process.env.HOST || "127.0.0.1",
+    preferredPort: process.env.AGINTI_WEB_PORT || process.env.PORT || 3210,
+    language,
+    restart: true,
+    respectAutoStartDisable: false,
+  }).catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error), url: "" }));
+}
+
 function providerLabel(provider) {
   const normalized = String(provider || "").toLowerCase();
   if (normalized === "openai") return "OpenAI";
@@ -1687,6 +1724,8 @@ export async function main(argv = process.argv.slice(2)) {
   }
 
   if (argv[0] === "update" || argv[0] === "upgrade") {
+    const updateCommandCwd = commandCwdFromArgv(argv);
+    const updateLanguage = languageFromArgv(argv);
     const updateResult = await maybeAutoUpdate({
       argv,
       force: true,
@@ -1695,11 +1734,14 @@ export async function main(argv = process.argv.slice(2)) {
       packageName: packageJson.name,
       packageVersion: packageJson.version,
       restart: false,
+      afterUpdate: () => restartWebAppAfterUpdate({ commandCwd: updateCommandCwd, language: updateLanguage }),
     });
     if (updateResult.error) process.exit(1);
     return;
   }
 
+  const updateCommandCwd = commandCwdFromArgv(argv);
+  const updateLanguage = languageFromArgv(argv);
   const autoUpdateResult = await maybeAutoUpdate({
     argv,
     force: argv.includes("--auto-update"),
@@ -1707,6 +1749,7 @@ export async function main(argv = process.argv.slice(2)) {
     packageName: packageJson.name,
     packageVersion: packageJson.version,
     restart: true,
+    afterUpdate: () => restartWebAppAfterUpdate({ commandCwd: updateCommandCwd, language: updateLanguage }),
   });
   if (autoUpdateResult.restarted) process.exit(autoUpdateResult.exitCode ?? 0);
 

package/src/web-autostart.js

@@ -187,7 +187,8 @@ export async function findReusableOrFreeWebPort({
     if (port >= 65536) break;
     const health = await fetchHealthDetails(normalizedHost, port);
     if (health.ok) {
-      if (restart && Number(port) === startPort) {
+      const compatible = compatibleHealth(health, { cwd: runtimeDir, home: homeDir, packageDir });
+      if (restart && compatible) {
         const stopped = await stopWebAppOnPort({ host: normalizedHost, port, health });
         if (!stopped.ok) return { port, host: normalizedHost, url: "", reused: false, available: false, stopped, error: stopped.error };
         return {
@@ -200,7 +201,7 @@ export async function findReusableOrFreeWebPort({
           stopped,
         };
       }
-      if (compatibleHealth(health, { cwd: runtimeDir, home: homeDir, packageDir })) {
+      if (compatible) {
         return { port, host: normalizedHost, url: webUrl(normalizedHost, port), reused: true, available: false, health };
       }
       continue;