@archon-claw/cli 0.0.2

package/dist/schemas.js

@@ -0,0 +1,134 @@
+import { z } from "zod";
+// ---- Model Config ----
+export const modelConfigSchema = z
+    .object({
+    $schema: z.string().optional(),
+    provider: z.enum(["anthropic", "openai", "bailian"]),
+    model: z.string(),
+    maxTokens: z.number().optional(),
+    temperature: z.number().min(0).max(2).optional(),
+    apiKey: z.string().optional(),
+    baseURL: z.string().optional(),
+})
+    .strict();
+// ---- JSON Schema Property (recursive) ----
+export const jsonSchemaPropertySchema = z.lazy(() => z.object({
+    type: z.enum(["string", "number", "boolean", "array", "object"]),
+    description: z.string().optional(),
+    enum: z.array(z.union([z.string(), z.number()])).optional(),
+    items: jsonSchemaPropertySchema.optional(),
+    properties: z.record(jsonSchemaPropertySchema).optional(),
+    required: z.array(z.string()).optional(),
+}));
+// ---- JSON Schema (object subset) ----
+export const jsonSchemaObjectSchema = z.object({
+    type: z.literal("object"),
+    properties: z.record(jsonSchemaPropertySchema),
+    required: z.array(z.string()).optional(),
+});
+// ---- Tool Schema ----
+export const toolSchemaSchema = z
+    .object({
+    $schema: z.string().optional(),
+    name: z.string().regex(/^[a-z][a-z0-9_]*$/),
+    description: z.string(),
+    input_schema: jsonSchemaObjectSchema,
+    execution_target: z.enum(["server", "client", "host"]).optional(),
+    handler: z.string().optional(),
+})
+    .strict()
+    .refine((t) => !(t.execution_target === "client" && !t.handler), "Client tools must have a handler")
+    .refine((t) => !((!t.execution_target || t.execution_target === "server") && t.handler), "Server tools cannot have a handler");
+// ---- Dataset ----
+export const datasetSchema = z.array(z.unknown()).min(1);
+// ---- Agent Skill Frontmatter ----
+export const agentSkillFrontmatterSchema = z
+    .object({
+    name: z.string(),
+    description: z.string(),
+})
+    .strict();
+// ---- Eval Types ----
+export const assertionTypeSchema = z.enum([
+    "contains",
+    "not-contains",
+    "regex",
+    "length-min",
+    "length-max",
+    "json-valid",
+    "tool-called",
+    "tool-not-called",
+    "tool-called-with",
+]);
+export const assertionSchema = z.object({
+    type: assertionTypeSchema,
+    value: z.string(),
+});
+export const evalTurnToolCallSchema = z.object({
+    name: z.string(),
+    args: z.record(z.unknown()),
+    result: z.unknown(),
+});
+export const evalTurnSchema = z.object({
+    role: z.enum(["user", "assistant"]),
+    content: z.string(),
+    assertions: z.array(assertionSchema).optional(),
+    judge: z.boolean().optional(),
+    expectedOutput: z.string().optional(),
+    toolCalls: z.array(evalTurnToolCallSchema).optional(),
+});
+export const evalModeSchema = z.enum(["single", "injected", "sequential"]);
+export const evalCaseSchema = z.object({
+    name: z.string(),
+    mode: evalModeSchema,
+    turns: z.array(evalTurnSchema).min(1),
+    assertions: z.array(assertionSchema).optional(),
+    expectedOutput: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    tools: z.array(z.string()).optional(),
+    judge: z.string().optional(),
+});
+export const evalFileSchema = z.object({
+    $schema: z.string().optional(),
+    name: z.string(),
+    description: z.string().optional(),
+    cases: z.array(evalCaseSchema).min(1),
+});
+// ---- Judge Types ----
+export const judgeDimensionSchema = z.object({
+    key: z.string(),
+    label: z.string(),
+    weight: z.number().min(0).max(1),
+    type: z.enum(["numeric", "binary"]).optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+});
+export const judgeConfigSchema = z.object({
+    $schema: z.string().optional(),
+    model: modelConfigSchema.optional(),
+    dimensions: z.array(judgeDimensionSchema).min(1),
+    promptTemplate: z.string().optional(),
+    turnPromptTemplate: z.string().optional(),
+});
+// ---- MCP Config ----
+export const mcpToolsFilterSchema = z.object({
+    include: z.array(z.string()).optional(),
+    exclude: z.array(z.string()).optional(),
+    rename: z.record(z.string()).optional(),
+}).strict();
+export const mcpServerConfigSchema = z.object({
+    transport: z.enum(["stdio", "sse", "streamable-http"]).optional(),
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string()).optional(),
+    cwd: z.string().optional(),
+    url: z.string().optional(),
+    headers: z.record(z.string()).optional(),
+    enabled: z.boolean().optional(),
+    timeout: z.number().positive().optional(),
+    tools: mcpToolsFilterSchema.optional(),
+}).strict().refine((s) => !!(s.command) !== !!(s.url), "Must provide exactly one of 'command' (stdio) or 'url' (sse/http), not both");
+export const mcpConfigSchema = z.object({
+    $schema: z.string().optional(),
+    mcpServers: z.record(mcpServerConfigSchema),
+}).strict();

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import http from "node:http";
+import type { AgentConfig } from "./types.js";
+export declare function createServer(config: AgentConfig, port: number): http.Server;

