@monkey-mini-app/dsh-mini-app 0.1.0

package/lib/index.js

@@ -0,0 +1,1094 @@
+// src/index.ts
+import { createHost } from "@monkey-mini-app/host";
+
+// src/apply-config.ts
+import { homedir } from "os";
+import path from "path";
+import {
+  asAbsolutePath,
+  bootstrapHostConfig,
+  createHostI18n,
+  HostConfigError,
+  loadHostConfig,
+  WorkspacePaths
+} from "@monkey-mini-app/host";
+function expandHome(p) {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/") || p.startsWith("~\\")) return path.join(homedir(), p.slice(2));
+  return p;
+}
+function toRuntimeRoot(input) {
+  const resolved = path.resolve(expandHome(input));
+  try {
+    return asAbsolutePath(resolved);
+  } catch (cause) {
+    throw new HostConfigError("host config runtimeRoot must be an absolute path", { cause });
+  }
+}
+function resolveRuntimeRoot(config = {}) {
+  if (typeof config.runtimeRoot === "string" && config.runtimeRoot.length > 0) {
+    return toRuntimeRoot(config.runtimeRoot);
+  }
+  return bootstrapHostConfig({}).runtimeRoot;
+}
+function missingConfigError(file, cause) {
+  const i18n = createHostI18n("zh-CN");
+  const message = `${i18n.t("config.missingFile", { path: file })} ${i18n.t("config.missingHint")}`;
+  return new HostConfigError(message, { code: "HOST_CONFIG_NOT_FOUND", cause });
+}
+function loadPluginHostConfig(config = {}) {
+  const runtimeRoot = resolveRuntimeRoot(config);
+  const paths = new WorkspacePaths(runtimeRoot);
+  try {
+    return loadHostConfig(paths);
+  } catch (cause) {
+    if (cause instanceof HostConfigError && cause.code === "HOST_CONFIG_NOT_FOUND") {
+      throw missingConfigError(paths.hostConfigFile(), cause);
+    }
+    throw cause;
+  }
+}
+
+// src/capabilities.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/agent-one-shot.ts
+import { randomUUID } from "crypto";
+import { rm } from "fs/promises";
+import {
+  effectiveSignal,
+  isMiniAppToolName,
+  resolveAgentCwd
+} from "@monkey-mini-app/host";
+
+// src/ctx.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getService(ctx, name2) {
+  try {
+    if (typeof ctx.get === "function") {
+      const viaGet = ctx.get(name2);
+      if (viaGet !== void 0) return viaGet;
+    }
+  } catch {
+  }
+  try {
+    const direct = ctx[name2];
+    if (direct !== void 0) return direct;
+  } catch {
+  }
+  return void 0;
+}
+function toolsOf(ctx) {
+  const tools = getService(ctx, "tools");
+  return isRecord(tools) ? tools : void 0;
+}
+
+// src/agent-event-project.ts
+function projectTurnEndReason(raw) {
+  if (typeof raw === "string" && raw.trim()) {
+    return { kind: raw.trim() };
+  }
+  if (!isRecord(raw)) return void 0;
+  const kind = typeof raw.kind === "string" ? raw.kind : "";
+  if (!kind) return void 0;
+  const out = { kind };
+  if (raw.error !== void 0) out.error = raw.error;
+  if (raw.reason !== void 0) out.reason = raw.reason;
+  return out;
+}
+function contentBlocksToText(blocks) {
+  if (!Array.isArray(blocks)) return "";
+  const parts = [];
+  for (const block of blocks) {
+    if (!isRecord(block)) continue;
+    if (block.type === "text" && typeof block.text === "string") parts.push(block.text);
+  }
+  return parts.join("");
+}
+function parseToolArgs(raw) {
+  if (typeof raw !== "string") return raw;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function emitSafe(onEvent, event) {
+  if (!onEvent) return;
+  try {
+    onEvent(event);
+  } catch {
+  }
+}
+function createSessionEventProjector(onEvent) {
+  const callNames = /* @__PURE__ */ new Map();
+  return {
+    push(raw) {
+      if (!onEvent || !isRecord(raw)) return;
+      const type = typeof raw.type === "string" ? raw.type : "";
+      const data = isRecord(raw.data) ? raw.data : raw;
+      if (type === "turn/start" && typeof data.turn === "number") {
+        emitSafe(onEvent, { type: "turn", phase: "start", turn: data.turn });
+        return;
+      }
+      if (type === "turn/end" && typeof data.turn === "number") {
+        const reason = projectTurnEndReason(data.reason);
+        emitSafe(onEvent, {
+          type: "turn",
+          phase: "end",
+          turn: data.turn,
+          ...reason ? { reason } : {}
+        });
+        return;
+      }
+      if (type === "assistant/chunk") {
+        const chunk = isRecord(data.chunk) ? data.chunk : null;
+        if (chunk && chunk.type === "text-delta" && typeof chunk.text === "string" && chunk.text) {
+          emitSafe(onEvent, { type: "text-delta", text: chunk.text });
+        }
+        return;
+      }
+      if (type === "tool/call") {
+        const name2 = typeof data.name === "string" ? data.name : "";
+        const callId = data.callId != null ? String(data.callId) : "";
+        if (callId && name2) callNames.set(callId, name2);
+        emitSafe(onEvent, {
+          type: "tool",
+          phase: "start",
+          name: name2,
+          args: parseToolArgs(data.arguments)
+        });
+        return;
+      }
+      if (type === "tool/result") {
+        const message = isRecord(data.message) ? data.message : null;
+        const callId = message && Array.isArray(message.content) && isRecord(message.content[0]) ? String(message.content[0].callId ?? "") : "";
+        const name2 = callId && callNames.get(callId) || "";
+        if (callId) callNames.delete(callId);
+        const resultText = message ? contentBlocksToText(message.content) : "";
+        emitSafe(onEvent, {
+          type: "tool",
+          phase: "end",
+          name: name2,
+          result: resultText || data.error || void 0
+        });
+      }
+    }
+  };
+}
+function emitAgentEvent(onEvent, event) {
+  emitSafe(onEvent, event);
+}
+
+// src/llm-route.ts
+var DSH_LLM_FALLBACK = {
+  provider: "deepseek-official",
+  model: "deepseek-v4-flash"
+};
+function pickLlmRoute(value) {
+  if (!isRecord(value)) return null;
+  const provider = typeof value.provider === "string" ? value.provider.trim() : "";
+  const model = typeof value.model === "string" ? value.model.trim() : "";
+  if (!provider || !model) return null;
+  return { provider, model };
+}
+function resolveLlmRoute(ctx, opts, hostLlm) {
+  const fromOpts = pickLlmRoute({ provider: opts?.provider, model: opts?.model });
+  if (fromOpts) return fromOpts;
+  const fromHost = pickLlmRoute(hostLlm);
+  if (fromHost) return fromHost;
+  const cfg = getService(ctx, "config");
+  const fromCfg = isRecord(cfg) ? pickLlmRoute(cfg.llm) : null;
+  if (fromCfg) return fromCfg;
+  const adm = getService(ctx, "agentDefaultModel");
+  if (isRecord(adm) && typeof adm.currentSelection === "function") {
+    try {
+      const fromAdm = pickLlmRoute(adm.currentSelection());
+      if (fromAdm) return fromAdm;
+    } catch {
+    }
+  }
+  return { provider: DSH_LLM_FALLBACK.provider, model: DSH_LLM_FALLBACK.model };
+}
+
+// src/llm-stream.ts
+function stringifyToolResult(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+function withJsonInstruction(prompt, opts) {
+  if (!opts || opts.schema == null) {
+    return { prompt, system: opts?.system };
+  }
+  const schemaText = JSON.stringify(opts.schema);
+  const system = [
+    opts.system ?? "",
+    "Return ONLY a JSON object matching this JSON Schema. No markdown fences, no preamble.",
+    schemaText
+  ].filter(Boolean).join("\n\n");
+  return { prompt, system };
+}
+function coerceSchemaJson(text, opts) {
+  if (!opts || opts.schema == null) return text;
+  const t = String(text || "").trim();
+  const fence = t.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const body = (fence?.[1] ?? t).trim();
+  if (body.startsWith("{") || body.startsWith("[")) return body;
+  const startObj = body.indexOf("{");
+  const endObj = body.lastIndexOf("}");
+  if (startObj >= 0 && endObj > startObj) return body.slice(startObj, endObj + 1);
+  const startArr = body.indexOf("[");
+  const endArr = body.lastIndexOf("]");
+  if (startArr >= 0 && endArr > startArr) return body.slice(startArr, endArr + 1);
+  return body;
+}
+function asChunk(value) {
+  if (typeof value !== "object" || value === null) return null;
+  return value;
+}
+async function collectLlmStream(llmSvc, prompt, route, opts) {
+  const { prompt: text, system } = withJsonInstruction(prompt, opts);
+  const req = {
+    provider: route.provider,
+    model: route.model,
+    messages: [{ role: "user", content: [{ type: "text", text }] }],
+    system,
+    maxTokens: opts?.maxTokens ?? 1024
+  };
+  const acc = [];
+  let sawDelta = false;
+  for await (const raw of llmSvc.stream(req)) {
+    const chunk = asChunk(raw);
+    if (!chunk) continue;
+    const type = chunk.type;
+    if (type === "text-delta" && typeof chunk.text === "string") {
+      sawDelta = true;
+      acc.push(chunk.text);
+    } else if (type === "block-end" && chunk.block && typeof chunk.block.text === "string") {
+      if (!sawDelta) acc.push(chunk.block.text);
+    }
+  }
+  const out = acc.join("");
+  if (!out) throw new Error("llm stream empty");
+  return coerceSchemaJson(out, opts);
+}
+
+// src/agent-one-shot.ts
+var helpersPromise = null;
+var helpersLoadError;
+function loadDshHelpers() {
+  if (!helpersPromise) {
+    helpersPromise = (async () => {
+      try {
+        const [sessionMod, llmMod, subagentMod] = await Promise.all([
+          import(
+            /* @vite-ignore */
+            "@deepseek-ai/dsh-session"
+          ),
+          import(
+            /* @vite-ignore */
+            "@deepseek-ai/dsh-llm"
+          ),
+          import(
+            /* @vite-ignore */
+            "@deepseek-ai/dsh-subagent"
+          )
+        ]);
+        const SessionId = sessionMod.SessionId;
+        const createUserMessage = llmMod.createUserMessage;
+        const finalAssistantOutput = subagentMod.finalAssistantOutput;
+        if (!SessionId || !createUserMessage || !finalAssistantOutput) {
+          helpersLoadError = "exports missing SessionId / createUserMessage / finalAssistantOutput";
+          return null;
+        }
+        helpersLoadError = void 0;
+        return { SessionId, createUserMessage, finalAssistantOutput };
+      } catch (cause) {
+        helpersLoadError = cause instanceof Error ? cause.message : String(cause);
+        return null;
+      }
+    })();
+  }
+  return helpersPromise.then((helpers) => {
+    if (!helpers) helpersPromise = null;
+    return helpers;
+  });
+}
+function contentBlocksToText2(blocks) {
+  if (!Array.isArray(blocks)) return "";
+  const parts = [];
+  for (const block of blocks) {
+    if (!isRecord(block)) continue;
+    if (block.type === "text" && typeof block.text === "string") parts.push(block.text);
+  }
+  return parts.join("");
+}
+function heuristicFinalText(events) {
+  let last = "";
+  for (const ev of events) {
+    if (!isRecord(ev)) continue;
+    const data = isRecord(ev.data) ? ev.data : ev;
+    const msg = isRecord(data.message) ? data.message : isRecord(data) ? data : null;
+    if (!msg || msg.role !== "assistant") continue;
+    const text = contentBlocksToText2(msg.content);
+    if (text.trim()) last = text;
+  }
+  return last;
+}
+function readTurnEndSummaries(events) {
+  const out = [];
+  for (const ev of events) {
+    if (!isRecord(ev) || ev.type !== "turn/end") continue;
+    const data = isRecord(ev.data) ? ev.data : ev;
+    const reason = data.reason;
+    const kind = isRecord(reason) && typeof reason.kind === "string" ? reason.kind : typeof reason === "string" ? reason : "unknown";
+    const turn = typeof data.turn === "number" ? data.turn : "?";
+    let detail;
+    if (isRecord(reason) && isRecord(reason.error)) {
+      const code = typeof reason.error.code === "string" ? reason.error.code : "";
+      const message = typeof reason.error.message === "string" ? reason.error.message : "";
+      detail = [code, message].filter(Boolean).join(": ") || void 0;
+    } else if (isRecord(reason) && reason.reason !== void 0) {
+      detail = typeof reason.reason === "string" ? reason.reason : JSON.stringify(reason.reason);
+    }
+    out.push({ turn, kind, detail });
+  }
+  return out;
+}
+function summarizeSessionEvents(events) {
+  const types = [];
+  for (const ev of events) {
+    if (!isRecord(ev)) continue;
+    types.push(typeof ev.type === "string" ? ev.type : "?");
+  }
+  const turnEnds = readTurnEndSummaries(events).map((t) => {
+    const base = `t${t.turn}:${t.kind}`;
+    return t.detail ? `${base}(${t.detail.slice(0, 160)})` : base;
+  });
+  const typeSeq = types.length ? types.join(" \u2192 ") : "(no events)";
+  const ends = turnEnds.length ? turnEnds.join(", ") : "(no turn/end)";
+  return `events=[${typeSeq}]; turnEnds=[${ends}]`;
+}
+function primaryTurnFailureMessage(events) {
+  const ends = readTurnEndSummaries(events);
+  for (let i = ends.length - 1; i >= 0; i--) {
+    const t = ends[i];
+    if (t.kind === "error") {
+      return t.detail ? `agent: turn ${t.turn} failed: ${t.detail}` : `agent: turn ${t.turn} failed`;
+    }
+    if (t.kind === "blocked") {
+      return `agent: turn ${t.turn} blocked (pre-step rejected)`;
+    }
+    if (t.kind === "aborted") {
+      return t.detail ? `agent: turn ${t.turn} aborted: ${t.detail}` : `agent: turn ${t.turn} aborted`;
+    }
+  }
+  return void 0;
+}
+function asAgentsService(value) {
+  if (!isRecord(value) || typeof value.create !== "function") return null;
+  return value;
+}
+function buildGoalText(goal, opts) {
+  const { prompt, system } = withJsonInstruction(goal, opts);
+  if (!system) return prompt;
+  return `${system}
+
+---
+
+${prompt}`;
+}
+function onEventOf(opts) {
+  return typeof opts?.onEvent === "function" ? opts.onEvent : void 0;
+}
+async function composeOneShotSetup(agentCtx) {
+  const presets = getService(agentCtx, "agentPresets");
+  if (isRecord(presets) && typeof presets.mount === "function") {
+    await presets.mount(agentCtx);
+  } else {
+    console.warn(
+      "[monkey-mini-app] agentPresets.mount unavailable; ctx.agent one-shot will lack preset tools (bash/read)"
+    );
+  }
+  const tools = toolsOf(agentCtx) ?? (isRecord(agentCtx) ? agentCtx.tools : void 0);
+  if (tools && typeof tools.restrict === "function") {
+    const rows = [];
+    if (typeof tools.schemas === "function") {
+      const list = tools.schemas();
+      if (Array.isArray(list)) rows.push(...list);
+    } else if (typeof tools.list === "function") {
+      const list = tools.list();
+      if (Array.isArray(list)) rows.push(...list);
+    }
+    for (const row of rows) {
+      const name2 = isRecord(row) && typeof row.name === "string" ? row.name : "";
+      if (!isMiniAppToolName(name2)) continue;
+      try {
+        tools.restrict({ deny: [name2] });
+      } catch {
+      }
+    }
+  }
+  return {
+    commit() {
+      const agent = isRecord(agentCtx) ? agentCtx.agent : void 0;
+      const sessionRec = isRecord(agent) && isRecord(agent.session) ? agent.session : void 0;
+      const append = sessionRec && typeof sessionRec.append === "function" ? sessionRec.append : void 0;
+      if (!append) return;
+      try {
+        append("approval/policy", { policy: "never", source: "delegation" });
+      } catch {
+      }
+      try {
+        append("sandbox/mode", { mode: "danger-full-access", source: "delegation" });
+      } catch {
+      }
+      try {
+        append("permission/preset", {
+          preset: "danger-full-access",
+          source: "delegation"
+        });
+      } catch {
+      }
+    }
+  };
+}
+function drainSessionEvents(events, cursor, projector) {
+  while (cursor.i < events.length) {
+    projector.push(events[cursor.i]);
+    cursor.i += 1;
+  }
+}
+async function runDshAgentOneShot(dsh, goal, opts, deps) {
+  const callCtx = deps?.callCtx;
+  const agents = asAgentsService(getService(dsh, "agents"));
+  if (!agents) {
+    throw new Error(
+      "agent: dsh agents factory unbound (ctx.agents.create). Ensure @deepseek-ai/dsh-agent-loop is loaded."
+    );
+  }
+  const helpers = await (deps?.loadHelpers ?? loadDshHelpers)();
+  if (!helpers) {
+    const detail = helpersLoadError ? `: ${helpersLoadError}` : "";
+    throw new Error(
+      `agent: dsh SDK helpers unavailable (@deepseek-ai/dsh-session / dsh-llm / dsh-subagent)${detail}`
+    );
+  }
+  const userOnEvent = onEventOf(opts);
+  const route = resolveLlmRoute(dsh, opts, callCtx?.hostLlm);
+  if (!route.provider.trim() || !route.model.trim()) {
+    throw new Error(
+      `agent: unresolved model route (need provider+model for prompt assembly; got provider=${JSON.stringify(route.provider)} model=${JSON.stringify(route.model)})`
+    );
+  }
+  const maxTokens = opts?.maxTokens;
+  const maxIterations = typeof opts?.maxIterations === "number" && Number.isFinite(opts.maxIterations) && opts.maxIterations > 0 ? Math.floor(opts.maxIterations) : void 0;
+  const signal = effectiveSignal(
+    opts?.signal instanceof AbortSignal ? opts.signal : void 0,
+    callCtx
+  );
+  const sessionId = helpers.SessionId(randomUUID());
+  const goalText = buildGoalText(String(goal || ""), opts);
+  const cwd = resolveAgentCwd(
+    { cwdType: opts?.cwdType, cwd: opts?.cwd },
+    { appDir: callCtx?.appDir }
+  );
+  const cleanupTemp = opts?.cwdType === "temp" ? cwd : void 0;
+  const handle = await agents.create({
+    sessionId,
+    // Absolute cwd required for {{cwd}} in deployment:persona; origin marks ephemeral isolation.
+    meta: { origin: "subagent", cwd },
+    agentOptions: {
+      provider: route.provider,
+      model: route.model,
+      ...maxTokens != null ? { maxTokens } : {}
+    },
+    // Headless: never ask (no UI), open sandbox, hide mini_app_* from this agent.
+    setup: (agentCtx) => composeOneShotSetup(agentCtx),
+    ...signal ? { signal } : {}
+  });
+  try {
+    const approval = getService(dsh, "approval");
+    if (isRecord(approval) && typeof approval.setPolicy === "function" && isRecord(handle.agent)) {
+      approval.setPolicy(handle.agent, "never");
+    }
+  } catch {
+  }
+  const onAbort = () => {
+    try {
+      handle.agent.cancel("host", { keepInbox: false });
+    } catch {
+    }
+  };
+  let turnEnds = 0;
+  let hitIterationLimit = false;
+  const onEvent = userOnEvent || maxIterations ? (ev) => {
+    if (ev.type === "turn" && ev.phase === "end" && maxIterations) {
+      turnEnds += 1;
+      if (turnEnds >= maxIterations && !hitIterationLimit) {
+        hitIterationLimit = true;
+        try {
+          handle.agent.cancel("host", { keepInbox: false });
+        } catch {
+        }
+      }
+    }
+    userOnEvent?.(ev);
+  } : void 0;
+  const projector = createSessionEventProjector(onEvent);
+  const cursor = { i: 0 };
+  let pollTimer;
+  try {
+    if (signal?.aborted) {
+      throw new Error("cancelled");
+    }
+    if (signal) signal.addEventListener("abort", onAbort, { once: true });
+    emitAgentEvent(onEvent, { type: "status", status: "running" });
+    const message = helpers.createUserMessage({
+      content: [{ type: "text", text: goalText }],
+      source: { kind: "plugin", plugin: "monkey-mini-app" }
+    });
+    handle.agent.followup(message);
+    if (onEvent) {
+      const pollMs = deps?.pollMs ?? 40;
+      pollTimer = setInterval(() => {
+        try {
+          drainSessionEvents(handle.agent.session.events, cursor, projector);
+        } catch {
+        }
+      }, pollMs);
+    }
+    await handle.agent.whenIdle();
+    if (pollTimer) {
+      clearInterval(pollTimer);
+      pollTimer = void 0;
+    }
+    drainSessionEvents(handle.agent.session.events, cursor, projector);
+    emitAgentEvent(onEvent, { type: "status", status: "idle" });
+    if (signal?.aborted) {
+      throw new Error("cancelled");
+    }
+    const events = handle.agent.session.events;
+    const blocks = helpers.finalAssistantOutput(events);
+    const text = contentBlocksToText2(blocks) || heuristicFinalText(events);
+    if (!text) {
+      const diag = summarizeSessionEvents(events);
+      const turnFailure = primaryTurnFailureMessage(events);
+      if (turnFailure) {
+        throw new Error(`${turnFailure}; ${diag}`);
+      }
+      throw new Error(
+        hitIterationLimit ? `agent: empty result after maxIterations=${maxIterations}; ${diag}` : `agent: empty result (no assistant output); ${diag}`
+      );
+    }
+    const finalText = coerceSchemaJson(text, opts);
+    emitAgentEvent(onEvent, { type: "done", text: finalText });
+    return finalText;
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    emitAgentEvent(onEvent, { type: "error", message });
+    throw cause;
+  } finally {
+    if (pollTimer) clearInterval(pollTimer);
+    if (signal) signal.removeEventListener("abort", onAbort);
+    try {
+      await handle.dispose();
+    } catch {
+    }
+    if (cleanupTemp) {
+      try {
+        await rm(cleanupTemp, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+
+// src/capabilities.ts
+var execFileAsync = promisify(execFile);
+function listDshTools(ctx) {
+  try {
+    const t = toolsOf(ctx);
+    if (typeof t?.schemas === "function") {
+      const list = t.schemas();
+      if (Array.isArray(list)) {
+        return list.map((x) => ({
+          name: String(x.name || ""),
+          description: String(x.description || ""),
+          parameters: x.parameters ?? { type: "object", properties: {} }
+        }));
+      }
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+var DshCapabilities = class {
+  constructor(dsh) {
+    this.dsh = dsh;
+  }
+  dsh;
+  async bash(_ctx, command) {
+    try {
+      const { stdout, stderr } = await execFileAsync("bash", ["-c", command], {
+        timeout: 12e4,
+        maxBuffer: 8 * 1024 * 1024,
+        env: process.env
+      });
+      return {
+        stdout: String(stdout ?? ""),
+        stderr: String(stderr ?? ""),
+        exitCode: 0
+      };
+    } catch (cause) {
+      const err = cause;
+      const exitCode = typeof err.code === "number" ? err.code : 1;
+      return {
+        stdout: String(err.stdout ?? ""),
+        stderr: String(err.stderr ?? (cause instanceof Error ? cause.message : String(cause))),
+        exitCode
+      };
+    }
+  }
+  async llm(ctx, prompt, opts) {
+    const llmSvc = getService(this.dsh, "llm") || getService(this.dsh, "model") || getService(this.dsh, "chat");
+    const route = resolveLlmRoute(this.dsh, opts, ctx.hostLlm);
+    if (isRecord(llmSvc) && typeof llmSvc.stream === "function") {
+      return collectLlmStream(llmSvc, prompt, route, opts);
+    }
+    if (typeof llmSvc === "function") {
+      return stringifyToolResult(
+        await llmSvc(prompt, opts)
+      );
+    }
+    throw new Error("llm: no dsh model service bound (ctx.llm)");
+  }
+  async agent(ctx, goal, opts) {
+    const agents = getService(this.dsh, "agents") || getService(this.dsh, "subagents");
+    if (isRecord(agents) && typeof agents.run === "function") {
+      return stringifyToolResult(
+        await agents.run(goal, opts)
+      );
+    }
+    if (isRecord(agents) && typeof agents.spawn === "function") {
+      return stringifyToolResult(
+        await agents.spawn({ goal, ...opts || {} })
+      );
+    }
+    return runDshAgentOneShot(this.dsh, goal, opts, { callCtx: ctx });
+  }
+  async tool(_ctx, name2, args) {
+    const tools = toolsOf(this.dsh);
+    if (!tools) throw new Error("tool: no dsh tools service");
+    const t = typeof tools.get === "function" ? tools.get(name2) : void 0;
+    if (isRecord(t) && typeof t.execute === "function") {
+      return stringifyToolResult(
+        await t.execute(args || {})
+      );
+    }
+    throw new Error(`tool not found: ${name2}`);
+  }
+  async mcp(_ctx, name2, args) {
+    const mcpSvc = getService(this.dsh, "mcp");
+    if (!mcpSvc) throw new Error("mcp: no dsh mcp service");
+    const call = isRecord(mcpSvc) ? typeof mcpSvc.call === "function" ? mcpSvc.call : mcpSvc.execute : void 0;
+    if (typeof call !== "function") throw new Error("mcp: service has no call");
+    return stringifyToolResult(await call(name2, args));
+  }
+  credentials(_ctx) {
+    const cred = getService(this.dsh, "credentials");
+    if (!cred) return {};
+    if (isRecord(cred) && typeof cred.getAll === "function") {
+      const all = cred.getAll() || {};
+      return { ...all };
+    }
+    if (isRecord(cred)) {
+      const out = {};
+      for (const [k, v] of Object.entries(cred)) {
+        if (typeof v === "string") out[k] = v;
+      }
+      return out;
+    }
+    return {};
+  }
+  config(_ctx) {
+    const cfg = getService(this.dsh, "config");
+    return isRecord(cfg) ? { ...cfg } : {};
+  }
+  listTools(_ctx) {
+    return listDshTools(this.dsh);
+  }
+};
+
+// src/lifecycle.ts
+import { cpSync, mkdirSync } from "fs";
+import { homedir as homedir2 } from "os";
+import path3 from "path";
+
+// src/skills.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+function resolveSkillDir() {
+  const here = path2.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path2.join(here, "..", "skills", "monkey-mini-app"),
+    path2.join(here, "..", "..", "skills", "monkey-mini-app")
+  ];
+  for (const c of candidates) {
+    if (existsSync(path2.join(c, "SKILL.md"))) return c;
+  }
+  return candidates[0];
+}
+function getSkillDir() {
+  return resolveSkillDir();
+}
+function getSkillMarkdown() {
+  return readFileSync(path2.join(resolveSkillDir(), "SKILL.md"), "utf8");
+}
+function getTemplateFiles(name2) {
+  const base = path2.join(resolveSkillDir(), "templates", name2);
+  if (!existsSync(base)) throw new Error(`template not found: ${name2} under ${resolveSkillDir()}`);
+  const out = {};
+  const walk = (dir, prefix) => {
+    for (const ent of readdirSync(dir, { withFileTypes: true })) {
+      const rel = prefix ? `${prefix}/${ent.name}` : ent.name;
+      const full = path2.join(dir, ent.name);
+      if (ent.isDirectory()) walk(full, rel);
+      else out[rel] = readFileSync(full, "utf8");
+    }
+  };
+  walk(base, "");
+  return out;
+}
+function getSkeletonTemplateFiles() {
+  return getTemplateFiles("minimal");
+}
+
+// src/lifecycle.ts
+function snapshotDshTools(tools) {
+  if (!tools) return [];
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (raw, fallbackName) => {
+    const t = isRecord(raw) ? raw : {};
+    const name2 = String(t.name || t.title || t.id || fallbackName || "");
+    if (!name2 || seen.has(name2)) return;
+    seen.add(name2);
+    rows.push({ name: name2, description: String(t.description || "") });
+  };
+  const listed = isRecord(tools) && typeof tools.list === "function" ? tools.list() : void 0;
+  if (Array.isArray(listed)) {
+    for (const item of listed) push(item);
+  } else if (isRecord(tools)) {
+    for (const key of Object.keys(tools)) {
+      push(tools[key], key);
+    }
+  }
+  return rows;
+}
+async function loadDefineTool() {
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      "@deepseek-ai/dsh-tools"
+    );
+    return typeof mod.defineTool === "function" ? mod.defineTool : null;
+  } catch {
+    return null;
+  }
+}
+function toDshValueSchema(field, fallbackDesc) {
+  const type = typeof field.type === "string" ? field.type : "string";
+  const description = typeof field.description === "string" ? field.description : fallbackDesc !== void 0 ? fallbackDesc : void 0;
+  if (type === "object") {
+    const props = isRecord(field.properties) ? field.properties : {};
+    const req = new Set(Array.isArray(field.required) ? field.required.map(String) : []);
+    const properties = {};
+    for (const [k, raw] of Object.entries(props)) {
+      const child = toDshValueSchema(isRecord(raw) ? raw : {}, k);
+      if (req.has(k)) child.required = true;
+      properties[k] = child;
+    }
+    const out2 = {
+      type: "object",
+      additionalProperties: typeof field.additionalProperties === "boolean" ? field.additionalProperties : true
+    };
+    if (description) out2.description = description;
+    if (Object.keys(properties).length > 0) out2.properties = properties;
+    return out2;
+  }
+  if (type === "array") {
+    const out2 = {
+      type: "array",
+      items: isRecord(field.items) ? toDshValueSchema(field.items) : { type: "string" }
+    };
+    if (description) out2.description = description;
+    return out2;
+  }
+  const out = { type };
+  if (description) out.description = description;
+  if (Array.isArray(field.enum)) out.enum = field.enum;
+  return out;
+}
+function toolParameters(toolDef) {
+  const schema = isRecord(toolDef.inputSchema) ? toolDef.inputSchema : {};
+  const props = isRecord(schema.properties) ? schema.properties : {};
+  const required = new Set(Array.isArray(schema.required) ? schema.required.map(String) : []);
+  const parameters = {};
+  for (const [key, raw] of Object.entries(props)) {
+    const field = isRecord(raw) ? raw : {};
+    const param = toDshValueSchema(field, key);
+    if (required.has(key)) param.required = true;
+    parameters[key] = param;
+  }
+  return parameters;
+}
+function registerTools(ctx, tools, defineTool) {
+  const disposers = [];
+  const toolsSvc = toolsOf(ctx);
+  if (!toolsSvc?.register) {
+    console.warn("[monkey-mini-app] ctx.tools missing; inject=['tools'] required for model-facing tools");
+    return disposers;
+  }
+  for (const toolDef of tools) {
+    const parameters = toolParameters(toolDef);
+    const execute = async (args, toolCtx) => {
+      return toolDef.execute ? await toolDef.execute(args ?? {}, toolCtx?.signal) : { ok: false, error: "no execute" };
+    };
+    const built = defineTool ? defineTool({
+      name: toolDef.name,
+      description: toolDef.description,
+      parameters,
+      output: {
+        schema: { type: "object", additionalProperties: true },
+        render: (_a, v) => [
+          { type: "text", text: typeof v === "string" ? v : JSON.stringify(v, null, 2) }
+        ]
+      },
+      execute
+    }) : {
+      name: toolDef.name,
+      description: toolDef.description,
+      parameters,
+      output: {
+        schema: { type: "object", additionalProperties: true },
+        render: (_a, v) => [
+          { type: "text", text: typeof v === "string" ? v : JSON.stringify(v, null, 2) }
+        ]
+      },
+      execute
+    };
+    try {
+      const ret = toolsSvc.register(built);
+      if (typeof ret === "function") disposers.push(ret);
+    } catch (e) {
+      console.warn(`[monkey-mini-app] tools.register failed for ${toolDef.name}:`, e);
+    }
+  }
+  return disposers;
+}
+function registerListCtxTools(ctx, defineTool = null) {
+  const toolsSvc = toolsOf(ctx);
+  if (!toolsSvc?.register) return null;
+  try {
+    const def = {
+      name: "mini_app_list_ctx_tools",
+      description: "List live dsh tools for ctx.tool(name, args) inside main.api.ts. Call ONLY when the app will use ctx.tool. Skip for storage/bash/llm-only apps.",
+      parameters: {},
+      output: {
+        schema: { type: "object", additionalProperties: true },
+        render: (_a, v) => [
+          { type: "text", text: typeof v === "string" ? v : JSON.stringify(v, null, 2) }
+        ]
+      },
+      async execute() {
+        const listed = snapshotDshTools(toolsOf(ctx));
+        return {
+          count: listed.length,
+          note: "These names are for ctx.tool(name, args) inside main.api.ts. Prefer storage/bash/llm when possible.",
+          tools: listed
+        };
+      }
+    };
+    const built = defineTool ? defineTool(def) : def;
+    const ret = toolsSvc.register(built);
+    return typeof ret === "function" ? ret : null;
+  } catch (e) {
+    console.warn("[monkey-mini-app] register mini_app_list_ctx_tools failed", e);
+    return null;
+  }
+}
+function installSkillDir(src, dest) {
+  mkdirSync(path3.dirname(dest), { recursive: true });
+  cpSync(src, dest, { recursive: true });
+}
+function defaultSkillDest() {
+  return path3.join(homedir2(), ".dsh", "skills", "monkey-mini-app");
+}
+var DshLifecycle = class {
+  constructor(ctx, options = {}) {
+    this.ctx = ctx;
+    this.options = options;
+  }
+  ctx;
+  options;
+  disposers = [];
+  async attach(_ctx, services) {
+    const defineTool = await loadDefineTool();
+    this.disposers.push(...registerTools(this.ctx, services.tools.definitions(), defineTool));
+    const extra = registerListCtxTools(this.ctx, defineTool);
+    if (extra) this.disposers.push(extra);
+    try {
+      installSkillDir(getSkillDir(), this.options.skillDest ?? defaultSkillDest());
+    } catch (e) {
+      console.warn("[monkey-mini-app] skill install skipped:", e);
+    }
+    if (typeof this.ctx.provide === "function") {
+      this.ctx.provide("monkeyMiniApp", {
+        tools: services.tools,
+        paths: services.paths,
+        config: services.config,
+        runtimeRoot: services.paths.root,
+        skillDir: getSkillDir(),
+        skillMarkdown: getSkillMarkdown()
+      });
+    }
+  }
+  async detach() {
+    const list = this.disposers.splice(0, this.disposers.length);
+    for (const d of list) {
+      try {
+        d();
+      } catch {
+      }
+    }
+  }
+  onHostPortChanged(_port) {
+  }
+  log(level, message, meta) {
+    const line = `[monkey-mini-app] ${message}`;
+    if (level === "error") console.error(line, meta ?? "");
+    else if (level === "warn") console.warn(line, meta ?? "");
+    else console.log(line, meta ?? "");
+  }
+};
+
+// src/theme-resource.ts
+import fs from "fs";
+import path4 from "path";
+import {
+  cssVars,
+  parseThemeCss,
+  runnerThemeCss,
+  themeLabelFromCss
+} from "@monkey-mini-app/panel/themes";
+function customThemesDir(runtimeRoot) {
+  return path4.join(path4.resolve(runtimeRoot, ".."), "themes");
+}
+function loadCustomPalettes(runtimeRoot) {
+  const dir = customThemesDir(runtimeRoot);
+  const out = [];
+  try {
+    if (!fs.existsSync(dir)) return out;
+    const names = fs.readdirSync(dir).filter((n) => /^theme-.+\.css$/.test(n));
+    for (const n of names) {
+      const id = n.replace(/^theme-/, "").replace(/\.css$/, "");
+      const css = fs.readFileSync(path4.join(dir, n), "utf8");
+      const tokens = parseThemeCss(css, id);
+      if (!tokens) continue;
+      out.push({
+        id,
+        label: themeLabelFromCss(css, id),
+        swatch: tokens.dark.primary,
+        tokens
+      });
+    }
+  } catch {
+  }
+  return out;
+}
+function customPaletteCss(runtimeRoot) {
+  return loadCustomPalettes(runtimeRoot).map(
+    (c) => `html[data-theme="light"][data-palette="${c.id}"]{${cssVars(c.tokens.light)}}html[data-theme="dark"][data-palette="${c.id}"]{${cssVars(c.tokens.dark)}}`
+  ).join("\n  ");
+}
+var DshThemeResource = class {
+  constructor(runtimeRoot) {
+    this.runtimeRoot = runtimeRoot;
+  }
+  runtimeRoot;
+  runnerCss() {
+    return runnerThemeCss() + customPaletteCss(this.runtimeRoot);
+  }
+  listCustomPalettes() {
+    return loadCustomPalettes(this.runtimeRoot).map((c) => ({
+      id: c.id,
+      label: c.label,
+      swatch: c.swatch,
+      custom: true,
+      tokens: c.tokens
+    }));
+  }
+};
+
+// src/index.ts
+var packageName = "@monkey-mini-app/dsh-mini-app";
+var name = "monkey-mini-app";
+var inject = ["tools"];
+async function apply(ctx, config = {}) {
+  const hostConfig = loadPluginHostConfig(config);
+  const themes = new DshThemeResource(hostConfig.runtimeRoot);
+  const host = createHost(new DshCapabilities(ctx), new DshLifecycle(ctx), {
+    config: hostConfig,
+    themes
+  });
+  let port;
+  try {
+    ({ port } = await host.apply(ctx));
+  } catch (cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    console.error(
+      `[monkey-mini-app] apps host failed to start on ${hostConfig.hostPort}: ${msg}
+  Free the port, or edit ${hostConfig.runtimeRoot}/host.json (hostPort) and restart.`
+    );
+    await host.stop().catch(() => {
+    });
+    return () => {
+    };
+  }
+  console.log(`[monkey-mini-app] apps host http://127.0.0.1:${port}`);
+  console.log(`[monkey-mini-app] loaded \xB7 runtimeRoot=${hostConfig.runtimeRoot} \xB7 skill=${getSkillDir()}`);
+  return () => {
+    void host.stop();
+  };
+}
+export {
+  DSH_LLM_FALLBACK,
+  DshCapabilities,
+  DshLifecycle,
+  DshThemeResource,
+  apply,
+  coerceSchemaJson,
+  collectLlmStream,
+  getSkeletonTemplateFiles,
+  getSkillDir,
+  getSkillMarkdown,
+  getTemplateFiles,
+  inject,
+  loadPluginHostConfig,
+  name,
+  packageName,
+  resolveLlmRoute,
+  resolveRuntimeRoot,
+  runDshAgentOneShot,
+  withJsonInstruction
+};