@aria-cli/tools 1.0.10 → 1.0.12

package/dist-cjs/providers/search-provider.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSearchProviderEnv = resolveSearchProviderEnv;
+exports.createProviderAbortSignal = createProviderAbortSignal;
+function resolveSearchProviderEnv(env = process.env) {
+    return {
+        ARIA_SEARCH_PROVIDER: env.ARIA_SEARCH_PROVIDER,
+        BRAVE_API_KEY: env.BRAVE_API_KEY,
+        FIRECRAWL_API_KEY: env.FIRECRAWL_API_KEY,
+        EXA_API_KEY: env.EXA_API_KEY,
+        TAVILY_API_KEY: env.TAVILY_API_KEY,
+        JINA_API_KEY: env.JINA_API_KEY,
+    };
+}
+function createProviderAbortSignal(timeoutMs, callerSignal) {
+    const controller = new AbortController();
+    const onCallerAbort = () => controller.abort();
+    if (callerSignal) {
+        if (callerSignal.aborted) {
+            controller.abort();
+        }
+        else {
+            callerSignal.addEventListener("abort", onCallerAbort, { once: true });
+        }
+    }
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    return {
+        signal: controller.signal,
+        cleanup: () => {
+            clearTimeout(timeout);
+            if (callerSignal) {
+                callerSignal.removeEventListener("abort", onCallerAbort);
+            }
+        },
+    };
+}

package/dist-cjs/providers/tavily.d.ts

@@ -0,0 +1,10 @@
+import type { SearchProvider, SearchOptions, SearchResult, SearchProviderEnv } from "./search-provider.js";
+export declare class TavilySearchProvider implements SearchProvider {
+    private readonly env;
+    readonly name = "tavily";
+    readonly requiresApiKey = true;
+    readonly priority = 4;
+    constructor(env?: SearchProviderEnv | Record<string, string | undefined>);
+    isAvailable(): boolean;
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+}

package/dist-cjs/providers/tavily.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TavilySearchProvider = void 0;
+const search_provider_js_1 = require("./search-provider.js");
+class TavilySearchProvider {
+    env;
+    name = "tavily";
+    requiresApiKey = true;
+    priority = 4;
+    constructor(env = process.env) {
+        this.env = env;
+    }
+    isAvailable() {
+        const apiKey = (0, search_provider_js_1.resolveSearchProviderEnv)(this.env).TAVILY_API_KEY;
+        return Boolean(apiKey && apiKey.trim().length > 0);
+    }
+    async search(query, options) {
+        const apiKey = (0, search_provider_js_1.resolveSearchProviderEnv)(this.env).TAVILY_API_KEY;
+        if (!apiKey) {
+            throw new Error("TAVILY_API_KEY environment variable is not set");
+        }
+        const limit = options?.limit ?? 5;
+        const body = {
+            api_key: apiKey,
+            query,
+            max_results: limit,
+            ...(options?.topic && { topic: options.topic }),
+            ...(options?.domains && { include_domains: options.domains }),
+            ...(options?.excludeDomains && { exclude_domains: options.excludeDomains }),
+        };
+        const { signal, cleanup } = (0, search_provider_js_1.createProviderAbortSignal)(30_000, options?.signal);
+        try {
+            const response = await fetch("https://api.tavily.com/search", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+                signal,
+            });
+            if (!response.ok) {
+                throw new Error(`Tavily Search API error: ${response.status} ${response.statusText}`);
+            }
+            const json = await response.json();
+            const results = (json.results || []);
+            return results.map((r) => ({
+                title: r.title,
+                url: r.url,
+                content: r.content,
+                score: r.score,
+            }));
+        }
+        finally {
+            cleanup();
+        }
+    }
+}
+exports.TavilySearchProvider = TavilySearchProvider;

package/dist-cjs/quip/desktop-session.d.ts

