Function createSystemdManager

packages/server/src/svc/systemd.ts:51–202

(
  overrides: Partial<SystemdManagerDeps> = {},
)

};

export function createSystemdManager(
  overrides: Partial<SystemdManagerDeps> = {},
): ServiceManager {
  const deps: SystemdManagerDeps = { ...DEFAULT_DEPS, ...overrides };

  async function install(args: InstallArgs): Promise<InstallResult> {
    const unitPath = deps.unitPath();
    const logPath = deps.logPath();
    const program = deps.resolveProgram();
    const plan = buildInstallPlan({ ...args, program, logPath });

    const alreadyInstalled = existsSync(unitPath);
    if (alreadyInstalled && args.force !== true) {
      return {
        status: 'already-installed',
        message: `systemd unit already installed at ${unitPath}. Rerun with --force to replace it.`,
        unitPath,
      };
    }

    await assertUserSystemdAvailable(deps);

    writeUnit(unitPath, plan);
    writeInstallPlan(plan);

    const reload = await deps.execSystemctl(['daemon-reload']);
    if (reload.code !== 0) {
      throw new Error(
        `systemctl --user daemon-reload failed (code ${reload.code}): ${detail(reload) ?? 'unknown error'}`,
      );
    }

    const enable = await deps.execSystemctl(['enable', '--now', KIMI_SERVER_SYSTEMD_UNIT]);
    if (enable.code !== 0) {
      throw new Error(
        `systemctl --user enable --now failed (code ${enable.code}): ${detail(enable) ?? 'unknown error'}`,
      );
    }

    return {
      status: alreadyInstalled ? 'replaced' : 'installed',
      message: `Kimi server systemd unit ${alreadyInstalled ? 'replaced' : 'installed'} at ${unitPath} (port ${plan.port}).`,
      unitPath,
    };
  }

  async function uninstall(): Promise<LifecycleResult> {
    const unitPath = deps.unitPath();
    if (!existsSync(unitPath)) {
      deleteInstallPlan();
      return { ok: true, message: 'systemd unit was not installed; nothing to remove.' };
    }
    await deps.execSystemctl(['disable', '--now', KIMI_SERVER_SYSTEMD_UNIT]).catch(() => undefined);
    try {
      rmSync(unitPath, { force: true });
    } catch (error) {
      throw new Error(
        `failed to remove unit ${unitPath}: ${error instanceof Error ? error.message : String(error)}`,