zd-agent-cli 0.1.1

package/dist/core/api.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTicketByIdApi = readTicketByIdApi;
+exports.findViewByNameApi = findViewByNameApi;
+exports.readQueueByViewIdApi = readQueueByViewIdApi;
+exports.searchTicketsApi = searchTicketsApi;
+exports.readCurrentUserApi = readCurrentUserApi;
+const util_1 = require("./util");
+function normalizeBaseUrl(raw) {
+    const text = String(raw || '').trim();
+    if (!text) {
+        return '';
+    }
+    try {
+        const url = new URL(text);
+        return `${url.protocol}//${url.host}`;
+    }
+    catch (_) {
+        return '';
+    }
+}
+function inferBaseUrl(page, options = {}) {
+    const fromOpt = normalizeBaseUrl(options.baseUrl);
+    if (fromOpt) {
+        return fromOpt;
+    }
+    return normalizeBaseUrl(page && typeof page.url === 'function' ? page.url() : '');
+}
+function agentUrl(baseUrl, suffix) {
+    const path = String(suffix || '').startsWith('/') ? suffix : `/${String(suffix || '')}`;
+    if (!baseUrl) {
+        return path;
+    }
+    return `${baseUrl}${path}`;
+}
+async function apiGet(page, path) {
+    try {
+        return await page.evaluate(async (endpoint) => {
+            try {
+                const res = await fetch(endpoint, {
+                    credentials: 'include',
+                    headers: {
+                        Accept: 'application/json'
+                    }
+                });
+                const text = await res.text();
+                let data = null;
+                try {
+                    data = text ? JSON.parse(text) : null;
+                }
+                catch (_) {
+                    data = null;
+                }
+                return { ok: res.ok, status: res.status, data };
+            }
+            catch (error) {
+                return { ok: false, status: 0, error: String(error && error.message ? error.message : error), data: null };
+            }
+        }, path);
+    }
+    catch (error) {
+        const message = String(error && error.message ? error.message : error);
+        return { ok: false, status: 0, error: message, data: null };
+    }
+}
+async function apiGetAllPages(page, initialPath, options = {}) {
+    const maxItems = Math.max(1, Number(options.maxItems) || 100);
+    const maxPages = Math.max(1, Number(options.maxPages) || 20);
+    const itemKey = options.itemKey || 'results';
+    let nextPath = initialPath;
+    let pageCount = 0;
+    const out = [];
+    while (nextPath && pageCount < maxPages && out.length < maxItems) {
+        const res = await apiGet(page, nextPath);
+        if (!res.ok || !res.data) {
+            break;
+        }
+        const rows = Array.isArray(res.data[itemKey]) ? res.data[itemKey] : [];
+        const remaining = maxItems - out.length;
+        out.push(...rows.slice(0, remaining));
+        const nextPage = res.data.next_page;
+        if (!nextPage || typeof nextPage !== 'string') {
+            break;
+        }
+        try {
+            const url = new URL(nextPage);
+            nextPath = `${url.pathname}${url.search}`;
+        }
+        catch (_) {
+            nextPath = null;
+        }
+        pageCount += 1;
+    }
+    return out;
+}
+function scoreNameMatch(name, target) {
+    const low = (0, util_1.clean)(name).toLowerCase();
+    const query = (0, util_1.clean)(target).toLowerCase();
+    if (!low || !query) {
+        return -1;
+    }
+    if (low === query)
+        return 100;
+    if (low.includes(query))
+        return 80;
+    if (query.includes(low))
+        return 60;
+    return -1;
+}
+async function fetchUsersMap(page, ids = []) {
+    const uniq = [...new Set(ids.map((id) => String(id || '').trim()).filter(Boolean))];
+    if (!uniq.length) {
+        return {};
+    }
+    const res = await apiGet(page, `/api/v2/users/show_many.json?ids=${encodeURIComponent(uniq.join(','))}`);
+    if (!res.ok || !res.data || !Array.isArray(res.data.users)) {
+        return {};
+    }
+    const map = {};
+    for (const user of res.data.users) {
+        if (!user || user.id === undefined || user.id === null) {
+            continue;
+        }
+        map[String(user.id)] = (0, util_1.clean)(user.name || user.email || '') || String(user.id);
+    }
+    return map;
+}
+async function readTicketByIdApi(page, ticketId, options = {}) {
+    const id = String(ticketId || '').replace(/\D+/g, '');
+    if (!id) {
+        return null;
+    }
+    const baseUrl = inferBaseUrl(page, options);
+    const commentsCount = Math.max(1, Number(options.count) || 10);
+    const ticketRes = await apiGet(page, `/api/v2/tickets/${id}.json`);
+    if (!ticketRes.ok || !ticketRes.data || !ticketRes.data.ticket) {
+        return null;
+    }
+    const commentsRes = await apiGet(page, `/api/v2/tickets/${id}/comments.json?sort_order=desc`);
+    const rawComments = commentsRes.ok && commentsRes.data && Array.isArray(commentsRes.data.comments)
+        ? commentsRes.data.comments
+        : [];
+    const ticket = ticketRes.data.ticket;
+    const actorIds = [ticket.requester_id, ticket.assignee_id, ...rawComments.map((c) => c && c.author_id)].filter(Boolean);
+    const usersById = await fetchUsersMap(page, actorIds);
+    const comments = rawComments
+        .slice(0, commentsCount)
+        .reverse()
+        .map((c) => ({
+        author: usersById[String(c.author_id)] || (c.author_id ? String(c.author_id) : null),
+        time: c.created_at || null,
+        text: (0, util_1.clean)(c.plain_body || c.body || '').slice(0, 4000)
+    }))
+        .filter((c) => c.text);
+    return {
+        pageUrl: agentUrl(baseUrl, `/agent/tickets/${id}`),
+        pageTitle: null,
+        ticketId: String(ticket.id),
+        subject: (0, util_1.clean)(ticket.subject || '') || null,
+        status: (0, util_1.clean)(ticket.status || '') || null,
+        priority: (0, util_1.clean)(ticket.priority || '') || null,
+        assignee: usersById[String(ticket.assignee_id)] || (ticket.assignee_id ? String(ticket.assignee_id) : null),
+        requester: usersById[String(ticket.requester_id)] || (ticket.requester_id ? String(ticket.requester_id) : null),
+        tags: Array.isArray(ticket.tags) ? ticket.tags : [],
+        comments,
+        source: 'api'
+    };
+}
+async function findViewByNameApi(page, queueName) {
+    const requested = (0, util_1.clean)(queueName);
+    if (!requested) {
+        return null;
+    }
+    const baseUrl = inferBaseUrl(page);
+    if (/^\d+$/.test(requested)) {
+        const id = requested;
+        return {
+            id,
+            score: 100,
+            name: requested,
+            href: agentUrl(baseUrl, `/agent/filters/${id}`),
+            source: 'id-api'
+        };
+    }
+    const responses = [
+        await apiGet(page, '/api/v2/views.json?page[size]=100'),
+        await apiGet(page, '/api/v2/views/active.json?page[size]=100')
+    ];
+    const allViews = [];
+    for (const res of responses) {
+        if (!res.ok || !res.data || !Array.isArray(res.data.views)) {
+            continue;
+        }
+        allViews.push(...res.data.views);
+    }
+    if (!allViews.length) {
+        return null;
+    }
+    let best = null;
+    for (const view of allViews) {
+        if (!view || !view.id) {
+            continue;
+        }
+        const name = (0, util_1.clean)(view.title || '');
+        if (!name) {
+            continue;
+        }
+        const score = scoreNameMatch(name, requested);
+        if (score < 0) {
+            continue;
+        }
+        if (!best || score > best.score) {
+            best = {
+                id: String(view.id),
+                score,
+                name,
+                href: agentUrl(baseUrl, `/agent/filters/${view.id}`),
+                source: 'api'
+            };
+        }
+    }
+    return best;
+}
+async function readQueueByViewIdApi(page, viewId, options = {}) {
+    const id = String(viewId || '').replace(/\D+/g, '');
+    if (!id) {
+        return null;
+    }
+    const baseUrl = inferBaseUrl(page, options);
+    const requestedCount = Number(options.count);
+    const fetchAll = options.fetchAll === true || !Number.isFinite(requestedCount) || requestedCount <= 0;
+    const count = fetchAll ? Number.MAX_SAFE_INTEGER : Math.max(1, Math.floor(requestedCount));
+    const viewRes = await apiGet(page, `/api/v2/views/${id}.json`);
+    const rawTickets = await apiGetAllPages(page, `/api/v2/views/${id}/tickets.json?per_page=${Math.min(count, 100)}`, {
+        maxItems: count,
+        maxPages: 500,
+        itemKey: 'tickets'
+    });
+    if (!rawTickets.length) {
+        return null;
+    }
+    const userIds = rawTickets
+        .flatMap((t) => {
+        const ids = [];
+        if (t && t.requester_id !== undefined && t.requester_id !== null) {
+            ids.push(String(t.requester_id));
+        }
+        if (t && t.assignee_id !== undefined && t.assignee_id !== null) {
+            ids.push(String(t.assignee_id));
+        }
+        return ids;
+    })
+        .filter(Boolean);
+    const usersById = await fetchUsersMap(page, userIds);
+    const tickets = rawTickets.map((t) => ({
+        ticketId: t && t.id !== undefined && t.id !== null ? String(t.id) : null,
+        subject: (0, util_1.clean)((t && t.subject) || ''),
+        status: (0, util_1.clean)((t && t.status) || ''),
+        assigneeId: t && t.assignee_id ? String(t.assignee_id) : null,
+        assignee: t && t.assignee_id
+            ? usersById[String(t.assignee_id)] || String(t.assignee_id)
+            : null,
+        requesterId: t && t.requester_id ? String(t.requester_id) : null,
+        requester: t && t.requester_id
+            ? usersById[String(t.requester_id)] || String(t.requester_id)
+            : null,
+        url: t && t.id ? agentUrl(baseUrl, `/agent/tickets/${t.id}`) : null
+    }));
+    const queueName = viewRes.ok && viewRes.data && viewRes.data.view && (0, util_1.clean)(viewRes.data.view.title || '')
+        ? (0, util_1.clean)(viewRes.data.view.title || '')
+        : null;
+    return {
+        pageUrl: agentUrl(baseUrl, `/agent/filters/${id}`),
+        pageTitle: null,
+        queueName,
+        source: 'api',
+        fullSync: fetchAll,
+        resultCount: tickets.length,
+        tickets
+    };
+}
+async function searchTicketsApi(page, query, options = {}) {
+    const q = (0, util_1.clean)(query);
+    if (!q) {
+        return null;
+    }
+    const baseUrl = inferBaseUrl(page, options);
+    const count = Math.max(1, Number(options.count) || 20);
+    const rows = await apiGetAllPages(page, `/api/v2/search.json?query=${encodeURIComponent(`type:ticket ${q}`)}&per_page=${Math.min(count, 100)}`, {
+        maxItems: count,
+        maxPages: 50,
+        itemKey: 'results'
+    });
+    if (!rows.length) {
+        return null;
+    }
+    const results = rows
+        .filter((row) => row && row.result_type === 'ticket')
+        .slice(0, count)
+        .map((row) => ({
+        ticketId: row.id ? String(row.id) : null,
+        title: (0, util_1.clean)(row.subject || ''),
+        snippet: (0, util_1.clean)(row.description || '').slice(0, 500),
+        url: row.id ? agentUrl(baseUrl, `/agent/tickets/${row.id}`) : null
+    }));
+    return {
+        pageUrl: agentUrl(baseUrl, `/agent/search/1?query=${encodeURIComponent(q)}`),
+        pageTitle: null,
+        query: q,
+        source: 'api',
+        resultCount: results.length,
+        results
+    };
+}
+async function readCurrentUserApi(page) {
+    const res = await apiGet(page, '/api/v2/users/me.json');
+    if (!res.ok || !res.data || !res.data.user) {
+        return null;
+    }
+    const user = res.data.user;
+    return {
+        id: user.id !== undefined && user.id !== null ? String(user.id) : null,
+        name: (0, util_1.clean)(user.name || '') || null,
+        email: (0, util_1.clean)(user.email || '') || null,
+        role: (0, util_1.clean)(user.role || '') || null
+    };
+}

