@dyyz1993/create-agent 1.9.0

package/templates/agent/src/shared/lib/__tests__/logger.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdirSync, existsSync, readdirSync, readFileSync, writeFileSync, rmSync, utimesSync } from "fs";
+import { join } from "path";
+
+const TEST_LOG_DIR = join(process.cwd(), "test-logs");
+
+describe("Logger", () => {
+  beforeEach(async () => {
+    if (existsSync(TEST_LOG_DIR)) {
+      rmSync(TEST_LOG_DIR, { recursive: true, force: true });
+    }
+    mkdirSync(TEST_LOG_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(TEST_LOG_DIR)) {
+      rmSync(TEST_LOG_DIR, { recursive: true, force: true });
+    }
+  });
+
+  it("should write logs asynchronously", async () => {
+    const { createLogger, configureLogDir, flushLogs } = await import("../logger");
+    await configureLogDir(TEST_LOG_DIR);
+
+    const logger = createLogger("test");
+    logger.info("test message");
+
+    await flushLogs();
+    await new Promise((r) => setTimeout(r, 100));
+
+    const files = readdirSync(TEST_LOG_DIR);
+    expect(files.length).toBeGreaterThan(0);
+
+    const content = readFileSync(join(TEST_LOG_DIR, files[0]), "utf-8");
+    expect(content).toContain("test message");
+  });
+
+  it("should support multiple log levels", async () => {
+    const { createLogger, configureLogDir, flushLogs } = await import("../logger");
+    await configureLogDir(TEST_LOG_DIR);
+
+    const logger = createLogger("test");
+    logger.debug("debug msg");
+    logger.info("info msg");
+    logger.warn("warn msg");
+    logger.error("error msg");
+
+    await flushLogs();
+
+    const files = readdirSync(TEST_LOG_DIR);
+    const content = readFileSync(join(TEST_LOG_DIR, files[0]), "utf-8");
+    expect(content).toContain("info msg");
+    expect(content).toContain("warn msg");
+    expect(content).toContain("error msg");
+  });
+
+  it("should clean up old log files based on maxAgeDays", async () => {
+    const { configureLogDir } = await import("../logger");
+
+    const oldDate = new Date(Date.now() - 10 * 86400000).toISOString().slice(0, 10);
+    const oldPath = join(TEST_LOG_DIR, `${oldDate}.log`);
+    writeFileSync(oldPath, "old log");
+    const oldTime = new Date(Date.now() - 10 * 86400000);
+    utimesSync(oldPath, oldTime, oldTime);
+
+    const todayFile = new Date().toISOString().slice(0, 10);
+    writeFileSync(join(TEST_LOG_DIR, `${todayFile}.log`), "today log");
+
+    await configureLogDir(TEST_LOG_DIR, { maxAgeDays: 5 });
+
+    const files = readdirSync(TEST_LOG_DIR);
+    expect(files.find((f) => f.includes(oldDate))).toBeUndefined();
+    expect(files.find((f) => f.includes(todayFile))).toBeDefined();
+  });
+
+  it("should flush all pending writes", async () => {
+    const { createLogger, configureLogDir, flushLogs } = await import("../logger");
+    await configureLogDir(TEST_LOG_DIR);
+
+    const logger = createLogger("test");
+    for (let i = 0; i < 100; i++) {
+      logger.info(`msg ${i}`);
+    }
+
+    await flushLogs();
+
+    const files = readdirSync(TEST_LOG_DIR);
+    const content = readFileSync(join(TEST_LOG_DIR, files[0]), "utf-8");
+    expect(content).toContain("msg 0");
+    expect(content).toContain("msg 99");
+  });
+});

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

