@jiangxiaosheng/digital-agent-platform 1.0.0

package/src/app/api/skills/[name]/route.ts

@@ -0,0 +1,40 @@
+import { NextResponse } from "next/server";
+import { listInstalledSkills } from "@/lib/skills";
+import path from "path";
+import fs from "fs";
+
+export const dynamic = "force-dynamic";
+
+type Params = { params: Promise<{ name: string }> };
+
+export async function GET(_req: Request, { params }: Params) {
+  const { name } = await params;
+  const skills = listInstalledSkills();
+  const skill = skills.find((s) => s.name === decodeURIComponent(name));
+  if (!skill) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const mdPath = fs.statSync(skill.filePath).isDirectory()
+    ? path.join(skill.filePath, "SKILL.md")
+    : skill.filePath;
+  const content = fs.existsSync(mdPath) ? fs.readFileSync(mdPath, "utf8") : "";
+  return NextResponse.json({ ...skill, content });
+}
+
+export async function DELETE(_req: Request, { params }: Params) {
+  const { name } = await params;
+  const skills = listInstalledSkills();
+  const skill = skills.find((s) => s.name === decodeURIComponent(name));
+  if (!skill) return NextResponse.json({ error: "Skill not found" }, { status: 404 });
+
+  try {
+    const stat = fs.statSync(skill.filePath);
+    if (stat.isDirectory()) {
+      fs.rmSync(skill.filePath, { recursive: true, force: true });
+    } else {
+      fs.unlinkSync(skill.filePath);
+    }
+    return NextResponse.json({ success: true });
+  } catch (e) {
+    return NextResponse.json({ error: String(e) }, { status: 500 });
+  }
+}

package/src/app/api/skills/install/route.ts

@@ -0,0 +1,35 @@
+import { NextRequest, NextResponse } from "next/server";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { getSkillsDir } from "@/lib/skills";
+
+export const dynamic = "force-dynamic";
+const execAsync = promisify(exec);
+
+export async function POST(req: NextRequest) {
+  try {
+    const { package: pkg } = await req.json() as { package: string };
+    if (!pkg?.trim()) {
+      return NextResponse.json({ error: "package required" }, { status: 400 });
+    }
+
+    const skillsDir = getSkillsDir();
+    // Install globally into ~/.pi/agent/skills/ via npx skills add
+    const cmd = `npx --yes skills add "${pkg.trim()}" -y --agent pi -g`;
+    const { stdout, stderr } = await execAsync(cmd, {
+      env: { ...process.env, SKILLS_DIR: skillsDir },
+      timeout: 60000,
+    });
+
+    return NextResponse.json({
+      success: true,
+      output: stdout || stderr || "安装完成",
+    });
+  } catch (e: unknown) {
+    const err = e as { message?: string; stdout?: string; stderr?: string };
+    return NextResponse.json({
+      error: err.message ?? String(e),
+      output: err.stderr ?? err.stdout ?? "",
+    }, { status: 500 });
+  }
+}

package/src/app/api/skills/route.ts

@@ -0,0 +1,54 @@
+import { NextRequest, NextResponse } from "next/server";
+import { listInstalledSkills, getSkillsDir, parseFrontmatter } from "@/lib/skills";
+import path from "path";
+import fs from "fs";
+
+export const dynamic = "force-dynamic";
+
+// GET — list installed skills
+export async function GET() {
+  return NextResponse.json(listInstalledSkills());
+}
+
+// POST — install skill from URL or raw markdown
+export async function POST(req: NextRequest) {
+  try {
+    const { url, content, name } = await req.json() as {
+      url?: string; content?: string; name?: string;
+    };
+
+    let markdown = content ?? "";
+
+    if (url && !markdown) {
+      const res = await fetch(url, { signal: AbortSignal.timeout(15000) });
+      if (!res.ok) throw new Error(`HTTP ${res.status} fetching ${url}`);
+      markdown = await res.text();
+    }
+
+    if (!markdown.trim()) {
+      return NextResponse.json({ error: "No skill content provided" }, { status: 400 });
+    }
+
+    const fm = parseFrontmatter(markdown);
+    const skillName = ((fm.name as string) || name || "custom-skill")
+      .trim().toLowerCase()
+      .replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+
+    if (!skillName) {
+      return NextResponse.json({ error: "Could not determine skill name" }, { status: 400 });
+    }
+
+    const dir = getSkillsDir();
+    fs.mkdirSync(dir, { recursive: true });
+
+    const skillDir = path.join(dir, skillName);
+    fs.mkdirSync(skillDir, { recursive: true });
+    fs.writeFileSync(path.join(skillDir, "SKILL.md"), markdown, "utf8");
+
+    const { loadSkillFromPath } = await import("@/lib/skills");
+    const skill = loadSkillFromPath(skillDir, skillName);
+    return NextResponse.json({ success: true, skill }, { status: 201 });
+  } catch (e) {
+    return NextResponse.json({ error: String(e) }, { status: 500 });
+  }
+}

