@indigoai-us/hq-cli 5.322.0 → 5.324.0

package/dist/lib/daemon/ops/memory.d.ts

@@ -0,0 +1,20 @@
+/**
+ * memory.get / memory.put ops (hq-anywhere US-009): session-scoped notes
+ * persisted at workspace/sessions/<sid>/hqd-memory.json under HQ_ROOT.
+ */
+export declare const MEMORY_FILE = "hqd-memory.json";
+export declare class MemoryOpError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare function memoryPath(hqRoot: string, sessionId: string): string;
+export declare function memoryPut(hqRoot: string, sessionId: string, key: string, value: unknown, now?: Date): {
+    key: string;
+    updatedAt: string;
+};
+export declare function memoryGet(hqRoot: string, sessionId: string, key?: string): {
+    value: unknown;
+} | {
+    entries: Record<string, unknown>;
+};
+//# sourceMappingURL=memory.d.ts.map

package/dist/lib/daemon/ops/memory.js

@@ -0,0 +1,65 @@
+/**
+ * memory.get / memory.put ops (hq-anywhere US-009): session-scoped notes
+ * persisted at workspace/sessions/<sid>/hqd-memory.json under HQ_ROOT.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+const SESSION_RE = /^[A-Za-z0-9._-]+$/;
+export const MEMORY_FILE = "hqd-memory.json";
+const MAX_VALUE_BYTES = 256 * 1024;
+export class MemoryOpError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "MemoryOpError";
+    }
+}
+export function memoryPath(hqRoot, sessionId) {
+    if (!SESSION_RE.test(sessionId) || sessionId === "." || sessionId === "..") {
+        throw new MemoryOpError("bad_args", "sessionId may only contain letters, digits, '.', '_' and '-'");
+    }
+    return path.join(hqRoot, "workspace", "sessions", sessionId, MEMORY_FILE);
+}
+function readAll(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return {};
+        throw err;
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new MemoryOpError("corrupt_memory", `${file} is not a JSON object`);
+    }
+    return parsed;
+}
+export function memoryPut(hqRoot, sessionId, key, value, now = new Date()) {
+    if (!key.trim())
+        throw new MemoryOpError("bad_args", "key must be non-empty");
+    const serialized = JSON.stringify(value ?? null);
+    if (Buffer.byteLength(serialized, "utf8") > MAX_VALUE_BYTES)
+        throw new MemoryOpError("too_large", `value is over ${MAX_VALUE_BYTES} bytes`);
+    const file = memoryPath(hqRoot, sessionId);
+    const all = readAll(file);
+    const updatedAt = now.toISOString();
+    if (value === null || value === undefined)
+        delete all[key];
+    else
+        all[key] = { value, updatedAt };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(all, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(tmp, file);
+    return { key, updatedAt };
+}
+export function memoryGet(hqRoot, sessionId, key) {
+    const all = readAll(memoryPath(hqRoot, sessionId));
+    if (key !== undefined)
+        return { value: all[key]?.value ?? null };
+    return { entries: Object.fromEntries(Object.entries(all).map(([k, e]) => [k, e.value])) };
+}
+//# sourceMappingURL=memory.js.map

package/dist/lib/daemon/ops/mesh.d.ts

@@ -0,0 +1,38 @@
+/**
+ * mesh.presence op (hq-anywhere US-009).
+ *
+ * Writes one schema-valid session event to the Work Mesh Live spool through
+ * the same enqueue path as `hq mesh session … --enqueue`. The daemon's mesh
+ * drainer service already flushes that spool, so presence from a session in a
+ * foreign cwd reaches Work Mesh Live without any new transport.
+ */
+export declare class MeshOpError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface MeshPresenceArgs {
+    sessionId: string;
+    harness: string;
+    kind: string;
+    cwd?: string;
+    company?: string;
+    project?: string;
+    task?: string;
+    taskId?: string;
+    status?: string;
+    summary?: string;
+    reason?: string;
+}
+export interface MeshPresenceDeps {
+    hqRoot?: string;
+    /** Work-mesh root override (tests); defaults to ~/.hq/work-mesh or HQ_WORK_MESH_ROOT. */
+    workMeshRoot?: string;
+    env?: NodeJS.ProcessEnv;
+    now?: () => Date;
+}
+export declare function meshPresence(args: MeshPresenceArgs, deps?: MeshPresenceDeps): {
+    eventId: string;
+    seq: number;
+    spoolPath: string;
+};
+//# sourceMappingURL=mesh.d.ts.map

