@wangjs-jacky/ticktick-cli 0.1.0

package/src/api/oauth.ts

@@ -0,0 +1,146 @@
+import crypto from 'crypto';
+import open from 'open';
+import type { OAuthConfig, TokenData, TokenResponse } from '../types.js';
+import { getOAuth, getToken, setToken, getRegion } from '../utils/config.js';
+import { getEndpoints } from '../utils/endpoints.js';
+import { createCallbackServer } from '../utils/server.js';
+
+const SCOPES = 'tasks:read tasks:write';
+const DEFAULT_PORT = 3000;
+
+/** 生成随机 state（防 CSRF） */
+export function generateState(): string {
+  return crypto.randomBytes(16).toString('hex');
+}
+
+/** 构建授权 URL */
+export function buildAuthUrl(config: OAuthConfig, state: string, port: number, region: 'cn' | 'global' = 'cn'): string {
+  const endpoints = getEndpoints(region);
+  const redirectUri = `http://localhost:${port}/callback`;
+  const params = new URLSearchParams({
+    client_id: config.clientId,
+    response_type: 'code',
+    redirect_uri: redirectUri,
+    scope: SCOPES,
+    state,
+  });
+  return `${endpoints.authUrl}?${params.toString()}`;
+}
+
+/** 用授权码换取 Token */
+export async function exchangeCode(
+  config: OAuthConfig,
+  code: string,
+  port: number
+): Promise<TokenData> {
+  const region = getRegion();
+  const endpoints = getEndpoints(region);
+  const redirectUri = `http://localhost:${port}/callback`;
+  const credentials = Buffer.from(`${config.clientId}:${config.clientSecret}`).toString('base64');
+
+  const response = await fetch(endpoints.tokenUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+      'Authorization': `Basic ${credentials}`,
+    },
+    body: new URLSearchParams({
+      code,
+      grant_type: 'authorization_code',
+      redirect_uri: redirectUri,
+      scope: SCOPES,
+    }).toString(),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Token 交换失败: ${response.status} ${text}`);
+  }
+
+  const data = (await response.json()) as TokenResponse;
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: Date.now() + data.expires_in * 1000,
+  };
+}
+
+/** 刷新 Token */
+export async function refreshAccessToken(): Promise<TokenData> {
+  const oauth = getOAuth();
+  const token = getToken();
+  const region = getRegion();
+  const endpoints = getEndpoints(region);
+
+  if (!oauth || !token) {
+    throw new Error('未登录，请先运行 tt login');
+  }
+
+  const credentials = Buffer.from(`${oauth.clientId}:${oauth.clientSecret}`).toString('base64');
+
+  const response = await fetch(endpoints.tokenUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+      'Authorization': `Basic ${credentials}`,
+    },
+    body: new URLSearchParams({
+      grant_type: 'refresh_token',
+      refresh_token: token.refreshToken,
+    }).toString(),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Token 刷新失败: ${response.status} ${text}`);
+  }
+
+  const data = (await response.json()) as TokenResponse;
+  const newToken: TokenData = {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: Date.now() + data.expires_in * 1000,
+  };
+  setToken(newToken);
+  return newToken;
+}
+
+/** 完整登录流程 */
+export async function loginWithBrowser(config: OAuthConfig, port = DEFAULT_PORT): Promise<TokenData> {
+  const region = getRegion();
+  const state = generateState();
+  const authUrl = buildAuthUrl(config, state, port, region);
+
+  // 先启动服务器
+  const codePromise = createCallbackServer(state, port);
+
+  // 再打开浏览器
+  await open(authUrl);
+
+  // 等待回调（含超时处理）
+  let callbackResult: { code: string; close: () => void };
+  try {
+    callbackResult = await codePromise;
+  } catch (err) {
+    if ((err as Error).message === 'TIMEOUT') {
+      throw new Error(
+        '登录超时（2 分钟未收到授权回调）。\n' +
+        '可能原因：\n' +
+        '  1. 浏览器授权页面显示了错误（如 invalid_client）\n' +
+        '  2. 凭证与当前区域不匹配\n' +
+        `  当前区域：${region === 'cn' ? '国内版（dida365.com）' : '国际版（ticktick.com）'}\n` +
+        '建议：检查浏览器页面错误，或尝试切换区域/重新配置凭证'
+      );
+    }
+    throw err;
+  }
+
+  // 交换 token
+  const token = await exchangeCode(config, callbackResult.code, port);
+  setToken(token);
+
+  // 关闭服务器
+  callbackResult.close();
+
+  return token;
+}

