mioku-plugin-agent 0.1.0

package/index.ts

@@ -0,0 +1,212 @@
+import { definePlugin, getService, Services } from "mioku";
+import type { AIInstance, AIModelRole, MiokuContext } from "mioku";
+import { initDatabase } from "./db";
+import { SessionManager } from "./core/session";
+import { EmotionManager } from "./core/emotion";
+import { ApprovalManager } from "./tools/approval";
+import { readChatSharedConfig } from "./core/chat-config";
+import { createMessageHandler } from "./handlers/message";
+import { registerCommands } from "./commands";
+import { mergeAgentConfig } from "./utils/config";
+import { workspaceRootFor } from "./tools/perm";
+import { BASE_CONFIG } from "./configs/base";
+import { SETTINGS_CONFIG } from "./configs/settings";
+import type {
+  AgentBaseConfig,
+  AgentHost,
+  AgentSettingsConfig,
+  ResolvedModel,
+} from "./types";
+
+function normalizeIdList(input: unknown): number[] {
+  if (!Array.isArray(input)) return [];
+  return Array.from(
+    new Set(
+      input
+        .map((item) => Math.floor(Number(item)))
+        .filter((id) => Number.isFinite(id) && id > 0),
+    ),
+  );
+}
+
+export default definePlugin({
+  name: "agent",
+  async setup(ctx: MiokuContext) {
+    const aiService = getService(ctx, Services.AI);
+    const configService = getService(ctx, Services.Config);
+    const screenshot = getService(ctx, Services.Screenshot);
+
+    if (!aiService) {
+      ctx.logger.error("AI 服务不可用");
+      return;
+    }
+
+    if (configService) {
+      await configService.registerConfig("agent", "base", BASE_CONFIG);
+      await configService.registerConfig("agent", "settings", SETTINGS_CONFIG);
+    }
+
+    let cachedBase: AgentBaseConfig = mergeAgentConfig(
+      BASE_CONFIG,
+      (await configService?.getConfig("agent", "base")) ?? {},
+    );
+    let cachedSettings: AgentSettingsConfig = mergeAgentConfig(
+      SETTINGS_CONFIG,
+      (await configService?.getConfig("agent", "settings")) ?? {},
+    );
+    if (!Array.isArray(cachedBase.access.users)) cachedBase.access.users = [];
+
+    const refreshBase = async () => {
+      cachedBase = mergeAgentConfig(
+        BASE_CONFIG,
+        (await configService?.getConfig("agent", "base")) ?? {},
+      );
+      if (!Array.isArray(cachedBase.access.users)) cachedBase.access.users = [];
+    };
+    const refreshSettings = async () => {
+      cachedSettings = mergeAgentConfig(
+        SETTINGS_CONFIG,
+        (await configService?.getConfig("agent", "settings")) ?? {},
+      );
+    };
+    if (configService) {
+      configService.onConfigChange("agent", "base", () =>
+        refreshBase().catch((err) =>
+          ctx.logger.error(`刷新 agent/base 缓存失败: ${err}`),
+        ),
+      );
+      configService.onConfigChange("agent", "settings", () =>
+        refreshSettings().catch((err) =>
+          ctx.logger.error(`刷新 agent/settings 缓存失败: ${err}`),
+        ),
+      );
+    }
+
+    const db = await initDatabase();
+    const sessions = new SessionManager(db);
+    const approvals = new ApprovalManager();
+    const emotions = new EmotionManager((userId, emotion) =>
+      sessions.setEmotion(userId, emotion),
+    );
+
+    const resolveModel = (): ResolvedModel | null => {
+      const getByRole = (role: AIModelRole) =>
+        aiService.getInstanceByRole?.(role) ?? aiService.get?.(role);
+      const main = getByRole("main") ?? aiService.getDefault?.();
+      if (!main) return null;
+      const working = getByRole("working") ?? main;
+      const vision = getByRole("vision") ?? working;
+      const bindings = aiService.getRoleBindings?.() ?? {
+        main: undefined,
+        working: undefined,
+        vision: undefined,
+      };
+      const models = aiService.listModels?.() ?? [];
+      const instanceName = (instance: AIInstance): string | undefined => {
+        const name = (instance as { name?: unknown }).name;
+        return typeof name === "string" ? name : undefined;
+      };
+      const pickModel = (full: string | undefined, instance: AIInstance) => {
+        if (full && full.includes("/")) {
+          return full.split("/").slice(1).join("/");
+        }
+        const name = instanceName(instance);
+        const info = aiService
+          .listInstances?.()
+          ?.find((item) => item.role === name || item.name === name);
+        return info?.modelId ?? "";
+      };
+
+      const overrideFullId = String(cachedBase.model ?? "").trim();
+      const overrideDesc = overrideFullId
+        ? models.find((item) => item.id === overrideFullId)
+        : undefined;
+      let instance = main;
+      let model = pickModel(bindings.main, main) || "";
+      if (overrideDesc) {
+        model = overrideDesc.modelId;
+        const info = aiService
+          .listInstances?.()
+          ?.find((item) => item.providerId === overrideDesc.providerId);
+        const candidate = info ? aiService.get?.(info.name) : undefined;
+        if (candidate) instance = candidate;
+      } else if (overrideFullId) {
+        model = overrideFullId.includes("/")
+          ? overrideFullId.split("/").slice(1).join("/")
+          : overrideFullId;
+      }
+
+      const workingModel = pickModel(bindings.working, working) || model;
+      const visionModel = pickModel(bindings.vision, vision) || workingModel;
+      const visionDesc =
+        models.find((item) => item.id === bindings.vision) ||
+        models.find((item) => item.modelId === visionModel);
+      const isMultimodal =
+        visionDesc?.capabilities?.includes("vision") ?? Boolean(visionModel);
+      const mainDesc =
+        overrideDesc ||
+        models.find((item) => item.id === bindings.main) ||
+        models.find((item) => item.modelId === model);
+      return {
+        instance,
+        model,
+        working,
+        workingModel,
+        vision,
+        visionModel,
+        isMultimodal,
+        contextWindow: mainDesc?.contextWindow ?? 0,
+      };
+    };
+
+    const host: AgentHost = {
+      ctx,
+      aiService,
+      configService,
+      screenshot,
+      db,
+      approvals,
+      sessions,
+      emotions,
+      getBase: () => cachedBase,
+      getSettings: () => cachedSettings,
+      getChatShared: () => readChatSharedConfig(configService),
+      resolveModel,
+      workspaceRoot: (userId: number) =>
+        workspaceRootFor(cachedBase.workspaceDir, userId),
+      isAllowed: async (userId: number) => {
+        const owners = (ctx.config.owners ?? []).map(Number);
+        if (owners.includes(userId)) return true;
+        if (
+          cachedBase.access.allowAdmins &&
+          (ctx.config.admins ?? []).map(Number).includes(userId)
+        ) {
+          return true;
+        }
+        return normalizeIdList(cachedBase.access.users).includes(userId);
+      },
+      updateBase: async (patch) => {
+        if (configService) {
+          await configService.updateConfig("agent", "base", patch);
+          return;
+        }
+        cachedBase = { ...cachedBase, ...patch };
+      },
+      logger: ctx.logger,
+    };
+
+    registerCommands(host);
+    ctx.handle("message", createMessageHandler(host));
+
+    const resolved = resolveModel();
+    ctx.logger.info(
+      `agent 插件加载成功 (model=${resolved ? resolved.model : "?"}, level=${cachedBase.permissionLevel})`,
+    );
+
+    return () => {
+      approvals.dispose();
+      db.close();
+      ctx.logger.info("agent 插件已卸载");
+    };
+  },
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "mioku-plugin-agent",
+  "version": "0.1.0",
+  "description": "超级用户 Agent 插件",
+  "main": "index.ts",
+  "type": "module",
+  "keywords": [
+    "mioku"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mioku-lab/mioku-plugin-agent.git"
+  },
+  "mioku": {
+    "services": [
+      "ai",
+      "config",
+      "screenshot"
+    ]
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "mioku": "workspace:*"
+  },
+  "peerDependencies": {
+    "mioku": "^1.0.0"
+  }
+}

package/tools/approval.ts

@@ -0,0 +1,119 @@
+import type { AgentPermissionLevel } from "../types";
+
+export interface PendingApproval {
+  id: string;
+  userId: number;
+  command: string;
+  cwd: string;
+  level: AgentPermissionLevel;
+  purpose: string;
+  reason: string;
+  createdAt: number;
+}
+
+interface PendingEntry extends PendingApproval {
+  timer: ReturnType<typeof setTimeout>;
+  resolve: (approved: boolean) => void;
+}
+
+export class ApprovalManager {
+  private pending = new Map<string, PendingEntry>();
+  private latestByUser = new Map<number, string>();
+  private seq = 0;
+
+  create(
+    info: Omit<PendingApproval, "id" | "createdAt">,
+    timeoutMs: number,
+  ): { approval: PendingApproval; promise: Promise<boolean> } {
+    const id = `bash_${Date.now().toString(36)}_${(this.seq++).toString(36)}`;
+    const entry: PendingEntry = {
+      ...info,
+      id,
+      createdAt: Date.now(),
+      timer: setTimeout(() => this.resolve(id, false), Math.max(1, timeoutMs)),
+      resolve: () => {},
+    };
+    const promise = new Promise<boolean>((resolvePromise) => {
+      entry.resolve = resolvePromise;
+    });
+    this.pending.set(id, entry);
+    this.latestByUser.set(info.userId, id);
+    return { approval: entry, promise };
+  }
+
+  resolve(id: string, approved: boolean): boolean {
+    const entry = this.pending.get(id);
+    if (!entry) return false;
+    clearTimeout(entry.timer);
+    this.pending.delete(id);
+    if (this.latestByUser.get(entry.userId) === id) {
+      const next = this.latestFor(entry.userId);
+      if (next) this.latestByUser.set(entry.userId, next);
+      else this.latestByUser.delete(entry.userId);
+    }
+    entry.resolve(approved);
+    return true;
+  }
+
+  resolveLatest(userId: number, approved: boolean): PendingApproval | null {
+    const id = this.latestByUser.get(userId) ?? this.latestFor(userId);
+    if (!id) return null;
+    const entry = this.pending.get(id);
+    if (!entry) return null;
+    const approval = this.toPending(entry);
+    this.resolve(id, approved);
+    return approval;
+  }
+
+  latestByUserId(userId: number): PendingApproval | null {
+    const id = this.latestByUser.get(userId) ?? this.latestFor(userId);
+    const entry = id ? this.pending.get(id) : undefined;
+    return entry ? this.toPending(entry) : null;
+  }
+
+  cancelByUser(userId: number): number {
+    const ids = [...this.pending.values()]
+      .filter((entry) => entry.userId === userId)
+      .map((entry) => entry.id);
+    for (const id of ids) this.resolve(id, false);
+    return ids.length;
+  }
+
+  listByUser(userId: number): PendingApproval[] {
+    return [...this.pending.values()]
+      .filter((entry) => entry.userId === userId)
+      .sort((a, b) => a.createdAt - b.createdAt)
+      .map((entry) => this.toPending(entry));
+  }
+
+  dispose(): void {
+    for (const [id, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      entry.resolve(false);
+      this.pending.delete(id);
+    }
+    this.latestByUser.clear();
+  }
+
+  private latestFor(userId: number): string | undefined {
+    let latest: PendingEntry | undefined;
+    for (const entry of this.pending.values()) {
+      if (entry.userId !== userId) continue;
+      if (!latest || entry.createdAt >= latest.createdAt) latest = entry;
+    }
+    return latest?.id;
+  }
+
+  private toPending(entry: PendingEntry): PendingApproval {
+    return {
+      id: entry.id,
+      userId: entry.userId,
+      command: entry.command,
+      cwd: entry.cwd,
+      level: entry.level,
+      purpose: entry.purpose,
+      reason: entry.reason,
+      createdAt: entry.createdAt,
+    };
+  }
+}

package/tools/bash.ts

@@ -0,0 +1,280 @@
+import * as fs from "node:fs";
+import type { AITool } from "mioku";
+import type { AgentPermissionLevel, BashConfig } from "../types";
+import type { ApprovalManager } from "./approval";
+import type { FsPolicy } from "./perm";
+import { bashRequiresApproval } from "./perm";
+
+const OUTPUT_MAX_CHARS = 20_000;
+const MIN_TIMEOUT_MS = 1_000;
+
+export interface BashApprovalNotice {
+  id: string;
+  command: string;
+  cwd: string;
+  level: AgentPermissionLevel;
+  purpose: string;
+  reason?: string;
+}
+
+export interface BashRunNotice {
+  command: string;
+  cwd: string;
+  level: AgentPermissionLevel;
+  purpose: string;
+  reason?: string;
+}
+
+export interface BashRunResult {
+  exitCode: number | null;
+  timedOut: boolean;
+  error?: string;
+  stdout?: string;
+  stderr?: string;
+}
+
+export interface BashReporter {
+  /** 需要用户审批时立即通知，任何模式都不延迟。 */
+  approval(notice: BashApprovalNotice): Promise<void>;
+  /** 即将自动执行：full 模式攒进操作流水，其余模式立即通知。 */
+  announce(notice: BashRunNotice): Promise<void>;
+  /** 执行结束：full 模式下写入本回合的操作流水，在最终回复前合并转发。 */
+  record(
+    notice: BashRunNotice,
+    result: BashRunResult,
+    startedAt: number,
+  ): void;
+}
+
+interface BashToolDeps {
+  userId: number;
+  policy: FsPolicy;
+  config: BashConfig;
+  approvals: ApprovalManager;
+  reporter: BashReporter;
+  assessRisk?: (
+    command: string,
+    purpose: string,
+  ) => Promise<{
+    dangerous: boolean;
+    reason: string;
+  }>;
+}
+
+interface ExecResult {
+  exitCode: number | null;
+  stdout: string;
+  stderr: string;
+  timedOut: boolean;
+}
+
+const UNIX_SHELL_CANDIDATES = [
+  "/bin/bash",
+  "/usr/bin/bash",
+  "/usr/local/bin/bash",
+  "/bin/sh",
+];
+
+let unixShell: string | null = null;
+
+function resolveUnixShell(): string {
+  if (unixShell) return unixShell;
+  const candidates = [process.env.SHELL, ...UNIX_SHELL_CANDIDATES];
+  unixShell =
+    candidates.find(
+      (candidate): candidate is string =>
+        typeof candidate === "string" &&
+        candidate.length > 0 &&
+        fs.existsSync(candidate),
+    ) ?? "sh";
+  return unixShell;
+}
+
+function shellInvocation(command: string): string[] {
+  if (process.platform === "win32") {
+    const comspec = process.env.ComSpec || process.env.COMSPEC || "cmd.exe";
+    return [comspec, "/d", "/s", "/c", command];
+  }
+  return [resolveUnixShell(), "-c", command];
+}
+
+function shellName(): string {
+  if (process.platform === "win32") return "cmd.exe";
+  return resolveUnixShell();
+}
+
+function shellHint(): string {
+  if (process.platform === "win32") {
+    return "Windows cmd.exe syntax (e.g. dir, type, copy). Do not use bash-only syntax.";
+  }
+  return "POSIX shell syntax (bash/sh).";
+}
+
+async function execShell(
+  command: string,
+  cwd: string,
+  timeoutMs: number,
+): Promise<ExecResult> {
+  fs.mkdirSync(cwd, { recursive: true });
+  const proc = Bun.spawn(shellInvocation(command), {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "ignore",
+  });
+  let timedOut = false;
+  const timer = setTimeout(
+    () => {
+      timedOut = true;
+      proc.kill();
+    },
+    Math.max(MIN_TIMEOUT_MS, timeoutMs),
+  );
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+  const exitCode = await proc.exited;
+  clearTimeout(timer);
+  return {
+    exitCode,
+    stdout: stdout.slice(0, OUTPUT_MAX_CHARS),
+    stderr: stderr.slice(0, OUTPUT_MAX_CHARS),
+    timedOut,
+  };
+}
+
+export function createBashTool(deps: BashToolDeps): AITool {
+  const { userId, policy, config, approvals, reporter } = deps;
+  return {
+    name: "bash",
+    description:
+      `Execute a shell command with ${shellName()} (${shellHint()}). ` +
+      "Always pass `purpose`: a short human-readable reason for running this command, shown to the user. " +
+      (bashRequiresApproval(policy.level)
+        ? `Runs in ${policy.level} mode: each command requires explicit user approval in the chat before execution. Working directory is the workspace (${policy.workspaceRoot}).`
+        : policy.level === "auto"
+          ? `Runs in auto mode: commands execute without asking first, but every command is reviewed by the working model and destructive ones still require the user's approval. Working directory is the workspace (${policy.workspaceRoot}).`
+          : policy.level === "yolo"
+            ? `Runs in yolo mode without approval and without notifying the user. Working directory defaults to the workspace (${policy.workspaceRoot}).`
+            : `Runs in full mode without approval; every command and its purpose is collected and reported to the user as one merged record after the turn. Working directory defaults to the workspace (${policy.workspaceRoot}).`),
+    parameters: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: `The shell command to execute (${shellName()}, ${shellHint()})`,
+        },
+        purpose: {
+          type: "string",
+          description:
+            "Short reason for this command (what it does and why), shown to the user for approval/notification",
+        },
+        timeout_ms: {
+          type: "number",
+          description: "Timeout in milliseconds (default from config)",
+        },
+      },
+      required: ["command", "purpose"],
+    },
+    handler: async (args: Record<string, unknown>) => {
+      const command = String(args?.command ?? "").trim();
+      if (!command) return { error: "command must be a non-empty string" };
+      const purpose = String(args?.purpose ?? "").trim();
+      if (!purpose) {
+        return {
+          error:
+            "purpose must be a non-empty string: describe what this command does and why it is needed",
+        };
+      }
+      if (!config.enabled) {
+        return { error: "bash execution is disabled in agent settings" };
+      }
+
+      const verdict = bashRequiresApproval(policy.level)
+        ? {
+            dangerous: true,
+            reason: `${policy.level} 模式下每条命令都需要审批`,
+          }
+        : deps.assessRisk
+          ? await deps.assessRisk(command, purpose)
+          : { dangerous: false, reason: "" };
+
+      const notice: BashRunNotice = {
+        command,
+        cwd: policy.workspaceRoot,
+        level: policy.level,
+        purpose,
+        reason: verdict.reason,
+      };
+
+      if (verdict.dangerous) {
+        const { approval, promise } = approvals.create(
+          {
+            userId,
+            command,
+            cwd: policy.workspaceRoot,
+            level: policy.level,
+            purpose,
+            reason: verdict.reason,
+          },
+          config.approvalTimeoutMs,
+        );
+        await reporter
+          .approval({
+            id: approval.id,
+            command: approval.command,
+            cwd: approval.cwd,
+            level: approval.level,
+            purpose: approval.purpose,
+            reason: approval.reason,
+          })
+          .catch(() => {});
+        const approved = await promise;
+        if (!approved) {
+          return {
+            success: false,
+            error:
+              "The user denied the command (or the approval request timed out). Do not retry the same command; adjust the plan or ask the user.",
+          };
+        }
+      } else {
+        await reporter.announce(notice).catch(() => {});
+      }
+
+      const timeoutMs = Math.max(
+        MIN_TIMEOUT_MS,
+        Math.floor(Number(args?.timeout_ms) || config.timeoutMs),
+      );
+      const startedAt = Date.now();
+      try {
+        const result = await execShell(
+          command,
+          policy.workspaceRoot,
+          timeoutMs,
+        );
+        reporter.record(notice, result, startedAt);
+        if (result.timedOut) {
+          return {
+            success: false,
+            error: `Command timed out after ${timeoutMs}ms and was killed.`,
+            stdout: result.stdout,
+            stderr: result.stderr,
+          };
+        }
+        return {
+          exitCode: result.exitCode,
+          stdout: result.stdout,
+          stderr: result.stderr,
+        };
+      } catch (err) {
+        reporter.record(
+          notice,
+          { exitCode: null, timedOut: false, error: String(err) },
+          startedAt,
+        );
+        return { error: `Failed to execute command: ${err}` };
+      }
+    },
+  };
+}