@@ -0,0 +1,77 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { validatePath, isRpcPathAllowed, setAllowedRoots } from "../path-security";
+
+describe("path-security", () => {
+  const originalCwd = process.cwd();
+  const originalEnv = process.env.NODE_ENV;
+
+  beforeEach(() => {
+    setAllowedRoots([process.cwd()]);
+  });
+
+  afterEach(() => {
+    process.env.NODE_ENV = originalEnv;
+  });
+
+  describe("isRpcPathAllowed", () => {
+    it("should allow paths within project root", () => {
+      expect(isRpcPathAllowed(`${originalCwd}/src/main.ts`)).toBe(true);
+    });
+
+    it("should allow project root itself", () => {
+      expect(isRpcPathAllowed(originalCwd)).toBe(true);
+    });
+
+    it("should reject paths outside project root", () => {
+      expect(isRpcPathAllowed("/etc/passwd")).toBe(false);
+      expect(isRpcPathAllowed("/etc/shadow")).toBe(false);
+    });
+
+    it("should reject path traversal attempts", () => {
+      expect(isRpcPathAllowed(`${originalCwd}/../../../etc/passwd`)).toBe(false);
+    });
+
+    it("should reject paths with encoded traversal", () => {
+      expect(isRpcPathAllowed(`${originalCwd}/%2e%2e/etc/passwd`)).toBe(false);
+    });
+
+    it("should handle relative paths", () => {
+      expect(isRpcPathAllowed("./src/main.ts")).toBe(true);
+      expect(isRpcPathAllowed("../../etc/passwd")).toBe(false);
+    });
+
+    it("should handle null bytes", () => {
+      expect(isRpcPathAllowed(`${originalCwd}/file.txt\0/etc/passwd`)).toBe(false);
+    });
+
+    it("should work with multiple allowed roots", () => {
+      setAllowedRoots([originalCwd, "/tmp/test"]);
+      expect(isRpcPathAllowed("/tmp/test/file.txt")).toBe(true);
+      expect(isRpcPathAllowed("/tmp/other/file.txt")).toBe(false);
+    });
+  });
+
+  describe("validatePath", () => {
+    it("should return resolved path for allowed paths", () => {
+      const result = validatePath("./src/main.ts");
+      expect(result).toContain("src/main.ts");
+    });
+
+    it("should throw for paths outside allowed roots", () => {
+      expect(() => validatePath("/etc/passwd")).toThrow("Access denied");
+    });
+
+    it("should throw for path traversal attempts", () => {
+      expect(() => validatePath("../../../etc/passwd")).toThrow("Access denied");
+    });
+
+    it("should throw for null byte injection", () => {
+      expect(() => validatePath("file.txt\0/evil")).toThrow("Access denied");
+    });
+
+    it("should normalize the returned path", () => {
+      const result = validatePath("./src/../src/./main.ts");
+      expect(result).toBe(`${originalCwd}/src/main.ts`);
+    });
+  });
+});

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

@@ -0,0 +1,64 @@
+export interface CommandPolicy {
+  enabled: boolean;
+  blockedPatterns: RegExp[];
+  allowedCommands: string[] | null;
+}
+
+let policy: CommandPolicy = {
+  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,
+};
+
+export function setCommandPolicy(p: CommandPolicy): void {
+  policy = p;
+}
+
+export function isCommandAllowed(command: string): boolean {
+  if (!policy.enabled) return false;
+
+  const trimmed = command.trim();
+  if (!trimmed) return false;
+
+  for (const pattern of policy.blockedPatterns) {
+    if (pattern.test(trimmed)) return false;
+  }
+
+  if (policy.allowedCommands) {
+    const baseCommand = trimmed.split(/\s+/)[0];
+    return policy.allowedCommands.some(
+      (allowed) => baseCommand === allowed || baseCommand.startsWith(allowed),
+    );
+  }
+
+  return true;
+}
+
+export function validateCommand(command: string): string {
+  if (!policy.enabled) {
+    throw new Error("Bash execution is disabled");
+  }
+
+  const trimmed = command.trim();
+  if (!trimmed) {
+    throw new Error("Command cannot be empty");
+  }
+
+  if (!isCommandAllowed(trimmed)) {
+    if (policy.allowedCommands) {
+      throw new Error(`Command not in whitelist: "${trimmed}"`);
+    }
+    throw new Error(`Command blocked for safety: "${trimmed}"`);
+  }
+
+  return trimmed;
+}

package/templates/agent/src/shared/lib/logger.ts