package/src/app/api/skills/search/route.ts

@@ -0,0 +1,60 @@
+import { NextRequest, NextResponse } from "next/server";
+
+export const dynamic = "force-dynamic";
+
+const SKILLS_REGISTRY = "https://skills.sh";
+
+// Actual response shape from skills.sh/api/search
+interface RegistrySkill {
+  id: string;         // "tavily-ai/skills/tavily-search"
+  skillId: string;    // "tavily-search"
+  name: string;
+  installs: number;
+  source: string;     // "tavily-ai/skills"
+}
+
+export interface SkillSearchResult {
+  package: string;        // "tavily-ai/skills@tavily-search"
+  name: string;
+  installs: number;
+  installsDisplay: string;
+  url: string;
+}
+
+function formatInstalls(n: number): string {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
+  return String(n);
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const { query, limit = 30 } = await req.json() as { query: string; limit?: number };
+    if (!query?.trim()) return NextResponse.json({ results: [] });
+
+    const url = `${SKILLS_REGISTRY}/api/search?q=${encodeURIComponent(query.trim())}&limit=${Math.min(limit, 50)}`;
+    const res = await fetch(url, {
+      headers: { "User-Agent": "digital-agent-platform/1.0" },
+      signal: AbortSignal.timeout(10000),
+    });
+
+    if (!res.ok) {
+      return NextResponse.json({ error: `Registry ${res.status}`, results: [] }, { status: 502 });
+    }
+
+    const data = await res.json() as { skills?: RegistrySkill[] };
+    const skills: RegistrySkill[] = data.skills ?? [];
+
+    const results: SkillSearchResult[] = skills.map(s => ({
+      package: `${s.source}@${s.skillId}`,
+      name: s.name,
+      installs: s.installs,
+      installsDisplay: formatInstalls(s.installs),
+      url: `${SKILLS_REGISTRY}/${s.source}/${s.skillId}`,
+    }));
+
+    return NextResponse.json({ results });
+  } catch (e) {
+    return NextResponse.json({ error: String(e), results: [] }, { status: 500 });
+  }
+}

package/src/app/api/tts/route.ts

