@sapienx/agentos 0.1.2 → 0.1.6

package/README.md

@@ -19,7 +19,10 @@ Optional flags:
 ```bash
 agentos start --port 3000 --host 127.0.0.1
 agentos start --port 3000 --host 127.0.0.1 --open
+agentos stop
+agentos stop --port 3000 --force
 agentos doctor
+agentos uninstall
 ```
 
 Optional environment variables:
@@ -32,4 +35,8 @@ AGENTOS_OPEN=1
 
 `agentos doctor` prints the effective URL, bundle status, Node.js compatibility, OpenClaw detection, and browser auto-open support.
 
+`agentos stop` sends `SIGTERM` to the tracked AgentOS server on the selected port. Use `--force` only if the process refuses to stop cleanly.
+
+`agentos uninstall` removes a release-installer copy. If the package was installed with `pnpm` or `npm`, remove it with your package manager instead.
+
 AgentOS is designed to work with a local OpenClaw installation. If OpenClaw is missing, AgentOS still starts and guides onboarding in the UI.

package/bin/agentos.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, rmdirSync, writeFileSync } from "node:fs";
+import { createInterface } from "node:readline/promises";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
@@ -14,6 +15,12 @@ const bundleDir = path.join(packageRoot, "bundle");
 const bundledServerPath = path.join(bundleDir, "server.js");
 
 const packageJson = JSON.parse(await readTextFile(packageJsonPath));