@@ -0,0 +1,130 @@
+import { appendFile, mkdir as mkdirAsync, readdir as readdirAsync, unlink as unlinkAsync, stat as statAsync } from "fs/promises";
+import { mkdirSync, existsSync } from "fs";
+import { join } from "path";
+
+export type LogModule = "server" | "gateway" | "system" | "chat" | "file" | "timer" | "git" | "feed";
+type LogLevel = "debug" | "info" | "warn" | "error";
+
+interface LogEntry {
+  timestamp: string;
+  level: LogLevel;
+  module: LogModule;
+  message: string;
+  data?: Record<string, unknown>;
+}
+
+let _logDir: string | null = null;
+let _maxAgeDays = 30;
+
+export async function configureLogDir(dir: string, options?: { maxAgeDays?: number }): Promise<void> {
+  _logDir = dir;
+  if (options?.maxAgeDays !== undefined) {
+    _maxAgeDays = options.maxAgeDays;
+  }
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  await cleanOldLogs(dir, _maxAgeDays);
+}
+
+function getLogDir(): string {
+  if (!_logDir) {
+    _logDir = "logs";
+    if (!existsSync(_logDir)) {
+      mkdirSync(_logDir, { recursive: true });
+    }
+  }
+  return _logDir;
+}
+
+async function cleanOldLogs(dir: string, maxAgeDays: number): Promise<void> {
+  try {
+    if (!existsSync(dir)) return;
+    const files = await readdirAsync(dir);
+    const cutoff = Date.now() - maxAgeDays * 86400000;
+    for (const f of files) {
+      if (!f.endsWith(".log")) continue;
+      const filePath = join(dir, f);
+      const s = await statAsync(filePath);
+      if (s.mtimeMs < cutoff) {
+        await unlinkAsync(filePath);
+      }
+    }
+  } catch { /* ignore */ }
+}
+
+function formatLine(entry: LogEntry): string {
+  const base = `[${entry.timestamp}] [${entry.level.toUpperCase()}] [${entry.module}] ${entry.message}`;
+  return entry.data ? `${base} ${JSON.stringify(entry.data)}` : base;
+}
+
+let writeQueue: Promise<void> = Promise.resolve();
+
+function writeToFile(line: string): void {
+  writeQueue = writeQueue.then(async () => {
+    try {
+      const date = new Date().toISOString().slice(0, 10);
+      const dir = getLogDir();
+      if (!existsSync(dir)) {
+        await mkdirAsync(dir, { recursive: true });
+      }
+      await appendFile(join(dir, `${date}.log`), `${line}\n`);
+    } catch { /* ignore */ }
+  });
+}
+
+export function flushLogs(): Promise<void> {
+  return writeQueue;
+}
+
+export class Logger {
+  private readonly module: LogModule;
+
+  constructor(module: LogModule) {
+    this.module = module;
+  }
+
+  debug(message: string, data?: Record<string, unknown>): void {
+    this.write("debug", message, data);
+  }
+
+  info(message: string, data?: Record<string, unknown>): void {
+    this.write("info", message, data);
+  }
+
+  warn(message: string, data?: Record<string, unknown>): void {
+    this.write("warn", message, data);
+  }
+
+  error(message: string, data?: Record<string, unknown>): void {
+    this.write("error", message, data);
+  }
+
+  private write(level: LogLevel, message: string, data?: Record<string, unknown>): void {
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      level,
+      module: this.module,
+      message,
+      ...(data ? { data } : {}),
+    };
+
+    const line = formatLine(entry);
+
+    if (level === "error") {
+      console.error(line);
+    } else if (level === "warn") {
+      console.warn(line);
+    } else {
+      console.log(line);
+    }
+
+    if (process.env.NODE_ENV !== "production" || level !== "debug") {
+      writeToFile(line);
+    }
+  }
+}
+
+export function createLogger(module: LogModule): Logger {
+  return new Logger(module);
+}

package/templates/agent/src/shared/lib/path-security.ts

@@ -0,0 +1,38 @@
+import { resolve } from "path";
+
+let allowedRoots: string[] = [process.cwd()];
+
+export function setAllowedRoots(roots: string[]): void {
+  allowedRoots = roots.map((r) => resolve(r));
+}
+
+export function isRpcPathAllowed(requestedPath: string): boolean {
+  try {
+    if (requestedPath.includes("\0")) return false;
+
+    const decoded = decodeURIComponent(requestedPath);
+    const resolved = resolve(decoded);
+    return allowedRoots.some(
+      (root) => resolved === root || resolved.startsWith(root + "/")
+    );
+  } catch {
+    return false;
+  }
+}
+
+export function validatePath(requestedPath: string): string {
+  if (requestedPath.includes("\0")) {
+    throw new Error(`Access denied: path contains null bytes`);
+  }
+
+  const decoded = decodeURIComponent(requestedPath);
+  const resolved = resolve(decoded);
+
+  if (!isRpcPathAllowed(resolved)) {
+    throw new Error(
+      `Access denied: path "${requestedPath}" is outside allowed roots`
+    );
+  }
+
+  return resolved;
+}