@@ -0,0 +1,235 @@
+import { NextRequest, NextResponse } from "next/server";
+import OpenAI from "openai";
+import { readVoiceProviderConfig } from "@/lib/voice-providers-config";
+
+export async function POST(req: NextRequest) {
+  try {
+    const { text, speed = 1.0 } = await req.json();
+
+    if (!text) {
+      return NextResponse.json({ error: "Text is required" }, { status: 400 });
+    }
+
+    // 读取全局语音供应商配置
+    const voiceConfig = readVoiceProviderConfig();
+    const provider = voiceConfig.currentProvider;
+
+    // 根据provider调用不同的TTS服务
+    switch (provider) {
+      case "openai":
+        return await handleOpenAITTS(text, speed, voiceConfig);
+      case "aliyun":
+        return await handleAliyunTTS(text, speed, voiceConfig);
+      case "tencent":
+        return await handleTencentTTS(text, speed, voiceConfig);
+      case "baidu":
+        return await handleBaiduTTS(text, speed, voiceConfig);
+      default:
+        return NextResponse.json({ error: "Unknown provider" }, { status: 400 });
+    }
+  } catch (error) {
+    console.error("TTS error:", error);
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "TTS generation failed" },
+      { status: 500 }
+    );
+  }
+}
+
+async function handleOpenAITTS(text: string, speed: number, voiceConfig: any) {
+  const config = voiceConfig.providers.openai;
+  if (!config?.apiKey) {
+    return NextResponse.json({ error: "OpenAI API key not configured" }, { status: 500 });
+  }
+
+  const openai = new OpenAI({ apiKey: config.apiKey });
+
+  const mp3 = await openai.audio.speech.create({
+    model: (config.model || "tts-1") as "tts-1" | "tts-1-hd",
+    voice: (config.voice || "alloy") as "alloy" | "echo" | "fable" | "onyx" | "nova" | "shimmer",
+    input: text,
+    speed: speed,
+  });
+
+  const buffer = Buffer.from(await mp3.arrayBuffer());
+
+  return new NextResponse(buffer, {
+    headers: {
+      "Content-Type": "audio/mpeg",
+      "Content-Length": buffer.length.toString(),
+    },
+  });
+}
+
+async function handleAliyunTTS(text: string, speed: number, voiceConfig: any) {
+  const config = voiceConfig.providers.aliyun;
+  if (!config?.accessKeyId || !config?.accessKeySecret) {
+    return NextResponse.json({ error: "阿里云 AccessKey 未配置" }, { status: 500 });
+  }
+
+  // 阿里云TTS使用REST API
+  const appKey = config.appKey || "default";
+  const voice = config.voice || "xiaoyun";
+  const format = "mp3";
+  const sampleRate = 16000;
+
+  try {
+    // 生成Token（简化版，生产环境应使用完整的签名流程）
+    const tokenUrl = "https://nls-meta.cn-shanghai.aliyuncs.com/token";
+    const tokenResponse = await fetch(tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        AccessKeyId: config.accessKeyId,
+        Action: "CreateToken",
+      }),
+    });
+
+    if (!tokenResponse.ok) {
+      return NextResponse.json({ error: "获取阿里云Token失败" }, { status: 500 });
+    }
+
+    const tokenData = await tokenResponse.json();
+    const token = tokenData.Token?.Id;
+
+    if (!token) {
+      return NextResponse.json({ error: "阿里云Token无效" }, { status: 500 });
+    }
+
+    // 调用TTS API
+    const ttsUrl = `https://nls-gateway.cn-shanghai.aliyuncs.com/stream/v1/tts`;
+    const ttsResponse = await fetch(ttsUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-NLS-Token": token,
+      },
+      body: JSON.stringify({
+        appkey: appKey,
+        text: text,
+        voice: voice,
+        format: format,
+        sample_rate: sampleRate,
+        speech_rate: Math.round(speed * 100),
+      }),
+    });
+
+    if (!ttsResponse.ok) {
+      return NextResponse.json({ error: "阿里云TTS调用失败" }, { status: 500 });
+    }
+
+    const audioBuffer = await ttsResponse.arrayBuffer();
+    const buffer = Buffer.from(audioBuffer);
+
+    return new NextResponse(buffer, {
+      headers: {
+        "Content-Type": "audio/mpeg",
+        "Content-Length": buffer.length.toString(),
+      },
+    });
+  } catch (error) {
+    console.error("阿里云TTS错误:", error);
+    return NextResponse.json({ error: "阿里云TTS处理失败" }, { status: 500 });
+  }
+}
+
+async function handleTencentTTS(text: string, speed: number, voiceConfig: any) {
+  const config = voiceConfig.providers.tencent;
+  if (!config?.secretId || !config?.secretKey) {
+    return NextResponse.json({ error: "腾讯云 SecretId/SecretKey 未配置" }, { status: 500 });
+  }
+
+  // 腾讯云TTS API参数
+  const voice = config.voice || "101001"; // 智瑜
+  const codec = "mp3";
+  const voiceType = 0;
+
+  try {
+    // 使用腾讯云TTS REST API
+    const endpoint = "https://tts.cloud.tencent.com/stream";
+    const params = new URLSearchParams({
+      Action: "TextToStreamAudio",
+      AppId: config.appId || "0",
+      SecretId: config.secretId,
+      Text: text,
+      ModelType: "1",
+      VoiceType: voice,
+      Codec: codec,
+      Speed: speed.toString(),
+      Timestamp: Math.floor(Date.now() / 1000).toString(),
+    });
+
+    const response = await fetch(`${endpoint}?${params.toString()}`);
+
+    if (!response.ok) {
+      return NextResponse.json({ error: "腾讯云TTS调用失败" }, { status: 500 });
+    }
+
+    const audioBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(audioBuffer);
+
+    return new NextResponse(buffer, {
+      headers: {
+        "Content-Type": "audio/mpeg",
+        "Content-Length": buffer.length.toString(),
+      },
+    });
+  } catch (error) {
+    console.error("腾讯云TTS错误:", error);
+    return NextResponse.json({ error: "腾讯云TTS处理失败" }, { status: 500 });
+  }
+}
+
+async function handleBaiduTTS(text: string, speed: number, voiceConfig: any) {
+  const config = voiceConfig.providers.baidu;
+  if (!config?.apiKey || !config?.secretKey) {
+    return NextResponse.json({ error: "百度 API Key/Secret Key 未配置" }, { status: 500 });
+  }
+
+  try {
+    // 获取百度access_token
+    const tokenUrl = `https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=${config.apiKey}&client_secret=${config.secretKey}`;
+    const tokenResponse = await fetch(tokenUrl);
+    const tokenData = await tokenResponse.json();
+
+    if (!tokenData.access_token) {
+      return NextResponse.json({ error: "获取百度access_token失败" }, { status: 500 });
+    }
+
+    // 调用百度TTS API
+    const ttsUrl = `https://tsn.baidu.com/text2audio`;
+    const params = new URLSearchParams({
+      tex: text,
+      tok: tokenData.access_token,
+      cuid: "pi-web",
+      ctp: "1",
+      lan: "zh",
+      spd: Math.round(speed * 5).toString(), // 百度速度范围0-15
+      pit: "5",
+      vol: "5",
+      per: config.voice || "0", // 0=女声, 1=男声, 3=情感男声, 4=情感女声
+      aue: "3", // 3=mp3
+    });
+
+    const response = await fetch(`${ttsUrl}?${params.toString()}`);
+
+    if (!response.ok) {
+      return NextResponse.json({ error: "百度TTS调用失败" }, { status: 500 });
+    }
+
+    const audioBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(audioBuffer);
+
+    return new NextResponse(buffer, {
+      headers: {
+        "Content-Type": "audio/mpeg",
+        "Content-Length": buffer.length.toString(),
+      },
+    });
+  } catch (error) {
+    console.error("百度TTS错误:", error);
+    return NextResponse.json({ error: "百度TTS处理失败" }, { status: 500 });
+  }
+}

