@hadooppei/hwcode 1.0.7 → 1.0.9

package/.pi/extensions/workflows/cloud/interactions.ts

@@ -0,0 +1,102 @@
+import { readFileSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+
+import type { ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { notify, secretInput } from "../../../lib/extension-ui.ts";
+import type { RemoteTrustInteraction } from "../../../lib/workflows/cloud/remote/connect.ts";
+import {
+  getCloudProvider, type CloudCredentials, type CloudVendorId,
+} from "../../../lib/workflows/cloud/providers.ts";
+import {
+  cloudVaultExists, createEmptyVault, defaultCloudVaultPath, readCloudVault,
+} from "../../../lib/workflows/cloud/vault.ts";
+
+export async function unlockVault(
+  ctx: ExtensionCommandContext,
+): Promise<{ password: string; payload: ReturnType<typeof createEmptyVault> } | undefined> {
+  const vaultPath = defaultCloudVaultPath();
+  if (!cloudVaultExists(vaultPath)) {
+    while (true) {
+      const password = await secretInput(ctx, "创建云凭据主密码（至少 8 个字符）");
+      if (password === undefined) return undefined;
+      if (password.length < 8) {
+        notify(ctx, "主密码至少需要 8 个字符。", "warning");
+        continue;
+      }
+      const confirmation = await secretInput(ctx, "再次输入主密码");
+      if (confirmation === undefined) return undefined;
+      if (confirmation !== password) {
+        notify(ctx, "两次输入的主密码不一致。", "warning");
+        continue;
+      }
+      return { password, payload: createEmptyVault() };
+    }
+  }
+  while (true) {
+    const password = await secretInput(ctx, "输入云凭据主密码以解锁");
+    if (password === undefined) return undefined;
+    try {
+      return { password, payload: readCloudVault(password, vaultPath) };
+    } catch (error) {
+      notify(ctx, error instanceof Error ? error.message : String(error), "error");
+      const retry = await ctx.ui.confirm("重新输入主密码？", "凭据未解锁，HWCode Cloud 尚未启动。");
+      if (!retry) return undefined;
+    }
+  }
+}
+
+export async function collectCredentials(
+  vendor: CloudVendorId,
+  root: string,
+  ctx: ExtensionCommandContext,
+): Promise<CloudCredentials | undefined> {
+  const credentials: CloudCredentials = {};
+  for (const field of getCloudProvider(vendor).credentialFields) {
+    let value = field.secret
+      ? await secretInput(ctx, field.label)
+      : await ctx.ui.input(field.label, field.placeholder);
+    if (value === undefined) return undefined;
+    value = value.trim();
+    if (!value && !field.optional) {
+      notify(ctx, `${field.label} 不能为空。`, "warning");
+      return collectCredentials(vendor, root, ctx);
+    }
+    if (!value) continue;
+    if (field.fileContents) {
+      const path = isAbsolute(value) ? value : resolve(root, value);
+      try {
+        const contents = readFileSync(path, "utf8");
+        JSON.parse(contents);
+        credentials[field.key] = contents;
+      } catch (error) {
+        notify(
+          ctx,
+          `无法读取有效的 JSON 凭据文件 ${path}: ${error instanceof Error ? error.message : String(error)}`,
+          "error",
+        );
+        return collectCredentials(vendor, root, ctx);
+      }
+    } else {
+      credentials[field.key] = value;
+    }
+  }
+  if (vendor === "gcp") {
+    const account = JSON.parse(credentials.serviceAccountJson) as Record<string, unknown>;
+    credentials.projectId ||= typeof account.project_id === "string" ? account.project_id : "";
+    if (!credentials.projectId) {
+      notify(ctx, "Service Account JSON 中没有 project_id，请重新输入。", "error");
+      return collectCredentials(vendor, root, ctx);
+    }
+  }
+  return credentials;
+}
+
+export function remoteTrustInteraction(ctx: ExtensionContext): RemoteTrustInteraction {
+  return {
+    confirm: async (host, port, keys, role) => ctx.hasUI && ctx.ui.confirm(
+      role === "jump" ? "信任 SSH 跳板机主机密钥？" : "信任 Terraform Runner 主机密钥？",
+      `主机：${host}:${port}\n${keys.map((key) => `${key.algorithm} ${key.fingerprint}`).join("\n")}\n\n请仅在指纹与云控制台或可信运维记录一致时确认。`,
+    ),
+  };
+}

package/.pi/extensions/workflows/cloud/provider-tools.ts

@@ -4,17 +4,23 @@ import { Type } from "@earendil-works/pi-ai";
 import { defineTool, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 import { CLOUD_RUNTIME_DEFAULTS } from "../../../lib/runtime/defaults.ts";
+import { toolError, toolOk } from "../../../lib/tool-result.ts";
 import { evaluateCommandArgumentsAccess } from "../../../lib/workspace/access-policy.ts";
 import { prepareCloudExecution } from "../../../lib/workflows/cloud/adapters.ts";
 import { cloudExecutionBlockReason, recordStrategyFailure } from "../../../lib/workflows/cloud/execution.ts";
 import { runProcess, truncateOutput, type ProcessResult } from "../../../lib/workflows/cloud/process.ts";
 import { CLOUD_EXECUTABLES, classifyCloudOperation, getCloudProvider, redactCredentialValues, type CloudOperation } from "../../../lib/workflows/cloud/providers.ts";
-import { WORKFLOW_EXTERNAL_AUDIT_TYPE } from "../../../lib/workflows/state.ts";
+import { cloudArtifactDirectory } from "../../../lib/workflows/cloud/workspace.ts";
+import { WORKFLOW_EXTERNAL_AUDIT_TYPE, cloudDetails } from "../../../lib/workflows/state.ts";
 import type { CloudExtensionRuntime } from "./runtime.ts";
-import {
-  CLOUD_AUDIT_TYPE, ORCHESTRATION_COMMANDS, SENSITIVE_ARGUMENT, approveOperation,
-  cloudArtifactDirectory, cloudDetails, safeStepText, terraformError, terraformOk,
-} from "./shared.ts";
+
+const CLOUD_AUDIT_TYPE = "hwcode-cloud-audit";
+const ORCHESTRATION_COMMANDS = new Set(["terraform", "tofu", "pulumi", "kubectl", "helm"]);
+const SENSITIVE_ARGUMENT = /^--?(?:access[-_]?key|secret(?:[-_]?(?:access|key))?|client[-_]?secret|password|credential|token)(?:=|$)/iu;
+
+function safeStepText(value: string, credentials: Record<string, string>): string {
+  return redactCredentialValues(value.replace(/[\r\n]+/gu, " ").slice(0, 2_000), credentials);
+}
 
 export function registerCloudProviderTools(pi: ExtensionAPI, runtime: CloudExtensionRuntime): void {
   pi.registerTool(defineTool({
@@ -31,20 +37,20 @@ export function registerCloudProviderTools(pi: ExtensionAPI, runtime: CloudExten
     async execute(_id, params, _signal, _onUpdate, ctx) {
       const activeState = runtime.restore(ctx);
       const blocked = cloudExecutionBlockReason(activeState, { allowAfterTerminalFailure: true });
-      if (!activeState || blocked) return terraformError(blocked ?? "HWCode Cloud is not active.");
+      if (!activeState || blocked) return toolError(blocked ?? "HWCode Cloud is not active.");
       const details = cloudDetails(activeState)!;
       const clean = (value: string, limit: number) => value.replace(/[\r\n\0]/gu, " ").trim().slice(0, limit);
       const id = clean(params.id, 256);
       const type = clean(params.type, 128);
       const region = clean(params.region, 128);
-      if (!id || !type || !region) return terraformError("Resource id, type, and region are required.");
+      if (!id || !type || !region) return toolError("Resource id, type, and region are required.");
       const resources = [...(details.resources ?? [])];
       const index = resources.findIndex((resource) => resource.id === id && resource.type === type && resource.region === region);
       const record = { id, type, region, ownership: params.ownership, status: params.status, updatedAt: new Date().toISOString() } as const;
       if (index >= 0) resources[index] = record;
       else resources.push(record);
       runtime.replaceDetails(activeState, { ...details, resources: resources.slice(-500) });
-      return terraformOk(`Resource inventory updated: ${type} ${id} (${params.status}).`, { resource: record });
+      return toolOk(`Resource inventory updated: ${type} ${id} (${params.status}).`, { resource: record });
     },
   }));
 
@@ -85,7 +91,7 @@ export function registerCloudProviderTools(pi: ExtensionAPI, runtime: CloudExten
         pi.appendEntry(WORKFLOW_EXTERNAL_AUDIT_TYPE, { mode: "cloud", root: activeState.root, toolName: "hwcode_cloud_exec", external, approvedAt: new Date().toISOString() });
       }
 
-      const approval = await approveOperation(operation, params, activeState, ctx);
+      const approval = await runtime.approveOperation(operation, params, activeState, ctx);
       if (approval === "deny") return { content: [{ type: "text" as const, text: `User denied ${operation} operation: ${params.intent}` }], isError: true, details: { denied: true, operation } };
       if (approval === "allow-session") {
         activeState = runtime.replaceDetails(activeState, { ...details, allowNonDeleteChanges: true });

package/.pi/extensions/workflows/cloud/runner-tools.ts

@@ -7,6 +7,7 @@ import { defineTool, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 import { CLOUD_RUNTIME_DEFAULTS } from "../../../lib/runtime/defaults.ts";
 import { remoteRunnerPaths, userRuntimePaths } from "../../../lib/runtime/paths.ts";
+import { toolError, toolOk } from "../../../lib/tool-result.ts";
 import { prepareRemoteRunner } from "../../../lib/workflows/cloud/remote/bootstrap.ts";
 import { connectRemoteTarget } from "../../../lib/workflows/cloud/remote/connect.ts";
 import { remoteTargetSummary, type RemoteTargetProfile } from "../../../lib/workflows/cloud/remote/profiles.ts";
@@ -14,9 +15,9 @@ import { createRemoteRunWorkspace, isTerraformSourceFile, syncRemoteWorkspace }
 import { truncateOutput } from "../../../lib/workflows/cloud/process.ts";
 import { assertSafeTerraformSource } from "../../../lib/workflows/cloud/terraform/policy.ts";
 import { saveRemoteTargetProfile, writeCloudVault } from "../../../lib/workflows/cloud/vault.ts";
-import type { TerraformRunState } from "../../../lib/workflows/state.ts";
+import { cloudDetails, type TerraformRunState } from "../../../lib/workflows/state.ts";
+import { remoteTrustInteraction } from "./interactions.ts";
 import type { CloudExtensionRuntime } from "./runtime.ts";
-import { cloudDetails, remoteTrustInteraction, terraformError, terraformOk } from "./shared.ts";
 
 export function registerCloudRunnerTools(pi: ExtensionAPI, runtime: CloudExtensionRuntime): void {
   pi.registerTool(defineTool({
@@ -38,11 +39,11 @@ export function registerCloudRunnerTools(pi: ExtensionAPI, runtime: CloudExtensi
       const activeState = runtime.restore(ctx);
       const details = activeState && cloudDetails(activeState);
       const blocked = runtime.blocked(activeState);
-      if (!activeState || !details || blocked) return terraformError(blocked ?? "HWCode Cloud is not active.");
-      if (!runtime.activeVault) return terraformError("HWCode Cloud credentials are locked. Run /hwcode-cloud before connecting a Runner.");
+      if (!activeState || !details || blocked) return toolError(blocked ?? "HWCode Cloud is not active.");
+      if (!runtime.activeVault) return toolError("HWCode Cloud credentials are locked. Run /hwcode-cloud before connecting a Runner.");
       const home = homedir();
       const keyPath = params.keyPath || CLOUD_RUNTIME_DEFAULTS.runner.keyCandidates.map((file) => resolve(home, ".ssh", file)).find(existsSync);
-      if (!keyPath || !existsSync(keyPath)) return terraformError("No local SSH private key was found. Pass keyPath explicitly or create ~/.ssh/id_ed25519.");
+      if (!keyPath || !existsSync(keyPath)) return toolError("No local SSH private key was found. Pass keyPath explicitly or create ~/.ssh/id_ed25519.");
       const user = params.user || CLOUD_RUNTIME_DEFAULTS.runner.defaultUser;
       const port = params.port || CLOUD_RUNTIME_DEFAULTS.runner.defaultPort;
       let profile: RemoteTargetProfile;
@@ -55,12 +56,12 @@ export function registerCloudRunnerTools(pi: ExtensionAPI, runtime: CloudExtensi
           identityType: params.identityType || "instance-role",
           proxyJump: params.jumpHost ? { host: params.jumpHost, port: params.jumpPort || CLOUD_RUNTIME_DEFAULTS.runner.defaultPort, user: params.jumpUser || user } : undefined,
         }, activeState.root, remoteTrustInteraction(ctx), signal);
-      } catch (error) { return terraformError(error instanceof Error ? error.message : String(error)); }
+      } catch (error) { return toolError(error instanceof Error ? error.message : String(error)); }
       runtime.activeRunner = profile;
       runtime.activeVault.payload = saveRemoteTargetProfile(runtime.activeVault.payload, profile);
       writeCloudVault(runtime.activeVault.payload, runtime.activeVault.password, runtime.activeVault.path);
       runtime.replaceDetails(activeState, { ...details, runner: remoteTargetSummary(profile) }, "connected");
-      return terraformOk(`Terraform Runner connected: ${profile.user}@${profile.host}:${profile.port}`, { runner: remoteTargetSummary(profile) });
+      return toolOk(`Terraform Runner connected: ${profile.user}@${profile.host}:${profile.port}`, { runner: remoteTargetSummary(profile) });
     },
   }));
 
@@ -71,21 +72,21 @@ export function registerCloudRunnerTools(pi: ExtensionAPI, runtime: CloudExtensi
     async execute(_id, _params, signal, _onUpdate, ctx) {
       const activeState = runtime.restore(ctx);
       const blocked = runtime.blocked(activeState);
-      if (!activeState || blocked) return terraformError(blocked ?? "HWCode Cloud is not active.");
+      if (!activeState || blocked) return toolError(blocked ?? "HWCode Cloud is not active.");
       let runner: RemoteTargetProfile;
-      try { runner = runtime.requireRunner(activeState); } catch (error) { return terraformError(error instanceof Error ? error.message : String(error)); }
+      try { runner = runtime.requireRunner(activeState); } catch (error) { return toolError(error instanceof Error ? error.message : String(error)); }
       try {
         const report = await prepareRemoteRunner(runner, signal);
         if (!report.ready) {
           const reason = `Runner is reachable but is missing required capabilities: ${report.missing.join(", ")}. Install them through provider bootstrap/cloud-init, then retry.`;
           runtime.runnerFailure(activeState, "runner-prepare", reason);
-          return terraformError(reason);
+          return toolError(reason);
         }
-        return terraformOk(`Runner ${runner.name} is ready.\n${report.terraformVersion || "Terraform available"}`, { runner: remoteTargetSummary(runner), capabilities: report });
+        return toolOk(`Runner ${runner.name} is ready.\n${report.terraformVersion || "Terraform available"}`, { runner: remoteTargetSummary(runner), capabilities: report });
       } catch (error) {
         const reason = error instanceof Error ? error.message : String(error);
         runtime.runnerFailure(activeState, "runner-prepare", reason);
-        return terraformError(`Runner preparation failed:\n${truncateOutput(reason)}`);
+        return toolError(`Runner preparation failed:\n${truncateOutput(reason)}`);
       }
     },
   }));
@@ -98,32 +99,32 @@ export function registerCloudRunnerTools(pi: ExtensionAPI, runtime: CloudExtensi
     async execute(_id, params, signal, _onUpdate, ctx) {
       const activeState = runtime.restore(ctx);
       const blocked = runtime.blocked(activeState);
-      if (!activeState || blocked) return terraformError(blocked ?? "HWCode Cloud is not active.");
+      if (!activeState || blocked) return toolError(blocked ?? "HWCode Cloud is not active.");
       let runner: RemoteTargetProfile;
-      try { runner = runtime.requireRunner(activeState); } catch (error) { return terraformError(error instanceof Error ? error.message : String(error)); }
+      try { runner = runtime.requireRunner(activeState); } catch (error) { return toolError(error instanceof Error ? error.message : String(error)); }
       const sourcePath = isAbsolute(params.sourcePath) ? resolve(params.sourcePath) : resolve(activeState.root, params.sourcePath);
       const trustedBundlePath = cloudDetails(activeState)!.terraformSourcePath ? resolve(cloudDetails(activeState)!.terraformSourcePath!) : undefined;
       const outside = relative(activeState.root, sourcePath).startsWith("..") || isAbsolute(relative(activeState.root, sourcePath));
-      if (outside && sourcePath !== trustedBundlePath) return terraformError("Terraform sourcePath must be inside the locked project root, except for the exact selected local Deployment Template bundle.");
-      if (!existsSync(sourcePath) || !statSync(sourcePath).isDirectory()) return terraformError("Terraform sourcePath must be an existing directory.");
+      if (outside && sourcePath !== trustedBundlePath) return toolError("Terraform sourcePath must be inside the locked project root, except for the exact selected local Terraform Template bundle.");
+      if (!existsSync(sourcePath) || !statSync(sourcePath).isDirectory()) return toolError("Terraform sourcePath must be an existing directory.");
       let workspace;
       try { workspace = createRemoteRunWorkspace(sourcePath, runner.remoteRoot); }
-      catch (error) { return terraformError(`Terraform source manifest rejected this bundle:\n${error instanceof Error ? error.message : String(error)}`); }
+      catch (error) { return toolError(`Terraform source manifest rejected this bundle:\n${error instanceof Error ? error.message : String(error)}`); }
       const files = workspace.files.filter((file) => isTerraformSourceFile(file.relativePath)).map((file) => ({ relativePath: file.relativePath, content: readFileSync(resolve(sourcePath, file.relativePath), "utf8") }));
       try { assertSafeTerraformSource(files, { requireRemoteBackend: true }); }
-      catch (error) { return terraformError(`Terraform source policy rejected this bundle:\n${error instanceof Error ? error.message : String(error)}`); }
+      catch (error) { return toolError(`Terraform source policy rejected this bundle:\n${error instanceof Error ? error.message : String(error)}`); }
       try { await syncRemoteWorkspace(runner, sourcePath, workspace, signal); }
       catch (error) {
         const reason = error instanceof Error ? error.message : String(error);
         runtime.runnerFailure(activeState, "terraform-runner-sync", reason);
-        return terraformError(`Terraform sync failed:\n${truncateOutput(reason)}`);
+        return toolError(`Terraform sync failed:\n${truncateOutput(reason)}`);
       }
       const run: TerraformRunState = {
         runId: workspace.runId, runnerId: runner.id, phase: "synced", sourceDigest: workspace.sourceDigest,
         sourcePath, remoteWorkspace: workspace.remotePath, startedAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
       };
       runtime.replaceDetails(activeState, { ...cloudDetails(activeState)!, terraformRun: run }, "executing");
-      return terraformOk(`Terraform source synced. runId=${run.runId}\nsourceDigest=${run.sourceDigest}\nremoteWorkspace=${run.remoteWorkspace}`, { runId: run.runId, sourceDigest: run.sourceDigest });
+      return toolOk(`Terraform source synced. runId=${run.runId}\nsourceDigest=${run.sourceDigest}\nremoteWorkspace=${run.remoteWorkspace}`, { runId: run.runId, sourceDigest: run.sourceDigest });
     },
   }));
 }

