ticktick-cli 1.0.2 → 1.1.0

package/README.md

@@ -5,7 +5,7 @@ A TypeScript CLI wrapper for the TickTick Open API documented at:
 - https://developer.ticktick.com/
 - https://developer.ticktick.com/docs#/openapi
 
-`v1.0.2` covers the documented OAuth flow plus every documented task and project endpoint.
+`v1` covers the documented OAuth flow plus every documented task and project endpoint.
 
 The CLI is available as both `ticktick` and the short alias `tt`.
 
@@ -13,6 +13,7 @@ The CLI is available as both `ticktick` and the short alias `tt`.
 
 - OAuth authorization code flow
 - OAuth authorize URL generation
+- Daily commands for `today`, `overdue`, and `next`
 - Get, create, update, complete, delete, move, list-completed, and filter task endpoints
 - List, get, create, update, delete, and get-data project endpoints
 - Raw authenticated request passthrough
@@ -100,6 +101,8 @@ Interactive login:
 ticktick auth login
 ```
 
+Successful auth stores the token in your local config file and masks secrets in the terminal output by default.
+
 If you already have an authorization code:
 
 ```bash
@@ -118,6 +121,8 @@ Check current auth state:
 ticktick auth status
 ```
 
+If you need the raw token values in the terminal, add `--show-secrets` to `auth login`, `auth exchange`, or `auth status`.
+
 Clear the stored access token:
 
 ```bash
@@ -126,6 +131,18 @@ ticktick auth logout
 
 ## Examples
 