package/src/app/api/voice-provider/route.ts

@@ -0,0 +1,98 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  readVoiceProviderConfig,
+  writeVoiceProviderConfig,
+  type VoiceProviderConfig,
+} from "@/lib/voice-providers-config";
+
+export const dynamic = "force-dynamic";
+
+// GET - 返回当前语音供应商配置（API key脱敏）
+export async function GET() {
+  const config = readVoiceProviderConfig();
+
+  // 脱敏处理：只显示key的最后4位
+  const maskedConfig = {
+    currentProvider: config.currentProvider,
+    providers: {} as any,
+  };
+
+  if (config.providers.aliyun) {
+    maskedConfig.providers.aliyun = {
+      appKey: maskKey(config.providers.aliyun.appKey),
+      accessKeyId: maskKey(config.providers.aliyun.accessKeyId),
+      accessKeySecret: maskKey(config.providers.aliyun.accessKeySecret),
+    };
+  }
+
+  if (config.providers.tencent) {
+    maskedConfig.providers.tencent = {
+      secretId: maskKey(config.providers.tencent.secretId),
+      secretKey: maskKey(config.providers.tencent.secretKey),
+      region: config.providers.tencent.region,
+    };
+  }
+
+  if (config.providers.baidu) {
+    maskedConfig.providers.baidu = {
+      apiKey: maskKey(config.providers.baidu.apiKey),
+      secretKey: maskKey(config.providers.baidu.secretKey),
+    };
+  }
+
+  if (config.providers.openai) {
+    maskedConfig.providers.openai = {
+      apiKey: maskKey(config.providers.openai.apiKey),
+      model: config.providers.openai.model,
+      voice: config.providers.openai.voice,
+    };
+  }
+
+  return NextResponse.json(maskedConfig);
+}
+
+function maskKey(key: string): string {
+  if (!key) return "";
+  if (key.length <= 4) return "***";
+  return "***" + key.slice(-4);
+}
+
+// PUT - 保存语音供应商配置
+export async function PUT(req: NextRequest) {
+  try {
+    const body = await req.json() as Partial<VoiceProviderConfig>;
+    const current = readVoiceProviderConfig();
+
+    // 更新配置
+    if (body.currentProvider) {
+      current.currentProvider = body.currentProvider;
+    }
+
+    if (body.providers) {
+      // 处理各个provider的配置，跳过脱敏的值
+      for (const [provider, config] of Object.entries(body.providers)) {
+        if (!config) continue;
+
+        const masked: any = {};
+        for (const [key, value] of Object.entries(config)) {
+          // 跳过脱敏的值（以***开头）
+          if (typeof value === "string" && value.startsWith("***")) {
+            continue;
+          }
+          masked[key] = value;
+        }
+
+        // 合并到当前配置
+        current.providers[provider as keyof typeof current.providers] = {
+          ...(current.providers[provider as keyof typeof current.providers] || {}),
+          ...masked,
+        } as any;
+      }
+    }
+
+    writeVoiceProviderConfig(current);
+    return NextResponse.json({ success: true });
+  } catch (e) {
+    return NextResponse.json({ error: String(e) }, { status: 500 });
+  }
+}

