@jackwener/opencli 1.5.5 → 1.5.7

package/dist/clis/ones/tasks.js

@@ -0,0 +1,79 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { gotoOnesHome, onesFetchInPage } from './common.js';
+import { enrichPeekEntriesWithDetails } from './enrich-tasks.js';
+import { resolveTaskListLabels } from './resolve-labels.js';
+import { defaultPeekBody, flattenPeekGroups, mapTaskEntry, parsePeekLimit } from './task-helpers.js';
+function buildQuery(project, assign) {
+    const must = [];
+    if (project?.trim()) {
+        must.push({ in: { 'field_values.field006': [project.trim()] } });
+    }
+    if (assign?.trim()) {
+        must.push({ equal: { assign: assign.trim() } });
+    }
+    if (must.length === 0) {
+        return { must: [] };
+    }
+    return { must };
+}
+cli({
+    site: 'ones',
+    name: 'tasks',
+    description: 'ONES Project API — list work items (POST team/:team/filters/peek); use token-info -f json for team uuid',
+    domain: 'ones.cn',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        {
+            name: 'team',
+            type: 'str',
+            required: false,
+            positional: true,
+            help: 'Team UUID (8 chars), or set ONES_TEAM_UUID',
+        },
+        {
+            name: 'project',
+            type: 'str',
+            required: false,
+            help: 'Filter by project UUID (field006 / 所属项目)',
+        },
+        {
+            name: 'assign',
+            type: 'str',
+            required: false,
+            help: 'Filter by assignee user UUID (负责人 assign)',
+        },
+        {
+            name: 'limit',
+            type: 'int',
+            default: 30,
+            help: 'Max rows after flattening groups (default 30)',
+        },
+    ],
+    columns: ['title', 'status', 'project', 'uuid', 'updated', '工时'],
+    func: async (page, kwargs) => {
+        const team = kwargs.team?.trim() ||
+            process.env.ONES_TEAM_UUID?.trim() ||
+            process.env.ONES_TEAM_ID?.trim();
+        if (!team) {
+            throw new CliError('CONFIG', 'team UUID required', 'Pass team as first argument or set ONES_TEAM_UUID (see `opencli ones token-info -f json` → teams[].uuid).');
+        }
+        const project = kwargs.project?.trim();
+        const assign = kwargs.assign?.trim();
+        const limit = parsePeekLimit(kwargs.limit, 30);
+        await gotoOnesHome(page);
+        const body = defaultPeekBody(buildQuery(project, assign));
+        const path = `team/${team}/filters/peek`;
+        const parsed = (await onesFetchInPage(page, path, {
+            method: 'POST',
+            body: JSON.stringify(body),
+            skipGoto: true,
+        }));
+        const entries = flattenPeekGroups(parsed, limit);
+        const enriched = await enrichPeekEntriesWithDetails(page, team, entries, true);
+        const labels = await resolveTaskListLabels(page, team, enriched, true);
+        return enriched.map((e) => mapTaskEntry(e, labels));
+    },
+});

package/dist/clis/ones/token-info.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/ones/token-info.js

@@ -0,0 +1,42 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { onesFetchInPage } from './common.js';
+cli({
+    site: 'ones',
+    name: 'token-info',
+    description: 'ONES Project API — session detail (GET auth/token_info) via Chrome Bridge: user, teams, org',
+    domain: 'ones.cn',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [],
+    columns: ['uuid', 'name', 'email', 'teams', 'org_name'],
+    func: async (page) => {
+        const root = (await onesFetchInPage(page, 'auth/token_info'));
+        const user = root.user && typeof root.user === 'object' ? root.user : null;
+        if (!user?.uuid) {
+            throw new CliError('FETCH_ERROR', 'Unexpected auth/token_info response', 'Try `opencli ones me -f json` or check ONES_* env vars.');
+        }
+        const teamRows = Array.isArray(root.teams) ? root.teams : [];
+        const teamsHint = teamRows
+            .map((t) => {
+            const n = String(t.name ?? '').trim();
+            const u = String(t.uuid ?? '').trim();
+            if (n && u)
+                return `${n} (${u})`;
+            return u || n;
+        })
+            .filter(Boolean)
+            .join(', ');
+        const org = root.org && typeof root.org === 'object' ? root.org : null;
+        return [
+            {
+                uuid: String(user.uuid),
+                name: String(user.name ?? ''),
+                email: String(user.email ?? ''),
+                teams: teamsHint,
+                org_name: org ? String(org.name ?? '') : '',
+            },
+        ];
+    },
+});