package/dist/server.js

@@ -0,0 +1,258 @@
+import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { getOrCreateSession, getSession, deleteSession, listSessions, saveSession } from "./session.js";
+import { runAgentLoop } from "./agent.js";
+import { resolveToolResult, rejectToolResult, cancelAllPending } from "./pending-tool-results.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const STATIC_DIR = path.resolve(__dirname, "public");
+// Dev-mode fallback: when running from src/ via tsx, serve web assets from packages/web
+const WEB_PUBLIC_DIR = path.resolve(__dirname, "../../web/public");
+const WEB_DIST_DIR = path.resolve(__dirname, "../../web/dist");
+const MIME_TYPES = {
+    ".html": "text/html",
+    ".js": "application/javascript",
+    ".css": "text/css",
+    ".json": "application/json",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+};
+function resolveStaticFile(pathname) {
+    const normalized = path.normalize(pathname).replace(/^[/\\]+/, "");
+    for (const dir of [STATIC_DIR, WEB_DIST_DIR, WEB_PUBLIC_DIR]) {
+        const filePath = path.resolve(dir, normalized);
+        if (!filePath.startsWith(dir + path.sep) && filePath !== dir)
+            continue;
+        if (fs.existsSync(filePath) && !fs.statSync(filePath).isDirectory())
+            return filePath;
+    }
+    return null;
+}
+function serveStatic(res, pathname) {
+    // Serve embed.html directly (not SPA fallback)
+    if (pathname === "/embed.html" || pathname === "/embed") {
+        const embedPath = resolveStaticFile("embed.html");
+        return embedPath ? serveFile(res, embedPath) : false;
+    }
+    const resolved = resolveStaticFile(pathname);
+    if (resolved)
+        return serveFile(res, resolved);
+    // SPA fallback
+    const indexPath = resolveStaticFile("index.html");
+    return indexPath ? serveFile(res, indexPath) : false;
+}
+function serveFile(res, filePath) {
+    if (!fs.existsSync(filePath))
+        return false;
+    const ext = path.extname(filePath);
+    const contentType = MIME_TYPES[ext] || "application/octet-stream";
+    const content = fs.readFileSync(filePath);
+    res.writeHead(200, { "Content-Type": contentType });
+    res.end(content);
+    return true;
+}
+function setCors(res) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+}
+function json(res, status, data) {
+    setCors(res);
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+}
+const MAX_BODY_SIZE = 1024 * 1024; // 1 MB
+const BODY_TIMEOUT_MS = 30_000; // 30 seconds
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = "";
+        let size = 0;
+        const timer = setTimeout(() => {
+            req.destroy();
+            reject(new Error("Request body timeout"));
+        }, BODY_TIMEOUT_MS);
+        req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > MAX_BODY_SIZE) {
+                clearTimeout(timer);
+                req.destroy();
+                reject(new Error("Request body too large"));
+                return;
+            }
+            body += chunk.toString();
+        });
+        req.on("end", () => {
+            clearTimeout(timer);
+            resolve(body);
+        });
+        req.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
+export function createServer(config, port) {
+    const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+        const method = req.method ?? "GET";
+        // CORS preflight
+        if (method === "OPTIONS") {
+            setCors(res);
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        // Health check
+        if (method === "GET" && url.pathname === "/api/health") {
+            json(res, 200, { status: "ok" });
+            return;
+        }
+        // List sessions
+        if (method === "GET" && url.pathname === "/api/sessions") {
+            const all = await listSessions();
+            const sessions = all.map((s) => {
+                const firstUser = s.messages.find((m) => m.role === "user");
+                const title = firstUser
+                    ? firstUser.content.slice(0, 50) +
+                        (firstUser.content.length > 50 ? "..." : "")
+                    : undefined;
+                return {
+                    id: s.id,
+                    title,
+                    messageCount: s.messages.length,
+                    createdAt: s.createdAt,
+                };
+            });
+            json(res, 200, { sessions });
+            return;
+        }
+        // Get session detail
+        const sessionMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)$/);
+        if (method === "GET" && sessionMatch) {
+            const session = await getSession(sessionMatch[1]);
+            if (!session) {
+                json(res, 404, { error: "Session not found" });
+                return;
+            }
+            json(res, 200, { session });
+            return;
+        }
+        // Delete session
+        const deleteMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)$/);
+        if (method === "DELETE" && deleteMatch) {
+            const deleted = await deleteSession(deleteMatch[1]);
+            json(res, deleted ? 200 : 404, { deleted });
+            return;
+        }
+        // Serve tool UI scripts
+        const toolUIMatch = url.pathname.match(/^\/api\/tool-uis\/([^/]+)\.ui\.js$/);
+        if (method === "GET" && toolUIMatch) {
+            const name = toolUIMatch[1];
+            if (!config.toolUIs.has(name)) {
+                json(res, 404, { error: "Tool UI not found" });
+                return;
+            }
+            const filePath = path.join(config.agentDir, "tool-uis", `${name}.ui.js`);
+            try {
+                const content = fs.readFileSync(filePath);
+                setCors(res);
+                res.writeHead(200, { "Content-Type": "application/javascript" });
+                res.end(content);
+            }
+            catch {
+                json(res, 404, { error: "Tool UI file not found" });
+            }
+            return;
+        }
+        // Tool result from client/host
+        if (method === "POST" && url.pathname === "/api/tool-result") {
+            let body;
+            try {
+                const raw = await readBody(req);
+                body = JSON.parse(raw);
+            }
+            catch {
+                json(res, 400, { error: "Invalid JSON body" });
+                return;
+            }
+            if (!body.toolCallId || typeof body.toolCallId !== "string") {
+                json(res, 400, { error: "Missing required field: toolCallId" });
+                return;
+            }
+            if (body.error) {
+                const found = rejectToolResult(body.toolCallId, body.error);
+                json(res, found ? 200 : 404, { ok: found });
+            }
+            else {
+                const found = resolveToolResult(body.toolCallId, body.result);
+                json(res, found ? 200 : 404, { ok: found });
+            }
+            return;
+        }
+        // Chat (SSE)
+        if (method === "POST" && url.pathname === "/api/chat") {
+            let body;
+            try {
+                const raw = await readBody(req);
+                body = JSON.parse(raw);
+            }
+            catch {
+                json(res, 400, { error: "Invalid JSON body" });
+                return;
+            }
+            if (!body.message || typeof body.message !== "string") {
+                json(res, 400, { error: "Missing required field: message" });
+                return;
+            }
+            setCors(res);
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive",
+            });
+            const session = await getOrCreateSession(body.sessionId);
+            const pendingToolCallIds = [];
+            const emit = (event) => {
+                // Track pending client/host tool calls for cleanup on disconnect
+                if (event.type === "tool_call" && event.executionTarget) {
+                    pendingToolCallIds.push(event.toolCallId);
+                }
+                if (event.type === "tool_result") {
+                    const idx = pendingToolCallIds.indexOf(event.toolCallId);
+                    if (idx !== -1)
+                        pendingToolCallIds.splice(idx, 1);
+                }
+                res.write(`data: ${JSON.stringify(event)}\n\n`);
+            };
+            req.on("close", () => {
+                if (pendingToolCallIds.length > 0) {
+                    cancelAllPending(pendingToolCallIds);
+                }
+            });
+            try {
+                await runAgentLoop(config, session, body.message, emit, body.hostContext);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                emit({ type: "error", message });
+            }
+            await saveSession(session);
+            res.end();
+            return;
+        }
+        // Static files (SPA fallback)
+        if (method === "GET" && serveStatic(res, url.pathname))
+            return;
+        // 404
+        json(res, 404, { error: "Not found" });
+    });
+    server.listen(port, () => {
+        console.log(`Server listening on http://localhost:${port}`);
+    });
+    return server;
+}

