git-ai-control 0.4.12 → 0.4.14

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 本项目的所有重要变更都会记录在此文件中。
 
+## [0.4.14] - 2026-09-09
+
+### 修复
+
+- `npx git-ai-control` 发现正在运行的配置中心版本低于当前 npm 包时，自动安装新版并重启本机服务；旧版没有版本标记时也会自动升级。
+
+### 变更
+
+- npm 包补充作者元数据为 `yingyanzhitong`，保留 GitHub Actions OIDC Trusted Publishing 的供应链签名。
+
+## [0.4.13] - 2026-09-09
+
+### 新增
+
+- Skill 过滤新增“新目录观察期”：目录创建未满 7 天时，首次 Skill 上报默认拦截 24 小时，超时未处理自动放行；观察期状态在本机持久化，服务重启不会重新计时。
+- 管理后台新增观察期白名单和 Skill 黑名单：白名单可立即放行指定 Skill，黑名单持续阻断指定 Skill 上报。
+
 ## [0.4.12] - 2026-08-12
 
 ### 变更

package/README.zh-CN.md

@@ -17,6 +17,7 @@
 - 可删除仓库信息、项目路径和分支名称等敏感字段；
 - 可将允许上传的 Skill 项目目录替换为固定目录；
 - 可按关键词或正则拦截指定 Skill；
+- 新建目录 7 天内的 Skill 上报默认进入 24 小时观察期，可在后台通过白名单放行或黑名单持续拦截；
 - 仓库插件可按不同主机添加多个，并支持全局兜底、仓库、目录、分支与优先级；
 - 敏感内容脱敏插件可识别 API Key、私钥、凭据，并按规则脱敏或拦截；
 - Agent / 模型治理插件支持允许名单、阻止正则及审计/拦截模式；
@@ -50,7 +51,7 @@ Windows:       %USERPROFILE%\.git-ai\bin\git-ai.exe
 npx git-ai-control
 ```
 
-首次运行时，该命令会自动下载最新版本、安装本机服务，并打开 Git AI 配置中心；之后检测到已运行的配置中心时，会直接复用现有进程。若浏览器没有自动打开，可手动访问：
+首次运行时，该命令会自动下载最新版本、安装本机服务，并打开 Git AI 配置中心；之后若检测到正在运行的旧版本，会自动更新文件并重启本机服务，版本相同才复用现有进程。若浏览器没有自动打开，可手动访问：
 
 ```text
 http://127.0.0.1:38742
@@ -90,7 +91,13 @@ http://127.0.0.1:38742
 3. 每行填写一个关键词或正则；
 4. 保存配置。
 
-### 5. 验证配置
+### 5. 新目录 Skill 观察期
+
+“Skill 过滤插件”默认启用新目录观察期。上报事件中的项目目录创建未满 7 天时，首次 Skill 上报会被拦截 24 小时；期间可将 Skill 加入观察期白名单立即放行，或加入 Skill 黑名单持续阻断。24 小时没有处理则自动恢复上报，且过滤服务重启不会重新计时。
+
+文件系统未提供目录创建时间时，观察期不会基于不可靠的修改时间推断目录年龄。
+
+### 6. 验证配置
 
 点击页面中的“验证配置”，或在终端检查两个本机服务：
 

package/bin/git-ai-control.js

@@ -1,15 +1,19 @@
 #!/usr/bin/env node
 
 import {spawnSync} from "node:child_process"
+import fs from "node:fs"
 import path from "node:path"
 import {fileURLToPath} from "node:url"
 
 import {browserCommand} from "../scripts/platform-services.mjs"
-import {controlPanelIsRunning} from "../scripts/install.mjs"
+import {controlPanelNeedsUpdate, controlPanelStatus} from "../scripts/install.mjs"
 
 const command = process.argv[2]
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
 const controlPanelUrl = "http://127.0.0.1:38742"