package/dist/clis/ones/worklog.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Log/backfill work hours. Project API paths vary by deployment,
+ * so we try common endpoints in sequence.
+ */
+export declare function buildAddManhourGraphqlBody(input: {
+    ownerId: string;
+    taskId: string;
+    startTime: number;
+    rawManhour: number;
+    note: string;
+}): string;

package/dist/clis/ones/worklog.js

@@ -0,0 +1,267 @@
+/**
+ * Log/backfill work hours. Project API paths vary by deployment,
+ * so we try common endpoints in sequence.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { gotoOnesHome, onesFetchInPageWithMeta, resolveOnesUserUuid, summarizeOnesError, } from './common.js';
+import { hoursToOnesManhourRaw } from './task-helpers.js';
+function summarizeOnesMutationBody(parsed, status) {
+    if (!parsed || typeof parsed !== 'object') {
+        return status >= 400 ? `HTTP ${status}` : null;
+    }
+    const o = parsed;
+    if (Array.isArray(o.errors) && o.errors.length > 0) {
+        const e0 = o.errors[0];
+        if (e0 && typeof e0 === 'object') {
+            const msg = String(e0.message ?? '').trim();
+            if (msg)
+                return msg;
+        }
+        return 'graphql errors';
+    }
+    if (o.data && typeof o.data === 'object') {
+        const data = o.data;
+        if (data.addManhour && typeof data.addManhour === 'object') {
+            const key = String(data.addManhour.key ?? '').trim();
+            if (!key)
+                return 'addManhour returned empty key';
+        }
+    }
+    if (Array.isArray(o.bad_tasks) && o.bad_tasks.length > 0) {
+        const b = o.bad_tasks[0];
+        return String(b.desc ?? b.code ?? JSON.stringify(b));
+    }
+    if (typeof o.reason === 'string' && o.reason.trim())
+        return o.reason.trim();
+    const c = o.code;
+    if (c !== undefined && c !== null) {
+        const n = Number(c);
+        if (Number.isFinite(n) && n !== 200 && n !== 0)
+            return `code=${String(c)}`;
+    }
+    const ec = o.errcode;
+    if (typeof ec === 'string' && ec && ec !== 'OK')
+        return ec;
+    return null;
+}
+function describeAttemptFailure(r) {
+    if (!r.ok)
+        return summarizeOnesError(r.status, r.parsed);
+    return summarizeOnesMutationBody(r.parsed, r.status);
+}
+function todayLocalYmd() {
+    const d = new Date();
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, '0');
+    const day = String(d.getDate()).padStart(2, '0');
+    return `${y}-${m}-${day}`;
+}
+function validateYmd(s) {
+    return /^\d{4}-\d{2}-\d{2}$/.test(s);
+}
+function toLocalMidnightUnixSeconds(ymd) {
+    const d = new Date(`${ymd}T00:00:00`);
+    const ms = d.getTime();
+    if (!Number.isFinite(ms))
+        return 0;
+    return Math.floor(ms / 1000);
+}
+function pickTaskTotalManhourRaw(parsed) {
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const o = parsed;
+    const n = Number(o.total_manhour);
+    return Number.isFinite(n) ? n : null;
+}
+export function buildAddManhourGraphqlBody(input) {
+    const { ownerId, taskId, startTime, rawManhour, note } = input;
+    const description = JSON.stringify(note);
+    const owner = JSON.stringify(ownerId);
+    const task = JSON.stringify(taskId);
+    return JSON.stringify({
+        query: `mutation AddManhour {
+  addManhour(
+    mode: "simple"
+    owner: ${owner}
+    task: ${task}
+    type: "recorded"
+    start_time: ${startTime}
+    hours: ${rawManhour}
+    description: ${description}
+    customData: {}
+  ) {
+    key
+  }
+}`,
+    });
+}
+cli({
+    site: 'ones',
+    name: 'worklog',
+    description: 'ONES — log work hours on a task (defaults to today; use --date to backfill; endpoint falls back by deployment).',
+    domain: 'ones.cn',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        {
+            name: 'task',
+            type: 'str',
+            required: true,
+            positional: true,
+            help: 'Work item UUID (usually 16 chars), from my-tasks or browser URL …/task/<id>',
+        },
+        {
+            name: 'hours',
+            type: 'str',
+            required: true,
+            positional: true,
+            help: 'Hours to log for this entry (e.g. 2 or 1.5), converted with ONES_MANHOUR_SCALE',
+        },
+        {
+            name: 'team',
+            type: 'str',
+            required: false,
+            help: 'Team UUID from URL …/team/<uuid>/…, or set ONES_TEAM_UUID',
+        },
+        {
+            name: 'date',
+            type: 'str',
+            required: false,
+            help: 'Entry date YYYY-MM-DD, defaults to today (local timezone); use for backfill',
+        },
+        {
+            name: 'note',
+            type: 'str',
+            required: false,
+            help: 'Optional note (written to description/desc)',
+        },
+        {
+            name: 'owner',
+            type: 'str',
+            required: false,
+            help: 'Owner user UUID (defaults to current logged-in user)',
+        },
+    ],
+    columns: ['task', 'date', 'hours', 'owner', 'endpoint'],
+    func: async (page, kwargs) => {
+        const taskId = String(kwargs.task ?? '').trim();
+        if (!taskId) {
+            throw new CliError('CONFIG', 'task uuid required', 'Pass the work item uuid from opencli ones my-tasks or the URL.');
+        }
+        const team = kwargs.team?.trim() ||
+            process.env.ONES_TEAM_UUID?.trim() ||
+            process.env.ONES_TEAM_ID?.trim();
+        if (!team) {
+            throw new CliError('CONFIG', 'team UUID required', 'Pass --team or set ONES_TEAM_UUID (from …/team/<team>/…).');
+        }
+        const hoursHuman = Number(String(kwargs.hours ?? '').replace(/,/g, ''));
+        if (!Number.isFinite(hoursHuman) || hoursHuman <= 0 || hoursHuman > 1000) {
+            throw new CliError('CONFIG', 'hours must be a positive number (hours)', 'Example: opencli ones worklog <taskUUID> 2 --team <teamUUID>');
+        }
+        const dateArg = kwargs.date?.trim();
+        const dateStr = dateArg || todayLocalYmd();
+        if (!validateYmd(dateStr)) {
+            throw new CliError('CONFIG', 'invalid --date', 'Use YYYY-MM-DD, e.g. 2026-03-24.');
+        }
+        const note = String(kwargs.note ?? '').trim();
+        const rawManhour = hoursToOnesManhourRaw(hoursHuman);
+        const startTime = toLocalMidnightUnixSeconds(dateStr);
+        if (!startTime) {
+            throw new CliError('CONFIG', 'invalid date for start_time', `Could not parse date ${dateStr}.`);
+        }
+        await gotoOnesHome(page);
+        const ownerFromKw = kwargs.owner?.trim();
+        const ownerId = ownerFromKw || (await resolveOnesUserUuid(page, { skipGoto: true }));
+        const entry = {
+            owner: ownerId,
+            manhour: rawManhour,
+            start_date: dateStr,
+            end_date: dateStr,
+            desc: note,
+        };
+        const entryAlt = {
+            owner: ownerId,
+            allManhour: rawManhour,
+            startDate: dateStr,
+            endDate: dateStr,
+            desc: note,
+        };
+        const enc = encodeURIComponent(taskId);
+        const gqlBody = buildAddManhourGraphqlBody({
+            ownerId,
+            taskId,
+            startTime,
+            rawManhour,
+            note,
+        });
+        const attempts = [
+            { path: `team/${team}/items/graphql`, body: gqlBody },
+            { path: `team/${team}/task/${enc}/manhours/add`, body: JSON.stringify(entry) },
+            { path: `team/${team}/task/${enc}/manhours/add`, body: JSON.stringify(entryAlt) },
+            { path: `team/${team}/task/${enc}/manhours/add`, body: JSON.stringify({ manhours: [entry] }) },
+            { path: `team/${team}/task/${enc}/manhours/add`, body: JSON.stringify({ manhours: [entryAlt] }) },
+            { path: `team/${team}/task/${enc}/manhour/add`, body: JSON.stringify(entry) },
+            { path: `team/${team}/task/${enc}/manhour/add`, body: JSON.stringify(entryAlt) },
+            {
+                path: `team/${team}/tasks/update3`,
+                body: JSON.stringify({
+                    tasks: [{ uuid: taskId, manhours: [entry] }],
+                }),
+            },
+        ];
+        const beforeInfo = await onesFetchInPageWithMeta(page, `team/${team}/task/${enc}/info`, {
+            method: 'GET',
+            skipGoto: true,
+        });
+        const beforeTotal = beforeInfo.ok ? pickTaskTotalManhourRaw(beforeInfo.parsed) : null;
+        let lastDetail = '';
+        for (const { path, body } of attempts) {
+            const r = await onesFetchInPageWithMeta(page, path, {
+                method: 'POST',
+                body,
+                skipGoto: true,
+            });
+            const fail = describeAttemptFailure(r);
+            if (!fail) {
+                // Guard against false success: HTTP 200 but no actual manhour change.
+                const afterInfo = await onesFetchInPageWithMeta(page, `team/${team}/task/${enc}/info`, {
+                    method: 'GET',
+                    skipGoto: true,
+                });
+                if (afterInfo.ok) {
+                    const afterTotal = pickTaskTotalManhourRaw(afterInfo.parsed);
+                    const changed = beforeTotal === null
+                        ? afterTotal !== null
+                        : afterTotal !== null && Math.abs(afterTotal - beforeTotal) >= 1;
+                    if (changed) {
+                        return [
+                            {
+                                task: taskId,
+                                date: dateStr,
+                                hours: String(hoursHuman),
+                                owner: ownerId,
+                                endpoint: path,
+                            },
+                        ];
+                    }
+                    lastDetail = `no effect (total_manhour ${String(beforeTotal)} -> ${String(afterTotal)})`;
+                    continue;
+                }
+                // If verification read fails, return success conservatively.
+                return [
+                    {
+                        task: taskId,
+                        date: dateStr,
+                        hours: String(hoursHuman),
+                        owner: ownerId,
+                        endpoint: path,
+                    },
+                ];
+            }
+            lastDetail = fail;
+        }
+        throw new CliError('FETCH_ERROR', `ONES worklog: all endpoints failed (last: ${lastDetail})`);
+    },
+});

package/dist/clis/ones/worklog.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/ones/worklog.test.js

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { buildAddManhourGraphqlBody } from './worklog.js';
+describe('buildAddManhourGraphqlBody', () => {
+    it('inlines the addManhour arguments so the mutation is syntactically valid', () => {
+        const payload = JSON.parse(buildAddManhourGraphqlBody({
+            ownerId: 'user-1',
+            taskId: 'task-1',
+            startTime: 1711411200,
+            rawManhour: 150000,
+            note: 'Backfill',
+        }));
+        expect(payload.query).toContain('mutation AddManhour');
+        expect(payload.query).toContain('owner: "user-1"');
+        expect(payload.query).toContain('task: "task-1"');
+        expect(payload.query).toContain('start_time: 1711411200');
+        expect(payload.query).toContain('hours: 150000');
+        expect(payload.query).not.toContain('$owner');
+        expect(payload.query).not.toContain('$task');
+    });
+});

package/dist/clis/spotify/spotify.d.ts

@@ -0,0 +1 @@
+export {};