+Daily task views:
+
+```bash
+ticktick today
+tt today
+ticktick overdue
+ticktick next
+ticktick task today --json
+```
+
+`today` includes both overdue tasks and tasks due today, with overdue shown first.
+
 List projects:
 
 ```bash

package/dist/auth.js

@@ -118,7 +118,7 @@ export async function openBrowserWith(url, options = {}) {
     const stderr = options.stderr ?? ((text) => process.stderr.write(text));
     try {
         if (platform === "win32") {
-            await run("cmd", ["/c", "start", "", url]);
+            await run("rundll32", ["url.dll,FileProtocolHandler", url]);
             return;
         }
         if (platform === "darwin") {

package/dist/cli.js

@@ -47,6 +47,7 @@ export function createProgram(dependencies = defaultCliDependencies) {
         .option("--scopes <scopes>", "Override the OAuth scopes");
     buildAuthCommands(program, dependencies);
     buildConfigCommands(program, dependencies);
+    buildDailyCommands(program, dependencies);
     buildTaskCommands(program, dependencies);
     buildProjectCommands(program, dependencies);
     buildRequestCommand(program, dependencies);
@@ -83,6 +84,7 @@ function buildAuthCommands(root, dependencies) {
         .command("login")
         .description("Open the OAuth flow, exchange the code, and store the access token")
         .option("--timeout-ms <number>", "Timeout while waiting for the callback", parseInteger, 120000)
+        .option("--show-secrets", "Include access token and refresh token in the output")
         .action(async (...args) => {
         const command = args.at(-1);
         const options = command.optsWithGlobals();
@@ -97,24 +99,27 @@ function buildAuthCommands(root, dependencies) {
             });
             return;
         }
+        dependencies.stderr(`Waiting for OAuth callback on ${config.redirectUri}...\n`);
         const codePromise = dependencies.waitForOAuthCode(config.redirectUri, state, options.timeoutMs);
         await dependencies.openBrowser(url);
         const code = await codePromise;
         const token = await dependencies.exchangeAuthorizationCode(config, code);
         await persistConfig(config, token, dependencies);
-        dependencies.printJson(token);
+        dependencies.printJson(formatAuthSuccess(config, token, options.showSecrets, dependencies));
     });
     auth
         .command("exchange <code>")
         .description("Exchange an authorization code for an access token")
+        .option("--show-secrets", "Include access token and refresh token in the output")
         .action(async (...args) => {
         const command = args.at(-1);
         const [code] = args;
-        const config = await dependencies.resolveRuntimeConfig(runtimeOverrides(command.optsWithGlobals(), dependencies));
+        const options = command.optsWithGlobals();
+        const config = await dependencies.resolveRuntimeConfig(runtimeOverrides(options, dependencies));
         requireClientCredentials(config);
         const token = await dependencies.exchangeAuthorizationCode(config, code);
         await persistConfig(config, token, dependencies);
-        dependencies.printJson(token);
+        dependencies.printJson(formatAuthSuccess(config, token, options.showSecrets, dependencies));
     });
     auth
         .command("status")
@@ -210,8 +215,171 @@ function buildConfigCommands(root, dependencies) {
         dependencies.printJson(stored);
     });
 }
+function buildDailyCommands(root, dependencies) {
+    buildDailyCommandSet(root, dependencies);
+}
+function buildDailyCommandSet(root, dependencies) {
+    root
+        .command("today")
+        .description("Show overdue tasks and tasks due today")
+        .option("--json", "Print structured JSON")
+        .action(async (...args) => {
+        await runDailyCommand(args, dependencies, "today");
+    });
+    root
+        .command("overdue")
+        .description("Show overdue open tasks")
+        .option("--json", "Print structured JSON")
+        .action(async (...args) => {
+        await runDailyCommand(args, dependencies, "overdue");
+    });
+    root
+        .command("next")
+        .description("Show the next 10 upcoming tasks after today")
+        .option("--json", "Print structured JSON")
+        .action(async (...args) => {
+        await runDailyCommand(args, dependencies, "next");
+    });
+}
+async function runDailyCommand(args, dependencies, mode) {
+    const command = args.at(-1);
+    const options = command.optsWithGlobals();
+    const config = await dependencies.resolveRuntimeConfig(runtimeOverrides(options, dependencies));
+    const client = dependencies.createClient(config);
+    const tasks = await client.listOpenTasksWithProjects();
+    const dueTasks = collectDueTasks(tasks);
+    const bounds = localDayBounds();
+    if (mode === "today") {
+        const view = buildTodayDueTaskView(dueTasks, bounds.start, bounds.end);
+        if (options.json) {
+            dependencies.printJson({
+                overdue: view.overdue.map(({ task }) => task),
+                today: view.today.map(({ task }) => task),
+            });
+            return;
+        }
+        printTaskSection("Overdue", view.overdue, "No overdue tasks.");
+        process.stdout.write("\n");
+        printTaskSection("Today", view.today, "Nothing due today.");
+        return;
+    }
+    const tasksView = mode === "overdue"
+        ? buildOverdueDueTaskView(dueTasks, bounds.start)
+        : buildNextDueTaskView(dueTasks, bounds.end, 10);
+    if (options.json) {
+        dependencies.printJson({
+            tasks: tasksView.tasks.map(({ task }) => task),
+        });
+        return;
+    }
+    if (mode === "overdue") {
+        printTaskSection("Overdue", tasksView.tasks, "No overdue tasks.");
+        return;
+    }
+    printTaskSection("Next", tasksView.tasks, "No upcoming tasks after today.");
+}
+function buildTodayDueTaskView(tasks, dayStart, nextDayStart) {
+    return {
+        overdue: tasks.filter(({ dueAt }) => dueAt.getTime() < dayStart.getTime()),
+        today: tasks.filter(({ dueAt }) => dueAt.getTime() >= dayStart.getTime() && dueAt.getTime() < nextDayStart.getTime()),
+    };
+}
+function buildOverdueDueTaskView(tasks, dayStart) {
+    return {
+        tasks: tasks.filter(({ dueAt }) => dueAt.getTime() < dayStart.getTime()),
+    };
+}
+function buildNextDueTaskView(tasks, nextDayStart, limit) {
+    return {
+        tasks: tasks
+            .filter(({ dueAt }) => dueAt.getTime() >= nextDayStart.getTime())
+            .slice(0, limit),
+    };
+}
+function collectDueTasks(tasks) {
+    return tasks
+        .flatMap((task) => {
+        const dueAt = parseTickTickDate(task.dueDate);
+        return dueAt ? [{ task, dueAt }] : [];
+    })
+        .sort(compareDueTasks);
+}
+function compareDueTasks(left, right) {
+    const dueTimeDelta = left.dueAt.getTime() - right.dueAt.getTime();
+    if (dueTimeDelta !== 0) {
+        return dueTimeDelta;
+    }
+    const priorityDelta = (right.task.priority ?? 0) - (left.task.priority ?? 0);
+    if (priorityDelta !== 0) {
+        return priorityDelta;
+    }
+    return (left.task.title ?? "").localeCompare(right.task.title ?? "");
+}
+function parseTickTickDate(value) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.replace(/([+-]\d{2})(\d{2})$/, "$1:$2");
+    const parsed = new Date(normalized);
+    if (Number.isNaN(parsed.getTime())) {
+        return undefined;
+    }
+    return parsed;
+}
+function localDayBounds(reference = new Date()) {
+    const start = new Date(reference);
+    start.setHours(0, 0, 0, 0);
+    const end = new Date(start);
+    end.setDate(end.getDate() + 1);
+    return { start, end };
+}
+function printTaskSection(title, tasks, emptyMessage) {
+    process.stdout.write(`${title} (${tasks.length})\n`);
+    if (tasks.length === 0) {
+        process.stdout.write(`${emptyMessage}\n`);
+        return;
+    }
+    for (const entry of tasks) {
+        process.stdout.write(`${formatTaskLine(entry)}\n`);
+    }
+}
+function formatTaskLine(entry) {
+    const title = entry.task.title?.trim() || "(Untitled task)";
+    const projectName = entry.task.projectName?.trim() || entry.task.projectId || "Unknown project";
+    return `- ${title} [${projectName}] - ${formatDueLabel(entry)}`;
+}
+function formatDueLabel(entry) {
+    const bounds = localDayBounds();
+    const due = entry.dueAt;
+    const dayKey = dueDayKey(due);
+    const todayKey = dueDayKey(bounds.start);
+    const yesterday = new Date(bounds.start);
+    yesterday.setDate(yesterday.getDate() - 1);
+    const yesterdayKey = dueDayKey(yesterday);
+    const baseLabel = dayKey === todayKey
+        ? "Today"
+        : dayKey === yesterdayKey
+            ? "Yesterday"
+            : new Intl.DateTimeFormat(undefined, {
+                weekday: "short",
+                month: "short",
+                day: "numeric",
+            }).format(due);
+    if (entry.task.isAllDay) {
+        return `${baseLabel} (all day)`;
+    }
+    const timeLabel = new Intl.DateTimeFormat(undefined, {
+        hour: "numeric",
+        minute: "2-digit",
+    }).format(due);
+    return `${baseLabel} ${timeLabel}`;
+}
+function dueDayKey(value) {
+    return `${value.getFullYear()}-${value.getMonth()}-${value.getDate()}`;
+}
 function buildTaskCommands(root, dependencies) {
-    const task = root.command("task").description("Task endpoints");
+    const task = root.command("task").description("Task endpoints and daily task views");
+    buildDailyCommandSet(task, dependencies);
     task
         .command("get <projectId> <taskId>")
         .description("Get a task by project id and task id")
@@ -509,6 +677,26 @@ async function persistConfig(runtime, token, dependencies) {
     };
     await dependencies.saveStoredConfig(runtime.configFile, next);
 }
+function formatAuthSuccess(runtime, token, showSecrets, dependencies) {
+    return {
+        ok: true,
+        message: "Authorization complete.",
+        service: runtime.service,
+        configFile: runtime.configFile,
+        redirectUri: runtime.redirectUri,
+        scope: token.scope ?? runtime.scopes,
+        tokenType: token.token_type,
+        expiresIn: token.expires_in,
+        accessToken: showSecrets
+            ? token.access_token
+            : dependencies.maskSecret(token.access_token),
+        refreshToken: token.refresh_token
+            ? showSecrets
+                ? token.refresh_token
+                : dependencies.maskSecret(token.refresh_token)
+            : undefined,
+    };
+}
 function requireClientCredentials(config) {
     if (!config.clientId || !config.clientSecret) {
         throw new Error("Client credentials are required. Set TICKTICK_CLIENT_ID and TICKTICK_CLIENT_SECRET or use `ticktick config set`.");

package/dist/client.js

@@ -72,6 +72,30 @@ export class TickTickClient {
     filterTasks(payload) {
         return this.requestRaw("POST", "/open/v1/task/filter", payload);
     }
+    async listOpenTasksWithProjects() {
+        const tasks = ((await this.filterTasks({ status: [0] })) ?? []).filter(isOpenTask);
+        const projectNames = new Map();
+        const projects = (await this.listProjects()) ?? [];
+        for (const project of projects) {
+            if (project.id && project.name) {
+                projectNames.set(project.id, project.name);
+            }
+        }
+        const missingProjectIds = Array.from(new Set(tasks
+            .map((task) => task.projectId)
+            .filter((projectId) => Boolean(projectId && !projectNames.has(projectId)))));
+        await Promise.all(missingProjectIds.map(async (projectId) => {
+            const data = await this.getProjectData(projectId);
+            const projectName = data?.project?.name ?? inferProjectName(projectId);
+            if (projectName) {
+                projectNames.set(projectId, projectName);
+            }
+        }));
+        return tasks.map((task) => ({
+            ...task,
+            projectName: task.projectId ? projectNames.get(task.projectId) ?? inferProjectName(task.projectId) : undefined,
+        }));
+    }
     listProjects() {
         return this.requestRaw("GET", "/open/v1/project");
     }
@@ -99,3 +123,15 @@ function tryParseJson(value) {
         return value;
     }
 }
+function isOpenTask(task) {
+    return !task.completedTime && task.status !== 2;
+}
+function inferProjectName(projectId) {
+    if (!projectId) {
+        return undefined;
+    }
+    if (projectId.startsWith("inbox")) {
+        return "Inbox";
+    }
+    return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticktick-cli",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "CLI wrapper for the TickTick Open API",
   "type": "module",
   "files": [