pretticlaw 0.1.0

package/src/agent/tools/shell.ts

@@ -0,0 +1,69 @@
+import { exec } from "node:child_process";
+import path from "node:path";
+import { promisify } from "node:util";
+import { Tool } from "./base.js";
+
+const execAsync = promisify(exec);
+
+export class ExecTool extends Tool {
+  readonly name = "exec";
+  readonly description = "Execute a shell command and return its output. Use with caution.";
+  readonly parameters = {
+    type: "object",
+    properties: {
+      command: { type: "string", description: "The shell command to execute" },
+      working_dir: { type: "string", description: "Optional working directory for the command" },
+    },
+    required: ["command"],
+  };
+
+  constructor(
+    private readonly timeout = 60,
+    private readonly workingDir?: string,
+    private readonly restrictToWorkspace = false,
+    private readonly pathAppend = "",
+  ) { super(); }
+
+  private guard(command: string, cwd: string): string | null {
+    const lower = command.toLowerCase();
+    const deny = [/\brm\s+-[rf]{1,2}\b/, /\bdel\s+\/[fq]\b/, /\brmdir\s+\/s\b/, /(?:^|[;&|]\s*)format\b/, /\b(mkfs|diskpart)\b/, /\bdd\s+if=/, />\s*\/dev\/sd/, /\b(shutdown|reboot|poweroff)\b/, /:\(\)\s*\{.*\};\s*:/];
+    if (deny.some((r) => r.test(lower))) return "Error: Command blocked by safety guard (dangerous pattern detected)";
+    if (this.restrictToWorkspace) {
+      if (command.includes("../") || command.includes("..\\")) return "Error: Command blocked by safety guard (path traversal detected)";
+      const abs = command.match(/[A-Za-z]:\\[^\s"']+/g) ?? [];
+      for (const raw of abs) {
+        const p = path.resolve(raw);
+        const c = path.resolve(cwd);
+        if (!p.startsWith(c)) return "Error: Command blocked by safety guard (path outside working dir)";
+      }
+    }
+    return null;
+  }
+
+  async execute(args: Record<string, unknown>): Promise<string> {
+    const command = String(args.command ?? "");
+    const cwd = String(args.working_dir ?? this.workingDir ?? process.cwd());
+    const blocked = this.guard(command, cwd);
+    if (blocked) return blocked;
+
+    const env = { ...process.env } as Record<string, string>;
+    if (this.pathAppend) env.PATH = `${env.PATH ?? ""}${path.delimiter}${this.pathAppend}`;
+
+    try {
+      const { stdout, stderr } = await execAsync(command, { cwd, env, timeout: this.timeout * 1000, maxBuffer: 1024 * 1024 });
+      let out = "";
+      if (stdout) out += stdout;
+      if (stderr?.trim()) out += `${out ? "\n" : ""}STDERR:\n${stderr}`;
+      if (!out) out = "(no output)";
+      if (out.length > 10000) out = `${out.slice(0, 10000)}\n... (truncated, ${out.length - 10000} more chars)`;
+      return out;
+    } catch (err: any) {
+      if (typeof err?.killed === "boolean" && err.killed) return `Error: Command timed out after ${this.timeout} seconds`;
+      const stdout = err?.stdout ? `${err.stdout}\n` : "";
+      const stderr = err?.stderr ? `STDERR:\n${err.stderr}\n` : "";
+      const code = typeof err?.code === "number" ? `\nExit code: ${err.code}` : "";
+      const text = `${stdout}${stderr}${code}`.trim();
+      return text || `Error executing command: ${String(err)}`;
+    }
+  }
+}

package/src/agent/tools/spawn.ts

@@ -0,0 +1,37 @@
+import { Tool } from "./base.js";
+import type { SubagentManager } from "../subagent.js";
+
+export class SpawnTool extends Tool {
+  readonly name = "spawn";
+  readonly description = "Spawn a subagent to handle a task in the background.";
+  readonly parameters = {
+    type: "object",
+    properties: {
+      task: { type: "string", description: "The task for the subagent to complete" },
+      label: { type: "string", description: "Optional short label" },
+    },
+    required: ["task"],
+  };
+
+  private originChannel = "cli";
+  private originChatId = "direct";
+  private sessionKey = "cli:direct";
+
+  constructor(private readonly manager: SubagentManager) { super(); }
+
+  setContext(channel: string, chatId: string): void {
+    this.originChannel = channel;
+    this.originChatId = chatId;
+    this.sessionKey = `${channel}:${chatId}`;
+  }
+
+  async execute(args: Record<string, unknown>): Promise<string> {
+    return this.manager.spawn({
+      task: String(args.task ?? ""),
+      label: args.label != null ? String(args.label) : null,
+      originChannel: this.originChannel,
+      originChatId: this.originChatId,
+      sessionKey: this.sessionKey,
+    });
+  }
+}

package/src/agent/tools/web.ts

@@ -0,0 +1,108 @@
+import { Tool } from "./base.js";
+
+function stripTags(text: string): string {
+  return text.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, "").trim();
+}
+
+function normalize(text: string): string {
+  return text.replace(/[ \t]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+function validateUrl(url: string): [boolean, string] {
+  try {
+    const u = new URL(url);
+    if (!["http:", "https:"].includes(u.protocol)) return [false, `Only http/https allowed, got '${u.protocol.replace(":", "")}'`];
+    if (!u.hostname) return [false, "Missing domain"];
+    return [true, ""];
+  } catch (err) {
+    return [false, String(err)];
+  }
+}
+
+export class WebSearchTool extends Tool {
+  readonly name = "web_search";
+  readonly description = "Search the web. Returns titles, URLs, and snippets.";
+  readonly parameters = {
+    type: "object",
+    properties: { query: { type: "string", description: "Search query" }, count: { type: "integer", minimum: 1, maximum: 10, description: "Results (1-10)" } },
+    required: ["query"],
+  };
+
+  constructor(private readonly apiKey: string | null, private readonly maxResults = 5) { super(); }
+
+  async execute(args: Record<string, unknown>): Promise<string> {
+    const query = String(args.query ?? "");
+    const count = Math.min(Math.max(Number(args.count ?? this.maxResults), 1), 10);
+    const key = this.apiKey || process.env.BRAVE_API_KEY || "";
+    if (!key) return "Error: Brave Search API key not configured. Set tools.web.search.apiKey or BRAVE_API_KEY.";
+
+    try {
+      const url = new URL("https://api.search.brave.com/res/v1/web/search");
+      url.searchParams.set("q", query);
+      url.searchParams.set("count", String(count));
+      const res = await fetch(url, { headers: { Accept: "application/json", "X-Subscription-Token": key } });
+      if (!res.ok) return `Error: ${res.status} ${res.statusText}`;
+      const json: any = await res.json();
+      const results = json.web?.results ?? [];
+      if (!results.length) return `No results for: ${query}`;
+      const lines = [`Results for: ${query}`, ""];
+      results.slice(0, count).forEach((item: any, i: number) => {
+        lines.push(`${i + 1}. ${item.title ?? ""}`);
+        lines.push(`   ${item.url ?? ""}`);
+        if (item.description) lines.push(`   ${item.description}`);
+      });
+      return lines.join("\n");
+    } catch (err) {
+      return `Error: ${String(err)}`;
+    }
+  }
+}
+
+export class WebFetchTool extends Tool {
+  readonly name = "web_fetch";
+  readonly description = "Fetch URL and extract readable content (HTML to markdown/text).";
+  readonly parameters = {
+    type: "object",
+    properties: {
+      url: { type: "string", description: "URL to fetch" },
+      extractMode: { type: "string", enum: ["markdown", "text"] },
+      maxChars: { type: "integer", minimum: 100 },
+    },
+    required: ["url"],
+  };
+
+  constructor(private readonly maxChars = 50000) { super(); }
+
+  async execute(args: Record<string, unknown>): Promise<string> {
+    const url = String(args.url ?? "");
+    const extractMode = String(args.extractMode ?? "markdown");
+    const maxChars = Number(args.maxChars ?? this.maxChars);
+    const [ok, err] = validateUrl(url);
+    if (!ok) return JSON.stringify({ error: `URL validation failed: ${err}`, url });
+
+    try {
+      const res = await fetch(url, { redirect: "follow", headers: { "User-Agent": "Mozilla/5.0" } });
+      const ctype = res.headers.get("content-type") || "";
+      let text = "";
+      let extractor = "raw";
+      if (ctype.includes("application/json")) {
+        text = JSON.stringify(await res.json(), null, 2);
+        extractor = "json";
+      } else {
+        const raw = await res.text();
+        if (ctype.includes("text/html") || /^\s*<!doctype|^\s*<html/i.test(raw.slice(0, 256))) {
+          const content = extractMode === "text" ? stripTags(raw) : normalize(stripTags(raw));
+          text = content;
+          extractor = "html";
+        } else {
+          text = raw;
+        }
+      }
+      const truncated = text.length > maxChars;
+      const sliced = truncated ? text.slice(0, maxChars) : text;
+      return JSON.stringify({ url, finalUrl: res.url, status: res.status, extractor, truncated, length: sliced.length, text: sliced });
+    } catch (e) {
+      return JSON.stringify({ error: String(e), url });
+    }
+  }
+}

package/src/bus/async-queue.ts

@@ -0,0 +1,20 @@
+export class AsyncQueue<T> {
+  private items: T[] = [];
+  private waiters: Array<(v: T) => void> = [];
+
+  push(v: T): void {
+    const waiter = this.waiters.shift();
+    if (waiter) waiter(v);
+    else this.items.push(v);
+  }
+
+  async pop(): Promise<T> {
+    const item = this.items.shift();
+    if (item !== undefined) return item;
+    return new Promise<T>((resolve) => this.waiters.push(resolve));
+  }
+
+  size(): number {
+    return this.items.length;
+  }
+}

package/src/bus/events.ts

@@ -0,0 +1,23 @@
+export interface InboundMessage {
+  channel: string;
+  senderId: string;
+  chatId: string;
+  content: string;
+  timestamp?: Date;
+  media?: string[];
+  metadata?: Record<string, unknown>;
+  sessionKeyOverride?: string;
+}
+
+export interface OutboundMessage {
+  channel: string;
+  chatId: string;
+  content: string;
+  replyTo?: string;
+  media?: string[];
+  metadata?: Record<string, unknown>;
+}
+
+export function sessionKey(msg: InboundMessage): string {
+  return msg.sessionKeyOverride ?? `${msg.channel}:${msg.chatId}`;
+}

package/src/bus/queue.ts

@@ -0,0 +1,31 @@
+import { AsyncQueue } from "./async-queue.js";
+import type { InboundMessage, OutboundMessage } from "./events.js";
+
+export class MessageBus {
+  readonly inbound = new AsyncQueue<InboundMessage>();
+  readonly outbound = new AsyncQueue<OutboundMessage>();
+
+  async publishInbound(msg: InboundMessage): Promise<void> {
+    this.inbound.push(msg);
+  }
+
+  async consumeInbound(): Promise<InboundMessage> {
+    return this.inbound.pop();
+  }
+
+  async publishOutbound(msg: OutboundMessage): Promise<void> {
+    this.outbound.push(msg);
+  }
+
+  async consumeOutbound(): Promise<OutboundMessage> {
+    return this.outbound.pop();
+  }
+
+  get inboundSize(): number {
+    return this.inbound.size();
+  }
+
+  get outboundSize(): number {
+    return this.outbound.size();
+  }
+}

package/src/channels/base.ts

@@ -0,0 +1,36 @@
+import type { MessageBus } from "../bus/queue.js";
+import type { OutboundMessage } from "../bus/events.js";
+
+export abstract class BaseChannel<TConfig = unknown> {
+  protected running = false;
+  constructor(protected readonly config: TConfig, protected readonly bus: MessageBus) {}
+  abstract readonly name: string;
+  abstract start(): Promise<void>;
+  abstract stop(): Promise<void>;
+  abstract send(msg: OutboundMessage): Promise<void>;
+
+  protected isAllowed(senderId: string): boolean {
+    const allowFrom: string[] = ((this.config as any)?.allowFrom ?? []) as string[];
+    if (!allowFrom.length) return true;
+    if (allowFrom.includes(String(senderId))) return true;
+    if (String(senderId).includes("|")) return String(senderId).split("|").some((p) => allowFrom.includes(p));
+    return false;
+  }
+
+  protected async handleMessage(input: { senderId: string; chatId: string; content: string; media?: string[]; metadata?: Record<string, unknown>; sessionKey?: string }): Promise<void> {
+    if (!this.isAllowed(input.senderId)) return;
+    await this.bus.publishInbound({
+      channel: this.name,
+      senderId: String(input.senderId),
+      chatId: String(input.chatId),
+      content: input.content,
+      media: input.media ?? [],
+      metadata: input.metadata ?? {},
+      sessionKeyOverride: input.sessionKey,
+    });
+  }
+
+  get isRunning(): boolean {
+    return this.running;
+  }
+}

package/src/channels/discord.ts

@@ -0,0 +1,156 @@
+import WebSocket, { type RawData } from "ws";
+import type { OutboundMessage } from "../bus/events.js";
+import type { MessageBus } from "../bus/queue.js";
+import { BaseChannel } from "./base.js";
+
+type DiscordConfig = {
+  enabled: boolean;
+  token: string;
+  allowFrom: string[];
+  gatewayUrl: string;
+  intents: number;
+};
+
+type DiscordGatewayPayload = {
+  op: number;
+  d: any;
+  s: number | null;
+  t: string | null;
+};
+
+export class DiscordChannel extends BaseChannel<DiscordConfig> {
+  readonly name = "discord";
+  private ws: WebSocket | null = null;
+  private hb: NodeJS.Timeout | null = null;
+  private seq: number | null = null;
+
+  constructor(config: DiscordConfig, bus: MessageBus) {
+    super(config, bus);
+  }
+
+  async start(): Promise<void> {
+    if (!this.config.token) {
+      console.error("Discord token not configured");
+      return;
+    }
+
+    this.running = true;
+    while (this.running) {
+      try {
+        await this.connectOnce();
+      } catch {
+        // reconnect loop
+      }
+      if (this.running) await new Promise((r) => setTimeout(r, 2000));
+    }
+  }
+
+  async stop(): Promise<void> {
+    this.running = false;
+    if (this.hb) {
+      clearInterval(this.hb);
+      this.hb = null;
+    }
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {
+        // ignore
+      }
+      this.ws = null;
+    }
+  }
+
+  async send(msg: OutboundMessage): Promise<void> {
+    if (!this.config.token) return;
+    await fetch(`https://discord.com/api/v10/channels/${msg.chatId}/messages`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bot ${this.config.token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ content: msg.content || "" }),
+    }).catch(() => undefined);
+  }
+
+  private async connectOnce(): Promise<void> {
+    await new Promise<void>((resolve) => {
+      const ws = new WebSocket(this.config.gatewayUrl);
+      this.ws = ws;
+
+      ws.on("message", async (raw: RawData) => {
+        let payload: DiscordGatewayPayload;
+        try {
+          payload = JSON.parse(raw.toString());
+        } catch {
+          return;
+        }
+
+        if (payload.s != null) this.seq = payload.s;
+
+        if (payload.op === 10) {
+          const interval = Number(payload.d?.heartbeat_interval ?? 30000);
+          this.startHeartbeat(interval);
+          this.sendPayload({
+            op: 2,
+            d: {
+              token: this.config.token,
+              intents: this.config.intents,
+              properties: { os: process.platform, browser: "pretticlaw", device: "pretticlaw" },
+            },
+          });
+          return;
+        }
+
+        if (payload.op === 7) {
+          ws.close();
+          return;
+        }
+
+        if (payload.op === 11) return;
+
+        if (payload.t === "MESSAGE_CREATE") {
+          const m = payload.d;
+          if (!m || m.author?.bot) return;
+          const content = String(m.content ?? "").trim();
+          if (!content) return;
+          const sender = `${m.author?.id}${m.author?.username ? `|${m.author.username}` : ""}`;
+          await this.handleMessage({
+            senderId: sender,
+            chatId: String(m.channel_id),
+            content,
+            metadata: { message_id: m.id, guild_id: m.guild_id ?? null },
+          });
+        }
+      });
+
+      ws.on("close", () => {
+        if (this.hb) {
+          clearInterval(this.hb);
+          this.hb = null;
+        }
+        resolve();
+      });
+
+      ws.on("error", () => {
+        if (this.hb) {
+          clearInterval(this.hb);
+          this.hb = null;
+        }
+        resolve();
+      });
+    });
+  }
+
+  private startHeartbeat(intervalMs: number): void {
+    if (this.hb) clearInterval(this.hb);
+    this.hb = setInterval(() => {
+      this.sendPayload({ op: 1, d: this.seq });
+    }, intervalMs);
+  }
+
+  private sendPayload(data: Record<string, unknown>): void {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    this.ws.send(JSON.stringify(data));
+  }
+}

