nextclaw 0.9.10 → 0.9.12

package/dist/cli/index.js

@@ -1831,8 +1831,8 @@ import { join as join3 } from "path";
 var CronCommands = class {
   cronList(opts) {
     const storePath = join3(getDataDir3(), "cron", "jobs.json");
-    const service2 = new CronService(storePath);
-    const jobs = service2.listJobs(Boolean(opts.all));
+    const service = new CronService(storePath);
+    const jobs = service.listJobs(Boolean(opts.all));
     if (!jobs.length) {
       console.log("No scheduled jobs.");
       return;
@@ -1851,7 +1851,7 @@ var CronCommands = class {
   }
   cronAdd(opts) {
     const storePath = join3(getDataDir3(), "cron", "jobs.json");
-    const service2 = new CronService(storePath);
+    const service = new CronService(storePath);
     let schedule = null;
     if (opts.every) {
       schedule = { kind: "every", everyMs: Number(opts.every) * 1e3 };
@@ -1864,7 +1864,7 @@ var CronCommands = class {
       console.error("Error: Must specify --every, --cron, or --at");
       return;
     }
-    const job = service2.addJob({
+    const job = service.addJob({
       name: opts.name,
       schedule,
       message: opts.message,
@@ -1876,8 +1876,8 @@ var CronCommands = class {
   }
   cronRemove(jobId) {
     const storePath = join3(getDataDir3(), "cron", "jobs.json");
-    const service2 = new CronService(storePath);
-    if (service2.removeJob(jobId)) {
+    const service = new CronService(storePath);
+    if (service.removeJob(jobId)) {
       console.log(`\u2713 Removed job ${jobId}`);
     } else {
       console.log(`Job ${jobId} not found`);
@@ -1885,8 +1885,8 @@ var CronCommands = class {
   }
   cronEnable(jobId, opts) {
     const storePath = join3(getDataDir3(), "cron", "jobs.json");
-    const service2 = new CronService(storePath);
-    const job = service2.enableJob(jobId, !opts.disable);
+    const service = new CronService(storePath);
+    const job = service.enableJob(jobId, !opts.disable);
     if (job) {
       console.log(`\u2713 Job '${job.name}' ${opts.disable ? "disabled" : "enabled"}`);
     } else {
@@ -1895,8 +1895,8 @@ var CronCommands = class {
   }
   async cronRun(jobId, opts) {
     const storePath = join3(getDataDir3(), "cron", "jobs.json");
-    const service2 = new CronService(storePath);
-    const ok = await service2.runJob(jobId, Boolean(opts.force));
+    const service = new CronService(storePath);
+    const ok = await service.runJob(jobId, Boolean(opts.force));
     console.log(ok ? "\u2713 Job executed" : `Failed to run job ${jobId}`);
   }
 };
@@ -2252,12 +2252,12 @@ import {
   stopPluginChannelGateways
 } from "@nextclaw/openclaw-compat";
 import { startUiServer } from "@nextclaw/server";
-import { appendFileSync, closeSync, cpSync, existsSync as existsSync8, mkdirSync as mkdirSync4, openSync, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
+import { appendFileSync, closeSync, cpSync, existsSync as existsSync8, mkdirSync as mkdirSync4, mkdtempSync, openSync, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
 import { dirname, isAbsolute as isAbsolute2, join as join5, relative, resolve as resolve7 } from "path";
-import { spawn as spawn2, spawnSync as spawnSync4 } from "child_process";
+import { tmpdir } from "os";
+import { spawn as spawn2 } from "child_process";
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
-import { homedir, userInfo } from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import chokidar from "chokidar";
 
@@ -4035,85 +4035,6 @@ var ServiceCommands = class {
     clearServiceState();
     console.log(`\u2713 ${APP_NAME2} stopped`);
   }
-  async installSystemdService(options) {
-    if (process.platform !== "linux") {
-      console.error("Error: systemd installation is only supported on Linux.");
-      return;
-    }
-    if (typeof process.getuid === "function" && process.getuid() !== 0) {
-      console.error("Error: Run this command as root (for example: sudo nextclaw service install-systemd).");
-      return;
-    }
-    const serviceName = this.resolveSystemdServiceName(options.name);
-    const config2 = loadConfig6();
-    const uiConfig = resolveUiConfig(config2, { enabled: true, host: "0.0.0.0" });
-    const uiPort = this.parseSystemdUiPort(options.uiPort, uiConfig.port);
-    if (uiPort === null) {
-      console.error("Error: Invalid --ui-port. Provide a positive integer.");
-      return;
-    }
-    const systemctlAvailable = this.runSystemCommand("systemctl", ["--version"]);
-    if (!systemctlAvailable.ok) {
-      console.error("Error: systemctl is not available on this machine.");
-      return;
-    }
-    const runUser = this.resolveSystemdRunUser();
-    const runHome = this.resolveSystemdRunHome(runUser);
-    const servicePath = `/etc/systemd/system/${serviceName}.service`;
-    const cliPath = fileURLToPath2(new URL("../index.js", import.meta.url));
-    const execArgs = [process.execPath, ...process.execArgv, cliPath, "serve", "--ui-port", String(uiPort)];
-    const unit = this.buildSystemdUnit({
-      runUser,
-      runHome,
-      execArgs
-    });
-    writeFileSync4(servicePath, unit, "utf-8");
-    const daemonReload = this.runSystemCommand("systemctl", ["daemon-reload"]);
-    if (!daemonReload.ok) {
-      console.error(`Error: Failed to reload systemd. ${daemonReload.stderr}`.trim());
-      return;
-    }
-    const enableStart = this.runSystemCommand("systemctl", ["enable", "--now", `${serviceName}.service`]);
-    if (!enableStart.ok) {
-      console.error(`Error: Failed to enable/start ${serviceName}.service. ${enableStart.stderr}`.trim());
-      return;
-    }
-    const active = this.runSystemCommand("systemctl", ["is-active", `${serviceName}.service`]);
-    if (!active.ok || active.stdout.trim() !== "active") {
-      console.error(`Error: ${serviceName}.service is not active. ${active.stderr || active.stdout}`.trim());
-      return;
-    }
-    console.log(`\u2713 Installed systemd service: ${serviceName}.service`);
-    console.log(`Run user: ${runUser}`);
-    console.log(`UI port: ${uiPort}`);
-    console.log(`Unit file: ${servicePath}`);
-    console.log(`Health: http://127.0.0.1:${uiPort}/api/health`);
-    console.log(`Logs: journalctl -u ${serviceName}.service -f`);
-  }
-  async uninstallSystemdService(options) {
-    if (process.platform !== "linux") {
-      console.error("Error: systemd removal is only supported on Linux.");
-      return;
-    }
-    if (typeof process.getuid === "function" && process.getuid() !== 0) {
-      console.error("Error: Run this command as root.");
-      return;
-    }
-    const serviceName = this.resolveSystemdServiceName(options.name);
-    const servicePath = `/etc/systemd/system/${serviceName}.service`;
-    if (!existsSync8(servicePath)) {
-      console.error(`Error: ${servicePath} does not exist.`);
-      return;
-    }
-    this.runSystemCommand("systemctl", ["disable", "--now", `${serviceName}.service`]);
-    rmSync3(servicePath, { force: true });
-    const daemonReload = this.runSystemCommand("systemctl", ["daemon-reload"]);
-    if (!daemonReload.ok) {
-      console.error(`Warning: Removed unit file but failed to reload systemd. ${daemonReload.stderr}`.trim());
-      return;
-    }
-    console.log(`\u2713 Removed systemd service: ${serviceName}.service`);
-  }
   async waitForBackgroundServiceReady(params) {
     const startedAt = Date.now();
     let lastProbeError = null;
@@ -4144,78 +4065,6 @@ var ServiceCommands = class {
     const resolved = fromOverride ?? fromEnv ?? fallback;
     return Math.max(3e3, resolved);
   }
-  resolveSystemdServiceName(rawName) {
-    const trimmed = rawName?.trim() || APP_NAME2;
-    return trimmed.endsWith(".service") ? trimmed.slice(0, -".service".length) : trimmed;
-  }
-  parseSystemdUiPort(rawPort, fallbackPort) {
-    if (rawPort === void 0 || rawPort === null || rawPort === "") {
-      return fallbackPort;
-    }
-    const parsed = Number(rawPort);
-    if (!Number.isInteger(parsed) || parsed <= 0) {
-      return null;
-    }
-    return parsed;
-  }
-  resolveSystemdRunUser() {
-    const sudoUser = process.env.SUDO_USER?.trim();
-    if (sudoUser && sudoUser !== "root") {
-      return sudoUser;
-    }
-    return userInfo().username;
-  }
-  resolveSystemdRunHome(runUser) {
-    const passwd = this.runSystemCommand("getent", ["passwd", runUser]);
-    if (passwd.ok) {
-      const fields = passwd.stdout.trim().split(":");
-      if (fields.length >= 6 && fields[5]) {
-        return fields[5];
-      }
-    }
-    return process.env.HOME?.trim() || homedir();
-  }
-  buildSystemdUnit(params) {
-    const execStart = params.execArgs.map((arg) => this.escapeSystemdArg(arg)).join(" ");
-    return [
-      "[Unit]",
-      `Description=${APP_NAME2} gateway + UI`,
-      "After=network-online.target",
-      "Wants=network-online.target",
-      "",
-      "[Service]",
-      "Type=simple",
-      `User=${params.runUser}`,
-      `WorkingDirectory=${params.runHome}`,
-      `Environment=HOME=${params.runHome}`,
-      "Environment=NODE_ENV=production",
-      `ExecStart=${execStart}`,
-      "Restart=always",
-      "RestartSec=3",
-      "TimeoutStopSec=20",
-      "",
-      "[Install]",
-      "WantedBy=multi-user.target",
-      ""
-    ].join("\n");
-  }
-  escapeSystemdArg(value) {
-    if (/^[A-Za-z0-9_./:@%+=,-]+$/.test(value)) {
-      return value;
-    }
-    return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
-  }
-  runSystemCommand(command, args) {
-    const result = spawnSync4(command, args, {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    return {
-      ok: result.status === 0,
-      stdout: result.stdout ?? "",
-      stderr: result.stderr ?? ""
-    };
-  }
   appendStartupStage(logPath, message) {
     try {
       appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] [startup] ${message}
@@ -4519,54 +4368,221 @@ var ServiceCommands = class {
     if (existsSync8(destination) && params.force) {
       rmSync3(destination, { recursive: true, force: true });
     }
-    const skildArgs = ["--yes", "skild", "install", source, "--target", "agents", "--local", "--json", "--skill", skillName];
-    if (params.registry) {
-      skildArgs.push("--registry", params.registry);
+    const materialized = await this.materializeMarketplaceGitSkillSource({ source, skillName });
+    try {
+      const installSkillFile = join5(materialized.skillDir, "SKILL.md");
+      if (!existsSync8(installSkillFile)) {
+        throw new Error(`git skill source does not contain SKILL.md for ${skillName}`);
+      }
+      mkdirSync4(dirname(destination), { recursive: true });
+      cpSync(materialized.skillDir, destination, { recursive: true, force: true });
+      return {
+        message: `Installed skill: ${skillName}`,
+        output: [
+          `Source: ${source}`,
+          `Materialized skill: ${materialized.skillDir}`,
+          `Workspace target: ${destination}`,
+          materialized.commandOutput
+        ].filter(Boolean).join("\n")
+      };
+    } finally {
+      rmSync3(materialized.tempRoot, { recursive: true, force: true });
     }
-    if (params.force) {
-      skildArgs.push("--force");
+  }
+  async materializeMarketplaceGitSkillSource(params) {
+    const parsed = this.parseMarketplaceGitSkillSource(params.source);
+    const gitPath = this.resolveGitExecutablePath();
+    const fallbackNotes = [];
+    if (gitPath) {
+      try {
+        return await this.materializeMarketplaceGitSkillViaGit({ gitPath, parsed });
+      } catch (error) {
+        fallbackNotes.push(`Git fast path failed: ${String(error)}`);
+      }
+    } else {
+      fallbackNotes.push("Git fast path unavailable: git executable not found");
     }
-    let result = await this.runCommandWithFallback(
-      ["npx", "/opt/homebrew/bin/npx", "/usr/local/bin/npx"],
-      skildArgs,
-      {
-        cwd: workspace,
+    const httpResult = await this.materializeMarketplaceGitSkillViaGithubApi(parsed);
+    return {
+      ...httpResult,
+      commandOutput: [...fallbackNotes, httpResult.commandOutput].filter(Boolean).join("\n")
+    };
+  }
+  resolveGitExecutablePath() {
+    return findExecutableOnPath("git");
+  }
+  async materializeMarketplaceGitSkillViaGit(params) {
+    const tempRoot = mkdtempSync(join5(tmpdir(), "nextclaw-marketplace-skill-"));
+    const repoDir = join5(tempRoot, "repo");
+    try {
+      const cloneArgs = ["clone", "--depth", "1", "--filter=blob:none", "--sparse"];
+      if (params.parsed.ref) {
+        cloneArgs.push("--branch", params.parsed.ref);
+      }
+      cloneArgs.push(params.parsed.repoUrl, repoDir);
+      const cloneResult = await this.runCommand(params.gitPath, cloneArgs, {
+        cwd: tempRoot,
         timeoutMs: 18e4
+      });
+      const sparseResult = await this.runCommand(params.gitPath, ["-C", repoDir, "sparse-checkout", "set", params.parsed.skillPath], {
+        cwd: tempRoot,
+        timeoutMs: 6e4
+      });
+      const skillDir = join5(repoDir, params.parsed.skillPath);
+      return {
+        tempRoot,
+        skillDir,
+        commandOutput: [
+          "Installer path: git-sparse",
+          `Git repository: ${params.parsed.repoUrl}`,
+          `Git path: ${params.parsed.skillPath}`,
+          this.mergeCommandOutput(cloneResult.stdout, cloneResult.stderr),
+          this.mergeCommandOutput(sparseResult.stdout, sparseResult.stderr)
+        ].filter(Boolean).join("\n")
+      };
+    } catch (error) {
+      rmSync3(tempRoot, { recursive: true, force: true });
+      throw error;
+    }
+  }
+  async materializeMarketplaceGitSkillViaGithubApi(parsed) {
+    const tempRoot = mkdtempSync(join5(tmpdir(), "nextclaw-marketplace-skill-"));
+    const skillDir = join5(tempRoot, "skill");
+    const downloadedFiles = [];
+    try {
+      mkdirSync4(skillDir, { recursive: true });
+      await this.downloadGithubDirectoryToPath({
+        parsed,
+        remotePath: parsed.skillPath,
+        localDir: skillDir,
+        relativePrefix: "",
+        downloadedFiles
+      });
+      return {
+        tempRoot,
+        skillDir,
+        commandOutput: [
+          "Installer path: github-http",
+          `Git repository: ${parsed.repoUrl}`,
+          `Git path: ${parsed.skillPath}`,
+          `Downloaded files: ${downloadedFiles.length}`
+        ].join("\n")
+      };
+    } catch (error) {
+      rmSync3(tempRoot, { recursive: true, force: true });
+      throw error;
+    }
+  }
+  async downloadGithubDirectoryToPath(params) {
+    const encodedPath = params.remotePath.split("/").filter(Boolean).map((segment) => encodeURIComponent(segment)).join("/");
+    const apiUrl = new URL(`https://api.github.com/repos/${params.parsed.owner}/${params.parsed.repo}/contents/${encodedPath}`);
+    if (params.parsed.ref) {
+      apiUrl.searchParams.set("ref", params.parsed.ref);
+    }
+    const payload = await this.fetchJsonWithHeaders(apiUrl.toString(), {
+      Accept: "application/vnd.github+json",
+      "User-Agent": `${APP_NAME2}/${getPackageVersion()}`
+    });
+    if (!Array.isArray(payload)) {
+      throw new Error(`GitHub path is not a directory: ${params.remotePath}`);
+    }
+    for (const entry of payload) {
+      if (!entry || typeof entry !== "object") {
+        continue;
       }
-    );
-    let payload = this.parseSkildJsonOutput(result.stdout);
-    if (!payload) {
-      const forceArgs = skildArgs.includes("--force") ? skildArgs : [...skildArgs, "--force"];
-      result = await this.runCommandWithFallback(
-        ["npx", "/opt/homebrew/bin/npx", "/usr/local/bin/npx"],
-        forceArgs,
-        {
-          cwd: workspace,
-          timeoutMs: 18e4
-        }
-      );
-      payload = this.parseSkildJsonOutput(result.stdout);
+      const item = entry;
+      const itemName = typeof item.name === "string" ? item.name.trim() : "";
+      const itemPath = typeof item.path === "string" ? item.path.trim() : "";
+      if (!itemName || !itemPath) {
+        continue;
+      }
+      if (item.type === "dir") {
+        const childLocalDir = join5(params.localDir, itemName);
+        mkdirSync4(childLocalDir, { recursive: true });
+        await this.downloadGithubDirectoryToPath({
+          parsed: params.parsed,
+          remotePath: itemPath,
+          localDir: childLocalDir,
+          relativePrefix: params.relativePrefix ? `${params.relativePrefix}/${itemName}` : itemName,
+          downloadedFiles: params.downloadedFiles
+        });
+        continue;
+      }
+      if (item.type !== "file") {
+        throw new Error(`Unsupported GitHub skill entry type: ${item.type ?? "unknown"}`);
+      }
+      if (!item.download_url) {
+        throw new Error(`GitHub skill file missing download_url: ${itemPath}`);
+      }
+      const content = await this.fetchBinaryWithHeaders(item.download_url, {
+        "User-Agent": `${APP_NAME2}/${getPackageVersion()}`
+      });
+      const localFile = join5(params.localDir, itemName);
+      writeFileSync4(localFile, content);
+      params.downloadedFiles.push(params.relativePrefix ? `${params.relativePrefix}/${itemName}` : itemName);
     }
-    if (!payload) {
-      throw new Error("skild returned null json payload even after force reinstall");
+  }
+  async fetchJsonWithHeaders(url, headers) {
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status} when fetching ${url}`);
     }
-    const installDir = typeof payload.installDir === "string" ? payload.installDir.trim() : "";
-    const installSkillFile = installDir ? join5(installDir, "SKILL.md") : "";
-    if (!installDir || !existsSync8(installSkillFile)) {
-      throw new Error(`skild install did not produce a valid skill directory for ${skillName}`);
+    return await response.json();
+  }
+  async fetchBinaryWithHeaders(url, headers) {
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status} when downloading ${url}`);
     }
-    mkdirSync4(dirname(destination), { recursive: true });
-    if (resolve7(installDir) !== resolve7(destination)) {
-      cpSync(installDir, destination, { recursive: true, force: true });
+    const bytes = await response.arrayBuffer();
+    return Buffer.from(bytes);
+  }
+  parseMarketplaceGitSkillSource(source) {
+    const trimmed = source.trim();
+    if (!trimmed) {
+      throw new Error("Git skill source is required");
+    }
+    if (trimmed.includes("://")) {
+      const parsedUrl = new URL(trimmed);
+      if (parsedUrl.hostname !== "github.com") {
+        throw new Error(`Unsupported git skill source host: ${parsedUrl.hostname}`);
+      }
+      const parts2 = parsedUrl.pathname.split("/").filter(Boolean);
+      if (parts2.length < 5 || parts2[2] !== "tree" && parts2[2] !== "blob") {
+        throw new Error(`Unsupported GitHub skill source URL: ${source}`);
+      }
+      const [owner2, repoRaw, , ref2, ...pathParts2] = parts2;
+      const repo2 = repoRaw.replace(/\.git$/i, "");
+      if (!owner2 || !repo2 || !ref2 || pathParts2.length === 0) {
+        throw new Error(`Unsupported GitHub skill source URL: ${source}`);
+      }
+      return {
+        owner: owner2,
+        repo: repo2,
+        repoUrl: `https://github.com/${owner2}/${repo2}.git`,
+        skillPath: pathParts2.join("/"),
+        ref: ref2
+      };
+    }
+    const parts = trimmed.split("/").filter(Boolean);
+    if (parts.length < 3) {
+      throw new Error(`Unsupported git skill source: ${source}`);
+    }
+    const owner = parts[0] ?? "";
+    const repoWithOptionalRef = parts[1] ?? "";
+    const pathParts = parts.slice(2);
+    const atIndex = repoWithOptionalRef.indexOf("@");
+    const repo = (atIndex >= 0 ? repoWithOptionalRef.slice(0, atIndex) : repoWithOptionalRef).replace(/\.git$/i, "");
+    const ref = atIndex >= 0 ? repoWithOptionalRef.slice(atIndex + 1) : void 0;
+    if (!owner || !repo || pathParts.length === 0) {
+      throw new Error(`Unsupported git skill source: ${source}`);
     }
     return {
-      message: `Installed skill: ${skillName}`,
-      output: [
-        `Source: ${source}`,
-        `Installed via skild: ${installDir}`,
-        `Workspace target: ${destination}`,
-        this.mergeCommandOutput(result.stdout, result.stderr)
-      ].filter(Boolean).join("\n")
+      owner,
+      repo,
+      repoUrl: `https://github.com/${owner}/${repo}.git`,
+      skillPath: pathParts.join("/"),
+      ref: ref && ref.trim().length > 0 ? ref.trim() : void 0
     };
   }
   async enableMarketplacePlugin(id) {
@@ -4587,17 +4603,13 @@ var ServiceCommands = class {
   async uninstallMarketplaceSkill(slug) {
     const workspace = getWorkspacePath5(loadConfig6().agents.defaults.workspace);
     const targetDir = join5(workspace, "skills", slug);
-    const skildDir = join5(workspace, ".agents", "skills", slug);
-    const existingTargets = [targetDir, skildDir].filter((path) => existsSync8(path));
-    if (existingTargets.length === 0) {
+    if (!existsSync8(targetDir)) {
       throw new Error(`Skill not installed in workspace: ${slug}`);
     }
-    for (const path of existingTargets) {
-      rmSync3(path, { recursive: true, force: true });
-    }
+    rmSync3(targetDir, { recursive: true, force: true });
     return {
       message: `Uninstalled skill: ${slug}`,
-      output: existingTargets.map((path) => `Removed ${path}`).join("\n")
+      output: `Removed ${targetDir}`
     };
   }
   installBuiltinMarketplaceSkill(slug, force) {
@@ -4659,39 +4671,6 @@ var ServiceCommands = class {
     }
     return destination;
   }
-  parseSkildJsonOutput(stdout) {
-    const trimmed = stdout.trim();
-    if (!trimmed) {
-      throw new Error("skild returned empty output");
-    }
-    const maybeJson = (() => {
-      const start = trimmed.indexOf("{");
-      const end = trimmed.lastIndexOf("}");
-      if (start >= 0 && end > start) {
-        return trimmed.slice(start, end + 1);
-      }
-      return trimmed;
-    })();
-    try {
-      const parsed = JSON.parse(maybeJson);
-      if (parsed === null) {
-        return null;
-      }
-      if (Array.isArray(parsed)) {
-        const firstObject = parsed.find((item) => item && typeof item === "object" && !Array.isArray(item));
-        if (firstObject) {
-          return firstObject;
-        }
-        throw new Error("skild json output array does not contain an object");
-      }
-      if (typeof parsed !== "object") {
-        throw new Error("skild json output is not an object");
-      }
-      return parsed;
-    } catch (error) {
-      throw new Error(`failed to parse skild --json output: ${String(error)}`);
-    }
-  }
   mergeCommandOutput(stdout, stderr) {
     return `${stdout}
 ${stderr}`.trim();
@@ -4768,7 +4747,7 @@ import { createRequire } from "module";
 import { dirname as dirname2, join as join6, resolve as resolve8 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { APP_NAME as APP_NAME3, getDataDir as getDataDir7 } from "@nextclaw/core";
-import { spawnSync as spawnSync5 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 var WorkspaceManager = class {
   constructor(logo) {
     this.logo = logo;
@@ -4915,7 +4894,7 @@ var WorkspaceManager = class {
       recursive: true,
       filter: (src) => !src.includes("node_modules") && !src.includes("dist")
     });
-    const install = spawnSync5("npm", ["install"], { cwd: userBridge, stdio: "pipe" });
+    const install = spawnSync4("npm", ["install"], { cwd: userBridge, stdio: "pipe" });
     if (install.status !== 0) {
       console.error(`Bridge install failed: ${install.status ?? 1}`);
       if (install.stderr) {
@@ -4923,7 +4902,7 @@ var WorkspaceManager = class {
       }
       process.exit(1);
     }
-    const build = spawnSync5("npm", ["run", "build"], { cwd: userBridge, stdio: "pipe" });
+    const build = spawnSync4("npm", ["run", "build"], { cwd: userBridge, stdio: "pipe" });
     if (build.status !== 0) {
       console.error(`Bridge build failed: ${build.status ?? 1}`);
       if (build.stderr) {
@@ -5293,12 +5272,6 @@ ${this.logo} ${APP_NAME4} is ready! (${source})`);
   async stop() {
     await this.serviceCommands.stopService();
   }
-  async serviceInstallSystemd(opts) {
-    await this.serviceCommands.installSystemdService(opts);
-  }
-  async serviceUninstallSystemd(opts) {
-    await this.serviceCommands.uninstallSystemdService(opts);
-  }
   async agent(opts) {
     const configPath = getConfigPath4();
     const config2 = resolveConfigSecrets3(loadConfig7(), { configPath });
@@ -5561,9 +5534,6 @@ program.command("start").description(`Start the ${APP_NAME5} gateway + UI in the
 program.command("restart").description(`Restart the ${APP_NAME5} background service`).option("--ui-port <port>", "UI port").option("--start-timeout <ms>", "Maximum wait time for startup readiness in milliseconds").option("--open", "Open browser after restart", false).action(async (opts) => runtime.restart(opts));
 program.command("serve").description(`Run the ${APP_NAME5} gateway + UI in the foreground`).option("--ui-port <port>", "UI port").option("--open", "Open browser after start", false).action(async (opts) => runtime.serve(opts));
 program.command("stop").description(`Stop the ${APP_NAME5} background service`).action(async () => runtime.stop());
-var service = program.command("service").description("Manage OS service integration");
-service.command("install-systemd").description(`Install a systemd unit for ${APP_NAME5} on Linux servers`).option("--name <name>", "Systemd unit name", APP_NAME5).option("--ui-port <port>", "UI port").action(async (opts) => runtime.serviceInstallSystemd(opts));
-service.command("uninstall-systemd").description(`Remove the systemd unit for ${APP_NAME5}`).option("--name <name>", "Systemd unit name", APP_NAME5).action(async (opts) => runtime.serviceUninstallSystemd(opts));
 program.command("agent").description("Interact with the agent directly").option("-m, --message <message>", "Message to send to the agent").option("-s, --session <session>", "Session ID", "cli:default").option("--model <model>", "Session model override for this run").option("--no-markdown", "Disable Markdown rendering").action(async (opts) => runtime.agent(opts));
 program.command("update").description(`Update ${APP_NAME5}`).option("--timeout <ms>", "Update command timeout in milliseconds").action(async (opts) => runtime.update(opts));
 var registerClawHubInstall = (cmd) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nextclaw",
-  "version": "0.9.10",
+  "version": "0.9.12",
   "description": "Lightweight personal AI assistant with CLI, multi-provider routing, and channel integrations.",
   "private": false,
   "type": "module",

package/templates/USAGE.md

@@ -418,8 +418,6 @@ Created under the workspace:
 | `nextclaw start` | Start gateway + UI in the background |
 | `nextclaw restart` | Restart the background service with optional start flags |
 | `nextclaw stop` | Stop the background service |
-| `sudo nextclaw service install-systemd` | Install a managed Linux `systemd` service for public/server deployment |
-| `sudo nextclaw service uninstall-systemd` | Remove the managed Linux `systemd` service |
 | `nextclaw ui` | Start UI and gateway in the foreground |
 | `nextclaw gateway` | Start gateway only (for channels) |
 | `nextclaw serve` | Run gateway + UI in the foreground (no background) |
@@ -460,13 +458,6 @@ Gateway options (when running `nextclaw gateway` or `nextclaw start`):
 
 If service is already running, new UI port flags do not hot-apply; use `nextclaw restart ...` to apply them.
 
-Linux server deployment tip:
-
-- If you put Nginx/Caddy/Traefik in front of NextClaw, do not rely on a one-time `nextclaw start` only.
-- `nextclaw start` is a background convenience command, not a crash/reboot supervisor.
-- On Linux servers, install a managed unit with `sudo nextclaw service install-systemd` so the UI/API comes back automatically after reboot or unexpected exit.
-- Verify with `systemctl status nextclaw`, `journalctl -u nextclaw -f`, and `curl http://127.0.0.1:18791/api/health`.
-
 Status/diagnostics tips:
 
 - `nextclaw status` shows runtime truth (process + health + config summary).