rainskills 0.1.14 → 0.1.16

package/README.md

@@ -228,7 +228,7 @@ node ~/.rainbond/lib/rainskills/bin/rainskills.js platform install --onboarding-
 
 Rainskills 会在用户下一次发起业务动作时，由本地运行时立即返回环境查询结果，并另行启动后台任务静默检查更新。更新只跟随 npm `latest` 指向的正式版。当前版本是 RC 或其他预发布版本时不会查询、不会自动升级；npm 上的新 RC 版本也不参与正式版自动升级。
 
-发现更高的正式版后，后台任务只委托到经过校验的精确版本，例如 `rainskills@0.1.14`，不会执行浮动的 `@latest` 业务代码。新版本原子刷新已经安装的 Rainskills Skills；当前业务继续使用启动时已经加载的版本，最迟从下一条新任务开始使用新版。npm 超时、版本检查失败、安装位置不安全或文件迁移失败时会保留旧版本，且不会阻塞或改变当前操作。
+发现更高的正式版后，后台任务只委托到经过校验的精确版本，例如 `rainskills@0.1.16`，不会执行浮动的 `@latest` 业务代码。新版本原子刷新已经安装的 Rainskills Skills；当前业务继续使用启动时已经加载的版本，最迟从下一条新任务开始使用新版。npm 超时、版本检查失败、安装位置不安全或文件迁移失败时会保留旧版本，且不会阻塞或改变当前操作。
 
 升级只更新 Rainskills 自身，不触发 Rainbond 安装、运行环境选择、登录授权或重新对接，也不会新增 Agent MCP 配置。更新内容仅包括 Skills 和本地 CLI。原始业务操作会继续执行；只有该业务操作本身需要运行环境时，才按既有门禁检查当前连接。可用连接直接复用，401 只重新授权一次，403 立即停止，从未连接过运行环境时才进入环境选择。
 

package/SKILL.md

@@ -42,7 +42,9 @@ Rainskills 安装完成，下一条消息即可直接使用。
 
 受限沙箱（包括 Codex）执行本地状态命令时，必须申请用户级受保护目录访问权限；在 Codex 中使用 `require_escalated`。不得修改 `~/.rainbond` 权限、复制受保护状态到工作区，或因沙箱权限错误建议重装。
 
-环境是全局列表，不是项目绑定。本地状态命令必须定位已安装的同级 `rainbond-platform-installer/scripts/local-runtime.js`，解析为绝对路径后通过 `node` 以 argv 数组执行；不得为了查询本地环境访问 npm。只有连接或安装环境时才使用与当前技能包一致的固定 launcher `node <home>/.rainbond/lib/rainskills/bin/rainskills.js`（运行包版本 `rainskills@0.1.14`）。
+涉及浏览器或设备授权的 `runtime connect`，以及恢复/安装场景中的 `rainskills <target> --self-hosted`，必须在附加交互终端（TTY）中运行；在 Codex 中设置 `tty: true` 并保持进程附着直到授权完成。禁止通过非交互命令要求用户粘贴 JWT；非交互模式只可复用已存在的受保护凭据。
+
+环境是全局列表，不是项目绑定。本地状态命令必须定位已安装的同级 `rainbond-platform-installer/scripts/local-runtime.js`，解析为绝对路径后通过 `node` 以 argv 数组执行；不得为了查询本地环境访问 npm。只有连接或安装环境时才使用与当前技能包一致的固定 launcher `node <home>/.rainbond/lib/rainskills/bin/rainskills.js`（运行包版本 `rainskills@0.1.16`）。
 
 - 列表：用本地 launcher 执行 `environment list --json`，只展示名称、类型、状态、是否默认和最近验证时间。
 - 重命名：用本地 launcher 执行 `environment rename --environment-id <uuid> --name <name>`。

package/bin/rainskills-tools.js

@@ -54,6 +54,12 @@ const PLATFORM_QUERY_TO_RESOURCE = Object.freeze({
   rainbond_get_team_apps: "team-apps",
   rainbond_query_components: "components",
 });
