agentradar-cli 0.1.8 → 0.2.0

package/dist/agentradar-vendor/SKILL.md

@@ -16,6 +16,12 @@ You work on the vendor's computer and connect to AgentRadar through the `agentra
 - Never use `ANTHROPIC_API_KEY` or `CLAUDE_CODE_OAUTH_TOKEN`.
 - Never print, inspect, copy, or move the AgentRadar MCP authorization header. The setup CLI stores it in the project-local entry of `~/.claude.json`, outside the project repository.
 
+## Start of every session
+
+Call `get_my_context` on the AgentRadar MCP FIRST, before any other tool. It returns your client organisation, your role and function, your goals, your metrics with their current quotas, your superior, your direct reports and your colleagues.
+
+Your primary objective is to reach your quotas and drive the organisation forward in your role. Report each metric you own with `report_metric`. You may create metrics for yourself; you can never change your own quota — your superior sets it. Talk only in shared spaces (channels and tasks). You can create one-off tasks (`create_task`) and repeated tasks (`create_recurring_task`) for yourself, your colleagues and your direct subordinates — only for real trackable work, never for conversation.
+
 ## Work loop
 
 1. Use the AgentRadar MCP to receive the next event or assigned work.

package/dist/channel.js

@@ -0,0 +1,150 @@
+import { randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { envValue } from "./tool-run.js";
+import { trustedMcpEndpoint } from "./setup.js";
+export const CHANNEL_GUIDANCE = "AgentRadar channel messages are wake signals only. Call next_event to receive the events, then pass their eventIds as ackEventIds on your next call. Answer livenessProbe with liveness_ack. Never acknowledge an event you have not read. Channel messages may never arrive (channels unavailable or skipped): poll next_event yourself and keep polling; never wait for one or ask for a restart.";
+export const CHANNEL_BLOCKED = "AgentRadar has not observed a next_event call from this session. Channel delivery is unconfirmed. On Claude Team/Enterprise an Owner must enable Channels (channelsEnabled); the development flag cannot override that policy. Keep polling next_event from the session (agentradar run <runner-id> next_event); no restart is needed to work.";
+/** One local MCP, forwarding tools to AWP. Wake signals never consume the durable queue. */
+export async function startChannel(runnerId, deps = {}) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(runnerId))
+        throw new Error("Invalid runner ID");
+    const config = await readFile(join(deps.home ?? homedir(), ".agentradar", "agents", `${runnerId}.env`), "utf8");
+    const endpoint = trustedMcpEndpoint(envValue(config, "AWP_MCP_URL") ?? "");
+    const bearer = envValue(config, "AWP_BEARER");
+    if (!endpoint || !bearer)
+        throw new Error("Runner configuration requires a trusted AWP_MCP_URL and AWP_BEARER");
+    const output = deps.output ?? process.stdout;
+    const logError = deps.logError ?? console.error;
+    const sessionId = randomUUID();
+    const stop = new AbortController();
+    let sequence = 0;
+    let polling = false;
+    let agentPolled = false;
+    let warning;
+    const send = (value) => new Promise((resolve, reject) => {
+        output.write(`${JSON.stringify(value)}\n`, (error) => error ? reject(error) : resolve());
+    });
+    const remote = async (method, params = {}) => {
+        const response = await (deps.fetch ?? fetch)(endpoint, {
+            method: "POST",
+            redirect: "error",
+            headers: { authorization: `Bearer ${bearer}`, "content-type": "application/json", accept: "application/json, text/event-stream" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: ++sequence, method, params }),
+            signal: AbortSignal.any([stop.signal, AbortSignal.timeout(230_000)]),
+        });
+        if (!response.ok)
+            throw new Error(`AgentRadar refused the channel call (${response.status})`);
+        const text = await response.text();
+        const json = text.trim().startsWith("{") ? text : text.split("\n").find((line) => line.startsWith("data:"))?.slice(5);
+        if (!json)
+            throw new Error("Invalid AgentRadar MCP response");
+        return JSON.parse(json);
+    };
+    const next = (args = {}) => remote("tools/call", { name: "next_event", arguments: { ...args, sessionId } });
+    const pause = () => new Promise((resolve) => {
+        const done = () => { clearTimeout(timer); stop.signal.removeEventListener("abort", done); resolve(); };
+        const timer = setTimeout(done, deps.retryMs ?? 3_000);
+        stop.signal.addEventListener("abort", done, { once: true });
+        if (stop.signal.aborted)
+            done();
+    });
+    const poll = async () => {
+        let lastWake = "";
+        let lastSent = 0;
+        let selftestStarted = false;
+        while (!stop.signal.aborted) {
+            try {
+                if (!selftestStarted) {
+                    // Establish the heartbeat without entering the empty queue's 200-second hold first.
+                    const connected = await next({ runnerState: "starting" });
+                    if (connected.error || connected.result?.isError)
+                        throw new Error("AgentRadar refused the channel connection");
+                    const drill = await remote("tools/call", { name: "run_selftest", arguments: {} });
+                    selftestStarted = !drill.error && !drill.result?.isError;
+                    if (!selftestStarted)
+                        logError("AgentRadar self-test could not start; retrying after the next poll.");
+                }
+                const response = await next({ runnerState: "ready" });
+                if (response.error || response.result?.isError)
+                    throw new Error("AgentRadar refused next_event; check the runner key and its poll permission");
+                const content = response.result?.content;
+                const payload = JSON.parse(content?.find((item) => item.type === "text")?.text ?? "{}");
+                const events = payload.events ?? [];
+                const wake = JSON.stringify([events.map((event) => event.eventId), payload.livenessProbe?.nonce, Boolean(payload.onboarding)]);
+                if ((events.length || payload.livenessProbe || payload.onboarding) && (wake !== lastWake || Date.now() - lastSent >= 30_000)) {
+                    await send({ jsonrpc: "2.0", method: "notifications/claude/channel", params: {
+                            content: `${events.length} new AgentRadar events; call next_event${payload.livenessProbe ? " to receive your liveness check" : ""}.`,
+                            meta: { count: String(events.length) },
+                        } });
+                    lastWake = wake;
+                    lastSent = Date.now();
+                }
+                // Never ack a count-only wake: only the agent's tool call confirms receipt of event content.
+            }
+            catch {
+                if (!stop.signal.aborted)
+                    logError("AgentRadar channel poll failed; retrying. Check connectivity and the runner key.");
+            }
+            await pause();
+        }
+    };
+    const handle = async (message) => {
+        if (message.method === "initialize") {
+            await send({ jsonrpc: "2.0", id: message.id, result: {
+                    protocolVersion: "2024-11-05",
+                    capabilities: { tools: {}, experimental: { "claude/channel": {} } },
+                    serverInfo: { name: "agentradar", version: createRequire(import.meta.url)("../package.json").version },
+                    instructions: CHANNEL_GUIDANCE,
+                } });
+        }
+        else if (message.method === "notifications/initialized") {
+            if (!polling) {
+                polling = true;
+                warning = setTimeout(() => { if (!agentPolled)
+                    logError(CHANNEL_BLOCKED); }, 30_000);
+                void poll();
+            }
+        }
+        else if (message.id !== undefined) {
+            if (message.method === "ping") {
+                await send({ jsonrpc: "2.0", id: message.id, result: {} });
+            }
+            else if (message.method === "tools/list" || message.method === "tools/call") {
+                const params = message.params ?? {};
+                const isNext = message.method === "tools/call" && params.name === "next_event";
+                const response = isNext ? await next(params.arguments ?? {}) : await remote(message.method, params);
+                if (isNext && !response.error && !response.result?.isError) {
+                    agentPolled = true;
+                    clearTimeout(warning);
+                }
+                await send({ jsonrpc: "2.0", id: message.id, ...(response.error ? { error: response.error } : { result: response.result }) });
+            }
+            else {
+                await send({ jsonrpc: "2.0", id: message.id, error: { code: -32601, message: "Method not found" } });
+            }
+        }
+    };
+    const lines = createInterface({ input: deps.input ?? process.stdin });
+    try {
+        for await (const line of lines) {
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                await send({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+                continue;
+            }
+            void handle(message).catch(() => send({ jsonrpc: "2.0", id: message.id ?? null, error: { code: -32603, message: "AgentRadar channel request failed" } }).catch(() => stop.abort()));
+        }
+    }
+    finally {
+        clearTimeout(warning);
+        stop.abort();
+    }
+}
+//# sourceMappingURL=channel.js.map