package/dist/lib/daemon/ops/mesh.js

@@ -0,0 +1,70 @@
+/**
+ * mesh.presence op (hq-anywhere US-009).
+ *
+ * Writes one schema-valid session event to the Work Mesh Live spool through
+ * the same enqueue path as `hq mesh session … --enqueue`. The daemon's mesh
+ * drainer service already flushes that spool, so presence from a session in a
+ * foreign cwd reaches Work Mesh Live without any new transport.
+ */
+import { CLI_VERSION } from "../../../cli-version.js";
+import { CLI_KIND_TO_SCHEMA, EnqueueValidationError, enqueueSessionEvent } from "../../mesh/live/enqueue.js";
+import { reserveSessionSeq } from "../../mesh/live/session-seq.js";
+const HARNESSES = ["claude-code", "claude-desktop", "codex", "grok", "hq-sessions", "agent-box", "agents-v2"];
+const SCHEMA_KINDS = new Set(Object.values(CLI_KIND_TO_SCHEMA));
+const STATUSES = new Set(["queued", "in_progress", "review", "done"]);
+export class MeshOpError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "MeshOpError";
+    }
+}
+export function meshPresence(args, deps = {}) {
+    const env = deps.env ?? process.env;
+    if (!HARNESSES.includes(args.harness)) {
+        throw new MeshOpError("bad_args", `harness must be one of ${HARNESSES.join(", ")}`);
+    }
+    const kind = (CLI_KIND_TO_SCHEMA[args.kind] ?? (SCHEMA_KINDS.has(args.kind) ? args.kind : undefined));
+    if (!kind)
+        throw new MeshOpError("bad_args", `kind must be one of ${Object.keys(CLI_KIND_TO_SCHEMA).join(", ")}`);
+    if (args.status !== undefined && !STATUSES.has(args.status))
+        throw new MeshOpError("bad_args", "status must be queued, in_progress, review or done");
+    let seq;
+    try {
+        seq = reserveSessionSeq(args.sessionId, 1, env);
+    }
+    catch (err) {
+        throw new MeshOpError("bad_args", `sessionId rejected: ${err.message}`);
+    }
+    let result;
+    try {
+        result = enqueueSessionEvent({
+            kind,
+            sessionId: args.sessionId,
+            harness: args.harness,
+            adapterVersion: CLI_VERSION,
+            source: "hooks",
+            seq,
+            cwd: args.cwd,
+            hqRoot: deps.hqRoot,
+            companySlug: args.company,
+            project: args.project,
+            task: args.task,
+            taskId: args.taskId,
+            status: args.status,
+            summary: args.summary,
+            reason: args.reason,
+            root: deps.workMeshRoot,
+            env,
+            now: deps.now,
+        });
+    }
+    catch (err) {
+        if (err instanceof EnqueueValidationError)
+            throw new MeshOpError("bad_args", err.message);
+        throw err;
+    }
+    return { eventId: result.event.eventId, seq, spoolPath: result.spoolPath };
+}
+//# sourceMappingURL=mesh.js.map

package/dist/lib/daemon/ops/policy.d.ts

