@linghun/tui 0.1.0

package/dist/chunk-DDXS2RDZ.js

@@ -0,0 +1,228 @@
+import {
+  collectInputFiles,
+  findPermissionRule,
+  formatPermissionSummary,
+  getHardDenyReason,
+  isPlanAllowedTool
+} from "./chunk-J7ZE2JKP.js";
+import {
+  classifyToolRequest
+} from "./chunk-LHHKPGLX.js";
+
+// src/tui-permission-runtime.ts
+import { randomUUID } from "crypto";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { builtInTools } from "@linghun/tools";
+async function addAllowRule(context, toolName, risk) {
+  if (toolName !== "*" && !(toolName in builtInTools)) {
+    return { kind: "invalid", message: `\u672A\u77E5\u5DE5\u5177\uFF1A${toolName}` };
+  }
+  const existing = context.permissions.rules.find((r) => {
+    if (r.effect !== "allow") return false;
+    if (r.toolName !== toolName && r.toolName !== "*") return false;
+    if (r.risk && r.risk !== risk) return false;
+    return true;
+  });
+  if (existing) {
+    return {
+      kind: "duplicate",
+      rule: existing,
+      message: `\u5DF2\u5B58\u5728\u7B49\u4EF7 allow \u89C4\u5219\uFF1A${existing.id} allow ${existing.toolName}${existing.risk ? ` ${existing.risk}` : ""}`
+    };
+  }
+  const rule = { id: randomUUID(), effect: "allow", toolName, risk };
+  context.permissions.rules.push(rule);
+  try {
+    await savePermissionState(context.projectPath, context.permissions);
+  } catch (error) {
+    context.permissions.rules = context.permissions.rules.filter((r) => r.id !== rule.id);
+    return {
+      kind: "save_failed",
+      error,
+      message: `\u4FDD\u5B58\u6743\u9650\u89C4\u5219\u5931\u8D25\uFF1A${error.message}`
+    };
+  }
+  return {
+    kind: "added",
+    rule,
+    message: `\u5DF2\u6DFB\u52A0\u6743\u9650\u89C4\u5219\uFF1A${rule.id} allow ${toolName}${risk ? ` ${risk}` : ""}`
+  };
+}
+function toPermissionPromptView(permission) {
+  return {
+    toolName: permission.request.toolName,
+    decision: permission.decision,
+    risk: permission.request.risk,
+    mode: permission.request.mode,
+    reason: permission.reason,
+    scope: permission.request.files
+  };
+}
+async function decidePermission(name, input, context, _sessionId) {
+  const tool = builtInTools[name];
+  const files = collectInputFiles(input);
+  const toolPermission = (() => {
+    try {
+      return tool.checkPermissions(tool.validateInput(input), context.tools);
+    } catch {
+      return {
+        behavior: "passthrough",
+        reason: "tool input validation is handled by the tool runtime"
+      };
+    }
+  })();
+  const hardDeny = getHardDenyReason(name, input, files, context.projectPath);
+  const request = {
+    id: randomUUID(),
+    toolName: name,
+    mode: context.permissionMode,
+    risk: tool.permission.risk,
+    summary: formatPermissionSummary(name, files, tool.permission.risk),
+    files,
+    reason: tool.permission.reason
+  };
+  if (hardDeny) {
+    await recordPermissionDenied(context, name, hardDeny);
+    return { request, decision: "deny", reason: hardDeny };
+  }
+  if (toolPermission.behavior === "deny") {
+    await recordPermissionDenied(context, name, toolPermission.reason);
+    return { request, decision: "deny", reason: toolPermission.reason };
+  }
+  if (toolPermission.behavior === "allow") {
+    return { request, decision: "allow", reason: toolPermission.reason };
+  }
+  const verdict = classifyToolRequest({
+    toolName: name,
+    input,
+    workspaceRoot: context.projectPath
+  });
+  const schedulerDecision = context.lastMetaSchedulerDecision;
+  if (schedulerDecision?.policyDecision.permissionPlan.requireExplicitGate && verdict.semantic === "mutating") {
+    if (context.permissionMode === "default" || context.permissionMode === "full-access") {
+      return {
+        request,
+        decision: "ask",
+        reason: context.language === "en-US" ? "Scheduler expects mutating actions this turn; confirmation required." : "\u8C03\u5EA6\u5668\u9884\u6D4B\u672C\u8F6E\u6709\u5199\u5165\u64CD\u4F5C\uFF0C\u9700\u8981\u786E\u8BA4\u3002",
+        verdict
+      };
+    }
+  }
+  if (context.permissionMode !== "plan" && context.permissionMode !== "auto-review") {
+    if (verdict.decision === "auto_allow_readonly") {
+      const existingRule = findPermissionRule(context.permissions.rules, name, tool.permission.risk);
+      if (!existingRule) {
+        return {
+          request,
+          decision: "allow",
+          reason: `policy auto_allow_readonly: ${verdict.reason}`,
+          autoAllowReadonly: verdict,
+          verdict
+        };
+      }
+    }
+  }
+  if (context.permissionMode === "plan") {
+    if (isPlanAllowedTool(name, tool.isReadOnly)) {
+      return { request, decision: "allow", reason: "Plan \u6A21\u5F0F\u5141\u8BB8\u53EA\u8BFB\u6216\u4F1A\u8BDD\u5185\u89C4\u5212\u5DE5\u5177\u3002", verdict };
+    }
+    const reason2 = "Plan \u6A21\u5F0F\u7981\u6B62\u5199\u5165\u3001\u7F16\u8F91\u548C Bash \u6267\u884C\uFF1B\u8BF7\u5148 /plan accept \u786E\u8BA4\u65B9\u6848\u5E76\u5207\u56DE\u6267\u884C\u6A21\u5F0F\u3002";
+    await recordPermissionDenied(context, name, reason2);
+    return { request, decision: "deny", reason: reason2, verdict };
+  }
+  const rule = findPermissionRule(context.permissions.rules, name, tool.permission.risk);
+  if (rule) {
+    if (rule.effect === "deny") {
+      const reason2 = "\u547D\u4E2D\u62D2\u7EDD\u89C4\u5219\u3002";
+      await recordPermissionDenied(context, name, reason2);
+      return { request, decision: "deny", reason: reason2, verdict };
+    }
+    if (rule.effect === "ask") {
+      const reason2 = "\u547D\u4E2D\u9700\u786E\u8BA4\u89C4\u5219\u3002\u9700\u8981\u7528\u6237\u786E\u8BA4\u540E\u624D\u4F1A\u6267\u884C\u672C\u6B21\u5DE5\u5177\u3002";
+      await recordPermissionDenied(context, name, reason2);
+      return { request, decision: "ask", reason: reason2, verdict };
+    }
+    return { request, decision: "allow", reason: "\u547D\u4E2D\u5141\u8BB8\u89C4\u5219\u3002", verdict };
+  }
+  if (context.permissionMode === "auto-review") {
+    if (verdict.decision === "auto_allow_readonly") {
+      return {
+        request,
+        decision: "allow",
+        reason: `auto-review \u653E\u884C\u5B89\u5168\u53EA\u8BFB\u52A8\u4F5C\uFF1A${verdict.reason}`,
+        autoAllowReadonly: verdict,
+        verdict
+      };
+    }
+    if (tool.permission.risk === "high") {
+      const reason3 = "auto-review \u5DF2\u653E\u884C\u5E38\u89C4\u64CD\u4F5C\uFF0C\u4F46\u672C\u6B21\u52A8\u4F5C\u6D89\u53CA\u9AD8\u98CE\u9669\uFF0C\u9700\u786E\u8BA4\u3002";
+      return { request, decision: "ask", reason: reason3, verdict };
+    }
+    const reason2 = "auto-review \u653E\u884C\u975E\u9AD8\u98CE\u9669\u64CD\u4F5C\u3002";
+    return {
+      request,
+      decision: "allow",
+      reason: reason2,
+      verdict
+    };
+  }
+  if (context.permissionMode === "full-access") {
+    return {
+      request,
+      decision: "allow",
+      reason: "full-access \u5DF2\u7531\u672C\u5730\u7528\u6237\u663E\u5F0F\u5F00\u542F\uFF0C\u4F46\u786C\u62D2\u7EDD\u548C\u5B89\u5168\u8DEF\u5F84\u4ECD\u751F\u6548\u3002",
+      verdict
+    };
+  }
+  if (tool.isReadOnly || name === "Todo" || name === "Diff") {
+    return { request, decision: "allow", reason: "default \u6A21\u5F0F\u5141\u8BB8\u53EA\u8BFB\u6216\u4F1A\u8BDD\u5185\u5DE5\u5177\u3002", verdict };
+  }
+  const reason = "default \u6A21\u5F0F\u4E0D\u4F1A\u9759\u9ED8\u6267\u884C Bash\u3001\u5199\u5165\u3001\u7F16\u8F91\u3001\u5220\u9664\u3001\u914D\u7F6E\u3001\u5B89\u88C5\u3001\u8054\u7F51\u6216\u6743\u9650\u53D8\u66F4\uFF1B\u9700\u8981\u7528\u6237\u786E\u8BA4\u540E\u624D\u4F1A\u6267\u884C\u672C\u6B21\u5DE5\u5177\u3002";
+  await recordPermissionDenied(context, name, reason);
+  return { request, decision: "ask", reason, verdict };
+}
+async function recordPermissionDenied(context, toolName, reason) {
+  context.permissions.recentDenied.unshift({
+    id: randomUUID(),
+    toolName,
+    mode: context.permissionMode,
+    reason,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  context.permissions.recentDenied = context.permissions.recentDenied.slice(0, 20);
+  await savePermissionState(context.projectPath, context.permissions);
+}
+async function loadPermissionState(projectPath) {
+  try {
+    const raw = await readFile(permissionStatePath(projectPath), "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      rules: Array.isArray(parsed.rules) ? parsed.rules : [],
+      recentDenied: Array.isArray(parsed.recentDenied) ? parsed.recentDenied : []
+    };
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { rules: [], recentDenied: [] };
+    }
+    throw error;
+  }
+}
+async function savePermissionState(projectPath, state) {
+  await mkdir(join(projectPath, ".linghun"), { recursive: true });
+  await writeFile(permissionStatePath(projectPath), `${JSON.stringify(state, null, 2)}
+`, "utf8");
+}
+function permissionStatePath(projectPath) {
+  return join(projectPath, ".linghun", "permissions.json");
+}
+
+export {
+  addAllowRule,
+  toPermissionPromptView,
+  decidePermission,
+  recordPermissionDenied,
+  loadPermissionState,
+  savePermissionState,
+  permissionStatePath
+};

package/dist/chunk-DICVLZHH.js

@@ -0,0 +1,144 @@
+// src/shell/terminal-capability.ts
+import { release as osRelease } from "os";
+var cachedCapability;
+function detectTerminalCapability() {
+  if (cachedCapability) return cachedCapability;
+  cachedCapability = detectTerminalCapabilityUncached();
+  return cachedCapability;
+}
+function resetTerminalCapabilityCache() {
+  cachedCapability = void 0;
+}
+function detectTerminalCapabilityUncached() {
+  const env = process.env;
+  if (env.LINGHUN_TERMINAL_TIER === "legacy") return legacyCapability();
+  if (env.LINGHUN_TERMINAL_TIER === "basic") return basicCapability();
+  if (env.LINGHUN_TERMINAL_TIER === "modern") return modernCapability();
+  if (env.TERM === "dumb") return legacyCapability();
+  if (env.WT_SESSION) {
+    return {
+      ...modernCapability(),
+      keyboardProtocols: ["csi-u", "modifyOtherKeys"]
+    };
+  }
+  if (process.platform === "win32") {
+    return detectWindowsTerminal(env);
+  }
+  return detectUnixTerminal(env);
+}
+function detectWindowsTerminal(env) {
+  if (env.TERM_PROGRAM === "vscode") {
+    return { ...modernCapability(), keyboardProtocols: ["csi-u"] };
+  }
+  if (env.TERM_PROGRAM === "WezTerm") {
+    return {
+      ...modernCapability(),
+      keyboardProtocols: ["csi-u", "modifyOtherKeys"]
+    };
+  }
+  if (env.TERM_PROGRAM === "alacritty" || env.ALACRITTY_WINDOW_ID) {
+    return { ...modernCapability(), keyboardProtocols: ["csi-u"] };
+  }
+  if (env.ConEmuPID || env.CONEMUDIR) return basicCapability();
+  if (env.TERM_PROGRAM === "mintty" || env.MSYSTEM) return basicCapability();
+  if (isWindows10ConptyCapable()) {
+    return {
+      ...basicCapability(),
+      keyboardProtocols: ["csi-u", "modifyOtherKeys"]
+    };
+  }
+  if (env.TERM && env.TERM !== "dumb") return basicCapability();
+  return legacyCapability();
+}
+function isWindows10ConptyCapable() {
+  try {
+    const ver = process.platform === "win32" ? osRelease() : "";
+    const parts = ver.split(".");
+    const major = Number.parseInt(parts[0] ?? "0", 10);
+    const build = Number.parseInt(parts[2] ?? "0", 10);
+    return major >= 10 && build >= 17763;
+  } catch {
+    return false;
+  }
+}
+function detectUnixTerminal(env) {
+  const termProgram = env.TERM_PROGRAM ?? "";
+  if (termProgram === "iTerm.app") return modernCapability();
+  if (termProgram === "WezTerm") return modernCapability();
+  if (termProgram === "alacritty" || env.ALACRITTY_WINDOW_ID) return modernCapability();
+  if (termProgram === "kitty" || env.KITTY_WINDOW_ID) {
+    return {
+      ...modernCapability(),
+      kittyKeyboard: true,
+      shiftEnter: true,
+      keyboardProtocols: ["kitty", "csi-u"]
+    };
+  }
+  if (termProgram === "vscode") {
+    return { ...modernCapability(), keyboardProtocols: ["csi-u"] };
+  }
+  if (termProgram === "ghostty") {
+    return { ...modernCapability(), keyboardProtocols: ["csi-u"] };
+  }
+  if (termProgram === "rio") {
+    return { ...modernCapability(), keyboardProtocols: ["csi-u"] };
+  }
+  if (env.TMUX || env.TERM?.startsWith("screen")) return basicCapability();
+  if (env.TERM?.includes("256color") || env.COLORTERM === "truecolor") {
+    return modernCapability();
+  }
+  if (env.TERM?.startsWith("xterm")) return basicCapability();
+  return basicCapability();
+}
+function modernCapability() {
+  return {
+    tier: "modern",
+    unicodeBox: true,
+    cjkWide: true,
+    richColor: true,
+    kittyKeyboard: false,
+    alternateScreen: true,
+    cursorPositioning: true,
+    shiftEnter: false,
+    multilineFallbacks: ["ctrl-j", "backslash-enter"],
+    keyboardProtocols: ["csi-u"]
+  };
+}
+function basicCapability() {
+  return {
+    tier: "basic",
+    unicodeBox: true,
+    cjkWide: true,
+    richColor: true,
+    kittyKeyboard: false,
+    alternateScreen: true,
+    cursorPositioning: true,
+    shiftEnter: false,
+    multilineFallbacks: ["ctrl-j", "backslash-enter"],
+    keyboardProtocols: []
+  };
+}
+function legacyCapability() {
+  return {
+    tier: "legacy",
+    unicodeBox: false,
+    cjkWide: false,
+    richColor: false,
+    kittyKeyboard: false,
+    alternateScreen: false,
+    cursorPositioning: false,
+    shiftEnter: false,
+    multilineFallbacks: ["ctrl-j", "backslash-enter"],
+    keyboardProtocols: []
+  };
+}
+function isXtermJsTerminal(env = process.env) {
+  const termProgram = (env.TERM_PROGRAM ?? "").toLowerCase();
+  return termProgram === "vscode" || termProgram.includes("cursor") || termProgram.includes("windsurf");
+}
+
+export {
+  detectTerminalCapability,
+  resetTerminalCapabilityCache,
+  isXtermJsTerminal
+};