@mecha.im/cli 0.3.4

package/agent/tools/mecha-fleet.ts

@@ -0,0 +1,176 @@
+/**
+ * Fleet management MCP tools for orchestrator bots.
+ * Only registered when config.permissions.fleet_control is true.
+ * All operations proxy to the daemon's /api/fleet/* endpoints.
+ */
+
+import { tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+
+const FLEET_URL = process.env.MECHA_FLEET_URL;
+const FLEET_SECRET = process.env.MECHA_FLEET_INTERNAL_SECRET;
+const BOT_NAME = process.env.MECHA_BOT_NAME;
+
+// Rate limiting (in-memory, best-effort)
+let spawnCount = 0;
+let opsCount = 0;
+let lastReset = Date.now();
+const MAX_SPAWNS_PER_HOUR = 5;
+const MAX_OPS_PER_HOUR = 20;
+
+function checkRateLimit(isSpawn: boolean): string | null {
+  const now = Date.now();
+  if (now - lastReset > 3600_000) { spawnCount = 0; opsCount = 0; lastReset = now; }
+  opsCount++;
+  if (isSpawn) spawnCount++;
+  if (spawnCount > MAX_SPAWNS_PER_HOUR) return `Spawn rate limit exceeded (max ${MAX_SPAWNS_PER_HOUR}/hour)`;
+  if (opsCount > MAX_OPS_PER_HOUR) return `Fleet operation rate limit exceeded (max ${MAX_OPS_PER_HOUR}/hour)`;
+  return null;
+}
+
+async function fleetApi(path: string, method = "GET", body?: unknown): Promise<unknown> {
+  if (!FLEET_URL || !FLEET_SECRET) throw new Error("Fleet API not configured (MECHA_FLEET_URL not set)");
+  const headers: Record<string, string> = { "Authorization": `Bearer ${FLEET_SECRET}` };
+  if (body) headers["Content-Type"] = "application/json";
+  const resp = await fetch(`${FLEET_URL}/api/fleet${path}`, {
+    method, headers,
+    body: body ? JSON.stringify(body) : undefined,
+    signal: AbortSignal.timeout(30_000),
+  });
+  const text = await resp.text();
+  if (!resp.ok) throw new Error(`Fleet API error ${resp.status}: ${text}`);
+  try { return JSON.parse(text); } catch { return text; }
+}
+
+function textResult(data: unknown): { content: Array<{ type: "text"; text: string }> } {
+  return { content: [{ type: "text" as const, text: typeof data === "string" ? data : JSON.stringify(data, null, 2) }] };
+}
+
+export function createFleetTools() {
+  return [
+    tool(
+      "mecha_fleet_ls",
+      "List all bots in the fleet with status, model, uptime, and cost.",
+      {},
+      async () => {
+        const limit = checkRateLimit(false);
+        if (limit) return textResult({ error: limit });
+        const data = await fleetApi("/bots");
+        return textResult(data);
+      },
+    ),
+
+    tool(
+      "mecha_fleet_spawn",
+      "Spawn a new bot in the fleet.",
+      {
+        name: z.string().min(1).max(32).describe("Bot name"),
+        system: z.string().min(1).describe("System prompt"),
+        model: z.string().optional().describe("Model (default: sonnet)"),
+        auth: z.string().optional().describe("Auth profile name"),
+      },
+      async (args) => {
+        const limit = checkRateLimit(true);
+        if (limit) return textResult({ error: limit });
+        const data = await fleetApi("/bots", "POST", args);
+        return textResult(data);
+      },
+    ),
+
+    tool(
+      "mecha_fleet_stop",
+      "Stop a running bot.",
+      { name: z.string().min(1).max(32).describe("Bot name to stop") },
+      async (args) => {
+        if (args.name === BOT_NAME) return textResult({ error: "Cannot stop self" });
+        const limit = checkRateLimit(false);
+        if (limit) return textResult({ error: limit });
+        const data = await fleetApi(`/bots/${encodeURIComponent(args.name)}/stop`, "POST");
+        return textResult(data);
+      },
+    ),
+
+    tool(
+      "mecha_fleet_start",
+      "Start a stopped bot.",
+      { name: z.string().min(1).max(32).describe("Bot name to start") },
+      async (args) => {
+        const limit = checkRateLimit(false);
+        if (limit) return textResult({ error: limit });
+        const data = await fleetApi(`/bots/${encodeURIComponent(args.name)}/start`, "POST");
+        return textResult(data);
+      },
+    ),
+
+    tool(
+      "mecha_fleet_restart",
+      "Restart a running bot.",
+      { name: z.string().min(1).max(32).describe("Bot name to restart") },
+      async (args) => {
+        if (args.name === BOT_NAME) return textResult({ error: "Cannot restart self" });
+        const limit = checkRateLimit(false);
+        if (limit) return textResult({ error: limit });
+        const data = await fleetApi(`/bots/${encodeURIComponent(args.name)}/restart`, "POST");
+        return textResult(data);
+      },
+    ),
+
+    tool(
+      "mecha_fleet_rm",
+      "Remove a bot from the fleet (stops and deletes).",
+      { name: z.string().min(1).max(32).describe("Bot name to remove") },
+      async (args) => {
+        if (args.name === BOT_NAME) return textResult({ error: "Cannot remove self" });
+        const limit = checkRateLimit(false);
+        if (limit) return textResult({ error: limit });
+        const data = await fleetApi(`/bots/${encodeURIComponent(args.name)}`, "DELETE");
+        return textResult(data);
+      },
+    ),
+
+    tool(
+      "mecha_fleet_costs",
+      "Get cost breakdown for the fleet or a specific bot.",
+      {
+        name: z.string().optional().describe("Bot name (omit for fleet total)"),
+        period: z.enum(["today", "week", "month"]).optional().describe("Time period"),
+      },
+      async (args) => {
+        const limit = checkRateLimit(false);
+        if (limit) return textResult({ error: limit });
+        const path = args.name ? `/costs/${encodeURIComponent(args.name)}` : "/costs";
+        const query = args.period ? `?period=${args.period}` : "";
+        const data = await fleetApi(`${path}${query}`);
+        return textResult(data);
+      },
+    ),
+
+    tool(
+      "mecha_fleet_config",
+      "View a bot's configuration (read-only).",
+      {
+        name: z.string().min(1).max(32).describe("Bot name"),
+        field: z.string().optional().describe("Specific field to retrieve"),
+      },
+      async (args) => {
+        const limit = checkRateLimit(false);
+        if (limit) return textResult({ error: limit });
+        const query = args.field ? `?field=${encodeURIComponent(args.field)}` : "";
+        const data = await fleetApi(`/bots/${encodeURIComponent(args.name)}/config${query}`);
+        return textResult(data);
+      },
+    ),
+
+    tool(
+      "mecha_fleet_status",
+      "Get fleet health summary (running bots, costs, version).",
+      {},
+      async () => {
+        const limit = checkRateLimit(false);
+        if (limit) return textResult({ error: limit });
+        const data = await fleetApi("/health");
+        return textResult(data);
+      },
+    ),
+  ];
+}

package/agent/tools/mecha-list.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { isValidUrl } from "../../shared/validation.js";
+
+const headscaleResponseSchema = z.object({
+  machines: z.array(z.object({
+    name: z.string(),
+    ipAddresses: z.array(z.string()).default([]),
+    online: z.boolean().default(false),
+    forcedTags: z.array(z.string()).optional(),
+  })),
+});
+
+export async function listBots(): Promise<Array<{
+  name: string;
+  ip: string;
+  status: string;
+}>> {
+  const headscaleUrl = process.env.MECHA_HEADSCALE_URL;
+  const headscaleApiKey = process.env.MECHA_HEADSCALE_API_KEY;
+
+  if (!headscaleUrl || !headscaleApiKey) {
+    return [{ name: "(unknown)", ip: "(no headscale)", status: "error: MECHA_HEADSCALE_URL and MECHA_HEADSCALE_API_KEY required" }];
+  }
+
+  if (!isValidUrl(headscaleUrl)) {
+    return [{ name: "(error)", ip: "", status: "error: MECHA_HEADSCALE_URL is not a valid http(s) URL" }];
+  }
+
+  try {
+    const resp = await fetch(`${headscaleUrl}/api/v1/machine`, {
+      headers: { Authorization: `Bearer ${headscaleApiKey}` },
+      signal: AbortSignal.timeout(10_000),
+    });
+
+    if (!resp.ok) {
+      return [{ name: "(error)", ip: "", status: `Headscale API returned ${resp.status}` }];
+    }
+
+    const raw = await resp.json();
+    const parsed = headscaleResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      return [{ name: "(error)", ip: "", status: "Headscale API returned unexpected response shape" }];
+    }
+
+    return parsed.data.machines
+      .filter((m) => m.forcedTags?.includes("tag:mecha-bot") || m.name.startsWith("mecha-"))
+      .map((m) => ({
+        name: m.name.replace(/^mecha-/, ""),
+        ip: m.ipAddresses[0] ?? "",
+        status: m.online ? "online" : "offline",
+      }));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [{ name: "(error)", ip: "", status: `Headscale unavailable: ${msg}` }];
+  }
+}

