@aria-cli/tools 1.0.12 → 1.0.14

package/dist/definitions/delegation.js

@@ -1,512 +0,0 @@
-/**
- * Delegation tool definitions
- *
- * Tools: delegate_arion, spawn_worker, check_delegation, pause_delegation, resume_delegation, delegate_remote, quest_report (7 tools)
- *
- * delegate_arion and spawn_worker call context.delegationExecutor (injected by runner).
- * check_delegation uses context.delegationRegistry for status queries.
- * When the executor/registry aren't wired, tools return a clear error.
- */
-import { z } from "zod";
-import { NodeIdSchema } from "../network-runtime/index.js";
-import { tool } from "../tool-factory.js";
-/**
- * Delegate a task to another arion in the room.
- * The arion runs in parallel with its own memory and persona.
- */
-const delegate_arion = tool({
-    name: "delegate_arion",
-    description: "Delegate a task to another arion in the room. The arion runs in parallel with its own memory and persona. Use check_delegation to get results.",
-    parameters: z.object({
-        arion: z.string().min(1).max(100).describe("Name of the arion to delegate to"),
-        task: z.string().min(1).max(100_000).describe("The task description for the delegated arion"),
-        tier: z
-            .enum(["fast", "balanced", "powerful", "ensemble"])
-            .optional()
-            .describe("Model tier override (fast/balanced/powerful)"),
-    }),
-    category: "arion",
-    riskLevel: "moderate",
-    isReadOnly: false,
-    loadingTier: "always",
-    execute: async (input, context) => {
-        if (!context.delegationExecutor) {
-            return {
-                success: false,
-                message: "delegate_arion: Delegation executor not available. Ensure RunSession is configured with delegation support.",
-            };
-        }
-        try {
-            const id = await context.delegationExecutor.delegateToArion(input.arion, input.task, input.tier);
-            return {
-                success: true,
-                message: `Delegation ${id} started. Arion "${input.arion}" is working on the task. Use check_delegation to monitor progress.`,
-                data: { id, arion: input.arion },
-            };
-        }
-        catch (e) {
-            return {
-                success: false,
-                message: `delegate_arion failed: ${e.message}`,
-            };
-        }
-    },
-});
-/**
- * Spawn a lightweight worker to execute a focused task in parallel.
- * No memory or persona. Use for quick, isolated tasks.
- */
-const spawn_worker = tool({
-    name: "spawn_worker",
-    description: "Spawn a lightweight worker to execute a focused task in parallel. No memory or persona. Use for quick, isolated tasks. Use check_delegation to get results.",
-    parameters: z.object({
-        task: z.string().min(1).max(100_000).describe("The task for the worker"),
-        type: z
-            .enum(["worker", "cli_agent"])
-            .optional()
-            .default("worker")
-            .describe("Delegation type: lightweight worker (default) or external CLI agent"),
-        tools: z
-            .array(z
-            .string()
-            .min(1)
-            .max(100)
-            .regex(/^[a-z0-9_]+$/))
-            .max(100)
-            .optional()
-            .describe("Restrict worker to these tools only"),
-        tier: z
-            .enum(["fast", "balanced", "powerful", "ensemble"])
-            .optional()
-            .default("fast")
-            .describe("Model tier"),
-        driver: z
-            .string()
-            .regex(/^[a-z0-9-]+$/)
-            .max(50)
-            .optional()
-            .describe("CLI agent driver ID (for type='cli_agent', e.g. claude-code/codex)"),
-        workspace: z
-            .enum(["cwd", "tempdir", "worktree"])
-            .optional()
-            .describe("Workspace strategy for CLI agent delegation"),
-        model: z.string().max(200).optional().describe("CLI model override (for type='cli_agent')"),
-        resume: z.string().max(200).optional().describe("Resume from an existing CLI session ID"),
-        timeout: z
-            .number()
-            .int()
-            .min(1000)
-            .max(3_600_000)
-            .optional()
-            .describe("CLI delegation timeout in ms"),
-    }),
-    category: "meta",
-    riskLevel: "moderate",
-    isReadOnly: false,
-    loadingTier: "always",
-    execute: async (input, context) => {
-        if (!context.delegationExecutor) {
-            return {
-                success: false,
-                message: "spawn_worker: Delegation executor not available. Ensure RunSession is configured with delegation support.",
-            };
-        }
-        try {
-            if (input.type === "cli_agent") {
-                const id = await context.delegationExecutor.spawnCliAgent({
-                    task: input.task,
-                    driver: input.driver ?? "claude-code",
-                    workspace: input.workspace,
-                    model: input.model,
-                    resume: input.resume,
-                    timeout: input.timeout,
-                });
-                return {
-                    success: true,
-                    message: "CLI agent delegation started",
-                    data: { id },
-                };
-            }
-            const id = await context.delegationExecutor.spawnWorker(input.task, input.tools, input.tier);
-            return {
-                success: true,
-                message: `Worker ${id} spawned. Use check_delegation to monitor progress.`,
-                data: { id },
-            };
-        }
-        catch (e) {
-            return {
-                success: false,
-                message: `spawn_worker failed: ${e.message}`,
-            };
-        }
-    },
-});
-/**
- * Check the status of a delegated task or spawned worker.
- * Uses typed DelegationRegistryRef from ToolContext.
- */
-const check_delegation = tool({
-    name: "check_delegation",
-    description: "Check the status of a delegated task. The ID is always a quest_xxx ID. Returns the result when complete.",
-    parameters: z.object({
-        id: z
-            .string()
-            .regex(/^quest_[a-z0-9]{6,20}$/)
-            .max(50)
-            .describe("Quest ID (quest_xxx)"),
-        wait: z.boolean().optional().default(false).describe("Wait for completion instead of polling."),
-        timeout: z
-            .number()
-            .int()
-            .min(1000)
-            .max(3_600_000)
-            .optional()
-            .describe("Max wait time in ms when wait=true (default 300000)"),
-    }),
-    category: "meta",
-    riskLevel: "safe",
-    isReadOnly: true,
-    loadingTier: "always",
-    execute: async (input, context) => {
-        const registry = context.delegationRegistry;
-        if (!registry) {
-            return { success: false, message: "No delegation registry available" };
-        }
-        const entry = registry.get(input.id);
-        // If not in registry (evicted or process died), check quest store
-        if (!entry && context.questStore) {
-            const quest = context.questStore.getQuest(input.id);
-            if (quest) {
-                const questMessages = context.messageStore?.getByCorrelation(input.id) ?? [];
-                return {
-                    success: quest.status === "done" || quest.status === "active",
-                    message: quest.status === "done"
-                        ? quest.progress || "Quest completed"
-                        : quest.status === "blocked"
-                            ? quest.progress || "Quest blocked"
-                            : `Quest is ${quest.status}`,
-                    data: {
-                        id: quest.id,
-                        status: quest.status,
-                        progress: quest.progress,
-                        questMessages: questMessages.slice(-10),
-                    },
-                };
-            }
-        }
-        if (!entry) {
-            return { success: false, message: `Delegation not found: ${input.id}` };
-        }
-        if (input.wait && entry.status === "running") {
-            try {
-                const completed = await registry.await(input.id, input.timeout ?? 300_000);
-                return buildCheckResponse(completed, context);
-            }
-            catch (e) {
-                return { success: false, message: `Wait failed: ${e.message}` };
-            }
-        }
-        return buildCheckResponse(entry, context);
-    },
-});
-/** Build check_delegation response, enriching with quest store data when available. */
-function buildCheckResponse(entry, context) {
-    let questProgress;
-    let questMessages;
-    if (context.questStore) {
-        const quest = context.questStore.getQuest(entry.id);
-        if (quest)
-            questProgress = quest.progress;
-    }
-    if (context.messageStore) {
-        questMessages = context.messageStore.getByCorrelation(entry.id).slice(-10);
-    }
-    const isTerminalFailure = entry.status === "failed" || entry.status === "aborted";
-    return {
-        success: entry.status === "completed" || entry.status === "running",
-        message: entry.status === "completed"
-            ? (entry.result ?? "Delegation completed")
-            : isTerminalFailure
-                ? (entry.error ?? `Delegation ${entry.status}`)
-                : `Delegation is ${entry.status}`,
-        data: {
-            id: entry.id,
-            type: entry.type,
-            status: entry.status,
-            result: entry.result,
-            error: entry.error,
-            questProgress,
-            questMessages,
-            metadata: entry.metadata,
-        },
-    };
-}
-/**
- * Pause a running delegation.
- * The agent stops after the AbortController signals cancellation.
- * Can be resumed later with resume_delegation.
- */
-const pause_delegation = tool({
-    name: "pause_delegation",
-    description: "Pause a running delegation by terminating it. No in-flight state is preserved. Use resume_delegation to re-create the delegation with the original task.",
-    parameters: z.object({
-        id: z
-            .string()
-            .regex(/^quest_[a-z0-9]{6,20}$/)
-            .max(50)
-            .describe("Quest ID (quest_xxx) to pause"),
-        reason: z.string().max(1000).optional().describe("Reason for pausing"),
-    }),
-    category: "meta",
-    riskLevel: "moderate",
-    isReadOnly: false,
-    loadingTier: "always",
-    execute: async (input, context) => {
-        const registry = context.delegationRegistry;
-        if (!registry) {
-            return { success: false, message: "No delegation registry available" };
-        }
-        const entry = registry.get(input.id);
-        if (!entry) {
-            return { success: false, message: `Delegation not found: ${input.id}` };
-        }
-        if (entry.status !== "running") {
-            return {
-                success: false,
-                message: `Cannot pause — delegation is ${entry.status}`,
-            };
-        }
-        registry.abort(input.id);
-        // Sync quest store so check_delegation's fallback path sees "blocked" after registry eviction
-        if (context.questStore) {
-            try {
-                context.questStore.updateQuest(input.id, {
-                    status: "blocked",
-                    progress: input.reason ?? "Paused by user",
-                });
-            }
-            catch {
-                // Non-fatal — registry is authoritative while process lives
-            }
-        }
-        return {
-            success: true,
-            message: `Delegation ${input.id} aborted${input.reason ? `: ${input.reason}` : ""}. Use resume_delegation to re-create with the original task.`,
-            data: { id: input.id, status: "aborted" },
-        };
-    },
-});
-/**
- * Resume a paused delegation from where it stopped.
- * Creates a new delegation that continues the original task.
- */
-const resume_delegation = tool({
-    name: "resume_delegation",
-    description: "Resume a paused delegation by creating a new delegation with the original task. Does not restore in-flight state — the agent starts fresh with the original task description.",
-    parameters: z.object({
-        id: z
-            .string()
-            .regex(/^quest_[a-z0-9]{6,20}$/)
-            .max(50)
-            .describe("Quest ID (quest_xxx) to resume"),
-        additionalContext: z
-            .string()
-            .max(50_000)
-            .optional()
-            .describe("Additional context or instructions for the resumed agent"),
-    }),
-    category: "meta",
-    riskLevel: "moderate",
-    isReadOnly: false,
-    loadingTier: "always",
-    execute: async (input, context) => {
-        const executor = context.delegationExecutor;
-        if (!executor) {
-            return {
-                success: false,
-                message: "Delegation executor not available",
-            };
-        }
-        const registry = context.delegationRegistry;
-        if (!registry) {
-            return { success: false, message: "No delegation registry available" };
-        }
-        const entry = registry.get(input.id);
-        if (!entry) {
-            return { success: false, message: `Delegation not found: ${input.id}` };
-        }
-        if (entry.status === "running") {
-            return {
-                success: false,
-                message: `Cannot resume — delegation ${input.id} is still running. Use pause_delegation first.`,
-            };
-        }
-        // Build a continuation task from the original task + optional additional context
-        const task = input.additionalContext
-            ? `Continue the previous task: ${entry.task}\n\nAdditional context: ${input.additionalContext}`
-            : `Continue the previous task: ${entry.task}`;
-        try {
-            let newId;
-            if (entry.type === "arion" && entry.arionName) {
-                newId = await executor.delegateToArion(entry.arionName, task);
-            }
-            else if (entry.type === "cli_agent") {
-                if (entry.metadata?.driver) {
-                    newId = await executor.spawnCliAgent({
-                        task,
-                        driver: entry.metadata.driver,
-                        workspace: entry.metadata.workspace,
-                        model: entry.metadata.model,
-                    });
-                }
-                else {
-                    return {
-                        success: false,
-                        message: "Cannot resume CLI agent delegation — original driver metadata not preserved. Use spawn_worker with type='cli_agent' instead.",
-                    };
-                }
-            }
-            else {
-                newId = await executor.spawnWorker(task);
-            }
-            return {
-                success: true,
-                message: `Delegation resumed as ${newId}. Original: ${input.id}`,
-                data: { originalId: input.id, newId, type: entry.type },
-            };
-        }
-        catch (e) {
-            return {
-                success: false,
-                message: `Resume failed: ${e.message}`,
-            };
-        }
-    },
-});
-/**
- * Delegate a task to a remote ARIA node connected via WireGuard tunnel.
- * The remote node receives the task as a quest message and executes it independently.
- * Results come back via quest completion messages through the tunnel.
- */
-const delegate_remote = tool({
-    name: "delegate_remote",
-    description: "Delegate a task to a remote ARIA node connected via WireGuard tunnel. The node executes the task independently. Use check_delegation to get results.",
-    parameters: z.object({
-        node_id: NodeIdSchema.describe("Durable remote node id to delegate to"),
-        task: z.string().min(1).max(100_000).describe("Task description for the remote node"),
-        tier: z
-            .enum(["fast", "balanced", "powerful"])
-            .optional()
-            .describe("Model tier for the remote execution"),
-    }),
-    category: "messaging",
-    riskLevel: "moderate",
-    isReadOnly: false,
-    loadingTier: "always",
-    execute: async (input, context) => {
-        if (!context.delegationExecutor?.delegateToRemote) {
-            return {
-                success: false,
-                message: "delegate_remote: Remote delegation not available — no delegateToRemote configured. Ensure mailbox and network are wired.",
-            };
-        }
-        try {
-            const id = await context.delegationExecutor.delegateToRemote(NodeIdSchema.parse(input.node_id), input.task, input.tier);
-            return {
-                success: true,
-                message: `Remote delegation ${id} sent to node "${input.node_id}". Use check_delegation to monitor progress.`,
-                data: { id, nodeId: input.node_id },
-            };
-        }
-        catch (e) {
-            return {
-                success: false,
-                message: `delegate_remote failed: ${e.message}`,
-            };
-        }
-    },
-});
-/**
- * View the structured completion report for a finished quest.
- * Parses the JSON progress field to surface commits, files changed, commands run, and cost.
- */
-const quest_report = tool({
-    name: "quest_report",
-    description: "View the structured completion report for a finished quest, including commits, files changed, commands run, and cost",
-    parameters: z.object({
-        quest_id: z.string().min(1).max(100).describe("Quest ID to view report for"),
-    }),
-    category: "meta",
-    riskLevel: "safe",
-    isReadOnly: true,
-    loadingTier: "always",
-    execute: async (input, context) => {
-        const questId = input.quest_id;
-        if (!context.questStore) {
-            return { success: false, message: "Quest store not available" };
-        }
-        const quest = context.questStore.getQuest(questId);
-        if (!quest) {
-            return { success: false, message: `Quest not found: ${questId}` };
-        }
-        if (quest.status !== "done") {
-            return {
-                success: true,
-                message: `Quest not yet completed (status: ${quest.status})`,
-                data: { questId, status: quest.status },
-            };
-        }
-        // Try to parse structured progress JSON
-        try {
-            const report = JSON.parse(quest.progress);
-            return {
-                success: true,
-                message: "Quest completion report",
-                data: {
-                    questId,
-                    title: quest.title,
-                    status: quest.status,
-                    report: {
-                        summary: report.summary ?? quest.progress.slice(0, 500),
-                        commits: report.commits ?? [],
-                        filesChanged: report.filesChanged ?? [],
-                        commandsRun: report.commandsRun ?? [],
-                        toolsUsed: report.toolsUsed ?? [],
-                        turnCount: report.turnCount ?? 0,
-                        tokensUsed: report.tokensUsed ?? 0,
-                        costUsd: report.costUsd ?? 0,
-                    },
-                },
-            };
-        }
-        catch {
-            // Progress is plain text, not structured JSON
-            return {
-                success: true,
-                message: "Quest completion report (plain text)",
-                data: {
-                    questId,
-                    title: quest.title,
-                    status: quest.status,
-                    report: {
-                        summary: quest.progress,
-                        commits: [],
-                        filesChanged: [],
-                        commandsRun: [],
-                    },
-                },
-            };
-        }
-    },
-});
-/** Delegation tool definitions (7) */
-export const DELEGATION_TOOL_DEFINITIONS = [
-    delegate_arion,
-    spawn_worker,
-    check_delegation,
-    pause_delegation,
-    resume_delegation,
-    delegate_remote,
-    quest_report,
-];

