rainskills 0.1.44 → 0.1.46

package/bin/rainskills-tools.js

@@ -32,20 +32,7 @@ const SENSITIVE_RESPONSE_KEY_PATTERN = /(?:authorization|jwt|token|password|secr
 const SENSITIVE_ENV_NAME_PATTERN = /(?:^|_)(?:PASSWORD|PASSWD|PASS|SECRET|TOKEN|API_?KEY|PRIVATE_?KEY|CREDENTIALS?|AUTH(?:ORIZATION)?|COOKIE|CERT(?:IFICATE)?)(?:_|$)/i;
 const ENV_NAME_FIELDS = Object.freeze(["attr_name", "name", "note", "env_name"]);
 const ENV_VALUE_FIELDS = new Set(["attr_value", "value"]);
-const RISK_POLICY = Object.freeze({
-  version: "1",
-  readPrefixes: [
-    "rainbond_query_", "rainbond_get_", "rainbond_list_", "rainbond_check_",
-    "rainbond_describe_", "rainbond_validate_", "rainbond_verify_", "rainbond_search_",
-  ],
-  destructiveFragments: ["delete", "remove", "purge", "destroy"],
-});
-const MIXED_TOOL_OPERATION_POLICY = Object.freeze({
-  rainbond_manage_component_dependency: Object.freeze({
-    readOperations: Object.freeze(["summary"]),
-    destructiveOperations: Object.freeze(["delete"]),
-  }),
-});
+const { RISK_POLICY, classifyTool } = require("./tool-policy.js");
 const CALL_OPTION_DEFINITIONS = Object.freeze({
   "--confirm": Object.freeze({ property: "confirmation", pattern: OPERATION_ID_PATTERN }),
   "--skill-id": Object.freeze({ property: "skillId", pattern: SKILL_ID_PATTERN }),
@@ -79,20 +66,7 @@ const HANDOFF_SKILLS = new Set([
   "rainbond-template-installer",
 ]);
 
-const EXIT = Object.freeze({
-  USAGE: 2,
-  CONFIG: 3,
-  TRANSPORT: 4,
-  TOOL: 5,
-});
-
-class BridgeError extends Error {
-  constructor(message, exitCode, payload) {
-    super(message);
-    this.exitCode = exitCode;
-    this.payload = payload;
-  }
-}
+const { BridgeError, EXIT, inputValidation, errorResult } = require("./bridge-errors.js");
 
 function requireRuntimeModule(filename) {
   const candidates = [
@@ -308,6 +282,11 @@ function parseCommand(args) {
   if (command === "read" && remaining.length === 4 && remaining[1] && remaining[2] === "--input" && remaining[3] === "-") {
     return { command, toolName: remaining[1], input: remaining[3], ...context };
   }
+  if (command === "batch" || command === "recipe") {
+    if (!["rainbond-app-assistant", "rainbond-fullstack-bootstrap", "rainbond-fullstack-troubleshooter"].includes(skillId)) throw new BridgeError("batch is not allowed for this skill", EXIT.USAGE);
+    const parsed = parseCommand(["call", "rainskills_confirmed_batch", ...remaining.slice(1), "--skill-id", skillId]);
+    return { ...parsed, command };
+  }
   if (command === "call" && remaining.length >= 4 && remaining[1] && remaining[2] === "--input" && remaining[3] === "-") {
     const parsed = { command, toolName: remaining[1], input: remaining[3], ...context };
     for (let index = 4; index < remaining.length; index += 2) {
@@ -550,7 +529,8 @@ async function executeWithUsageTelemetry(command, config) {
       : command;
     const output = await execute(executionCommand, config);
     if (telemetry) {
-      const firstUse = telemetry.recordFirstUse("success");
+      const workflowFailed = ["batch", "recipe"].includes(command.command) && output.status !== "succeeded";
+      const firstUse = telemetry.recordFirstUse(workflowFailed ? "failed" : "success");
       const active = telemetry.recordActiveDaily();
       await Promise.allSettled([firstUse.delivery, active.delivery]);
     }
@@ -570,7 +550,7 @@ async function executeWithUsageTelemetry(command, config) {
 }
 
 function commandTracksBusinessUsage(command) {
-  return ["read", "call", "snapshot", "poll"].includes(command?.command);
+  return ["read", "call", "snapshot", "poll", "batch", "recipe"].includes(command?.command);
 }
 
 function loadSkillBinding(config, skillId, rootSkillId) {
@@ -622,23 +602,6 @@ function loadSkillBinding(config, skillId, rootSkillId) {
   };
 }
 
-function classifyTool(toolName, argumentsValue = {}) {
-  const normalized = String(toolName || "").toLowerCase();
-  const operation = typeof argumentsValue.operation === "string"
-    ? argumentsValue.operation.trim().toLowerCase()
-    : "";
-  const mixedPolicy = MIXED_TOOL_OPERATION_POLICY[normalized];
-  if (mixedPolicy) {
-    if (mixedPolicy.destructiveOperations.includes(operation)) return "destructive";
-    if (mixedPolicy.readOperations.includes(operation)) return "read";
-  }
-  if (RISK_POLICY.destructiveFragments.some((fragment) => normalized.includes(fragment))) {
-    return "destructive";
-  }
-  if (RISK_POLICY.readPrefixes.some((prefix) => normalized.startsWith(prefix))) return "read";
-  return "write";
-}
-
 function operationFile(config, operationId) {
   return path.join(operationsPath(config), `${operationId}.json`);
 }
@@ -728,6 +691,7 @@ function confirmOperation(
   if (!record || record.status !== "awaiting_confirmation" || record.tool_name !== toolName ||
     record.operation_class !== operationClass ||
     record.arguments_digest !== argumentsDigest(argumentsValue) ||
+    (record.expires_at && Date.now() >= Date.parse(record.expires_at)) ||
     record.skill_id !== skillBinding.skillId ||
     record.root_skill_id !== skillBinding.rootSkillId ||
     record.skill_package_version !== skillBinding.packageVersion ||
@@ -862,6 +826,7 @@ function sanitizeToolResult(value, pathParts = [], sensitiveArguments = []) {
   const safe = {};
   const sensitiveEnv = hasSensitiveEnvName(value);
   for (const [key, item] of Object.entries(value)) {
+    if (key === "request_body") continue;
     // Console destructive operations may return this one-time control value.
     // It is not a credential and must remain available for the confirmation flow.
     const isPackageUploadAuthMode = key === "authorization"
@@ -915,12 +880,15 @@ function safeJson(value, secrets = []) {
 function httpJsonRpcRequest(config, endpointPath, message, {
   timeoutMs = REQUEST_TIMEOUT_MS,
   maxResponseBytes = RESPONSE_MAX_BYTES,
+  signal,
 } = {}) {
   const endpoint = new URL(`${config.baseUrl.replace(/\/+$/, "")}${endpointPath}`);
   const payload = JSON.stringify(message);
   const client = endpoint.protocol === "https:" ? https : http;
 
   return new Promise((resolve, reject) => {
+    if (signal?.aborted) { reject(new BridgeError("request cancelled", EXIT.TRANSPORT)); return; }
+    let abortRequest;
     let settled = false;
     let responseRef;
     let wallTimer;
@@ -929,6 +897,7 @@ function httpJsonRpcRequest(config, endpointPath, message, {
       if (settled) return;
       settled = true;
       clearTimeout(wallTimer);
+      signal?.removeEventListener("abort", abortRequest);
       callback(value);
     };
     const fail = (error, abort = false) => {
@@ -990,6 +959,8 @@ function httpJsonRpcRequest(config, endpointPath, message, {
         ? error
         : new BridgeError("unable to reach Rainbond API", EXIT.TRANSPORT));
     });
+    abortRequest = () => fail(new BridgeError("request cancelled", EXIT.TRANSPORT), true);
+    signal?.addEventListener("abort", abortRequest, { once: true });
     wallTimer = setTimeout(() => {
       fail(new BridgeError("Rainbond API request timed out", EXIT.TRANSPORT), true);
     }, timeoutMs);
@@ -1073,7 +1044,7 @@ async function rpcRequest(config, method, params = {}, options = {}) {
     id: 1,
     method,
     params,
-  }, options);
+  }, { ...options, signal: options.signal || config.signal });
   if (isVerifiedMissingRpcRoute(response)) {
     throw new BridgeError(
       "当前 Rainbond 版本不支持 Rainskills CLI，请先将 Rainbond 升级到 v6.9.9 或更高版本",
@@ -1351,7 +1322,91 @@ async function resolveStatelessContext(input, config) {
   return workspaceSelectionResult(enterpriseId, matchingOptions);
 }
 
+async function executeConfirmedToolCall(command, config, toolName, argumentsValue, executeStep = execute) {
+  if (command.signal?.aborted) throw new BridgeError("workflow cancelled", EXIT.USAGE, undefined, "E_CANCELLED");
+  const child = { command: "call", toolName, argumentsValue, skillId: command.skillId, rootSkillId: command.rootSkillId, telemetryInstallationId: command.telemetryInstallationId, signal: command.signal };
+  const prepared = await executeStep(child, config);
+  if (command.signal?.aborted) throw new BridgeError("workflow cancelled", EXIT.USAGE, undefined, "E_CANCELLED");
+  if (!prepared.requires_confirmation || !prepared.confirmation_id) throw new BridgeError("workflow write did not return a confirmation", EXIT.CONFIG);
+  return executeStep({ ...child, confirmation: prepared.confirmation_id }, config);
+}
+
+async function executeConfirmedWorkflow(command, config) {
+  const { validateBatch, executeBatch, configurationSatisfied } = require("./confirmed-batch.js");
+  const { preflightRecipe, executeRecipe } = require("./component-recipe.js");
+  const input = command.argumentsValue;
+  const recipe = command.command === "recipe";
+  const tool = recipe ? "rainskills_component_recipe" : "rainskills_confirmed_batch";
+  const validate = (name, args) => validateToolArguments(config, name, args);
+  const read = (toolName, argumentsValue) => execute({ command: "read", toolName, argumentsValue, skillId: command.skillId, signal: command.signal }, config);
+  const skipKeys = [];
+  const snapshots = new Map();
+  const dirtyComponents = new Set();
+  let completedWrites = 0;
+  const currentConfiguration = async (step) => {
+    const { team_name, region_name, app_id, service_id } = step.arguments;
+    const key = `${step.tool}:${service_id}`;
+    if (!snapshots.has(key)) {
+      const args = { team_name, region_name, app_id, service_id, operation: "summary" };
+      try { await validate(step.tool, args); }
+      catch (error) { if (error.exitCode === EXIT.USAGE) return false; throw error; }
+      snapshots.set(key, await read(step.tool, args));
+    }
+    return configurationSatisfied(step.tool, step.arguments, snapshots.get(key));
+  };
+  let steps;
+  if (recipe) {
+    const plan = await preflightRecipe(input, { validate, read });
+    steps = [{ key: "create", tool: plan.tool }, ...plan.steps];
+  } else {
+    steps = validateBatch(input);
+    for (const step of steps) await validate(step.tool, step.arguments);
+    for (const step of steps) {
+      const satisfied = await currentConfiguration(step);
+      if (satisfied && !dirtyComponents.has(step.arguments.service_id)) skipKeys.push(step.key);
+      else {
+        dirtyComponents.add(step.arguments.service_id);
+        if (step.arguments.dep_service_id) dirtyComponents.add(step.arguments.dep_service_id);
+        for (const id of step.arguments.dep_service_ids || []) dirtyComponents.add(id);
+      }
+    }
+  }
+  const binding = loadSkillBinding(config, command.skillId, command.rootSkillId);
+  const protectedInput = { input, skipped: skipKeys, identity: argumentsDigest({ endpoint: config.baseUrl, identity: config.jwt }) };
+  let operation;
+  if (!command.confirmation) {
+    operation = prepareOperation(config, tool, "write", protectedInput, binding);
+    writeOperation(config, { ...operation, expires_at: new Date(Date.now() + 10 * 60_000).toISOString() });
+    return { requires_confirmation: true, confirmation_id: operation.operation_id, operation_class: "write", steps: steps.map(({ key, tool: name }) => ({ key, tool: name, status: skipKeys.includes(key) ? "skipped" : "planned" })), summary: "Confirm this exact workflow within the current authorized app scope." };
+  }
+  operation = confirmOperation(config, command.confirmation, tool, "write", protectedInput, binding);
+  try {
+    const adapters = {
+      validate, read, signal: command.signal,
+      isSatisfied: async (step) => {
+        const satisfied = await currentConfiguration(step);
+        if (skipKeys.includes(step.key) && !satisfied) throw new BridgeError("confirmed no-op state changed; prepare a new batch", EXIT.USAGE, undefined, "E_PLAN_STALE");
+        return satisfied;
+      },
+      call: (toolName, argumentsValue) => executeConfirmedToolCall(command, config, toolName, argumentsValue),
+      onCreated: async (identity) => { operation = { ...operation, created: identity }; writeOperation(config, operation); },
+      onProgress: async (output) => {
+        if (output.completed !== completedWrites) { snapshots.clear(); completedWrites = output.completed; }
+        operation = { ...operation, progress: output }; writeOperation(config, operation);
+      },
+    };
+    const output = await (recipe ? executeRecipe(input, adapters) : executeBatch(input, adapters));
+    writeOperation(config, { ...operation, status: output.status, progress: output });
+    return output;
+  } catch (error) {
+    updateOperation(config, operation, error.exitCode === EXIT.TRANSPORT ? "unknown" : "failed");
+    throw error;
+  }
+}
+
 async function execute(command, config) {
+  if (command.signal?.aborted) throw new BridgeError("workflow cancelled", EXIT.USAGE, undefined, "E_CANCELLED");
+  if (["batch", "recipe"].includes(command.command)) return executeConfirmedWorkflow(command, config);
   if (command.command === "context") {
     return resolveStatelessContext(command.argumentsValue, config);
   }
@@ -1359,7 +1414,8 @@ async function execute(command, config) {
     return executePackageUpload(command, config);
   }
   if (command.command === "snapshot") {
-    const { executeReadSnapshot } = require("./read-snapshot.js");
+    const { executeReadSnapshot, validateSnapshotInput } = require("./read-snapshot.js");
+    inputValidation(() => validateSnapshotInput(command.argumentsValue));
     return executeReadSnapshot(command.argumentsValue, {
       callTool: async (name, argumentsValue) => {
         const result = await rpcRequest(config, "tools/call", { name, arguments: argumentsValue });
@@ -1375,10 +1431,12 @@ async function execute(command, config) {
     });
   }
   if (command.command === "poll") {
-    const { executeProtectedPoll } = require("./protected-poll.js");
+    const { executeProtectedPoll, validatePollInput } = require("./protected-poll.js");
+    inputValidation(() => validatePollInput(command.toolName, command.argumentsValue));
     return executeProtectedPoll(command.toolName, command.argumentsValue, {
-      callTool: async (name, argumentsValue) => {
-        const result = await rpcRequest(config, "tools/call", { name, arguments: argumentsValue });
+      signal: command.signal,
+      callTool: async (name, argumentsValue, options) => {
+        const result = await rpcRequest(config, "tools/call", { name, arguments: argumentsValue }, options);
         if (!result || result.isError || !("structuredContent" in result)) {
           throw new BridgeError("poll read failed", EXIT.TOOL);
         }
@@ -1418,6 +1476,9 @@ async function execute(command, config) {
   }
 
   const argumentsValue = command.argumentsValue || readArguments(command.input);
+  if (command.toolName === "rainbond_wait_for_build_completion") {
+    if (argumentsValue.timeout !== undefined && (!Number.isInteger(argumentsValue.timeout) || argumentsValue.timeout < 1 || argumentsValue.timeout > 60)) throw new BridgeError("wait timeout must be between 1 and 60 seconds", EXIT.USAGE);
+  }
   const operationClass = classifyTool(command.toolName, argumentsValue);
   if (command.command === "read" && operationClass !== "read") {
     throw new BridgeError(
@@ -1472,7 +1533,7 @@ async function execute(command, config) {
         installation_id: command.telemetryInstallationId,
       };
     }
-    const result = await rpcRequest(config, "tools/call", params);
+    const result = await rpcRequest(config, "tools/call", params, command.toolName === "rainbond_wait_for_build_completion" ? { timeoutMs: (argumentsValue.timeout || 60) * 1000, signal: command.signal } : { signal: command.signal });
     if (!result || typeof result !== "object") {
       throw new BridgeError("Rainbond tool result is invalid", EXIT.TRANSPORT);
     }
@@ -1498,6 +1559,7 @@ async function execute(command, config) {
   } catch (error) {
     if (operation) {
       updateOperation(config, operation, error.exitCode === EXIT.TRANSPORT ? "unknown" : "failed");
+      if (error.exitCode === EXIT.TRANSPORT) error.code = "E_WRITE_RESULT_UNKNOWN";
     }
     throw error;
   }
@@ -1507,9 +1569,16 @@ async function main(args = process.argv.slice(2)) {
   let config;
   let command;
   let argumentRedactions = [];
+  const controller = new AbortController();
+  const cancel = () => controller.abort();
   try {
     command = parseCommand(args);
-    if (["read", "call", "package-upload", "query", "context", "delivery", "handoff", "snapshot", "poll"].includes(command.command)) {
+    command.signal = controller.signal;
+    if (["poll", "batch", "recipe"].includes(command.command)) {
+      process.once("SIGINT", cancel);
+      process.once("SIGTERM", cancel);
+    }
+    if (["read", "call", "package-upload", "query", "context", "delivery", "handoff", "snapshot", "poll", "batch", "recipe"].includes(command.command)) {
       const argumentsValue = readArguments(command.input);
       command.argumentsValue = argumentsValue;
       argumentRedactions = collectArgumentRedactions(argumentsValue);
@@ -1548,14 +1617,14 @@ async function main(args = process.argv.slice(2)) {
     }
     if (command.command === "handoff") {
       const { createHandoffContext, validateHandoffContext } = require("./handoff-context.js");
-      const output = command.action === "create"
+      const output = inputValidation(() => command.action === "create"
         ? createHandoffContext(command.argumentsValue)
         : validateHandoffContext(command.argumentsValue.context, {
           current: command.argumentsValue.current,
           signal: command.argumentsValue.signal,
           now: command.argumentsValue.now,
           maxAgeMs: command.argumentsValue.max_age_ms,
-        });
+        }));
       process.stdout.write(`${JSON.stringify(fitOutput(output))}\n`);
       return;
     }
@@ -1565,20 +1634,26 @@ async function main(args = process.argv.slice(2)) {
     if (config.isInsecureHttp) {
       process.stderr.write('{"warning":"using insecure HTTP transport"}\n');
     }
+    config.signal = command.signal;
     const output = await executeWithUsageTelemetry(command, config);
     process.stdout.write(`${JSON.stringify(fitOutput(output))}\n`);
   } catch (error) {
     const bridgeError = error instanceof BridgeError
       ? error
-      : new BridgeError("unexpected API bridge error", EXIT.TRANSPORT);
+      : new BridgeError(error.code === "MODULE_NOT_FOUND" ? "installed Rainskills CLI runtime is incomplete" : "unexpected internal CLI error", error.code === "MODULE_NOT_FOUND" ? EXIT.CONFIG : EXIT.TRANSPORT, undefined, error.code === "MODULE_NOT_FOUND" ? "E_RUNTIME_INCOMPLETE" : "E_INTERNAL");
     const secrets = [config && config.jwt, config && config.baseUrl, ...argumentRedactions];
-    const output = bridgeError.payload || { error: bridgeError.message };
+    const output = sanitizeToolResult(errorResult(bridgeError), [], argumentRedactions);
     process.stderr.write(`${safeJson(output, secrets)}\n`);
     process.exitCode = bridgeError.exitCode;
+  } finally {
+    process.removeListener("SIGINT", cancel);
+    process.removeListener("SIGTERM", cancel);
   }
 }
 
 module.exports = {
+  main,
+  executeConfirmedToolCall,
   REQUEST_TIMEOUT_MS,
   INPUT_MAX_BYTES,
   RESPONSE_MAX_BYTES,

package/bin/rainskills.js

@@ -278,6 +278,11 @@ async function runBuiltin(args, {
       throw new Error("runtime status 只支持固定参数 --json");
     }
     const packageVersion = require("../package.json").version;
+    const integrity = require("./runtime-integrity.js").checkRuntimeIntegrity();
+    if (integrity.status !== "ok") {
+      write(`${JSON.stringify({ schema: "rainskills.runtime-status.v1", state: "needs_reconnect", usable: false, package_version: packageVersion, integrity, repair_required: true })}\n`);
+      return true;
+    }
     if (runtimeStateManager) {
       write(`${JSON.stringify({
         ...(await runtimeStateManager.status()),

package/bin/read-snapshot.js

@@ -1,11 +1,7 @@
 "use strict";
 
 const SCOPES = new Set(["runtime", "app", "component", "delivery"]);
-const READ_PREFIXES = [
-  "rainbond_query_", "rainbond_get_", "rainbond_list_", "rainbond_check_",
-  "rainbond_describe_", "rainbond_validate_", "rainbond_verify_", "rainbond_search_",
-];
-const DESTRUCTIVE = /(?:delete|remove|purge|destroy|update|create|set|manage|operate|restart|deploy)/i;
+const { classifyTool } = require("./tool-policy.js");
 const SENSITIVE_KEY = /(?:authorization|jwt|token|password|secret|credential|private[_-]?key|cookie|certificate|ssl)/i;
 const LOG_OR_EVENT = /(?:log|event)/i;
 const BOUND_KEYS = new Set(["cursor", "since_seconds", "tail"]);
@@ -16,11 +12,6 @@ function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 
-function readOnlyTool(name) {
-  return typeof name === "string"
-    && READ_PREFIXES.some((prefix) => name.startsWith(prefix))
-    && !DESTRUCTIVE.test(name);
-}
 
 function validateSnapshotInput(input) {
   if (!isPlainObject(input) || !SCOPES.has(input.scope)) throw new Error("snapshot scope is invalid");
@@ -28,7 +19,7 @@ function validateSnapshotInput(input) {
     throw new Error("snapshot requires one to eight requests");
   }
   for (const entry of input.requests) {
-    if (!isPlainObject(entry) || !readOnlyTool(entry.name) || !isPlainObject(entry.arguments)) {
+    if (!isPlainObject(entry) || classifyTool(entry.name, entry.arguments) !== "read" || !isPlainObject(entry.arguments)) {
       throw new Error("snapshot accepts read-only tool requests with object arguments");
     }
     if (LOG_OR_EVENT.test(entry.name) && !Object.keys(entry.arguments).some((key) => BOUND_KEYS.has(key))) {
@@ -43,6 +34,7 @@ function redact(value) {
   if (!isPlainObject(value)) return value;
   const output = {};
   for (const [key, child] of Object.entries(value)) {
+    if (key === "request_body") continue;
     if (SENSITIVE_KEY.test(key)) continue;
     output[key] = redact(child);
   }

package/bin/runtime-integrity.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const MODULES = Object.freeze({
+  "rainskills-tools.js": "main",
+  "handoff-context.js": "createHandoffContext",
+  "read-snapshot.js": "executeReadSnapshot",
+  "protected-poll.js": "executeProtectedPoll",
+  "delivery-probe.js": "createDeliveryProbe",
+  "bridge-errors.js": "errorResult",
+  "confirmed-batch.js": "validateBatch",
+  "component-recipe.js": "prepareRecipe",
+  "tool-policy.js": "classifyTool",
+});
+function checkRuntimeIntegrity(directory = __dirname) {
+  const missing = [];
+  for (const [name, entrypoint] of Object.entries(MODULES)) {
+    try {
+      const target = path.join(directory, name);
+      const info = fs.lstatSync(target);
+      if (!info.isFile() || info.isSymbolicLink() || typeof require(target)[entrypoint] !== "function") missing.push(name);
+    } catch { missing.push(name); }
+  }
+  return { status: missing.length ? "failed" : "ok", missing };
+}
+module.exports = { checkRuntimeIntegrity };

package/bin/runtime-smoke.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+"use strict";
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const http = require("node:http");
+const { spawn } = require("node:child_process");
+const { checkRuntimeIntegrity } = require("./runtime-integrity.js");
+
+async function smokeInstalledRuntime(home) {
+  if (checkRuntimeIntegrity().status !== "ok") throw new Error("installed runtime integrity failed");
+  const probeHome = fs.mkdtempSync(path.join(os.tmpdir(), "rainskills-smoke-"));
+  const sockets = new Set();
+  const server = http.createServer((request, response) => {
+    let body = "";
+    request.on("data", (chunk) => { body += chunk; });
+    request.on("end", () => {
+      const message = JSON.parse(body);
+      const result = message.method === "tools/list"
+        ? { tools: [{ name: "rainbond_get_smoke_status", inputSchema: { type: "object" } }] }
+        : { structuredContent: { status: "Running" } };
+      response.writeHead(200, { "Content-Type": "application/json" });
+      response.end(JSON.stringify({ jsonrpc: "2.0", id: message.id, result }));
+    });
+  });
+  server.on("connection", (socket) => { sockets.add(socket); socket.on("close", () => sockets.delete(socket)); });
+  try {
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    require("../rainbond-platform-installer/scripts/single-runtime.js").createSingleRuntimeStore({ home: probeHome }).write({ kind: "private", consoleOrigin: `http://127.0.0.1:${server.address().port}`, token: "smoke.payload.signature", allowInsecureHttp: true });
+    const bridge = path.join(home, ".rainbond/bin/rainskills-tools.js");
+    const run = (args, input) => new Promise((resolve, reject) => {
+      const child = spawn(process.execPath, [bridge, ...args, "--input", "-", "--skill-id", "rainbond-app-assistant"], {
+        cwd: probeHome, env: { ...process.env, HOME: probeHome, USERPROFILE: probeHome, RAINSKILLS_TELEMETRY_DISABLED: "1", RAINSKILLS_CREDENTIAL_SOURCE: "", RAINBOND_URL: "", RAINBOND_JWT: "" }, stdio: ["pipe", "pipe", "pipe"],
+      });
+      let stdout = "";
+      const timer = setTimeout(() => child.kill("SIGKILL"), 5000);
+      child.stdout.on("data", (chunk) => { stdout += chunk; });
+      child.stderr.resume();
+      child.on("error", (error) => { clearTimeout(timer); reject(error); });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        if (code !== 0) return reject(new Error(`installed ${args[0]} smoke failed`));
+        try { resolve(JSON.parse(stdout)); } catch { reject(new Error("invalid installed smoke output")); }
+      });
+      child.stdin.end(JSON.stringify(input));
+    });
+    const context = await run(["handoff", "create"], { producer: "rainbond-app-assistant", profile: "cli", observed_at: new Date().toISOString(), enterprise_id: "smoke", team_id: "smoke", team_name: "smoke", region_name: "smoke", app_id: null, app_name: "smoke", endpoint: "https://example.invalid", runtime_revision: "smoke", snapshot_revision: null, source_kind: "image", runtime_state: "topology_missing", next_phase: "init", invalidation_reason: null });
+    const snapshot = await run(["snapshot", "app"], { scope: "app", requests: [{ name: "rainbond_get_smoke_status", arguments: {} }] });
+    const poll = await run(["poll", "rainbond_get_smoke_status"], { arguments: {}, status_path: "status", terminal_values: ["Running", "Failed"], failure_values: ["Failed"], max_attempts: 1, interval_ms: 0, timeout_ms: 1000 });
+    if (context.schema !== "rainskills.handoff-context.v1" || snapshot.evidence?.[0]?.available !== true || poll.completed !== true) throw new Error("installed runtime smoke contract failed");
+    return { status: "ok", checked: ["handoff", "snapshot", "poll"] };
+  } finally {
+    for (const socket of sockets) socket.destroy();
+    await new Promise((resolve) => server.close(resolve));
+    fs.rmSync(probeHome, { recursive: true, force: true });
+  }
+}
+module.exports = { smokeInstalledRuntime };
+if (require.main === module) {
+  const home = process.argv[2];
+  if (!home) { process.stderr.write("installed home is required\n"); process.exitCode = 2; }
+  else smokeInstalledRuntime(path.resolve(home)).then((result) => process.stdout.write(`${JSON.stringify(result)}\n`)).catch(() => { process.stderr.write("installed runtime smoke failed\n"); process.exitCode = 1; });
+}

package/bin/tool-policy.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const RISK_POLICY = Object.freeze({
+  version: "2",
+  readPrefixes: ["rainbond_query_", "rainbond_get_", "rainbond_list_", "rainbond_check_", "rainbond_describe_", "rainbond_validate_", "rainbond_verify_", "rainbond_search_"],
+  destructiveFragments: ["delete", "remove", "purge", "destroy"],
+});
+const SUMMARY_TOOLS = new Set(["ports", "dependency", "storage", "connection_envs", "envs"].map((name) => `rainbond_manage_component_${name}`));
+function classifyTool(toolName, argumentsValue = {}) {
+  const name = String(toolName || "").toLowerCase();
+  const operation = typeof argumentsValue.operation === "string" ? argumentsValue.operation.trim().toLowerCase() : "";
+  if (SUMMARY_TOOLS.has(name)) {
+    if (operation === "summary") return "read";
+    if (RISK_POLICY.destructiveFragments.some((part) => operation.includes(part))) return "destructive";
+    return "write";
+  }
+  if (RISK_POLICY.destructiveFragments.some((part) => name.includes(part))) return "destructive";
+  if (name === "rainbond_wait_for_build_completion" || RISK_POLICY.readPrefixes.some((prefix) => name.startsWith(prefix))) return "read";
+  return "write";
+}
+module.exports = { RISK_POLICY, classifyTool };

package/contracts/component-recipe.schema.yaml

@@ -0,0 +1,30 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: rainskills.component-recipe.v1.request
+title: Explicit component creation and configuration recipe
+type: object
+additionalProperties: false
+required: [schema, scope, enterprise_id, kind, create]
+properties:
+  schema: {const: rainskills.component-recipe.v1.request}
+  scope: {$ref: 'confirmed-batch.schema.yaml#/$defs/scope'}
+  enterprise_id: {type: string, minLength: 1}
+  kind: {enum: [image, source, package]}
+  create:
+    type: object
+    required: [service_cname]
+    description: Exact live create-tool arguments. is_deploy must be false; source URL/ref and package event remain unchanged. Existing names block creation.
+  configure:
+    type: array
+    maxItems: 32
+    description: Configuration batch steps without service_id. Only the create response may supply that ID.
+    items: {type: object, required: [key, tool, arguments]}
+  stateful: {type: boolean}
+  storage:
+    type: object
+    required: [volume_name, volume_type, volume_path]
+    description: Explicit create_volume parameters, applied before deployment. Scope, operation and service_id are supplied by the recipe.
+allOf:
+  - if:
+      properties: {stateful: {const: true}}
+      required: [stateful]
+    then: {required: [storage]}

package/contracts/confirmed-batch.schema.yaml

@@ -0,0 +1,42 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: rainskills.confirmed-batch.v1.request
+title: Confirmed configuration batch
+type: object
+additionalProperties: false
+required: [schema, scope, steps]
+properties:
+  schema: {const: rainskills.confirmed-batch.v1.request}
+  scope: {$ref: '#/$defs/scope'}
+  steps:
+    type: array
+    minItems: 1
+    maxItems: 32
+    items:
+      type: object
+      additionalProperties: false
+      required: [key, tool, arguments]
+      properties:
+        key: {type: string, minLength: 1, maxLength: 64, description: At most 64 UTF-8 bytes.}
+        tool:
+          enum: [rainbond_manage_component_envs, rainbond_manage_component_ports, rainbond_manage_component_connection_envs, rainbond_manage_component_dependency]
+        arguments:
+          type: object
+          description: Validated against the live tool schema and the exact configuration-operation allowlist. Scope overrides are rejected. No delete or arbitrary result bindings.
+$defs:
+  scope:
+    type: object
+    additionalProperties: false
+    required: [team_name, region_name, app_id]
+    properties:
+      team_name: {type: string, minLength: 1, maxLength: 128}
+      region_name: {type: string, minLength: 1, maxLength: 128}
+      app_id: {type: integer, minimum: 1}
+  result:
+    type: object
+    required: [schema, status, completed, steps, blocker]
+    properties:
+      schema: {const: rainskills.confirmed-batch.v1.result}
+      status: {enum: [succeeded, partial, failed, unknown]}
+      completed: {type: integer, minimum: 0}
+      steps: {type: array, maxItems: 32}
+      blocker: {type: [object, 'null']}

package/contracts/runtime/cli-base.md

@@ -1,10 +1,12 @@
 <!-- rainskills-runtime-gate:start -->
 # 单运行环境 CLI 门禁（生成文件）
 
-本机只允许连接一个 Rainbond 运行环境。当前 Skill 在本会话第一次调用 Rainbond 前，执行固定 launcher 的 `runtime status --json`。只有命令退出码为 0、`state=connected` 且 `usable=true` 时才继续。不得配置或直接调用客户端 MCP，不得枚举环境、读取凭据、创建业务 operation，或生成运行环境 ID、业务 operation ID 与 intent JSON。
+本机只允许连接一个 Rainbond 运行环境。当前 Skill 在本会话第一次调用 Rainbond 前，执行固定 launcher 的 `runtime status --json`。只有命令退出码为 0、`state=connected` 且 `usable=true` 时才继续。不得配置或直接调用客户端 MCP，不得枚举环境、读取凭据、创建自定义业务 operation，或生成运行环境 ID、业务 operation ID 与 intent JSON。固定 batch/recipe 请求和 CLI 返回的 confirmation_id 属于受保护调用协议，不是模型自建业务工作流。
 
 {{VERSION_GUARD}}
 
+如果 integrity.status=failed 或 repair_required=true，停止业务调用并修复相同版本的本地安装；不得将缺模块当作 API 参数错误排查或绕过兼容入口。
+
 没有可用运行环境时，严格按下方 overlay 的 `missing_runtime_mode` 进入对应的 Runtime Routing；不得扩大可选环境范围。连接和重新授权必须使用浏览器 Device Flow，不复用 Shell 中缓存的 JWT；Device Flow 不依赖 stdin TTY，必须保持进程附着直到完成。新凭据只有通过 live probe 后才可覆盖唯一运行环境。CLI 返回 401 时，只读调用可在 `runtime reconnect` 成功后重试一次；写调用不得自动重放，必须先查询平台真实状态。403 直接停止，不重新授权。
 
 授权命令是同步门禁。命令返回“进程仍在运行”或会话 ID 时，只等待或轮询同一个命令会话；在该会话结束前禁止任何后续业务步骤。浏览器页面显示成功不代表完成；只有原命令退出码为 0，并输出 `rainskills.runtime-connect-result.v1` 且 `state=connected`，才可继续。不得另起 `runtime status` 猜测完成。