package/agent/tools/mecha-server.ts

@@ -0,0 +1,70 @@
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+import type { SessionManager } from "../session.js";
+import type { BotConfig } from "../types.js";
+import { callBot } from "./mecha-call.js";
+import { listBots } from "./mecha-list.js";
+import { createFleetTools } from "./mecha-fleet.js";
+
+export function createMechaToolServer(sessionManager: SessionManager, config?: BotConfig) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const tools: any[] = [
+    tool(
+      "mecha_new_session",
+      "Start a new task/session. Call this when you want to begin a fresh conversation or when the current task is complete.",
+      { summary: z.string().optional().describe("Summary of the completed task") },
+      async (args) => {
+        const { newTask, previousTask } = sessionManager.newSession(args.summary);
+        return {
+          content: [{
+            type: "text" as const,
+            text: JSON.stringify({
+              new_task_id: newTask.id,
+              previous_task: previousTask
+                ? { id: previousTask.id, summary: previousTask.summary, status: "completed" }
+                : null,
+            }),
+          }],
+        };
+      },
+    ),
+
+    tool(
+      "mecha_call",
+      "Call another mecha bot on the network and get its response. Use this to delegate tasks or ask questions to other specialized bots.",
+      {
+        bot: z.string().min(1).max(32).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/).describe("Target bot name"),
+        message: z.string().min(1).max(50_000).describe("Message to send to the bot"),
+      },
+      async (args) => {
+        const response = await callBot(args.bot, args.message);
+        return {
+          content: [{ type: "text" as const, text: response }],
+        };
+      },
+    ),
+
+    tool(
+      "mecha_list",
+      "List available mecha bots on the network. Shows bot names, IPs, and online status.",
+      {},
+      async () => {
+        const bots = await listBots();
+        return {
+          content: [{ type: "text" as const, text: JSON.stringify(bots, null, 2) }],
+        };
+      },
+    ),
+  ];
+
+  // Register fleet tools only for orchestrator bots with fleet_control permission
+  if (config?.permissions?.fleet_control) {
+    tools.push(...createFleetTools());
+  }
+
+  return createSdkMcpServer({
+    name: "mecha-tools",
+    version: "1.0.0",
+    tools,
+  });
+}