package/src/api/resources.ts

@@ -0,0 +1,291 @@
+import { apiRequest } from './client.js';
+import type {
+  Project,
+  ProjectData,
+  Task,
+  CreateProjectParams,
+  UpdateProjectParams,
+  CreateTaskParams,
+  UpdateTaskParams,
+  MoveTaskParams,
+  CompletedTasksParams,
+  FilterTasksParams,
+  BatchTasksParams,
+  UserPreference,
+  UndoneTasksParams,
+} from '../types.js';
+
+// ─── Project API ─────────────────────────────────────
+
+/** 获取所有项目 */
+export function getProjects(): Promise<Project[]> {
+  return apiRequest<Project[]>('project');
+}
+
+/** 获取单个项目 */
+export function getProject(projectId: string): Promise<Project> {
+  return apiRequest<Project>(`project/${projectId}`);
+}
+
+/** 获取项目及任务数据 */
+export function getProjectData(projectId: string): Promise<ProjectData> {
+  return apiRequest<ProjectData>(`project/${projectId}/data`);
+}
+
+/** 创建项目 */
+export function createProject(data: CreateProjectParams): Promise<Project> {
+  return apiRequest<Project>('project', {
+    method: 'POST',
+    body: JSON.stringify(data),
+  });
+}
+
+/** 更新项目 */
+export function updateProject(
+  projectId: string,
+  data: UpdateProjectParams
+): Promise<Project> {
+  return apiRequest<Project>(`project/${projectId}`, {
+    method: 'POST',
+    body: JSON.stringify(data),
+  });
+}
+
+/** 删除项目 */
+export function deleteProject(projectId: string): Promise<void> {
+  return apiRequest<void>(`project/${projectId}`, { method: 'DELETE' });
+}
+
+// ─── Task API ────────────────────────────────────────
+
+/** 获取任务 */
+export function getTask(projectId: string, taskId: string): Promise<Task> {
+  return apiRequest<Task>(`project/${projectId}/task/${taskId}`);
+}
+
+/** 创建任务 */
+export function createTask(data: CreateTaskParams): Promise<Task> {
+  return apiRequest<Task>('task', {
+    method: 'POST',
+    body: JSON.stringify(data),
+  });
+}
+
+/** 更新任务 */
+export function updateTask(
+  taskId: string,
+  data: UpdateTaskParams
+): Promise<Task> {
+  return apiRequest<Task>(`task/${taskId}`, {
+    method: 'POST',
+    body: JSON.stringify(data),
+  });
+}
+
+/** 完成任务 */
+export function completeTask(
+  projectId: string,
+  taskId: string
+): Promise<void> {
+  return apiRequest<void>(`project/${projectId}/task/${taskId}/complete`, {
+    method: 'POST',
+  });
+}
+
+/** 删除任务 */
+export function deleteTask(
+  projectId: string,
+  taskId: string
+): Promise<void> {
+  return apiRequest<void>(`project/${projectId}/task/${taskId}`, {
+    method: 'DELETE',
+  });
+}
+
+/** 移动任务 */
+export function moveTasks(
+  moves: MoveTaskParams[]
+): Promise<Array<{ id: string; etag: string }>> {
+  return apiRequest<Array<{ id: string; etag: string }>>('task/move', {
+    method: 'POST',
+    body: JSON.stringify(moves),
+  });
+}
+
+/** 获取已完成任务 */
+export function getCompletedTasks(
+  params: CompletedTasksParams
+): Promise<Task[]> {
+  return apiRequest<Task[]>('task/completed', {
+    method: 'POST',
+    body: JSON.stringify(params),
+  });
+}
+
+/** 筛选任务 */
+export function filterTasks(params: FilterTasksParams): Promise<Task[]> {
+  return apiRequest<Task[]>('task/filter', {
+    method: 'POST',
+    body: JSON.stringify(params),
+  });
+}
+
+// ─── 批量操作 ──────────────────────────────────────
+
+/** 批量添加任务（API 返回 { id2etag: {...} }，不是 Task[]） */
+export async function batchAddTasks(
+  tasks: CreateTaskParams[]
+): Promise<{ count: number; id2etag?: Record<string, string> }> {
+  const res = await apiRequest<Record<string, unknown>>('task/batch', {
+    method: 'POST',
+    body: JSON.stringify({ add: tasks }),
+  });
+  return {
+    count: tasks.length,
+    id2etag: (res?.id2etag ?? res) as Record<string, string> | undefined,
+  };
+}
+
+/** 批量更新任务 */
+export function batchUpdateTasks(
+  tasks: UpdateTaskParams[]
+): Promise<void> {
+  return apiRequest<void>('task/batch', {
+    method: 'POST',
+    body: JSON.stringify({ update: tasks }),
+  });
+}
+
+/** 批量完成项目内任务 */
+export async function completeTasksInProject(
+  projectId: string,
+  taskIds: string[]
+): Promise<{ completed: string[]; failed: string[] }> {
+  const completed: string[] = [];
+  const failed: string[] = [];
+  for (const taskId of taskIds) {
+    try {
+      await completeTask(projectId, taskId);
+      completed.push(taskId);
+    } catch {
+      failed.push(taskId);
+    }
+  }
+  return { completed, failed };
+}
+
+// ─── 查询 ──────────────────────────────────────────
+
+/** 按 ID 查找任务（无需 projectId，同时搜索未完成和已完成任务） */
+export async function getTaskById(taskId: string): Promise<Task> {
+  // 并行获取未完成任务和已完成任务，确保覆盖所有任务
+  // 注意：filterTasks API 有返回数量限制，改用 listUndoneTasksByDate 获取更完整的数据
+  const [undoneTasks, completedTasks] = await Promise.all([
+    listUndoneTasksByDate({}),
+    getCompletedTasks({}),
+  ]);
+  const allTasks = [...undoneTasks, ...completedTasks];
+  const task = allTasks.find((t) => t.id === taskId);
+  if (!task) throw new Error(`任务 ${taskId} 不存在`);
+  return task;
+}
+
+/** 获取用户偏好 */
+export function getUserPreference(): Promise<UserPreference> {
+  return apiRequest<UserPreference>('user/info');
+}
+
+/** 按日期范围获取未完成任务 */
+export function listUndoneTasksByDate(
+  params: UndoneTasksParams
+): Promise<Task[]> {
+  const filterParams: FilterTasksParams = { status: [0] };
+  if (params.projectIds) filterParams.projectIds = params.projectIds;
+  if (params.startDate) filterParams.startDate = params.startDate;
+  if (params.endDate) filterParams.endDate = params.endDate;
+  return filterTasks(filterParams);
+}
+
+/** 按预设查询获取未完成任务 */
+export function listUndoneTasksByTimeQuery(
+  query: string
+): Promise<Task[]> {
+  const now = new Date();
+  let startDate: string;
+  let endDate: string;
+
+  const toISO = (d: Date) => d.toISOString();
+
+  switch (query) {
+    case 'today': {
+      const start = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      const end = new Date(start);
+      end.setDate(end.getDate() + 1);
+      startDate = toISO(start);
+      endDate = toISO(end);
+      break;
+    }
+    case 'tomorrow': {
+      const start = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
+      const end = new Date(start);
+      end.setDate(end.getDate() + 1);
+      startDate = toISO(start);
+      endDate = toISO(end);
+      break;
+    }
+    case 'last24hour': {
+      const start = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+      startDate = toISO(start);
+      endDate = toISO(now);
+      break;
+    }
+    case 'next24hour': {
+      const end = new Date(now.getTime() + 24 * 60 * 60 * 1000);
+      startDate = toISO(now);
+      endDate = toISO(end);
+      break;
+    }
+    case 'last7day': {
+      const start = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+      startDate = toISO(start);
+      endDate = toISO(now);
+      break;
+    }
+    case 'next7day': {
+      const end = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
+      startDate = toISO(now);
+      endDate = toISO(end);
+      break;
+    }
+    default:
+      throw new Error(
+        `不支持的查询预设: ${query}，支持: today, tomorrow, last24hour, next24hour, last7day, next7day`
+      );
+  }
+
+  return listUndoneTasksByDate({ startDate, endDate });
+}
+
+/** 搜索任务（关键词匹配，同时搜索未完成和已完成任务） */
+export async function searchTask(keyword: string): Promise<Task[]> {
+  // 并行获取未完成任务和已完成任务，确保覆盖所有任务
+  // 注意：filterTasks API 有返回数量限制，改用 listUndoneTasksByDate 获取更完整的数据
+  const [undoneTasks, completedTasks] = await Promise.all([
+    listUndoneTasksByDate({}),
+    getCompletedTasks({}),
+  ]);
+
+  // 合并并去重（按 id）
+  const taskMap = new Map<string, Task>();
+  for (const t of [...undoneTasks, ...completedTasks]) {
+    taskMap.set(t.id, t);
+  }
+  const allTasks = Array.from(taskMap.values());
+
+  const lower = keyword.toLowerCase();
+  return allTasks.filter(
+    (t) =>
+      t.title.toLowerCase().includes(lower) ||
+      (t.content && t.content.toLowerCase().includes(lower))
+  );
+}

