codeharbor 0.1.4 → 0.1.6

package/README.md

@@ -64,6 +64,24 @@ curl -fsSL https://raw.githubusercontent.com/biglone/CodeHarbor/main/scripts/ins
   --matrix-access-token 'your-token'
 ```
 
+Install first, then enable systemd service with one command:
+
+```bash
+sudo codeharbor service install
+```
+
+Install + enable main and admin services:
+
+```bash
+sudo codeharbor service install --with-admin
+```
+
+Remove installed services:
+
+```bash
+sudo codeharbor service uninstall --with-admin
+```
+
 Enable Admin service at install time:
 
 ```bash
@@ -83,8 +101,9 @@ Run local script with custom options:
 
 Runtime home behavior:
 
-- By default, all `codeharbor` commands use `/opt/codeharbor` for `.env` and relative data paths.
-- No manual `cd /opt/codeharbor` is required after installation.
+- By default, all `codeharbor` commands use `~/.codeharbor` for `.env` and relative data paths.
+- Backward compatibility: if `/opt/codeharbor/.env` already exists, it continues to be used automatically.
+- No manual `cd` is required after installation.
 - To use a custom runtime directory, set `CODEHARBOR_HOME` (for example `export CODEHARBOR_HOME=/srv/codeharbor`).
 
 Install directly from GitHub:
@@ -228,6 +247,8 @@ It documents:
 - `codeharbor start`: start service
 - `codeharbor doctor`: check `codex` and Matrix connectivity
 - `codeharbor admin serve`: start admin UI + config API server
+- `codeharbor service install`: install/enable systemd unit(s) after npm install (supports `--with-admin`)
+- `codeharbor service uninstall`: remove installed systemd unit(s) (supports `--with-admin`)
 - `codeharbor config export`: export current config snapshot as JSON
 - `codeharbor config import <file>`: import config snapshot JSON (supports `--dry-run`)
 - `npm run changelog:check`: validate `CHANGELOG.md` has notes for current package version

package/dist/cli.js

@@ -24,8 +24,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli.ts
-var import_node_fs9 = __toESM(require("fs"));
-var import_node_path11 = __toESM(require("path"));
+var import_node_fs11 = __toESM(require("fs"));
+var import_node_path12 = __toESM(require("path"));
 var import_commander = require("commander");
 
 // src/app.ts
@@ -4911,21 +4911,288 @@ function readEnv(env, key) {
 }
 
 // src/runtime-home.ts
+var import_node_fs9 = __toESM(require("fs"));
+var import_node_os2 = __toESM(require("os"));
 var import_node_path10 = __toESM(require("path"));