package/agent/types.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+
+const VALID_CRON = /^(\S+\s+){4}\S+$/;
+
+export const botConfigSchema = z.object({
+  name: z.string().min(1).max(32),
+  system: z.string().min(1),
+  model: z.string().default("sonnet"),
+  auth: z.string().optional(),
+  max_turns: z.number().int().min(1).max(100).default(25),
+  max_budget_usd: z.number().positive().optional(),
+  permission_mode: z.enum(["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk"]).default("default"),
+  schedule: z.array(z.object({
+    cron: z.string().refine((s) => VALID_CRON.test(s), { message: "Invalid cron expression (expected 5 fields)" }),
+    prompt: z.string().min(1).max(10_000),
+  })).optional(),
+  webhooks: z.object({
+    accept: z.array(z.string()),
+    secret: z.string().optional(),
+  }).optional(),
+  permissions: z.object({
+    fleet_control: z.boolean().default(false),
+  }).optional(),
+  workspace: z.string().optional(),
+  workspace_writable: z.boolean().default(false),
+  expose: z.number().int().min(1).max(65535).optional(),
+  tailscale: z.object({
+    auth_key_profile: z.string().optional(),
+    auth_key: z.string().optional(),
+    login_server: z.string().optional(),
+    tags: z.array(z.string()).default(["tag:mecha-bot"]),
+  }).optional(),
+});
+
+export type BotConfig = z.infer<typeof botConfigSchema>;

package/agent/webhook.ts

