ticktick-cli 0.1.1 → 1.0.2

package/README.md

@@ -1,11 +1,13 @@
-# TickTick CLI
+# TickTick CLI v1
 
-A simple TypeScript CLI wrapper for the TickTick Open API documented at:
+A TypeScript CLI wrapper for the TickTick Open API documented at:
 
 - https://developer.ticktick.com/
 - https://developer.ticktick.com/docs#/openapi
 
-This wrapper covers the documented OAuth flow plus every documented task and project endpoint.
+`v1.0.2` covers the documented OAuth flow plus every documented task and project endpoint.
+
+The CLI is available as both `ticktick` and the short alias `tt`.
 
 ## What it covers
 
@@ -19,6 +21,10 @@ This wrapper covers the documented OAuth flow plus every documented task and pro
 
 ## Install
 
+Requires Node.js `18+`.
+
+Install from the local repo:
+
 ```bash
 npm install
 npm run build
@@ -27,7 +33,7 @@ npm run build
 Run locally with:
 
 ```bash
-node dist/cli.js --help
+node dist/bin.js --help
 ```
 
 Or install the built CLI globally from this directory:
@@ -35,8 +41,19 @@ Or install the built CLI globally from this directory:
 ```bash
 npm install -g .
 ticktick --help
+tt --help
+```
+
+Once published to npm, install it with:
+
+```bash
+npm install -g ticktick-cli
+ticktick --help
+tt --help
 ```
 
+All command examples below use `ticktick`, but `tt` works the same way.
+
 ## Configure
 
 The CLI reads config in this order:
@@ -60,6 +77,12 @@ TICKTICK_AUTH_BASE_URL=https://ticktick.com
 TICKTICK_CONFIG_FILE=/custom/path/config.json
 ```
 
+Default local redirect URI:
+
+```bash
+http://127.0.0.1:18463/callback
+```
+
 You can also persist config values:
 
 ```bash
@@ -180,6 +203,14 @@ Send a raw request to a full URL without bearer auth:
 ticktick request POST https://httpbin.org/post --no-auth --json '{"hello":"world"}'
 ```
 
+## Development
+
+Build the CLI:
+
+```bash
+npm run build
+```
+
 ## Notes
 
 - The docs currently show `api.ticktick.com` for most endpoints, but `api.dida365.com` in the examples for `task/move`, `task/completed`, and `task/filter`. This CLI defaults to the selected service profile and lets you override base URLs explicitly if your account needs something different.

package/dist/auth.js

@@ -32,7 +32,16 @@ export async function exchangeAuthorizationCode(config, code, fetchImpl = fetch)
         body: params,
     });
     const raw = await response.text();