package/dist/session.d.ts

@@ -0,0 +1,8 @@
+import type { Session } from "./types.js";
+export declare function initSessionStore(agentDir: string): Promise<void>;
+export declare function saveSession(session: Session): Promise<void>;
+export declare function createSession(): Promise<Session>;
+export declare function getSession(id: string): Promise<Session | undefined>;
+export declare function getOrCreateSession(id?: string): Promise<Session>;
+export declare function deleteSession(id: string): Promise<boolean>;
+export declare function listSessions(): Promise<Session[]>;

package/dist/session.js

@@ -0,0 +1,70 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+let sessionsDir = "";
+export async function initSessionStore(agentDir) {
+    sessionsDir = path.join(agentDir, "sessions");
+    await fs.mkdir(sessionsDir, { recursive: true });
+}
+function sessionPath(id) {
+    return path.join(sessionsDir, `${id}.json`);
+}
+export async function saveSession(session) {
+    await fs.writeFile(sessionPath(session.id), JSON.stringify(session, null, 2));
+}
+export async function createSession() {
+    const session = {
+        id: crypto.randomUUID(),
+        messages: [],
+        createdAt: Date.now(),
+    };
+    await saveSession(session);
+    return session;
+}
+export async function getSession(id) {
+    try {
+        const data = await fs.readFile(sessionPath(id), "utf-8");
+        return JSON.parse(data);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function getOrCreateSession(id) {
+    if (id) {
+        const existing = await getSession(id);
+        if (existing)
+            return existing;
+    }
+    return createSession();
+}
+export async function deleteSession(id) {
+    try {
+        await fs.unlink(sessionPath(id));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function listSessions() {
+    try {
+        const files = await fs.readdir(sessionsDir);
+        const sessions = [];
+        for (const file of files) {
+            if (!file.endsWith(".json"))
+                continue;
+            try {
+                const data = await fs.readFile(path.join(sessionsDir, file), "utf-8");
+                sessions.push(JSON.parse(data));
+            }
+            catch {
+                // skip corrupt files
+            }
+        }
+        return sessions;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/templates/agent/model.json

@@ -0,0 +1,6 @@
+{
+  "provider": "anthropic",
+  "model": "claude-sonnet-4-20250514",
+  "maxTokens": 4096,
+  "temperature": 0.7
+}

package/dist/templates/agent/system-prompt.md

@@ -0,0 +1,9 @@
+你是一个专业的 AI 助手。
+
+## 可用技能
+
+当用户请求匹配某个技能时，使用 `skill_load` 工具加载该技能的完整指令，然后按照指令执行。
+
+{% for skill in skills %}
+- **{{ skill.name }}**：{{ skill.description }}
+{% endfor %}

package/dist/templates/agent/tool-impls/greeting.impl.js

@@ -0,0 +1,9 @@
+/**
+ * Greeting tool implementation
+ * @param {object} params
+ * @param {string} params.name - The name of the person to greet
+ * @returns {Promise<object>} Greeting message
+ */
+export default async ({ name }) => {
+  return { message: `Hello, ${name}!` };
+};

package/dist/templates/agent/tools/greeting.json

@@ -0,0 +1,14 @@
+{
+  "name": "greeting",
+  "description": "Generate a greeting message for the given name",
+  "input_schema": {
+    "type": "object",
+    "properties": {
+      "name": {
+        "type": "string",
+        "description": "The name of the person to greet"
+      }
+    },
+    "required": ["name"]
+  }
+}

package/dist/templates/workspace/.claude/skills/create-agent/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: create-agent
+description: 创建完整的 agent 配置目录。当用户需要新建一个 AI Agent 时使用。
+argument-hint: "[agent_name]"
+---
+
+在 `agents/` 目录下创建一个完整的 agent 配置文件夹。
+
+## 目录结构
+
+```
+agents/<agent-name>/
+├── system-prompt.md        # 系统提示词（必填）
+├── model.json              # 模型配置（必填）
+├── tools/                  # 工具定义（必填，至少 1 个）
+│   └── <tool-name>.json
+├── tool-impls/             # 工具实现（必填，与 tools/ 一一对应）
+│   └── <tool-name>.impl.js
+├── datasets/               # 数据集（可选）
+│   └── <name>.json
+└── skills/                 # 技能（可选）
+    └── <skill-name>/
+        └── SKILL.md
+```
+
+## 创建步骤
+
+1. **创建 `system-prompt.md`** — 定义 agent 的角色和行为指令
+   - 可使用 Liquid 模板语法引用 datasets 中的数据
+   - 语法：`{% for item in dataset_name %}` / `{{ item.field }}`
+   - 内容不能为空
+
+2. **创建 `model.json`** — 模型配置
+   - 必填：`provider`（`"anthropic"` 或 `"openai"`）、`model`（模型 ID）
+   - 可选：`maxTokens`、`temperature`（0~2）、`apiKey`
+   - 必须通过 `src/schemas/model.schema.json` 校验
+
+3. **创建 `tools/` 目录** — 至少一个工具定义 JSON
+   - 每个文件定义一个工具：`name`、`description`、`input_schema`
+   - `name` 匹配 `^[a-z][a-z0-9_]*$`
+   - 必须通过 `src/schemas/tool.schema.json` 校验
+
+4. **创建 `tool-impls/` 目录** — 每个工具对应一个实现文件
+   - 文件名格式：`<tool-name>.impl.js`
+   - ES6 模块，export default async function
+   - 必须与 tools/ 中的工具一一对应
+
+5. **（可选）创建 `datasets/` 目录** — 数据集 JSON 文件
+   - 必须是非空数组（字符串数组或对象数组）
+   - 文件名去掉 `.json` 后作为 Liquid 模板变量名
+
+6. **（可选）创建 `skills/` 目录** — agent 技能
+   - 每个技能一个子目录，包含 `SKILL.md`
+   - frontmatter 必须有 `name` 和 `description`
+
+## 示例
+
+创建一个名为 `my-assistant` 的 agent：
+
+```
+agents/my-assistant/
+├── system-prompt.md
+├── model.json
+├── tools/
+│   └── web_search.json
+├── tool-impls/
+│   └── web_search.impl.js
+├── datasets/
+│   └── rules.json
+└── skills/
+    └── summarize/
+        └── SKILL.md
+```
+
+## 验证
+
+创建完成后运行验证确保配置正确：
+
+```typescript
+import { validateDir } from "./src/validator/index.js";
+const result = await validateDir("agent-dir", "agents/<agent-name>");
+```
+
+## 注意
+
+- tools/ 和 tool-impls/ 必须一一对应（名称匹配）
+- system-prompt.md 中的 Liquid 模板变量名要与 datasets/ 中的文件名对应
+- 参考 `agents/my-agent/` 作为完整示例
+
+请根据用户的需求创建 agent。$ARGUMENTS

package/dist/templates/workspace/.claude/skills/create-dataset/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: create-dataset
+description: 创建 dataset JSON 文件。当用户需要为 agent 添加数据集（few-shot 示例、规则列表等）时使用。
+---
+
+在 `agents/my-agent/datasets/` 目录下创建一个新的 dataset JSON 文件。
+
+## 规范
+
+- 文件名语义化，如 `examples.json`、`rules.json`
+- 必须通过 `src/schemas/dataset.schema.json` 的校验
+- 必须是 JSON 数组，至少包含一个元素
+
+## 支持的格式
+
+### 字符串数组（规则、提示等）
+
+```json
+[
+  "回答使用中文",
+  "代码示例使用 TypeScript"
+]
+```
+
+### 对象数组（问答对、示例等）
+
+```json
+[
+  {
+    "input": "什么是 TypeScript？",
+    "output": "TypeScript 是 JavaScript 的超集，添加了静态类型系统。"
+  }
+]
+```
+
+## 在 system-prompt.md 中引用
+
+dataset 的文件名（去掉 .json）作为 Liquid 模板变量名：
+
+```markdown
+{% for rule in rules %}
+- {{ rule }}
+{% endfor %}
+
+{% for item in examples %}
+问：{{ item.input }}
+答：{{ item.output }}
+{% endfor %}
+```
+
+## 注意
+
+- 数组不能为空（minItems: 1）
+- 文件名会作为模板变量名，建议用小写字母和下划线
+- 对象数组的字段名自由定义，但要和 system-prompt.md 模板对应
+
+请根据用户需求创建 dataset 文件。$ARGUMENTS