TaskWarrior Server Setup: Secure Sync on Linux, Win & Android

TaskWarrior is a powerful open-source time management utility that enhances the functionality of Todo.txt and its derivatives. In today’s multi-device environment, having centralized access to your task data is crucial. This guide walks you through configuring the TaskServer (taskd) and the TaskWarrior client (task) so that several client devices can synchronize and securely share data.

Key Features

• Unlimited task creation
• Task prioritization
• Filtering with search
• Support for tags
• Syncing across devices automatically
• Built-in backup functionality
• Complete control and privacy
• Encrypted data transmission

System Requirements

• A 64-bit CentOS 7 server
• A user account with sudo privileges
• A domain name directing to your server (e.g., taskd.example.com)

Step 1: Perform System Update

Begin by logging in with your sudo-enabled user account. Proceed to install the EPEL repository and update the server system using the commands below:

sudo yum install epel-release -y
sudo yum clean all && sudo yum update -y

Step 2: Install RPM Build Tools and Prepare the Build Environment

Since the EPEL repository doesn't offer a prebuilt RPM package for TaskServer (taskd), you'll need to compile it from source into an RPM manually.

First, install the essential build tools, such as GCC, Make, RPM utilities, and signing components:

sudo yum install gcc gcc-c++ make rpmdevtools rpm-sign rpm-build -y

Create a directory to store GnuPG-related files required for signing the RPM packages:

mkdir .gnupg

Key generation depends on system entropy. To ensure sufficient entropy, install the rngd daemon which utilizes /dev/urandom:

yum install rngd -y

Launch the rngd daemon using /dev/urandom as the entropy source:

sudo rngd -r /dev/urandom

Generate a new GPG key pair with the following command:

gpg --gen-key

When prompted, use these selections:

• Select option (1) RSA and RSA (default)
• Use default key size: 2048
• Accept default expiration (no expiration)
• Confirm with y when asked if the configuration is correct
• Provide a name and email address
• Leave the Comment field blank or enter your own text
• Press O to confirm and create the key
• Enter and confirm your passphrase

To verify the GPG key pair and its files, run:

ls -la .gnupg

Export the generated GPG key to a file, replacing the placeholders with the actual name and custom identifier you provided:

gpg --export -a 'Joe Q. Public' > RPM-GPG-KEY-jqpublic

Import the exported key into RPM’s keyring:

sudo rpm --import RPM-GPG-KEY-jqpublic

Confirm the key was successfully added by running this query:

rpm -q gpg-pubkey --qf '%{name}-%{version}-%{release} --> %{summary}\n'

Now, create a file named .rpmmacros using a text editor like nano:

nano .rpmmacros

Add the following content, replacing the name with your GPG identity:

%_gpg_name  Joe Q. Public
%_query_all_fmt %%{name}-%%{version}-%%{release}.%%{arch}
%_signature gpg
%_topdir %(echo $HOME)/rpmbuild

To save the file: press CTRL + X, then press S, and hit Enter.

Set up the RPM development directory structure and extend the macros using this command:

rpmdev-setuptree

Inspect the directory structure of rpmbuild to ensure required folders were created:

find rpmbuild

Download the source code archive of TaskServer (version 1.1.0) into the SOURCES directory:

wget https://taskwarrior.org/download/taskd-1.1.0.tar.gz -P rpmbuild/SOURCES/

Terminate the running rngd process:

sudo kill -9 rngd

Step 3: Compile the TaskServer (taskd) RPM from Source

To create a new RPM package for TaskServer, begin by writing a SPEC file that outlines how the software will be built and packaged. This file must be placed in the rpmbuild/SPECS directory.

Open and edit the SPEC file with the following command:

nano rpmbuild/SPECS/taskd.spec

Insert the following content into the taskd.spec file:

Name:           taskd
Version:        1.1.0
Release:        1%{?dist}
Summary:        Secure server providing multi-user, multi-client access to task data
Group:          Applications/Productivity
License:        MIT
URL:            http://tasktools.org/projects/taskd.html
Source0:        http://taskwarrior.org/download/%{name}-%{version}.tar.gz
Source1:        taskd.service
Source2:        taskd-config
Source3:        taskd.xml

BuildRequires:  cmake
BuildRequires:  libuuid-devel
BuildRequires:  gnutls-devel
BuildRequires:  shadow-utils

%if 0%{?rhel} && 0%{?rhel} <= 6
%else
BuildRequires:  systemd
%endif