@@ -0,0 +1,78 @@
+/**
+ * policy.check and policy.index ops (hq-anywhere US-009).
+ *
+ * Verdicts come from the hq-core hook scripts under HQ_ROOT, run as child
+ * processes with a synthesized hook payload, so hookless hosts and sub-agents
+ * get the same answer a hook-dispatching session would. No rule is
+ * reimplemented here:
+ *   - .claude/hooks/mandatory-scope-authorizer.sh decides allow/block
+ *     (exit 2 = block, reason on stderr).
+ *   - .claude/hooks/inject-policy-on-trigger.sh supplies additionalContext.
+ *
+ * The policy index (which policy files exist for a company) is cached
+ * in-process and invalidated by fs.watch on core/policies, personal/policies
+ * and companies/<co>/policies.
+ */
+export declare const SCOPE_AUTHORIZER = ".claude/hooks/mandatory-scope-authorizer.sh";
+export declare const POLICY_TRIGGER = ".claude/hooks/inject-policy-on-trigger.sh";
+export declare class PolicyOpError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface PolicyEntry {
+    slug: string;
+    path: string;
+    scope: "core" | "personal" | "company";
+    company?: string;
+}
+/** Cached list of policy files under HQ_ROOT, invalidated by fs.watch. */
+export declare class PolicyIndex {
+    readonly hqRoot: string;
+    private readonly log;
+    private entries;
+    private watchers;
+    private closed;
+    /** Bumped on every invalidation; lets callers see that the cache was rebuilt. */
+    version: number;
+    constructor(hqRoot: string, log?: (level: "info" | "warn" | "error", message: string) => void);
+    /** Policies visible to `company`: core, personal, and that company only. */
+    list(company?: string): PolicyEntry[];
+    invalidate(): void;
+    close(): void;
+    private rebuild;
+    private rewatch;
+}
+export interface PolicyCheckArgs {
+    company: string;
+    event?: string;
+    tool: string;
+    input?: Record<string, unknown>;
+    sessionId?: string;
+    cwd?: string;
+}
+export interface PolicyCheckResult {
+    decision: "allow" | "block";
+    reasons: string[];
+    additionalContext: string;
+    session: string;
+    policies: {
+        count: number;
+        version: number;
+    };
+}
+/**
+ * The scope authorizer reads the session's company from
+ * workspace/sessions/<sid>/meta.yaml (or scope-capability.json). hqd binds a
+ * session id of its own per company + caller, so a check never borrows the
+ * binding of an unrelated session.
+ */
+export declare function bindCheckSession(hqRoot: string, company: string, callerSession: string | undefined, now: Date): string;
+export interface PolicyCheckDeps {
+    hqRoot: string;
+    index: PolicyIndex;
+    env?: NodeJS.ProcessEnv;
+    now?: () => Date;
+    timeoutMs?: number;
+}
+export declare function policyCheck(args: PolicyCheckArgs, deps: PolicyCheckDeps): Promise<PolicyCheckResult>;
+//# sourceMappingURL=policy.d.ts.map

package/dist/lib/daemon/ops/policy.js

