@dyyz1993/create-agent 1.9.0

package/templates/agent/src/shared/handlers/file.ts

@@ -0,0 +1,99 @@
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import type { MethodParams, MethodResult } from "@dyyz1993/rpc-core";
+import type { RPCMethods, HandlerOptions } from "../rpc-schema";
+import { readdir, stat, writeFile, readFile, mkdir, rename, rm, cp } from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { createLogger } from "../lib/logger";
+import { validatePath } from "../lib/path-security";
+
+const log = createLogger("file");
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+  method: K,
+  handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+export function register(server: RPCServer, _options: HandlerOptions): void {
+  const r: RegisterFn = (method, handler) => {
+    server.register(method, handler as (params: unknown) => Promise<unknown>);
+  };
+
+  r("file.findProjectRoot", async () => {
+    let dir = process.cwd();
+    for (let i = 0; i < 20; i++) {
+      if (existsSync(join(dir, "package.json"))) return { path: dir };
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    return { path: process.cwd() };
+  });
+
+  r("file.listDir", async (params) => {
+    const basePath = validatePath(params.path || process.cwd());
+    const entries: { name: string; path: string; type: "file" | "directory"; size?: number }[] = [];
+    try {
+      const files = await readdir(basePath);
+      for (const name of files) {
+        const fullPath = join(basePath, name);
+        try {
+          const s = await stat(fullPath);
+          entries.push({
+            name,
+            path: fullPath,
+            type: s.isDirectory() ? "directory" : "file",
+            size: s.size,
+          });
+        } catch {
+          entries.push({ name, path: fullPath, type: "file" });
+        }
+      }
+    } catch (err) {
+      log.error("listDir error", { error: err });
+    }
+    return { entries, basePath };
+  });
+
+  r("file.createFile", async (params) => {
+    const dirPath = validatePath(params.dirPath);
+    const filePath = join(dirPath, params.name);
+    await writeFile(filePath, "");
+    return { path: filePath };
+  });
+
+  r("file.createDir", async (params) => {
+    const dirPath = validatePath(params.dirPath);
+    const fullDirPath = join(dirPath, params.name);
+    await mkdir(fullDirPath, { recursive: true });
+    return { path: fullDirPath };
+  });
+
+  r("file.rename", async (params) => {
+    const oldPath = validatePath(params.oldPath);
+    const newPath = join(dirname(oldPath), params.newName);
+    await rename(oldPath, newPath);
+    return { newPath };
+  });
+
+  r("file.delete", async (params) => {
+    const safePath = validatePath(params.path);
+    await rm(safePath, { recursive: true, force: true });
+    return { ok: true };
+  });
+
+  r("file.copy", async (params) => {
+    const srcPath = validatePath(params.srcPath);
+    const destDir = validatePath(params.destDir);
+    const name = srcPath.split("/").pop() || srcPath;
+    const destPath = join(destDir, name);
+    await cp(srcPath, destPath, { recursive: true });
+    return { path: destPath };
+  });
+
+  r("file.readFile", async (params) => {
+    const filePath = validatePath(params.path);
+    const content = await readFile(filePath);
+    return { content: content.toString(), size: content.length };
+  });
+}

package/templates/agent/src/shared/handlers/git.ts

@@ -0,0 +1,263 @@
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import type { MethodParams, MethodResult } from "@dyyz1993/rpc-core";
+import type { RPCMethods, HandlerOptions } from "../rpc-schema";
+import type { GitFileChange } from "../modules/git";
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+  method: K,
+  handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+function execGit(args: string[], cwd: string, allowNonZero = false): string {
+  const proc = Bun.spawnSync(["git", ...args], { cwd, stdout: "pipe", stderr: "pipe" });
+  if (proc.exitCode !== 0 && !allowNonZero) {
+    throw new Error(proc.stderr.toString().trim() || `git ${args[0]} failed`);
+  }
+  return proc.stdout.toString();
+}
+
+function getRepoRoot(cwd: string): string {
+  return execGit(["rev-parse", "--show-toplevel"], cwd).trim();
+}
+
+function parseStatus(output: string): {
+  staged: GitFileChange[];
+  changed: GitFileChange[];
+  untracked: string[];
+} {
+  const staged: GitFileChange[] = [];
+  const changed: GitFileChange[] = [];
+  const untracked: string[] = [];
+
+  for (const line of output.split("\n")) {
+    if (!line.trim()) continue;
+    const xy = line.slice(0, 2);
+    const filePath = line.slice(3).trim();
+
+    const statusMap: Record<string, "modified" | "added" | "deleted" | "renamed" | "copied"> = {
+      M: "modified", A: "added", D: "deleted", R: "renamed", C: "copied",
+    };
+
+    // Index (staged) - first char
+    const indexStatus = xy[0];
+    if (indexStatus !== " " && indexStatus !== "?" && statusMap[indexStatus]) {
+      const path = indexStatus === "R" ? filePath.split(" -> ")[1] : filePath;
+      staged.push({ path, status: statusMap[indexStatus] });
+    }
+
+    // Working tree - second char
+    const wtStatus = xy[1];
+    if (wtStatus !== " " && wtStatus !== "?" && statusMap[wtStatus]) {
+      changed.push({ path: filePath, status: statusMap[wtStatus] });
+    }
+
+    // Untracked
+    if (xy === "??") {
+      untracked.push(filePath);
+    }
+  }
+
+  return { staged, changed, untracked };
+}
+
+export function register(server: RPCServer, _options: HandlerOptions): void {
+  const r: RegisterFn = (method, handler) => {
+    server.register(method, handler as (params: unknown) => Promise<unknown>);
+  };
+
+  r("git.status", async (params) => {
+    const repoRoot = getRepoRoot(params.repoPath);
+    const output = execGit(["status", "--porcelain=v1", "--branch"], repoRoot);
+    const lines = output.split("\n");
+
+    // Parse branch info from first line
+    const branchLine = lines[0] || "";
+    const branchMatch = branchLine.match(/^## (.+?)(?:\.\.\.(\S+))?(?:\s+\[(ahead\s+(\d+))?(?:,\s*)?(behind\s+(\d+))?\])?$/);
+    const branch = branchMatch?.[1]?.replace("HEAD detached", "").replace(/[()]/g, "").trim() || "unknown";
+    const ahead = branchMatch?.[3] ? parseInt(branchMatch[3]) : 0;
+    const behind = branchMatch?.[5] ? parseInt(branchMatch[5]) : 0;
+
+    const { staged, changed, untracked } = parseStatus(lines.slice(1).join("\n"));
+
+    return { staged, changed, untracked, branch, ahead, behind };
+  });
+
+  r("git.diff", async (params) => {
+    const repoRoot = getRepoRoot(params.repoPath);
+    let diff = "";
+    if (params.staged) {
+      diff = execGit(["diff", "--cached", "--", params.filePath], repoRoot);
+    } else {
+      diff = execGit(["diff", "--", params.filePath], repoRoot);
+      if (!diff) {
+        try {
+          diff = execGit(["diff", "--no-index", "/dev/null", params.filePath], repoRoot, true);
+        } catch {
+          // ignore
+        }
+      }
+    }
+
+    // Get old content (HEAD version) and new content (working tree)
+    let oldContent = "";
+    let newContent = "";
+    try {
+      oldContent = execGit(["show", `HEAD:${params.filePath}`], repoRoot);
+    } catch {
+      // New file — no old content
+    }
+    try {
+      const { readFile } = await import("fs/promises");
+      const { join } = await import("path");
+      newContent = (await readFile(join(repoRoot, params.filePath))).toString();
+    } catch {
+      // Deleted file — no new content
+    }
+
+    return { filePath: params.filePath, diff, oldContent, newContent };
+  });
+
+  r("git.log", async (params) => {
+    const repoRoot = getRepoRoot(params.repoPath);
+    const count = params.maxCount || 50;
+    const output = execGit([
+      "log", `--max-count=${count}`,
+      "--pretty=format:%H|%h|%s|%an|%aI",
+    ], repoRoot);
+
+    const commits = output.split("\n").filter(Boolean).map((line) => {
+      const [hash, shortHash, message, author, date] = line.split("|");
+      return { hash, shortHash, message, author, date };
+    });
+
+    return { commits };
+  });
+
+  r("git.commitFiles", async (params) => {
+    const repoRoot = getRepoRoot(params.repoPath);
+    const output = execGit([
+      "diff-tree", "--no-commit-id", "--name-status", "-r", params.hash,
+    ], repoRoot);
+
+    const statusMap: Record<string, GitFileChange["status"]> = {
+      M: "modified", A: "added", D: "deleted", R: "renamed", C: "copied",
+    };
+
+    const files: GitFileChange[] = output.split("\n").filter(Boolean).map((line) => {
+      const [status, ...pathParts] = line.split("\t");
+      const path = pathParts.join("\t"); // handle paths with tabs (renames: old\tnew)
+      return { path: status === "R" ? path.split("\t").pop()! : path, status: statusMap[status] || "modified" };
+    });
+
+    return { files };
+  });
+
+  r("git.commitFileDiff", async (params) => {
+    const repoRoot = getRepoRoot(params.repoPath);
+    const { hash, filePath } = params;
+
+    // Get the diff for this file in this commit
+    const diff = execGit(["diff", `${hash}^..${hash}`, "--", filePath], repoRoot, true);
+
+    // Get old content (parent commit version)
+    let oldContent = "";
+    try {
+      oldContent = execGit(["show", `${hash}^:${filePath}`], repoRoot);
+    } catch {
+      // File was added in this commit — no old content
+    }
+
+    // Get new content (this commit version)
+    let newContent = "";
+    try {
+      newContent = execGit(["show", `${hash}:${filePath}`], repoRoot);
+    } catch {
+      // File was deleted in this commit — no new content
+    }
+
+    return { filePath, diff, oldContent, newContent };
+  });
+
+  r("git.branches", async (params) => {
+    const repoRoot = getRepoRoot(params.repoPath);
+    const output = execGit(["branch", "-a", "--no-color"], repoRoot);
+    const branches = output.split("\n").filter(Boolean).map((line) => {
+      const isCurrent = line.startsWith("*");
+      const name = line.replace(/^\*?\s+/, "").trim();
+      const isRemote = name.startsWith("remotes/");
+      return { name, isCurrent, isRemote };
+    });
+    return { branches };
+  });
+
+  r("git.checkout", async (params) => {
+    const repoRoot = getRepoRoot(params.repoPath);
+    execGit(["checkout", params.branch], repoRoot);
+    return { ok: true };
+  });
+
+  r("git.add", async (params) => {
+    const repoRoot = getRepoRoot(params.repoPath);
+    execGit(["add", ...params.paths], repoRoot);
+    return { ok: true };
+  });
+
+  r("git.reset", async (params) => {
+    const repoRoot = getRepoRoot(params.repoPath);
+    execGit(["reset", "HEAD", "--", ...params.paths], repoRoot);
+    return { ok: true };
+  });
+
+  r("git.commit", async (params) => {
+    const repoRoot = getRepoRoot(params.repoPath);
+    const output = execGit(["commit", "-m", params.message], repoRoot);
+    // Extract hash from output like "[main abc1234] message"
+    const hashMatch = output.match(/\[[\w\-/.]+\s+([0-9a-f]{7,40})\]/);
+    const shortHash = hashMatch?.[1] || "";
+    let hash = "";
+    if (shortHash) {
+      hash = execGit(["rev-parse", shortHash], repoRoot).trim();
+    }
+    return { hash, shortHash };
+  });
+
+  r("git.push", async (params) => {
+    const repoRoot = getRepoRoot(params.repoPath);
+    execGit(["push"], repoRoot);
+    return { ok: true };
+  });
+
+  r("git.pull", async (params) => {
+    const repoRoot = getRepoRoot(params.repoPath);
+    execGit(["pull"], repoRoot);
+    return { ok: true };
+  });
+
+  r("git.worktreeList", async (params) => {
+    const repoRoot = getRepoRoot(params.repoPath);
+    const output = execGit(["worktree", "list", "--porcelain"], repoRoot);
+    const worktrees: { path: string; branch: string; isMain: boolean }[] = [];
+    let current: Partial<typeof worktrees[0]> = {};
+
+    for (const line of output.split("\n")) {
+      if (line.startsWith("worktree ")) {
+        if (current.path) {
+          worktrees.push({ path: current.path!, branch: current.branch || "", isMain: !!current.isMain });
+        }
+        current = { path: line.slice(9), isMain: false };
+      } else if (line.startsWith("branch ")) {
+        current.branch = line.slice(7).replace("refs/heads/", "");
+      } else if (line === "bare") {
+        current.isMain = false;
+      } else if (line === "" && current.path) {
+        // first worktree is main
+        if (worktrees.length === 0) current.isMain = true;
+      }
+    }
+    if (current.path) {
+      worktrees.push({ path: current.path!, branch: current.branch || "", isMain: !!current.isMain });
+    }
+
+    return { worktrees };
+  });
+}

package/templates/agent/src/shared/handlers/index.ts

@@ -0,0 +1,10 @@
+// Handler barrel — 新增模块在此加一行 export
+export { register as system } from "./system";
+export { register as file } from "./file";
+export { register as timer } from "./timer";
+export { register as chat } from "./chat";
+export { register as git } from "./git";
+export { register as feed } from "./feed";
+export { register as bash } from "./bash";
+export { register as rules } from "./rules";
+export { register as todo } from "./todo";

package/templates/agent/src/shared/handlers/rules.ts

@@ -0,0 +1,45 @@
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import type { MethodParams, MethodResult } from "@dyyz1993/rpc-core";
+import type { RPCMethods, HandlerOptions } from "../rpc-schema";
+import type { Rule } from "../modules/rules";
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+  method: K,
+  handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+const rules: Rule[] = [];
+let ruleIdCounter = 1;
+
+export function register(server: RPCServer, _options: HandlerOptions): void {
+  const r: RegisterFn = (method, handler) => {
+    server.register(method, handler as (params: unknown) => Promise<unknown>);
+  };
+
+  r("rules.list", async () => ({ rules }));
+
+  r("rules.add", async (params) => {
+    const rule: Rule = {
+      id: `rule-${ruleIdCounter++}`,
+      name: params.name,
+      pattern: params.pattern,
+      enabled: true,
+    };
+    rules.push(rule);
+    return { rule };
+  });
+
+  r("rules.toggle", async (params) => {
+    const rule = rules.find((r) => r.id === params.id);
+    if (!rule) throw new Error(`Rule ${params.id} not found`);
+    rule.enabled = !rule.enabled;
+    return { rule };
+  });
+
+  r("rules.remove", async (params) => {
+    const idx = rules.findIndex((r) => r.id === params.id);
+    if (idx === -1) return { success: false };
+    rules.splice(idx, 1);
+    return { success: true };
+  });
+}

package/templates/agent/src/shared/handlers/system.ts

@@ -0,0 +1,27 @@
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import type { MethodParams, MethodResult } from "@dyyz1993/rpc-core";
+import type { RPCMethods, HandlerOptions } from "../rpc-schema";
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+  method: K,
+  handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+export function register(server: RPCServer, options: HandlerOptions): void {
+  const r: RegisterFn = (method, handler) => {
+    server.register(method, handler as (params: unknown) => Promise<unknown>);
+  };
+
+  r("system.ping", async () => ({
+    pong: true,
+    timestamp: Date.now(),
+    platform: options.platform,
+  }));
+
+  r("system.hello", async (params) => ({
+    message: `Hello ${params.name || "World"}!`,
+    timestamp: Date.now(),
+  }));
+
+  r("system.echo", async (params) => params);
+}

package/templates/agent/src/shared/handlers/timer.ts

@@ -0,0 +1,34 @@
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import type { MethodParams, MethodResult } from "@dyyz1993/rpc-core";
+import type { RPCMethods, HandlerOptions } from "../rpc-schema";
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+  method: K,
+  handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+export function register(server: RPCServer, _options: HandlerOptions): void {
+  const r: RegisterFn = (method, handler) => {
+    server.register(method, handler as (params: unknown) => Promise<unknown>);
+  };
+
+  let timerId: ReturnType<typeof setInterval> | null = null;
+
+  r("timer.start", async () => {
+    if (timerId !== null) return { alreadyRunning: true };
+    let count = 0;
+    timerId = setInterval(() => {
+      count++;
+      server.emitEvent("timer.tick", { count, timestamp: Date.now() }, { channel: "default" });
+    }, 1000);
+    return { started: true };
+  });
+
+  r("timer.stop", async () => {
+    if (timerId !== null) {
+      clearInterval(timerId);
+      timerId = null;
+    }
+    return { stopped: true };
+  });
+}

package/templates/agent/src/shared/handlers/todo.ts

@@ -0,0 +1,45 @@
+import type { RPCServer } from "@dyyz1993/rpc-core";
+import type { MethodParams, MethodResult } from "@dyyz1993/rpc-core";
+import type { RPCMethods, HandlerOptions } from "../rpc-schema";
+import type { TodoItem, TodoStatus } from "../modules/todo";
+
+type RegisterFn = <K extends keyof RPCMethods & string>(
+  method: K,
+  handler: (params: MethodParams<RPCMethods, K>) => Promise<MethodResult<RPCMethods, K>>,
+) => void;
+
+const items: TodoItem[] = [];
+let todoIdCounter = 1;
+
+export function register(server: RPCServer, _options: HandlerOptions): void {
+  const r: RegisterFn = (method, handler) => {
+    server.register(method, handler as (params: unknown) => Promise<unknown>);
+  };
+
+  r("todo.list", async () => ({ items }));
+
+  r("todo.add", async (params) => {
+    const item: TodoItem = {
+      id: `todo-${todoIdCounter++}`,
+      content: params.content,
+      status: "pending",
+      createdAt: Date.now(),
+    };
+    items.push(item);
+    return { item };
+  });
+
+  r("todo.update", async (params) => {
+    const item = items.find((i) => i.id === params.id);
+    if (!item) throw new Error(`Todo ${params.id} not found`);
+    item.status = params.status as TodoStatus;
+    return { item };
+  });
+
+  r("todo.remove", async (params) => {
+    const idx = items.findIndex((i) => i.id === params.id);
+    if (idx === -1) return { success: false };
+    items.splice(idx, 1);
+    return { success: true };
+  });
+}

package/templates/agent/src/shared/lib/__tests__/bash-security.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  isCommandAllowed,
+  validateCommand,
+  setCommandPolicy,
+} from "../bash-security";
+
+describe("bash-security", () => {
+  describe("default policy (enabled with blocked list)", () => {
+    beforeEach(() => {
+      setCommandPolicy({
+        enabled: true,
+        blockedPatterns: [
+          /rm\s+-rf\s+(.*\s)?\/($|\s)/,
+          /rm\s+-rf\s+--no-preserve-root/,
+          /mkfs/,
+          /dd\s+if=/,
+          />\s*\/dev\//,
+          /:()\s*\{.*\|.*&\s*\}/,
+          /shutdown/,
+          /reboot/,
+        ],
+        allowedCommands: null,
+      });
+    });
+
+    it("should allow normal commands", () => {
+      expect(isCommandAllowed("ls -la")).toBe(true);
+      expect(isCommandAllowed("git status")).toBe(true);
+      expect(isCommandAllowed("npm install")).toBe(true);
+      expect(isCommandAllowed("echo hello")).toBe(true);
+    });
+
+    it("should block dangerous rm -rf /", () => {
+      expect(isCommandAllowed("rm -rf /")).toBe(false);
+      expect(isCommandAllowed("rm -rf --no-preserve-root /")).toBe(false);
+    });
+
+    it("should block mkfs commands", () => {
+      expect(isCommandAllowed("mkfs.ext4 /dev/sda1")).toBe(false);
+    });
+
+    it("should block dd write commands", () => {
+      expect(isCommandAllowed("dd if=/dev/zero of=/dev/sda")).toBe(false);
+    });
+
+    it("should block redirect to device files", () => {
+      expect(isCommandAllowed("echo data > /dev/sda")).toBe(false);
+    });
+
+    it("should block shutdown and reboot", () => {
+      expect(isCommandAllowed("shutdown now")).toBe(false);
+      expect(isCommandAllowed("reboot")).toBe(false);
+    });
+
+    it("should allow rm in project directory", () => {
+      expect(isCommandAllowed("rm -rf ./node_modules")).toBe(true);
+      expect(isCommandAllowed("rm -rf ./dist")).toBe(true);
+    });
+  });
+
+  describe("disabled policy", () => {
+    it("should reject all commands when disabled", () => {
+      setCommandPolicy({
+        enabled: false,
+        blockedPatterns: [],
+        allowedCommands: null,
+      });
+      expect(isCommandAllowed("ls")).toBe(false);
+      expect(isCommandAllowed("echo hello")).toBe(false);
+    });
+  });
+
+  describe("whitelist policy", () => {
+    it("should only allow whitelisted commands", () => {
+      setCommandPolicy({
+        enabled: true,
+        blockedPatterns: [],
+        allowedCommands: ["git", "npm", "node", "ls", "cat", "echo"],
+      });
+      expect(isCommandAllowed("git status")).toBe(true);
+      expect(isCommandAllowed("npm test")).toBe(true);
+      expect(isCommandAllowed("python script.py")).toBe(false);
+    });
+  });
+
+  describe("validateCommand", () => {
+    it("should return trimmed command for allowed commands", () => {
+      setCommandPolicy({
+        enabled: true,
+        blockedPatterns: [],
+        allowedCommands: null,
+      });
+      expect(validateCommand("  ls -la  ")).toBe("ls -la");
+    });
+
+    it("should throw for blocked commands", () => {
+      setCommandPolicy({
+        enabled: true,
+        blockedPatterns: [/rm\s+-rf\s+\//],
+        allowedCommands: null,
+      });
+      expect(() => validateCommand("rm -rf /")).toThrow("blocked");
+    });
+
+    it("should throw when bash is disabled", () => {
+      setCommandPolicy({
+        enabled: false,
+        blockedPatterns: [],
+        allowedCommands: null,
+      });
+      expect(() => validateCommand("ls")).toThrow("disabled");
+    });
+
+    it("should throw for empty commands", () => {
+      setCommandPolicy({
+        enabled: true,
+        blockedPatterns: [],
+        allowedCommands: null,
+      });
+      expect(() => validateCommand("")).toThrow("empty");
+      expect(() => validateCommand("   ")).toThrow("empty");
+    });
+  });
+});