package/src/channels/manager.ts

@@ -0,0 +1,70 @@
+import type { Config } from "../config/schema.js";
+import type { MessageBus } from "../bus/queue.js";
+import type { OutboundMessage } from "../bus/events.js";
+import type { BaseChannel } from "./base.js";
+import { StubChannel } from "./stub.js";
+import { TelegramChannel } from "./telegram.js";
+import { DiscordChannel } from "./discord.js";
+
+export class ChannelManager {
+  readonly channels = new Map<string, BaseChannel>();
+  private dispatchLoop: Promise<void> | null = null;
+  private stopping = false;
+
+  constructor(private readonly config: Config, private readonly bus: MessageBus) {
+    this.initChannels();
+  }
+
+  private initChannels(): void {
+    const add = (name: string, enabled: boolean, channelConfig: any) => {
+      if (enabled) this.channels.set(name, new StubChannel(name, channelConfig, this.bus));
+    };
+    if (this.config.channels.telegram.enabled) {
+      this.channels.set("telegram", new TelegramChannel(this.config.channels.telegram, this.bus));
+    }
+    add("whatsapp", this.config.channels.whatsapp.enabled, this.config.channels.whatsapp);
+    if (this.config.channels.discord.enabled) {
+      this.channels.set("discord", new DiscordChannel(this.config.channels.discord, this.bus));
+    }
+    add("feishu", this.config.channels.feishu.enabled, this.config.channels.feishu);
+    add("mochat", this.config.channels.mochat.enabled, this.config.channels.mochat);
+    add("dingtalk", this.config.channels.dingtalk.enabled, this.config.channels.dingtalk);
+    add("email", this.config.channels.email.enabled, this.config.channels.email);
+    add("slack", this.config.channels.slack.enabled, this.config.channels.slack);
+    add("qq", this.config.channels.qq.enabled, this.config.channels.qq);
+    add("matrix", this.config.channels.matrix.enabled, this.config.channels.matrix);
+  }
+
+  async startAll(): Promise<void> {
+    if (!this.channels.size) return;
+    this.stopping = false;
+    this.dispatchLoop = this.dispatchOutbound();
+    await Promise.all([...this.channels.values()].map((c) => c.start().catch(() => undefined)));
+  }
+
+  async stopAll(): Promise<void> {
+    this.stopping = true;
+    await Promise.all([...this.channels.values()].map((c) => c.stop().catch(() => undefined)));
+  }
+
+  private async dispatchOutbound(): Promise<void> {
+    while (!this.stopping) {
+      const msg = await this.bus.consumeOutbound();
+      if (msg.metadata?._progress) {
+        const isTool = !!msg.metadata._tool_hint;
+        if (isTool && !this.config.channels.sendToolHints) continue;
+        if (!isTool && !this.config.channels.sendProgress) continue;
+      }
+      const ch = this.channels.get(msg.channel);
+      if (ch) await ch.send(msg as OutboundMessage).catch(() => undefined);
+    }
+  }
+
+  get enabledChannels(): string[] {
+    return [...this.channels.keys()];
+  }
+
+  getStatus(): Record<string, unknown> {
+    return Object.fromEntries([...this.channels].map(([name, c]) => [name, { enabled: true, running: c.isRunning }]));
+  }
+}

package/src/channels/stub.ts

@@ -0,0 +1,20 @@
+import type { OutboundMessage } from "../bus/events.js";
+import type { MessageBus } from "../bus/queue.js";
+import { BaseChannel } from "./base.js";
+
+export class StubChannel extends BaseChannel<any> {
+  constructor(public readonly name: string, config: any, bus: MessageBus) { super(config, bus); }
+
+  async start(): Promise<void> {
+    this.running = true;
+    await new Promise<void>(() => {});
+  }
+
+  async stop(): Promise<void> {
+    this.running = false;
+  }
+
+  async send(_msg: OutboundMessage): Promise<void> {
+    // no-op
+  }
+}