package/templates/agent/src/shared/lib/port-registry.ts

@@ -0,0 +1,103 @@
+/**
+ * Global port registry — tracks all running pi-agent instances.
+ *
+ * File: ~/.pi-agent/ports.json
+ *
+ * Format:
+ * {
+ *   "/absolute/project/path": {
+ *     "port": 3101,
+ *     "pid": 12345,
+ *     "startedAt": "2026-04-29T08:00:00.000Z",
+ *     "name": "my-project"
+ *   }
+ * }
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, basename } from "path";
+import { homedir } from "os";
+
+const REGISTRY_DIR = join(homedir(), ".pi-agent");
+const REGISTRY_FILE = join(REGISTRY_DIR, "ports.json");
+
+export interface PortEntry {
+  port: number;
+  pid: number;
+  startedAt: string;
+  name: string;
+}
+
+export type PortRegistry = Record<string, PortEntry>;
+
+function ensureDir() {
+  if (!existsSync(REGISTRY_DIR)) {
+    mkdirSync(REGISTRY_DIR, { recursive: true });
+  }
+}
+
+export function readRegistry(): PortRegistry {
+  try {
+    if (!existsSync(REGISTRY_FILE)) return {};
+    return JSON.parse(readFileSync(REGISTRY_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function writeRegistry(registry: PortRegistry): void {
+  ensureDir();
+  writeFileSync(REGISTRY_FILE, JSON.stringify(registry, null, 2), "utf-8");
+}
+
+export function registerPort(projectPath: string, port: number, name: string): void {
+  const registry = readRegistry();
+  registry[projectPath] = {
+    port,
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    name: name || basename(projectPath),
+  };
+  writeRegistry(registry);
+}
+
+export function unregisterPort(projectPath: string): void {
+  const registry = readRegistry();
+  delete registry[projectPath];
+  if (Object.keys(registry).length === 0) {
+    writeRegistry(registry);
+  } else {
+    writeRegistry(registry);
+  }
+}
+
+export function cleanupStaleEntries(): void {
+  const registry = readRegistry();
+  let changed = false;
+  for (const [path, entry] of Object.entries(registry)) {
+    try {
+      process.kill(entry.pid, 0);
+    } catch {
+      delete registry[path];
+      changed = true;
+    }
+  }
+  if (changed) writeRegistry(registry);
+}
+
+export function formatRegistryForOutput(): string {
+  cleanupStaleEntries();
+  const registry = readRegistry();
+  const entries = Object.entries(registry);
+  if (entries.length === 0) return "No active instances.";
+
+  const lines = entries.map(([path, entry]) => {
+    const uptime = Math.round((Date.now() - new Date(entry.startedAt).getTime()) / 1000);
+    const uptimeStr = uptime < 60 ? `${uptime}s` : uptime < 3600 ? `${Math.floor(uptime / 60)}m ${uptime % 60}s` : `${Math.floor(uptime / 3600)}h ${Math.floor((uptime % 3600) / 60)}m`;
+    return `  ${entry.name}  →  http://localhost:${entry.port}  (PID ${entry.pid}, up ${uptimeStr})\n  ${path}`;
+  });
+
+  return `Active pi-agent instances (${entries.length}):\n${lines.join("\n\n")}\n\nRegistry: ${REGISTRY_FILE}`;
+}
+
+export { REGISTRY_FILE };

package/templates/agent/src/shared/modules/bash.ts

@@ -0,0 +1,19 @@
+export interface BashMethods {
+  "bash.execute": {
+    params: { command: string; cwd?: string };
+    result: { pid: number; output: string };
+  };
+  "bash.kill": {
+    params: { pid: number };
+    result: { success: boolean };
+  };
+  "bash.listProcesses": {
+    params: {};
+    result: { processes: Array<{ pid: number; command: string; running: boolean }> };
+  };
+}
+
+export interface BashEvents {
+  "bash.output": { pid: number; data: string; stream: "stdout" | "stderr" };
+  "bash.exit": { pid: number; code: number | null };
+}

package/templates/agent/src/shared/modules/chat.ts

@@ -0,0 +1,20 @@
+/**
+ * Chat 模块 — 聊天消息
+ */
+export interface ChatMethods {
+  "chat.list": {
+    params: { limit?: number; cursor?: string };
+    result: {
+      messages: { id: string; role: "user" | "assistant"; content: string; timestamp: number }[];
+      hasMore: boolean;
+    };
+  };
+  "chat.send": {
+    params: { content: string };
+    result: { ok: boolean };
+  };
+}
+
+export interface ChatEvents {
+  "chat.message": { id: string; role: "user" | "assistant"; content: string; timestamp: number };
+}