@@ -0,0 +1,127 @@
+import { Hono } from "hono";
+import type { Context } from "hono";
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { log } from "../shared/logger.js";
+import type { BotConfig } from "./types.js";
+
+export type WebhookHandler = (prompt: string) => Promise<boolean>;
+
+const MAX_PAYLOAD_BYTES = 100_000;
+
+function safeExtractPayload(body: Record<string, unknown>): Record<string, unknown> {
+  const { installation, sender, repository, ...rest } = body;
+  const safe: Record<string, unknown> = { ...rest };
+  if (repository && typeof repository === "object") {
+    const repo = repository as Record<string, unknown>;
+    safe.repository = { full_name: repo.full_name, html_url: repo.html_url };
+  }
+  if (sender && typeof sender === "object") {
+    const s = sender as Record<string, unknown>;
+    safe.sender = { login: s.login };
+  }
+  return safe;
+}
+
+export interface WebhookState {
+  accept: string[];
+  secret: string | undefined;
+}
+
+export function createWebhookRoutes(
+  config: BotConfig,
+  handler: WebhookHandler,
+  isBusy: () => boolean,
+): { app: Hono; state: WebhookState } {
+  const app = new Hono();
+  const state: WebhookState = {
+    accept: [...(config.webhooks?.accept ?? [])],
+    secret: config.webhooks?.secret,
+  };
+
+  if (!state.secret) {
+    log.warn("Webhook secret not configured — payloads will be accepted without signature verification. Set webhooks.secret for production use.");
+  }
+
+  app.post("/webhook", async (c) => {
+    // Payload size limit (check header as hint, enforce on body)
+    const contentLength = parseInt(c.req.header("content-length") ?? "0", 10);
+    if (contentLength > MAX_PAYLOAD_BYTES) {
+      return c.json({ error: "Payload too large" }, 413);
+    }
+
+    // Read secret from state each request (supports runtime updates)
+    const currentSecret = state.secret;
+
+    // Webhook signature verification (GitHub HMAC)
+    if (currentSecret) {
+      const signature = c.req.header("x-hub-signature-256");
+      if (!signature) {
+        return c.json({ error: "Missing signature" }, 401);
+      }
+      const body = await c.req.text();
+      if (Buffer.byteLength(body, "utf8") > MAX_PAYLOAD_BYTES) {
+        return c.json({ error: "Payload too large" }, 413);
+      }
+      const expected = "sha256=" + createHmac("sha256", currentSecret).update(body).digest("hex");
+      const sigBuf = Buffer.from(signature);
+      const expBuf = Buffer.from(expected);
+      if (sigBuf.length !== expBuf.length || !timingSafeEqual(sigBuf, expBuf)) {
+        return c.json({ error: "Invalid signature" }, 401);
+      }
+      let parsed: Record<string, unknown>;
+      try {
+        parsed = JSON.parse(body);
+      } catch {
+        return c.json({ error: "Invalid JSON" }, 400);
+      }
+      return handlePayload(c, parsed);
+    }
+
+    // Enforce size limit even without HMAC secret
+    const rawBody = await c.req.text();
+    if (Buffer.byteLength(rawBody, "utf8") > MAX_PAYLOAD_BYTES) {
+      return c.json({ error: "Payload too large" }, 413);
+    }
+    let body: Record<string, unknown>;
+    try {
+      body = JSON.parse(rawBody);
+    } catch {
+      return c.json({ error: "Invalid JSON" }, 400);
+    }
+    return handlePayload(c, body);
+  });
+
+  async function handlePayload(c: Context, body: Record<string, unknown>) {
+    // Extract event type
+    let eventType: string;
+    const githubEvent = c.req.header("x-github-event");
+    if (githubEvent) {
+      const action = (body.action as string) ?? "";
+      eventType = action ? `${githubEvent}.${action}` : githubEvent;
+    } else {
+      eventType = (body.type as string) ?? "unknown";
+    }
+
+    // Check allowlist
+    if (!state.accept.includes(eventType)) {
+      return c.body(null, 204); // silently drop
+    }
+
+    // Busy check
+    if (isBusy()) {
+      c.header("Retry-After", "60");
+      return c.json({ error: "Bot is busy" }, 429);
+    }
+
+    // Forward to handler with redacted payload
+    const safePayload = safeExtractPayload(body);
+    const prompt = `Webhook event: ${eventType}\n\nPayload:\n${JSON.stringify(safePayload, null, 2)}`;
+    const accepted = await handler(prompt);
+    if (accepted) {
+      return c.json({ status: "accepted", event: eventType });
+    }
+    return c.json({ error: "Handler rejected" }, 500);
+  }
+
+  return { app, state };
+}

package/agent/ws-terminal.ts

