pretticlaw 0.1.0

package/src/config/schema.ts

@@ -0,0 +1,144 @@
+import path from "node:path";
+
+export interface ProviderConfig {
+  apiKey: string;
+  apiBase: string | null;
+  extraHeaders: Record<string, string> | null;
+}
+
+export interface ChannelsConfig {
+  sendProgress: boolean;
+  sendToolHints: boolean;
+  whatsapp: { enabled: boolean; bridgeUrl: string; bridgeToken: string; allowFrom: string[] };
+  telegram: { enabled: boolean; token: string; allowFrom: string[]; proxy: string | null; replyToMessage: boolean };
+  discord: { enabled: boolean; token: string; allowFrom: string[]; gatewayUrl: string; intents: number };
+  feishu: { enabled: boolean; appId: string; appSecret: string; allowFrom: string[] };
+  mochat: { enabled: boolean; baseUrl: string; allowFrom: string[] };
+  dingtalk: { enabled: boolean; clientId: string; clientSecret: string; allowFrom: string[] };
+  email: { enabled: boolean; consentGranted: boolean; imapHost: string; allowFrom: string[] };
+  slack: { enabled: boolean; botToken: string; appToken: string; groupPolicy: string; groupAllowFrom: string[] };
+  qq: { enabled: boolean; appId: string; secret: string; allowFrom: string[] };
+  matrix: { enabled: boolean; homeserver: string; accessToken: string; userId: string; deviceId: string; allowFrom: string[] };
+}
+
+export interface Config {
+  agents: {
+    defaults: {
+      workspace: string;
+      model: string;
+      provider: string;
+      maxTokens: number;
+      temperature: number;
+      maxToolIterations: number;
+      memoryWindow: number;
+    };
+  };
+  channels: ChannelsConfig;
+  providers: Record<string, ProviderConfig>;
+  gateway: {
+    host: string;
+    port: number;
+    heartbeat: { enabled: boolean; intervalS: number };
+  };
+  tools: {
+    web: { search: { apiKey: string; maxResults: number } };
+    exec: { timeout: number; pathAppend: string };
+    restrictToWorkspace: boolean;
+    mcpServers: Record<string, { command: string; args: string[]; env: Record<string, string>; url: string; headers: Record<string, string>; toolTimeout: number }>;
+  };
+}
+
+export const PROVIDERS = [
+  { name: "custom", keywords: [], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "" },
+  { name: "openrouter", keywords: ["openrouter"], isOauth: false, isGateway: true, isLocal: false, defaultApiBase: "https://openrouter.ai/api/v1", detectByKeyPrefix: "sk-or-", detectByBaseKeyword: "openrouter" },
+  { name: "aihubmix", keywords: ["aihubmix"], isOauth: false, isGateway: true, isLocal: false, defaultApiBase: "https://aihubmix.com/v1", detectByBaseKeyword: "aihubmix" },
+  { name: "siliconflow", keywords: ["siliconflow"], isOauth: false, isGateway: true, isLocal: false, defaultApiBase: "https://api.siliconflow.cn/v1", detectByBaseKeyword: "siliconflow" },
+  { name: "volcengine", keywords: ["volcengine", "volces", "ark"], isOauth: false, isGateway: true, isLocal: false, defaultApiBase: "https://ark.cn-beijing.volces.com/api/v3", detectByBaseKeyword: "volces" },
+  { name: "anthropic", keywords: ["anthropic", "claude"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "" },
+  { name: "openai", keywords: ["openai", "gpt"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "" },
+  { name: "openai_codex", keywords: ["openai-codex", "codex"], isOauth: true, isGateway: false, isLocal: false, defaultApiBase: "https://chatgpt.com/backend-api" },
+  { name: "github_copilot", keywords: ["github_copilot", "copilot"], isOauth: true, isGateway: false, isLocal: false, defaultApiBase: "" },
+  { name: "deepseek", keywords: ["deepseek"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "" },
+  { name: "gemini", keywords: ["gemini"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "" },
+  { name: "zhipu", keywords: ["zhipu", "glm", "zai"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "" },
+  { name: "dashscope", keywords: ["qwen", "dashscope"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "" },
+  { name: "moonshot", keywords: ["moonshot", "kimi"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "https://api.moonshot.ai/v1" },
+  { name: "minimax", keywords: ["minimax"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "https://api.minimax.io/v1" },
+  { name: "vllm", keywords: ["vllm"], isOauth: false, isGateway: false, isLocal: true, defaultApiBase: "" },
+  { name: "groq", keywords: ["groq"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "" },
+] as const;
+
+const providerDefaults = Object.fromEntries(PROVIDERS.map((p) => [p.name, { apiKey: "", apiBase: null, extraHeaders: null }])) as Record<string, ProviderConfig>;
+
+export const DEFAULT_CONFIG: Config = {
+  agents: {
+    defaults: {
+      workspace: path.join("~", ".pretticlaw", "workspace"),
+      model: "anthropic/claude-sonnet-4",
+      provider: "auto",
+      maxTokens: 8192,
+      temperature: 0.1,
+      maxToolIterations: 40,
+      memoryWindow: 100,
+    },
+  },
+  channels: {
+    sendProgress: true,
+    sendToolHints: false,
+    whatsapp: { enabled: false, bridgeUrl: "ws://localhost:3001", bridgeToken: "", allowFrom: [] },
+    telegram: { enabled: false, token: "", allowFrom: [], proxy: null, replyToMessage: false },
+    discord: { enabled: false, token: "", allowFrom: [], gatewayUrl: "wss://gateway.discord.gg/?v=10&encoding=json", intents: 37377 },
+    feishu: { enabled: false, appId: "", appSecret: "", allowFrom: [] },
+    mochat: { enabled: false, baseUrl: "https://mochat.io", allowFrom: [] },
+    dingtalk: { enabled: false, clientId: "", clientSecret: "", allowFrom: [] },
+    email: { enabled: false, consentGranted: false, imapHost: "", allowFrom: [] },
+    slack: { enabled: false, botToken: "", appToken: "", groupPolicy: "mention", groupAllowFrom: [] },
+    qq: { enabled: false, appId: "", secret: "", allowFrom: [] },
+    matrix: { enabled: false, homeserver: "https://matrix.org", accessToken: "", userId: "", deviceId: "", allowFrom: [] },
+  },
+  providers: providerDefaults,
+  gateway: { host: "0.0.0.0", port: 18790, heartbeat: { enabled: true, intervalS: 1800 } },
+  tools: { web: { search: { apiKey: "", maxResults: 5 } }, exec: { timeout: 60, pathAppend: "" }, restrictToWorkspace: false, mcpServers: {} },
+};
+
+function normalize(name: string): string {
+  return name.toLowerCase().replace(/-/g, "_");
+}
+
+export function getProviderName(config: Config, model?: string): string | null {
+  const forced = config.agents.defaults.provider;
+  if (forced !== "auto") return config.providers[forced] ? forced : null;
+
+  const m = (model ?? config.agents.defaults.model).toLowerCase();
+  const mNorm = normalize(m);
+  const prefix = m.includes("/") ? m.split("/", 1)[0] : "";
+
+  for (const spec of PROVIDERS) {
+    const p = config.providers[spec.name];
+    if (prefix && normalize(prefix) === spec.name && (spec.isOauth || p?.apiKey)) return spec.name;
+  }
+  for (const spec of PROVIDERS) {
+    const p = config.providers[spec.name];
+    if (spec.keywords.some((kw) => m.includes(kw) || mNorm.includes(normalize(kw))) && (spec.isOauth || p?.apiKey)) return spec.name;
+  }
+  for (const spec of PROVIDERS) {
+    if (spec.isOauth) continue;
+    const p = config.providers[spec.name];
+    if (p?.apiKey) return spec.name;
+  }
+  return null;
+}
+
+export function getProvider(config: Config, model?: string): ProviderConfig | null {
+  const name = getProviderName(config, model);
+  return name ? config.providers[name] ?? null : null;
+}
+
+export function getApiBase(config: Config, model?: string): string | null {
+  const name = getProviderName(config, model);
+  if (!name) return null;
+  const p = config.providers[name];
+  if (p?.apiBase) return p.apiBase;
+  const spec = PROVIDERS.find((s) => s.name === name);
+  return spec?.isGateway ? spec.defaultApiBase : null;
+}

package/src/cron/service.ts

@@ -0,0 +1,190 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import parser from "cron-parser";
+import type { CronJob, CronSchedule, CronStore } from "./types.js";
+
+function nowMs(): number { return Date.now(); }
+
+function computeNextRun(schedule: CronSchedule, now: number): number | null {
+  if (schedule.kind === "at") return schedule.atMs > now ? schedule.atMs : null;
+  if (schedule.kind === "every") return schedule.everyMs > 0 ? now + schedule.everyMs : null;
+  if (schedule.kind === "cron") {
+    try {
+      const it = parser.parseExpression(schedule.expr, { currentDate: new Date(now), tz: schedule.tz });
+      return it.next().toDate().getTime();
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+function validateScheduleForAdd(schedule: CronSchedule): void {
+  if ("tz" in schedule && schedule.tz && schedule.kind !== "cron") throw new Error("tz can only be used with cron schedules");
+  if (schedule.kind === "cron" && schedule.tz) {
+    try {
+      new Intl.DateTimeFormat("en-US", { timeZone: schedule.tz });
+    } catch {
+      throw new Error(`unknown timezone '${schedule.tz}'`);
+    }
+  }
+}
+
+export class CronService {
+  private store: CronStore | null = null;
+  private timer: NodeJS.Timeout | null = null;
+  private running = false;
+
+  constructor(private readonly storePath: string, public onJob?: (job: CronJob) => Promise<string | null>) {}
+
+  private loadStore(): CronStore {
+    if (this.store) return this.store;
+    if (!fs.existsSync(this.storePath)) {
+      this.store = { version: 1, jobs: [] };
+      return this.store;
+    }
+    try {
+      const parsed = JSON.parse(fs.readFileSync(this.storePath, "utf8")) as CronStore;
+      this.store = parsed;
+    } catch {
+      this.store = { version: 1, jobs: [] };
+    }
+    return this.store;
+  }
+
+  private saveStore(): void {
+    if (!this.store) return;
+    fs.mkdirSync(path.dirname(this.storePath), { recursive: true });
+    fs.writeFileSync(this.storePath, JSON.stringify(this.store, null, 2), "utf8");
+  }
+
+  private getNextWakeMs(): number | null {
+    const s = this.loadStore();
+    const times = s.jobs.filter((j) => j.enabled && j.state.nextRunAtMs).map((j) => j.state.nextRunAtMs as number);
+    return times.length ? Math.min(...times) : null;
+  }
+
+  private armTimer(): void {
+    if (this.timer) clearTimeout(this.timer);
+    const next = this.getNextWakeMs();
+    if (!this.running || !next) return;
+    this.timer = setTimeout(() => void this.onTimer(), Math.max(0, next - nowMs()));
+  }
+
+  private async onTimer(): Promise<void> {
+    const s = this.loadStore();
+    const now = nowMs();
+    const due = s.jobs.filter((j) => j.enabled && j.state.nextRunAtMs && now >= j.state.nextRunAtMs);
+    for (const job of due) await this.executeJob(job);
+    this.saveStore();
+    this.armTimer();
+  }
+
+  private async executeJob(job: CronJob): Promise<void> {
+    const start = nowMs();
+    try {
+      if (this.onJob) await this.onJob(job);
+      job.state.lastStatus = "ok";
+      job.state.lastError = null;
+    } catch (err) {
+      job.state.lastStatus = "error";
+      job.state.lastError = String(err);
+    }
+    job.state.lastRunAtMs = start;
+    job.updatedAtMs = nowMs();
+    if (job.schedule.kind === "at") {
+      if (job.deleteAfterRun) {
+        this.store!.jobs = this.store!.jobs.filter((j) => j.id !== job.id);
+      } else {
+        job.enabled = false;
+        job.state.nextRunAtMs = null;
+      }
+    } else {
+      job.state.nextRunAtMs = computeNextRun(job.schedule, nowMs());
+    }
+  }
+
+  async start(): Promise<void> {
+    this.running = true;
+    const s = this.loadStore();
+    for (const job of s.jobs) if (job.enabled) job.state.nextRunAtMs = computeNextRun(job.schedule, nowMs());
+    this.saveStore();
+    this.armTimer();
+  }
+
+  stop(): void {
+    this.running = false;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+
+  listJobs(includeDisabled = false): CronJob[] {
+    const s = this.loadStore();
+    const jobs = includeDisabled ? s.jobs : s.jobs.filter((j) => j.enabled);
+    return [...jobs].sort((a, b) => (a.state.nextRunAtMs ?? Number.MAX_SAFE_INTEGER) - (b.state.nextRunAtMs ?? Number.MAX_SAFE_INTEGER));
+  }
+
+  addJob(input: { name: string; schedule: CronSchedule; message: string; deliver?: boolean; channel?: string; to?: string; deleteAfterRun?: boolean }): CronJob {
+    const s = this.loadStore();
+    validateScheduleForAdd(input.schedule);
+    const now = nowMs();
+    const job: CronJob = {
+      id: randomUUID().slice(0, 8),
+      name: input.name,
+      enabled: true,
+      schedule: input.schedule,
+      payload: { kind: "agent_turn", message: input.message, deliver: !!input.deliver, channel: input.channel, to: input.to },
+      state: { nextRunAtMs: computeNextRun(input.schedule, now), lastRunAtMs: null, lastStatus: null, lastError: null },
+      createdAtMs: now,
+      updatedAtMs: now,
+      deleteAfterRun: !!input.deleteAfterRun,
+    };
+    s.jobs.push(job);
+    this.saveStore();
+    this.armTimer();
+    return job;
+  }
+
+  removeJob(jobId: string): boolean {
+    const s = this.loadStore();
+    const before = s.jobs.length;
+    s.jobs = s.jobs.filter((j) => j.id !== jobId);
+    const removed = s.jobs.length < before;
+    if (removed) {
+      this.saveStore();
+      this.armTimer();
+    }
+    return removed;
+  }
+
+  enableJob(jobId: string, enabled = true): CronJob | null {
+    const s = this.loadStore();
+    const job = s.jobs.find((j) => j.id === jobId);
+    if (!job) return null;
+    job.enabled = enabled;
+    job.updatedAtMs = nowMs();
+    job.state.nextRunAtMs = enabled ? computeNextRun(job.schedule, nowMs()) : null;
+    this.saveStore();
+    this.armTimer();
+    return job;
+  }
+
+  async runJob(jobId: string, force = false): Promise<boolean> {
+    const s = this.loadStore();
+    const job = s.jobs.find((j) => j.id === jobId);
+    if (!job) return false;
+    if (!force && !job.enabled) return false;
+    await this.executeJob(job);
+    this.saveStore();
+    this.armTimer();
+    return true;
+  }
+
+  status(): Record<string, unknown> {
+    const s = this.loadStore();
+    return { enabled: this.running, jobs: s.jobs.length, nextWakeAtMs: this.getNextWakeMs() };
+  }
+}
+
+export { validateScheduleForAdd };

package/src/cron/types.ts

@@ -0,0 +1,36 @@
+export type CronSchedule =
+  | { kind: "at"; atMs: number; everyMs?: never; expr?: never; tz?: string }
+  | { kind: "every"; everyMs: number; atMs?: never; expr?: never; tz?: string }
+  | { kind: "cron"; expr: string; tz?: string; atMs?: never; everyMs?: never };
+
+export interface CronPayload {
+  kind: "system_event" | "agent_turn";
+  message: string;
+  deliver: boolean;
+  channel?: string;
+  to?: string;
+}
+
+export interface CronJobState {
+  nextRunAtMs: number | null;
+  lastRunAtMs: number | null;
+  lastStatus: "ok" | "error" | "skipped" | null;
+  lastError: string | null;
+}
+
+export interface CronJob {
+  id: string;
+  name: string;
+  enabled: boolean;
+  schedule: CronSchedule;
+  payload: CronPayload;
+  state: CronJobState;
+  createdAtMs: number;
+  updatedAtMs: number;
+  deleteAfterRun: boolean;
+}
+
+export interface CronStore {
+  version: number;
+  jobs: CronJob[];
+}