package/src/commands/auth.ts

@@ -0,0 +1,218 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import type { Region, OAuthConfig } from '../types.js';
+import { getOAuth, setOAuth, getToken, clearToken, isTokenValid, getRegion, setRegion } from '../utils/config.js';
+import { getEndpoints } from '../utils/endpoints.js';
+import { loginWithBrowser } from '../api/oauth.js';
+import { apiRequest } from '../api/client.js';
+
+const REGION_LABELS: Record<Region, string> = {
+  cn: '国内版（滴答清单）',
+  global: '国际版（TickTick）',
+};
+
+/** 引导用户输入 OAuth 凭证 */
+async function promptOAuthCredentials(developerUrl: string): Promise<OAuthConfig | undefined> {
+  p.log.info(`请访问 ${developerUrl} 获取凭证`);
+  p.log.info('Redirect URI 设置为: http://localhost:3000/callback\n');
+
+  const clientId = await p.text({
+    message: '请输入 Client ID',
+    validate: (v) => (!v ? 'Client ID 不能为空' : undefined),
+  });
+  if (p.isCancel(clientId)) return undefined;
+
+  const clientSecret = await p.text({
+    message: '请输入 Client Secret',
+    validate: (v) => (!v ? 'Client Secret 不能为空' : undefined),
+  });
+  if (p.isCancel(clientSecret)) return undefined;
+
+  const oauth: OAuthConfig = { clientId, clientSecret };
+  setOAuth(oauth);
+  p.log.success('凭证已保存');
+  return oauth;
+}
+
+/** tt login */
+export async function loginCommand(): Promise<void> {
+  const region = getRegion();
+  const endpoints = getEndpoints(region);
+
+  p.intro(pc.bgCyan(pc.black(` 滴答清单 CLI 登录 [${REGION_LABELS[region]}] `)));
+
+  const token = getToken();
+  if (token && isTokenValid()) {
+    p.outro(pc.green('已登录，无需重复登录。使用 tt logout 先登出。'));
+    return;
+  }
+
+  let oauth = getOAuth();
+
+  // 检测凭证区域不匹配
+  if (oauth?.region && oauth.region !== region) {
+    p.log.warn(`当前区域为 ${REGION_LABELS[region]}，但保存的凭证属于 ${REGION_LABELS[oauth.region]}`);
+    p.log.warn('凭证与区域不匹配会导致登录失败\n');
+    const reconfigure = await p.confirm({
+      message: `是否为 ${REGION_LABELS[region]} 重新配置凭证？`,
+    });
+    if (p.isCancel(reconfigure) || !reconfigure) {
+      p.outro('已取消');
+      return;
+    }
+    oauth = undefined;
+  }
+
+  // 旧凭证无区域标记，提示确认后再补充
+  if (oauth && !oauth.region) {
+    p.log.warn('保存的凭证未标记区域，可能与当前区域不匹配');
+    const confirmRegion = await p.confirm({
+      message: `这些凭证是否用于 ${REGION_LABELS[region]}？`,
+    });
+    if (p.isCancel(confirmRegion)) {
+      p.outro('已取消');
+      return;
+    }
+    if (confirmRegion) {
+      setOAuth(oauth);
+      p.log.success(`已将凭证标记为 ${REGION_LABELS[region]}`);
+    } else {
+      oauth = undefined;
+    }
+  }
+
+  if (!oauth) {
+    oauth = await promptOAuthCredentials(endpoints.developerUrl);
+    if (!oauth) { p.outro('已取消'); return; }
+  }
+
+  const s = p.spinner();
+  s.start('正在打开浏览器进行授权...');
+
+  try {
+    await loginWithBrowser(oauth);
+    s.stop('授权完成');
+    p.outro(pc.green('✔ 登录成功！'));
+  } catch (err) {
+    s.stop('登录失败');
+    const msg = (err as Error).message;
+
+    if (msg.includes('invalid_client') || msg.includes('TIMEOUT')) {
+      p.log.error(pc.red('登录失败：凭证无效或与区域不匹配'));
+      p.log.info(`当前区域：${REGION_LABELS[region]}`);
+      p.log.info(`凭证来源：${oauth.region ? REGION_LABELS[oauth.region] : '未知'}\n`);
+
+      const action = await p.select({
+        message: '请选择下一步操作',
+        options: [
+          { value: 'switch', label: `切换到${region === 'cn' ? '国际版' : '国内版'}` },
+          { value: 'reconfig', label: '重新输入当前区域的凭证' },
+          { value: 'exit', label: '退出' },
+        ],
+      });
+
+      if (p.isCancel(action) || action === 'exit') {
+        p.outro('已退出');
+        return;
+      }
+
+      if (action === 'switch') {
+        const newRegion: Region = region === 'cn' ? 'global' : 'cn';
+        setRegion(newRegion);
+        p.log.success(`已切换到 ${REGION_LABELS[newRegion]}，请重新运行 tt login`);
+        p.outro('区域已切换');
+        return;
+      }
+
+      if (action === 'reconfig') {
+        await promptOAuthCredentials(endpoints.developerUrl);
+        p.outro('凭证已更新，请重新运行 tt login');
+        return;
+      }
+    }
+
+    p.outro(pc.red(`✖ ${msg}`));
+    process.exit(1);
+  }
+}
+
+/** tt logout */
+export async function logoutCommand(): Promise<void> {
+  p.intro(pc.bgCyan(pc.black(' 滴答清单 CLI 登出 ')));
+  clearToken();
+  p.outro(pc.green('✔ 已登出'));
+}
+
+/** tt whoami */
+export async function whoamiCommand(): Promise<void> {
+  const region = getRegion();
+  p.intro(pc.bgCyan(pc.black(' 滴答清单 CLI 状态 ')));
+
+  const token = getToken();
+  if (!token) {
+    p.outro(pc.yellow('未登录，请先运行 tt login'));
+    return;
+  }
+
+  const s = p.spinner();
+  s.start('正在验证登录状态...');
+
+  try {
+    await apiRequest<unknown[]>('project');
+    s.stop('验证完成');
+
+    const expiresIn = token.expiresAt - Date.now();
+    if (expiresIn <= 0) {
+      p.outro(pc.yellow('Token 已失效，请运行 tt login 重新登录'));
+      return;
+    }
+
+    const hours = Math.floor(expiresIn / 3600000);
+    const minutes = Math.floor((expiresIn % 3600000) / 60000);
+    p.log.success(pc.green(`已登录 [${REGION_LABELS[region]}]`));
+    p.log.info(`Token 有效期: 剩余 ${hours} 小时 ${minutes} 分钟`);
+    p.outro('一切正常');
+  } catch {
+    s.stop('验证失败');
+    p.outro(pc.red('Token 已失效，请运行 tt login 重新登录'));
+  }
+}
+
+/** tt config [--region cn|global] */
+export async function configCommand(args?: { region?: Region }): Promise<void> {
+  if (args?.region) {
+    const oldRegion = getRegion();
+    setRegion(args.region);
+    clearToken();
+    p.intro(pc.bgCyan(pc.black(' 滴答清单 CLI 配置 ')));
+    p.log.success(`已切换到 ${REGION_LABELS[args.region]}`);
+    if (oldRegion !== args.region) {
+      p.log.warn('区域已变更，请重新运行 tt login');
+    }
+    p.outro('配置已更新');
+    return;
+  }
+
+  const region = getRegion();
+  p.intro(pc.bgCyan(pc.black(' 滴答清单 CLI 配置 ')));
+  p.log.info(`区域: ${REGION_LABELS[region]}`);
+
+  const oauth = getOAuth();
+  if (oauth) {
+    p.log.info(`Client ID: ${oauth.clientId}`);
+    p.log.info(`Client Secret: ${oauth.clientSecret.substring(0, 8)}${'*'.repeat(Math.max(0, oauth.clientSecret.length - 8))}`);
+  } else {
+    p.log.warn('尚未配置 OAuth 凭证');
+  }
+
+  const token = getToken();
+  if (token) {
+    p.log.info(`Token: ${token.accessToken.substring(0, 8)}...`);
+    p.log.info(`过期时间: ${new Date(token.expiresAt).toLocaleString('zh-CN')}`);
+  } else {
+    p.log.info('Token: 未登录');
+  }
+
+  p.log.info('\n使用 tt config --region cn/global 切换区域');
+  p.outro('配置信息如上');
+}