@@ -0,0 +1,174 @@
+import { WebSocketServer, WebSocket } from "ws";
+import type { IncomingMessage } from "node:http";
+import type { Server as HttpServer } from "node:http";
+import { createHmac, timingSafeEqual } from "node:crypto";
+import type { PtyManager } from "./pty-manager.js";
+import { log } from "../shared/logger.js";
+
+const BACKPRESSURE_LIMIT = 1_048_576; // 1 MB
+const PING_INTERVAL_MS = 30_000;
+const SESSION_ID_RE = /^[a-zA-Z0-9_-]+$/;
+
+function makeSessionToken(botToken: string): string {
+  return createHmac("sha256", botToken).update("mecha-dashboard-session").digest("hex");
+}
+
+/** Verify session cookie from WebSocket upgrade request. */
+function verifyAuth(req: IncomingMessage, botToken: string): boolean {
+  const cookie = req.headers.cookie;
+  if (!cookie) return false;
+  const match = cookie.match(/mecha_session=([^;]+)/);
+  if (!match) return false;
+  const expected = makeSessionToken(botToken);
+  const received = Buffer.from(match[1]);
+  const expectedBuf = Buffer.from(expected);
+  return received.length === expectedBuf.length && timingSafeEqual(received, expectedBuf);
+}
+
+/** Attach WebSocket terminal server to an HTTP server. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function attachTerminalWs(
+  httpServer: any,
+  ptyManager: PtyManager,
+  botToken: string,
+): void {
+  const wss = new WebSocketServer({ noServer: true });
+
+  httpServer.on("upgrade", (req: IncomingMessage, socket: import("node:stream").Duplex, head: Buffer) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+
+    // Only handle /ws/terminal path
+    if (!url.pathname.startsWith("/ws/terminal")) {
+      socket.destroy();
+      return;
+    }
+
+    // Auth check
+    if (!verifyAuth(req, botToken)) {
+      socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+      socket.destroy();
+      return;
+    }
+
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      wss.emit("connection", ws, req);
+    });
+  });
+
+  wss.on("connection", (ws: WebSocket, req: IncomingMessage) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    let sessionId = url.searchParams.get("session") ?? undefined;
+    const initCols = Number(url.searchParams.get("cols")) || 80;
+    const initRows = Number(url.searchParams.get("rows")) || 24;
+
+    // Validate session ID format
+    if (sessionId && !SESSION_ID_RE.test(sessionId)) {
+      ws.send(JSON.stringify({ __mecha: true, type: "error", message: `Invalid session ID: ${sessionId}` }));
+      ws.close(4400, "Invalid session ID");
+      return;
+    }
+
+    // Look up existing PTY session
+    let session = sessionId ? ptyManager.getSession(sessionId) : null;
+
+    try {
+      if (session) {
+        const attached = ptyManager.attach(session.id, ws);
+        if (!attached) {
+          session = ptyManager.spawn(sessionId, initCols, initRows);
+          ptyManager.attach(session.id, ws);
+        }
+      } else {
+        session = ptyManager.spawn(sessionId, initCols, initRows);
+        ptyManager.attach(session.id, ws);
+      }
+    } catch (err) {
+      ws.send(JSON.stringify({
+        __mecha: true,
+        type: "error",
+        message: err instanceof Error ? err.message : String(err),
+      }));
+      ws.close(4500, "Spawn failed");
+      return;
+    }
+
+    const sessionKey = session.id;
+    log.info(`Terminal WS connected: session=${sessionKey}`);
+
+    function safeSend(data: string): void {
+      if (ws.readyState !== WebSocket.OPEN) return;
+      try { ws.send(data); } catch { /* socket closing */ }
+    }
+
+    // Send session ID so client can use it for resume
+    safeSend(JSON.stringify({ __mecha: true, type: "session", id: session.claudeSessionId }));
+
+    // Replay scrollback
+    if (session.scrollback.length > 0) {
+      for (const chunk of session.scrollback) {
+        safeSend(chunk);
+      }
+      safeSend("\r\n\x1b[2m--- reconnected ---\x1b[0m\r\n");
+    }
+
+    // PTY output → WS (text frames to avoid UTF-8 fragmentation issues)
+    const dataDisposable = session.pty.onData((data) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        if (ws.bufferedAmount > BACKPRESSURE_LIMIT) return;
+        safeSend(data);
+      }
+    });
+
+    // PTY exit → WS
+    const exitDisposable = session.pty.onExit(({ exitCode }) => {
+      if (ws.readyState !== WebSocket.OPEN) return;
+      safeSend(JSON.stringify({ __mecha: true, type: "exit", code: exitCode }));
+      ws.close(1000, "PTY exited");
+    });
+
+    // WS → PTY
+    ws.on("message", (data: Buffer, isBinary: boolean) => {
+      const s = ptyManager.getSession(sessionKey);
+      if (!s) return;
+
+      const str = data.toString();
+
+      if (!isBinary) {
+        try {
+          const msg = JSON.parse(str) as { type: string; cols?: number; rows?: number };
+          if (msg.type === "resize" && typeof msg.cols === "number" && typeof msg.rows === "number") {
+            ptyManager.resize(sessionKey, msg.cols, msg.rows);
+            return;
+          }
+        } catch {
+          // Not JSON — treat as PTY input
+        }
+      }
+      s.pty.write(str);
+    });
+
+    // Heartbeat
+    let isAlive = true;
+    ws.on("pong", () => { isAlive = true; });
+    const pingTimer = setInterval(() => {
+      if (!isAlive) { ws.terminate(); return; }
+      isAlive = false;
+      if (ws.readyState === WebSocket.OPEN) ws.ping();
+    }, PING_INTERVAL_MS);
+
+    ws.on("error", () => {
+      clearInterval(pingTimer);
+      ptyManager.detach(sessionKey, ws);
+      dataDisposable.dispose();
+      exitDisposable.dispose();
+    });
+
+    ws.on("close", () => {
+      log.info(`Terminal WS disconnected: session=${sessionKey}`);
+      clearInterval(pingTimer);
+      ptyManager.detach(sessionKey, ws);
+      dataDisposable.dispose();
+      exitDisposable.dispose();
+    });
+  });
+}

