opencode-agent-skill 14.2.0-beta.1 → 15.0.0

package/pi/extensions/ues-child-runtime.ts

@@ -6,10 +6,30 @@ import { getEvidenceSelected } from "../../lib/evidence-store.mjs";
 import { recordVerification } from "../../lib/verification-broker.mjs";
 import { runtimeWorkspaceFingerprint } from "../../lib/workspace-fingerprint.mjs";
 import { destructiveShellRisk } from "../../lib/safety.mjs";
+import { crossToolTempPathRisk, isLocalEnvPath, localEnvWriteRisk } from "../../lib/execution-contract.mjs";
 import {
   canonicalVerificationCommand,
   looksLikeVerificationCommand,
 } from "../../lib/verification-command.mjs";
+import {
+  applyAnchoredFileEdits,
+  diagnoseCode,
+  probeCodeIntelligence,
+  readAnchoredCode,
+  searchCodeIntelligence,
+} from "../../lib/code-intelligence/index.mjs";
+import { ingestDocument } from "../../lib/document-ingestion.mjs";
+import { compactContext, expandContext, searchContext } from "../../lib/reversible-context.mjs";
+import {
+  looksLikeLongRunningServiceCommand,
+  restartService,
+  serviceLogs,
+  serviceStatus,
+  startService,
+  stopAllServices,
+  stopService,
+  waitForService,
+} from "../../lib/service-manager.mjs";
 
 const toolExecutionState = new Map<string, {
   startedAt: number;
@@ -72,15 +92,67 @@ async function capturedText(event: any, fallback: string) {
 }
 
 export default function (pi: ExtensionAPI) {
+  // Internal-only extension: the package host may discover this file alongside
+  // ues.ts, but only specialist child Pi processes should register its tools.
+  // Parent launch paths set UES_CHILD_PROCESS=1 for both CLI and RPC workers.
+  if (process.env.UES_CHILD_PROCESS !== "1") return;
+
   const clearExecutionState = () => toolExecutionState.clear();
   pi.on("session_start", clearExecutionState);
-  pi.on("session_shutdown", clearExecutionState);
+  pi.on("session_shutdown", async (_event, ctx) => {
+    clearExecutionState();
+    await stopAllServices(ctx.cwd).catch(() => []);
+  });
 
   pi.on("tool_call", async (event, ctx) => {
     const toolName = String(event.toolName || "");
+    const input: any = event.input || {};
+    const localEnvAllowed = String(process.env.UES_CHILD_ALLOW_LOCAL_ENV_WRITE || "") === "1";
+    const writeTool = ["edit", "write", "write_file", "apply_patch", "ues_code_edit"].includes(toolName);
+    const fileTool = ["read", "edit", "write", "write_file", "apply_patch", "ues_code", "ues_code_edit"].includes(toolName);
+    const fileCandidate = String(input.file || input.path || input.filePath || input.target || "");
+    const tempPathRisk = crossToolTempPathRisk(fileCandidate);
+    if (fileTool && tempPathRisk.risky) {
+      toolExecutionState.delete(String(event.toolCallId || ""));
+      return {
+        block: true,
+        reason:
+          "UES portable temp-path guard blocked " + fileCandidate +
+          ". On Windows, /tmp and /var/tmp may resolve differently between Pi file tools and bash/MSYS. " +
+          "For transient transforms, keep creation/read in one shell pipeline; for cross-tool scratch use a repository-local ignored UES path such as .ues-cache/tmp after creating it.",
+      };
+    }
+    if (writeTool && isLocalEnvPath(fileCandidate) && !localEnvAllowed) {
+      toolExecutionState.delete(String(event.toolCallId || ""));
+      return {
+        block: true,
+        reason:
+          "UES local-env guard blocked a write to " + fileCandidate +
+          ". .env/.env.* are local runtime inputs; update an example/template or report NEEDS_USER_ENV unless the user explicitly authorized this local env mutation.",
+      };
+    }
+
     if (!["bash", "powershell"].includes(toolName)) return undefined;
 
-    const command = String((event.input as any)?.command || "");
+    const command = String(input.command || "");
+    const envRisk = localEnvWriteRisk(command);
+    if (envRisk.risky && !localEnvAllowed) {
+      toolExecutionState.delete(String(event.toolCallId || ""));
+      return {
+        block: true,
+        reason:
+          "UES local-env guard blocked a shell write to .env/.env.*. Use .env.example/sample/template or report NEEDS_USER_ENV unless explicitly authorized.",
+      };
+    }
+    if (looksLikeLongRunningServiceCommand(command)) {
+      toolExecutionState.delete(String(event.toolCallId || ""));
+      return {
+        block: true,
+        reason:
+          "UES detected a likely long-running foreground service command. " +
+          "Use the ues_service tool (start -> wait-ready/logs -> stop) instead of bash/powershell so the agent does not stall.",
+      };
+    }
     const risk = destructiveShellRisk(command);
     if (risk.risky) {
       toolExecutionState.delete(String(event.toolCallId || ""));
@@ -190,6 +262,232 @@ export default function (pi: ExtensionAPI) {
     };
   });
 
+  const AnchoredEdit = Type.Object({
+    anchor: Type.String({ minLength: 1 }),
+    endAnchor: Type.Optional(Type.String({ minLength: 1 })),
+    replacement: Type.String(),
+  });
+
+  pi.registerTool({
+    name: "ues_code",
+    label: "UES Code Intelligence",
+    description:
+      "Bounded code/document/context intelligence for weak models: semantic/AST search, hash-anchored reads, optional LSP diagnostics, optional MarkItDown ingestion, and reversible context recovery.",
+    parameters: Type.Object({
+      action: Type.Union([
+        Type.Literal("status"),
+        Type.Literal("search"),
+        Type.Literal("read"),
+        Type.Literal("diagnostics"),
+        Type.Literal("document"),
+        Type.Literal("context-expand"),
+        Type.Literal("context-search"),
+      ]),
+      file: Type.Optional(Type.String()),
+      query: Type.Optional(Type.String()),
+      structuralPattern: Type.Optional(Type.String()),
+      language: Type.Optional(Type.String()),
+      startLine: Type.Optional(Type.Number({ minimum: 1 })),
+      endLine: Type.Optional(Type.Number({ minimum: 1 })),
+      ref: Type.Optional(Type.String()),
+      maxBytes: Type.Optional(Type.Number({ minimum: 1, maximum: 128000 })),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        let result: any;
+        if (params.action === "status") {
+          result = probeCodeIntelligence(params.file || "");
+        } else if (params.action === "search") {
+          if (!params.query) throw new Error("ues_code search requires query");
+          result = await searchCodeIntelligence(ctx.cwd, params.query, {
+            structuralPattern: params.structuralPattern,
+            language: params.language,
+            file: params.file,
+            maxResults: 12,
+          });
+        } else if (params.action === "read") {
+          if (!params.file) throw new Error("ues_code read requires file");
+          const startLine = Math.max(1, Math.trunc(Number(params.startLine || 1)));
+          const endLine = Math.max(startLine, Math.min(startLine + 399, Math.trunc(Number(params.endLine || startLine + 199))));
+          result = await readAnchoredCode(ctx.cwd, params.file, { startLine, endLine });
+          return {
+            content: [{ type: "text", text: [
+              `file: ${result.file}; lines: ${result.startLine}-${result.endLine}/${result.lineCount}; sourceHash: ${result.sourceHash}`,
+              "",
+              result.text,
+            ].join("\n") }],
+            details: { action: params.action, file: result.file, sourceHash: result.sourceHash, startLine: result.startLine, endLine: result.endLine },
+          };
+        } else if (params.action === "diagnostics") {
+          if (!params.file) throw new Error("ues_code diagnostics requires file");
+          result = await diagnoseCode(ctx.cwd, params.file, { timeoutMs: 3000, maxDiagnostics: 40 });
+        } else if (params.action === "document") {
+          if (!params.file) throw new Error("ues_code document requires file");
+          const document = await ingestDocument(ctx.cwd, params.file, { maxBytes: Math.min(Number(params.maxBytes || 4 * 1024 * 1024), 4 * 1024 * 1024) });
+          const block = await compactContext(ctx.cwd, document.markdown, {
+            kind: "document-ingestion",
+            source: document.file,
+            summary: `Normalized document from ${document.provider}`,
+          });
+          result = {
+            provider: document.provider,
+            file: document.file,
+            bytes: document.bytes,
+            optionalDependency: document.optionalDependency,
+            contextRef: block.ref,
+            originalChars: block.originalChars,
+            summary: block.levels.T1,
+          };
+        } else if (params.action === "context-expand") {
+          if (!params.ref) throw new Error("ues_code context-expand requires ref");
+          const expanded = await expandContext(ctx.cwd, params.ref, { maxBytes: params.maxBytes || 16000 });
+          return {
+            content: [{ type: "text", text: expanded.content }],
+            details: { action: params.action, ref: expanded.ref, start: expanded.start, returnedBytes: expanded.returnedBytes, truncated: expanded.truncated },
+          };
+        } else if (params.action === "context-search") {
+          if (!params.ref || !params.query) throw new Error("ues_code context-search requires ref and query");
+          result = await searchContext(ctx.cwd, params.ref, params.query, { maxBytes: params.maxBytes || 512000, maxMatches: 12 });
+        } else {
+          throw new Error("unsupported ues_code action");
+        }
+        const encoded = JSON.stringify(result, null, 2);
+        return {
+          content: [{ type: "text", text: encoded.length <= 32000 ? encoded : encoded.slice(0, 32000) + "\n...[bounded by ues_code]" }],
+          details: { action: params.action, bounded: encoded.length > 32000 },
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+          details: { action: params.action },
+          isError: true,
+        };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "ues_code_edit",
+    label: "UES Anchored Edit",
+    description:
+      "Apply fail-closed hash-anchored edits. A stale or mismatched anchor is rejected; re-read with ues_code instead of fuzzy retrying.",
+    parameters: Type.Object({
+      file: Type.String({ minLength: 1 }),
+      edits: Type.Array(AnchoredEdit, { minItems: 1, maxItems: 50 }),
+      dryRun: Type.Optional(Type.Boolean()),
+      diagnostics: Type.Optional(Type.Boolean()),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const edited = await applyAnchoredFileEdits(ctx.cwd, params.file, params.edits, { dryRun: params.dryRun === true });
+        const diagnostics = params.diagnostics === true && params.dryRun !== true
+          ? await diagnoseCode(ctx.cwd, params.file, { timeoutMs: 3000, maxDiagnostics: 40 }).catch(() => null)
+          : null;
+        const result = {
+          file: edited.file,
+          applied: edited.applied,
+          dryRun: edited.dryRun,
+          sourceHash: edited.sourceHash,
+          outputHash: edited.outputHash,
+          diagnostics: diagnostics ? {
+            available: diagnostics.available,
+            provider: diagnostics.provider,
+            reason: diagnostics.reason,
+            count: diagnostics.diagnostics?.length || 0,
+            items: (diagnostics.diagnostics || []).slice(0, 40),
+          } : null,
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }], details: result };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+          details: { file: params.file },
+          isError: true,
+        };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "ues_service",
+    label: "UES Managed Service",
+    description:
+      "Manage long-running development servers/watchers without blocking the agent. Use start, wait-ready, status, logs, stop, or restart. For start/restart, command is the executable only (for example node or npm); put every argument in args. Services are bounded to the current workspace/runtime and are cleaned up on session shutdown.",
+    parameters: Type.Object({
+      action: Type.Union([
+        Type.Literal("start"),
+        Type.Literal("wait-ready"),
+        Type.Literal("status"),
+        Type.Literal("logs"),
+        Type.Literal("stop"),
+        Type.Literal("restart"),
+      ]),
+      name: Type.String({ minLength: 1, maxLength: 64 }),
+      command: Type.Optional(Type.String({ minLength: 1 })),
+      args: Type.Optional(Type.Array(Type.String(), { maxItems: 128 })),
+      cwd: Type.Optional(Type.String()),
+      readyPort: Type.Optional(Type.Number({ minimum: 1, maximum: 65535 })),
+      readyHost: Type.Optional(Type.String({ maxLength: 255 })),
+      readyLog: Type.Optional(Type.String({ maxLength: 512 })),
+      timeoutMs: Type.Optional(Type.Number({ minimum: 100, maximum: 600000 })),
+      lifetimeMs: Type.Optional(Type.Number({ minimum: 10000, maximum: 7200000 })),
+      idleTimeoutMs: Type.Optional(Type.Number({ minimum: 5000, maximum: 3600000 })),
+      maxChars: Type.Optional(Type.Number({ minimum: 256, maximum: 128000 })),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        let result: any;
+        if (params.action === "start") {
+          if (!params.command) throw new Error("ues_service start requires command");
+          const riskText = [params.command, ...(params.args || [])].join(" ");
+          const risk = destructiveShellRisk(riskText);
+          if (risk.risky) throw new Error(`UES service safety blocked ${risk.id || "destructive"} command`);
+          result = await startService(ctx.cwd, {
+            name: params.name,
+            command: params.command,
+            args: params.args || [],
+            cwd: params.cwd,
+            readyPort: params.readyPort,
+            readyHost: params.readyHost,
+            readyLog: params.readyLog,
+            timeoutMs: params.timeoutMs,
+            lifetimeMs: params.lifetimeMs,
+            idleTimeoutMs: params.idleTimeoutMs,
+          });
+        } else if (params.action === "wait-ready") {
+          result = await waitForService(ctx.cwd, params.name, { timeoutMs: params.timeoutMs });
+        } else if (params.action === "status") {
+          result = await serviceStatus(ctx.cwd, params.name);
+        } else if (params.action === "logs") {
+          result = await serviceLogs(ctx.cwd, params.name, { maxChars: params.maxChars, evidence: true });
+        } else if (params.action === "stop") {
+          result = await stopService(ctx.cwd, params.name, { timeoutMs: params.timeoutMs });
+        } else if (params.action === "restart") {
+          result = await restartService(ctx.cwd, params.name, {
+            timeoutMs: params.timeoutMs,
+            lifetimeMs: params.lifetimeMs,
+            idleTimeoutMs: params.idleTimeoutMs,
+          });
+        } else {
+          throw new Error("Unknown ues_service action");
+        }
+        const failed =
+          (params.action === "start" || params.action === "wait-ready") && result?.ready !== true;
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          details: result,
+          isError: failed,
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+          details: { action: params.action, name: params.name },
+          isError: true,
+        };
+      }
+    },
+  });
+
   pi.registerTool({
     name: "ues_evidence_get",
     label: "UES Evidence Get",