package/dist/core/automation.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getZendeskPage = getZendeskPage;
+exports.openTicketById = openTicketById;
+exports.readCurrentTicket = readCurrentTicket;
+exports.openQueueByName = openQueueByName;
+exports.readQueueTickets = readQueueTickets;
+exports.runTicketSearch = runTicketSearch;
+exports.readCurrentUser = readCurrentUser;
+exports.isAuthenticated = isAuthenticated;
+const constants_1 = require("./constants");
+const util_1 = require("./util");
+const dom = __importStar(require("./dom"));
+const api = __importStar(require("./api"));
+function getBaseUrlFromPage(page) {
+    try {
+        const url = new URL(page.url());
+        return `${url.protocol}//${url.host}`;
+    }
+    catch (_) {
+        return '';
+    }
+}
+function parseViewIdFromUrl(pageUrl = '') {
+    const m = String(pageUrl).match(/\/agent\/filters\/(\d+)/i);
+    return m ? m[1] : null;
+}
+function parseTicketIdFromUrl(pageUrl = '') {
+    const m = String(pageUrl).match(/\/agent\/tickets\/(\d+)/i);
+    return m ? m[1] : null;
+}
+async function getZendeskPage(context, startUrl, background) {
+    return dom.getZendeskPage(context, startUrl, background);
+}
+async function openTicketById(page, ticketId, uiWaitMs = constants_1.DEFAULT_UI_WAIT_MS) {
+    return dom.openTicketByIdDom(page, ticketId, uiWaitMs);
+}
+async function readCurrentTicket(page, options = {}) {
+    const count = Math.max(1, Number(options.count) || 10);
+    const ticketId = parseTicketIdFromUrl(page.url());
+    const baseUrl = getBaseUrlFromPage(page);
+    if (ticketId) {
+        const apiResult = await api.readTicketByIdApi(page, ticketId, { count, baseUrl });
+        if (apiResult) {
+            return {
+                ...apiResult,
+                pageUrl: page.url(),
+                pageTitle: (await page.title().catch(() => null)) || apiResult.pageTitle || null
+            };
+        }
+    }
+    return dom.readCurrentTicketDom(page, { count });
+}
+async function openQueueByName(page, queueName, uiWaitMs = constants_1.DEFAULT_UI_WAIT_MS, options = {}) {
+    const requested = (0, util_1.clean)(queueName);
+    const queuePath = (0, util_1.clean)(options.queuePath || '');
+    if (!requested && !queuePath) {
+        throw new Error('Queue name or queue path is required.');
+    }
+    if (queuePath) {
+        return dom.openQueueByPathDom(page, queuePath, uiWaitMs);
+    }
+    await dom.waitForAgentReady(page, uiWaitMs);
+    const matchedApi = await api.findViewByNameApi(page, requested);
+    if (matchedApi && matchedApi.href) {
+        await page.goto(matchedApi.href, { waitUntil: 'domcontentloaded', timeout: 45000 });
+        await dom.waitForAgentReady(page, uiWaitMs);
+        return matchedApi;
+    }
+    return dom.openQueueByNameDom(page, requested, uiWaitMs);
+}
+async function readQueueTickets(page, options = {}) {
+    const requestedCount = Number(options.count);
+    const hasCount = Number.isFinite(requestedCount) && requestedCount > 0;
+    const count = hasCount ? Math.max(1, Math.floor(requestedCount)) : Number.MAX_SAFE_INTEGER;
+    const fetchAll = options.fetchAll === true || !hasCount;
+    const viewId = parseViewIdFromUrl(page.url());
+    const baseUrl = getBaseUrlFromPage(page);
+    if (viewId) {
+        const apiResult = await api.readQueueByViewIdApi(page, viewId, { count, fetchAll, baseUrl });
+        if (apiResult) {
+            return {
+                ...apiResult,
+                pageUrl: page.url(),
+                pageTitle: (await page.title().catch(() => null)) || apiResult.pageTitle || null
+            };
+        }
+    }
+    return dom.readQueueTicketsDom(page, { count });
+}
+async function runTicketSearch(page, query, count = 20, uiWaitMs = constants_1.DEFAULT_UI_WAIT_MS) {
+    await dom.waitForAgentReady(page, uiWaitMs);
+    const baseUrl = getBaseUrlFromPage(page);
+    const apiResult = await api.searchTicketsApi(page, query, { count, baseUrl });
+    if (apiResult && apiResult.resultCount > 0) {
+        return {
+            ...apiResult,
+            pageUrl: baseUrl
+                ? `${baseUrl}/agent/search/1?query=${encodeURIComponent((0, util_1.clean)(query))}`
+                : apiResult.pageUrl,
+            pageTitle: (await page.title().catch(() => null)) || apiResult.pageTitle || null
+        };
+    }
+    const domResult = await dom.runTicketSearchDom(page, query, count, uiWaitMs);
+    if (domResult && domResult.resultCount > 0) {
+        return domResult;
+    }
+    return apiResult || domResult;
+}
+async function readCurrentUser(page) {
+    return api.readCurrentUserApi(page);
+}
+async function isAuthenticated(page) {
+    const user = await readCurrentUser(page);
+    return Boolean(user && user.id);
+}