@@ -0,0 +1,283 @@
+/**
+ * policy.check and policy.index ops (hq-anywhere US-009).
+ *
+ * Verdicts come from the hq-core hook scripts under HQ_ROOT, run as child
+ * processes with a synthesized hook payload, so hookless hosts and sub-agents
+ * get the same answer a hook-dispatching session would. No rule is
+ * reimplemented here:
+ *   - .claude/hooks/mandatory-scope-authorizer.sh decides allow/block
+ *     (exit 2 = block, reason on stderr).
+ *   - .claude/hooks/inject-policy-on-trigger.sh supplies additionalContext.
+ *
+ * The policy index (which policy files exist for a company) is cached
+ * in-process and invalidated by fs.watch on core/policies, personal/policies
+ * and companies/<co>/policies.
+ */
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const SCOPE_AUTHORIZER = ".claude/hooks/mandatory-scope-authorizer.sh";
+export const POLICY_TRIGGER = ".claude/hooks/inject-policy-on-trigger.sh";
+const SLUG_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const SESSION_RE = /^[A-Za-z0-9._-]+$/;
+export class PolicyOpError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "PolicyOpError";
+    }
+}
+/** Cached list of policy files under HQ_ROOT, invalidated by fs.watch. */
+export class PolicyIndex {
+    hqRoot;
+    log;
+    entries = null;
+    watchers = [];
+    closed = false;
+    /** Bumped on every invalidation; lets callers see that the cache was rebuilt. */
+    version = 0;
+    constructor(hqRoot, log = () => { }) {
+        this.hqRoot = hqRoot;
+        this.log = log;
+    }
+    /** Policies visible to `company`: core, personal, and that company only. */
+    list(company) {
+        if (!this.entries)
+            this.rebuild();
+        return this.entries.filter((e) => e.scope !== "company" || e.company === company);
+    }
+    invalidate() {
+        if (this.entries === null)
+            return;
+        this.entries = null;
+        this.version += 1;
+    }
+    close() {
+        this.closed = true;
+        for (const w of this.watchers)
+            w.close();
+        this.watchers = [];
+    }
+    rebuild() {
+        const dirs = [
+            { dir: path.join(this.hqRoot, "core", "policies"), scope: "core" },
+            { dir: path.join(this.hqRoot, "personal", "policies"), scope: "personal" },
+        ];
+        const companiesDir = path.join(this.hqRoot, "companies");
+        const companyDirs = [];
+        for (const co of readDirNames(companiesDir)) {
+            if (!SLUG_RE.test(co))
+                continue;
+            const companyDir = path.join(companiesDir, co);
+            if (isDir(companyDir))
+                companyDirs.push(companyDir);
+            const dir = path.join(companiesDir, co, "policies");
+            if (isDir(dir))
+                dirs.push({ dir, scope: "company", company: co });
+        }
+        const entries = [];
+        for (const d of dirs) {
+            for (const name of readDirNames(d.dir)) {
+                if (!name.endsWith(".md") || name.startsWith("_"))
+                    continue;
+                entries.push({ slug: name.slice(0, -3), path: path.join(d.dir, name), scope: d.scope, ...(d.company ? { company: d.company } : {}) });
+            }
+        }
+        this.entries = entries;
+        this.rewatch([...dirs.map((d) => d.dir), ...companyDirs, companiesDir]);
+    }
+    rewatch(dirs) {
+        for (const w of this.watchers)
+            w.close();
+        this.watchers = [];
+        if (this.closed)
+            return;
+        for (const dir of dirs) {
+            if (!isDir(dir))
+                continue;
+            try {
+                const w = fs.watch(dir, () => this.invalidate());
+                w.on("error", (err) => {
+                    this.log("warn", `policy index watch on ${dir} failed: ${err.message}`);
+                    this.invalidate();
+                });
+                this.watchers.push(w);
+            }
+            catch (err) {
+                this.log("warn", `could not watch ${dir}: ${err.message}`);
+            }
+        }
+    }
+}
+function readDirNames(dir) {
+    try {
+        return fs.readdirSync(dir);
+    }
+    catch (err) {
+        if (err.code === "ENOENT" || err.code === "ENOTDIR")
+            return [];
+        throw err;
+    }
+}
+function isDir(dir) {
+    try {
+        return fs.statSync(dir).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function runScript(script, payload, env, cwd, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("bash", [script], { cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGKILL");
+        }, timeoutMs);
+        child.stdout.on("data", (c) => (stdout += c.toString("utf8")));
+        child.stderr.on("data", (c) => (stderr += c.toString("utf8")));
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolve({ code, stdout, stderr, timedOut });
+        });
+        child.stdin.on("error", () => {
+            // The script may exit before reading stdin; its exit code still decides.
+        });
+        child.stdin.end(payload);
+    });
+}
+/**
+ * The scope authorizer reads the session's company from
+ * workspace/sessions/<sid>/meta.yaml (or scope-capability.json). hqd binds a
+ * session id of its own per company + caller, so a check never borrows the
+ * binding of an unrelated session.
+ */
+export function bindCheckSession(hqRoot, company, callerSession, now) {
+    const caller = (callerSession ?? "default").replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 80) || "default";
+    const sid = `hqd-${company}-${caller}`;
+    if (!SESSION_RE.test(sid))
+        throw new PolicyOpError("bad_args", "sessionId has no usable characters");
+    const dir = path.join(hqRoot, "workspace", "sessions", sid);
+    const meta = path.join(dir, "meta.yaml");
+    const body = `session_id: ${sid}\nstarted_at: ${now.toISOString()}\nsenior: user\ncompany_slug: ${company}\nsource: hqd\n`;
+    let current = "";
+    try {
+        current = fs.readFileSync(meta, "utf8");
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    if (!current.includes(`\ncompany_slug: ${company}\n`)) {
+        fs.mkdirSync(dir, { recursive: true });
+        const tmp = `${meta}.${process.pid}.tmp`;
+        fs.writeFileSync(tmp, body);
+        fs.renameSync(tmp, meta);
+    }
+    return sid;
+}
+function extractContext(stdout) {
+    const text = stdout.trim();
+    if (!text)
+        return "";
+    try {
+        const parsed = JSON.parse(text);
+        const ctx = parsed.hookSpecificOutput?.additionalContext ?? parsed.additionalContext;
+        return typeof ctx === "string" ? ctx : "";
+    }
+    catch {
+        return text;
+    }
+}
+function blockFromJson(stdout) {
+    try {
+        const parsed = JSON.parse(stdout.trim());
+        if (parsed.decision === "block")
+            return typeof parsed.reason === "string" ? parsed.reason : "blocked";
+        if (parsed.hookSpecificOutput?.permissionDecision === "deny") {
+            const r = parsed.hookSpecificOutput.permissionDecisionReason;
+            return typeof r === "string" ? r : "denied";
+        }
+    }
+    catch {
+        // Plain-text stdout is not a verdict.
+    }
+    return null;
+}
+export async function policyCheck(args, deps) {
+    const { hqRoot } = deps;
+    if (!SLUG_RE.test(args.company))
+        throw new PolicyOpError("bad_args", "company must be a company slug");
+    if (!isDir(path.join(hqRoot, "companies", args.company))) {
+        throw new PolicyOpError("unknown_company", `no companies/${args.company} under ${hqRoot}`);
+    }
+    const authorizer = path.join(hqRoot, SCOPE_AUTHORIZER);
+    const trigger = path.join(hqRoot, POLICY_TRIGGER);
+    if (!fs.existsSync(authorizer)) {
+        throw new PolicyOpError("policy_engine_unavailable", `scope authorizer not found at ${authorizer}`);
+    }
+    const event = args.event ?? "PreToolUse";
+    const session = bindCheckSession(hqRoot, args.company, args.sessionId, (deps.now ?? (() => new Date()))());
+    const payload = JSON.stringify({
+        session_id: session,
+        hook_event_name: event,
+        tool_name: args.tool,
+        tool_input: args.input ?? {},
+        cwd: args.cwd ?? hqRoot,
+    });
+    const env = {
+        ...(deps.env ?? process.env),
+        HQ_ROOT: hqRoot,
+        CLAUDE_PROJECT_DIR: hqRoot,
+        HQ_POLICY_COMPANY: args.company,
+        BASH_ENV: "/dev/null",
+    };
+    delete env.HQ_HOOK_SESSION_ID;
+    delete env.HQ_HOOK_TOOL_NAME;
+    const timeoutMs = deps.timeoutMs ?? 15_000;
+    const reasons = [];
+    let decision = "allow";
+    if (event === "PreToolUse") {
+        const r = await runScript(authorizer, payload, env, hqRoot, timeoutMs);
+        const jsonBlock = blockFromJson(r.stdout);
+        if (r.timedOut) {
+            decision = "block";
+            reasons.push(`scope authorizer timed out after ${timeoutMs}ms; failing closed`);
+        }
+        else if (r.code === 2 || jsonBlock) {
+            decision = "block";
+            reasons.push((jsonBlock ?? r.stderr).trim() || "blocked by scope authorizer");
+        }
+        else if (r.code !== 0) {
+            decision = "block";
+            reasons.push(`scope authorizer exited ${r.code}; failing closed: ${r.stderr.trim()}`);
+        }
+    }
+    let additionalContext = "";
+    if (fs.existsSync(trigger)) {
+        const r = await runScript(trigger, payload, env, hqRoot, timeoutMs);
+        if (r.code === 0 && !r.timedOut)
+            additionalContext = extractContext(r.stdout);
+        else
+            reasons.push(`policy trigger hook did not complete (exit ${r.code}${r.timedOut ? ", timed out" : ""}); no policy context`);
+    }
+    else {
+        reasons.push(`policy trigger hook not found at ${trigger}; no policy context`);
+    }
+    return {
+        decision,
+        reasons,
+        additionalContext,
+        session,
+        policies: { count: deps.index.list(args.company).length, version: deps.index.version },
+    };
+}
+//# sourceMappingURL=policy.js.map

