agent-pager 0.1.0

package/dist/src/hosted-vercel.js

@@ -0,0 +1,51 @@
+import { createHostedHttpHandlerFromEnv } from "./hosted-http.js";
+let cachedHandler;
+export async function handleVercelNodeRequest(req, res) {
+    try {
+        const handler = cachedHandler || (cachedHandler = createHostedHttpHandlerFromEnv());
+        const bodyText = await readBody(req);
+        const request = new Request(requestUrl(req), {
+            method: req.method || "GET",
+            headers: headersFromIncoming(req.headers),
+            body: allowsBody(req.method || "GET") ? bodyText : undefined
+        });
+        const response = await handler.handle(request);
+        res.statusCode = response.status;
+        response.headers.forEach((value, key) => res.setHeader(key, value));
+        res.end(Buffer.from(await response.arrayBuffer()));
+    }
+    catch (error) {
+        res.statusCode = 500;
+        res.setHeader("content-type", "application/json; charset=utf-8");
+        res.end(JSON.stringify({ error: error instanceof Error ? error.message : "request failed" }));
+    }
+}
+function requestUrl(req) {
+    const host = req.headers.host || "localhost";
+    const forwardedProto = req.headers["x-forwarded-proto"];
+    const proto = Array.isArray(forwardedProto) ? forwardedProto[0] : forwardedProto || "https";
+    return new URL(req.url || "/", `${proto}://${host}`).toString();
+}
+function headersFromIncoming(headers) {
+    const out = new Headers();
+    for (const [key, value] of Object.entries(headers)) {
+        if (Array.isArray(value)) {
+            for (const child of value)
+                out.append(key, child);
+        }
+        else if (value !== undefined) {
+            out.set(key, value);
+        }
+    }
+    return out;
+}
+async function readBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+function allowsBody(method) {
+    return !["GET", "HEAD"].includes(method.toUpperCase());
+}

package/dist/src/http-client.js

@@ -0,0 +1,28 @@
+import { canonicalRequest, signText } from "./crypto.js";
+import { loadLocalConfig } from "./local-config.js";
+export async function apiRequest(path, options = {}) {
+    const config = options.config || loadLocalConfig();
+    const method = options.method || "GET";
+    const body = options.body === undefined ? "" : JSON.stringify(options.body);
+    const headers = {};
+    if (body) {
+        headers["content-type"] = "application/json";
+    }
+    if (options.signed !== false) {
+        const timestamp = new Date().toISOString();
+        headers["x-ap-device-id"] = config.deviceId;
+        headers["x-ap-timestamp"] = timestamp;
+        headers["x-ap-signature"] = signText(config.privateKeyPem, canonicalRequest(method, path, timestamp, body));
+    }
+    const response = await fetch(`${config.serverUrl}${path}`, {
+        method,
+        headers,
+        body: body || undefined
+    });
+    const text = await response.text();
+    const json = text ? JSON.parse(text) : null;
+    if (!response.ok) {
+        throw new Error(json?.error || `${response.status} ${response.statusText}`);
+    }
+    return json;
+}

package/dist/src/local-config.js