-var DEFAULT_RUNTIME_HOME = "/opt/codeharbor";
+var LEGACY_RUNTIME_HOME = "/opt/codeharbor";
+var USER_RUNTIME_HOME_DIR = ".codeharbor";
+var DEFAULT_RUNTIME_HOME = import_node_path10.default.resolve(import_node_os2.default.homedir(), USER_RUNTIME_HOME_DIR);
 var RUNTIME_HOME_ENV_KEY = "CODEHARBOR_HOME";
 function resolveRuntimeHome(env = process.env) {
   const configured = env[RUNTIME_HOME_ENV_KEY]?.trim();
   if (configured) {
     return import_node_path10.default.resolve(configured);
   }
-  return DEFAULT_RUNTIME_HOME;
+  const legacyEnvPath = import_node_path10.default.resolve(LEGACY_RUNTIME_HOME, ".env");
+  if (import_node_fs9.default.existsSync(legacyEnvPath)) {
+    return LEGACY_RUNTIME_HOME;
+  }
+  return resolveUserRuntimeHome(env);
+}
+function resolveUserRuntimeHome(env = process.env) {
+  const home = env.HOME?.trim() || import_node_os2.default.homedir();
+  return import_node_path10.default.resolve(home, USER_RUNTIME_HOME_DIR);
+}
+
+// src/service-manager.ts
+var import_node_child_process5 = require("child_process");
+var import_node_fs10 = __toESM(require("fs"));
+var import_node_os3 = __toESM(require("os"));
+var import_node_path11 = __toESM(require("path"));
+var SYSTEMD_DIR = "/etc/systemd/system";
+var MAIN_SERVICE_NAME = "codeharbor.service";
+var ADMIN_SERVICE_NAME = "codeharbor-admin.service";
+function resolveDefaultRunUser(env = process.env) {
+  const sudoUser = env.SUDO_USER?.trim();
+  if (sudoUser) {
+    return sudoUser;
+  }
+  const user = env.USER?.trim();
+  if (user) {
+    return user;
+  }
+  try {
+    return import_node_os3.default.userInfo().username;
+  } catch {
+    return "root";
+  }
+}
+function resolveRuntimeHomeForUser(runUser, env = process.env, explicitRuntimeHome) {
+  const configuredRuntimeHome = explicitRuntimeHome?.trim() || env[RUNTIME_HOME_ENV_KEY]?.trim();
+  if (configuredRuntimeHome) {
+    return import_node_path11.default.resolve(configuredRuntimeHome);
+  }
+  const userHome = resolveUserHome(runUser);
+  if (userHome) {
+    return import_node_path11.default.resolve(userHome, USER_RUNTIME_HOME_DIR);
+  }
+  return import_node_path11.default.resolve(import_node_os3.default.homedir(), USER_RUNTIME_HOME_DIR);
+}
+function buildMainServiceUnit(options) {
+  validateUnitOptions(options);
+  const runtimeHome2 = import_node_path11.default.resolve(options.runtimeHome);
+  return [
+    "[Unit]",
+    "Description=CodeHarbor main service",
+    "After=network-online.target",
+    "Wants=network-online.target",
+    "",
+    "[Service]",
+    "Type=simple",
+    `User=${options.runUser}`,
+    `WorkingDirectory=${runtimeHome2}`,
+    `Environment=CODEHARBOR_HOME=${runtimeHome2}`,
+    `ExecStart=${import_node_path11.default.resolve(options.nodeBinPath)} ${import_node_path11.default.resolve(options.cliScriptPath)} start`,
+    "Restart=always",
+    "RestartSec=3",
+    "NoNewPrivileges=true",
+    "PrivateTmp=true",
+    "ProtectSystem=full",
+    "ProtectHome=true",
+    `ReadWritePaths=${runtimeHome2}`,
+    "",
+    "[Install]",
+    "WantedBy=multi-user.target",
+    ""
+  ].join("\n");
+}
+function buildAdminServiceUnit(options) {
+  validateUnitOptions(options);
+  const runtimeHome2 = import_node_path11.default.resolve(options.runtimeHome);
+  return [
+    "[Unit]",
+    "Description=CodeHarbor admin service",
+    "After=network-online.target",
+    "Wants=network-online.target",
+    "",
+    "[Service]",
+    "Type=simple",
+    `User=${options.runUser}`,
+    `WorkingDirectory=${runtimeHome2}`,
+    `Environment=CODEHARBOR_HOME=${runtimeHome2}`,
+    `ExecStart=${import_node_path11.default.resolve(options.nodeBinPath)} ${import_node_path11.default.resolve(options.cliScriptPath)} admin serve`,
+    "Restart=always",
+    "RestartSec=3",
+    "NoNewPrivileges=true",
+    "PrivateTmp=true",
+    "ProtectSystem=full",
+    "ProtectHome=true",
+    `ReadWritePaths=${runtimeHome2}`,
+    "",
+    "[Install]",
+    "WantedBy=multi-user.target",
+    ""
+  ].join("\n");
+}
+function installSystemdServices(options) {
+  assertLinuxWithSystemd();
+  assertRootPrivileges();
+  const output = options.output ?? process.stdout;
+  const runUser = options.runUser.trim();
+  const runtimeHome2 = import_node_path11.default.resolve(options.runtimeHome);
+  validateSimpleValue(runUser, "runUser");
+  validateSimpleValue(runtimeHome2, "runtimeHome");
+  validateSimpleValue(options.nodeBinPath, "nodeBinPath");
+  validateSimpleValue(options.cliScriptPath, "cliScriptPath");
+  ensureUserExists(runUser);
+  const runGroup = resolveUserGroup(runUser);
+  import_node_fs10.default.mkdirSync(runtimeHome2, { recursive: true });
+  runCommand("chown", ["-R", `${runUser}:${runGroup}`, runtimeHome2]);
+  const mainPath = import_node_path11.default.join(SYSTEMD_DIR, MAIN_SERVICE_NAME);
+  const adminPath = import_node_path11.default.join(SYSTEMD_DIR, ADMIN_SERVICE_NAME);
+  const unitOptions = {
+    runUser,
+    runtimeHome: runtimeHome2,
+    nodeBinPath: options.nodeBinPath,
+    cliScriptPath: options.cliScriptPath
+  };
+  import_node_fs10.default.writeFileSync(mainPath, buildMainServiceUnit(unitOptions), "utf8");
+  if (options.installAdmin) {
+    import_node_fs10.default.writeFileSync(adminPath, buildAdminServiceUnit(unitOptions), "utf8");
+  }
+  runSystemctl(["daemon-reload"]);
+  if (options.startNow) {
+    runSystemctl(["enable", "--now", MAIN_SERVICE_NAME]);
+    if (options.installAdmin) {
+      runSystemctl(["enable", "--now", ADMIN_SERVICE_NAME]);
+    }
+  } else {
+    runSystemctl(["enable", MAIN_SERVICE_NAME]);
+    if (options.installAdmin) {
+      runSystemctl(["enable", ADMIN_SERVICE_NAME]);
+    }
+  }
+  output.write(`Installed systemd unit: ${mainPath}
+`);
+  if (options.installAdmin) {
+    output.write(`Installed systemd unit: ${adminPath}
+`);
+  }
+  output.write("Done. Check status with: systemctl status codeharbor --no-pager\n");
+}
+function uninstallSystemdServices(options) {
+  assertLinuxWithSystemd();
+  assertRootPrivileges();
+  const output = options.output ?? process.stdout;
+  const mainPath = import_node_path11.default.join(SYSTEMD_DIR, MAIN_SERVICE_NAME);
+  const adminPath = import_node_path11.default.join(SYSTEMD_DIR, ADMIN_SERVICE_NAME);
+  stopAndDisableIfPresent(MAIN_SERVICE_NAME);
+  if (import_node_fs10.default.existsSync(mainPath)) {
+    import_node_fs10.default.unlinkSync(mainPath);
+  }
+  if (options.removeAdmin) {
+    stopAndDisableIfPresent(ADMIN_SERVICE_NAME);
+    if (import_node_fs10.default.existsSync(adminPath)) {
+      import_node_fs10.default.unlinkSync(adminPath);
+    }
+  }
+  runSystemctl(["daemon-reload"]);
+  runSystemctlIgnoreFailure(["reset-failed"]);
+  output.write(`Removed systemd unit: ${mainPath}
+`);
+  if (options.removeAdmin) {
+    output.write(`Removed systemd unit: ${adminPath}
+`);
+  }
+  output.write("Done.\n");
+}
+function resolveUserHome(runUser) {
+  try {
+    const passwdRaw = import_node_fs10.default.readFileSync("/etc/passwd", "utf8");
+    const line = passwdRaw.split(/\r?\n/).find((item) => item.startsWith(`${runUser}:`));
+    if (!line) {
+      return null;
+    }
+    const fields = line.split(":");
+    return fields[5] ? fields[5].trim() : null;
+  } catch {
+    return null;
+  }
+}
+function validateUnitOptions(options) {
+  validateSimpleValue(options.runUser, "runUser");
+  validateSimpleValue(options.runtimeHome, "runtimeHome");
+  validateSimpleValue(options.nodeBinPath, "nodeBinPath");
+  validateSimpleValue(options.cliScriptPath, "cliScriptPath");
+}
+function validateSimpleValue(value, key) {
+  if (!value.trim()) {
+    throw new Error(`${key} cannot be empty.`);
+  }
+  if (/[\r\n]/.test(value)) {
+    throw new Error(`${key} contains invalid newline characters.`);
+  }
+}
+function assertLinuxWithSystemd() {
+  if (process.platform !== "linux") {
+    throw new Error("Systemd service install only supports Linux.");
+  }
+  try {
+    (0, import_node_child_process5.execFileSync)("systemctl", ["--version"], { stdio: "ignore" });
+  } catch {
+    throw new Error("systemctl is required but not found.");
+  }
+}
+function assertRootPrivileges() {
+  if (typeof process.getuid !== "function") {
+    return;
+  }
+  if (process.getuid() !== 0) {
+    throw new Error("Root privileges are required. Run with sudo.");
+  }
+}
+function ensureUserExists(runUser) {
+  runCommand("id", ["-u", runUser]);
+}
+function resolveUserGroup(runUser) {
+  return runCommand("id", ["-gn", runUser]).trim();
+}
+function runSystemctl(args) {
+  runCommand("systemctl", args);
+}
+function stopAndDisableIfPresent(unitName) {
+  runSystemctlIgnoreFailure(["disable", "--now", unitName]);
+}
+function runSystemctlIgnoreFailure(args) {
+  try {
+    runCommand("systemctl", args);
+  } catch {
+  }
+}
+function runCommand(file, args) {
+  try {
+    return (0, import_node_child_process5.execFileSync)(file, args, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (error) {
+    throw new Error(formatCommandError(file, args, error), { cause: error });
+  }
+}
+function formatCommandError(file, args, error) {
+  const command = `${file} ${args.join(" ")}`.trim();
+  if (error && typeof error === "object") {
+    const maybeError = error;
+    const stderr = bufferToTrimmedString(maybeError.stderr);
+    const stdout = bufferToTrimmedString(maybeError.stdout);
+    const details = stderr || stdout || maybeError.message || "command failed";
+    return `Command failed: ${command}. ${details}`;
+  }
+  return `Command failed: ${command}. ${String(error)}`;
+}
+function bufferToTrimmedString(value) {
+  if (!value) {
+    return "";
+  }
+  const text = typeof value === "string" ? value : value.toString("utf8");
+  return text.trim();
 }
 
 // src/cli.ts
 var runtimeHome = null;
+var cliVersion = resolveCliVersion();
 var program = new import_commander.Command();
-program.name("codeharbor").description("Instant-messaging bridge for Codex CLI sessions").version("0.1.0");
+program.name("codeharbor").description("Instant-messaging bridge for Codex CLI sessions").version(cliVersion);
 program.command("init").description("Create or update .env via guided prompts").option("-f, --force", "overwrite existing .env without confirmation").action(async (options) => {
   const home = ensureRuntimeHomeOrExit();
   await runInitCommand({ force: options.force ?? false, cwd: home });
@@ -4961,6 +5228,7 @@ program.command("doctor").description("Check codex and matrix connectivity").act
 });
 var admin = program.command("admin").description("Admin utilities");
 var configCommand = program.command("config").description("Config snapshot utilities");
+var serviceCommand = program.command("service").description("Systemd service management");
 admin.command("serve").description("Start admin config API server").option("--host <host>", "override admin bind host").option("--port <port>", "override admin bind port").option(
   "--allow-insecure-no-token",
   "allow serving admin API without ADMIN_TOKEN on non-loopback host (not recommended)"
@@ -5018,6 +5286,37 @@ configCommand.command("import").description("Import config snapshot from JSON").
     process.exitCode = 1;
   }
 });