Requires:       gnutls-utils
Requires(post):    systemd
Requires(preun):   systemd
Requires(postun):  systemd

%description
The TaskServer provides secure, lightweight synchronization for task data across multiple clients and platforms. It enables users to maintain updated task lists from different devices and offers robust data exchange for systems without constant connectivity or identical features.

%prep
%setup -q %{name}-%{version}

%build
%cmake
make %{?_smp_mflags}

%install
make install DESTDIR=%{buildroot}

mkdir -p %{buildroot}%{_sharedstatedir}/taskd/
mkdir -p %{buildroot}%{_sysconfdir}/pki/taskd/
cp -a pki/generate* %{buildroot}%{_sysconfdir}/pki/taskd/.
mkdir -p %{buildroot}%{_localstatedir}/log/taskd/

%if 0%{?rhel} && 0%{?rhel} <= 6
%else
mkdir -p %{buildroot}%{_unitdir}/
cp -a %{SOURCE1} %{buildroot}%{_unitdir}/taskd.service
mkdir -p %{buildroot}%{_prefix}/lib/firewalld/services
cp -a %{SOURCE3} %{buildroot}%{_prefix}/lib/firewalld/services/taskd.xml
%endif

mkdir -p %{buildroot}%{_sharedstatedir}/taskd/orgs/
cp -a %{SOURCE2} %{buildroot}%{_sharedstatedir}/taskd/config
rm -r %{buildroot}%{_datadir}/doc/taskd/

%pre
getent group taskd >/dev/null || groupadd -r taskd
getent passwd taskd >/dev/null || \
    useradd -r -g taskd -d %{_sharedstatedir}/taskd/ -s /usr/bin/sh \
    -c "Task Server system user" taskd
exit 0

%if 0%{?rhel} && 0%{?rhel} <= 6
%else

%post
%systemd_post taskd.service

%preun
%systemd_preun taskd.service

%postun
%systemd_postun_with_restart taskd.service

%endif

%files
%doc AUTHORS COPYING ChangeLog NEWS README
%{_bindir}/taskd
%{_bindir}/taskdctl
%{_mandir}/man1/taskd.1.*
%{_mandir}/man1/taskdctl.1.*
%{_mandir}/man5/taskdrc.5.*

%{_sysconfdir}/pki/taskd/generate*

%dir %attr(0750, taskd, taskd) %{_sysconfdir}/pki/taskd/
%dir %attr(0750, taskd, taskd) %{_localstatedir}/log/taskd/
%dir %attr(0750, taskd, taskd) %{_sharedstatedir}/taskd/
%config(noreplace) %attr(0644, taskd, taskd) %{_sharedstatedir}/taskd/config
%dir %attr(0750, taskd, taskd) %{_sharedstatedir}/taskd/orgs/

%if 0%{?rhel} && 0%{?rhel} <= 6
%else
%{_unitdir}/taskd.service
%{_prefix}/lib/firewalld/services/taskd.xml
%endif

%changelog
* Thu Aug 17 2017 Jarrett Graham <jarrett+rpmbuild@jarrettgraham.com> - 1.1.0
- Initial packaging.
</jarrett+rpmbuild@jarrettgraham.com>

The RPM build process also needs three support files. First, create the taskd-config file in rpmbuild/SOURCES:

nano rpmbuild/SOURCES/taskd-config

Insert the following configuration settings:

# taskd configuration file
confirmation=1
verbose=1
ip.log=on
extensions=/usr/libexec/taskd
queue.size=10
request.limit=1048576
server=0.0.0.0:53589
root=/var/lib/taskd
log=/var/log/taskd/taskd.log
pid.file=/var/run/taskd.pid
ca.cert=/etc/pki/taskd/ca.cert.pem
server.cert=/etc/pki/taskd/server.cert.pem
server.key=/etc/pki/taskd/server.key.pem
server.crl=/etc/pki/taskd/server.crl.pem

Next, create the systemd service unit file for TaskServer:

nano rpmbuild/SOURCES/taskd.service

Add this unit definition for systemd:

[Unit]
Description=Secure server providing multi-user, multi-client access to task data
After=network.target
Documentation=https://tasktools.org/projects/taskd.html

[Service]
ExecStart=/usr/bin/taskd server --data /var/lib/taskd
Type=simple
User=taskd
Group=taskd

[Install]
WantedBy=multi-user.target

Create the taskd.xml Firewall Definition

The final supporting file needed is the taskd.xml, which defines a custom firewall service for TaskServer. Use the command below to create the file in the rpmbuild/SOURCES directory:

