feat: integrate Claude Code as coding-agent backend (z.ai/Zhipu GLM)

Replace custom HF API tools with Claude Code CLI sub-agent. The extension
now spawns `claude -p` with ANTHROPIC_BASE_URL=api.z.ai to autonomously
clone, analyze, fix, and push code changes to HF Spaces.

- Dockerfile: install @anthropic-ai/claude-code globally
- index.ts: 3 tools (claude_code, hf_space_status, hf_restart_space)
- sync_hf.py: add ZAI_API_KEY env var passthrough
- plugin.json: add zaiApiKey config field, bump to v2.0.0

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Dockerfile

@@ -21,6 +21,11 @@ RUN echo "[build] Installing system deps..." && START=$(date +%s) \
   && chown -R node:node /home/node \
   && echo "[build] System deps: $(($(date +%s) - START))s"
 
+# ── Claude Code CLI (for coding agent extension — uses z.ai/Zhipu GLM) ──────
+RUN echo "[build] Installing Claude Code CLI..." && START=$(date +%s) \
+  && npm install -g @anthropic-ai/claude-code \
+  && echo "[build] Claude Code CLI: $(($(date +%s) - START))s"
+
 # ── Copy pre-built OpenClaw (skips clone + install + build entirely) ─────────
 COPY --from=openclaw-prebuilt --chown=node:node /app /app/openclaw
 

extensions/coding-agent/index.ts

@@ -1,15 +1,17 @@
 /**
  * Coding Agent Extension for OpenClaw
  *
- * Registers tools that let the OpenClaw agent manage HuggingFace Spaces:
- * - Read/write/delete files on Space and Dataset repos
- * - Check Space health and restart
- * - Search code patterns (grep-like)
- * - Validate Python syntax before writing
- * - List files in repos
+ * Integrates Claude Code (backed by Zhipu GLM via z.ai) as a sub-agent
+ * for autonomous coding on HuggingFace Spaces.
+ *
+ * Tools:
+ *   - claude_code: Spawn Claude Code CLI to autonomously complete coding tasks
+ *   - hf_space_status: Check Space health/stage
+ *   - hf_restart_space: Restart a Space
  */
 
 import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
@@ -17,7 +19,6 @@ interface PluginApi {
   pluginConfig: Record<string, unknown>;
   logger: { info: (...a: unknown[]) => void; warn: (...a: unknown[]) => void; error: (...a: unknown[]) => void };
   registerTool?: (def: ToolDef) => void;
-  resolvePath?: (p: string) => string;
 }
 
 interface ToolDef {
@@ -30,163 +31,68 @@ interface ToolDef {
 
 interface ToolResult {
   content: Array<{ type: "text"; text: string }>;
-  details?: Record<string, unknown>;
-}
-
-// ── HuggingFace API helpers ──────────────────────────────────────────────────
-
-const HF_API = "https://huggingface.co/api";
-
-async function hfFetch(path: string, token: string, options: RequestInit = {}): Promise<Response> {
-  const url = path.startsWith("http") ? path : `${HF_API}${path}`;
-  return fetch(url, {
-    ...options,
-    headers: {
-      Authorization: `Bearer ${token}`,
-      ...((options.headers as Record<string, string>) || {}),
-    },
-  });
-}
-
-async function hfReadFile(repoType: string, repoId: string, filePath: string, token: string): Promise<string> {
-  const url = `https://huggingface.co/${repoType}s/${repoId}/resolve/main/${filePath}`;
-  const resp = await hfFetch(url, token);
-  if (!resp.ok) throw new Error(`${resp.status} ${resp.statusText}: ${filePath}`);
-  return resp.text();
 }
 
-async function hfWriteFile(repoType: string, repoId: string, filePath: string, content: string, token: string): Promise<string> {
-  const url = `${HF_API}/${repoType}s/${repoId}/upload/main/${filePath}`;
-  const blob = new Blob([content], { type: "text/plain" });
-  const form = new FormData();
-  form.append("file", blob, filePath);
-  const resp = await hfFetch(url, token, { method: "POST", body: form });
-  if (!resp.ok) {
-    const text = await resp.text().catch(() => "");
-    throw new Error(`${resp.status}: ${text}`);
-  }
-  return `Wrote ${content.length} bytes to ${repoType}:${filePath}`;
-}
+// ── Helpers ──────────────────────────────────────────────────────────────────
 
-async function hfDeleteFile(repoType: string, repoId: string, filePath: string, token: string): Promise<string> {
-  // Use the HF Hub commit API to delete a file
-  const url = `${HF_API}/${repoType}s/${repoId}/commit/main`;
-  const body = {
-    summary: `Delete ${filePath}`,
-    operations: [{ op: "delete", path: filePath }],
-  };
-  const resp = await hfFetch(url, token, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body),
-  });
-  if (!resp.ok) {
-    const text = await resp.text().catch(() => "");
-    throw new Error(`${resp.status}: ${text}`);
-  }
-  return `Deleted ${repoType}:${filePath}`;
-}
+const WORK_DIR = "/tmp/claude-workspace";
+const CLAUDE_TIMEOUT = 300_000; // 5 minutes
 