+const ENTERPRISE_SCOPED_PLATFORM_QUERY_TOOLS = new Set([
+  "rainbond_query_teams",
+  "rainbond_query_regions",
+  "rainbond_query_apps",
+  "rainbond_query_components",
+]);
 
 const EXIT = Object.freeze({
   USAGE: 2,
@@ -195,6 +201,7 @@ function loadOperationConfig({ homeDir, operationId, includeRuntime }) {
     environmentId: environment.id,
     intent: operation.intent,
     requiredSkillId,
+    operationStore,
     ...(includeRuntime ? {
       homeDir,
       allowInsecureHttp: parsed.protocol === "http:",
@@ -325,20 +332,51 @@ function parseCommand(args) {
     throw new BridgeError("every tools command requires --operation-id <uuid>", EXIT.USAGE);
   }
   const operationId = args[operationIndex + 1];
-  const remaining = [
+  const operationArgs = [
     ...args.slice(0, operationIndex),
     ...args.slice(operationIndex + 2),
   ];
+  const skillIndex = operationArgs.indexOf("--skill-id");
+  if (
+    skillIndex < 0
+    || !SKILL_ID_PATTERN.test(operationArgs[skillIndex + 1] || "")
+    || operationArgs.indexOf("--skill-id", skillIndex + 1) !== -1
+  ) {
+    throw new BridgeError(
+      "every tools command requires --skill-id <active-skill-id>",
+      EXIT.USAGE
+    );
+  }
+  const skillId = operationArgs[skillIndex + 1];
+  const remaining = [
+    ...operationArgs.slice(0, skillIndex),
+    ...operationArgs.slice(skillIndex + 2),
+  ];
   const command = remaining[0];
-  if (command === "status" && remaining.length === 1) return { command, operationId };
+  const context = { operationId, skillId };
+  if (
+    command === "context"
+    && ["resolve", "select"].includes(remaining[1])
+    && remaining.length === 4
+    && remaining[2] === "--input"
+    && remaining[3] === "-"
+  ) {
+    return {
+      command,
+      action: remaining[1],
+      input: remaining[3],
+      ...context,
+    };
+  }
+  if (command === "status" && remaining.length === 1) return { command, ...context };
   if (command === "list") {
-    if (remaining.length === 1) return { command, operationId };
+    if (remaining.length === 1) return { command, ...context };
     if (remaining.length === 3 && remaining[1] === "--prefix" && remaining[2]) {
-      return { command, prefix: remaining[2], operationId };
+      return { command, prefix: remaining[2], ...context };
     }
   }
   if (command === "describe" && remaining.length === 2 && remaining[1]) {
-    return { command, toolName: remaining[1], operationId };
+    return { command, toolName: remaining[1], ...context };
   }
   if (
     command === "package-upload"
@@ -349,13 +387,13 @@ function parseCommand(args) {
     && remaining[3] === "--input"
     && remaining[4] === "-"
   ) {
-    return { command, archive: remaining[2], input: remaining[4], operationId };
+    return { command, archive: remaining[2], input: remaining[4], ...context };
   }
   if (command === "read" && remaining.length === 4 && remaining[1] && remaining[2] === "--input" && remaining[3] === "-") {
-    return { command, toolName: remaining[1], input: remaining[3], operationId };
+    return { command, toolName: remaining[1], input: remaining[3], ...context };
   }
   if (command === "call" && remaining.length >= 4 && remaining[1] && remaining[2] === "--input" && remaining[3] === "-") {
-    const parsed = { command, toolName: remaining[1], input: remaining[3], operationId };
+    const parsed = { command, toolName: remaining[1], input: remaining[3], ...context };
     for (let index = 4; index < remaining.length; index += 2) {
       const option = remaining[index];
       const value = remaining[index + 1];
@@ -403,6 +441,27 @@ function platformQueryIntent(toolName, argumentsValue) {
   }
 }
 
+async function resolvePlatformQueryArguments(toolName, argumentsValue, config) {
+  if (
+    !ENTERPRISE_SCOPED_PLATFORM_QUERY_TOOLS.has(toolName)
+    || (typeof argumentsValue.enterprise_id === "string" && argumentsValue.enterprise_id)
+  ) {
+    return argumentsValue;
+  }
+  const identity = await execute({
+    command: "read",
+    toolName: "rainbond_get_current_user",
+    argumentsValue: {},
+  }, config);
+  if (!identity || typeof identity.enterprise_id !== "string" || !identity.enterprise_id) {
+    throw new BridgeError(
+      "current Rainbond identity does not include an enterprise",
+      EXIT.TOOL
+    );
+  }
+  return { ...argumentsValue, enterprise_id: identity.enterprise_id };
+}
+
 function readArguments(input) {
   if (input !== "-") {
     throw new BridgeError("read and call accept JSON only through --input - (stdin)", EXIT.USAGE);
@@ -1024,7 +1083,128 @@ async function listTools(config) {
   return result.tools;
 }
 
+function schemaTypeMatches(value, type) {
+  if (type === "null") return value === null;
+  if (type === "array") return Array.isArray(value);
+  if (type === "object") return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+  if (type === "integer") return Number.isInteger(value);
+  if (type === "number") return typeof value === "number" && Number.isFinite(value);
+  return typeof value === type;
+}
+
+function validateSchemaValue(value, schema, fieldPath) {
+  if (!schema || typeof schema !== "object") return null;
+  if (Array.isArray(schema.oneOf)) {
+    const matches = schema.oneOf.filter((candidate) => !validateSchemaValue(value, candidate, fieldPath));
+    return matches.length === 1 ? null : `field ${fieldPath} must match exactly one allowed schema`;
+  }
+  if (Array.isArray(schema.anyOf)) {
+    const matches = schema.anyOf.some((candidate) => !validateSchemaValue(value, candidate, fieldPath));
+    return matches ? null : `field ${fieldPath} does not match an allowed schema`;
+  }
+  if (Array.isArray(schema.enum) && !schema.enum.some((candidate) => candidate === value)) {
+    return `field ${fieldPath} has an unsupported value`;
+  }
+  if (schema.type) {
+    const allowedTypes = Array.isArray(schema.type) ? schema.type : [schema.type];
+    if (!allowedTypes.some((type) => schemaTypeMatches(value, type))) {
+      return `field ${fieldPath} must be ${allowedTypes.join(" or ")}`;
+    }
+  }
+  if (typeof value === "string") {
+    if (Number.isInteger(schema.minLength) && value.length < schema.minLength) {
+      return `field ${fieldPath} is shorter than the allowed minimum`;
+    }
+    if (Number.isInteger(schema.maxLength) && value.length > schema.maxLength) {
+      return `field ${fieldPath} exceeds the allowed maximum`;
+    }
+    if (typeof schema.pattern === "string") {
+      try {
+        if (!new RegExp(schema.pattern).test(value)) return `field ${fieldPath} has an invalid format`;
+      } catch (_error) {
+        throw new BridgeError("Rainbond tool schema contains an invalid pattern", EXIT.TRANSPORT);
+      }
+    }
+  }
+  if (typeof value === "number") {
+    if (typeof schema.minimum === "number" && value < schema.minimum) {
+      return `field ${fieldPath} is below the allowed minimum`;
+    }
+    if (typeof schema.maximum === "number" && value > schema.maximum) {
+      return `field ${fieldPath} exceeds the allowed maximum`;
+    }
+  }
+  if (Array.isArray(value)) {
+    if (Number.isInteger(schema.minItems) && value.length < schema.minItems) {
+      return `field ${fieldPath} has too few items`;
+    }
+    if (Number.isInteger(schema.maxItems) && value.length > schema.maxItems) {
+      return `field ${fieldPath} has too many items`;
+    }
+    if (schema.items) {
+      for (let index = 0; index < value.length; index += 1) {
+        const error = validateSchemaValue(value[index], schema.items, `${fieldPath}[${index}]`);
+        if (error) return error;
+      }
+    }
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    for (const field of required) {
+      if (!Object.prototype.hasOwnProperty.call(value, field)) return `missing required field: ${field}`;
+    }
+    const properties = schema.properties && typeof schema.properties === "object"
+      ? schema.properties
+      : {};
+    for (const [field, item] of Object.entries(value)) {
+      if (Object.prototype.hasOwnProperty.call(properties, field)) {
+        const error = validateSchemaValue(item, properties[field], `${fieldPath}.${field}`);
+        if (error) return error;
+      } else if (schema.additionalProperties === false) {
+        return `unsupported field: ${field}`;
+      } else if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+        const error = validateSchemaValue(item, schema.additionalProperties, `${fieldPath}.${field}`);
+        if (error) return error;
+      }
+    }
+  }
+  return null;
+}
+
+async function validateToolArguments(config, toolName, argumentsValue) {
+  const tools = await listTools(config);
+  const tool = tools.find((candidate) => candidate && candidate.name === toolName);
+  if (!tool) throw new BridgeError("Rainbond tool was not found", EXIT.TOOL);
+  if (!tool.inputSchema || typeof tool.inputSchema !== "object") {
+    throw new BridgeError("Rainbond tool schema is invalid", EXIT.TRANSPORT);
+  }
+  const validationError = validateSchemaValue(argumentsValue, tool.inputSchema, "$input");
+  if (validationError) throw new BridgeError(validationError, EXIT.USAGE);
+}
+
 async function execute(command, config) {
+  if (command.command === "context") {
+    const { createRuntimeContextResolver } = requireRuntimeModule("runtime-context-resolver.js");
+    const resolver = createRuntimeContextResolver({
+      operationStore: config.operationStore,
+      queryTool: async (toolName, argumentsValue) => execute({
+        command: "read",
+        toolName,
+        argumentsValue,
+      }, config),
+    });
+    if (command.action === "resolve") {
+      return resolver.resolve({
+        operationId: config.operationId,
+        required: command.argumentsValue.required,
+      });
+    }
+    return resolver.select({
+      operationId: config.operationId,
+      selectionId: command.argumentsValue.selection_id,
+      optionId: command.argumentsValue.option_id,
+    });
+  }
   if (command.command === "package-upload") {
     return executePackageUpload(command, config);
   }
@@ -1073,6 +1253,7 @@ async function execute(command, config) {
     }
     skillBinding = loadSkillBinding(config, command.skillId, command.rootSkillId);
     if (!command.confirmation) {
+      await validateToolArguments(config, command.toolName, argumentsValue);
       operation = prepareOperation(
         config,
         command.toolName,
@@ -1140,14 +1321,19 @@ async function main(args = process.argv.slice(2)) {
   let argumentRedactions = [];
   try {
     command = parseCommand(args);
-    if (["read", "call", "package-upload", "query"].includes(command.command)) {
+    if (["read", "call", "package-upload", "query", "context"].includes(command.command)) {
       const argumentsValue = readArguments(command.input);
       command.argumentsValue = argumentsValue;
       argumentRedactions = collectArgumentRedactions(argumentsValue);
     }
     if (command.command === "query") {
-      platformQueryIntent(command.toolName, command.argumentsValue);
       config = loadEnvironmentConfig({ environmentId: command.environmentId });
+      command.argumentsValue = await resolvePlatformQueryArguments(
+        command.toolName,
+        command.argumentsValue,
+        config
+      );
+      platformQueryIntent(command.toolName, command.argumentsValue);
       command = {
         command: "read",
         toolName: command.toolName,
@@ -1164,6 +1350,12 @@ async function main(args = process.argv.slice(2)) {
       includeRuntime: true,
       operationId: command.operationId,
     });
+    if (command.skillId !== config.requiredSkillId) {
+      throw new BridgeError(
+        "Skill does not match the protected runtime operation intent",
+        EXIT.CONFIG
+      );
+    }
     if (config.isInsecureHttp) {
       process.stderr.write('{"warning":"using insecure HTTP transport"}\n');
     }
@@ -1195,6 +1387,8 @@ module.exports = {
   platformQueryIntent,
   loadEnvironmentConfig,
   rpcRequest,
+  validateSchemaValue,
+  validateToolArguments,
   validatePackageUploadRequest,
 };
 

package/bin/rainskills.js

@@ -412,15 +412,44 @@ async function runBuiltin(args, {
   const getOperationStore = () => operationStore || getEnvironmentServices().operationStore;
   const getEnvironmentCredentialStore = () => environmentCredentialStore
     || getEnvironmentServices().environmentCredentialStore;
-  const getRuntimeStateManager = (operationId, { scoped = false } = {}) => {
+  const getRuntimeStateManager = (operationId, {
+    scoped = false,
+    protectedOperation = null,
+  } = {}) => {
     if (runtimeStateManager) return runtimeStateManager;
     const operationScoped = scoped || (
       credentialEnvironment.RAINSKILLS_RUNTIME_STATE_SCOPE === "operation"
       && credentialEnvironment.RAINSKILLS_RUNTIME_OPERATION_ID === operationId
     );
+    const managerOptions = operationScoped ? { operationId } : {};
+    if (protectedOperation?.environment_id) {
+      const environment = getEnvironmentRegistry().get(protectedOperation.environment_id);
+      if (!environment || environment.connection_state !== "connected") {
+        throw new Error("runtime operation 绑定的运行环境当前不可用");
+      }
+      const credentialStore = getEnvironmentCredentialStore();
+      const credential = credentialStore.read({
+        environmentId: environment.id,
+        expectedOrigin: environment.console_origin,
+      });
+      managerOptions.env = {
+        RAINBOND_JWT: credential.token,
+        RAINBOND_URL: credential.origin,
+      };
+      managerOptions.credentialWriter = ({ token, baseUrl }) => {
+        if (baseUrl !== environment.console_origin) {
+          throw new Error("runtime renewed credential origin 不匹配");
+        }
+        credentialStore.write({
+          environmentId: environment.id,
+          origin: baseUrl,
+          token,
+        });
+      };
+    }
     return require(
       "../rainbond-platform-installer/scripts/runtime-state.js"
-    ).createRuntimeStateManager(operationScoped ? { operationId } : {});
+    ).createRuntimeStateManager(managerOptions);
   };
 
   if (args[0] === "environment" && args[1] === "list") {
@@ -908,8 +937,15 @@ async function runBuiltin(args, {
     const protectedOperation = runtimeStateManager ? null : getOperationStore().read(args[3]);
     const manager = getRuntimeStateManager(args[3], {
       scoped: protectedOperation?.intent?.type === "environment-add",
+      protectedOperation,
     });
-    manager.assertContinuationEligible(args[3]);
+    const eligible = manager.assertContinuationEligible(args[3]);
+    if (protectedOperation?.environment_id) {
+      const environment = getEnvironmentRegistry().get(protectedOperation.environment_id);
+      if (!environment || eligible.console_origin !== environment.console_origin) {
+        throw new Error("runtime operation 与已锁定运行环境不匹配");
+      }
+    }
     const status = await manager.status();
     if (status.state !== "connected" || status.usable !== true) {
       throw new Error("runtime 尚未 connected 且通过 live probe，不能恢复 intent");

package/install.sh

@@ -2652,6 +2652,11 @@ main() {
   done < <(find "$SCRIPT_DIR" -maxdepth 1 -mindepth 1 -type d -name 'rainbond-*' | sort)
   [[ "${#skills[@]}" -gt 0 ]] || die "在 $SCRIPT_DIR 下没有找到 rainbond-* skill 目录。"
 
+  local root_skill_dir="$SCRIPT_DIR/marketplace/rainskills/skills/rainskills"
+  if [[ -d "$root_skill_dir" ]]; then
+    skills+=("$root_skill_dir")
+  fi
+
   for skill_dir in "${skills[@]}"; do
     validate_skill_dir "$skill_dir"
   done

package/marketplace/rainskills/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "rainskills",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Install the complete Rainskills AI deployment skill suite as one product.",
   "author": {
     "name": "Goodrain",

package/marketplace/rainskills/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "rainskills",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Install the complete Rainskills AI deployment skill suite as one product.",
   "author": {
     "name": "Goodrain",

package/marketplace/rainskills/skills/rainskills/SKILL.md

@@ -14,7 +14,7 @@ This is the single marketplace entry for the complete Rainskills product. The in
 3. Keep stdin, stdout, and stderr attached. When `RAINSKILLS_USER_INPUT_REQUIRED` appears, pause for that installer choice. If the installer emits `rainskills.next-action.v1`, execute only its fixed `argv` through the same launcher; never evaluate output as a shell command. If the adjacent `bin/rainskills.js` exists, use it for fixed next actions; otherwise use the same versioned npm package fallback described below.
 4. Stay attached until every independent Skill is installed. Do not select, connect, or configure an application runtime during installation. In the user-facing response, output only the fixed completion message below.
 
-If the adjacent installer is missing, check the local Node.js version before choosing the fallback. With `npx` and Node.js 18 or newer, use `npx --yes rainskills@0.1.14 <target>`. With no Node.js or a version below 18, use `bash <(curl -fsSL https://get.rainbond.com/rainskills/install.sh) <target>` instead. Omit `<target>` only when the host cannot be determined reliably. Keep either command attached to the interactive terminal. For an update or repair, refresh this marketplace Skill first, then run the installer again; it compares and updates every independent internal Skill.
+If the adjacent installer is missing, check the local Node.js version before choosing the fallback. With `npx` and Node.js 18 or newer, use `npx --yes rainskills@0.1.16 <target>`. With no Node.js or a version below 18, use `bash <(curl -fsSL https://get.rainbond.com/rainskills/install.sh) <target>` instead. Omit `<target>` only when the host cannot be determined reliably. Keep either command attached to the interactive terminal. For an update or repair, refresh this marketplace Skill first, then run the installer again; it compares and updates every independent internal Skill.
 
 Skills-only 安装不需要 Node.js；CDN fallback 只负责安装 Skill 文件，不代表运行环境连接、应用部署或平台安装已经可执行。用户首次提出需要运行环境的动作时，对应业务 Skill 才检查 Node.js；固定 Rainskills launcher 需要 Node.js 18 或更高版本。缺失或版本过低时保留原始 intent 并停止，等待用户或 agent 明确同意安装或升级 Node.js，安装完成消息不得提前提示 Node.js。
 
@@ -42,7 +42,9 @@ Rainskills 安装完成，下一条消息即可直接使用。
 
 受限沙箱（包括 Codex）执行本地状态命令时，必须申请用户级受保护目录访问权限；在 Codex 中使用 `require_escalated`。不得修改 `~/.rainbond` 权限、复制受保护状态到工作区，或因沙箱权限错误建议重装。
 
-环境是全局列表，不是项目绑定。本地状态命令必须定位已安装的同级 `rainbond-platform-installer/scripts/local-runtime.js`，解析为绝对路径后通过 `node` 以 argv 数组执行；不得为了查询本地环境访问 npm。只有连接或安装环境时才使用与当前技能包一致的固定 launcher `node <home>/.rainbond/lib/rainskills/bin/rainskills.js`（运行包版本 `rainskills@0.1.14`）。
+涉及浏览器或设备授权的 `runtime connect`，以及恢复/安装场景中的 `rainskills <target> --self-hosted`，必须在附加交互终端（TTY）中运行；在 Codex 中设置 `tty: true` 并保持进程附着直到授权完成。禁止通过非交互命令要求用户粘贴 JWT；非交互模式只可复用已存在的受保护凭据。
+
+环境是全局列表，不是项目绑定。本地状态命令必须定位已安装的同级 `rainbond-platform-installer/scripts/local-runtime.js`，解析为绝对路径后通过 `node` 以 argv 数组执行；不得为了查询本地环境访问 npm。只有连接或安装环境时才使用与当前技能包一致的固定 launcher `node <home>/.rainbond/lib/rainskills/bin/rainskills.js`（运行包版本 `rainskills@0.1.16`）。
 
 - 列表：用本地 launcher 执行 `environment list --json`，只展示名称、类型、状态、是否默认和最近验证时间。
 - 重命名：用本地 launcher 执行 `environment rename --environment-id <uuid> --name <name>`。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rainskills",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Interactive Rainbond skill installer for Codex, Claude Code, and Pi Agent",
   "license": "Apache-2.0",
   "homepage": "https://github.com/goodrain/rainskills#readme",
@@ -58,11 +58,12 @@
     "check:runtime-version": "node scripts/sync-runtime-version.mjs --check",
     "version": "npm run sync:runtime-version && npm run build:marketplace",
     "prepack": "node scripts/sync-runtime-version.mjs --check && node scripts/build-marketplace-package.mjs --check --quiet",
-    "test": "npm run test:runtime-version && npm run test:auto-update && npm run test:launcher && npm run test:api-bridge && npm run test:skill-profile && npm run test:marketplace && npm run test:runtime-routing && npm run test:telemetry && npm run test:platform && npm run test:windows && npm run test:package-upload && npm run test:package && npm run test:installer && npm run test:signal && npm run test:npx-pty",
+    "test": "npm run test:runtime-version && npm run test:auto-update && npm run test:launcher && npm run test:api-bridge && npm run test:console-contract && npm run test:skill-profile && npm run test:marketplace && npm run test:runtime-routing && npm run test:telemetry && npm run test:platform && npm run test:windows && npm run test:package-upload && npm run test:package && npm run test:installer && npm run test:signal && npm run test:npx-pty",
     "test:runtime-version": "node --test tests/runtime-version-sync.test.js",
     "test:auto-update": "node --test tests/auto-update.test.js",
     "test:launcher": "node --test tests/console-origin.test.js tests/environment-credentials.test.js tests/environment-registry.test.js tests/local-runtime-cli.test.js tests/local-cli-installer.test.js tests/npx-launcher.test.js tests/runtime-credentials.test.js tests/runtime-intents.test.js tests/runtime-operations.test.js tests/runtime-state.test.js tests/cli-only-transport.test.js tests/skill-manifest-builder.test.js",
     "test:api-bridge": "node --test tests/api-bridge.test.js",
+    "test:console-contract": "python3 tests/console_tool_contract_test.py",
     "test:skill-profile": "node --test tests/skill-profile-builder.test.js tests/markdown-link-integrity.test.js",
     "test:marketplace": "node --test tests/marketplace-entry.test.js",
     "test:runtime-routing": "node --test tests/runtime-onboarding-routing.test.js && python3 tests/run_skill_routing_evals.py",

package/rainbond-app-assistant/SKILL.md

@@ -102,19 +102,21 @@ description: "Use whenever a user asks to deploy, run, deliver, publish, inspect
 
   第一步检查 Node.js 是否存在且主版本不低于 18。Node.js 缺失或低于 18 时，只说明“Rainskills 执行组件需要 Node.js 18 或更高版本”并停止：不选择运行环境，不调用 MCP，不猜测替代命令。只有用户或 agent 明确同意后才安装或升级 Node.js，再从同一原始 intent 继续。
 
-  固定 launcher 是 `["node", "<home>/.rainbond/lib/rainskills/bin/rainskills.js"]`；运行包版本标记为 `rainskills@0.1.14`，且必须与本技能包 `package.json` 一致。把 launcher 与参数拼成 argv 数组直接执行，禁止使用 `rainskills@latest`，禁止拼接或执行 shell 字符串。
+  固定 launcher 是 `["node", "<home>/.rainbond/lib/rainskills/bin/rainskills.js"]`；运行包版本标记为 `rainskills@0.1.16`，且必须与本技能包 `package.json` 一致。把 launcher 与参数拼成 argv 数组直接执行，禁止使用 `rainskills@latest`，禁止拼接或执行 shell 字符串。
 
   本地 launcher 必须从当前 Skill 所在目录的同级目录定位 `rainbond-platform-installer/scripts/local-runtime.js`，解析为绝对路径后使用 `["node", "<绝对路径>"]` 执行。`environment list`、`operation begin`、`operation complete` 和 `runtime message` 只能使用本地 launcher；本地 launcher 只读取已安装文件和本机受保护状态，不得访问 npm 或其它网络。只有用户选定连接或安装运行环境后，才使用上面的固定本地 launcher。
 
   所有 Rainbond 查询和变更必须通过本地 `~/.rainbond/bin/rainskills-tools.js` 执行，并绑定本次 operation ID。禁止 Agent 直接调用 Rainbond MCP，也不得启动本地 Rainskills MCP 服务；只允许执行 CLI 返回的结构化结果与确认续接 argv。
 
+  业务操作开始后，必须先用固定 argv `["node", "<home>/.rainbond/bin/rainskills-tools.js", "context", "resolve", "--input", "-", "--operation-id", "<uuid>", "--skill-id", "rainbond-app-assistant"]`，通过 stdin 传入 `{"required": ["enterprise", "workspace"]}`。返回 `resolved` 时只使用该 operation 已保存的企业、工作空间和集群上下文；返回 `needs-selection` 时，把 CLI 返回的“工作空间 + 集群”组合选项一次性列给用户，不得逐项询问，也不得让用户提供 enterprise_id。用户选择后执行 `context select`，stdin 只传 `{"selection_id":"<selection-id>","option_id":"<option-id>"}`；选择成功后继续原操作，同一 operation 不再重复查询上下文。
+
   只有 CLI 返回并通过校验的 `rainskills.next-action.v1` argv 才能执行续接。普通失败一律禁止自动重试：不得再次执行原命令，不得执行 `--help`、`sleep`、`rg`、`grep`，不得搜索 Rainskills 源码；同一 `operation complete` 最多执行一次。
 
   <!-- rainskills-runtime-contract:start -->
   ```json
   {
     "schema": "rainskills.skill-runtime-contract.v1",
-    "package_version": "rainskills@0.1.14",
+    "package_version": "rainskills@0.1.16",
     "launcher": ["node", "<home>/.rainbond/lib/rainskills/bin/rainskills.js"],
     "local_launcher": ["node", "<installed-skills-root>/rainbond-platform-installer/scripts/local-runtime.js"],
     "local_argv": {
@@ -147,11 +149,15 @@ description: "Use whenever a user asks to deploy, run, deliver, publish, inspect
 
   连接或平台安装完成后，用固定 `onboarding-id` 执行 launcher + `["intent", "resume", "--onboarding-id", "<同一 onboarding-id>"]`，恢复原始 intent 和 `resume_step`，不得重新猜测动作。
 
+  同一条附着命令先输出 `runtime.device-authorization`、随后输出 schema 为 `rainskills.runtime-connect-result.v1` 且 `state=connected` 时，最终 connected 结果覆盖前面的等待授权消息。不得再次展示旧授权消息、不得等待用户回复“已授权”；必须在同一轮立即使用同一 `onboarding-id` 执行 `intent resume`。
+
   业务 MCP 返回 401 时，先执行 launcher + `["runtime", "record-failure", "--onboarding-id", "<同一 onboarding-id>", "--step", "<当前固定步骤>", "--reason", "credential-expired"]`，再仅一次执行 launcher + `["runtime", "reconnect", "--onboarding-id", "<同一 onboarding-id>"]`，然后 resume 并只重试该步骤；第二次 401 立即停止。403 时执行 launcher + `["runtime", "record-failure", "--onboarding-id", "<同一 onboarding-id>", "--step", "<当前固定步骤>", "--reason", "permission-denied"]` 后停止，不得 reconnect、重新授权或自动重试，只说明缺少的权限。
 <!-- rainskills-runtime-gate:end -->
 
 受限沙箱（包括 Codex）执行本地状态命令时，必须申请用户级受保护目录访问权限；在 Codex 中使用 `require_escalated`。不得修改 `~/.rainbond` 权限、复制受保护状态到工作区，或因沙箱权限错误建议重装。
 
+涉及浏览器或设备授权的 `runtime connect`，以及恢复/安装场景中的 `rainskills <target> --self-hosted`，必须在附加交互终端（TTY）中运行；在 Codex 中设置 `tty: true` 并保持进程附着直到授权完成。禁止通过非交互命令要求用户粘贴 JWT；非交互模式只可复用已存在的受保护凭据。
+
 执行优化：同一会话内只检查一次 Node.js（首次使用本地 CLI 前）；仅在 Node.js 或 Rainskills 安装、升级，或 PATH 变更后失效。固定 launcher 和 argv 已在本 Skill 中，禁止读取、搜索或探测 `rainskills.js`，也禁止执行 `npm root -g`。每个新的业务操作仍需要刷新一次环境列表；带已有 `operation_id` 或 `onboarding-id` 的续接复用已绑定的环境 ID，不重复枚举环境。
 
 <!-- rainskills-runtime-routing:start -->
@@ -286,7 +292,7 @@ description: "Use whenever a user asks to deploy, run, deliver, publish, inspect
     - 可以用 `rainbond_query_region_rbd_components` 查询并展示它们的状态
     - 不能通过 MCP 对它们执行重启、部署、修改等写操作；当前 MCP 工具集不支持此类操作
      - 如果用户要求操作这些组件，明确告知：需要通过 Kubernetes 命令（如 `kubectl rollout restart deployment/<name> -n rbd-system`）或 Rainbond 集群管理控制台进行，超出本技能的操作范围，不要假装可以执行
-28a. 写操作失败或结果异常时，先调用 `rainbond_get_operation_failure_context`，按其 `classified_reason` 决定停下、只读核实或低风险修复；`unknown` 回退既有证据链，禁止盲目重放写操作。
+28a. 已知 `service_id` 的组件在构建、部署或运行操作后失败或立即异常时，调用 `rainbond_get_operation_failure_context({team_name, region_name, app_id, service_id, event_id?})`，按其 `classified_reason` 决定停下、只读核实或低风险修复；`unknown` 回退既有证据链，禁止盲目重放写操作。CLI 在确认令牌生成前报告的 missing/invalid field 属于参数校验失败，尚未进入组件操作：按 Console Tool schema 修正参数一次，不调用 failure context，也不查询组件残留。
     `event_log_tail` 只作为敏感诊断证据使用，绝不能复制、引用或向用户展示其原文；输出只能使用 `classified_reason`、非敏感摘要和已脱敏字段。
 28b. 运行态或交付健康检查先调用 `rainbond_get_app_health_overview`；仅 `abnormal` 或 `unknown` 组件再读取 component summary、日志、事件或存储明细。
 29. **仅给 bare Git URL 时默认 root + 空 `subdirectories`**：当用户给的只是一个 Git URL（无本地 manifest、无明确子目录提示），默认 `subdirectories=""`（仓库根）进入 source 检测，让后端判断这个仓库结构。**不要**先问用户"根目录还是子目录"。
@@ -366,7 +372,7 @@ description: "Use whenever a user asks to deploy, run, deliver, publish, inspect
     - 从对话历史里随手抓一个看起来像 UUID 的字符串（可能是 `check_event_id` / `check_uuid` / `event_id` / 历史 service_id）
     - 凭"我记得是这个"或"上次也是这个 ID"做猜测
     - 用户消息里粘的、但本会话没验证过的 ID
-    强制流程：动手前如果不能 100% 确定 `service_id` 出处，**第一动作**必须是 `rainbond_query_components(team_name, region_name, app_id)`，按 `service_cname` 或 `k8s_component_name` 匹配出真实 `service_id`，再调写工具。
+    强制流程：动手前如果不能 100% 确定 `service_id` 出处，**第一动作**必须是 `rainbond_query_components({enterprise_id, app_id})`，必要时携带 `query=<service_cname 或 service_id>`，按 `service_cname` 或 `k8s_component_name` 匹配出真实 `service_id`，再调写工具。
     反例（**禁止**）：日志里出现"修改组件 `7059eb62cccc3a16f22c9415c905bbcc` 的构建源" — 这个 ID 在本会话所有 query 结果里都没出现过，是模型从某处幻觉出来的。正确做法：调 update 之前先 `rainbond_query_components` 拿到真实 `service_id`，再 update。
     与 Iron Law 31 配套：31 管"写工具前必须 select skill"，34 管"写工具的 service_id 必须有明确出处"。两条共同把"模型自由发挥参数"这条路堵死。
 
@@ -384,7 +390,7 @@ description: "Use whenever a user asks to deploy, run, deliver, publish, inspect
     反例（来自真实回归 case `cs_1779149681822_3u`，2026-05-19）：模型从 `rainbond_get_component_summary` 响应的 `recent_events` 段看到形如 `{"ID": 17740, "event_id": "...", "opt_type": "build-service"}`，直接把 `17740` 当成 `event_id` 传给 `rainbond_get_component_build_logs`，工具返回 `items: []`（找不到该 UUID 的日志）。正确做法：从同一 `recent_events[i].event_id` 字段取出 UUID 字符串，或调 `rainbond_get_component_events` 重查。
 35. **会话内部叙述纪律 + 内部 preflight 工具不要主动调**。下列四类是"内部会话状态"，对用户**无信息量**，禁止外漏到 assistant 可见消息：
     - **`select_skill_*` 工具调用本身**：这是 server 内部 hookup，把指定 skill 的执行手册拼到 system prompt 用的。调用前**不要**说"我先加载 bootstrap 手册"、"现在调用 select_skill_..."；调用后**不要**说"Bootstrap 手册已加载"、"skill ready" 这类回声。server 返回的 `loaded_skill` / `already active` ack 是给你看的内部信号，**直接进入下一个真实工具调用**，保持沉默。
-    - **`rainbond_get_current_user`**：本工具被 server 端 AuthSubjectResolver 在每次 HTTP 请求的 preflight 里跑过了。当前 user_id / username / enterprise_id / team_name / region_name **已经在 system prompt 的 session-context 段提供**，需要时直接读那里，**不要发 tool call 重新拉**。例外：用户明确说"我换了团队/企业，重新认一下"这种 explicit 重认证需求才调。
+    - **`rainbond_get_current_user`**：不得由 Agent 单独调用。企业、工作空间和集群上下文统一由受保护的 `context resolve` 命令解析并绑定到本次 operation；只有 CLI 明确返回需要选择时才询问用户。
     - **`rainbond_query_components` 同入参重复轮询**：服务端 30s 内的同 args 调用会走缓存；你**不要**在每个新 user turn 开头都"先查一下组件列表"，priorTurnMessages 里上一次的 query 结果在 contextSignature 不变时仍然有效。
     - **规则推理过程 / MCP 工具内部限制 / 分类决策叙述**：你内部基于哪条 Iron Law / hard rule / 推断信号做的决策、具体 MCP 工具签名 / 字段限制、对组件 / 服务的分类判断（"ClickHouse 是公认的列式分析数据库"这类），都属于内部状态，对用户**无信息量**。
       
@@ -414,7 +420,7 @@ description: "Use whenever a user asks to deploy, run, deliver, publish, inspect
     反例（**禁止**）：上一轮已经 `select_skill_rainbond-fullstack-bootstrap` 过了，本轮 user 简短回复 "java/jar"，你又调一次 `select_skill_rainbond-fullstack-bootstrap` 并叙述"先加载 bootstrap"。正确做法：priorTurnMessages 已有 ack → 直接 `rainbond_update_component_build_source(...)` 继续。
     正例：上一轮 `select_skill_rainbond-fullstack-bootstrap`，本轮用户说"组件起不来帮我排查下" → 现在阶段从部署切到排障 → 调一次 `select_skill_rainbond-fullstack-troubleshooter`（新 skill，允许）→ 沉默地进入诊断流程，不复述"troubleshooter 已加载"。
 36. **用户给出的字面值（URL / 镜像地址 / 分支名 / 凭证）必须 verbatim 传给工具，禁止 LLM 凭训练知识"补全"、"修正"、"猜测"**。
-    适用字段：`git_url` / `image_address` / `code_version`（分支/tag/commit）/ `username` / `password` / `token` / `subdirectories` 等任何用户在消息里给出的字面值。
+    适用字段：`git_url` / `image`（用户所说的镜像地址映射到 Console Tool 的 `image` 字段）/ `code_version`（分支/tag/commit）/ `username` / `password` / `token` / `subdirectories` 等任何用户在消息里给出的字面值。
     **禁止行为**：
     - 看到 `service_cname=java-maven-demo` 就自创 `git_url=https://gitee.com/mirrors_123/java-maven-demo.git`（按训练数据里"常见仓库地址"补全）
     - 用户给的 URL 没 `.git` 后缀就自动加上
@@ -478,11 +484,11 @@ description: "Use whenever a user asks to deploy, run, deliver, publish, inspect
     - 与 Iron Law 14（delivery mode 切换必须用户确认）配套：14 管 source↔package↔image↔template 的策略切换需用户确认，38 管"用户已经显式给了源码意图时，模板不是默认路径、且切换必须清理残留"。
 39. **轮次纪律：复用已知值，不重复无变化的调用**（与 Iron Law 35 的"内部 preflight 工具不要主动调"配套，35 管哪些工具不该调，39 管已拿到的值要复用）：
     - **复用创建返回的 `service_id` / `service_alias`**：`rainbond_create_component_*` 成功后会返回 `service_id` 和 `service_alias`（k8s component name），**记住并在本轮后续 mutating 操作里直接复用**。**禁止**在每次 `rainbond_manage_component_*` / `rainbond_operate_app` 之前都先 `rainbond_query_components` 重查一遍 alias —— 创建时已经返回过，重查只是浪费轮次（仅当 `service_id` 出处不明、按 Iron Law 34 必须重新建立 provenance 时才查）。
-    - **不重复调 `rainbond_get_current_user`**：身份（user_id / username / enterprise_id / team_name / region_name）在一次会话内不变，已在 system prompt 的 session-context 段提供，需要时直接读（见 Iron Law 35 第 2 类）。
+    - **不重复调 `rainbond_get_current_user`**：同一 operation 复用 `context resolve` 已保存的企业、工作空间和集群上下文；只有上下文失效或用户明确切换目标时才重新解析。
     - **同一 mutating 调用成功后禁止原样重复**：一个写工具用相同入参成功返回后，不要在同一轮再发一次相同调用"确认一下"——成功就是成功，要确认状态用读工具（`rainbond_get_component_summary` 等），不要重发写调用。
-40. **对外访问地址必须引用工具返回的真实值，禁止按格式拼装。** 组件的对外访问地址是**事实信息**，唯一权威来源是 `rainbond_get_component_summary` 返回的 `access_infos` 字段（来自网关真实绑定）。
-    - 本轮已调用该工具拿到真实地址 → 报告里引用 `access_infos` 的真实值。
-    - 本轮**未**调用该工具、或该工具未返回可用地址 → 最终报告必须写"请在控制台该组件的端口页查看对外访问地址"，**禁止**按记忆或文档示例的 URL 格式（`<name>.<ip>.nip.io`、`<service>-<port>-<team>.<ip>.nip.io` 等）拼装一个地址当成真的。
+40. **对外访问地址必须引用工具返回的真实值，禁止按格式拼装。** 组件的对外访问地址是**事实信息**，权威来源是 `rainbond_get_component_detail` 或 `rainbond_get_component_summary` 返回的 `access_infos` 字段（都来自网关真实绑定）。只需状态和访问地址时优先调用轻量的 detail；只有异常组件确实需要端口、env、存储或事件证据时才调用 summary。
+    - 本轮已通过上述任一工具拿到真实地址 → 报告里引用 `access_infos` 的真实值。
+    - 本轮**未**通过上述工具拿到可用地址 → 最终报告必须写"请在控制台该组件的端口页查看对外访问地址"，**禁止**按记忆或文档示例的 URL 格式（`<name>.<ip>.nip.io`、`<service>-<port>-<team>.<ip>.nip.io` 等）拼装一个地址当成真的。
     - **禁止**把任何拼装/猜测出来的访问地址写进任何组件 env（如 `APP_WEB_URL` / `*_BASE_URL` / `*_PUBLIC_URL` 等）。需要把对外地址回填给某个组件时，同样只能用 `access_infos` 的真实值；拿不到真实值就停下来让用户在控制台确认后提供，不要先拼一个填进去。
     - 真实事故：模型在没有任何工具返回访问地址的情况下，照文档示例格式拼出 `http://dify.<ip>.nip.io`，既写进最终报告又配进了组件 `APP_WEB_URL`，全是编造的。这是 Iron Law 违反。
 41. **部署位置和访问地址必须分开。** `project.deployment_location_url` 是 Rainbond 控制台应用概览地址；仅在可信 Console base（`RAINBOND_URL` 或等价 session context）、`team_name`、`region_name` 和 `app_id` 全部已知时生成：

package/rainbond-app-version-assistant/SKILL.md

@@ -18,19 +18,21 @@ description: "Use when a user explicitly asks for an existing Rainbond app versi
 
 第一步检查 Node.js 是否存在且主版本不低于 18。Node.js 缺失或低于 18 时，只说明“Rainskills 执行组件需要 Node.js 18 或更高版本”并停止：不选择运行环境，不调用 MCP，不猜测替代命令。只有用户或 agent 明确同意后才安装或升级 Node.js，再从同一原始 intent 继续。
 
-固定 launcher 是 `["node", "<home>/.rainbond/lib/rainskills/bin/rainskills.js"]`；运行包版本标记为 `rainskills@0.1.14`，且必须与本技能包 `package.json` 一致。把 launcher 与参数拼成 argv 数组直接执行，禁止 `rainskills@latest` 或执行 shell 字符串。
+固定 launcher 是 `["node", "<home>/.rainbond/lib/rainskills/bin/rainskills.js"]`；运行包版本标记为 `rainskills@0.1.16`，且必须与本技能包 `package.json` 一致。把 launcher 与参数拼成 argv 数组直接执行，禁止 `rainskills@latest` 或执行 shell 字符串。
 
 本地 launcher 必须从当前 Skill 所在目录的同级目录定位 `rainbond-platform-installer/scripts/local-runtime.js`，解析为绝对路径后使用 `["node", "<绝对路径>"]` 执行。`environment list`、`operation begin`、`operation complete` 和 `runtime message` 只能使用本地 launcher；本地 launcher 只读取已安装文件和本机受保护状态，不得访问 npm 或其它网络。只有用户选定连接运行环境后，才使用上面的固定本地 launcher。
 
 所有 Rainbond 查询和变更必须通过本地 `~/.rainbond/bin/rainskills-tools.js` 执行，并绑定本次 operation ID。禁止 Agent 直接调用 Rainbond MCP，也不得启动本地 Rainskills MCP 服务；只允许执行 CLI 返回的结构化结果与确认续接 argv。
 
+业务操作开始后，必须先用固定 argv `["node", "<home>/.rainbond/bin/rainskills-tools.js", "context", "resolve", "--input", "-", "--operation-id", "<uuid>", "--skill-id", "rainbond-app-version-assistant"]`，通过 stdin 传入 `{"required": ["enterprise", "workspace"]}`。返回 `resolved` 时只使用该 operation 已保存的企业、工作空间和集群上下文；返回 `needs-selection` 时，把 CLI 返回的“工作空间 + 集群”组合选项一次性列给用户，不得逐项询问，也不得让用户提供 enterprise_id。用户选择后执行 `context select`，stdin 只传 `{"selection_id":"<selection-id>","option_id":"<option-id>"}`；选择成功后继续原操作，同一 operation 不再重复查询上下文。
+
 只有 CLI 返回并通过校验的 `rainskills.next-action.v1` argv 才能执行续接。普通失败一律禁止自动重试：不得再次执行原命令，不得执行 `--help`、`sleep`、`rg`、`grep`，不得搜索 Rainskills 源码；同一 `operation complete` 最多执行一次。
 
 <!-- rainskills-runtime-contract:start -->
 ```json
 {
   "schema": "rainskills.skill-runtime-contract.v1",
-  "package_version": "rainskills@0.1.14",
+  "package_version": "rainskills@0.1.16",
     "launcher": ["node", "<home>/.rainbond/lib/rainskills/bin/rainskills.js"],
   "local_launcher": ["node", "<installed-skills-root>/rainbond-platform-installer/scripts/local-runtime.js"],
   "local_argv": {
@@ -60,6 +62,8 @@ target 只允许 `codex`、`claude`、`pi`、`all`。校验 intent 后只执行
 
 受限沙箱（包括 Codex）执行本地状态命令时，必须申请用户级受保护目录访问权限；在 Codex 中使用 `require_escalated`。不得修改 `~/.rainbond` 权限、复制受保护状态到工作区，或因沙箱权限错误建议重装。
 
+涉及浏览器或设备授权的 `runtime connect`，以及恢复/安装场景中的 `rainskills <target> --self-hosted`，必须在附加交互终端（TTY）中运行；在 Codex 中设置 `tty: true` 并保持进程附着直到授权完成。禁止通过非交互命令要求用户粘贴 JWT；非交互模式只可复用已存在的受保护凭据。
+
 执行优化：同一会话内只检查一次 Node.js（首次使用本地 CLI 前）；仅在 Node.js 或 Rainskills 安装、升级，或 PATH 变更后失效。固定 launcher 和 argv 已在本 Skill 中，禁止读取、搜索或探测 `rainskills.js`，也禁止执行 `npm root -g`。每个新的业务操作仍需要刷新一次环境列表；带已有 `operation_id` 或 `onboarding-id` 的续接复用已绑定的环境 ID，不重复枚举环境。
 
 <!-- rainskills-runtime-routing:start -->