+const defaultInstallRoot = path.join(os.homedir(), ".agentos");
+const defaultBinDir = path.join(os.homedir(), ".local", "bin");
+const runtimeInstallRoot = resolveRuntimeInstallRoot();
+const runtimeStateDir = path.join(runtimeInstallRoot, "run");
+const stopPollIntervalMs = 100;
+const stopTimeoutMs = 5_000;
 
 main().catch((error) => {
   console.error(error instanceof Error ? error.message : String(error));
@@ -44,6 +51,26 @@ async function main() {
     return;
   }
 
+  if (firstArg === "stop") {
+    if (args[1] === "--help" || args[1] === "-h" || args[1] === "help") {
+      printStopHelp();
+      return;
+    }
+
+    await runStop(args.slice(1));
+    return;
+  }
+
+  if (firstArg === "uninstall") {
+    if (args[1] === "--help" || args[1] === "-h" || args[1] === "help") {
+      printUninstallHelp();
+      return;
+    }
+
+    await runUninstall(args.slice(1));
+    return;
+  }
+
   if (firstArg === "start") {
     await startServer(args.slice(1));
     return;
@@ -56,9 +83,21 @@ async function startServer(rawArgs) {
   ensureBundleExists();
 
   const options = parseStartArgs(rawArgs);
+  const runtimeStatePath = resolveRuntimeStatePath(options.port);
+  const trackedState = readRuntimeState(runtimeStatePath);
   const openClawCheck = detectOpenClaw();
   const browserOpener = detectBrowserOpener();
 
+  if (trackedState?.pid && isProcessRunning(trackedState.pid)) {
+    throw new Error(
+      `AgentOS is already running on port ${options.port} (PID ${trackedState.pid}). Use "agentos stop --port ${options.port}" first.`
+    );
+  }
+
+  if (trackedState) {
+    clearRuntimeState(runtimeStatePath);
+  }
+
   const url = `http://${displayHost(options.host)}:${options.port}`;
   console.log(`Starting AgentOS on ${url}`);
 
@@ -84,6 +123,23 @@ async function startServer(rawArgs) {
     }
   });
 
+  if (!child.pid) {
+    child.kill("SIGTERM");
+    throw new Error("AgentOS could not determine the server PID.");
+  }
+
+  try {
+    writeRuntimeState(runtimeStatePath, {
+      pid: child.pid,
+      port: options.port,
+      host: options.host,
+      startedAt: new Date().toISOString()
+    });
+  } catch (error) {
+    child.kill("SIGTERM");
+    throw error;
+  }
+
   const browserState = { opened: false };
   const relayStdout = createRelay(process.stdout, options, url, browserOpener, browserState);
   const relayStderr = createRelay(process.stderr, options, url, browserOpener, browserState);
@@ -91,6 +147,19 @@ async function startServer(rawArgs) {
   child.stdout.on("data", relayStdout);
   child.stderr.on("data", relayStderr);
 
+  let cleanedUp = false;
+  const cleanup = () => {
+    if (cleanedUp) {
+      return;
+    }
+
+    cleanedUp = true;
+    process.off("SIGINT", forwardSignal);
+    process.off("SIGTERM", forwardSignal);
+    process.off("SIGQUIT", forwardSignal);
+    clearRuntimeState(runtimeStatePath, child.pid);
+  };
+
   const forwardSignal = (signal) => {
     if (!child.killed) {
       child.kill(signal);
@@ -99,10 +168,16 @@ async function startServer(rawArgs) {
 
   process.on("SIGINT", forwardSignal);
   process.on("SIGTERM", forwardSignal);
+  process.on("SIGQUIT", forwardSignal);
+
+  child.on("error", (error) => {
+    cleanup();
+    console.error(`AgentOS failed to start: ${error.message}`);
+    process.exit(1);
+  });
 
   child.on("exit", (code, signal) => {
-    process.off("SIGINT", forwardSignal);
-    process.off("SIGTERM", forwardSignal);
+    cleanup();
 
     if (signal) {
       process.kill(process.pid, signal);
@@ -176,6 +251,48 @@ function runDoctor() {
   }
 }
 
+async function runStop(rawArgs) {
+  const options = parseStopArgs(rawArgs);
+  const runtimeStatePath = resolveRuntimeStatePath(options.port);
+  const trackedState = readRuntimeState(runtimeStatePath);
+  const targetPid = trackedState?.pid ?? findListeningPidForPort(options.port);
+
+  if (!targetPid) {
+    clearRuntimeState(runtimeStatePath);
+    console.log(`No running AgentOS process was found on port ${options.port}.`);
+    return;
+  }
+
+  console.log(`Stopping AgentOS on port ${options.port} (PID ${targetPid})...`);
+
+  try {
+    process.kill(targetPid, options.force ? "SIGKILL" : "SIGTERM");
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ESRCH") {
+      clearRuntimeState(runtimeStatePath);
+      console.log(`AgentOS is not running on port ${options.port}.`);
+      return;
+    }
+
+    throw error;
+  }
+
+  const stopped = await waitForProcessExit(targetPid, options.force ? 1_000 : stopTimeoutMs);
+
+  if (!stopped) {
+    console.error(
+      options.force
+        ? `AgentOS did not stop after SIGKILL on port ${options.port}.`
+        : `AgentOS did not stop within ${Math.round(stopTimeoutMs / 1000)} seconds. Re-run "agentos stop --port ${options.port} --force" if you want to terminate it.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  clearRuntimeState(runtimeStatePath);
+  console.log(`Stopped AgentOS on port ${options.port}.`);
+}
+
 function parseStartArgs(rawArgs) {
   const envPort = process.env.AGENTOS_PORT || process.env.PORT;
   const options = {
@@ -233,6 +350,59 @@ function parseStartArgs(rawArgs) {
   return options;
 }
 
+function parseStopArgs(rawArgs) {
+  const envPort = process.env.AGENTOS_PORT || process.env.PORT;
+  const options = {
+    port: envPort && /^\d+$/.test(envPort) ? Number(envPort) : 3000,
+    force: false
+  };
+
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const arg = rawArgs[index];
+
+    if (arg === "--port" || arg === "-p") {
+      const value = rawArgs[index + 1];
+      index += 1;
+      assertPort(value);
+      options.port = Number(value);
+      continue;
+    }
+
+    if (arg.startsWith("--port=")) {
+      const value = arg.slice("--port=".length);
+      assertPort(value);
+      options.port = Number(value);
+      continue;
+    }
+
+    if (arg === "--force" || arg === "-f") {
+      options.force = true;
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+}
+
+function parseUninstallArgs(rawArgs) {
+  const options = {
+    yes: false
+  };
+
+  for (const arg of rawArgs) {
+    if (arg === "--yes" || arg === "-y") {
+      options.yes = true;
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+}
+
 function assertPort(value) {
   if (!value || !/^\d+$/.test(value)) {
     throw new Error("Expected a numeric value after --port.");
@@ -328,14 +498,44 @@ function printHelp() {
 Usage:
   agentos
   agentos start --port 3000 --host 127.0.0.1 --open
+  agentos stop --port 3000 [--force]
   agentos doctor
+  agentos uninstall [--yes]
   agentos --version
 
 Options:
-  --port, -p   Port to bind the local server (default: 3000)
-  --host, -H   Host to bind the local server (default: 127.0.0.1)
-  --open, -o   Open AgentOS in the default browser after startup
-  --no-open    Disable browser auto-open even if AGENTOS_OPEN is set
+  start: --port, -p   Port to bind the local server (default: 3000)
+  start: --host, -H   Host to bind the local server (default: 127.0.0.1)
+  start: --open, -o   Open AgentOS in the default browser after startup
+  start: --no-open    Disable browser auto-open even if AGENTOS_OPEN is set
+  stop:  --port, -p   Port to stop (default: 3000)
+  stop:  --force, -f  Send SIGKILL if SIGTERM does not stop the server
+`);
+}
+
+function printStopHelp() {
+  console.log(`Stop a running AgentOS server.
+
+Usage:
+  agentos stop
+  agentos stop --port 3000
+  agentos stop --port 3000 --force
+
+Options:
+  --port, -p    Port to stop (default: 3000)
+  --force, -f   Send SIGKILL if SIGTERM does not stop the server
+`);
+}
+
+function printUninstallHelp() {
+  console.log(`Remove an AgentOS release installation.
+
+Usage:
+  agentos uninstall
+  agentos uninstall --yes
+
+Options:
+  --yes, -y   Skip the confirmation prompt
 `);
 }
 
@@ -427,3 +627,298 @@ async function readTextFile(filePath) {
   const { readFile } = await import("node:fs/promises");
   return readFile(filePath, "utf8");
 }
+
+async function runUninstall(rawArgs) {
+  const options = parseUninstallArgs(rawArgs);
+  const install = inspectInstallation();
+
+  if (install.kind === "package-manager") {
+    printPackageManagerUninstallGuidance();
+    return;
+  }
+
+  if (install.kind === "source") {
+    console.log("This AgentOS copy looks like a source checkout, not a release installation.");
+    console.log(`Delete the checkout manually if you want to remove it: ${findRepoRoot()}`);
+    return;
+  }
+
+  if (!options.yes) {
+    const confirmed = await confirmUninstall(install);
+
+    if (!confirmed) {
+      console.log("Uninstall cancelled.");
+      return;
+    }
+  }
+
+  const removedPaths = [];
+
+  if (await removePathIfExists(install.packagePath)) {
+    removedPaths.push(install.packagePath);
+  }
+
+  if (install.launcherPath && (await removePathIfExists(install.launcherPath))) {
+    removedPaths.push(install.launcherPath);
+  }
+
+  await removeDirectoryIfEmpty(install.installRoot);
+
+  if (removedPaths.length === 0) {
+    console.log("No removable AgentOS release files were found.");
+    return;
+  }
+
+  console.log("Removed AgentOS release installation:");
+
+  for (const removedPath of removedPaths) {
+    console.log(`- ${removedPath}`);
+  }
+
+  if (!install.launcherPath) {
+    console.log(`No managed launcher was detected on PATH. If you used a custom bin directory, remove that launcher manually.`);
+  }
+}
+
+function inspectInstallation() {
+  if (path.basename(packageRoot) === "package") {
+    return {
+      kind: "release",
+      installRoot: path.dirname(packageRoot),
+      packagePath: packageRoot,
+      launcherPath: detectManagedLauncher(packageRoot)
+    };
+  }
+
+  if (packageRoot.includes(`${path.sep}node_modules${path.sep}`) || packageRoot.includes(`${path.sep}.pnpm${path.sep}`)) {
+    return {
+      kind: "package-manager"
+    };
+  }
+
+  return {
+    kind: "source"
+  };
+}
+
+function printPackageManagerUninstallGuidance() {
+  console.log("This AgentOS install appears to come from a package manager.");
+  console.log("Remove it with one of:");
+  console.log("  pnpm remove -g @sapienx/agentos");
+  console.log("  npm uninstall -g @sapienx/agentos");
+}
+
+function findRepoRoot() {
+  return path.resolve(packageRoot, "..", "..");
+}
+
+function detectManagedLauncher(installedPackagePath) {
+  const scriptMarker = normalizeForMatch(path.join(installedPackagePath, "bin", "agentos.js"));
+  const candidates = new Set([
+    resolveCommandPath("agentos"),
+    path.join(defaultBinDir, "agentos")
+  ]);
+
+  for (const candidate of candidates) {
+    if (!candidate || !existsSync(candidate)) {
+      continue;
+    }
+
+    try {
+      const contents = readFileSync(candidate, "utf8");
+
+      if (normalizeForMatch(contents).includes(scriptMarker)) {
+        return candidate;
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return null;
+}
+
+function normalizeForMatch(value) {
+  return value.replaceAll("\\", "/");
+}
+
+function resolveRuntimeInstallRoot() {
+  if (process.env.AGENTOS_INSTALL_ROOT) {
+    return path.resolve(process.env.AGENTOS_INSTALL_ROOT);
+  }
+
+  if (path.basename(packageRoot) === "package") {
+    return path.dirname(packageRoot);
+  }
+
+  return defaultInstallRoot;
+}
+
+function resolveRuntimeStatePath(port) {
+  return path.join(runtimeStateDir, `agentos-${port}.json`);
+}
+
+function readRuntimeState(runtimeStatePath) {
+  if (!existsSync(runtimeStatePath)) {
+    return null;
+  }
+
+  try {
+    const payload = JSON.parse(readFileSync(runtimeStatePath, "utf8"));
+
+    if (!payload || typeof payload !== "object" || !Number.isInteger(payload.pid) || payload.pid <= 0) {
+      return null;
+    }
+
+    return payload;
+  } catch {
+    return null;
+  }
+}
+
+function writeRuntimeState(runtimeStatePath, payload) {
+  mkdirSync(runtimeStateDir, {
+    recursive: true
+  });
+  writeFileSync(runtimeStatePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+
+function clearRuntimeState(runtimeStatePath, expectedPid) {
+  if (existsSync(runtimeStatePath)) {
+    if (expectedPid) {
+      const payload = readRuntimeState(runtimeStatePath);
+
+      if (payload?.pid && payload.pid !== expectedPid) {
+        return;
+      }
+    }
+
+    rmSync(runtimeStatePath, {
+      force: true
+    });
+  }
+
+  if (!existsSync(runtimeStateDir)) {
+    return;
+  }
+
+  if (readdirSync(runtimeStateDir).length === 0) {
+    rmdirSync(runtimeStateDir);
+  }
+}
+
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error) {
+      if (error.code === "ESRCH") {
+        return false;
+      }
+
+      if (error.code === "EPERM") {
+        return true;
+      }
+    }
+
+    throw error;
+  }
+}
+
+function findListeningPidForPort(port) {
+  if (process.platform === "win32") {
+    return null;
+  }
+
+  const result = spawnSync("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], {
+    encoding: "utf8"
+  });
+
+  if (result.error || result.status !== 0) {
+    return null;
+  }
+
+  const firstLine = result.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find(Boolean);
+
+  if (!firstLine || !/^\d+$/.test(firstLine)) {
+    return null;
+  }
+
+  return Number(firstLine);
+}
+
+async function waitForProcessExit(pid, timeoutMs) {
+  const startedAt = Date.now();
+
+  while (Date.now() - startedAt < timeoutMs) {
+    if (!isProcessRunning(pid)) {
+      return true;
+    }
+
+    await new Promise((resolve) => {
+      setTimeout(resolve, stopPollIntervalMs);
+    });
+  }
+
+  return !isProcessRunning(pid);
+}
+
+async function confirmUninstall(install) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("Refusing to uninstall without --yes in a non-interactive terminal.");
+  }
+
+  console.log("AgentOS release uninstall");
+  console.log(`Package: ${install.packagePath}`);
+
+  if (install.launcherPath) {
+    console.log(`Launcher: ${install.launcherPath}`);
+  } else {
+    console.log(`Launcher: not detected on PATH`);
+  }
+
+  const readline = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  try {
+    const answer = await readline.question("Remove these files? [y/N] ");
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    readline.close();
+  }
+}
+
+async function removePathIfExists(targetPath) {
+  const { rm } = await import("node:fs/promises");
+
+  if (!existsSync(targetPath)) {
+    return false;
+  }
+
+  await rm(targetPath, {
+    recursive: true,
+    force: true
+  });
+
+  return true;
+}
+
+async function removeDirectoryIfEmpty(targetPath) {
+  const { readdir, rmdir } = await import("node:fs/promises");
+
+  if (!existsSync(targetPath)) {
+    return;
+  }
+
+  const entries = await readdir(targetPath);
+
+  if (entries.length === 0) {
+    await rmdir(targetPath);
+  }
+}

package/bundle/.next/BUILD_ID

@@ -1 +1 @@
-VOlzZmzuIhPpxC4007UHA
+4ThNPJp9bEISWCDFyw3Jd

package/bundle/.next/app-path-routes-manifest.json

@@ -1,25 +1,26 @@
 {
-  "/_not-found/page": "/_not-found",
   "/_global-error/page": "/_global-error",
-  "/api/mission/route": "/api/mission",
+  "/_not-found/page": "/_not-found",
   "/api/files/reveal/route": "/api/files/reveal",
   "/api/agents/route": "/api/agents",
   "/api/diagnostics/route": "/api/diagnostics",
   "/api/gateway/control/route": "/api/gateway/control",
-  "/api/planner/[planId]/route": "/api/planner/[planId]",
-  "/api/planner/[planId]/deploy/route": "/api/planner/[planId]/deploy",
+  "/api/mission/route": "/api/mission",
   "/api/planner/[planId]/simulate/route": "/api/planner/[planId]/simulate",
+  "/api/planner/[planId]/deploy/route": "/api/planner/[planId]/deploy",
+  "/api/planner/[planId]/route": "/api/planner/[planId]",
+  "/api/planner/[planId]/turn/route": "/api/planner/[planId]/turn",
   "/api/runtimes/[runtimeId]/route": "/api/runtimes/[runtimeId]",
+  "/api/snapshot/route": "/api/snapshot",
+  "/api/reset/route": "/api/reset",
+  "/api/settings/workspace-root/route": "/api/settings/workspace-root",
+  "/api/onboarding/models/route": "/api/onboarding/models",
   "/api/settings/gateway/route": "/api/settings/gateway",
   "/api/planner/route": "/api/planner",
-  "/api/planner/[planId]/turn/route": "/api/planner/[planId]/turn",
-  "/api/settings/workspace-root/route": "/api/settings/workspace-root",
-  "/api/snapshot/route": "/api/snapshot",
   "/api/system/open-terminal/route": "/api/system/open-terminal",
   "/api/stream/route": "/api/stream",
-  "/api/onboarding/route": "/api/onboarding",
   "/api/update/route": "/api/update",
-  "/api/onboarding/models/route": "/api/onboarding/models",
+  "/api/onboarding/route": "/api/onboarding",
   "/api/workspaces/route": "/api/workspaces",
   "/page": "/"
 }

package/bundle/.next/build-manifest.json

@@ -4,14 +4,14 @@
   ],
   "devFiles": [],
   "lowPriorityFiles": [
-    "static/VOlzZmzuIhPpxC4007UHA/_buildManifest.js",
-    "static/VOlzZmzuIhPpxC4007UHA/_ssgManifest.js"
+    "static/4ThNPJp9bEISWCDFyw3Jd/_buildManifest.js",
+    "static/4ThNPJp9bEISWCDFyw3Jd/_ssgManifest.js"
   ],
   "rootMainFiles": [
     "static/chunks/webpack-032b5b42e067a790.js",
     "static/chunks/474f1956-ebf51c0dd00ff236.js",
     "static/chunks/26-8f7c2b7e8773b4cb.js",
-    "static/chunks/main-app-9229332086036e25.js"
+    "static/chunks/main-app-245e6e74e3ad1df9.js"
   ],
   "rootMainFilesTree": {},
   "pages": {

package/bundle/.next/required-server-files.json

@@ -101,7 +101,7 @@
         "transform": "lodash/{{member}}"
       }
     },
-    "outputFileTracingRoot": "/Users/kazimakgul/Documents/GitHub/AgentOS-Core",
+    "outputFileTracingRoot": "/Users/kazimakgul/Documents/GitHub/AgentOS",
     "cacheComponents": false,
     "cacheLife": {
       "default": {
@@ -294,11 +294,11 @@
     "bundlePagesRouterDependencies": false,
     "configFileName": "next.config.mjs",
     "turbopack": {
-      "root": "/Users/kazimakgul/Documents/GitHub/AgentOS-Core"
+      "root": "/Users/kazimakgul/Documents/GitHub/AgentOS"
     },
     "distDirRoot": ".next"
   },
-  "appDir": "/Users/kazimakgul/Documents/GitHub/AgentOS-Core",
+  "appDir": "/Users/kazimakgul/Documents/GitHub/AgentOS",
   "relativeAppDir": "",
   "files": [
     ".next/routes-manifest.json",

package/bundle/.next/routes-manifest.json

@@ -129,6 +129,12 @@
       "routeKeys": {},
       "namedRegex": "^/api/planner(?:/)?$"
     },
+    {
+      "page": "/api/reset",
+      "regex": "^/api/reset(?:/)?$",
+      "routeKeys": {},
+      "namedRegex": "^/api/reset(?:/)?$"
+    },
     {
       "page": "/api/settings/gateway",
       "regex": "^/api/settings/gateway(?:/)?$",