-async function hfListFiles(repoType: string, repoId: string, token: string): Promise<string[]> {
-  const url = `${HF_API}/${repoType}s/${repoId}`;
-  const resp = await hfFetch(url, token);
-  if (!resp.ok) throw new Error(`${resp.status}: listing failed`);
-  const data = await resp.json() as Record<string, unknown>;
-  const siblings = (data.siblings || []) as Array<{ rfilename: string }>;
-  return siblings.map((s) => s.rfilename);
+function text(t: string): ToolResult {
+  return { content: [{ type: "text", text: t }] };
 }
 
-async function hfSpaceInfo(spaceId: string, token: string): Promise<Record<string, unknown>> {
-  const resp = await hfFetch(`/spaces/${spaceId}`, token);
-  if (!resp.ok) throw new Error(`${resp.status}: space info failed`);
-  return resp.json() as Promise<Record<string, unknown>>;
+function asStr(v: unknown, fallback = ""): string {
+  return typeof v === "string" ? v : fallback;
 }
 
-async function hfRestartSpace(spaceId: string, token: string): Promise<string> {
-  const resp = await hfFetch(`/spaces/${spaceId}/restart`, token, { method: "POST" });
-  if (!resp.ok) {
-    const text = await resp.text().catch(() => "");
-    throw new Error(`${resp.status}: ${text}`);
-  }
-  return `Space ${spaceId} is restarting`;
-}
+// ── Git helpers ──────────────────────────────────────────────────────────────
 
-// ── Python syntax checker ────────────────────────────────────────────────────
+function ensureRepo(targetSpace: string, hfToken: string): void {
+  const repoUrl = `https://user:${hfToken}@huggingface.co/spaces/${targetSpace}`;
 
-function checkPythonSyntax(code: string): { valid: boolean; error?: string } {
-  try {
-    execSync(`python3 -c "import ast; ast.parse('''${code.replace(/'/g, "\\'")}''')"`, {
-      timeout: 5000,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-    return { valid: true };
-  } catch (e: unknown) {
-    // Fallback: write to temp file and check
+  if (existsSync(`${WORK_DIR}/.git`)) {
+    // Reset to latest remote state (clean slate for each task)
     try {
-      const tmpFile = `/tmp/_syntax_check_${Date.now()}.py`;
-      require("node:fs").writeFileSync(tmpFile, code);
-      execSync(`python3 -c "import ast; ast.parse(open('${tmpFile}').read())"`, {
-        timeout: 5000,
-        stdio: ["pipe", "pipe", "pipe"],
+      execSync("git fetch origin && git reset --hard origin/main", {
+        cwd: WORK_DIR,
+        timeout: 30_000,
+        stdio: "pipe",
       });
-      require("node:fs").unlinkSync(tmpFile);
-      return { valid: true };
-    } catch (e2: unknown) {
-      const msg = e2 instanceof Error ? e2.message : String(e2);
-      // Extract the actual syntax error line
-      const match = msg.match(/SyntaxError:.*|File.*line \d+/g);
-      return { valid: false, error: match ? match.join("\n") : msg.slice(0, 500) };
-    }
-  }
-}
-
-// ── Code search helper ───────────────────────────────────────────────────────
-
-async function searchInRepo(repoType: string, repoId: string, pattern: string, token: string, fileGlob?: string): Promise<string> {
-  const files = await hfListFiles(repoType, repoId, token);
-  const codeFiles = files.filter((f) => {
-    const ext = f.split(".").pop()?.toLowerCase() || "";
-    const isCode = ["py", "js", "ts", "json", "yaml", "yml", "md", "txt", "sh", "css", "html", "toml", "cfg", "ini"].includes(ext);
-    if (fileGlob) {
-      // Simple glob: *.py matches .py extension
-      const globExt = fileGlob.replace("*.", "");
-      return f.endsWith(`.${globExt}`);
-    }
-    return isCode;
-  });
-
-  const results: string[] = [];
-  const regex = new RegExp(pattern, "gi");
-
-  for (const file of codeFiles.slice(0, 30)) {
-    try {
-      const content = await hfReadFile(repoType, repoId, file, token);
-      const lines = content.split("\n");
-      for (let i = 0; i < lines.length; i++) {
-        if (regex.test(lines[i])) {
-          results.push(`${file}:${i + 1}: ${lines[i].trim()}`);
-        }
-        regex.lastIndex = 0; // Reset regex state
-      }
+      return;
     } catch {
-      // Skip unreadable files (binary, too large, etc.)
+      // If fetch/reset fails, re-clone
+      execSync(`rm -rf ${WORK_DIR}`, { stdio: "pipe" });
     }
-    if (results.length >= 50) break;
   }
 
-  return results.length > 0
-    ? `Found ${results.length} match(es):\n${results.join("\n")}`
-    : `No matches for "${pattern}" in ${codeFiles.length} files`;
+  // Fresh clone
+  if (existsSync(WORK_DIR)) {
+    execSync(`rm -rf ${WORK_DIR}`, { stdio: "pipe" });
+  }
+  execSync(`git clone --depth 20 ${repoUrl} ${WORK_DIR}`, {
+    timeout: 60_000,
+    stdio: "pipe",
+  });
+  execSync('git config user.name "Claude Code"', { cwd: WORK_DIR, stdio: "pipe" });
+  execSync('git config user.email "claude-code@huggingclaw"', { cwd: WORK_DIR, stdio: "pipe" });
 }
 
-// ── Helpers ──────────────────────────────────────────────────────────────────
+function pushChanges(summary: string): string {
+  const status = execSync("git status --porcelain", {
+    cwd: WORK_DIR,
+    encoding: "utf-8",
+  }).trim();
 
-function text(t: string): ToolResult {
-  return { content: [{ type: "text", text: t }] };
-}
+  if (!status) return "No files changed.";
 
-function asStr(v: unknown, fallback = ""): string {
-  return typeof v === "string" ? v : fallback;
+  execSync("git add -A", { cwd: WORK_DIR, stdio: "pipe" });
+  // Use a safe commit message
+  const msg = summary.slice(0, 72).replace(/"/g, '\\"');
+  execSync(`git commit -m "Claude Code: ${msg}"`, { cwd: WORK_DIR, stdio: "pipe" });
+  execSync("git push", { cwd: WORK_DIR, timeout: 60_000, stdio: "pipe" });
+
+  return `Pushed changes:\n${status}`;
 }
 
 // ── Plugin ──────────────��────────────────────────────────────────────────────
@@ -194,153 +100,96 @@ function asStr(v: unknown, fallback = ""): string {
 const plugin = {
   id: "coding-agent",
   name: "Coding Agent",
-  description: "HuggingFace Space coding tools with syntax validation",
+  description: "Claude Code sub-agent for autonomous coding on HF Spaces (Zhipu GLM backend via z.ai)",
 
   register(api: PluginApi) {
-    const cfg = api.pluginConfig as Record<string, unknown> || {};
+    const cfg = (api.pluginConfig as Record<string, unknown>) || {};
     const targetSpace = asStr(cfg.targetSpace) || process.env.CODING_AGENT_TARGET_SPACE || "";
-    const targetDataset = asStr(cfg.targetDataset) || process.env.CODING_AGENT_TARGET_DATASET || "";
     const hfToken = asStr(cfg.hfToken) || process.env.HF_TOKEN || "";
+    const zaiApiKey = asStr(cfg.zaiApiKey) || process.env.ZAI_API_KEY || process.env.ZHIPU_API_KEY || "";
 
-    if (!hfToken) {
-      api.logger.warn("coding-agent: No HF token configured — tools will fail");
-    }
-    api.logger.info(`coding-agent: targetSpace=${targetSpace}, targetDataset=${targetDataset}`);
+    api.logger.info(`coding-agent: targetSpace=${targetSpace}, zaiKey=${zaiApiKey ? "set" : "missing"}`);
 
     if (!api.registerTool) {
       api.logger.warn("coding-agent: registerTool unavailable — no tools registered");
       return;
     }
 
-    // ── Tool: hf_read_file ──────────────────────────────────────────────────
+    // ── Tool: claude_code ───────────────────────────────────────────────────
     api.registerTool({
-      name: "hf_read_file",
-      label: "Read File from HF Repo",
+      name: "claude_code",
+      label: "Run Claude Code",
       description:
-        "Read a file from the target HuggingFace Space or Dataset. " +
-        "Use repo='space' for code files, repo='dataset' for data/memory files.",
+        "Run Claude Code to autonomously complete a coding task on the target HF Space. " +
+        "Claude Code clones the Space repo, analyzes code, makes changes, and pushes them back. " +
+        "Powered by Zhipu GLM via z.ai. Use for: debugging, fixing errors, adding features, refactoring.",
       parameters: {
         type: "object",
-        required: ["repo", "path"],
+        required: ["task"],
         properties: {
-          repo: { type: "string", enum: ["space", "dataset"], description: "Which repo: 'space' (code) or 'dataset' (data)" },
-          path: { type: "string", description: "File path within the repo (e.g. app.py, scripts/entrypoint.sh)" },
+          task: {
+            type: "string",
+            description: "Detailed coding task description. Be specific about what to fix/change and why.",
+          },
+          auto_push: {
+            type: "boolean",
+            description: "Automatically push changes after Claude Code finishes (default: true)",
+          },
         },
       },
       async execute(_id, params) {
-        const repo = asStr(params.repo);
-        const path = asStr(params.path);
-        const repoId = repo === "dataset" ? targetDataset : targetSpace;
-        if (!repoId) return text(`Error: no target ${repo} configured`);
-        try {
-          const content = await hfReadFile(repo === "dataset" ? "dataset" : "space", repoId, path, hfToken);
-          return text(`=== ${repo}:${path} ===\n${content}`);
-        } catch (e: unknown) {
-          return text(`Error reading ${repo}:${path}: ${e instanceof Error ? e.message : e}`);
-        }
-      },
-    });
+        const task = asStr(params.task);
+        const autoPush = params.auto_push !== false;
 
-    // ── Tool: hf_write_file ─────────────────────────────────────────────────
-    api.registerTool({
-      name: "hf_write_file",
-      label: "Write File to HF Repo",
-      description:
-        "Write/update a file in the target HuggingFace Space or Dataset. " +
-        "For .py files, syntax is automatically validated before writing. " +
-        "Writing to the Space triggers a rebuild. Use repo='space' for code, repo='dataset' for data.",
-      parameters: {
-        type: "object",
-        required: ["repo", "path", "content"],
-        properties: {
-          repo: { type: "string", enum: ["space", "dataset"], description: "Which repo: 'space' or 'dataset'" },
-          path: { type: "string", description: "File path (e.g. app.py)" },
-          content: { type: "string", description: "Full file content to write" },
-          skip_syntax_check: { type: "boolean", description: "Skip Python syntax validation (default: false)" },
-        },
-      },
-      async execute(_id, params) {
-        const repo = asStr(params.repo);
-        const path = asStr(params.path);
-        const content = asStr(params.content);
-        const skipCheck = params.skip_syntax_check === true;
-        const repoType = repo === "dataset" ? "dataset" : "space";
-        const repoId = repo === "dataset" ? targetDataset : targetSpace;
-        if (!repoId) return text(`Error: no target ${repo} configured`);
-
-        // Auto syntax check for Python files
-        if (path.endsWith(".py") && !skipCheck) {
-          const check = checkPythonSyntax(content);
-          if (!check.valid) {
-            return text(
-              `SYNTAX ERROR — file NOT written.\n` +
-              `File: ${path}\n` +
-              `Error: ${check.error}\n\n` +
-              `Fix the syntax error and try again. Use skip_syntax_check=true to force write.`
-            );
-          }
-        }
+        if (!targetSpace) return text("Error: no targetSpace configured");
+        if (!hfToken) return text("Error: no HF token configured");
+        if (!zaiApiKey) return text("Error: no ZAI_API_KEY or ZHIPU_API_KEY configured for Claude Code backend");
 
         try {
-          const result = await hfWriteFile(repoType, repoId, path, content, hfToken);
-          const note = repo === "space" ? " (triggers Space rebuild)" : "";
-          return text(`${result}${note}`);
-        } catch (e: unknown) {
-          return text(`Error writing ${repo}:${path}: ${e instanceof Error ? e.message : e}`);
-        }
-      },
-    });
+          // 1. Clone / reset to latest
+          api.logger.info(`coding-agent: Syncing repo ${targetSpace}...`);
+          ensureRepo(targetSpace, hfToken);
+
+          // 2. Run Claude Code with z.ai backend
+          api.logger.info(`coding-agent: Running Claude Code: ${task.slice(0, 100)}...`);
+          const claudeEnv: Record<string, string> = {
+            ...(process.env as Record<string, string>),
+            ANTHROPIC_BASE_URL: "https://api.z.ai/api/anthropic",
+            ANTHROPIC_AUTH_TOKEN: zaiApiKey,
+            ANTHROPIC_DEFAULT_OPUS_MODEL: "GLM-4.7",
+            ANTHROPIC_DEFAULT_SONNET_MODEL: "GLM-4.7",
+            ANTHROPIC_DEFAULT_HAIKU_MODEL: "GLM-4.5-Air",
+            // Avoid interactive prompts
+            CI: "true",
+          };
+
+          const output = execSync(
+            `claude -p ${JSON.stringify(task)} --output-format text`,
+            {
+              cwd: WORK_DIR,
+              env: claudeEnv,
+              timeout: CLAUDE_TIMEOUT,
+              encoding: "utf-8",
+              maxBuffer: 10 * 1024 * 1024, // 10MB
+            },
+          );
 
-    // ── Tool: hf_delete_file ────────────────────────────────────────────────
-    api.registerTool({
-      name: "hf_delete_file",
-      label: "Delete File from HF Repo",
-      description: "Delete a file from the target Space or Dataset repo.",
-      parameters: {
-        type: "object",
-        required: ["repo", "path"],
-        properties: {
-          repo: { type: "string", enum: ["space", "dataset"], description: "Which repo" },
-          path: { type: "string", description: "File path to delete" },
-        },
-      },
-      async execute(_id, params) {
-        const repo = asStr(params.repo);
-        const path = asStr(params.path);
-        const repoType = repo === "dataset" ? "dataset" : "space";
-        const repoId = repo === "dataset" ? targetDataset : targetSpace;
-        if (!repoId) return text(`Error: no target ${repo} configured`);
-        try {
-          const result = await hfDeleteFile(repoType, repoId, path, hfToken);
-          return text(result);
-        } catch (e: unknown) {
-          return text(`Error deleting ${repo}:${path}: ${e instanceof Error ? e.message : e}`);
-        }
-      },
-    });
+          // 3. Push changes if requested
+          let pushResult = "Auto-push disabled.";
+          if (autoPush) {
+            try {
+              pushResult = pushChanges(task);
+            } catch (e: unknown) {
+              pushResult = `Push failed: ${e instanceof Error ? e.message : e}`;
+            }
+          }
 
-    // ── Tool: hf_list_files ─────────────────────────────────────────────────
-    api.registerTool({
-      name: "hf_list_files",
-      label: "List Files in HF Repo",
-      description: "List all files in the target Space or Dataset repo.",
-      parameters: {
-        type: "object",
-        required: ["repo"],
-        properties: {
-          repo: { type: "string", enum: ["space", "dataset"], description: "Which repo to list" },
-        },
-      },
-      async execute(_id, params) {
-        const repo = asStr(params.repo);
-        const repoType = repo === "dataset" ? "dataset" : "space";
-        const repoId = repo === "dataset" ? targetDataset : targetSpace;
-        if (!repoId) return text(`Error: no target ${repo} configured`);
-        try {
-          const files = await hfListFiles(repoType, repoId, hfToken);
-          return text(`Files in ${repoId} (${files.length}):\n${files.map((f) => `  ${f}`).join("\n")}`);
+          return text(
+            `=== Claude Code Output ===\n${output}\n\n=== Changes ===\n${pushResult}`,
+          );
         } catch (e: unknown) {
-          return text(`Error listing ${repo}: ${e instanceof Error ? e.message : e}`);
+          const msg = e instanceof Error ? e.message : String(e);
+          return text(`Claude Code failed:\n${msg.slice(0, 3000)}`);
         }
       },
     });
@@ -351,7 +200,7 @@ const plugin = {
       label: "Check Space Health",
       description:
         "Check the current status of the target HuggingFace Space. " +
-        "Returns: stage (BUILDING, APP_STARTING, RUNNING, RUNTIME_ERROR, BUILD_ERROR, etc.)",
+        "Returns: stage (BUILDING, APP_STARTING, RUNNING, RUNTIME_ERROR, BUILD_ERROR, NO_APP_FILE).",
       parameters: {
         type: "object",
         properties: {},
@@ -359,26 +208,27 @@ const plugin = {
       async execute() {
         if (!targetSpace) return text("Error: no target space configured");
         try {
-          const info = await hfSpaceInfo(targetSpace, hfToken);
-          const runtime = info.runtime as Record<string, unknown> | undefined;
-          const stage = runtime?.stage || "unknown";
-          const hardware = runtime?.hardware || "unknown";
-
-          // Also try hitting the API endpoint
+          const resp = await fetch(`https://huggingface.co/api/spaces/${targetSpace}`, {
+            headers: { Authorization: `Bearer ${hfToken}` },
+          });
+          if (!resp.ok) throw new Error(`${resp.status} ${resp.statusText}`);
+          const data = (await resp.json()) as Record<string, unknown>;
+          const runtime = (data.runtime as Record<string, unknown>) || {};
+          const stage = runtime.stage || "unknown";
+          const hardware = runtime.hardware || "unknown";
+
+          // Try hitting the Space URL
           let apiStatus = "not checked";
           try {
             const spaceUrl = `https://${targetSpace.replace("/", "-").toLowerCase()}.hf.space`;
-            const resp = await fetch(`${spaceUrl}/api/state`, { signal: AbortSignal.timeout(8000) });
-            apiStatus = resp.ok ? `OK (${resp.status})` : `error (${resp.status})`;
+            const probe = await fetch(spaceUrl, { signal: AbortSignal.timeout(8000) });
+            apiStatus = probe.ok ? `reachable (${probe.status})` : `error (${probe.status})`;
           } catch {
             apiStatus = "unreachable";
           }
 
           return text(
-            `Space: ${targetSpace}\n` +
-            `Stage: ${stage}\n` +
-            `Hardware: ${hardware}\n` +
-            `API: ${apiStatus}`
+            `Space: ${targetSpace}\nStage: ${stage}\nHardware: ${hardware}\nAPI: ${apiStatus}`,
           );
         } catch (e: unknown) {
           return text(`Error checking space: ${e instanceof Error ? e.message : e}`);
@@ -398,71 +248,22 @@ const plugin = {
       async execute() {
         if (!targetSpace) return text("Error: no target space configured");
         try {
-          const result = await hfRestartSpace(targetSpace, hfToken);
-          return text(result);
+          const resp = await fetch(`https://huggingface.co/api/spaces/${targetSpace}/restart`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${hfToken}` },
+          });
+          if (!resp.ok) {
+            const body = await resp.text().catch(() => "");
+            throw new Error(`${resp.status}: ${body}`);
+          }
+          return text(`Space ${targetSpace} is restarting`);
         } catch (e: unknown) {
           return text(`Error restarting space: ${e instanceof Error ? e.message : e}`);
         }
       },
     });
 
-    // ── Tool: hf_search_code ────────────────────────────────────────────────
-    api.registerTool({
-      name: "hf_search_code",
-      label: "Search Code in Repo",
-      description:
-        "Search for a pattern (regex) across all code files in the Space or Dataset. " +
-        "Like grep — returns matching lines with file:line references.",
-      parameters: {
-        type: "object",
-        required: ["repo", "pattern"],
-        properties: {
-          repo: { type: "string", enum: ["space", "dataset"], description: "Which repo to search" },
-          pattern: { type: "string", description: "Regex pattern to search for (e.g. 'import gradio', 'port.*7860')" },
-          file_glob: { type: "string", description: "Optional file filter (e.g. '*.py' to search only Python files)" },
-        },
-      },
-      async execute(_id, params) {
-        const repo = asStr(params.repo);
-        const pattern = asStr(params.pattern);
-        const fileGlob = asStr(params.file_glob);
-        const repoType = repo === "dataset" ? "dataset" : "space";
-        const repoId = repo === "dataset" ? targetDataset : targetSpace;
-        if (!repoId) return text(`Error: no target ${repo} configured`);
-        try {
-          const result = await searchInRepo(repoType, repoId, pattern, hfToken, fileGlob || undefined);
-          return text(result);
-        } catch (e: unknown) {
-          return text(`Error searching ${repo}: ${e instanceof Error ? e.message : e}`);
-        }
-      },
-    });
-
-    // ── Tool: python_syntax_check ───────────────────────────────────────────
-    api.registerTool({
-      name: "python_syntax_check",
-      label: "Check Python Syntax",
-      description:
-        "Validate Python code syntax without writing it. " +
-        "Use this to verify code before committing changes. Returns OK or the specific syntax error.",
-      parameters: {
-        type: "object",
-        required: ["code"],
-        properties: {
-          code: { type: "string", description: "Python code to validate" },
-        },
-      },
-      async execute(_id, params) {
-        const code = asStr(params.code);
-        const result = checkPythonSyntax(code);
-        if (result.valid) {
-          return text("Syntax OK — code is valid Python");
-        }
-        return text(`SYNTAX ERROR:\n${result.error}`);
-      },
-    });
-
-    api.logger.info(`coding-agent: Registered 8 tools for ${targetSpace || "(no target space)"}`);
+    api.logger.info("coding-agent: Registered 3 tools (claude_code, hf_space_status, hf_restart_space)");
   },
 };
 

extensions/coding-agent/openclaw.plugin.json

@@ -1,12 +1,13 @@
 {
   "id": "coding-agent",
   "name": "Coding Agent",
-  "description": "HuggingFace Space coding tools — read, write, edit, search, and manage code on HF Spaces with syntax validation",
-  "version": "1.0.0",
+  "description": "Claude Code sub-agent for autonomous coding on HF Spaces — powered by Zhipu GLM via z.ai",
+  "version": "2.0.0",
   "defaultConfig": {
     "targetSpace": "",
     "targetDataset": "",
-    "hfToken": ""
+    "hfToken": "",
+    "zaiApiKey": ""
   },
   "configSchema": {
     "type": "object",
@@ -23,10 +24,15 @@
       "hfToken": {
         "type": "string",
         "description": "HuggingFace API token (or use HF_TOKEN env var)"
+      },
+      "zaiApiKey": {
+        "type": "string",
+        "description": "Z.AI API key for Claude Code backend (or use ZAI_API_KEY / ZHIPU_API_KEY env var)"
       }
     }
   },
   "uiHints": {
-    "hfToken": { "sensitive": true }
+    "hfToken": { "sensitive": true },
+    "zaiApiKey": { "sensitive": true }
   }
 }

scripts/sync_hf.py

@@ -76,6 +76,9 @@ OPENROUTER_API_KEY = os.environ.get("OPENROUTER_API_KEY", "")
 # Zhipu AI (z.ai) API key (optional; GLM-4 series, Anthropic-compatible endpoint)
 ZHIPU_API_KEY = os.environ.get("ZHIPU_API_KEY", "")
 
+# Z.AI API key (optional; used by Claude Code backend via api.z.ai)
+ZAI_API_KEY = os.environ.get("ZAI_API_KEY", "")
+
 # Gateway token (default: huggingclaw; override via GATEWAY_TOKEN env var)
 GATEWAY_TOKEN = os.environ.get("GATEWAY_TOKEN", "huggingclaw")
 
@@ -522,9 +525,10 @@ class OpenClawFullSync:
                         "targetSpace": CODING_TARGET_SPACE,
                         "targetDataset": CODING_TARGET_DATASET,
                         "hfToken": HF_TOKEN or "",
+                        "zaiApiKey": ZAI_API_KEY or ZHIPU_API_KEY or "",
                     }
                 }
-                print(f"[SYNC] Coding agent configured: space={CODING_TARGET_SPACE}, dataset={CODING_TARGET_DATASET}")
+                print(f"[SYNC] Coding agent configured: space={CODING_TARGET_SPACE}, dataset={CODING_TARGET_DATASET}, zaiKey={'set' if (ZAI_API_KEY or ZHIPU_API_KEY) else 'missing'}")
             if "telegram" not in data["plugins"]["entries"]:
                 data["plugins"]["entries"]["telegram"] = {"enabled": True}
             elif isinstance(data["plugins"]["entries"]["telegram"], dict):
@@ -674,6 +678,8 @@ class OpenClawFullSync:
             env["OPENROUTER_API_KEY"] = OPENROUTER_API_KEY
         if ZHIPU_API_KEY:
             env["ZHIPU_API_KEY"] = ZHIPU_API_KEY
+        if ZAI_API_KEY:
+            env["ZAI_API_KEY"] = ZAI_API_KEY
         if not OPENAI_API_KEY and not OPENROUTER_API_KEY and not ZHIPU_API_KEY:
             print(f"[SYNC] WARNING: No API key set (OPENAI/OPENROUTER/ZHIPU), LLM features may not work")