package/dist/lib/daemon/protocol.d.ts

@@ -0,0 +1,68 @@
+/**
+ * hqd wire protocol (hq-anywhere US-008).
+ *
+ * One Unix domain socket (a named pipe on Windows) carrying newline-delimited
+ * JSON. Requests are `{id, op, args}`; each gets exactly one response
+ * `{id, ok: true, result}` or `{id, ok: false, error}`. Responses may arrive
+ * out of order, so clients match them by `id`.
+ */
+export declare const HQD_SOCKET_NAME = "hqd.sock";
+export declare const HQD_OPS: readonly ["ping", "resolve", "session.open", "session.get", "session.close", "policy.check", "policy.index", "journal.append", "memory.get", "memory.put", "mesh.presence", "shutdown"];
+export type HqdOp = (typeof HQD_OPS)[number];
+/** A request line larger than this is rejected and the connection closed. */
+export declare const HQD_MAX_LINE_BYTES: number;
+export interface HqdRequest {
+    id: string | number;
+    op: string;
+    args?: Record<string, unknown>;
+}
+export interface HqdError {
+    code: string;
+    message: string;
+}
+export type HqdResponse = {
+    id: string | number | null;
+    ok: true;
+    result: unknown;
+} | {
+    id: string | number | null;
+    ok: false;
+    error: HqdError;
+};
+/**
+ * Socket path: HQ_HQD_SOCKET, else <HQ_REGISTRY_DIR or ~/.hq>/hqd.sock.
+ * On Windows the socket is a per-user named pipe.
+ */
+export declare function hqdSocketPath(home?: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): string;
+export declare function encodeMessage(message: HqdRequest | HqdResponse): string;
+export type ParsedLine = {
+    ok: true;
+    request: HqdRequest;
+} | {
+    ok: false;
+    id: string | number | null;
+    error: HqdError;
+};
+/** Validate one request line. Never throws. */
+export declare function parseRequestLine(line: string): ParsedLine;
+/**
+ * Split a byte stream into lines. Returns a push function that hands each
+ * complete line to `onLine`, and reports overflow when a partial line grows
+ * past `maxBytes`.
+ */
+export declare function createLineSplitter(onLine: (line: string) => void, onOverflow: () => void, maxBytes?: number): (chunk: Buffer | string) => void;
+export declare class HqdClientError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface HqdRequestOptions {
+    socketPath?: string;
+    /** Whole-request budget, including connect. Default 2000ms. */
+    timeoutMs?: number;
+}
+/**
+ * Send one request and wait for its response. A daemon that is not running
+ * fails fast with the socket error code (ENOENT or ECONNREFUSED).
+ */
+export declare function hqdRequest(op: HqdOp | string, args?: Record<string, unknown>, opts?: HqdRequestOptions): Promise<unknown>;
+//# sourceMappingURL=protocol.d.ts.map