package/dist/agent/activity.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from "node:events";
+export type ActivityState = "idle" | "thinking" | "calling" | "scheduled" | "webhook" | "error";
+export declare class ActivityTracker extends EventEmitter {
+    private state;
+    private talkingTo;
+    private lastActive;
+    getState(): ActivityState;
+    getTalkingTo(): string | null;
+    getLastActive(): string | null;
+    transition(newState: ActivityState, meta?: {
+        talkingTo?: string;
+    }): void;
+}
+//# sourceMappingURL=activity.d.ts.map

package/dist/agent/activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.d.ts","sourceRoot":"","sources":["../../agent/activity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,UAAU,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAEhG,qBAAa,eAAgB,SAAQ,YAAY;IAC/C,OAAO,CAAC,KAAK,CAAyB;IACtC,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,UAAU,CAAuB;IAEzC,QAAQ,IAAI,aAAa;IAIzB,YAAY,IAAI,MAAM,GAAG,IAAI;IAI7B,aAAa,IAAI,MAAM,GAAG,IAAI;IAI9B,UAAU,CAAC,QAAQ,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;CASzE"}

package/dist/agent/activity.js

@@ -0,0 +1,25 @@
+import { EventEmitter } from "node:events";
+export class ActivityTracker extends EventEmitter {
+    state = "idle";
+    talkingTo = null;
+    lastActive = null;
+    getState() {
+        return this.state;
+    }
+    getTalkingTo() {
+        return this.talkingTo;
+    }
+    getLastActive() {
+        return this.lastActive;
+    }
+    transition(newState, meta) {
+        const prev = this.state;
+        this.state = newState;
+        this.talkingTo = meta?.talkingTo ?? null;
+        if (newState !== "idle") {
+            this.lastActive = new Date().toISOString();
+        }
+        this.emit("change", { prev, state: newState, talkingTo: this.talkingTo });
+    }
+}
+//# sourceMappingURL=activity.js.map

package/dist/agent/activity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.js","sourceRoot":"","sources":["../../agent/activity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3C,MAAM,OAAO,eAAgB,SAAQ,YAAY;IACvC,KAAK,GAAkB,MAAM,CAAC;IAC9B,SAAS,GAAkB,IAAI,CAAC;IAChC,UAAU,GAAkB,IAAI,CAAC;IAEzC,QAAQ;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,aAAa;QACX,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED,UAAU,CAAC,QAAuB,EAAE,IAA6B;QAC/D,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC;QACxB,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC;QACtB,IAAI,CAAC,SAAS,GAAG,IAAI,EAAE,SAAS,IAAI,IAAI,CAAC;QACzC,IAAI,QAAQ,KAAK,MAAM,EAAE,CAAC;YACxB,IAAI,CAAC,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAC7C,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;IAC5E,CAAC;CACF"}