+const packageVersion = JSON.parse(
+  fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"),
+).version
 
 function printHelp() {
   console.log(`Git AI Control Panel
@@ -37,8 +41,14 @@ try {
     await uninstall()
     process.exit(0)
   }
-  const reused = await controlPanelIsRunning()
-  if (!reused) {
+  const status = await controlPanelStatus()
+  if (!status) {
+    const {install} = await import("../scripts/install.mjs")
+    await install()
+  } else if (controlPanelNeedsUpdate(status.controlPanelVersion, packageVersion)) {
+    console.log(
+      `检测到新版本 ${packageVersion}，正在从 ${status.controlPanelVersion || "旧版"} 更新并重启服务`,
+    )
     const {install} = await import("../scripts/install.mjs")
     await install()
   } else {

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "git-ai-control",
-  "version": "0.4.12",
+  "version": "0.4.14",
   "description": "Git AI 本地配置与上传隐私控制面板",
+  "author": "yingyanzhitong",
   "type": "module",
   "bin": {
     "git-ai-control": "bin/git-ai-control.js"

package/plugins/upload-filter/plugin_filter_runtime.py

@@ -3,6 +3,7 @@
 
 from __future__ import annotations
 
+import hashlib
 import json
 import os
 import re
@@ -39,9 +40,14 @@ GIT_AI_ROOT = Path(os.environ.get("GIT_AI_ROOT", Path.home() / ".git-ai")).resol
 POLICY_CONFIG_PATH = GIT_AI_ROOT / "filter_plugins.json"
 UPSTREAM_CONFIG_PATH = GIT_AI_ROOT / "upstream_metrics.json"
 FILTER_AUDIT_PATH = GIT_AI_ROOT / "filter_audit.jsonl"
+RECENT_SKILL_HOLD_PATH = GIT_AI_ROOT / "recent_skill_holds.json"
 FILTER_AUDIT_RETENTION = timedelta(hours=24)
 FILTER_AUDIT_MAX_EVENTS = 2_000
 FILTER_AUDIT_LOCK = threading.Lock()
+RECENT_SKILL_HOLD_LOCK = threading.Lock()
+RECENT_DIRECTORY_MAX_AGE = timedelta(days=7)
+RECENT_SKILL_HOLD_DURATION = timedelta(hours=24)
+RECENT_SKILL_HOLD_RETENTION = timedelta(days=7)
 OWNER_REPOSITORY_PATTERN = re.compile(r"^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+(?:\.git)?$")
 SKILL_KEYS = {"skillName", "skill", "name"}
 PATH_KEYS = {
@@ -137,6 +143,11 @@ DEFAULT_POLICY_CONFIG = {
             "cloudflare",
             "cloud-flare",
         ],
+        "recent_directory_guard": {
+            "enabled": True,
+            "allowlist_patterns": [],
+            "blocklist_patterns": [],
+        },
     },
     "plugins": [
         {
@@ -275,6 +286,15 @@ def iter_skill_text(value):
             yield from iter_skill_text(child)
 
 
+def skill_names(payload) -> list[str]:
+    names = set()
+    for value in iter_skill_text(payload):
+        name = audit_text(value, 160)
+        if name:
+            names.add(name)
+    return sorted(names)
+
+
 def audit_timestamp() -> str:
     return datetime.now(timezone.utc).isoformat(timespec="seconds").replace("+00:00", "Z")
 
@@ -660,6 +680,148 @@ def matches_allowlist(value: str, patterns) -> bool:
     return any(selector_matches(pattern, [value]) for pattern in patterns)
 
 
+def compile_skill_patterns(patterns) -> list[re.Pattern]:
+    compiled = []
+    for pattern in patterns:
+        try:
+            compiled.append(re.compile(str(pattern), re.IGNORECASE))
+        except re.error:
+            continue
+    return compiled
+
+
+def directory_created_at(path: Path) -> datetime | None:
+    try:
+        metadata = path.stat()
+    except OSError:
+        return None
+
+    timestamp = getattr(metadata, "st_birthtime", None)
+    if timestamp is None and os.name == "nt":
+        timestamp = metadata.st_ctime
+    if timestamp is None:
+        return None
+    return datetime.fromtimestamp(timestamp, timezone.utc)
+
+
+def recent_payload_directories(payload, now: datetime) -> list[str]:
+    directories = set()
+    for value in iter_path_text(payload):
+        if not isinstance(value, str) or not value.strip():
+            continue
+        try:
+            path = Path(value).expanduser().resolve(strict=True)
+        except OSError:
+            continue
+        if not path.is_dir():
+            path = path.parent
+        created_at = directory_created_at(path)
+        if created_at is not None and now - created_at < RECENT_DIRECTORY_MAX_AGE:
+            directories.add(str(path))
+    return sorted(directories)
+
+
+def read_recent_skill_holds(path: Path = RECENT_SKILL_HOLD_PATH) -> dict[str, str]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    holds = value.get("holds", {}) if isinstance(value, dict) else {}
+    if not isinstance(holds, dict):
+        return {}
+    return {
+        key: timestamp
+        for key, timestamp in holds.items()
+        if isinstance(key, str) and parse_audit_timestamp(timestamp) is not None
+    }
+
+
+def write_recent_skill_holds(
+    holds: dict[str, str], path: Path = RECENT_SKILL_HOLD_PATH
+) -> None:
+    temporary = None
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+        temporary.write_text(
+            json.dumps({"version": 1, "holds": holds}, ensure_ascii=False, indent=2)
+            + "\n",
+            encoding="utf-8",
+        )
+        if os.name != "nt":
+            os.chmod(temporary, 0o600)
+        os.replace(temporary, path)
+    except OSError:
+        if temporary:
+            try:
+                temporary.unlink(missing_ok=True)
+            except OSError:
+                pass
+
+
+def recent_skill_hold_key(directory: str, skill: str) -> str:
+    return hashlib.sha256(f"{directory}\0{skill}".encode("utf-8")).hexdigest()
+
+
+def recent_directory_skill_guard(
+    payload,
+    skill_policy: dict,
+    *,
+    now: datetime | None = None,
+    state_path: Path = RECENT_SKILL_HOLD_PATH,
+) -> str | None:
+    if not skill_policy.get("installed", True) or not skill_policy.get("enabled", True):
+        return None
+    guard = skill_policy.get("recent_directory_guard", {})
+    if not isinstance(guard, dict):
+        return None
+    skills = skill_names(payload) or ["[unknown]"]
+    blocklist = compile_skill_patterns(guard.get("blocklist_patterns", []))
+    if any(pattern.search(skill) for skill in skills for pattern in blocklist):
+        return "recent_directory_skill_blocklist"
+    if not guard.get("enabled", True):
+        return None
+    allowlist = compile_skill_patterns(guard.get("allowlist_patterns", []))
+    if skills and all(any(pattern.search(skill) for pattern in allowlist) for skill in skills):
+        return None
+
+    now = now or datetime.now(timezone.utc)
+    if now.tzinfo is None:
+        now = now.replace(tzinfo=timezone.utc)
+    now = now.astimezone(timezone.utc)
+    directories = recent_payload_directories(payload, now)
+    if not directories:
+        return None
+
+    with RECENT_SKILL_HOLD_LOCK:
+        holds = read_recent_skill_holds(state_path)
+        holds = {
+            key: timestamp
+            for key, timestamp in holds.items()
+            if now - parse_audit_timestamp(timestamp) < RECENT_SKILL_HOLD_RETENTION
+        }
+        should_hold = False
+        for directory in directories:
+            for skill in skills:
+                key = recent_skill_hold_key(directory, skill)
+                first_seen = parse_audit_timestamp(holds.get(key))
+                if first_seen is None:
+                    first_seen = now
+                    holds[key] = audit_timestamp_from(now)
+                if now - first_seen < RECENT_SKILL_HOLD_DURATION:
+                    should_hold = True
+        write_recent_skill_holds(holds, state_path)
+    return "recent_directory_skill_hold" if should_hold else None
+
+
+def audit_timestamp_from(value: datetime) -> str:
+    return (
+        value.astimezone(timezone.utc)
+        .isoformat(timespec="seconds")
+        .replace("+00:00", "Z")
+    )
+
+
 def governance_findings(payload, policy: dict) -> list[str]:
     if not policy.get("installed", False) or not policy.get("enabled", False):
         return []
@@ -717,6 +879,16 @@ def evaluate_request(
             "plugin": plugin_id,
             "config_error": config_error,
         }
+    if event_type == "skill" and (
+        reason := recent_directory_skill_guard(payload, skill_policy)
+    ):
+        return {
+            "blocked": True,
+            "reason": reason,
+            "payload": payload,
+            "plugin": plugin_id,
+            "config_error": config_error,
+        }
 
     if plugin:
         allowed = bool(plugin.get("allow", {}).get(event_type, False))

package/policy.example.json

@@ -22,7 +22,12 @@
       "git-hub",
       "cloudflare",
       "cloud-flare"
-    ]
+    ],
+    "recent_directory_guard": {
+      "enabled": true,
+      "allowlist_patterns": [],
+      "blocklist_patterns": []
+    }
   },
   "plugins": [
     {

package/scripts/install.mjs

@@ -42,6 +42,14 @@ const ROUTE_KEYS = {
 }
 const CONTROL_PANEL_STATUS_URL = "http://127.0.0.1:38742/api/status"
 
+function packageVersion() {
+  const metadata = readJson(path.join(PROJECT_ROOT, "package.json"), {})
+  if (typeof metadata.version !== "string" || !metadata.version.trim()) {
+    throw new Error("无法识别当前 git-ai-control 版本")
+  }
+  return metadata.version.trim()
+}
+
 function run(command, args, options = {}) {
   const result = spawnSync(command, args, {
     encoding: "utf8",
@@ -207,7 +215,7 @@ function configureCustomMetrics(gitAiRoot) {
   writeJsonAtomic(metricsPath, {...config, ...LOCAL_ENDPOINTS})
 }
 
-function copyRuntime(gitAiRoot) {
+function copyRuntime(gitAiRoot, version) {
   const controlPanelDir = path.join(gitAiRoot, "control-panel")
   const filterDir = path.join(gitAiRoot, "filters")
   fs.mkdirSync(controlPanelDir, {recursive: true})
@@ -224,6 +232,7 @@ function copyRuntime(gitAiRoot) {
   fs.cpSync(path.join(PROJECT_ROOT, "static"), path.join(controlPanelDir, "static"), {
     recursive: true,
   })
+  writeJsonAtomic(path.join(controlPanelDir, "runtime.json"), {version})
   if (process.platform !== "win32") {
     fs.chmodSync(path.join(controlPanelDir, "server.py"), 0o700)
     fs.chmodSync(path.join(filterDir, "plugin_filter_runtime.py"), 0o700)
@@ -387,13 +396,13 @@ async function waitForHttp(url, label) {
   throw new Error(`${label}启动失败：${url}`)
 }
 
-export async function controlPanelIsRunning(url = CONTROL_PANEL_STATUS_URL) {
+export async function controlPanelStatus(url = CONTROL_PANEL_STATUS_URL) {
   const controller = new AbortController()
   const timeout = setTimeout(() => controller.abort(), 1_500)
   try {
     const response = await fetch(url, {signal: controller.signal})
     if (!response.ok) {
-      return false
+      return null
     }
     const status = await response.json()
     return (
@@ -401,14 +410,39 @@ export async function controlPanelIsRunning(url = CONTROL_PANEL_STATUS_URL) {
       typeof status === "object" &&
       typeof status.distribution === "string" &&
       typeof status.gitAiStatus === "string"
-    )
+    ) ? status : null
   } catch {
-    return false
+    return null
   } finally {
     clearTimeout(timeout)
   }
 }
 
+export async function controlPanelIsRunning(url = CONTROL_PANEL_STATUS_URL) {
+  return Boolean(await controlPanelStatus(url))
+}
+
+export function controlPanelNeedsUpdate(installedVersion, packageVersion) {
+  if (typeof installedVersion !== "string" || !installedVersion.trim()) {
+    return true
+  }
+  const parseVersion = (value) => {
+    const match = value.trim().match(/^(\d+)\.(\d+)\.(\d+)$/)
+    return match ? match.slice(1).map(Number) : null
+  }
+  const installed = parseVersion(installedVersion)
+  const available = parseVersion(packageVersion)
+  if (!installed || !available) {
+    return false
+  }
+  for (let index = 0; index < available.length; index += 1) {
+    if (available[index] !== installed[index]) {
+      return available[index] > installed[index]
+    }
+  }
+  return false
+}
+
 export async function install(options = {}) {
   const platform = options.platform ?? process.platform
   if (!["darwin", "linux", "win32"].includes(platform)) {
@@ -418,6 +452,7 @@ export async function install(options = {}) {
     options.gitAiRoot ?? process.env.GIT_AI_ROOT ?? path.join(os.homedir(), ".git-ai"),
   )
   const pythonCommand = options.pythonCommand ?? findPython(platform)
+  const version = packageVersion()
   const binary = gitAiBinaryCandidates(gitAiRoot, platform).find(fs.existsSync)
   if (!binary) {
     throw new Error(
@@ -459,7 +494,7 @@ export async function install(options = {}) {
     console.log("检测到官方上游版：保留原生配置管理，不修改无效的 custom_metrics.json")
   }
 
-  copyRuntime(gitAiRoot)
+  copyRuntime(gitAiRoot, version)
   run(pythonCommand[0], [
     ...pythonCommand.slice(1),
     "-m",

package/server.py

@@ -35,6 +35,7 @@ FILTER_HEALTH_URL = "http://127.0.0.1:38741/health"
 FILTER_MAC_LABEL = "com.git-ai.skill-usage-filter"
 FILTER_LINUX_UNIT = "git-ai-filter.service"
 FILTER_WINDOWS_TASK = "GitAIFilter"
+CONTROL_PANEL_RUNTIME_PATH = APP_ROOT / "runtime.json"
 
 NATIVE_FIELDS = {
     "git_path",
@@ -229,6 +230,31 @@ def validate_policy_config(value) -> dict:
             re.compile(pattern)
         except re.error as error:
             raise ConfigError(f"无效的 Skill 正则：{pattern}（{error}）") from error
+    recent_directory_guard = skill_policy.get("recent_directory_guard", {})
+    if not isinstance(recent_directory_guard, dict):
+        raise ConfigError("新目录观察期配置必须是对象")
+    recent_directory_guard_enabled = recent_directory_guard.get("enabled", True)
+    if not isinstance(recent_directory_guard_enabled, bool):
+        raise ConfigError("新目录观察期开关必须是布尔值")
+    recent_directory_allowlist = validate_string_list(
+        recent_directory_guard.get("allowlist_patterns", []),
+        "新目录观察期白名单",
+        maximum=256,
+    )
+    recent_directory_blocklist = validate_string_list(
+        recent_directory_guard.get("blocklist_patterns", []),
+        "新目录观察期黑名单",
+        maximum=256,
+    )
+    for label, patterns in (
+        ("新目录观察期白名单", recent_directory_allowlist),
+        ("新目录观察期黑名单", recent_directory_blocklist),
+    ):
+        for pattern in patterns:
+            try:
+                re.compile(pattern)
+            except re.error as error:
+                raise ConfigError(f"无效的{label}正则：{pattern}（{error}）") from error
 
     plugins = value.get("plugins")
     if not isinstance(plugins, list) or len(plugins) > 32:
@@ -392,6 +418,11 @@ def validate_policy_config(value) -> dict:
             "installed": skill_installed,
             "enabled": skill_enabled,
             "blocked_patterns": blocked_patterns,
+            "recent_directory_guard": {
+                "enabled": recent_directory_guard_enabled,
+                "allowlist_patterns": recent_directory_allowlist,
+                "blocklist_patterns": recent_directory_blocklist,
+            },
         },
         "plugins": normalized_plugins,
         "plugin_order": plugin_order,
@@ -534,6 +565,12 @@ def git_ai_updated_at() -> str:
         return ""
 
 
+def control_panel_version() -> str:
+    metadata = read_json(CONTROL_PANEL_RUNTIME_PATH, {})
+    version = metadata.get("version") if isinstance(metadata, dict) else ""
+    return version if isinstance(version, str) else ""
+
+
 @lru_cache(maxsize=1)
 def custom_metrics_supported() -> bool:
     binary = git_ai_binary_path()
@@ -597,6 +634,7 @@ def runtime_status() -> dict:
         "platform": platform.system().lower(),
         "gitAiVersion": git_ai_version(),
         "gitAiUpdatedAt": git_ai_updated_at(),
+        "controlPanelVersion": control_panel_version(),
         "paths": {
             "nativeConfig": str(NATIVE_CONFIG_PATH),
             "policyConfig": str(POLICY_CONFIG_PATH),