+serviceCommand.command("install").description("Install and enable codeharbor systemd service (requires root)").option("--run-user <user>", "service user (default: sudo user or current user)").option("--runtime-home <path>", "runtime home used as CODEHARBOR_HOME").option("--with-admin", "also install codeharbor-admin.service").option("--no-start", "enable service without starting immediately").action((options) => {
+  try {
+    const runUser = options.runUser?.trim() || resolveDefaultRunUser();
+    const runtimeHomePath = resolveRuntimeHomeForUser(runUser, process.env, options.runtimeHome);
+    installSystemdServices({
+      runUser,
+      runtimeHome: runtimeHomePath,
+      nodeBinPath: process.execPath,
+      cliScriptPath: resolveCliScriptPath(),
+      installAdmin: options.withAdmin ?? false,
+      startNow: options.start ?? true
+    });
+  } catch (error) {
+    process.stderr.write(`Service install failed: ${formatError3(error)}
+`);
+    process.stderr.write("Hint: run with sudo, for example: sudo codeharbor service install\n");
+    process.exitCode = 1;
+  }
+});
+serviceCommand.command("uninstall").description("Remove codeharbor systemd service (requires root)").option("--with-admin", "also remove codeharbor-admin.service").action((options) => {
+  try {
+    uninstallSystemdServices({
+      removeAdmin: options.withAdmin ?? false
+    });
+  } catch (error) {
+    process.stderr.write(`Service uninstall failed: ${formatError3(error)}
+`);
+    process.stderr.write("Hint: run with sudo, for example: sudo codeharbor service uninstall\n");
+    process.exitCode = 1;
+  }
+});
 if (process.argv.length <= 2) {
   process.argv.push("start");
 }