package/templates/agent/src/shared/modules/feed.ts

@@ -0,0 +1,30 @@
+/**
+ * Feed 模块 — 帖子 & 频道订阅过滤
+ */
+
+type FeedCategory = "tech" | "news" | "general";
+
+interface FeedPost {
+  id: string;
+  content: string;
+  category: FeedCategory;
+  author: string;
+  timestamp: number;
+}
+
+export interface FeedMethods {
+  "feed.post": {
+    params: { content: string; category: FeedCategory; author?: string };
+    result: { id: string };
+  };
+  "feed.list": {
+    params: { category?: FeedCategory; limit?: number };
+    result: { posts: FeedPost[] };
+  };
+}
+
+export interface FeedEvents {
+  "feed.update": FeedPost;
+}
+
+export type { FeedCategory, FeedPost };

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

@@ -0,0 +1,40 @@
+/**
+ * File 模块 — 文件系统操作
+ */
+export interface FileMethods {
+  "file.findProjectRoot": {
+    params: Record<string, never>;
+    result: { path: string };
+  };
+  "file.listDir": {
+    params: { path: string };
+    result: {
+      entries: { name: string; path: string; type: "file" | "directory"; size?: number }[];
+      basePath: string;
+    };
+  };
+  "file.createFile": {
+    params: { dirPath: string; name: string };
+    result: { path: string };
+  };
+  "file.createDir": {
+    params: { dirPath: string; name: string };
+    result: { path: string };
+  };
+  "file.rename": {
+    params: { oldPath: string; newName: string };
+    result: { newPath: string };
+  };
+  "file.delete": {
+    params: { path: string };
+    result: { ok: boolean };
+  };
+  "file.copy": {
+    params: { srcPath: string; destDir: string };
+    result: { path: string };
+  };
+  "file.readFile": {
+    params: { path: string };
+    result: { content: string; size: number };
+  };
+}

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

@@ -0,0 +1,81 @@
+/**
+ * Git 模块 — 版本控制操作
+ */
+export interface GitMethods {
+  "git.status": {
+    params: { repoPath: string };
+    result: {
+      staged: GitFileChange[];
+      changed: GitFileChange[];
+      untracked: string[];
+      branch: string;
+      ahead: number;
+      behind: number;
+    };
+  };
+  "git.diff": {
+    params: { repoPath: string; filePath: string; staged?: boolean };
+    result: { filePath: string; diff: string; oldContent: string; newContent: string };
+  };
+  "git.log": {
+    params: { repoPath: string; maxCount?: number };
+    result: {
+      commits: {
+        hash: string;
+        shortHash: string;
+        message: string;
+        author: string;
+        date: string;
+      }[];
+    };
+  };
+  "git.commitFiles": {
+    params: { repoPath: string; hash: string };
+    result: { files: GitFileChange[] };
+  };
+  "git.commitFileDiff": {
+    params: { repoPath: string; hash: string; filePath: string };
+    result: { filePath: string; diff: string; oldContent: string; newContent: string };
+  };
+  "git.branches": {
+    params: { repoPath: string };
+    result: {
+      branches: { name: string; isCurrent: boolean; isRemote: boolean }[];
+    };
+  };
+  "git.checkout": {
+    params: { repoPath: string; branch: string };
+    result: { ok: boolean };
+  };
+  "git.add": {
+    params: { repoPath: string; paths: string[] };
+    result: { ok: boolean };
+  };
+  "git.reset": {
+    params: { repoPath: string; paths: string[] };
+    result: { ok: boolean };
+  };
+  "git.commit": {
+    params: { repoPath: string; message: string };
+    result: { hash: string; shortHash: string };
+  };
+  "git.push": {
+    params: { repoPath: string };
+    result: { ok: boolean };
+  };
+  "git.pull": {
+    params: { repoPath: string };
+    result: { ok: boolean };
+  };
+  "git.worktreeList": {
+    params: { repoPath: string };
+    result: {
+      worktrees: { path: string; branch: string; isMain: boolean }[];
+    };
+  };
+}
+
+export interface GitFileChange {
+  path: string;
+  status: "modified" | "added" | "deleted" | "renamed" | "copied";
+}