nano rpmbuild/SOURCES/taskd.xml

Add the following XML content to define the custom service for firewall rules:

<!--?xml version="1.0" encoding="utf-8"?-->

  Task-warrior server
  This option allows you to connect to the task warrior server.

Install Required Build Dependencies

Before compiling TaskServer, make sure all necessary development packages are installed. Use this command to install them:

sudo yum install cmake libuuid-devel gnutls-devel gnutls-utils -y

Build and Sign the TaskServer RPM Package

Navigate to the rpmbuild/SPECS directory and begin the build process. When prompted, enter the GPG password that you created earlier to sign the package:

cd rpmbuild/SPECS/
rpm -ba --sign taskd.spec

Install the Generated TaskServer RPM

After the RPM is successfully built, install it on your CentOS system using the command below. This will complete the setup of TaskServer:

cd
sudo rpm -ivh rpmbuild/RPMS/x86_64/taskd-1.1.0-1.el7.centos.x86_64.rpm

Step 4: Set Up and Configure TaskServer (taskd)

To allow synchronization between TaskServer (taskd) and TaskWarrior (task) clients, you must generate the necessary server and client certificates using the helper scripts located in /etc/pki/taskd/.

Switch to the root user and navigate to the certificate directory with these commands:

sudo su -
cd /etc/pki/taskd/

Next, create a configuration file named vars to define the settings for generating a self-signed Root Certificate Authority (CA):

nano vars

Add the following variables to the vars file, updating the values for organization, domain name, and location as needed:

BITS=4096
EXPIRATION_DAYS=365
ORGANIZATION="centron.de."
CN=taskd.example.com
COUNTRY=US
STATE="New York"
LOCALITY="New York"

Now, execute the following scripts to generate the Root CA, server certificate, server private key, and optionally a certificate revocation list:

./generate.ca
./generate.server
./generate.crl

These scripts will produce the following files inside the /etc/pki/taskd/ directory:

• ca.cert.pem
• ca.key.pem
• server.cert.pem
• server.key.pem
• server.crl.pem

TaskServer requires specific ownership and permission settings for these files. Apply the changes with the commands below:

chown taskd.taskd ca.cert.pem ca.key.pem server.cert.pem server.crl.pem server.key.pem
chmod 400 ca.cert.pem ca.key.pem server.cert.pem server.crl.pem server.key.pem

Enable and launch the TaskServer service with the following systemd commands:

systemctl enable taskd
systemctl start taskd

Finally, open the required TCP port in the system firewall and reload the ruleset to apply changes:

firewall-cmd --permanent --zone=public --add-port=53589/tcp
firewall-cmd --reload

With this, TaskServer (taskd) is now successfully configured and running on your CentOS 7 server.

Step 6: Set Up Your First TaskWarrior Group and User

To begin managing tasks using TaskWarrior, a user account is required. However, you must first establish an organizational group that users will belong to. Use the following command to create this group, replacing GROUP with a meaningful name of your choice:

Note: It’s critical to execute these commands as the taskd user. Running them as root will result in permission issues due to incorrect file ownership in /var/lib/taskd/orgs, which can block clients from accessing or syncing task data.

sudo -u taskd taskd add org GROUP --data /var/lib/taskd

After creating the group, proceed to add your first user. Replace GROUP with the group name from the previous step and enter the user’s full name in quotes. Once generated, save the user key, username, and group name in a secure text file. You can repeat this step for each new user you wish to register.

sudo -u taskd taskd add user GROUP 'Joe. Q. Public' --data /var/lib/taskd

Step 7: Install TaskWarrior on Windows 10

To use TaskWarrior on a Windows 10 machine (Build 1607 or newer), you'll need to install the Windows Subsystem for Linux (WSL). This enables a Linux environment that supports the TaskWarrior command-line tool.

Begin by launching an elevated PowerShell prompt. Press the Windows key, search for PowerShell, right-click on it, and select Run as administrator. In the User Account Control prompt, click Yes. Then, run the following command to enable WSL:

Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux

Once the installation finishes, press Y to reboot your computer. After restarting, open the Command Prompt and run:

bash

This installs Ubuntu on Windows. Accept the setup prompts, and choose a username and password as instructed.

Once inside the Linux shell, install TaskWarrior by running:

sudo apt-get install task -y