package/dist/definitions/deploy.js

@@ -1,65 +0,0 @@
-/**
- * Deploy tool definition.
- *
- * Tools: deploy (1 tool)
- *
- * Deploys ARIA to a remote machine via SSH. Detects OS, installs Node.js + pnpm,
- * clones/syncs repo, builds, sets up TLS certs, configures firewall, writes config,
- * and starts the daemon.
- *
- * Safety: requires explicit user confirmation (dangerous risk level).
- * Auto-denied in daemon autorun mode.
- */
-import { executeDeploy } from "../executors/index.js";
-const deploy = {
-    name: "deploy",
-    description: "Deploy ARIA to a remote machine via SSH. Detects OS, installs Node.js + pnpm, " +
-        "clones/syncs repo, builds, discovers/provisions TLS certs, opens firewall ports, " +
-        "configures ~/.aria, and starts the daemon. Returns host, port, fingerprint, and TLS type.",
-    category: "arion",
-    parameters: {
-        type: "object",
-        properties: {
-            target: {
-                type: "string",
-                description: "SSH target (e.g. 'claude@10.0.0.1' or 'hostname')",
-            },
-            repo_url: {
-                type: "string",
-                description: "Git repo URL (default: current repo origin)",
-            },
-            branch: {
-                type: "string",
-                description: "Branch to deploy (default: main)",
-            },
-            arion_name: {
-                type: "string",
-                description: "Arion identity name (default: hostname of target)",
-            },
-            coordination_url: {
-                type: "string",
-                description: "Coordination server URL for mesh registration",
-            },
-            ssh_key_path: {
-                type: "string",
-                description: "Path to SSH private key (default: ~/.ssh/id_ed25519)",
-            },
-            commit_hash: {
-                type: "string",
-                description: "Git commit hash to checkout after clone (pins exact code version, prevents MITM on branch refs)",
-            },
-            verify_signatures: {
-                type: "boolean",
-                description: "Verify GPG signature on HEAD commit after checkout. Fails deploy if signature is invalid or missing.",
-            },
-        },
-        required: ["target"],
-    },
-    riskLevel: "dangerous",
-    requiresConfirmation: true,
-    isReadOnly: false,
-    loadingTier: "always",
-    execute: executeDeploy,
-};
-/** Deploy tool definitions (1) */
-export const DEPLOY_TOOL_DEFINITIONS = [deploy];