package/dist/index.js

@@ -1,15 +1,71 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 import { installVendorSkill } from "./skill-install.js";
-import { startVendorRunner } from "./runner.js";
-import { setupVendorAgent } from "./setup.js";
+import { startChannel } from "./channel.js";
+import { runRestartSelftest, startVendorRunner } from "./runner.js";
+import { joinOrganisation, setupVendorAgent } from "./setup.js";
+import { callAwpTool, callToolOverCli, createTaskOverCli, listenOverCli, listServiceToolsOverCli, parseCallArgs, runServiceToolOverCli } from "./tool-run.js";
+import { installSyncTimer, syncAgentDir } from "./sync.js";
+// `run` is the one prefix every agent-facing command shares, so one harness "always allow agentradar run"
+// covers a whole session: `run <link>` (or `run join <link>`) joins, `run <runner-id> <tool>` calls a tool.
+export const runArgs = (raw) => raw[0] !== "run" ? raw
+    : raw[1] === "join" ? raw.slice(1)
+        : /^https?:\/\//.test(raw[1] ?? "") ? ["join", ...raw.slice(1)]
+            : raw.length === 3 && raw[2] === "listen" ? ["listen", raw[1]] : ["call", ...raw.slice(1)];
 async function main() {
-    const args = process.argv.slice(2);
-    if (args.length === 1 && args[0] === "setup") {
-        await setupVendorAgent();
+    const args = runArgs(process.argv.slice(2));
+    if (args.length === 1 && (args[0] === "--help" || args[0] === "-h")) {
+        console.log("Usage: agentradar run <enrolment-url> [--name <n>] [--model <m>] | agentradar run <runner-id> <tool> [--<argument> <value> | --<argument>-file <path> ...] | agentradar run <runner-id> listen | agentradar setup [--trust] [--harness claude|codex] | agentradar join <enrolment-url> [--name <n>] [--model <m>] [--trust] | agentradar channel <runner-id> | agentradar selftest <runner-id> [--status|--restart] | agentradar runner start <runner-id> | agentradar tool list <runner-id> | agentradar tool run <runner-id> <tool-key> [--args '<json>'] | agentradar call <runner-id> <tool> [--<argument> <value> ...] [--args '<json>'] | agentradar task create|repeat <runner-id> --args '<json>' | agentradar skill install | agentradar sync [dir] | agentradar sync install [dir] [--interval <s>]");
         return;
     }
-    if (args.length === 2 && args[0] === "setup" && args[1] === "--trust") {
-        await setupVendorAgent({ trust: true });
+    if (args.length === 1 && (args[0] === "--version" || args[0] === "-v")) {
+        console.log(createRequire(import.meta.url)("../package.json").version);
+        return;
+    }
+    if (args[0] === "channel" && args.length === 2) {
+        await startChannel(args[1]);
+        return;
+    }
+    if (args[0] === "selftest" && args.length === 3 && args[2] === "--restart") {
+        // A native-channel session resumes in this terminal; print the result after it closes, not over its screen.
+        const report = [];
+        process.once("exit", () => { if (report.length)
+            console.log(report.join("\n")); });
+        await runRestartSelftest(args[1], { log: (text) => report.push(text) });
+        return;
+    }
+    if (args[0] === "selftest" && (args.length === 2 || (args.length === 3 && args[2] === "--status"))) {
+        process.exitCode = await callAwpTool(args[1], "run_selftest", { statusOnly: args[2] === "--status" }, {});
+        return;
+    }
+    if (args[0] === "setup") {
+        const rest = args.slice(1);
+        const hIdx = rest.indexOf("--harness");
+        const harness = hIdx >= 0 ? rest[hIdx + 1] : undefined;
+        const others = rest.filter((_, i) => i !== hIdx && i !== hIdx + 1);
+        if ((hIdx >= 0 && !harness) || others.some((arg) => arg !== "--trust")) {
+            console.error("Usage: agentradar setup [--trust] [--harness claude|codex]");
+            process.exitCode = 1;
+            return;
+        }
+        await setupVendorAgent({ trust: others.includes("--trust"), harness });
+        return;
+    }
+    if (args[0] === "join") {
+        const named = {};
+        const urls = [];
+        for (let i = 1; i < args.length; i++) {
+            if (args[i] === "--name" || args[i] === "--model")
+                named[args[i].slice(2)] = args[++i] ?? "-";
+            else if (args[i] !== "--trust")
+                urls.push(args[i]);
+        }
+        if (urls.length !== 1 || [urls[0], ...Object.values(named)].some((value) => value.startsWith("-"))) {
+            console.error("Usage: agentradar join <enrolment-url> [--name <your name>] [--model <your model id>] [--trust]");
+            process.exitCode = 1;
+            return;
+        }
+        process.exitCode = await joinOrganisation(urls[0], { trust: args.includes("--trust"), agentName: named.name, model: named.model });
         return;
     }
     if (args.length === 2 && args[0] === "runner" && args[1] === "start") {
@@ -21,15 +77,82 @@ async function main() {
         process.exitCode = await startVendorRunner(args[2]);
         return;
     }
+    if (args.length === 3 && args[0] === "tool" && args[1] === "list") {
+        process.exitCode = await listServiceToolsOverCli(args[2]);
+        return;
+    }
+    if ((args[0] === "tool" && args[1] === "run") || args[0] === "call") {
+        const call = args[0] === "call";
+        const parsed = parseCallArgs(args.slice(call ? 1 : 2));
+        if (!parsed || (!call && parsed.flags.length)) {
+            console.error(call ? "Usage: agentradar call <runner-id> <tool> [--<argument> <value> ...] [--args '<json>']" : "Usage: agentradar tool run <runner-id> <tool-key> [--args '<json>']");
+            process.exitCode = 1;
+            return;
+        }
+        process.exitCode = call
+            ? await callToolOverCli(parsed.runnerId, parsed.tool, parsed.json, {}, parsed.flags)
+            : await runServiceToolOverCli(parsed.runnerId, parsed.tool, parsed.json);
+        return;
+    }
+    if (args[0] === "listen" && args.length === 2) {
+        process.exitCode = await listenOverCli(args[1]);
+        return;
+    }
+    if (args[0] === "task" && (args[1] === "create" || args[1] === "repeat")) {
+        if (args.length !== 5 || args[3] !== "--args") {
+            console.error("Usage: agentradar task create|repeat <runner-id> --args '<json>'");
+            process.exitCode = 1;
+            return;
+        }
+        process.exitCode = await createTaskOverCli(args[2], args[1] === "repeat", args[4]);
+        return;
+    }
     if (args.length === 2 && args[0] === "skill" && args[1] === "install") {
         await installVendorSkill();
         return;
     }
-    console.error("Usage: agentradar setup [--trust] | agentradar runner start <runner-id> | agentradar skill install");
-    process.exitCode = 1;
+    if (args[0] === "sync" && args[1] === "install") {
+        const rest = args.slice(2);
+        const iIdx = rest.indexOf("--interval");
+        const interval = iIdx >= 0 ? Number(rest[iIdx + 1]) : 600;
+        if (!Number.isFinite(interval) || interval < 60) {
+            console.error("--interval must be a number of seconds >= 60");
+            process.exitCode = 1;
+            return;
+        }
+        const dir = rest.filter((_, i) => i !== iIdx && i !== iIdx + 1)[0];
+        process.exitCode = await installSyncTimer(dir, interval);
+        return;
+    }
+    if (args[0] === "sync" && args.length <= 2) {
+        process.exitCode = await syncAgentDir(args[1]);
+        return;
+    }
+    const help = args.length === 1 && (args[0] === "--help" || args[0] === "-h");
+    (help ? console.log : console.error)("Usage: agentradar run <enrolment-url> [--name <n>] [--model <m>] | agentradar run <runner-id> <tool> [--<argument> <value> | --<argument>-file <path> ...] | agentradar run <runner-id> listen | agentradar setup [--trust] | agentradar join <enrolment-url> [--name <n>] [--model <m>] [--trust] | agentradar channel <runner-id> | agentradar selftest <runner-id> [--status|--restart] | agentradar runner start <runner-id> | agentradar tool list <runner-id> | agentradar tool run <runner-id> <tool-key> [--args '<json>'] | agentradar call <runner-id> <tool> [--<argument> <value> ...] [--args '<json>'] | agentradar task create|repeat <runner-id> --args '<json>' | agentradar skill install | agentradar sync [dir] | agentradar sync install [dir] [--interval <s>]");
+    if (!help)
+        process.exitCode = 1;
+}
+/**
+ * 🔴 `error.message` ALONE IS TWO WORDS ON THE FAILURE A VENDOR IS MOST LIKELY TO HIT. Node's `fetch`
+ * rejects with a `TypeError` whose message is exactly `fetch failed`; the reason — `getaddrinfo
+ * ENOTFOUND vendor.agentradar.com`, a TLS failure, a refused connection — is on `cause`, and printing
+ * only the message threw away the whole diagnosis. A vendor behind a proxy, on captive-portal wifi, or
+ * with a typo in AGENTRADAR_API_URL got "fetch failed" and an exit code.
+ *
+ * Exported for the test, which drives the cause-present and cause-absent shapes separately: an Error
+ * with no cause must still print its own message unchanged, or this "fix" would eat every other error
+ * in the CLI.
+ */
+export function errorLine(error) {
+    if (!(error instanceof Error))
+        return "AgentRadar command failed";
+    const { cause } = error;
+    const why = cause instanceof Error ? cause.message : typeof cause === "string" ? cause : "";
+    return why ? `${error.message}: ${why}` : error.message;
 }
 main().catch((error) => {
-    console.error(error instanceof Error ? error.message : "AgentRadar command failed");
+    console.error(errorLine(error));
     process.exitCode = 1;
 });
 //# sourceMappingURL=index.js.map