-    const parsed = raw.length > 0 ? JSON.parse(raw) : {};
+    let parsed = {};
+    if (raw.length > 0) {
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Token exchange returned invalid JSON: ${message}`);
+        }
+    }
     if (!response.ok) {
         throw new Error(`Token exchange failed with status ${response.status}: ${JSON.stringify(parsed)}`);
     }
@@ -46,18 +55,24 @@ export function isLoopbackRedirect(redirectUri) {
     return (parsed.protocol === "http:" &&
         ["127.0.0.1", "localhost"].includes(parsed.hostname));
 }
+export function getOAuthCallbackBinding(redirectUri) {
+    const redirect = new URL(redirectUri);
+    return {
+        hostname: redirect.hostname === "localhost" ? "127.0.0.1" : redirect.hostname,
+        port: Number.parseInt(redirect.port || "80", 10),
+        callbackPath: redirect.pathname,
+    };
+}
 export async function waitForOAuthCode(redirectUri, expectedState, timeoutMs = 120_000) {
     const redirect = new URL(redirectUri);
-    const hostname = redirect.hostname === "localhost" ? "127.0.0.1" : redirect.hostname;
-    const port = Number.parseInt(redirect.port || "80", 10);
-    const callbackPath = redirect.pathname || "/";
+    const { hostname, port, callbackPath } = getOAuthCallbackBinding(redirectUri);
     return new Promise((resolve, reject) => {
         const timeout = setTimeout(() => {
             server.close();
             reject(new Error("Timed out waiting for the OAuth callback."));
         }, timeoutMs);
         const server = createServer((request, response) => {
-            const requestUrl = new URL(request.url ?? "/", redirect.origin);
+            const requestUrl = new URL(request.url, redirect.origin);
             if (requestUrl.pathname !== callbackPath) {
                 response.statusCode = 404;
                 response.end("Not Found");
@@ -91,20 +106,29 @@ export async function waitForOAuthCode(redirectUri, expectedState, timeoutMs = 1
         server.listen(port, hostname);
     });
 }
-export async function openBrowser(url) {
+export async function openBrowser(url, options) {
+    return openBrowserWith(url, options);
+}
+export async function openBrowserWith(url, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const run = options.execFile ??
+        (async (file, args) => {
+            await execFileAsync(file, args);
+        });
+    const stderr = options.stderr ?? ((text) => process.stderr.write(text));
     try {
-        if (process.platform === "win32") {
-            await execFileAsync("cmd", ["/c", "start", "", url]);
+        if (platform === "win32") {
+            await run("cmd", ["/c", "start", "", url]);
             return;
         }
-        if (process.platform === "darwin") {
-            await execFileAsync("open", [url]);
+        if (platform === "darwin") {
+            await run("open", [url]);
             return;
         }
-        await execFileAsync("xdg-open", [url]);
+        await run("xdg-open", [url]);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        process.stderr.write(`Could not open a browser automatically: ${message}\n`);
+        stderr(`Could not open a browser automatically: ${message}\n`);
     }
 }

package/dist/bin.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from "./cli.js";
+await main();

package/dist/cli.js

@@ -1,5 +1,5 @@
-#!/usr/bin/env node
 import { Command } from "commander";
+import { pathToFileURL } from "node:url";
 import { buildAuthorizationUrl, exchangeAuthorizationCode, isLoopbackRedirect, openBrowser, waitForOAuthCode, } from "./auth.js";
 import { TickTickClient } from "./client.js";
 import { loadStoredConfig, resolveRuntimeConfig, saveStoredConfig, validateService, } from "./config.js";
@@ -14,26 +14,59 @@ const CONFIG_KEYS = new Set([
     "apiBaseUrl",
     "authBaseUrl",
 ]);
-const program = new Command();
-program
-    .name("ticktick")
-    .description("Simple CLI wrapper for the TickTick Open API")
-    .option("--config-file <path>", "Custom config file path")
-    .option("--service <service>", 'Service: "ticktick" or "dida365"')
-    .option("--api-base-url <url>", "Override the API base URL")
-    .option("--auth-base-url <url>", "Override the OAuth base URL")
-    .option("--access-token <token>", "Override the access token for a single command")
-    .option("--client-id <id>", "Override the OAuth client id")
-    .option("--client-secret <secret>", "Override the OAuth client secret")
-    .option("--redirect-uri <uri>", "Override the OAuth redirect URI")
-    .option("--scopes <scopes>", "Override the OAuth scopes");
-buildAuthCommands(program);
-buildConfigCommands(program);
-buildTaskCommands(program);
-buildProjectCommands(program);
-buildRequestCommand(program);
-program.parseAsync(process.argv).catch(handleError);
-function buildAuthCommands(root) {
+export const defaultCliDependencies = {
+    buildAuthorizationUrl,
+    exchangeAuthorizationCode,
+    isLoopbackRedirect,
+    loadJsonValue,
+    loadStoredConfig,
+    maskSecret,
+    mergeDefined,
+    openBrowser,
+    printJson,
+    resolveRuntimeConfig,
+    saveStoredConfig,
+    validateService,
+    waitForOAuthCode,
+    createClient: (config) => new TickTickClient(config),
+    stderr: (text) => process.stderr.write(text),
+};
+export function createProgram(dependencies = defaultCliDependencies) {
+    const program = new Command();
+    program
+        .name("ticktick")
+        .description("CLI wrapper for the TickTick Open API")
+        .option("--config-file <path>", "Custom config file path")
+        .option("--service <service>", 'Service: "ticktick" or "dida365"')
+        .option("--api-base-url <url>", "Override the API base URL")
+        .option("--auth-base-url <url>", "Override the OAuth base URL")
+        .option("--access-token <token>", "Override the access token for a single command")
+        .option("--client-id <id>", "Override the OAuth client id")
+        .option("--client-secret <secret>", "Override the OAuth client secret")
+        .option("--redirect-uri <uri>", "Override the OAuth redirect URI")
+        .option("--scopes <scopes>", "Override the OAuth scopes");
+    buildAuthCommands(program, dependencies);
+    buildConfigCommands(program, dependencies);
+    buildTaskCommands(program, dependencies);
+    buildProjectCommands(program, dependencies);
+    buildRequestCommand(program, dependencies);
+    return program;
+}
+export async function main(argv = process.argv, dependencies = defaultCliDependencies) {
+    const program = createProgram(dependencies);
+    try {
+        await program.parseAsync(argv);
+    }
+    catch (error) {
+        handleError(error, dependencies);
+    }
+}
+export function handleError(error, dependencies = defaultCliDependencies) {
+    const message = error instanceof Error ? error.message : String(error);
+    dependencies.stderr(`${message}\n`);
+    process.exitCode = 1;
+}
+function buildAuthCommands(root, dependencies) {
     const auth = root.command("auth").description("OAuth and token management");
     auth
         .command("url")
@@ -42,10 +75,9 @@ function buildAuthCommands(root) {
         .action(async (...args) => {
         const command = args.at(-1);
         const options = command.optsWithGlobals();
-        const config = await resolveRuntimeConfig(runtimeOverrides(options));
+        const config = await dependencies.resolveRuntimeConfig(runtimeOverrides(options, dependencies));
         requireClientId(config);
-        const result = buildAuthorizationUrl(config, options.state);
-        printJson(result);
+        dependencies.printJson(dependencies.buildAuthorizationUrl(config, options.state));
     });
     auth
         .command("login")
@@ -54,23 +86,23 @@ function buildAuthCommands(root) {
         .action(async (...args) => {
         const command = args.at(-1);
         const options = command.optsWithGlobals();
-        const config = await resolveRuntimeConfig(runtimeOverrides(options));
+        const config = await dependencies.resolveRuntimeConfig(runtimeOverrides(options, dependencies));
         requireClientCredentials(config);
-        const { url, state } = buildAuthorizationUrl(config);
-        process.stderr.write(`Authorize URL:\n${url}\n`);
-        if (!isLoopbackRedirect(config.redirectUri)) {
-            printJson({
+        const { url, state } = dependencies.buildAuthorizationUrl(config);
+        dependencies.stderr(`Authorize URL:\n${url}\n`);
+        if (!dependencies.isLoopbackRedirect(config.redirectUri)) {
+            dependencies.printJson({
                 ok: false,
                 reason: "redirect_uri is not a local HTTP callback. Open the URL above and then run `ticktick auth exchange <code>`.",
             });
             return;
         }
-        const codePromise = waitForOAuthCode(config.redirectUri, state, options.timeoutMs);
-        await openBrowser(url);
+        const codePromise = dependencies.waitForOAuthCode(config.redirectUri, state, options.timeoutMs);
+        await dependencies.openBrowser(url);
         const code = await codePromise;
-        const token = await exchangeAuthorizationCode(config, code);
-        await persistConfig(config, token.access_token);
-        printJson(token);
+        const token = await dependencies.exchangeAuthorizationCode(config, code);
+        await persistConfig(config, token, dependencies);
+        dependencies.printJson(token);
     });
     auth
         .command("exchange <code>")
@@ -78,11 +110,11 @@ function buildAuthCommands(root) {
         .action(async (...args) => {
         const command = args.at(-1);
         const [code] = args;
-        const config = await resolveRuntimeConfig(runtimeOverrides(command.optsWithGlobals()));
+        const config = await dependencies.resolveRuntimeConfig(runtimeOverrides(command.optsWithGlobals(), dependencies));
         requireClientCredentials(config);
-        const token = await exchangeAuthorizationCode(config, code);
-        await persistConfig(config, token.access_token);
-        printJson(token);
+        const token = await dependencies.exchangeAuthorizationCode(config, code);
+        await persistConfig(config, token, dependencies);
+        dependencies.printJson(token);
     });
     auth
         .command("status")
@@ -91,15 +123,19 @@ function buildAuthCommands(root) {
         .action(async (...args) => {
         const command = args.at(-1);
         const options = command.optsWithGlobals();
-        const config = await resolveRuntimeConfig(runtimeOverrides(options));
-        printJson({
+        const config = await dependencies.resolveRuntimeConfig(runtimeOverrides(options, dependencies));
+        dependencies.printJson({
             service: config.service,
             configFile: config.configFile,
             clientId: config.clientId,
-            clientSecret: options.showSecrets ? config.clientSecret : maskSecret(config.clientSecret),
+            clientSecret: options.showSecrets
+                ? config.clientSecret
+                : dependencies.maskSecret(config.clientSecret),
             redirectUri: config.redirectUri,
             scopes: config.scopes,
-            accessToken: options.showSecrets ? config.accessToken : maskSecret(config.accessToken),
+            accessToken: options.showSecrets
+                ? config.accessToken
+                : dependencies.maskSecret(config.accessToken),
             apiBaseUrl: config.apiBaseUrl,
             authBaseUrl: config.authBaseUrl,
         });
@@ -109,14 +145,14 @@ function buildAuthCommands(root) {
         .description("Remove the stored access token from the config file")
         .action(async (...args) => {
         const command = args.at(-1);
-        const config = await resolveRuntimeConfig(runtimeOverrides(command.optsWithGlobals()));
-        const stored = await loadStoredConfig(config.configFile);
+        const config = await dependencies.resolveRuntimeConfig(runtimeOverrides(command.optsWithGlobals(), dependencies));
+        const stored = await dependencies.loadStoredConfig(config.configFile);
         delete stored.accessToken;
-        await saveStoredConfig(config.configFile, stored);
-        printJson({ ok: true });
+        await dependencies.saveStoredConfig(config.configFile, stored);
+        dependencies.printJson({ ok: true });
     });
 }
-function buildConfigCommands(root) {
+function buildConfigCommands(root, dependencies) {
     const config = root.command("config").description("Read and write local CLI config");
     config
         .command("show")
@@ -125,15 +161,19 @@ function buildConfigCommands(root) {
         .action(async (...args) => {
         const command = args.at(-1);
         const options = command.optsWithGlobals();
-        const resolved = await resolveRuntimeConfig(runtimeOverrides(options));
-        printJson({
+        const resolved = await dependencies.resolveRuntimeConfig(runtimeOverrides(options, dependencies));
+        dependencies.printJson({
             service: resolved.service,
             configFile: resolved.configFile,
             clientId: resolved.clientId,
-            clientSecret: options.showSecrets ? resolved.clientSecret : maskSecret(resolved.clientSecret),
+            clientSecret: options.showSecrets
+                ? resolved.clientSecret
+                : dependencies.maskSecret(resolved.clientSecret),
             redirectUri: resolved.redirectUri,
             scopes: resolved.scopes,
-            accessToken: options.showSecrets ? resolved.accessToken : maskSecret(resolved.accessToken),
+            accessToken: options.showSecrets
+                ? resolved.accessToken
+                : dependencies.maskSecret(resolved.accessToken),
             apiBaseUrl: resolved.apiBaseUrl,
             authBaseUrl: resolved.authBaseUrl,
         });
@@ -144,15 +184,15 @@ function buildConfigCommands(root) {
         .action(async (...args) => {
         const command = args.at(-1);
         const [key, value] = args;
-        const runtime = await resolveRuntimeConfig(runtimeOverrides(command.optsWithGlobals()));
+        const runtime = await dependencies.resolveRuntimeConfig(runtimeOverrides(command.optsWithGlobals(), dependencies));
         if (!CONFIG_KEYS.has(key)) {
             throw new Error(`Unsupported config key "${key}". Allowed keys: ${Array.from(CONFIG_KEYS).join(", ")}`);
         }
-        const stored = await loadStoredConfig(runtime.configFile);
-        const normalizedValue = key === "service" ? validateService(value) : value;
+        const stored = await dependencies.loadStoredConfig(runtime.configFile);
+        const normalizedValue = key === "service" ? dependencies.validateService(value) : value;
         const next = { ...stored, [key]: normalizedValue };
-        await saveStoredConfig(runtime.configFile, next);
-        printJson(next);
+        await dependencies.saveStoredConfig(runtime.configFile, next);
+        dependencies.printJson(next);
     });
     config
         .command("unset <key>")
@@ -160,24 +200,24 @@ function buildConfigCommands(root) {
         .action(async (...args) => {
         const command = args.at(-1);
         const [key] = args;
-        const runtime = await resolveRuntimeConfig(runtimeOverrides(command.optsWithGlobals()));
+        const runtime = await dependencies.resolveRuntimeConfig(runtimeOverrides(command.optsWithGlobals(), dependencies));
         if (!CONFIG_KEYS.has(key)) {
             throw new Error(`Unsupported config key "${key}". Allowed keys: ${Array.from(CONFIG_KEYS).join(", ")}`);
         }
-        const stored = await loadStoredConfig(runtime.configFile);
+        const stored = await dependencies.loadStoredConfig(runtime.configFile);
         delete stored[key];
-        await saveStoredConfig(runtime.configFile, stored);
-        printJson(stored);
+        await dependencies.saveStoredConfig(runtime.configFile, stored);
+        dependencies.printJson(stored);
     });
 }
-function buildTaskCommands(root) {
+function buildTaskCommands(root, dependencies) {
     const task = root.command("task").description("Task endpoints");
     task
         .command("get <projectId> <taskId>")
         .description("Get a task by project id and task id")
         .action(async (...args) => {
         const [projectId, taskId] = args;
-        await runClientCommand(args, (client) => client.getTask(projectId, taskId));
+        await runClientCommand(args, dependencies, (client) => client.getTask(projectId, taskId));
     });
     withJsonBody(task
         .command("create")
@@ -207,11 +247,11 @@ function buildTaskCommands(root) {
             priority: options.priority,
             sortOrder: options.sortOrder,
             isAllDay: options.allDay,
-        }));
+        }, dependencies));
         if (!payload.projectId || !payload.title) {
             throw new Error("Task creation requires both projectId and title.");
         }
-        await runClientCommand(args, (client) => client.createTask(payload));
+        await runClientCommand(args, dependencies, (client) => client.createTask(payload));
     });
     withJsonBody(task
         .command("update <taskId>")
@@ -243,26 +283,26 @@ function buildTaskCommands(root) {
             priority: options.priority,
             sortOrder: options.sortOrder,
             isAllDay: options.allDay,
-        }));
+        }, dependencies));
         payload.id = taskId;
         if (!payload.projectId) {
             throw new Error("Task update requires projectId.");
         }
-        await runClientCommand(args, (client) => client.updateTask(taskId, payload));
+        await runClientCommand(args, dependencies, (client) => client.updateTask(taskId, payload));
     });
     task
         .command("complete <projectId> <taskId>")
         .description("Complete a task")
         .action(async (...args) => {
         const [projectId, taskId] = args;
-        await runClientCommand(args, (client) => client.completeTask(projectId, taskId));
+        await runClientCommand(args, dependencies, (client) => client.completeTask(projectId, taskId));
     });
     task
         .command("delete <projectId> <taskId>")
         .description("Delete a task")
         .action(async (...args) => {
         const [projectId, taskId] = args;
-        await runClientCommand(args, (client) => client.deleteTask(projectId, taskId));
+        await runClientCommand(args, dependencies, (client) => client.deleteTask(projectId, taskId));
     });
     withJsonBody(task
         .command("move")
@@ -272,7 +312,7 @@ function buildTaskCommands(root) {
         .option("--task-id <id>", "Task id")).action(async (...args) => {
         const command = args.at(-1);
         const options = command.optsWithGlobals();
-        let payload = (await loadJsonValue(options.json, options.jsonFile));
+        let payload = (await dependencies.loadJsonValue(options.json, options.jsonFile));
         if (!payload) {
             if (!options.fromProjectId || !options.toProjectId || !options.taskId) {
                 throw new Error("Provide --json/--json-file or all of --from-project-id, --to-project-id, and --task-id.");
@@ -288,7 +328,7 @@ function buildTaskCommands(root) {
         if (!Array.isArray(payload)) {
             throw new Error("Move payload must be a JSON array.");
         }
-        await runClientCommand(args, (client) => client.moveTasks(payload));
+        await runClientCommand(args, dependencies, (client) => client.moveTasks(payload));
     });
     withJsonBody(task
         .command("completed")
@@ -302,8 +342,8 @@ function buildTaskCommands(root) {
             projectIds: options.projectId && options.projectId.length > 0 ? options.projectId : undefined,
             startDate: options.startDate,
             endDate: options.endDate,
-        }));
-        await runClientCommand(args, (client) => client.listCompletedTasks(payload));
+        }, dependencies));
+        await runClientCommand(args, dependencies, (client) => client.listCompletedTasks(payload));
     });
     withJsonBody(task
         .command("filter")
@@ -323,31 +363,31 @@ function buildTaskCommands(root) {
             priority: options.priority && options.priority.length > 0 ? options.priority : undefined,
             tag: options.tag && options.tag.length > 0 ? options.tag : undefined,
             status: options.status && options.status.length > 0 ? options.status : undefined,
-        }));
-        await runClientCommand(args, (client) => client.filterTasks(payload));
+        }, dependencies));
+        await runClientCommand(args, dependencies, (client) => client.filterTasks(payload));
     });
 }
-function buildProjectCommands(root) {
+function buildProjectCommands(root, dependencies) {
     const project = root.command("project").description("Project endpoints");
     project
         .command("list")
         .description("List user projects")
         .action(async (...args) => {
-        await runClientCommand(args, (client) => client.listProjects());
+        await runClientCommand(args, dependencies, (client) => client.listProjects());
     });
     project
         .command("get <projectId>")
         .description("Get a project by id")
         .action(async (...args) => {
         const [projectId] = args;
-        await runClientCommand(args, (client) => client.getProject(projectId));
+        await runClientCommand(args, dependencies, (client) => client.getProject(projectId));
     });
     project
         .command("data <projectId>")
         .description("Get a project together with tasks and columns")
         .action(async (...args) => {
         const [projectId] = args;
-        await runClientCommand(args, (client) => client.getProjectData(projectId));
+        await runClientCommand(args, dependencies, (client) => client.getProjectData(projectId));
     });
     withJsonBody(project
         .command("create")
@@ -365,11 +405,11 @@ function buildProjectCommands(root) {
             sortOrder: options.sortOrder,
             viewMode: options.viewMode,
             kind: options.kind,
-        }));
+        }, dependencies));
         if (!payload.name) {
             throw new Error("Project creation requires name.");
         }
-        await runClientCommand(args, (client) => client.createProject(payload));
+        await runClientCommand(args, dependencies, (client) => client.createProject(payload));
     });
     withJsonBody(project
         .command("update <projectId>")
@@ -388,18 +428,18 @@ function buildProjectCommands(root) {
             sortOrder: options.sortOrder,
             viewMode: options.viewMode,
             kind: options.kind,
-        }));
-        await runClientCommand(args, (client) => client.updateProject(projectId, payload));
+        }, dependencies));
+        await runClientCommand(args, dependencies, (client) => client.updateProject(projectId, payload));
     });
     project
         .command("delete <projectId>")
         .description("Delete a project")
         .action(async (...args) => {
         const [projectId] = args;
-        await runClientCommand(args, (client) => client.deleteProject(projectId));
+        await runClientCommand(args, dependencies, (client) => client.deleteProject(projectId));
     });
 }
-function buildRequestCommand(root) {
+function buildRequestCommand(root, dependencies) {
     withJsonBody(root
         .command("request <method> <path>")
         .description("Send a raw request to the configured API base URL, or to a full URL")
@@ -407,11 +447,13 @@ function buildRequestCommand(root) {
         const command = args.at(-1);
         const [method, path] = args;
         const options = command.optsWithGlobals();
-        const config = await resolveRuntimeConfig(runtimeOverrides(options));
-        const client = new TickTickClient(config);
-        const body = await loadJsonValue(options.json, options.jsonFile);
-        const result = await client.requestRaw(method.toUpperCase(), path, body, { auth: options.auth });
-        printJson(result ?? { ok: true });
+        const config = await dependencies.resolveRuntimeConfig(runtimeOverrides(options, dependencies));
+        const client = dependencies.createClient(config);
+        const body = await dependencies.loadJsonValue(options.json, options.jsonFile);
+        const result = await client.requestRaw(method.toUpperCase(), path, body, {
+            auth: options.auth,
+        });
+        dependencies.printJson(result ?? { ok: true });
     });
 }
 function withJsonBody(command) {
@@ -419,10 +461,10 @@ function withJsonBody(command) {
         .option("--json <json>", "Inline JSON body")
         .option("--json-file <path>", "Path to a JSON body file");
 }
-function runtimeOverrides(options) {
+function runtimeOverrides(options, dependencies) {
     return {
         configFile: options.configFile,
-        service: options.service ? validateService(options.service) : undefined,
+        service: options.service ? dependencies.validateService(options.service) : undefined,
         apiBaseUrl: options.apiBaseUrl,
         authBaseUrl: options.authBaseUrl,
         accessToken: options.accessToken,
@@ -432,28 +474,28 @@ function runtimeOverrides(options) {
         scopes: options.scopes,
     };
 }
-async function runClientCommand(args, runner) {
+async function runClientCommand(args, dependencies, runner) {
     const command = args.at(-1);
-    const config = await resolveRuntimeConfig(runtimeOverrides(command.optsWithGlobals()));
-    const client = new TickTickClient(config);
+    const config = await dependencies.resolveRuntimeConfig(runtimeOverrides(command.optsWithGlobals(), dependencies));
+    const client = dependencies.createClient(config);
     const result = await runner(client, config);
-    printJson(result ?? { ok: true });
+    dependencies.printJson(result ?? { ok: true });
 }
-async function loadObjectPayload(options, flags) {
-    const loaded = await loadJsonValue(options.json, options.jsonFile);
+async function loadObjectPayload(options, flags, dependencies) {
+    const loaded = await dependencies.loadJsonValue(options.json, options.jsonFile);
     if (loaded === undefined) {
-        return mergeDefined({}, flags);
+        return dependencies.mergeDefined({}, flags);
     }
     if (!isPlainObject(loaded)) {
         throw new Error("Expected a JSON object payload.");
     }
-    return mergeDefined(loaded, flags);
+    return dependencies.mergeDefined(loaded, flags);
 }
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-async function persistConfig(runtime, accessToken) {
-    const stored = await loadStoredConfig(runtime.configFile);
+async function persistConfig(runtime, token, dependencies) {
+    const stored = await dependencies.loadStoredConfig(runtime.configFile);
     const next = {
         ...stored,
         service: runtime.service,
@@ -463,9 +505,9 @@ async function persistConfig(runtime, accessToken) {
         scopes: runtime.scopes,
         apiBaseUrl: runtime.apiBaseUrl,
         authBaseUrl: runtime.authBaseUrl,
-        accessToken,
+        accessToken: token.access_token,
     };
-    await saveStoredConfig(runtime.configFile, next);
+    await dependencies.saveStoredConfig(runtime.configFile, next);
 }
 function requireClientCredentials(config) {
     if (!config.clientId || !config.clientSecret) {
@@ -483,8 +525,9 @@ function collectString(value, previous = []) {
 function collectInteger(value, previous = []) {
     return [...previous, parseInteger(value)];
 }
-function handleError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    process.stderr.write(`${message}\n`);
-    process.exitCode = 1;
+function isDirectExecution() {
+    return Boolean(process.argv[1]) && import.meta.url === pathToFileURL(process.argv[1]).href;
+}
+if (isDirectExecution()) {
+    await main();
 }

package/dist/config.js

@@ -13,15 +13,18 @@ const SERVICE_DEFAULTS = {
         authBaseUrl: "https://dida365.com",
     },
 };
-export function defaultConfigFilePath() {
-    const appData = process.env.APPDATA;
-    if (process.platform === "win32" && appData) {
-        return path.join(appData, "ticktick-cli", "config.json");
+export function defaultConfigFilePath(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const appData = options.appData ?? process.env.APPDATA;
+    const homeDir = options.homeDir ?? os.homedir();
+    const pathModule = platform === "win32" ? path.win32 : path.posix;
+    if (platform === "win32" && appData) {
+        return pathModule.join(appData, "ticktick-cli", "config.json");
     }
-    if (process.platform === "darwin") {
-        return path.join(os.homedir(), "Library", "Application Support", "ticktick-cli", "config.json");
+    if (platform === "darwin") {
+        return pathModule.join(homeDir, "Library", "Application Support", "ticktick-cli", "config.json");
     }
-    return path.join(os.homedir(), ".config", "ticktick-cli", "config.json");
+    return pathModule.join(homeDir, ".config", "ticktick-cli", "config.json");
 }
 export async function loadStoredConfig(configFile) {
     try {

package/dist/utils.js

@@ -25,24 +25,24 @@ export function parseInteger(value) {
     }
     return parsed;
 }
-export async function maybeReadStdin() {
-    if (process.stdin.isTTY) {
+export async function maybeReadStdin(input = process.stdin) {
+    if (input.isTTY) {
         return undefined;
     }
     const chunks = [];
-    for await (const chunk of process.stdin) {
+    for await (const chunk of input) {
         chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
     }
     const text = Buffer.concat(chunks).toString("utf8").trim();
     return text.length > 0 ? text : undefined;
 }
-export async function loadJsonValue(inlineJson, jsonFile) {
+export async function loadJsonValue(inlineJson, jsonFile, input = process.stdin) {
     let raw = inlineJson;
     if (jsonFile) {
         raw = await readFile(jsonFile, "utf8");
     }
     if (!raw) {
-        raw = await maybeReadStdin();
+        raw = await maybeReadStdin(input);
     }
     if (!raw) {
         return undefined;
@@ -55,8 +55,8 @@ export async function loadJsonValue(inlineJson, jsonFile) {
         throw new Error(`Failed to parse JSON input: ${message}`);
     }
 }
-export function printJson(value) {
-    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+export function printJson(value, write = (text) => process.stdout.write(text)) {
+    write(`${JSON.stringify(value, null, 2)}\n`);
 }
 export function maskSecret(value) {
     if (!value) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ticktick-cli",
-  "version": "0.1.1",
-  "description": "Simple CLI wrapper for the TickTick Open API",
+  "version": "1.0.2",
+  "description": "CLI wrapper for the TickTick Open API",
   "type": "module",
   "files": [
     "dist",
@@ -9,15 +9,15 @@
     "LICENSE"
   ],
   "bin": {
-    "ticktick": "dist/cli.js"
+    "ticktick": "dist/bin.js",
+    "tt": "dist/bin.js"
   },
   "scripts": {
     "build": "npm run clean && tsc -p tsconfig.json",
     "check": "npm run build",
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
     "dev": "tsx src/cli.ts",
-    "prepack": "npm run test",
-    "test": "npm run build && node --import tsx --test src/test/*.test.ts"
+    "prepack": "npm run build"
   },
   "keywords": [
     "ticktick",