zd-agent-cli 0.1.1

package/dist/core/browser-cdp.js

@@ -0,0 +1,285 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = sleep;
+exports.normalizeHttpUrl = normalizeHttpUrl;
+exports.parsePort = parsePort;
+exports.buildCdpUrlWithPort = buildCdpUrlWithPort;
+exports.getWsEndpoint = getWsEndpoint;
+exports.isCdpReachable = isCdpReachable;
+exports.launchChromeForCdp = launchChromeForCdp;
+exports.checkCdpOwnership = checkCdpOwnership;
+exports.ensureCdp = ensureCdp;
+exports.prepareInteractionContext = prepareInteractionContext;
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const get_port_1 = __importStar(require("get-port"));
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeHttpUrl(cdpUrl) {
+    if (cdpUrl.startsWith('http://') || cdpUrl.startsWith('https://')) {
+        return cdpUrl;
+    }
+    return `http://${cdpUrl}`;
+}
+function parsePort(cdpUrl) {
+    const normalized = normalizeHttpUrl(cdpUrl);
+    const url = new URL(normalized);
+    const port = Number(url.port || '9222');
+    if (!Number.isInteger(port) || port <= 0) {
+        throw new Error(`Invalid CDP URL: ${cdpUrl}`);
+    }
+    return port;
+}
+function buildCdpUrlWithPort(cdpUrl, port) {
+    const normalized = normalizeHttpUrl(cdpUrl);
+    const url = new URL(normalized);
+    url.port = String(port);
+    return `${url.protocol}//${url.hostname}:${port}`;
+}
+async function getWsEndpoint(cdpUrl) {
+    const base = normalizeHttpUrl(cdpUrl);
+    const versionUrl = new URL('/json/version', base).toString();
+    const response = await fetch(versionUrl);
+    if (!response.ok) {
+        throw new Error(`CDP endpoint returned ${response.status} at ${versionUrl}`);
+    }
+    const json = await response.json();
+    if (!json.webSocketDebuggerUrl) {
+        throw new Error(`No webSocketDebuggerUrl at ${versionUrl}`);
+    }
+    return json.webSocketDebuggerUrl;
+}
+async function isCdpReachable(cdpUrl) {
+    try {
+        await getWsEndpoint(cdpUrl);
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+}
+async function waitForCdp(cdpUrl, launchTimeoutMs, pollMs) {
+    const started = Date.now();
+    while (Date.now() - started < launchTimeoutMs) {
+        if (await isCdpReachable(cdpUrl)) {
+            return true;
+        }
+        await sleep(pollMs);
+    }
+    return false;
+}
+function launchChromeForCdp(profileDir, port) {
+    fs_1.default.mkdirSync(profileDir, { recursive: true });
+    const chromeArgs = [
+        `--user-data-dir=${profileDir}`,
+        `--remote-debugging-port=${port}`,
+        '--no-first-run',
+        '--no-default-browser-check',
+        '--disable-search-engine-choice-screen'
+    ];
+    const child = (0, child_process_1.spawn)('open', ['-na', 'Google Chrome', '--args', ...chromeArgs], { stdio: 'ignore', detached: true });
+    child.unref();
+}
+function getListenerPid(port) {
+    try {
+        const raw = (0, child_process_1.execFileSync)('lsof', ['-n', '-P', `-iTCP:${port}`, '-sTCP:LISTEN', '-t'], { encoding: 'utf8' }).trim();
+        const first = raw.split('\n').map((x) => x.trim()).find(Boolean);
+        return first || '';
+    }
+    catch (_) {
+        return '';
+    }
+}
+function getProcessCommand(pid) {
+    if (!pid)
+        return '';
+    try {
+        return (0, child_process_1.execFileSync)('ps', ['-p', String(pid), '-o', 'command='], { encoding: 'utf8' }).trim();
+    }
+    catch (_) {
+        return '';
+    }
+}
+function extractUserDataDirArg(commandText = '') {
+    const text = String(commandText || '');
+    if (!text)
+        return '';
+    const m = text.match(/--user-data-dir=(?:"([^"]+)"|'([^']+)'|([^\s]+))/);
+    if (!m)
+        return '';
+    return m[1] || m[2] || m[3] || '';
+}
+function normalizePath(p) {
+    const raw = String(p || '').trim();
+    if (!raw)
+        return '';
+    try {
+        return fs_1.default.realpathSync(raw);
+    }
+    catch (_) {
+        return path_1.default.resolve(raw);
+    }
+}
+function checkCdpOwnership({ cdpUrl, expectedProfileDir }) {
+    const port = parsePort(cdpUrl);
+    const pid = getListenerPid(port);
+    const command = getProcessCommand(pid);
+    const actualRaw = extractUserDataDirArg(command);
+    const expected = normalizePath(expectedProfileDir);
+    const actual = normalizePath(actualRaw);
+    const matches = Boolean(expected && actual && expected === actual);
+    return {
+        port,
+        pid: pid || null,
+        actualProfileDir: actualRaw || null,
+        expectedProfileDir: expectedProfileDir || null,
+        matches,
+        command: command || null
+    };
+}
+async function findOwnedReachableCdp({ cdpUrl, expectedProfileDir, portSpan }) {
+    const startPort = parsePort(cdpUrl);
+    const endPort = startPort + Math.max(0, Number(portSpan) || 0);
+    for (let port = startPort; port <= endPort; port += 1) {
+        const candidateUrl = buildCdpUrlWithPort(cdpUrl, port);
+        if (!(await isCdpReachable(candidateUrl))) {
+            continue;
+        }
+        const ownership = checkCdpOwnership({
+            cdpUrl: candidateUrl,
+            expectedProfileDir
+        });
+        if (ownership.matches) {
+            return {
+                cdpUrl: candidateUrl,
+                ownership
+            };
+        }
+    }
+    return null;
+}
+async function findFreePortInRange(cdpUrl, portSpan) {
+    const startPort = parsePort(cdpUrl);
+    const endPort = startPort + Math.max(0, Number(portSpan) || 0);
+    return (0, get_port_1.default)({ port: (0, get_port_1.portNumbers)(startPort, endPort) });
+}
+async function ensureCdp({ cdpUrl, profileDir, noLaunch = false, launchTimeoutMs = 20000, pollMs = 500, allowSharedCdp = false, autoPort = true, cdpPortSpan = 10 }) {
+    const span = Math.max(0, Number(cdpPortSpan) || 0);
+    if (await isCdpReachable(cdpUrl)) {
+        if (!allowSharedCdp) {
+            const ownership = checkCdpOwnership({ cdpUrl, expectedProfileDir: profileDir });
+            if (!ownership.matches) {
+                if (autoPort) {
+                    const ownedExisting = await findOwnedReachableCdp({
+                        cdpUrl,
+                        expectedProfileDir: profileDir,
+                        portSpan: span
+                    });
+                    if (ownedExisting) {
+                        return {
+                            launchedChrome: false,
+                            cdpUrl: ownedExisting.cdpUrl,
+                            wsEndpoint: await getWsEndpoint(ownedExisting.cdpUrl)
+                        };
+                    }
+                    if (!noLaunch) {
+                        const freePort = await findFreePortInRange(cdpUrl, span);
+                        const launchUrl = buildCdpUrlWithPort(cdpUrl, freePort);
+                        launchChromeForCdp(profileDir, freePort);
+                        const up = await waitForCdp(launchUrl, launchTimeoutMs, pollMs);
+                        if (up) {
+                            return {
+                                launchedChrome: true,
+                                cdpUrl: launchUrl,
+                                wsEndpoint: await getWsEndpoint(launchUrl)
+                            };
+                        }
+                        throw new Error(`CDP endpoint did not come up at ${launchUrl}`);
+                    }
+                }
+                const actual = ownership.actualProfileDir || 'unknown';
+                const pid = ownership.pid || 'unknown';
+                throw new Error(`CDP endpoint ${cdpUrl} is already in use by Chrome pid=${pid} with user-data-dir=${actual}. Expected ${profileDir}. ` +
+                    'Stop that Chrome instance, use a different --cdp-url, pass --allow-shared-cdp, or keep auto port fallback enabled.');
+            }
+        }
+        return { launchedChrome: false, cdpUrl, wsEndpoint: await getWsEndpoint(cdpUrl) };
+    }
+    if (noLaunch) {
+        if (autoPort) {
+            const ownedExisting = await findOwnedReachableCdp({
+                cdpUrl,
+                expectedProfileDir: profileDir,
+                portSpan: span
+            });
+            if (ownedExisting) {
+                return {
+                    launchedChrome: false,
+                    cdpUrl: ownedExisting.cdpUrl,
+                    wsEndpoint: await getWsEndpoint(ownedExisting.cdpUrl)
+                };
+            }
+        }
+        throw new Error(`CDP endpoint is not reachable at ${cdpUrl} and --no-launch is set.`);
+    }
+    const launchPort = autoPort ? await findFreePortInRange(cdpUrl, span) : parsePort(cdpUrl);
+    const launchUrl = buildCdpUrlWithPort(cdpUrl, launchPort);
+    launchChromeForCdp(profileDir, launchPort);
+    const up = await waitForCdp(launchUrl, launchTimeoutMs, pollMs);
+    if (up) {
+        return { launchedChrome: true, cdpUrl: launchUrl, wsEndpoint: await getWsEndpoint(launchUrl) };
+    }
+    throw new Error(`CDP endpoint did not come up at ${launchUrl}`);
+}
+async function prepareInteractionContext(page, uiWaitMs = 1000, opts = {}) {
+    const x = Number.isFinite(opts.x) ? opts.x : 40;
+    const y = Number.isFinite(opts.y) ? opts.y : 40;
+    await page
+        .evaluate(() => {
+        const active = document.activeElement;
+        if (active && typeof active.blur === 'function') {
+            active.blur();
+        }
+    })
+        .catch(() => undefined);
+    await page.click('body', { position: { x, y } }).catch(() => undefined);
+    await sleep(Math.max(120, Math.floor(uiWaitMs / 4)));
+}

package/dist/core/config.js

@@ -0,0 +1,287 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAbsPath = toAbsPath;
+exports.normalizeAgentPath = normalizeAgentPath;
+exports.validateConfigContract = validateConfigContract;
+exports.resolveQueueInput = resolveQueueInput;
+exports.loadResolvedConfig = loadResolvedConfig;
+exports.pickBool = pickBool;
+exports.pickString = pickString;
+exports.pickNumber = pickNumber;
+exports.safeOptionSource = safeOptionSource;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const util_1 = require("./util");
+const CONFIG_BASENAMES = ['zendesk.config.json', 'zendesk.json'];
+function asObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function truthyString(value) {
+    const raw = String(value || '').trim().toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+function resolveUp(startDir, fileName) {
+    let dir = path_1.default.resolve(startDir || process.cwd());
+    while (true) {
+        const candidate = path_1.default.join(dir, fileName);
+        if (fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir) {
+            return '';
+        }
+        dir = parent;
+    }
+}
+function findRepoRoot(startDir) {
+    let dir = path_1.default.resolve(startDir || process.cwd());
+    while (true) {
+        const gitDir = path_1.default.join(dir, '.git');
+        if (fs_1.default.existsSync(gitDir)) {
+            return dir;
+        }
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir) {
+            return path_1.default.resolve(startDir || process.cwd());
+        }
+        dir = parent;
+    }
+}
+function resolveConfigPath(explicitPath, cwd) {
+    if (explicitPath) {
+        return path_1.default.resolve(cwd, explicitPath);
+    }
+    for (const basename of CONFIG_BASENAMES) {
+        const found = resolveUp(cwd, basename);
+        if (found) {
+            return found;
+        }
+    }
+    // Fallback for npm-link/dev workflows: allow config in the CLI package root.
+    const packageRoot = path_1.default.resolve(__dirname, '..', '..');
+    for (const basename of CONFIG_BASENAMES) {
+        const candidate = path_1.default.join(packageRoot, basename);
+        if (fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return '';
+}
+function readConfigFile(filePath) {
+    if (!filePath) {
+        return {};
+    }
+    const raw = fs_1.default.readFileSync(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return asObject(parsed);
+}
+function toAbsPath(value, baseDir) {
+    const raw = String(value || '').trim();
+    if (!raw) {
+        return '';
+    }
+    return path_1.default.isAbsolute(raw) ? raw : path_1.default.resolve(baseDir, raw);
+}
+function normalizeAgentPath(rawPath, fallback = '') {
+    const base = String(rawPath || '').trim();
+    const selected = base || String(fallback || '').trim();
+    if (!selected) {
+        return '';
+    }
+    if (selected.startsWith('/')) {
+        return selected;
+    }
+    return `/${selected}`;
+}
+function normalizeQueues(rawQueues) {
+    const queues = asObject(rawQueues);
+    const out = {};
+    for (const [alias, value] of Object.entries(queues)) {
+        const row = asObject(value);
+        const name = (0, util_1.clean)(row.name || row.displayName || '');
+        const displayName = (0, util_1.clean)(row.displayName || row.name || '');
+        const queuePath = normalizeAgentPath(row.path || '');
+        if (!queuePath) {
+            continue;
+        }
+        out[alias] = {
+            name,
+            displayName,
+            path: queuePath,
+            team: (0, util_1.clean)(row.team || '')
+        };
+    }
+    return out;
+}
+function validateConfigContract(config = {}, queueConfig = {}) {
+    const issues = [];
+    const cfg = asObject(config);
+    const queuesRaw = asObject(cfg.queues);
+    const aliases = Object.keys(queuesRaw);
+    if (!(0, util_1.clean)(cfg.domain || '')) {
+        issues.push('Missing required field: domain');
+    }
+    const startPath = normalizeAgentPath(cfg.startPath || '');
+    if (!startPath) {
+        issues.push('Missing required field: startPath');
+    }
+    else if (!/^\/agent\//i.test(startPath)) {
+        issues.push(`Invalid startPath "${startPath}". startPath must begin with "/agent/".`);
+    }
+    if (!(0, util_1.clean)(cfg.defaultQueue || '')) {
+        issues.push('Missing required field: defaultQueue');
+    }
+    if (!aliases.length) {
+        issues.push('Missing required field: queues (object with at least one alias)');
+    }
+    for (const [alias, row] of Object.entries(queuesRaw)) {
+        const queuePath = normalizeAgentPath(asObject(row).path || '');
+        if (!queuePath) {
+            issues.push(`queues.${alias}.path is required`);
+            continue;
+        }
+        if (!/^\/agent\//i.test(queuePath)) {
+            issues.push(`queues.${alias}.path must begin with "/agent/" (got "${queuePath}")`);
+        }
+    }
+    const defaultQueue = (0, util_1.clean)(queueConfig.defaultQueue || cfg.defaultQueue || '');
+    if (defaultQueue && !queueConfig.queues[defaultQueue]) {
+        issues.push(`defaultQueue "${defaultQueue}" is not defined in queues`);
+    }
+    return {
+        ok: issues.length === 0,
+        issues
+    };
+}
+function resolveQueueInput(rawInput, queueConfig) {
+    const requestedRaw = (0, util_1.clean)(rawInput || '');
+    const defaultQueue = (0, util_1.clean)(queueConfig.defaultQueue || '');
+    const requested = requestedRaw || defaultQueue;
+    const aliases = asObject(queueConfig.queues);
+    if (!requested) {
+        return {
+            queueName: '',
+            queueDisplayName: '',
+            queuePath: '',
+            alias: '',
+            team: ''
+        };
+    }
+    if (aliases[requested]) {
+        return {
+            queueName: aliases[requested].name || aliases[requested].displayName || requested,
+            queueDisplayName: aliases[requested].displayName || aliases[requested].name || '',
+            queuePath: aliases[requested].path || '',
+            alias: requested,
+            team: aliases[requested].team || ''
+        };
+    }
+    const requestedLow = requested.toLowerCase();
+    for (const [alias, row] of Object.entries(aliases)) {
+        if (alias.toLowerCase() === requestedLow) {
+            return {
+                queueName: row.name || row.displayName || alias,
+                queueDisplayName: row.displayName || row.name || '',
+                queuePath: row.path || '',
+                alias,
+                team: row.team || ''
+            };
+        }
+    }
+    for (const [alias, row] of Object.entries(aliases)) {
+        const rowName = String(row.name || '').toLowerCase();
+        const rowDisplayName = String(row.displayName || '').toLowerCase();
+        if (rowName === requestedLow || rowDisplayName === requestedLow) {
+            return {
+                queueName: row.name || row.displayName || alias,
+                queueDisplayName: row.displayName || row.name || '',
+                queuePath: row.path || '',
+                alias,
+                team: row.team || ''
+            };
+        }
+    }
+    return {
+        queueName: requested,
+        queueDisplayName: requested,
+        queuePath: '',
+        alias: '',
+        team: ''
+    };
+}
+function loadResolvedConfig(options = {}) {
+    const cwd = path_1.default.resolve(options.cwd || process.cwd());
+    const explicitPath = options.configPath || process.env.ZENDESK_CONFIG || '';
+    const configPath = resolveConfigPath(explicitPath, cwd);
+    const configDir = configPath ? path_1.default.dirname(configPath) : cwd;
+    const repoRoot = configPath ? findRepoRoot(configDir) : findRepoRoot(cwd);
+    const config = readConfigFile(configPath);
+    const queueConfig = {
+        defaultQueue: (0, util_1.clean)(config.defaultQueue || ''),
+        queues: normalizeQueues(config.queues)
+    };
+    return {
+        repoRoot,
+        configPath,
+        configDir,
+        config,
+        queueConfig
+    };
+}
+function pickBool({ cliValue, cliSource, envValue, configValue, fallback }) {
+    if (cliSource === 'cli') {
+        return Boolean(cliValue);
+    }
+    if (envValue !== undefined && envValue !== null && String(envValue).trim()) {
+        return truthyString(envValue);
+    }
+    if (configValue !== undefined && configValue !== null && String(configValue).trim()) {
+        return truthyString(configValue);
+    }
+    return Boolean(fallback);
+}
+function pickString({ cliValue, cliSource, envValue, configValue, fallback }) {
+    if (cliSource === 'cli') {
+        return String(cliValue || '').trim();
+    }
+    if (envValue !== undefined && envValue !== null && String(envValue).trim()) {
+        return String(envValue).trim();
+    }
+    if (configValue !== undefined && configValue !== null && String(configValue).trim()) {
+        return String(configValue).trim();
+    }
+    return String(fallback || '').trim();
+}
+function pickNumber({ cliValue, cliSource, envValue, configValue, fallback }) {
+    const resolve = (raw) => {
+        const n = Number(raw);
+        return Number.isFinite(n) ? n : NaN;
+    };
+    if (cliSource === 'cli') {
+        const n = resolve(cliValue);
+        if (Number.isFinite(n))
+            return n;
+    }
+    if (envValue !== undefined && envValue !== null && String(envValue).trim()) {
+        const n = resolve(envValue);
+        if (Number.isFinite(n))
+            return n;
+    }
+    if (configValue !== undefined && configValue !== null && String(configValue).trim()) {
+        const n = resolve(configValue);
+        if (Number.isFinite(n))
+            return n;
+    }
+    return Number(fallback);
+}
+function safeOptionSource(program, name) {
+    if (!program || typeof program.getOptionValueSource !== 'function') {
+        return '';
+    }
+    const src = program.getOptionValueSource(name);
+    return typeof src === 'string' ? src : '';
+}

package/dist/core/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_STORE_ROOT = exports.DEFAULT_UI_WAIT_MS = exports.DEFAULT_START_PATH = exports.DEFAULT_DOMAIN = exports.DEFAULT_PROFILE_DIR = exports.DEFAULT_CDP_URL = void 0;
+const path_1 = __importDefault(require("path"));
+exports.DEFAULT_CDP_URL = 'http://127.0.0.1:9223';
+exports.DEFAULT_PROFILE_DIR = path_1.default.join('.', 'output', 'zendesk', 'chrome-profile');
+exports.DEFAULT_DOMAIN = '';
+exports.DEFAULT_START_PATH = '/agent/filters';
+exports.DEFAULT_UI_WAIT_MS = 1200;
+exports.DEFAULT_STORE_ROOT = './output/zendesk';