@shadowob/cloud 1.1.6-dev.311

package/dist/gitagent-MWI75OIX.js

@@ -0,0 +1,725 @@
+import {
+  definePlugin
+} from "./chunk-JY2HTT7Q.js";
+import "./chunk-R5U7XKVJ.js";
+
+// src/plugins/gitagent/index.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve } from "path";
+
+// src/plugins/gitagent/k8s.ts
+var STANDARD_GITAGENT_FILES = [
+  "SOUL.md",
+  "RULES.md",
+  "AGENTS.md",
+  "INSTRUCTIONS.md",
+  "agent.yaml",
+  "scheduler.yml",
+  "scheduler.yaml",
+  "skills",
+  "tools",
+  "hooks",
+  "skillflows",
+  "memory",
+  "knowledge",
+  "compliance"
+];
+function buildGitCloneCommand(opts) {
+  const { url, ref, depth, agentDir, mountPath, include } = opts;
+  const cloneTarget = "/tmp/agent-source";
+  const cmds = [];
+  cmds.push(`git clone --depth ${depth} --branch "${ref}" "${url}" "${cloneTarget}"`);
+  const sourceDir = agentDir ? `${cloneTarget}/${agentDir}` : cloneTarget;
+  cmds.push(`mkdir -p "${mountPath}"`);
+  if (include && include.length > 0) {
+    for (const pattern of include) {
+      cmds.push(`cp -r "${sourceDir}/${pattern}" "${mountPath}/" 2>/dev/null || true`);
+    }
+  } else {
+    for (const f of STANDARD_GITAGENT_FILES) {
+      cmds.push(`cp -r "${sourceDir}/${f}" "${mountPath}/" 2>/dev/null || true`);
+    }
+  }
+  return ["/bin/sh", "-c", cmds.join(" && ")];
+}
+function parsePollInterval(input) {
+  if (input == null) return 0;
+  if (typeof input === "number") return Math.max(0, Math.floor(input));
+  const m = /^(\d+)\s*(s|m|h)?$/.exec(input.trim());
+  if (!m) return 0;
+  const n = Number(m[1]);
+  const unit = m[2] ?? "s";
+  switch (unit) {
+    case "h":
+      return n * 3600;
+    case "m":
+      return n * 60;
+    default:
+      return n;
+  }
+}
+function buildGitSyncSidecar(opts) {
+  const { name, url, ref, depth, agentDir, mountPath, include, intervalSec } = opts;
+  if (!intervalSec || intervalSec <= 0) return void 0;
+  const cloneTarget = "/tmp/agent-source";
+  const filesToCopy = include && include.length > 0 ? include : STANDARD_GITAGENT_FILES;
+  const copySnippet = filesToCopy.map(
+    (f) => `cp -r "${cloneTarget}/${agentDir ?? "."}/${f}" "${mountPath}/" 2>/dev/null || true`
+  ).join("; ");
+  const script = `
+set -e
+if [ ! -d "${cloneTarget}/.git" ]; then
+  git clone --depth ${depth} --branch "${ref}" "${url}" "${cloneTarget}"
+fi
+while true; do
+  cd "${cloneTarget}"
+  git fetch --depth ${depth} origin "${ref}" 2>&1 || echo "[gitagent-sync] fetch failed, will retry"
+  git reset --hard "origin/${ref}" 2>&1 || git reset --hard "${ref}" 2>&1 || true
+  mkdir -p "${mountPath}"
+  ${copySnippet}
+  # touch a marker file so readers using chokidar(fs) can debounce on it
+  date -u +%FT%TZ > "${mountPath}/.gitagent-synced-at" || true
+  sleep ${intervalSec}
+done
+`.trim();
+  return {
+    name,
+    image: "alpine/git:latest",
+    imagePullPolicy: "IfNotPresent",
+    command: ["/bin/sh", "-c", script],
+    volumeMounts: [{ name: "gitagent-src", mountPath }],
+    resources: {
+      requests: { cpu: "10m", memory: "32Mi" },
+      limits: { cpu: "100m", memory: "128Mi" }
+    }
+  };
+}
+
+// src/plugins/gitagent/manifest.json
+var manifest_default = {
+  id: "gitagent",
+  name: "GitAgent",
+  description: "Deploy agents from gitagent-standard git repositories. Supports init-container (runtime clone) and build-image (pre-baked) strategies.",
+  version: "1.0.0",
+  category: "code",
+  icon: "git-branch",
+  website: "https://gitagent.sh/",
+  docs: "https://github.com/open-gitagent/gitagent",
+  auth: {
+    type: "token",
+    fields: [
+      {
+        key: "GITHUB_TOKEN",
+        label: "Git Token (HTTPS)",
+        description: "Personal access token for private HTTPS repositories",
+        required: false,
+        sensitive: true,
+        placeholder: "ghp_..."
+      }
+    ]
+  },
+  config: {
+    type: "object",
+    properties: {
+      git: {
+        type: "object",
+        description: "Git repository source",
+        properties: {
+          url: { type: "string", description: "Repository URL (HTTPS or SSH)" },
+          ref: { type: "string", description: "Branch, tag, or commit SHA" },
+          dir: { type: "string", description: "Subdirectory within the repo" },
+          depth: { type: "number", description: "Shallow clone depth" },
+          sshKeySecret: { type: "string", description: "K8s Secret name for SSH key" },
+          tokenSecret: {
+            type: "string",
+            description: "K8s Secret name or env var for HTTPS token"
+          }
+        }
+      },
+      path: { type: "string", description: "Local gitagent directory (dev mode)" },
+      poll: {
+        type: "string",
+        description: "Poll interval for live git-pull sidecar, e.g. '5m', '30s'. Omit to disable."
+      },
+      strategy: {
+        type: "string",
+        enum: ["init-container", "build-image"],
+        default: "init-container"
+      },
+      mountPath: { type: "string", default: "/agent" },
+      include: { type: "array", items: { type: "string" } },
+      imageTag: { type: "string", description: "Docker image tag for build-image strategy" }
+    }
+  },
+  capabilities: ["config-builder"],
+  tags: ["git", "gitagent", "source", "repository", "init-container", "build-image"]
+};
+
+// src/plugins/gitagent/reader.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { readdir, readFile as readFileAsync, stat } from "fs/promises";
+import { join } from "path";
+function parseYaml(content) {
+  const lines = content.split("\n");
+  let pos = 0;
+  const at = (i) => lines[i];
+  function skipEmptyAndComments() {
+    while (pos < lines.length) {
+      const line = at(pos);
+      const trimmed = line.trim();
+      if (trimmed === "" || trimmed.startsWith("#")) {
+        pos++;
+      } else {
+        break;
+      }
+    }
+  }
+  function getIndent(line) {
+    return line.length - line.trimStart().length;
+  }
+  function parseValue(raw) {
+    const v = raw.trim();
+    if (v === "true" || v === "yes") return true;
+    if (v === "false" || v === "no") return false;
+    if (v === "null" || v === "~" || v === "") return null;
+    if (/^-?\d+$/.test(v)) return Number.parseInt(v, 10);
+    if (/^-?\d*\.\d+$/.test(v)) return Number.parseFloat(v);
+    if (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")) {
+      return v.slice(1, -1);
+    }
+    if (v.startsWith("[") && v.endsWith("]")) {
+      const inner = v.slice(1, -1);
+      if (inner.trim() === "") return [];
+      return inner.split(",").map((s) => parseValue(s.trim())).filter((s) => s !== null && s !== "");
+    }
+    return v;
+  }
+  function parseBlock(minIndent) {
+    skipEmptyAndComments();
+    if (pos >= lines.length) return null;
+    const firstLine = at(pos);
+    const firstIndent = getIndent(firstLine);
+    if (firstIndent < minIndent) return null;
+    const firstTrimmed = firstLine.trim();
+    if (firstTrimmed.startsWith("- ") || firstTrimmed === "-") {
+      const arr = [];
+      while (pos < lines.length) {
+        skipEmptyAndComments();
+        if (pos >= lines.length) break;
+        const line = at(pos);
+        const indent = getIndent(line);
+        if (indent < minIndent) break;
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("-")) break;
+        const afterDash = trimmed.slice(1).trim();
+        pos++;
+        if (afterDash === "") {
+          arr.push(parseBlock(indent + 2));
+        } else if (afterDash.includes(":")) {
+          const obj = {};
+          const [k, ...rest] = afterDash.split(":");
+          const v = rest.join(":").trim();
+          if (v !== "") {
+            obj[k.trim()] = parseValue(v);
+          }
+          while (pos < lines.length) {
+            skipEmptyAndComments();
+            if (pos >= lines.length) break;
+            const nextLine = at(pos);
+            const nextIndent = getIndent(nextLine);
+            if (nextIndent < indent + 2) break;
+            const nextTrimmed = nextLine.trim();
+            if (!nextTrimmed.includes(":")) break;
+            const [nk, ...nrest] = nextTrimmed.split(":");
+            const nv = nrest.join(":").trim();
+            pos++;
+            obj[nk.trim()] = nv !== "" ? parseValue(nv) : parseBlock(nextIndent + 2);
+          }
+          arr.push(Object.keys(obj).length > 1 ? obj : parseValue(afterDash));
+        } else {
+          arr.push(parseValue(afterDash));
+        }
+      }
+      return arr;
+    }
+    if (firstTrimmed.includes(":")) {
+      const obj = {};
+      while (pos < lines.length) {
+        skipEmptyAndComments();
+        if (pos >= lines.length) break;
+        const line = at(pos);
+        const indent = getIndent(line);
+        if (indent < minIndent) break;
+        const trimmed = line.trim();
+        if (trimmed.startsWith("-")) break;
+        const colonIdx = trimmed.indexOf(":");
+        if (colonIdx < 0) {
+          pos++;
+          continue;
+        }
+        const key = trimmed.slice(0, colonIdx).trim();
+        const afterColon = trimmed.slice(colonIdx + 1).trim();
+        pos++;
+        if (afterColon === "" || afterColon === "|" || afterColon === ">") {
+          if (afterColon === "|" || afterColon === ">") {
+            const blockLines = [];
+            while (pos < lines.length) {
+              const subLine = at(pos);
+              const subIndent = getIndent(subLine);
+              if (subLine.trim() === "") {
+                blockLines.push("");
+                pos++;
+                continue;
+              }
+              if (subIndent <= indent) break;
+              blockLines.push(subLine.slice(indent + 2));
+              pos++;
+            }
+            obj[key] = blockLines.join("\n").trimEnd();
+          } else {
+            skipEmptyAndComments();
+            if (pos < lines.length) {
+              const nextLine = at(pos);
+              const nextIndent = getIndent(nextLine);
+              if (nextIndent > indent) {
+                obj[key] = parseBlock(nextIndent);
+              } else {
+                obj[key] = null;
+              }
+            }
+          }
+        } else {
+          obj[key] = parseValue(afterColon);
+        }
+      }
+      return obj;
+    }
+    pos++;
+    return parseValue(firstTrimmed);
+  }
+  return parseBlock(0);
+}
+function safeParseYaml(content, context) {
+  try {
+    const result = parseYaml(content);
+    if (result !== null && typeof result === "object" && !Array.isArray(result)) {
+      return result;
+    }
+    return {};
+  } catch (err) {
+    process.stderr.write(`[gitagent] YAML parse warning in ${context}: ${String(err)}
+`);
+    return {};
+  }
+}
+function readFileSync_(dir, ...parts) {
+  const p = join(dir, ...parts);
+  if (!existsSync(p)) return null;
+  return readFileSync(p, "utf-8");
+}
+function listDirSync(dir, ...parts) {
+  const p = join(dir, ...parts);
+  if (!existsSync(p)) return [];
+  try {
+    return readdirSync(p);
+  } catch {
+    return [];
+  }
+}
+function parseAgentYaml(content) {
+  const raw = safeParseYaml(content, "agent.yaml");
+  const model = raw.model;
+  const compliance = raw.compliance;
+  const supervision = compliance?.supervision ?? {};
+  const recordkeeping = compliance?.recordkeeping ?? {};
+  return {
+    name: raw.name ?? "",
+    version: raw.version,
+    description: raw.description,
+    model: model ? {
+      preferred: model.preferred ?? "",
+      fallbacks: model.fallbacks ?? void 0,
+      constraints: model.constraints ? {
+        temperature: model.constraints.temperature ?? void 0,
+        max_tokens: model.constraints.max_tokens ?? void 0,
+        top_p: model.constraints.top_p ?? void 0,
+        thinking_level: model.constraints.thinking_level ?? void 0
+      } : void 0
+    } : void 0,
+    skills: raw.skills ?? void 0,
+    tools: raw.tools ?? void 0,
+    runtime: raw.runtime,
+    compliance: compliance ? {
+      risk_tier: compliance.risk_tier,
+      frameworks: compliance.frameworks ?? void 0,
+      supervision: {
+        human_in_the_loop: supervision.human_in_the_loop
+      },
+      recordkeeping: {
+        audit_logging: recordkeeping.audit_logging,
+        retention_period: recordkeeping.retention_period
+      },
+      model_risk: compliance.model_risk
+    } : void 0,
+    dependencies: raw.dependencies,
+    agents: raw.agents ?? void 0,
+    delegation: raw.delegation,
+    exports: raw.exports
+  };
+}
+function parseSoulMd(content) {
+  const lines = content.split("\n");
+  let name;
+  let personality = "";
+  for (const line of lines) {
+    if (!name && line.startsWith("# ")) {
+      name = line.slice(2).trim();
+      continue;
+    }
+    personality += `${line}
+`;
+  }
+  personality = personality.trim();
+  return {
+    name,
+    personality: personality || void 0
+  };
+}
+function parseRulesMd(content) {
+  return content.trim();
+}
+function parseInstructionsMd(content) {
+  return content.trim();
+}
+function parseSkillMd(skillId, content) {
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!fmMatch) {
+    return { id: skillId, content };
+  }
+  const meta = safeParseYaml(fmMatch[1], `skills/${skillId}/SKILL.md`);
+  return {
+    id: skillId,
+    name: meta.name ?? skillId,
+    version: meta.version,
+    description: meta.description,
+    triggers: meta.triggers ?? void 0,
+    content: fmMatch[2].trim()
+  };
+}
+function parseToolYaml(toolId, content) {
+  const raw = safeParseYaml(content, `tools/${toolId}.yaml`);
+  return {
+    id: toolId,
+    name: raw.name ?? toolId,
+    description: raw.description,
+    type: raw.type,
+    schema: raw.schema
+  };
+}
+function parseHooksYaml(content) {
+  const raw = safeParseYaml(content, "hooks/hooks.yaml");
+  const lifecycle = raw.lifecycle;
+  const events = raw.events;
+  return {
+    lifecycle: lifecycle ? {
+      on_start: lifecycle.on_start,
+      on_stop: lifecycle.on_stop,
+      on_error: lifecycle.on_error,
+      on_reset: lifecycle.on_reset
+    } : void 0,
+    events: events?.map((e) => ({
+      name: e.name ?? "",
+      trigger: e.trigger ?? "",
+      skill: e.skill,
+      tool: e.tool,
+      prompt: e.prompt
+    })),
+    bootstrap: void 0,
+    teardown: void 0
+  };
+}
+function parseSkillFlowYaml(content, filename) {
+  const raw = safeParseYaml(content, filename);
+  const stepsRaw = raw.steps ?? {};
+  const steps = {};
+  for (const [stepId, stepRaw] of Object.entries(stepsRaw)) {
+    if (!stepRaw || typeof stepRaw !== "object") continue;
+    steps[stepId] = {
+      skill: stepRaw.skill,
+      agent: stepRaw.agent,
+      tool: stepRaw.tool,
+      dependsOn: stepRaw.depends_on ?? void 0,
+      inputs: stepRaw.inputs ?? void 0,
+      prompt: stepRaw.prompt,
+      conditions: stepRaw.conditions ?? void 0
+    };
+  }
+  const errorHandling = raw.error_handling;
+  return {
+    name: raw.name ?? filename,
+    description: raw.description,
+    triggers: raw.triggers ?? void 0,
+    schedule: raw.schedule,
+    steps,
+    errorHandling: errorHandling ? {
+      onFailure: errorHandling.on_failure,
+      notifyChannel: errorHandling.notify_channel,
+      maxRetries: errorHandling.max_retries
+    } : void 0
+  };
+}
+function parseSchedulerYaml(content) {
+  const raw = safeParseYaml(content, "scheduler.yml");
+  const schedules = raw.schedules;
+  return {
+    schedules: schedules?.map((s) => ({
+      name: s.name ?? "",
+      cron: s.cron,
+      interval: s.interval,
+      skill: s.skill,
+      tool: s.tool,
+      prompt: s.prompt,
+      enabled: s.enabled
+    }))
+  };
+}
+function readGitAgentDir(dir) {
+  const parsed = {
+    skills: [],
+    tools: [],
+    skillFlows: [],
+    dir
+  };
+  const agentYaml = readFileSync_(dir, "agent.yaml");
+  if (agentYaml) parsed.manifest = parseAgentYaml(agentYaml);
+  const soulMd = readFileSync_(dir, "SOUL.md");
+  if (soulMd) parsed.soul = parseSoulMd(soulMd);
+  const rulesMd = readFileSync_(dir, "RULES.md");
+  if (rulesMd) parsed.rules = parseRulesMd(rulesMd);
+  const instructionsMd = readFileSync_(dir, "INSTRUCTIONS.md");
+  if (instructionsMd) parsed.instructions = parseInstructionsMd(instructionsMd);
+  const agentsMd = readFileSync_(dir, "AGENTS.md");
+  if (agentsMd) parsed.agents = agentsMd.trim();
+  for (const skillDir of listDirSync(dir, "skills")) {
+    const skillMd = readFileSync_(dir, "skills", skillDir, "SKILL.md");
+    if (skillMd) {
+      parsed.skills.push(parseSkillMd(skillDir, skillMd));
+    }
+  }
+  for (const toolFile of listDirSync(dir, "tools")) {
+    if (!toolFile.endsWith(".yaml") && !toolFile.endsWith(".yml")) continue;
+    const toolContent = readFileSync_(dir, "tools", toolFile);
+    if (toolContent) {
+      const toolId = toolFile.replace(/\.(ya?ml)$/, "");
+      parsed.tools.push(parseToolYaml(toolId, toolContent));
+    }
+  }
+  const hooksYaml = readFileSync_(dir, "hooks", "hooks.yaml");
+  if (hooksYaml) {
+    parsed.hooks = parseHooksYaml(hooksYaml);
+    parsed.hooks.bootstrap = readFileSync_(dir, "hooks", "bootstrap.md") ?? void 0;
+    parsed.hooks.teardown = readFileSync_(dir, "hooks", "teardown.md") ?? void 0;
+  } else {
+    const bootstrap = readFileSync_(dir, "hooks", "bootstrap.md");
+    const teardown = readFileSync_(dir, "hooks", "teardown.md");
+    if (bootstrap || teardown) {
+      parsed.hooks = { bootstrap: bootstrap ?? void 0, teardown: teardown ?? void 0 };
+    }
+  }
+  for (const sfFile of listDirSync(dir, "skillflows")) {
+    if (!sfFile.endsWith(".yaml") && !sfFile.endsWith(".yml")) continue;
+    const sfContent = readFileSync_(dir, "skillflows", sfFile);
+    if (sfContent) {
+      parsed.skillFlows.push(parseSkillFlowYaml(sfContent, sfFile));
+    }
+  }
+  const schedulerYml = readFileSync_(dir, "scheduler.yml") ?? readFileSync_(dir, "scheduler.yaml");
+  if (schedulerYml) parsed.scheduler = parseSchedulerYaml(schedulerYml);
+  const memoryMd = readFileSync_(dir, "memory", "MEMORY.md");
+  if (memoryMd) parsed.memoryInstructions = memoryMd.trim();
+  return parsed;
+}
+function adaptGitAgentModel(manifest) {
+  if (!manifest.model?.preferred) return void 0;
+  const m = manifest.model;
+  return {
+    preferred: m.preferred,
+    fallbacks: m.fallbacks,
+    constraints: m.constraints ? {
+      temperature: m.constraints.temperature,
+      maxTokens: m.constraints.max_tokens,
+      topP: m.constraints.top_p,
+      thinkingLevel: m.constraints.thinking_level
+    } : void 0
+  };
+}
+function adaptGitAgentCompliance(manifest) {
+  if (!manifest.compliance) return void 0;
+  const c = manifest.compliance;
+  return {
+    riskTier: c.risk_tier,
+    frameworks: c.frameworks,
+    humanInTheLoop: c.supervision?.human_in_the_loop,
+    auditLogging: c.recordkeeping?.audit_logging,
+    retentionPeriod: c.recordkeeping?.retention_period
+  };
+}
+function enrichAgentFromGitAgent(agent, parsed) {
+  const enriched = { ...agent };
+  if (parsed.soul) {
+    enriched.identity = {
+      name: agent.identity?.name ?? parsed.soul.name,
+      description: agent.identity?.description ?? parsed.manifest?.description,
+      personality: agent.identity?.personality ?? parsed.soul.personality,
+      systemPrompt: agent.identity?.systemPrompt
+    };
+  }
+  if (!enriched.description && parsed.manifest?.description) {
+    enriched.description = parsed.manifest.description;
+  }
+  if (!enriched.model && parsed.manifest) {
+    enriched.model = adaptGitAgentModel(parsed.manifest) ?? enriched.model;
+  }
+  if (!enriched.compliance && parsed.manifest) {
+    enriched.compliance = adaptGitAgentCompliance(parsed.manifest) ?? enriched.compliance;
+  }
+  if (!enriched.workflows?.length && parsed.skillFlows.length > 0) {
+    enriched.workflows = parsed.skillFlows;
+  }
+  return enriched;
+}
+function buildOpenClawFromGitAgent(parsed, mountPath) {
+  const result = {};
+  result.agents = {
+    defaults: {
+      repoRoot: mountPath
+    }
+  };
+  if (parsed.skills.length > 0) {
+    result.skills = {
+      load: { extraDirs: [join(mountPath, "skills")] },
+      entries: Object.fromEntries(
+        parsed.skills.map((s) => [
+          s.id,
+          {
+            enabled: true
+          }
+        ])
+      )
+    };
+  }
+  if (parsed.scheduler?.schedules?.length) {
+    const firstSchedule = parsed.scheduler.schedules[0];
+    if (firstSchedule.cron || firstSchedule.interval) {
+      if (!result.agents) result.agents = {};
+      if (!result.agents.defaults) result.agents.defaults = {};
+      result.agents.defaults.heartbeat = {
+        every: firstSchedule.interval ?? firstSchedule.cron,
+        prompt: firstSchedule.prompt ?? `Run scheduled task: ${firstSchedule.name}`
+      };
+    }
+  }
+  return result;
+}
+
+// src/plugins/gitagent/index.ts
+var gitagentK8sProvider = {
+  buildK8s(agent, _ctx) {
+    const src = agent.source;
+    if (!src) return void 0;
+    const useGitagent = src.gitagent !== false;
+    if (!useGitagent) return void 0;
+    const git = src.git;
+    if (!git?.url) return void 0;
+    const mountPath = src.mountPath ?? "/agent";
+    const ref = git.ref ?? "main";
+    const depth = git.depth ?? 1;
+    const include = src.include;
+    const poll = src.poll;
+    const intervalSec = parsePollInterval(poll);
+    const result = {
+      initContainers: [
+        {
+          name: "gitagent-clone",
+          image: "alpine/git:latest",
+          imagePullPolicy: "IfNotPresent",
+          command: buildGitCloneCommand({
+            url: git.url,
+            ref,
+            depth,
+            agentDir: git.dir,
+            mountPath,
+            include
+          }),
+          volumeMounts: [{ name: "gitagent-src", mountPath }]
+        }
+      ],
+      volumes: [{ name: "gitagent-src", spec: { emptyDir: {} } }],
+      volumeMounts: [{ name: "gitagent-src", mountPath }],
+      envVars: [{ name: "OPENCLAW_AGENT_DIR", value: mountPath }],
+      labels: { "gitagent.url": git.url.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 63) }
+    };
+    const sidecar = buildGitSyncSidecar({
+      name: "gitagent-sync",
+      url: git.url,
+      ref,
+      depth,
+      agentDir: git.dir,
+      mountPath,
+      include,
+      intervalSec
+    });
+    if (sidecar) result.sidecars = [sidecar];
+    return result;
+  }
+};
+var plugin = definePlugin(manifest_default, (api) => {
+  api.onResolveAgent((agent, _config) => {
+    const gitagentEntry = agent.use?.find((u) => u.plugin === "gitagent");
+    if (!gitagentEntry?.options) return agent;
+    let a = agent.source ? agent : { ...agent, source: gitagentEntry.options };
+    const localPath = a.source?.path ? resolve(a.source.path) : void 0;
+    if (localPath && existsSync2(localPath)) {
+      const parsed = readGitAgentDir(localPath);
+      a = enrichAgentFromGitAgent(a, parsed);
+    }
+    return a;
+  });
+  api.onBuildConfig((context) => {
+    const { agent } = context;
+    if (!agent.source) return {};
+    const mountPath = agent.source.mountPath ?? "/agent";
+    const useGitagent = agent.source.gitagent !== false;
+    if (!useGitagent) return {};
+    const fragment = {
+      agents: {
+        defaults: {
+          repoRoot: mountPath
+        }
+      }
+    };
+    if (agent.source.path) {
+      const localPath = resolve(agent.source.path);
+      if (existsSync2(localPath)) {
+        const parsed = readGitAgentDir(localPath);
+        const additions = buildOpenClawFromGitAgent(parsed, mountPath);
+        if (additions.skills) {
+          fragment.skills = additions.skills;
+        }
+        if (additions.agents?.defaults?.heartbeat) {
+          ;
+          fragment.agents.defaults = {
+            ...fragment.agents.defaults,
+            heartbeat: additions.agents.defaults.heartbeat
+          };
+        }
+      }
+    }
+    return fragment;
+  });
+});
+plugin.k8s = gitagentK8sProvider;
+var gitagent_default = plugin;
+export {
+  gitagent_default as default
+};