Project_ TaskServer (CCSync) – Making Task Synchronization Effortless
Project_ TaskServer (CCSync) – Making Task Synchronization Effortless
Organization: CCExtractor
Google Summer Of Code 2025
Mentor: Mabud Alam
Personal Introduction:
I am Nileshkumar Yadav, a 4th-year Computer Engineering undergrad at Shree LR
Tiwari College of Engineering, Mumbai, India. My interest lies in exploring new
technology and diving deep into it. I like to learn new things, and I am not afraid of
trying something new. I am always ready to learn and build whatever comes my
way.
I started coding in the 2nd year of my college and explored various technologies. I
found data structures and algorithms very interesting, along with databases. I came
across open-source contributions in my 3rd year and thought of giving it a try.
However, due to a lack of knowledge, I was not able to make much of an impact,
so I put it on hold to get more familiar with it.
To Me:
Open-source development excites me because it offers the opportunity to
contribute to real-world solutions. Being part of Google Summer of Code (GSoC)
is a long-held aspiration, and I’m committed to giving my best to complete this
project successfully. While I haven’t had the chance to work on a large-scale
practical project before, I’m now ready to dedicate myself entirely to this
challenge, learn from it, and grow as a developer.
To the Organization:
This project will provide users with an efficient and cost-free task management
solution. By ensuring seamless task synchronization across devices and platforms,
it will significantly enhance productivity for individual users and teams.
Additionally, a well-structured web UI and robust API will simplify task
management and offer a flexible alternative to paid task management tools. With
improved performance, security, and mobile integration, CCSync will become a
reliable choice for the open-source community and beyond.
Introduction of Project:
CCSync is a web UI and API solution designed to facilitate the retrieval and
synchronization of tasks from a taskchampion-sync-server container. It provides a
seamless experience for managing tasks across all Taskwarrior 3.0 (and higher)
clients, whether using the Taskwarrior CLI, the web frontend, or the Taskwarrior
Flutter app.
3.Taskwarrior Flutter App: The mobile app that allows users to manage
tasks on the go, fully integrated with the CCSync API.
Problem Statement:
Task management tools are critical for productivity, but existing open-source
solutions often lack seamless synchronization across platforms (CLI, web, mobile)
and self-hosting flexibility, limiting their adoption by users and teams. CCSync,
built on TaskWarrior’s ecosystem, aims to solve these challenges. However, the
current implementation faces critical gaps that hinder its production readiness:
Problem:
Users face session loss during server restarts, and manual API
management complicates integration with third-party tools.
Problem:
The mobile app lacks real-time updates and offline sync support,
reducing usability.
Impact:
Problem:
The backend struggles with large datasets (e.g., 100k+ tasks), causing
slow sync times and timeouts.
Impact:
Problem:
The Web UI lacks advanced features like bulk editing and task
prioritization, limiting adoption.
Impact:
Problem:
Impact:
Areas of Improvement:
The primary goal is to finalize CCSync for production by implementing
essential features, including:
● Enhancing the Web UI: Refine the web interface for better usability
and user experience, leveraging IndexedDB for offline support.
While significant progress was made last year, there is still room for
improvement in terms of performance, architecture, and scalability. This year,
the focus will be to:
Proposed Deliverables:
1.Authentication System (High Priority)
Provide API Key and Sync Token generation for TaskWarrior clients
to authenticate with the Taskchampion Sync Server.
Refine the existing data models for Tasks, Projects, and Tags
(models/task.go).
Implement background sync for offline tasks in the Flutter app, with
support for syncing when the app comes online.
5.Self-Hosting Capability
Refine the existing REST API with better error handling, input
validation, and rate limiting (build on the existing
RateLimitMiddleware).
10.Infrastructure Setup
11.Documentation (Must-Have)
Problem-Solution Mapping:
1.Authentication & Security
O Solution:
2.Cross-Platform Sync
O Solution:
O Solution:
Deliverable 5: Provide a Docker Compose setup for the
CCSync backend and Taskchampion Sync Server, with
clear environment variable configurations (e.g.,
CLIENT_ID, JWT_SECRET).
Deliverable 10: Optimize TaskWarrior command
execution in utils/tw (e.g., reduce temporary directory
creation overhead) and add Sentry logging for
performance monitoring.
4.Usability
O Solution:
Purpose:
My primary focus is to make TaskServer production-ready — ensuring that users
can self-host it, use it as a public service, and integrate it smoothly with the
existing TaskWarrior mobile app.
Implementation Detail:
The system architecture is modified as our goal is to make system cost effective
because some users will have 100k tasks in their system so it should handle it
efficiently:
■ Sync: /sync to fetch the full list of tasks from TaskWarrior when
the user clicks "Sync."
○ Description: The Flutter app syncs tasks with the Taskchampion Sync
Server independently.
○ Description: The Flutter app uses SQLite for local task storage.
Self-Hosting Capability (Public & Private Hosting)
Implementation Plan
Docker-Based Deployment:
Overview: The project already includes a Dockerfile for the CCSync backend. To
simplify deployment, we will enhance this by adding a Docker Compose setup for
a one-click deployment that includes both the CCSync backend and the
Taskchampion Sync Server. No external database is required, as task management
is handled by the Taskchampion Sync Server.
Goal: Enable users to run the entire CCSync system (backend and sync
server) with minimal effort.
Implementation Steps:
● Expose ports for both services (e.g., 8000 for the backend, 8080 for the sync
server).
2.Here’s an example
Docker-compose.yml:
version: '3.8'
services:
ccsync-backend:
build: .
env_file: .env
ports:
- "8000:8000"
depends_on:
- taskchampion-sync-server
taskchampion-sync-server:
restart: always
ports:
- "8080:8080"
environment:
- SYNC_SERVER_PORT=8080
- SYNC_SERVER_DATA_DIR=/data
volumes:
- sync-data:/data
volumes:
sync-data:
3.Update Documentation:
Goal: Enable a scalable, secure public deployment with minimal setup complexity.
Implementation Steps:
CLIENT_SEC=your_google_oauth_client_secret
REDIRECT_URL_DEV=http://localhost:8000/auth/callback
JWT_SECRET=your_jwt_secret
CONTAINER_ORIGIN=http://taskchampion-sync-server:8080
FRONTEND_ORIGIN_DEV=http://localhost:5172
Use a reverse proxy (e.g., Nginx) to handle HTTPS traffic for the public
instance.
server_name yourdomain.com;
ssl_certificate /path/to/cert.pem;
ssl_certificate_key /path/to/key.pem;
location / {
proxy_pass http://ccsync-backend:8000;
docker-compose build
docker-compose up -d
Configuration Management:
● Overview: Allow users to customize their CCSync setup without modifying
the source code by using environment variables.
● Goal: Ensure flexibility and ease of configuration for different hosting
scenarios.
Implementation Steps:
1. Update config.go to Read from Environment Variables:
Example in Go:
package config
import "os"
var (
FrontendOrigin = os.Getenv("FRONTEND_ORIGIN_DEV")
ClientID = os.Getenv("CLIENT_ID")
ClientSecret = os.Getenv("CLIENT_SEC")
RedirectURL = os.Getenv("REDIRECT_URL_DEV")
JWTSecret = os.Getenv("JWT_SECRET")
ContainerOrigin = os.Getenv("CONTAINER_ORIGIN")
Implementation of GUI:
I have a strong grasp of GUI development, so I am not overly concerned about it.
Additionally, there are not many GUI-related tasks in this project. My primary
focus is on working intensively on the backend to make it robust and
production-ready.
Also, there are here and some error in Gui which I will mend as I progresses in the
project and I found them while using it
Documentation Plan:
Clear and well-structured documentation is essential for CCSync to be easily
understandable and maintainable. As part of my implementation, I will focus on
writing detailed documentation that covers the following key areas:
To make onboarding easier, I will also create a "Getting Started" guide that
provides a quick overview of installation, setup, and basic usage. This will help
both developers and end-users get up to speed with CCSync efficiently.
Features to implement if project is completed before
GSoC time period:
If I complete the core tasks ahead of the GSoC timeline, I will focus on
implementing additional features to enhance the functionality of CCSync. These
may include:
● RSS Feeds for Upcoming Tasks: Implementing an RSS feed system that
allows users to subscribe to their upcoming tasks and receive updates in their
preferred feed reader.
● Push Notifications for Task Reminders: Adding support for push
notifications to alert users about upcoming or overdue tasks, improving task
management efficiency.
● Task Archive and History Functionality: Providing a way to archive
completed tasks and maintain a detailed history, allowing users to track
progress and revisit past tasks when needed.
These features will further enhance the usability of CCSync, making it more
user-friendly and efficient for task management.
BRIEF TIMELINE:
● Phase 0 (Till May 7): Pre-GSoC period.
● Phase 1 (May 8 - June 1): Community Bonding.
● Phase 2 (June 2 - July 14): Coding Phase 1.
● Phase 3 (July 14 - July 18): Midterm Evaluations.
● Phase 4 (July 14 - August 25): Coding Phase 2.
● Phase 5 (August 25 - September 1): Final Work Submission &
Evaluations.
● Phase 6 (September 1 - September 8): Final Mentor Evaluations.
● Phase 7 (September 1 - November 9): Extended Coding Period (if
applicable).
● Phase 8 (November 10): Final Deadline for Extended Projects.
Tentative Project Timeline for GSoC - CCSync:
Phase 0 (Till May 7): Pre-GSoC Period
Goals:
Tasks:
Goals:
Tasks:
By Midterm:
Key Milestones
Note1: I will be learning the necessary skills required for this project
alongside my work, as I am still developing my proficiency in Golang. I will be
implementing tasks while learning, with the guidance of my mentor.
Note2: Above all are the tentative timeline it can be changed if needed
according to the requirement of the project.
Availability:
As I am on my last semester of computer engineering which will be completed on
may I will be devoting my full time to this project and I do not have any other
summer internship
or Job, I reviewed the whole GSOC timeline and I would be able to devote approx.
40-50 hours every week to GSOC. If the project demands me to work overtime, I
am more than happy to work as my main goal is to complete this project.
I will be reporting my work to my mentor on a daily basis. I would strive to be
regular, and sincere with my scrum and daily updates as I understand that selection
in this project will require a serious commitment and 100% devotion from my side.
Why CCExtractor?
When I first started my open-source journey and began exploring GSoC,
CCExtractor was the first organization I came across. Out of curiosity, I started
looking into its projects and decided to solve a few issues. What began as a simple
exploration soon turned into something meaningful—I found myself deeply
engaged with the organization and its work.
CCExtractor, by coincidence, became the place where I took my first steps in open
source, and that connection has only grown stronger. The welcoming community,
the challenging yet exciting tasks, and the opportunity to contribute to real-world
projects have motivated me to continue working with CCExtractor. Now, as I apply
for GSoC, choosing CCExtractor feels less like a decision and more like a natural
continuation of my journey. I am eager to deepen my contributions and be part of
its growth while improving my own skills along the way.