@@ -0,0 +1,29 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { homedir } from "node:os";
+export function configDir() {
+    return process.env.AGENT_PAGER_HOME || join(homedir(), ".agent-pager");
+}
+export function configPath() {
+    return resolve(configDir(), "config.json");
+}
+export function inboxPath() {
+    return resolve(configDir(), "inbox.jsonl");
+}
+export function loadLocalConfig() {
+    const path = configPath();
+    if (!existsSync(path)) {
+        throw new Error("not logged in. Run `agent-pager login --username <name>` first.");
+    }
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+export function saveLocalConfig(config) {
+    const path = configPath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+}
+export function deleteLocalConfig() {
+    const path = configPath();
+    if (existsSync(path))
+        rmSync(path);
+}

package/dist/src/mcp.js

@@ -0,0 +1,341 @@
+import readline from "node:readline";
+import { apiRequest } from "./http-client.js";
+import { loadLocalConfig } from "./local-config.js";
+const tools = [
+    {
+        name: "page_friend",
+        description: "Send a concise page to an approved friend's active or most recent coding agent session.",
+        inputSchema: {
+            type: "object",
+            required: ["friend", "message"],
+            properties: {
+                friend: { type: "string", description: "Friend username to page." },
+                message: { type: "string", description: "Short action-oriented message. Do not include secrets." },
+                urgency: { type: "string", enum: ["gentle", "normal", "firm", "professionally-dramatic"] }
+            }
+        }
+    },
+    {
+        name: "reply_to_page",
+        description: "Reply to a received Agent Pager page.",
+        inputSchema: {
+            type: "object",
+            required: ["page_id", "message"],
+            properties: {
+                page_id: { type: "string" },
+                message: { type: "string" }
+            }
+        }
+    },
+    {
+        name: "list_friends",
+        description: "List approved Agent Pager friends and their limited reachable/busy/muted presence.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "get_share_link",
+        description: "Get this human's public Page my agent link. The link only creates friend requests for non-friends.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "request_friend",
+        description: "Create a pending friend request for a username only when the human asks to add or request access to that person.",
+        inputSchema: {
+            type: "object",
+            required: ["friend"],
+            properties: {
+                friend: { type: "string", description: "Username to request as a friend." },
+                note: { type: "string", description: "Optional short human-approved note." }
+            }
+        }
+    },
+    {
+        name: "list_friend_requests",
+        description: "List pending and resolved Agent Pager friend requests.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "approve_friend_request",
+        description: "Approve a pending friend request only when the human explicitly asks to approve that request.",
+        inputSchema: {
+            type: "object",
+            required: ["request_id"],
+            properties: {
+                request_id: { type: "string", description: "Friend request id to approve." }
+            }
+        }
+    },
+    {
+        name: "deny_friend_request",
+        description: "Deny a pending friend request only when the human explicitly asks to deny that request.",
+        inputSchema: {
+            type: "object",
+            required: ["request_id"],
+            properties: {
+                request_id: { type: "string", description: "Friend request id to deny." }
+            }
+        }
+    },
+    {
+        name: "cancel_friend_request",
+        description: "Cancel this user's outgoing pending friend request only when the human explicitly asks.",
+        inputSchema: {
+            type: "object",
+            required: ["request_id"],
+            properties: {
+                request_id: { type: "string", description: "Outgoing friend request id to cancel." }
+            }
+        }
+    },
+    {
+        name: "remove_friend",
+        description: "Remove an approved friendship only when the human explicitly asks to remove, unfriend, or end access for that friend.",
+        inputSchema: {
+            type: "object",
+            required: ["friend"],
+            properties: {
+                friend: { type: "string", description: "Friend username to remove." }
+            }
+        }
+    },
+    {
+        name: "check_pages",
+        description: "Check recent Agent Pager pages sent to or from this user.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "set_pager_status",
+        description: "Set Agent Pager presence status.",
+        inputSchema: {
+            type: "object",
+            required: ["status"],
+            properties: {
+                status: { type: "string", enum: ["online", "busy", "muted", "offline"] }
+            }
+        }
+    },
+    {
+        name: "mute_friend",
+        description: "Mute an approved friend so their pages are blocked for a duration or until changed.",
+        inputSchema: {
+            type: "object",
+            required: ["friend"],
+            properties: {
+                friend: { type: "string", description: "Friend username to mute." },
+                duration: { type: "string", description: "Duration such as 15m, 2h, 1d, or forever." },
+                reason: { type: "string", description: "Optional short reason for the audit log." }
+            }
+        }
+    },
+    {
+        name: "unmute_friend",
+        description: "Unmute a friend only when the human explicitly asks to allow their pages again.",
+        inputSchema: {
+            type: "object",
+            required: ["friend"],
+            properties: {
+                friend: { type: "string", description: "Friend username to unmute." }
+            }
+        }
+    },
+    {
+        name: "block_friend",
+        description: "Block a user from friend requests and pages only when the human explicitly asks for a block.",
+        inputSchema: {
+            type: "object",
+            required: ["friend"],
+            properties: {
+                friend: { type: "string", description: "Username to block." }
+            }
+        }
+    },
+    {
+        name: "unblock_friend",
+        description: "Unblock a previously blocked user only when the human explicitly asks.",
+        inputSchema: {
+            type: "object",
+            required: ["friend"],
+            properties: {
+                friend: { type: "string", description: "Username to unblock." }
+            }
+        }
+    },
+    {
+        name: "report_abuse",
+        description: "Report abusive or spammy Agent Pager behavior only when the human explicitly asks.",
+        inputSchema: {
+            type: "object",
+            required: ["reason"],
+            properties: {
+                friend: { type: "string", description: "Username to report." },
+                page_id: { type: "string", description: "Page id to report when available." },
+                reason: { type: "string", description: "Short reason such as spam, harassment, or unsafe content." },
+                details: { type: "string", description: "Optional human-provided details." }
+            }
+        }
+    }
+];
+export function runMcp() {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+    rl.on("line", async (line) => {
+        if (!line.trim())
+            return;
+        const request = JSON.parse(line);
+        if (request.id === undefined || request.id === null)
+            return;
+        try {
+            const result = await handle(request.method, request.params || {});
+            respond(request.id, { result });
+        }
+        catch (error) {
+            respond(request.id, { error: { code: -32000, message: error instanceof Error ? error.message : "tool failed" } });
+        }
+    });
+}
+async function handle(method, params) {
+    if (method === "initialize") {
+        return {
+            protocolVersion: params.protocolVersion || "2024-11-05",
+            capabilities: { tools: {} },
+            serverInfo: { name: "agent-pager", version: "0.1.0" }
+        };
+    }
+    if (method === "tools/list") {
+        return { tools };
+    }
+    if (method === "tools/call") {
+        return callTool(params.name, params.arguments || {});
+    }
+    if (method === "ping") {
+        return {};
+    }
+    throw new Error(`method not found: ${method}`);
+}
+async function callTool(name, args) {
+    if (name === "page_friend") {
+        const result = await apiRequest("/api/pages", {
+            method: "POST",
+            body: { to: args.friend, message: args.message, urgency: args.urgency || "normal" }
+        });
+        return text(`Paged ${result.page.toUsername}. Page id: ${result.page.id}`);
+    }
+    if (name === "reply_to_page") {
+        const pages = await apiRequest("/api/pages");
+        const original = pages.pages.find((page) => page.id === args.page_id);
+        if (!original)
+            throw new Error("page not found");
+        const result = await apiRequest("/api/pages", {
+            method: "POST",
+            body: { to: original.fromUsername, message: args.message, replyToPageId: args.page_id, urgency: "normal" }
+        });
+        return text(`Replied to ${result.page.toUsername}. Page id: ${result.page.id}`);
+    }
+    if (name === "list_friends") {
+        const result = await apiRequest("/api/friends");
+        return text(result.friends.map((friend) => `${friend.username}: ${friend.status}${friend.reachable ? " reachable" : ""}`).join("\n") || "No approved friends yet.");
+    }
+    if (name === "get_share_link") {
+        const localConfig = loadLocalConfig();
+        const me = await apiRequest("/api/me");
+        const config = await apiRequest("/api/config", { signed: false }).catch(() => ({ publicUrl: localConfig.serverUrl }));
+        const username = me.profile?.username || me.user?.username || "unknown";
+        const baseUrl = String(config.publicUrl || localConfig.serverUrl).replace(/\/+$/, "");
+        const url = `${baseUrl}/@${username}`;
+        return text(`Page my agent: ${url}\nNon-friends can only request access from this link.`);
+    }
+    if (name === "request_friend") {
+        const result = await apiRequest("/api/friend-requests", {
+            method: "POST",
+            body: { toUsername: args.friend, note: args.note || "" }
+        });
+        return text(`Friend request sent to ${args.friend}. Request id: ${result.friendRequest.id} (${result.friendRequest.status}).`);
+    }
+    if (name === "list_friend_requests") {
+        const result = await apiRequest("/api/friend-requests");
+        return text(result.friendRequests.map(formatFriendRequest).join("\n") || "No friend requests.");
+    }
+    if (name === "approve_friend_request") {
+        return resolveFriendRequest(args.request_id, "approve");
+    }
+    if (name === "deny_friend_request") {
+        return resolveFriendRequest(args.request_id, "deny");
+    }
+    if (name === "cancel_friend_request") {
+        return resolveFriendRequest(args.request_id, "cancel");
+    }
+    if (name === "remove_friend") {
+        const result = await apiRequest(`/api/friends/${encodeURIComponent(args.friend)}/remove`, {
+            method: "POST",
+            body: {}
+        });
+        return text(`Removed ${result.removedFriend.username}. They cannot page this agent unless friendship is approved again.`);
+    }
+    if (name === "check_pages") {
+        const result = await apiRequest("/api/pages");
+        return text(result.pages.slice(0, 10).map((page) => `#${page.id} ${page.fromUsername} -> ${page.toUsername}: ${page.message}`).join("\n") || "No pages yet.");
+    }
+    if (name === "set_pager_status") {
+        await apiRequest("/api/presence", { method: "POST", body: { status: args.status } });
+        return text(`Agent Pager status set to ${args.status}.`);
+    }
+    if (name === "mute_friend") {
+        const result = await apiRequest("/api/mutes", {
+            method: "POST",
+            body: { friend: args.friend, duration: args.duration || "forever", reason: args.reason }
+        });
+        const until = result.mutedUntil ? ` until ${new Date(result.mutedUntil).toLocaleString()}` : " forever";
+        return text(`Muted ${result.mutedUser.username}${until}.`);
+    }
+    if (name === "unmute_friend") {
+        const result = await apiRequest(`/api/mutes/${encodeURIComponent(args.friend)}/unmute`, {
+            method: "POST",
+            body: {}
+        });
+        return text(`Unmuted ${result.unmutedUser.username}.`);
+    }
+    if (name === "block_friend") {
+        const result = await apiRequest("/api/blocks", {
+            method: "POST",
+            body: { username: args.friend }
+        });
+        return text(`Blocked ${result.blockedUser.username}.`);
+    }
+    if (name === "unblock_friend") {
+        const result = await apiRequest(`/api/blocks/${encodeURIComponent(args.friend)}/unblock`, {
+            method: "POST",
+            body: {}
+        });
+        return text(`Unblocked ${result.unblockedUser.username}.`);
+    }
+    if (name === "report_abuse") {
+        const result = await apiRequest("/api/abuse-reports", {
+            method: "POST",
+            body: {
+                friend: args.friend,
+                page_id: args.page_id,
+                reason: args.reason,
+                details: args.details
+            }
+        });
+        return text(`Report filed: ${result.abuseReport.id} (${result.abuseReport.status}).`);
+    }
+    throw new Error(`unknown tool: ${name}`);
+}
+async function resolveFriendRequest(requestId, action) {
+    const result = await apiRequest(`/api/friend-requests/${encodeURIComponent(requestId)}/${action}`, {
+        method: "POST",
+        body: {}
+    });
+    return text(`Friend request ${result.request.status}.`);
+}
+function formatFriendRequest(request) {
+    const other = request.direction === "incoming" ? request.from : request.to;
+    const note = request.note ? ` · ${request.note}` : "";
+    return `${request.id} ${request.direction} ${request.status} @${other?.username || "unknown"}${note}`;
+}
+function text(value) {
+    return { content: [{ type: "text", text: value }] };
+}
+function respond(id, payload) {
+    process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, ...payload })}\n`);
+}

package/dist/src/render.js

@@ -0,0 +1,34 @@
+const width = 56;
+export function box(title, rows) {
+    const top = `┌─ ${title} ${"─".repeat(Math.max(0, width - title.length - 4))}┐`;
+    const bottom = `└${"─".repeat(width)}┘`;
+    return [top, ...rows.flatMap(wrapRow).map((row) => `│ ${row.padEnd(width - 2)} │`), bottom].join("\n");
+}
+export function statusBox(rows) {
+    return box("Agent Pager · Authorized Agent Service", Object.entries(rows).map(([key, value]) => `${key.padEnd(11)} ${value}`));
+}
+export function pageBox(page) {
+    return box("Incoming Agent Page", [
+        `From: ${page.fromUsername}`,
+        `Urgency: ${page.urgency}`,
+        `Page ID: ${page.id}`,
+        "",
+        page.message
+    ]);
+}
+function wrapRow(row) {
+    if (!row) {
+        return [""];
+    }
+    const limit = width - 2;
+    const parts = [];
+    let current = row;
+    while (current.length > limit) {
+        const breakAt = current.lastIndexOf(" ", limit);
+        const index = breakAt > 12 ? breakAt : limit;
+        parts.push(current.slice(0, index));
+        current = current.slice(index).trimStart();
+    }
+    parts.push(current);
+    return parts;
+}