package/.pi/extensions/workflows/cloud/runtime.ts

@@ -9,8 +9,10 @@ import type { CloudCredentials, CloudOperation } from "../../../lib/workflows/cl
 import type { RemoteTargetProfile } from "../../../lib/workflows/cloud/remote/profiles.ts";
 import { createEmptyVault } from "../../../lib/workflows/cloud/vault.ts";
 import { CLOUD_RUNTIME_DEFAULTS } from "../../../lib/runtime/defaults.ts";
-import { updateWorkflowState, type CloudWorkflowDetails, type TerraformRunState, type WorkflowState } from "../../../lib/workflows/state.ts";
-import { appendWorkflowState, cloudDetails, restoreCloudWorkflow } from "./shared.ts";
+import {
+  WORKFLOW_STATE_TYPE, activeWorkflow, cloudDetails, updateWorkflowState,
+  type CloudWorkflowDetails, type TerraformRunState, type WorkflowState,
+} from "../../../lib/workflows/state.ts";
 
 export interface ActiveCloudVault {
   password: string;
@@ -26,6 +28,7 @@ export class CloudExtensionRuntime {
   activeVault?: ActiveCloudVault;
   readonly temporaryStore: TemporaryCredentialStore;
   private readonly credentialDirectories = new Set<string>();
+  private approvalQueue = Promise.resolve();
 
   constructor(pi: ExtensionAPI) {
     this.pi = pi;
@@ -43,7 +46,8 @@ export class CloudExtensionRuntime {
   }
 
   restore(ctx: ExtensionContext): WorkflowState | undefined {
-    this.activeState = restoreCloudWorkflow(ctx);
+    const state = activeWorkflow(ctx.sessionManager.getEntries());
+    this.activeState = state?.mode === "cloud" && state.details ? state : undefined;
     return this.activeState;
   }
 
@@ -61,10 +65,43 @@ export class CloudExtensionRuntime {
   replaceDetails(state: WorkflowState, details: CloudWorkflowDetails, phase = state.phase): WorkflowState {
     const updated = updateWorkflowState(state, { details, phase });
     this.activeState = updated;
-    appendWorkflowState(this.pi, updated);
+    this.pi.appendEntry<WorkflowState>(WORKFLOW_STATE_TYPE, updated);
     return updated;
   }
 
+  async approveOperation(
+    operation: CloudOperation,
+    params: { command: string; args: string[]; intent: string },
+    state: WorkflowState,
+    ctx: ExtensionContext,
+  ): Promise<"allow" | "allow-session" | "deny"> {
+    if (operation === "read") return "allow";
+    if (!ctx.hasUI) return "deny";
+    const next = this.approvalQueue.then(async () => {
+      const details = cloudDetails(state)!;
+      const command = `${params.command} ${params.args.join(" ")}`;
+      if (operation === "delete") {
+        const approved = await ctx.ui.confirm(
+          "确认删除云资源？",
+          `目标：${params.intent}\n命令：${command}\n\n删除操作始终逐次确认。`,
+        );
+        return approved ? "allow" as const : "deny" as const;
+      }
+      if (details.allowNonDeleteChanges) return "allow" as const;
+      const choice = await ctx.ui.select("允许修改云账号内资源？", [
+        "仅允许本次",
+        "允许本会话后续非删除变更，不再询问",
+        "拒绝",
+      ]);
+      if (choice === "仅允许本次") return "allow" as const;
+      if (choice === "允许本会话后续非删除变更，不再询问") return "allow-session" as const;
+      return "deny" as const;
+    });
+
+    this.approvalQueue = next.then(() => {}, () => {});
+    return await next;
+  }
+
   terraformRun(state: WorkflowState): TerraformRunState | undefined {
     return cloudDetails(state)?.terraformRun;
   }

package/.pi/extensions/workflows/cloud/terraform-tools.ts

@@ -2,6 +2,7 @@ import { Type } from "@earendil-works/pi-ai";
 import { defineTool, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 import { CLOUD_RUNTIME_DEFAULTS } from "../../../lib/runtime/defaults.ts";
+import { toolError, toolOk } from "../../../lib/tool-result.ts";
 import type { CloudOperation } from "../../../lib/workflows/cloud/providers.ts";
 import type { RemoteTargetProfile } from "../../../lib/workflows/cloud/remote/profiles.ts";
 import {
@@ -11,8 +12,11 @@ import {
 import { digestTerraformPlan, executeTerraformRunner } from "../../../lib/workflows/cloud/terraform/runner.ts";
 import { cloudExecutionBlockReason } from "../../../lib/workflows/cloud/execution.ts";
 import { truncateOutput } from "../../../lib/workflows/cloud/process.ts";
+import {
+  cloudTerraformTemplateSource, persistAppliedTerraformArtifact,
+} from "../../../lib/workflows/cloud/bundles.ts";
+import { cloudDetails } from "../../../lib/workflows/state.ts";
 import type { CloudExtensionRuntime } from "./runtime.ts";
-import { approveOperation, cloudDetails, terraformError, terraformOk } from "./shared.ts";
 
 const PLAN_FILE = CLOUD_RUNTIME_DEFAULTS.terraform.planFile;
 
@@ -25,21 +29,21 @@ export function registerCloudTerraformTools(pi: ExtensionAPI, runtime: CloudExte
     async execute(_id, params, signal, _onUpdate, ctx) {
       const activeState = runtime.restore(ctx);
       const blocked = runtime.blocked(activeState);
-      if (!activeState || blocked) return terraformError(blocked ?? "HWCode Cloud is not active.");
+      if (!activeState || blocked) return toolError(blocked ?? "HWCode Cloud is not active.");
       const run = runtime.terraformRun(activeState);
-      if (!run || run.runId !== params.runId || run.phase !== "synced") return terraformError("Terraform validate requires a newly synced run.");
+      if (!run || run.runId !== params.runId || run.phase !== "synced") return toolError("Terraform validate requires a newly synced run.");
       let runner: RemoteTargetProfile;
-      try { runner = runtime.requireRunner(activeState); } catch (error) { return terraformError(error instanceof Error ? error.message : String(error)); }
+      try { runner = runtime.requireRunner(activeState); } catch (error) { return toolError(error instanceof Error ? error.message : String(error)); }
       for (const action of ["fmt", "init", "validate", "test"] as const) {
         const result = await executeTerraformRunner(runner, { action, workspace: run.remoteWorkspace }, { signal });
         if (result.code !== 0) {
           runtime.runnerFailure(activeState, `terraform-${action}`, result.stderr || result.stdout || `exit code ${result.code}`);
-          return terraformError(`terraform ${action} failed:\n${truncateOutput(result.stderr || result.stdout)}`);
+          return toolError(`terraform ${action} failed:\n${truncateOutput(result.stderr || result.stdout)}`);
         }
       }
       runtime.replaceDetails(activeState, { ...cloudDetails(activeState)!, terraformRun: { ...run, phase: "validated", updatedAt: new Date().toISOString() } }, "executing");
       runtime.recordTerraformSuccess(runtime.activeState!, ["fmt", "init", "validate", "test"], "read", "Validate Terraform source and tests", "terraform-runner");
-      return terraformOk("Terraform fmt/init/validate/test completed successfully.", { runId: run.runId });
+      return toolOk("Terraform fmt/init/validate/test completed successfully.", { runId: run.runId });
     },
   }));
 
@@ -51,22 +55,22 @@ export function registerCloudTerraformTools(pi: ExtensionAPI, runtime: CloudExte
     async execute(_id, params, signal, _onUpdate, ctx) {
       const activeState = runtime.restore(ctx);
       const blocked = runtime.blocked(activeState);
-      if (!activeState || blocked) return terraformError(blocked ?? "HWCode Cloud is not active.");
+      if (!activeState || blocked) return toolError(blocked ?? "HWCode Cloud is not active.");
       const run = runtime.terraformRun(activeState);
-      if (!run || run.runId !== params.runId || run.phase !== "validated") return terraformError("Terraform plan requires a validated run.");
+      if (!run || run.runId !== params.runId || run.phase !== "validated") return toolError("Terraform plan requires a validated run.");
       let runner: RemoteTargetProfile;
-      try { runner = runtime.requireRunner(activeState); } catch (error) { return terraformError(error instanceof Error ? error.message : String(error)); }
+      try { runner = runtime.requireRunner(activeState); } catch (error) { return toolError(error instanceof Error ? error.message : String(error)); }
       const planned = await executeTerraformRunner(runner, { action: "plan", workspace: run.remoteWorkspace, mode: params.mode }, { signal });
-      if (planned.code !== 0) { runtime.runnerFailure(activeState, `terraform-plan-${params.mode}`, planned.stderr || planned.stdout || `exit code ${planned.code}`); return terraformError(`terraform plan failed:\n${truncateOutput(planned.stderr || planned.stdout)}`); }
+      if (planned.code !== 0) { runtime.runnerFailure(activeState, `terraform-plan-${params.mode}`, planned.stderr || planned.stdout || `exit code ${planned.code}`); return toolError(`terraform plan failed:\n${truncateOutput(planned.stderr || planned.stdout)}`); }
       const inspected = await executeTerraformRunner(runner, { action: "show-plan", workspace: run.remoteWorkspace, planPath: PLAN_FILE }, { signal });
-      if (inspected.code !== 0) { runtime.runnerFailure(activeState, "terraform-show-plan", inspected.stderr || inspected.stdout); return terraformError(`terraform show plan failed:\n${truncateOutput(inspected.stderr || inspected.stdout)}`); }
+      if (inspected.code !== 0) { runtime.runnerFailure(activeState, "terraform-show-plan", inspected.stderr || inspected.stdout); return toolError(`terraform show plan failed:\n${truncateOutput(inspected.stderr || inspected.stdout)}`); }
       let summary;
       try { summary = classifyTerraformPlan(JSON.parse(inspected.stdout)); }
-      catch (error) { const reason = error instanceof Error ? error.message : String(error); runtime.runnerFailure(activeState, "terraform-parse-plan", reason); return terraformError(`Unable to parse Terraform plan JSON: ${reason}`); }
+      catch (error) { const reason = error instanceof Error ? error.message : String(error); runtime.runnerFailure(activeState, "terraform-parse-plan", reason); return toolError(`Unable to parse Terraform plan JSON: ${reason}`); }
       const planDigest = digestTerraformPlan(inspected.stdout);
       runtime.replaceDetails(activeState, { ...cloudDetails(activeState)!, terraformRun: { ...run, phase: "planned", planDigest, planSummary: summary, updatedAt: new Date().toISOString() } }, "executing");
       runtime.recordTerraformSuccess(runtime.activeState!, ["plan", params.mode], "read", `Create reviewed Terraform ${params.mode} plan`, "terraform-runner");
-      return terraformOk(`${terraformPlanSummaryText(summary)}\nplanDigest=${planDigest}`, { runId: run.runId, planDigest, requiresApproval: terraformPlanRequiresApproval(summary), hasDeletion: terraformPlanHasDeletion(summary), summary });
+      return toolOk(`${terraformPlanSummaryText(summary)}\nplanDigest=${planDigest}`, { runId: run.runId, planDigest, requiresApproval: terraformPlanRequiresApproval(summary), hasDeletion: terraformPlanHasDeletion(summary), summary });
     },
   }));
 
@@ -78,27 +82,36 @@ export function registerCloudTerraformTools(pi: ExtensionAPI, runtime: CloudExte
     async execute(_id, params, signal, _onUpdate, ctx) {
       let activeState = runtime.restore(ctx);
       const blocked = runtime.blocked(activeState);
-      if (!activeState || blocked) return terraformError(blocked ?? "HWCode Cloud is not active.");
+      if (!activeState || blocked) return toolError(blocked ?? "HWCode Cloud is not active.");
       const run = runtime.terraformRun(activeState);
-      if (!run || run.runId !== params.runId || run.phase !== "planned" || run.planDigest !== params.planDigest) return terraformError("Plan digest mismatch or no planned run is ready. Re-plan before apply.");
+      if (!run || run.runId !== params.runId || run.phase !== "planned" || run.planDigest !== params.planDigest) return toolError("Plan digest mismatch or no planned run is ready. Re-plan before apply.");
       let runner: RemoteTargetProfile;
-      try { runner = runtime.requireRunner(activeState); } catch (error) { return terraformError(error instanceof Error ? error.message : String(error)); }
+      try { runner = runtime.requireRunner(activeState); } catch (error) { return toolError(error instanceof Error ? error.message : String(error)); }
       const currentPlan = await executeTerraformRunner(runner, { action: "show-plan", workspace: run.remoteWorkspace, planPath: PLAN_FILE }, { signal });
-      if (currentPlan.code !== 0) { runtime.runnerFailure(activeState, "terraform-reverify-plan", currentPlan.stderr || currentPlan.stdout); return terraformError(`Unable to re-verify the managed Terraform plan:\n${truncateOutput(currentPlan.stderr || currentPlan.stdout)}`); }
+      if (currentPlan.code !== 0) { runtime.runnerFailure(activeState, "terraform-reverify-plan", currentPlan.stderr || currentPlan.stdout); return toolError(`Unable to re-verify the managed Terraform plan:\n${truncateOutput(currentPlan.stderr || currentPlan.stdout)}`); }
       const currentDigest = digestTerraformPlan(currentPlan.stdout);
-      if (currentDigest !== run.planDigest || currentDigest !== params.planDigest) { runtime.runnerFailure(activeState, "terraform-plan-integrity", "remote plan digest changed after review"); return terraformError("The remote Terraform plan changed after review. Apply is blocked; create and review a new plan."); }
+      if (currentDigest !== run.planDigest || currentDigest !== params.planDigest) { runtime.runnerFailure(activeState, "terraform-plan-integrity", "remote plan digest changed after review"); return toolError("The remote Terraform plan changed after review. Apply is blocked; create and review a new plan."); }
       let currentSummary;
       try { currentSummary = classifyTerraformPlan(JSON.parse(currentPlan.stdout)); }
-      catch (error) { const reason = error instanceof Error ? error.message : String(error); runtime.runnerFailure(activeState, "terraform-parse-current-plan", reason); return terraformError(`Unable to parse the current Terraform plan: ${reason}`); }
+      catch (error) { const reason = error instanceof Error ? error.message : String(error); runtime.runnerFailure(activeState, "terraform-parse-current-plan", reason); return toolError(`Unable to parse the current Terraform plan: ${reason}`); }
       const operation: CloudOperation = terraformPlanHasDeletion(currentSummary) ? "delete" : terraformPlanRequiresApproval(currentSummary) ? "change" : "read";
-      const approval = await approveOperation(operation, { command: "terraform", args: ["apply", PLAN_FILE], intent: params.intent }, activeState, ctx);
-      if (approval === "deny") return terraformError("User denied Terraform apply.");
+      const approval = await runtime.approveOperation(operation, { command: "terraform", args: ["apply", PLAN_FILE], intent: params.intent }, activeState, ctx);
+      if (approval === "deny") return toolError("User denied Terraform apply.");
       if (approval === "allow-session") activeState = runtime.replaceDetails(activeState, { ...cloudDetails(activeState)!, allowNonDeleteChanges: true });
       const result = await executeTerraformRunner(runner, { action: "apply", workspace: run.remoteWorkspace, planPath: PLAN_FILE }, { signal });
-      if (result.code !== 0) { runtime.runnerFailure(activeState, "terraform-apply", result.stderr || result.stdout || `exit code ${result.code}`); return terraformError(`terraform apply failed:\n${truncateOutput(result.stderr || result.stdout)}`); }
+      if (result.code !== 0) { runtime.runnerFailure(activeState, "terraform-apply", result.stderr || result.stdout || `exit code ${result.code}`); return toolError(`terraform apply failed:\n${truncateOutput(result.stderr || result.stdout)}`); }
       runtime.replaceDetails(activeState, { ...cloudDetails(activeState)!, terraformRun: { ...run, phase: "applied", planSummary: currentSummary, updatedAt: new Date().toISOString() } }, "executing");
-      runtime.recordTerraformSuccess(runtime.activeState!, ["apply", PLAN_FILE], operation, params.intent, "terraform-runner");
-      return terraformOk(`Terraform apply completed.\n${truncateOutput(result.stdout).trim()}`, { runId: run.runId, planDigest: params.planDigest });
+      const appliedState = runtime.recordTerraformSuccess(runtime.activeState!, ["apply", PLAN_FILE], operation, params.intent, "terraform-runner");
+      const appliedDetails = cloudDetails(appliedState)!;
+      let templateMessage = "";
+      try {
+        const artifact = persistAppliedTerraformArtifact(appliedState, run.sourcePath!, appliedDetails.artifactDirectory);
+        runtime.replaceDetails(appliedState, { ...appliedDetails, sourceTemplate: cloudTerraformTemplateSource(artifact.template) });
+        templateMessage = `\nTerraform artifact ${artifact.action}: ${artifact.template.manifest.name}`;
+      } catch (error) {
+        templateMessage = `\nTerraform apply succeeded, but the local artifact snapshot failed: ${error instanceof Error ? error.message : String(error)}`;
+      }
+      return toolOk(`Terraform apply completed.\n${truncateOutput(result.stdout).trim()}${templateMessage}`, { runId: run.runId, planDigest: params.planDigest });
     },
   }));
 
@@ -110,17 +123,17 @@ export function registerCloudTerraformTools(pi: ExtensionAPI, runtime: CloudExte
     async execute(_id, params, signal, _onUpdate, ctx) {
       const activeState = runtime.restore(ctx);
       const blocked = cloudExecutionBlockReason(activeState, { allowAfterTerminalFailure: true });
-      if (!activeState || blocked) return terraformError(blocked ?? "HWCode Cloud is not active.");
+      if (!activeState || blocked) return toolError(blocked ?? "HWCode Cloud is not active.");
       const run = runtime.terraformRun(activeState);
-      if (!run || run.runId !== params.runId || !["planned", "applied"].includes(run.phase)) return terraformError("Terraform status requires a planned or applied run.");
+      if (!run || run.runId !== params.runId || !["planned", "applied"].includes(run.phase)) return toolError("Terraform status requires a planned or applied run.");
       let runner: RemoteTargetProfile;
-      try { runner = runtime.requireRunner(activeState); } catch (error) { return terraformError(error instanceof Error ? error.message : String(error)); }
+      try { runner = runtime.requireRunner(activeState); } catch (error) { return toolError(error instanceof Error ? error.message : String(error)); }
       const result = await executeTerraformRunner(runner, { action: "show-state", workspace: run.remoteWorkspace }, { signal });
-      if (result.code !== 0) { runtime.runnerFailure(activeState, "terraform-state", result.stderr || result.stdout); return terraformError(`terraform state inspection failed:\n${truncateOutput(result.stderr || result.stdout)}`); }
+      if (result.code !== 0) { runtime.runnerFailure(activeState, "terraform-state", result.stderr || result.stdout); return toolError(`terraform state inspection failed:\n${truncateOutput(result.stderr || result.stdout)}`); }
       let summary;
       try { summary = summarizeTerraformState(JSON.parse(result.stdout)); }
-      catch (error) { return terraformError(`Unable to summarize Terraform state safely: ${error instanceof Error ? error.message : String(error)}`); }
-      return terraformOk(`Terraform state contains ${summary.resourceCount} managed resources.\n${Object.entries(summary.resourceTypes).map(([type, count]) => `${type}: ${count}`).join("\n") || "No managed resources."}`, { runId: run.runId, summary });
+      catch (error) { return toolError(`Unable to summarize Terraform state safely: ${error instanceof Error ? error.message : String(error)}`); }
+      return toolOk(`Terraform state contains ${summary.resourceCount} managed resources.\n${Object.entries(summary.resourceTypes).map(([type, count]) => `${type}: ${count}`).join("\n") || "No managed resources."}`, { runId: run.runId, summary });
     },
   }));
 }

