flake.nix

@@ -14,15 +14,8 @@
     };
   };
 
-  outputs = inputs @ {
+  outputs = inputs@{ self, nixpkgs, flake-parts, rust-overlay, ttp, ... }:
-    self,
+    flake-parts.lib.mkFlake { inherit inputs; } {
-    nixpkgs,
-    flake-parts,
-    rust-overlay,
-    ttp,
-    ...
-  }:
-    flake-parts.lib.mkFlake {inherit inputs;} {
       systems = [
         "x86_64-linux"
         "aarch64-linux"
@@ -30,230 +23,203 @@
         "aarch64-darwin"
       ];
 
-      perSystem = {
+      perSystem = { self', pkgs, system, ... }:
-        self',
+        let
-        pkgs,
+          rustPkgs = import nixpkgs {
-        system,
+            inherit system;
-        ...
+            overlays = [ (import rust-overlay) ];
-      }: let
+          };
-        rustPkgs = import nixpkgs {
+          rustToolchain = rustPkgs.rust-bin.stable.latest.default.override {
-          inherit system;
+            extensions = [ "rust-src" "rust-analyzer" "clippy" "rustfmt" ];
-          overlays = [(import rust-overlay)];
+          };
-        };
+        in
-        rustToolchain = rustPkgs.rust-bin.stable.latest.default.override {
+        {
-          extensions = ["rust-src" "rust-analyzer" "clippy" "rustfmt"];
+          packages = {
-        };
+            default = self'.packages.iota;
-      in {
+            iota = pkgs.rustPlatform.buildRustPackage {
-        packages = {
+              pname = "iota";
-          default = self'.packages.iota;
+              version = "0.1.0";
-          iota = pkgs.rustPlatform.buildRustPackage {
+              src = ./.;
-            pname = "iota";
+              cargoLock = {
-            version = "0.1.0";
+                lockFile = ./Cargo.lock;
-            src = ./.;
+                allowBuiltinFetchGit = true;
-            cargoLock = {
+              };
-              lockFile = ./Cargo.lock;
+              nativeBuildInputs = with pkgs; [ cmake perl pkg-config ];
-              allowBuiltinFetchGit = true;
+              buildInputs = with pkgs; [ openssl sqlite ];
-            };
+              dontUseCmakeConfigure = true;
-            nativeBuildInputs = with pkgs; [cmake perl pkg-config];
+              preConfigure = ''
-            buildInputs = with pkgs; [openssl sqlite];
+                if [ -d ../cargo-vendor-dir/ttp-core-0.1.0 ]; then
-            dontUseCmakeConfigure = true;
+                  cp ${ttp}/ttp-codec.json ../cargo-vendor-dir/ttp-codec.json
-            preConfigure = ''
-              if [ -d ../cargo-vendor-dir/ttp-core-0.1.0 ]; then
-                cp ${ttp}/ttp-codec.json ../cargo-vendor-dir/ttp-codec.json
-              fi
-            '';
-            postInstall = ''
-              mv $out/bin/iota-core $out/bin/iota
-              for f in $out/bin/*; do
-                if [ "$(basename "$f")" != "iota" ]; then
-                  rm "$f"
                 fi
-              done
+              '';
-            '';
+              postInstall = ''
-            passthru.dataDir = "/var/lib/iota";
+                mv $out/bin/iota-core $out/bin/iota
+                for f in $out/bin/*; do
+                  if [ "$(basename "$f")" != "iota" ]; then
+                    rm "$f"
+                  fi
+                done
+              '';
+              passthru.dataDir = "/var/lib/iota";
+            };
+          };
+
+          devShells.default = pkgs.mkShell {
+            nativeBuildInputs = with pkgs; [ rustToolchain git cmake perl pkg-config ];
+            buildInputs = with pkgs; [ openssl sqlite ];
           };
         };
 
-        devShells.default = pkgs.mkShell {
-          nativeBuildInputs = with pkgs; [rustToolchain git cmake perl pkg-config];
-          buildInputs = with pkgs; [openssl sqlite];
-        };
-      };
-
       flake = {
-        nixosModules.default = {
+        nixosModules.default = { config, pkgs, lib, ... }:
-          config,
+          let
-          pkgs,
+            cfg = config.services.iota;
-          lib,
+            defaultPackage = self.packages.${pkgs.stdenv.hostPlatform.system}.default or (throw "iota: no pre-built package for system ${pkgs.stdenv.hostPlatform.system}");
-          ...
-        }: let
-          cfg = config.services.iota;
-          defaultPackage = self.packages.${pkgs.stdenv.hostPlatform.system}.default or (throw "iota: no pre-built package for system ${pkgs.stdenv.hostPlatform.system}");
 
-          configFile =
+            configFile = if cfg.settingsFile != null then cfg.settingsFile else
-            if cfg.settingsFile != null
+              pkgs.writeText "iota-config.json" (builtins.toJSON cfg.settings);
-            then cfg.settingsFile
-            else pkgs.writeText "iota-config.json" (builtins.toJSON cfg.settings);
 
-          descriptionText = "Tensamin Iota";
+            descriptionText = "Iota Service"
-          #+ lib.optionalString cfg.useTmux " (attach TUI: tmux -S ${cfg.dataDir}/tmux.sock attach -t iota)";
+              + lib.optionalString cfg.useTmux " (attach TUI: tmux -S ${cfg.dataDir}/tmux.sock attach -t iota)";
-        in {
+          in
-          options.services.iota = {
+          {
-            enable = lib.mkEnableOption "Enable the Iota service.";
+            options.services.iota = {
+              enable = lib.mkEnableOption "the Iota service";
 
-            dataDir = lib.mkOption {
+              dataDir = lib.mkOption {
-              type = lib.types.str;
+                type = lib.types.str;
-              default = cfg.package.passthru.dataDir or "/var/lib/iota";
+                default = cfg.package.passthru.dataDir or "/var/lib/iota";
-              defaultText = lib.literalExpression ''config.services.iota.package.passthru.dataDir or "/var/lib/iota"'';
+                defaultText = lib.literalExpression ''config.services.iota.package.passthru.dataDir or "/var/lib/iota"'';
-              description = "Directory where Iota stores its data, config, and certificates.";
+                description = "Directory where Iota stores its data, config, and certificates.";
+              };
+
+              certFile = lib.mkOption {
+                type = lib.types.nullOr lib.types.path;
+                default = null;
+                description = "Path to the SSL certificate file (cert.pem).";
+              };
+
+              keyFile = lib.mkOption {
+                type = lib.types.nullOr lib.types.path;
+                default = null;
+                description = "Path to the SSL private key file (cert.key).";
+              };
+
+              environmentFiles = lib.mkOption {
+                type = lib.types.listOf lib.types.path;
+                default = [ ];
+                description = "Environment files to load for the Iota service.";
+              };
+
+              openFirewall = lib.mkOption {
+                type = lib.types.bool;
+                default = true;
+                description = "Whether to open the firewall for ports used by Iota.";
+              };
+
+              ttpBind = lib.mkOption {
+                type = lib.types.str;
+                default = "0.0.0.0";
+                description = "IP address to bind the TTP/QUIC server to.";
+              };
+
+              bindAddress = lib.mkOption {
+                type = lib.types.str;
+                default = "0.0.0.0";
+                description = "IP address to bind the HTTP server to.";
+              };
+
+              package = lib.mkOption {
+                type = lib.types.package;
+                default = defaultPackage;
+                description = "The Iota package to use.";
+              };
+
+              useTmux = lib.mkOption {
+                type = lib.types.bool;
+                default = true;
+                description = "Whether to run Iota inside a tmux session for shared TUI access.";
+              };
+
+              settings = lib.mkOption {
+                type = lib.types.attrs;
+                default = { };
+                description = "Configuration attributes for Iota, written to config.json.";
+              };
+
+              settingsFile = lib.mkOption {
+                type = lib.types.nullOr lib.types.path;
+                default = null;
+                description = "Path to an existing config.json file to use instead of generating from settings.";
+              };
             };
 
-            certFile = lib.mkOption {
+            config = lib.mkIf cfg.enable {
-              type = lib.types.nullOr lib.types.path;
+              users.users.iota = {
-              default = null;
+                isSystemUser = true;
-              description = "Path to the SSL certificate file (cert.pem).";
+                group = "iota";
-            };
+                home = cfg.dataDir;
+                createHome = true;
+                description = "Iota service user";
+              };
 
-            keyFile = lib.mkOption {
+              users.groups.iota = { };
-              type = lib.types.nullOr lib.types.path;
-              default = null;
-              description = "Path to the SSL private key file (cert.key).";
-            };
 
-            environmentFiles = lib.mkOption {
+              systemd.services.iota = {
-              type = lib.types.listOf lib.types.path;
+                description = descriptionText;
-              default = [];
+                wantedBy = [ "multi-user.target" ];
-              description = "Environment files to load for the Iota service.";
+                after = [ "network.target" ];
-            };
+                path = [ pkgs.tmux pkgs.bash pkgs.coreutils pkgs.systemd ];
 
-            openFirewall = lib.mkOption {
+                serviceConfig = {
-              type = lib.types.bool;
+                  Type = if cfg.useTmux then "forking" else "simple";
-              default = true;
-              description = "Whether to open the firewall for ports used by Iota.";
-            };
-
-            ttpBind = lib.mkOption {
-              type = lib.types.str;
-              default = "0.0.0.0";
-              description = "IP address to bind the TTP/QUIC server to.";
-            };
-
-            bindAddress = lib.mkOption {
-              type = lib.types.str;
-              default = "0.0.0.0";
-              description = "IP address to bind the HTTP server to.";
-            };
-
-            package = lib.mkOption {
-              type = lib.types.package;
-              default = defaultPackage;
-              description = "The Iota package to use.";
-            };
-
-            useTmux = lib.mkOption {
-              type = lib.types.bool;
-              default = true;
-              description = "Whether to run Iota inside a tmux session for shared TUI access.";
-            };
-
-            settings = lib.mkOption {
-              type = lib.types.attrs;
-              default = {};
-              description = "Configuration attributes for Iota, written to config.json.";
-            };
-
-            settingsFile = lib.mkOption {
-              type = lib.types.nullOr lib.types.path;
-              default = null;
-              description = "Path to an existing config.json file to use instead of generating from settings.";
-            };
-          };
-
-          config = lib.mkIf cfg.enable {
-            users.users.iota = {
-              isSystemUser = true;
-              group = "iota";
-              home = cfg.dataDir;
-              createHome = true;
-              description = "Iota service user";
-              shell = pkgs.bash;
-            };
-
-            users.groups.iota = {};
-
-            systemd.services.iota = let
-              iotaTmuxCmd = pkgs.writeShellScript "iota-tmux-cmd" ''
-                mkdir -p ${cfg.dataDir}
-                echo "[$(date)] Running Iota..."
-                ${cfg.package}/bin/iota
-                status=$?
-                echo ""
-                echo "[$(date)] Iota exited with status: $status"
-                echo "Press any key to exit..."
-                read -r -n 1
-                exit $status
-              '';
-            in {
-              description = descriptionText;
-              wantedBy = ["multi-user.target"];
-              after = ["network.target"];
-
-              serviceConfig =
-                {
-                  Type = "simple";
                   User = "iota";
                   Group = "iota";
                   WorkingDirectory = cfg.dataDir;
 
-                  ExecStart =
+                  ExecStart = if cfg.useTmux then
-                    if cfg.useTmux
+                    pkgs.writeShellScript "iota-start" ''
-                    then
+                      ${pkgs.tmux}/bin/tmux -S ${cfg.dataDir}/tmux.sock new-session -d -s iota \
-                      pkgs.writeShellScript "iota-start" ''
+                        "${pkgs.bash}/bin/bash -lc 'exec > >(${pkgs.coreutils}/bin/tee -a ${cfg.dataDir}/iota-output.log >(${pkgs.systemd}/bin/systemd-cat -t iota-daemon)) 2>&1; ${cfg.package}/bin/iota; status=$?; printf \"\nProcess exited with status %s. Press any key to close this tmux session...\" \"\$status\"; read -r -n 1; exit \"\$status\"'"
-                        set -e
+                    ''
-                        export TMUX_TMPDIR=${cfg.dataDir}
+                  else
-                        ${pkgs.coreutils}/bin/mkdir -p ${cfg.dataDir}
+                    "${cfg.package}/bin/iota";
-                        ${pkgs.coreutils}/bin/chown iota:iota ${cfg.dataDir}
 
-                        echo "[iota-start] Creating tmux session..."
+                  ExecStop = if cfg.useTmux then
-                        if ! ${pkgs.tmux}/bin/tmux -S ${cfg.dataDir}/tmux.sock new-session -d -s iota "${iotaTmuxCmd}"; then
+                    (pkgs.writeShellScript "iota-stop" ''
-                          echo "[iota-start] ERROR: tmux new-session failed"
+                      ${pkgs.tmux}/bin/tmux -S ${cfg.dataDir}/tmux.sock kill-session -t iota 2>/dev/null || true
-                          exit 1
+                    '')
-                        fi
+                  else
-                        echo "[iota-start] tmux session created, waiting..."
+                    null;
-                        echo "[iota-start] Run 'tmux -S ${cfg.dataDir}/tmux.sock attach -t iota' to attach to the tmux session."
-
-                        while ${pkgs.tmux}/bin/tmux -S ${cfg.dataDir}/tmux.sock has-session -t iota 2>/dev/null; do
-                          sleep 2
-                        done
-                        echo "[iota-start] tmux session ended"
-                      ''
-                    else "${cfg.package}/bin/iota";
 
                   ExecStartPre = [
-                    ("+"
+                    ("+" + pkgs.writeShellScript "iota-setup" ''
-                      + pkgs.writeShellScript "iota-setup" ''
+                      mkdir -p ${cfg.dataDir}/certs
-                        mkdir -p ${cfg.dataDir}/certs
 
-                        ${lib.optionalString (cfg.certFile != null) "ln -sf ${cfg.certFile} ${cfg.dataDir}/certs/cert.pem"}
+                      ${lib.optionalString (cfg.certFile != null) "ln -sf ${cfg.certFile} ${cfg.dataDir}/certs/cert.pem"}
-                        ${lib.optionalString (cfg.keyFile != null) "ln -sf ${cfg.keyFile} ${cfg.dataDir}/certs/cert.key"}
+                      ${lib.optionalString (cfg.keyFile != null) "ln -sf ${cfg.keyFile} ${cfg.dataDir}/certs/cert.key"}
 
-                        install -m 644 ${configFile} ${cfg.dataDir}/config.json
+                      install -m 644 ${configFile} ${cfg.dataDir}/config.json
 
-                        chown -R iota:iota ${cfg.dataDir}
+                      chown -R iota:iota ${cfg.dataDir}
-                      '')
+
+                      ${lib.optionalString cfg.useTmux ''
+                        echo "Iota started under tmux. Attach with: tmux -S ${cfg.dataDir}/tmux.sock attach -t iota" >&2
+                      ''}
+                    '')
                   ];
 
                   Restart = "always";
                   RestartSec = "5s";
 
-                  AmbientCapabilities = ["CAP_NET_BIND_SERVICE"];
+                  AmbientCapabilities = [ "CAP_NET_BIND_SERVICE" ];
-                  CapabilityBoundingSet = ["CAP_NET_BIND_SERVICE"];
+                  CapabilityBoundingSet = [ "CAP_NET_BIND_SERVICE" ];
 
                   ProtectSystem = "strict";
                   ProtectHome = true;
                   PrivateTmp = true;
                   NoNewPrivileges = true;
-                  ReadWritePaths = [cfg.dataDir];
+                  ReadWritePaths = [ cfg.dataDir ];
                   ProtectKernelTunables = true;
                   ProtectKernelModules = true;
                   ProtectControlGroups = true;
@@ -265,18 +231,17 @@
                     "TTP_BIND=${cfg.ttpBind}"
                     "BIND_ADDRESS=${cfg.bindAddress}"
                   ];
-                }
+                } // lib.optionalAttrs (cfg.environmentFiles != [ ]) {
-                // lib.optionalAttrs (cfg.environmentFiles != []) {
                   EnvironmentFile = cfg.environmentFiles;
                 };
-            };
+              };
 
-            networking.firewall = lib.mkIf cfg.openFirewall {
+              networking.firewall = lib.mkIf cfg.openFirewall {
-              allowedTCPPorts = [1984];
+                allowedTCPPorts = [ 1984 ];
-              allowedUDPPorts = [1984];
+                allowedUDPPorts = [ 1984 ];
+              };
             };
           };
-        };
       };
     };
 }

iota-util/src/file_util.rs

@@ -149,8 +149,9 @@ pub fn get_children(path: &str) -> Vec<String> {
 }
 
 pub fn get_directory() -> String {
-    std::env::current_dir()
+    let exe = std::env::current_exe().unwrap_or_else(|_| PathBuf::from("."));
-        .unwrap_or_else(|_| PathBuf::from("."))
+    exe.parent()
+        .unwrap_or(Path::new("."))
         .to_string_lossy()
         .to_string()
 }