package/src/app/api/workspace-files/route.ts

@@ -0,0 +1,151 @@
+import { NextRequest, NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { agentStore } from "@/lib/agents/store";
+import { resolveWorkspace } from "@/lib/agent-factory";
+
+export const dynamic = "force-dynamic";
+
+const IGNORED_DIRS = new Set([
+  "node_modules", ".git", ".next", "dist", "build", "__pycache__",
+  ".turbo", ".cache", "coverage", ".pytest_cache", ".mypy_cache",
+  "target", "vendor", ".DS_Store", ".venv", "venv",
+]);
+
+const CODE_EXTS = new Set([
+  "ts", "tsx", "js", "jsx", "py", "rb", "go", "rs", "java", "cpp",
+  "c", "h", "cs", "swift", "kt", "vue", "svelte", "html", "css",
+  "scss", "json", "yaml", "yml", "toml", "md", "txt", "sh", "bash",
+  "zsh", "fish", "sql", "graphql", "proto", "xml",
+]);
+
+function getFileIcon(name: string, isDir: boolean): string {
+  if (isDir) return "folder";
+  const ext = name.split(".").pop()?.toLowerCase() ?? "";
+  if (["ts", "tsx"].includes(ext)) return "file-ts";
+  if (["js", "jsx", "mjs"].includes(ext)) return "file-js";
+  if (["py"].includes(ext)) return "file-py";
+  if (["json", "jsonc"].includes(ext)) return "file-json";
+  if (["md", "mdx"].includes(ext)) return "file-md";
+  if (["css", "scss", "less"].includes(ext)) return "file-css";
+  if (["html", "htm"].includes(ext)) return "file-html";
+  if (["sh", "bash", "zsh"].includes(ext)) return "file-sh";
+  if (["yml", "yaml"].includes(ext)) return "file-yaml";
+  if (["png", "jpg", "jpeg", "gif", "svg", "webp", "ico"].includes(ext)) return "file-img";
+  if (CODE_EXTS.has(ext)) return "file-code";
+  return "file";
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}K`;
+  return `${(bytes / 1024 / 1024).toFixed(1)}M`;
+}
+
+export interface WorkspaceEntry {
+  name: string;
+  path: string;           // absolute path
+  relativePath: string;   // relative to workspace root
+  isDir: boolean;
+  size?: number;
+  sizeDisplay?: string;
+  modified?: number;
+  icon: string;
+  ext?: string;
+}
+
+export interface WorkspaceFilesResponse {
+  workspaceRoot: string;
+  workspaceDisplay: string;
+  currentPath: string;
+  currentDisplay: string;
+  parentPath: string | null;
+  entries: WorkspaceEntry[];
+  error?: string;
+}
+
+export async function GET(req: NextRequest) {
+  const agentId = req.nextUrl.searchParams.get("agentId");
+  const subPath = req.nextUrl.searchParams.get("path") ?? "";
+
+  if (!agentId) {
+    return NextResponse.json({ error: "agentId required" }, { status: 400 });
+  }
+
+  const agent = agentStore.getById(agentId);
+  if (!agent) {
+    return NextResponse.json({ error: "Agent not found" }, { status: 404 });
+  }
+
+  const workspaceRoot = resolveWorkspace(agent);
+  const targetPath = subPath
+    ? path.resolve(workspaceRoot, subPath)
+    : workspaceRoot;
+
+  // Security: must stay within workspace root
+  if (!targetPath.startsWith(workspaceRoot)) {
+    return NextResponse.json({ error: "Access denied" }, { status: 403 });
+  }
+
+  try {
+    const stat = fs.statSync(targetPath);
+    if (!stat.isDirectory()) {
+      return NextResponse.json({ error: "Not a directory" }, { status: 400 });
+    }
+
+    const raw = fs.readdirSync(targetPath, { withFileTypes: true });
+    const entries: WorkspaceEntry[] = [];
+
+    for (const e of raw) {
+      if (e.name.startsWith(".") && e.name !== ".env") continue;
+      const isDir = e.isDirectory() || (e.isSymbolicLink() &&
+        (() => { try { return fs.statSync(path.join(targetPath, e.name)).isDirectory(); } catch { return false; } })());
+      if (isDir && IGNORED_DIRS.has(e.name)) continue;
+
+      const fullPath = path.join(targetPath, e.name);
+      const relativePath = path.relative(workspaceRoot, fullPath);
+      const ext = e.name.split(".").pop()?.toLowerCase();
+      let size: number | undefined;
+      let modified: number | undefined;
+      try {
+        const s = fs.statSync(fullPath);
+        size = isDir ? undefined : s.size;
+        modified = s.mtimeMs;
+      } catch { /* ignore */ }
+
+      entries.push({
+        name: e.name,
+        path: fullPath,
+        relativePath,
+        isDir,
+        size,
+        sizeDisplay: size !== undefined ? formatSize(size) : undefined,
+        modified,
+        icon: getFileIcon(e.name, isDir),
+        ext,
+      });
+    }
+
+    // Sort: dirs first, then files, alphabetically
+    entries.sort((a, b) => {
+      if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+      return a.name.localeCompare(b.name, undefined, { sensitivity: "base" });
+    });
+
+    const home = os.homedir();
+    const parentPath = targetPath !== workspaceRoot ? path.dirname(targetPath) : null;
+
+    const resp: WorkspaceFilesResponse = {
+      workspaceRoot,
+      workspaceDisplay: workspaceRoot.replace(home, "~"),
+      currentPath: targetPath,
+      currentDisplay: targetPath.replace(home, "~"),
+      parentPath,
+      entries,
+    };
+    return NextResponse.json(resp);
+  } catch (e) {
+    return NextResponse.json({ error: String(e) }, { status: 500 });
+  }
+}