@@ -5049,7 +5348,7 @@ function ensureRuntimeHomeOrExit() {
   }
   const home = resolveRuntimeHome();
   try {
-    import_node_fs9.default.mkdirSync(home, { recursive: true });
+    import_node_fs11.default.mkdirSync(home, { recursive: true });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     process.stderr.write(`Runtime setup failed: cannot create ${home}. ${message}
@@ -5064,7 +5363,7 @@ function ensureRuntimeHomeOrExit() {
 `);
     process.exit(1);
   }
-  loadEnvFromFile(import_node_path11.default.resolve(home, ".env"));
+  loadEnvFromFile(import_node_path12.default.resolve(home, ".env"));
   runtimeHome = home;
   return runtimeHome;
 }
@@ -5077,6 +5376,23 @@ function parsePortOption(raw, fallback) {
   }
   return parsed;
 }
+function resolveCliVersion() {
+  try {
+    const packagePath = import_node_path12.default.resolve(__dirname, "..", "package.json");
+    const content = import_node_fs11.default.readFileSync(packagePath, "utf8");
+    const parsed = JSON.parse(content);
+    return typeof parsed.version === "string" && parsed.version.trim() ? parsed.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function resolveCliScriptPath() {
+  const argvPath = process.argv[1];
+  if (argvPath && argvPath.trim()) {
+    return import_node_path12.default.resolve(argvPath);
+  }
+  return import_node_path12.default.resolve(__dirname, "cli.js");
+}
 function formatError3(error) {
   if (error instanceof Error) {
     return error.message;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeharbor",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Instant-messaging bridge for Codex CLI sessions",
   "license": "MIT",
   "main": "dist/cli.js",