package/.pi/extensions/workflows/sdd.ts

@@ -6,6 +6,7 @@ import { Type } from "@earendil-works/pi-ai";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { isAbsolute, relative, resolve } from "node:path";
 
+import { notify } from "../../lib/extension-ui.ts";
 import {
 	canonicalizeWorkspaceRoot,
 } from "../../lib/workflow-guard.ts";
@@ -19,7 +20,7 @@ import {
 } from "../../lib/workflows/state.ts";
 import { advanceSddProgress, SDD_PHASES } from "../../lib/workflows/sdd.ts";
 import { PROJECT_SDD_SPECS_RELATIVE } from "../../lib/runtime/paths.ts";
-import { confirmWorkspace, modeLabel, notify } from "./workspace-guard.ts";
+import { confirmWorkspace, modeLabel } from "./workspace-guard.ts";
 
 interface GitState {
 	initialized: boolean;

package/.pi/extensions/workflows/vibe.ts

@@ -2,6 +2,7 @@ import type {
 	ExtensionAPI,
 } from "@earendil-works/pi-coding-agent";
 
+import { notify } from "../../lib/extension-ui.ts";
 import {
 	canonicalizeWorkspaceRoot,
 } from "../../lib/workflow-guard.ts";
@@ -12,7 +13,7 @@ import {
 	createWorkflowState,
 	type WorkflowState,
 } from "../../lib/workflows/state.ts";
-import { confirmWorkspace, modeLabel, notify } from "./workspace-guard.ts";
+import { confirmWorkspace, modeLabel } from "./workspace-guard.ts";
 
 export function registerVibeWorkflow(pi: ExtensionAPI) {
 	pi.registerCommand("hwcode-vibe", {

package/.pi/extensions/workflows/workspace-guard.ts

@@ -1,9 +1,9 @@
 import type {
 	ExtensionAPI,
 	ExtensionCommandContext,
-	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 
+import { notify } from "../../lib/extension-ui.ts";
 import {
 	canonicalizeWorkspaceRoot,
 } from "../../lib/workflow-guard.ts";
@@ -23,10 +23,6 @@ export function modeLabel(mode: WorkflowMode): string {
 	return workflowLabel(mode);
 }
 
-export function notify(ctx: ExtensionContext, message: string, level: "info" | "warning" | "error" = "info"): void {
-	if (ctx.hasUI) ctx.ui.notify(message, level);
-}
-
 export async function confirmWorkspace(mode: WorkflowMode, root: string, ctx: ExtensionCommandContext): Promise<boolean> {
 	if (!ctx.hasUI) return false;
 	return ctx.ui.confirm(

package/.pi/lib/extension-ui.ts

@@ -0,0 +1,52 @@
+import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { CURSOR_MARKER, Input, type Component, type TUI } from "@earendil-works/pi-tui";
+
+class MaskedInput implements Component {
+  private readonly input = new Input();
+  private _focused = true;
+  private readonly tui: TUI;
+  private readonly theme: Theme;
+  private readonly title: string;
+
+  constructor(
+    tui: TUI,
+    theme: Theme,
+    title: string,
+    done: (value: string | undefined) => void,
+  ) {
+    this.tui = tui;
+    this.theme = theme;
+    this.title = title;
+    this.input.onSubmit = (value) => done(value);
+    this.input.onEscape = () => done(undefined);
+    this.input.focused = true;
+  }
+
+  get focused(): boolean { return this._focused; }
+  set focused(value: boolean) { this._focused = value; this.input.focused = value; }
+  handleInput(data: string): void { this.input.handleInput(data); this.tui.requestRender(); }
+  invalidate(): void { this.input.invalidate(); }
+  render(width: number): string[] {
+    const masked = "•".repeat(Math.min(Array.from(this.input.getValue()).length, Math.max(1, width - 1)));
+    return [
+      this.theme.fg("accent", this.title),
+      `${masked}${CURSOR_MARKER}`,
+      this.theme.fg("dim", "Enter 确认 · Esc 取消 · 输入内容不会显示"),
+    ];
+  }
+}
+
+export function notify(
+  ctx: ExtensionContext,
+  message: string,
+  level: "info" | "warning" | "error" = "info",
+): void {
+  if (ctx.hasUI) ctx.ui.notify(message, level);
+}
+
+export async function secretInput(ctx: ExtensionContext, title: string): Promise<string | undefined> {
+  if (ctx.mode !== "tui") return undefined;
+  return ctx.ui.custom<string | undefined>((tui, theme, _keybindings, done) => (
+    new MaskedInput(tui, theme, title, done)
+  ));
+}