@@ -0,0 +1,69 @@
+export interface QuipDocumentSummary {
+    threadId: string;
+    title: string;
+    link: string;
+    updatedUsec: number;
+    createdUsec: number;
+}
+export interface QuipDocumentListResult {
+    documents: QuipDocumentSummary[];
+}
+export interface QuipDocumentDetail {
+    threadId: string;
+    title: string;
+    link: string;
+    markdown: string;
+    updatedUsec: number;
+    createdUsec: number;
+    authorId: string;
+}
+export interface QuipCreateResult {
+    threadId: string;
+    title: string;
+    link: string;
+}
+export interface QuipCommentView {
+    id: string;
+    authorId: string;
+    authorName: string;
+    text: string;
+    createdUsec: number;
+}
+export interface QuipCommentResult {
+    threadId: string;
+    commentId: string;
+}
+export interface QuipCommentListResult {
+    threadId: string;
+    comments: QuipCommentView[];
+}
+export interface QuipDesktopClient {
+    getUserId(): string;
+    listRecentDocuments(input: {
+        limit?: number;
+    }): Promise<QuipDocumentListResult>;
+    searchDocuments(input: {
+        query: string;
+        limit?: number;
+    }): Promise<QuipDocumentListResult>;
+    readDocument(input: {
+        threadId: string;
+    }): Promise<QuipDocumentDetail>;
+    createDocument(input: {
+        title: string;
+        content: string;
+        format?: "markdown" | "html";
+        folderId?: string;
+    }): Promise<QuipCreateResult>;
+    addComment(input: {
+        threadId: string;
+        content: string;
+    }): Promise<QuipCommentResult>;
+    listComments(input: {
+        threadId: string;
+    }): Promise<QuipCommentListResult>;
+    close(): Promise<void>;
+}
+export declare function createQuipDesktopClient(options?: {
+    bootstrapTimeoutMs?: number;
+}): Promise<QuipDesktopClient>;

package/dist-cjs/quip/desktop-session.js