Type exit twice to close the Bash shell and the Command Prompt. For quick access to Bash in the future, open the Start Menu, search for Ubuntu, right-click on Bash on Ubuntu on Windows, and choose Pin to taskbar.

Launch Ubuntu from the taskbar and run the following command to create the TaskWarrior data directory and config file:

task version
yes

Now, place your certificates.zip file—downloaded earlier during the TaskServer setup—into the ~/.task/ directory. Before extraction, ensure that the unzip utility is installed:

sudo apt-get install unzip -y
cp /mnt/c/User/WINDOWSUSER/Desktop/certificates.zip .
cd .task
unzip ../certificates.zip
cd

To connect the client with the TaskServer, configure TaskWarrior using the following commands. Replace the placeholders with your actual certificate filenames, organization name, user name, and unique key:

task config taskd.ca -- ~/.task/ca.cert.pem
task config taskd.certificate -- ~/.task/**NAME**.cert.pem
task config taskd.key -- ~/.task/**NAME**.key.pem
task config taskd.server -- taskd.example.com:53589
task config taskd.credentials -- GROUP/Joe Q. Public/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX

With your client configured, initialize synchronization with the TaskServer using this command:

task sync init

TaskWarrior on your Windows 10 system is now successfully connected to the TaskServer and ready for task synchronization.

Step 8: Install TaskWarrior on Android

To use TaskWarrior on Android, download the official TaskWarrior For Android app from the Google Play Store.

1. Open the Google Play Store and install TaskWarrior For Android.
2. Launch the app after installation completes.
3. When prompted, enter your preferred account name—the same one used when the user was created on the TaskServer.
4. Leave the Data Folder set to <<Create new>> and tap OK.
5. Using a file manager, create a new folder on your Android device—for example, /storage/emulate/0/Certs.
6. Place the previously saved certificates.zip file into that folder and extract its contents.
7. Return to the TaskWarrior app and open the menu by tapping the icon at the top left corner.
8. Scroll down and choose Settings to launch the built-in configuration editor.

Add the following settings into the editor to configure synchronization with the TaskServer. Update each line by replacing NAME, GROUP, Joe Q. Public, and the user key appropriately:

taskd.ca=/storage/emulate/0/Certs/ca.cert.pem
taskd.certificate=/storage/emulate/0/Certs/NAME.cert.pem
taskd.credentials=GROUP/Joe Q. Public/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
taskd.key=/storage/emulate/0/Certs/NAME.key.pem
taskd.server=taskd.example.com:53589

Once all values are filled in, tap the floppy disk icon to save your configuration.

Your TaskWarrior client on Android is now connected and synchronized with your TaskServer instance.

Step 9: Install TaskWarrior on Linux

To install TaskWarrior on Linux, consult your distribution’s package repository or the official TaskWarrior website for the appropriate installation method.

Once installed, open a terminal and run the following command to create the TaskWarrior configuration file and data directory:

task version
yes

Move the certificates.zip file you generated during the TaskServer setup into your home directory. Extract its contents into the ~/.task directory. If you don’t already have the unzip utility, install it using your package manager first. Then, execute the following commands (adjusting the path to your ZIP file as needed):

cp /location/of/certificates.zip .
cd .task
unzip ../certificates.zip
cd

Next, configure TaskWarrior to connect with your TaskServer. Replace the placeholders such as NAME, GROUP, Joe Q. Public, and the user’s unique key accordingly:

task config taskd.ca -- ~/.task/ca.cert.pem
task config taskd.certificate -- ~/.task/**NAME**.cert.pem
task config taskd.key -- ~/.task/**NAME**.key.pem
task config taskd.server -- taskd.example.com:53589
task config taskd.credentials -- GROUP/Joe Q. Public/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXX

Finally, initialize synchronization between TaskWarrior and your TaskServer by running the command below:

task sync init

Additional Tip: If you are using GNOME Shell, you may want to explore the “TaskWhisper” extension, which provides an interface for integrating TaskWarrior into your desktop environment.

Your TaskWarrior client is now successfully configured to sync with your TaskServer on Linux.

Conclusion

TaskWarrior, combined with TaskServer, delivers a secure, synchronized, and platform-independent solution for task management. Whether you're operating on CentOS, Windows, Linux, or Android, this setup allows you to seamlessly manage and sync your task data across multiple devices and users. By configuring TaskServer with proper certificates and securely linking each TaskWarrior client, you gain full control, privacy, and convenience—tailored for both individuals and teams. With this guide, you've now built a fully functional, encrypted, and flexible task management environment ready for real-world productivity.