@@ -0,0 +1,353 @@
+"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.createQuipDesktopClient = createQuipDesktopClient;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const QUIP_API_BASE = "https://platform.quip.com/1";
+const DEFAULT_BOOTSTRAP_TIMEOUT_MS = 30_000;
+// ── HTML → Markdown conversion (regex-based, no deps) ───────────────
+function htmlToMarkdown(html) {
+    let md = html;
+    // Block elements first
+    md = md.replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, "\n# $1\n");
+    md = md.replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, "\n## $1\n");
+    md = md.replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, "\n### $1\n");
+    md = md.replace(/<h4[^>]*>([\s\S]*?)<\/h4>/gi, "\n#### $1\n");
+    md = md.replace(/<br\s*\/?>/gi, "\n");
+    md = md.replace(/<\/p>/gi, "\n\n");
+    md = md.replace(/<p[^>]*>/gi, "");
+    md = md.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, "- $1\n");
+    md = md.replace(/<\/?(ul|ol)[^>]*>/gi, "\n");
+    md = md.replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi, (_, content) => content
+        .split("\n")
+        .map((line) => `> ${line}`)
+        .join("\n"));
+    md = md.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, "\n```\n$1\n```\n");
+    md = md.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, "`$1`");
+    // Inline formatting
+    md = md.replace(/<(b|strong)[^>]*>([\s\S]*?)<\/\1>/gi, "**$2**");
+    md = md.replace(/<(i|em)[^>]*>([\s\S]*?)<\/\1>/gi, "*$2*");
+    md = md.replace(/<(s|del|strike)[^>]*>([\s\S]*?)<\/\1>/gi, "~~$2~~");
+    md = md.replace(/<a\s+href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, "[$2]($1)");
+    // Strip remaining tags
+    md = md.replace(/<[^>]+>/g, "");
+    // Decode common HTML entities
+    md = md.replace(/&amp;/g, "&");
+    md = md.replace(/&lt;/g, "<");
+    md = md.replace(/&gt;/g, ">");
+    md = md.replace(/&quot;/g, '"');
+    md = md.replace(/&#39;/g, "'");
+    md = md.replace(/&nbsp;/g, " ");
+    // Collapse excessive blank lines
+    md = md.replace(/\n{3,}/g, "\n\n");
+    return md.trim();
+}
+async function extractKeychainDesktopToken() {
+    try {
+        // Use python3 to parse the bplist from Keychain — macOS ships python3
+        // and plutil requires a temp file; python3 one-liner is cleaner.
+        const { stdout } = await execFileAsync("python3", [
+            "-c",
+            `
+import subprocess, plistlib, sys
+from datetime import datetime, timedelta
+try:
+    raw = subprocess.check_output([
+        'security', 'find-generic-password', '-s', 'Quip', '-a', 'MultiAccount', '-g'
+    ], stderr=subprocess.STDOUT).decode()
+    import re
+    hex_match = re.search(r'password: 0x([0-9A-Fa-f]+)', raw)
+    if not hex_match:
+        sys.exit(1)
+    data = bytes.fromhex(hex_match.group(1))
+    plist = plistlib.loads(data)
+    import json
+    for uid, info in plist.get('accounts', {}).items():
+        exp = info.get('session_expiration', 0)
+        exp_date = datetime(2001, 1, 1) + timedelta(seconds=exp)
+        if exp_date > datetime.now():
+            json.dump({"token": info["session_id"], "userId": uid}, sys.stdout)
+            sys.exit(0)
+    sys.exit(1)
+except:
+    sys.exit(1)
+`.trim(),
+        ]);
+        const parsed = JSON.parse(stdout.trim());
+        if (parsed.token && parsed.userId) {
+            return parsed;
+        }
+    }
+    catch {
+        // Keychain extraction failed — fall through
+    }
+    return null;
+}
+async function extractManualKeychainToken() {
+    try {
+        const { stdout } = await execFileAsync("security", [
+            "find-generic-password",
+            "-a",
+            "aria",
+            "-s",
+            "quip-token",
+            "-w",
+        ]);
+        const token = stdout.trim();
+        return token || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function extractPlaywrightToken(timeoutMs) {
+    const playwright = await Promise.resolve().then(() => __importStar(require("playwright")));
+    const browser = await playwright.chromium.launch({ headless: true });
+    try {
+        const context = await browser.newContext();
+        const page = await context.newPage();
+        const tokenPromise = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                page.off("request", handleRequest);
+                reject(new Error("Timed out waiting for Quip API token via Playwright."));
+            }, timeoutMs);
+            const handleRequest = (request) => {
+                const url = request.url();
+                if (!url.includes("platform.quip.com"))
+                    return;
+                const authHeader = request.headers()["authorization"];
+                if (!authHeader?.startsWith("Bearer "))
+                    return;
+                clearTimeout(timer);
+                page.off("request", handleRequest);
+                resolve(authHeader.slice(7));
+            };
+            page.on("request", handleRequest);
+        });
+        await page.goto("https://quip.com", {
+            waitUntil: "domcontentloaded",
+            timeout: timeoutMs,
+        });
+        const token = await tokenPromise;
+        // Get user ID from /users/current
+        const resp = await context.request.get(`${QUIP_API_BASE}/users/current`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        const userData = (await resp.json());
+        const userId = typeof userData.id === "string" ? userData.id : "unknown";
+        await page.close().catch(() => undefined);
+        await context.close().catch(() => undefined);
+        await browser.close().catch(() => undefined);
+        return { token, userId };
+    }
+    catch (error) {
+        await browser.close().catch(() => undefined);
+        throw error;
+    }
+}
+// ── Thread/document helpers ─────────────────────────────────────────
+function toDocumentSummary(thread) {
+    return {
+        threadId: typeof thread.id === "string" ? thread.id : "",
+        title: typeof thread.title === "string" ? thread.title : "",
+        link: typeof thread.link === "string" ? thread.link : "",
+        updatedUsec: typeof thread.updated_usec === "number" ? thread.updated_usec : 0,
+        createdUsec: typeof thread.created_usec === "number" ? thread.created_usec : 0,
+    };
+}
+// ── Client factory ──────────────────────────────────────────────────
+async function createQuipDesktopClient(options) {
+    const timeoutMs = options?.bootstrapTimeoutMs ?? DEFAULT_BOOTSTRAP_TIMEOUT_MS;
+    // Priority 1: Keychain desktop token (auto from Quip desktop app)
+    let keychainResult = await extractKeychainDesktopToken();
+    // Priority 2: Playwright web session (SSO handles auth)
+    if (!keychainResult) {
+        try {
+            keychainResult = await extractPlaywrightToken(timeoutMs);
+        }
+        catch {
+            // Playwright extraction failed — fall through
+        }
+    }
+    // Priority 3: Manual keychain token
+    let token;
+    let userId;
+    if (keychainResult) {
+        token = keychainResult.token;
+        userId = keychainResult.userId;
+    }
+    else {
+        const manualToken = await extractManualKeychainToken();
+        if (!manualToken) {
+            throw new Error("No Quip token available. Install the Quip desktop app, or add a manual token:\n" +
+                '  security add-generic-password -a aria -s quip-token -w "<token>"\n' +
+                "Get a token from https://quip.com/dev/token");
+        }
+        token = manualToken;
+        userId = "unknown";
+    }
+    // Verify token and resolve userId if unknown
+    const invokeApi = async (method, endpoint, body) => {
+        const url = `${QUIP_API_BASE}${endpoint}`;
+        const headers = {
+            Authorization: `Bearer ${token}`,
+        };
+        const fetchOptions = { method, headers };
+        if (body) {
+            headers["Content-Type"] = "application/x-www-form-urlencoded";
+            fetchOptions.body = new URLSearchParams(Object.entries(body).map(([k, v]) => [k, String(v)])).toString();
+        }
+        const resp = await fetch(url, fetchOptions);
+        const text = await resp.text();
+        let json;
+        try {
+            json = JSON.parse(text);
+        }
+        catch {
+            throw new Error(`Quip API ${endpoint} returned non-JSON (HTTP ${resp.status}).`);
+        }
+        if (!resp.ok) {
+            const errorCode = typeof json.error_code === "number" ? json.error_code : resp.status;
+            const errorMsg = typeof json.error_description === "string" ? json.error_description : `HTTP ${resp.status}`;
+            throw new Error(`Quip API ${endpoint} failed (${errorCode}): ${errorMsg}`);
+        }
+        return json;
+    };
+    // Resolve userId on first use if unknown
+    if (userId === "unknown") {
+        const user = await invokeApi("GET", "/users/current");
+        userId = typeof user.id === "string" ? user.id : "unknown";
+    }
+    return {
+        getUserId: () => userId,
+        listRecentDocuments: async ({ limit = 20 }) => {
+            const data = await invokeApi("GET", `/threads/recent?count=${Math.min(limit, 50)}`);
+            const threads = Array.isArray(data)
+                ? data
+                : typeof data === "object" && data !== null
+                    ? Object.values(data)
+                    : [];
+            const documents = [];
+            for (const entry of threads) {
+                if (!entry || typeof entry !== "object")
+                    continue;
+                const thread = "thread" in entry
+                    ? entry.thread
+                    : entry;
+                documents.push(toDocumentSummary(thread));
+            }
+            return { documents: documents.slice(0, limit) };
+        },
+        searchDocuments: async ({ query, limit = 20 }) => {
+            const params = new URLSearchParams({ query, count: String(Math.min(limit, 50)) });
+            const data = await invokeApi("GET", `/threads/search?${params}`);
+            const threads = Array.isArray(data)
+                ? data
+                : typeof data === "object" && data !== null
+                    ? Object.values(data)
+                    : [];
+            const documents = [];
+            for (const entry of threads) {
+                if (!entry || typeof entry !== "object")
+                    continue;
+                const thread = "thread" in entry
+                    ? entry.thread
+                    : entry;
+                documents.push(toDocumentSummary(thread));
+            }
+            return { documents: documents.slice(0, limit) };
+        },
+        readDocument: async ({ threadId }) => {
+            const data = await invokeApi("GET", `/threads/${threadId}`);
+            const thread = typeof data.thread === "object" && data.thread !== null
+                ? data.thread
+                : data;
+            const rawHtml = typeof data.html === "string" ? data.html : "";
+            return {
+                threadId: typeof thread.id === "string" ? thread.id : threadId,
+                title: typeof thread.title === "string" ? thread.title : "",
+                link: typeof thread.link === "string" ? thread.link : "",
+                markdown: htmlToMarkdown(rawHtml),
+                updatedUsec: typeof thread.updated_usec === "number" ? thread.updated_usec : 0,
+                createdUsec: typeof thread.created_usec === "number" ? thread.created_usec : 0,
+                authorId: typeof thread.author_id === "string" ? thread.author_id : "",
+            };
+        },
+        createDocument: async ({ title, content, format = "markdown", folderId }) => {
+            const body = { title, content, format };
+            if (folderId)
+                body.member_ids = folderId;
+            const data = await invokeApi("POST", "/threads/new-document", body);
+            const thread = typeof data.thread === "object" && data.thread !== null
+                ? data.thread
+                : data;
+            return {
+                threadId: typeof thread.id === "string" ? thread.id : "",
+                title: typeof thread.title === "string" ? thread.title : title,
+                link: typeof thread.link === "string" ? thread.link : "",
+            };
+        },
+        addComment: async ({ threadId, content }) => {
+            const data = await invokeApi("POST", "/messages/new", {
+                thread_id: threadId,
+                content,
+            });
+            return {
+                threadId,
+                commentId: typeof data.id === "string" ? data.id : "",
+            };
+        },
+        listComments: async ({ threadId }) => {
+            const data = await invokeApi("GET", `/messages/${threadId}`);
+            const rawMessages = Array.isArray(data) ? data : [];
+            const comments = rawMessages
+                .filter((m) => !!m && typeof m === "object")
+                .map((m) => ({
+                id: typeof m.id === "string" ? m.id : "",
+                authorId: typeof m.author_id === "string" ? m.author_id : "",
+                authorName: typeof m.author_name === "string" ? m.author_name : "",
+                text: typeof m.text === "string" ? m.text : "",
+                createdUsec: typeof m.created_usec === "number" ? m.created_usec : 0,
+            }));
+            return { threadId, comments };
+        },
+        close: async () => {
+            // No persistent resources to clean up (unlike Slack which keeps a browser open).
+            // Token-based client is stateless.
+        },
+    };
+}

package/dist-cjs/registry/index.d.ts

@@ -0,0 +1 @@
+export { ToolRegistry, validateToolInput } from "./registry.js";

package/dist-cjs/registry/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateToolInput = exports.ToolRegistry = void 0;
+var registry_js_1 = require("./registry.js");
+Object.defineProperty(exports, "ToolRegistry", { enumerable: true, get: function () { return registry_js_1.ToolRegistry; } });
+Object.defineProperty(exports, "validateToolInput", { enumerable: true, get: function () { return registry_js_1.validateToolInput; } });