codebee 0.1.55 → 0.1.57

package/app/core/selfupdate.py

@@ -9,8 +9,8 @@
 
 升级 = 在标准 mgmt run 里跑 `npm install -g codebee@latest`（日志实时落盘、
 SSE 可看进度）。npm 替换的是包目录文件，当前进程已加载进内存不受影响，装完后由
-「重启」换新代码：新进程先等旧端口释放再 bind（Windows SO_REUSEADDR 允许双 LISTEN
-同时存在，必须先验旧进程真退了），旧进程发送完重启响应后自退。
+自动重启换新代码：新进程先等旧端口释放再 bind（Windows SO_REUSEADDR 允许双
+LISTEN 同时存在，必须先验旧进程真退了），旧进程发送完重启响应后自退。
 
 安全：两处子进程命令的 argv 均为**行内字面量列表**（可执行文件与全部参数不来自任何
 外部输入；重启仅透传 argparse 校验过的整型端口），shell 全程 False，绝不拼接用户输入。
@@ -170,7 +170,7 @@ def apply_upgrade(port=None):
     port=服务端口：升级成功且版本真变时会自动就地重启（用户拍板 2026-09-21：
     升级完不该再要求手动点「重启服务生效」——旧进程滞留是 unknown api/界面
     闪烁/老宠物一类「升级了没生效」事故的总根子）。拿不到端口或运行环境不
-    具备时自动跳过，回落版本页的手动重启按钮。"""
+    具备时才跳过自动重启。"""
     global _PENDING_PORT
     try:
         _PENDING_PORT = int(port) if port else None
@@ -237,10 +237,10 @@ def _log_note(log_path, text):
 
 
 def _maybe_auto_relaunch(old_pkg, log_path):
-    """升级成功后的自动重启（三道守卫，任一不满足就回落手动按钮）：
-    ①知道服务端口（apply_upgrade 传入）；②版本真的变了（同版本重装不折腾）；
-    ③没有用户任务在跑（jobs._alive 只剩本升级任务自己）——正在干活的任务
-    不能被升级重启打断，此时留给用户挑自己合适的时间手动重启。"""
+    """升级成功后的自动重启：
+    ①知道服务端口（apply_upgrade 传入）；②版本真的变了（同版本重装不折腾）；
+    ③等当前用户任务自然结束后再原子停止接单——正在干活的任务不能被升级
+    重启打断，也不再要求用户找到一个可能不存在的手动重启按钮。"""
     import threading
     from . import jobs
     if not _PENDING_PORT:
@@ -250,26 +250,27 @@ def _maybe_auto_relaunch(old_pkg, log_path):
     if not old_pkg or new_pkg == old_pkg:
         _log_note(log_path, "版本未变化（%s），无需重启" % (new_pkg or "?"))
         return
-    if getattr(jobs, "_alive", 0) > 1:
-        _log_note(log_path, "检测到还有 %d 个任务在运行，不自动重启——"
-                  "完成后请在版本页手动点「重启服务生效」" % (jobs._alive - 1))
-        return
-    port = _PENDING_PORT
+    port = _PENDING_PORT
 
     def _go():
         drain_started = False
+        wait_noted = False
         try:
             time.sleep(3.0)   # 留出日志收尾/浏览器看到「升级完成」的窗口
-            drain_started = jobs.begin_restart_drain()
-            if not drain_started:
-                _log_note(log_path, "延时窗口内有新任务进入，不自动重启——"
-                          "完成后请在版本页手动点「重启服务生效」")
-                return
+            while not drain_started:
+                if (not wait_noted and
+                        (getattr(jobs, "_alive", 0) > 1 or
+                         getattr(jobs, "_chat_alive", 0) > 0)):
+                    _log_note(log_path, "等待当前任务完成后自动重启服务…")
+                    wait_noted = True
+                drain_started = jobs.begin_restart_drain()
+                if not drain_started:
+                    jobs.wait_for_idle(timeout=1.0)
             _log_note(log_path, "自动重启服务以应用新版本 %s …" % new_pkg)
             if relaunch(port):
                 self_quit()
         except Exception:
-            log.exception("selfupdate: 自动重启失败，请在版本页手动重启")
+            log.exception("selfupdate: 自动重启失败")
         finally:
             # 正常 self_quit 会直接结束进程；若拉起失败、异常或测试替身返回，必须
             # 释放停止接单闸，避免当前实例永久拒绝新任务。

package/app/core/skill_scan.py

@@ -19,14 +19,19 @@ _PATTERNS = [
     (r"\beval\s*\(", "代码执行", "动态 eval 执行任意代码"),
     (r"\bexec\s*\(", "代码执行", "exec 执行任意代码"),
     (r"subprocess|os\.system|Popen", "代码执行", "起子进程执行命令"),
+    (r"child_process", "代码执行", "Node.js 子进程（可能执行任意命令）"),
     # 数据外发
     (r"https?://(?!api\.|docs\.|github\.com|raw\.githubusercontent)[a-z0-9.-]+/(upload|collect|track|ingest|webhook|callback)",
      "数据外发", "向非常规端点上传/回调数据"),
     (r"requests\.post|urllib\.request|fetch\s*\(", "网络请求", "发起网络请求（确认目标可信）"),
+    (r"base64.{0,10}(decode|b64decode|atob)", "数据外发",
+     "base64 解码（可能隐藏混淆载荷）"),
     # 敏感信息读取
     (r"os\.environ|process\.env|getenv", "环境读取", "读取环境变量（可能带走密钥）"),
     (r"\.ssh/|\.aws/|\.npmrc|\.gitconfig|credentials|\.env\b", "敏感文件", "触碰凭据/密钥文件路径"),
     (r"keychain|credential manager|dpapi", "敏感文件", "访问系统凭据库"),
+    (r"\.claude/|\.zcode/|\.kimi-code/|\.codebee/", "敏感文件",
+     "触碰 AI 助手配置目录（可能篡改系统提示词或模型绑定）"),
     # 提示注入特征
     (r"(ignore|disregard|forget).{0,30}(previous|above|prior|all).{0,20}(instruction|prompt|rule)",
      "提示注入", "指令覆盖话术（试图无视既有规则）"),

package/app/core/store.py

@@ -28,11 +28,11 @@ _RUNS = {}
 # 长跑也不会无限增长（finish_step 里调 clear_stream_state）。
 _STREAM_LOCK = threading.Lock()
 _STREAM_TS = {}
-LIVE_TEXT_MAX = 20000   # 单步骤实时思考/正文的保留上限（与 builtin_agent 同口径）
-
-DEFAULT_TASK_TIMEOUT_S = 3600
-MIN_TASK_TIMEOUT_S = 1
-MAX_TASK_TIMEOUT_S = 7 * 24 * 3600
+LIVE_TEXT_MAX = 20000   # 单步骤实时思考/正文的保留上限（与 builtin_agent 同口径）
+
+DEFAULT_TASK_TIMEOUT_S = 3600
+MIN_TASK_TIMEOUT_S = 1
+MAX_TASK_TIMEOUT_S = 7 * 24 * 3600
 
 # ---------------------------------------------------------------- 状态版本（SSE 事件驱动）
 # 任何落盘写都算状态变化：SSE 连接等版本号变化才构建/推送全量状态，
@@ -61,38 +61,38 @@ def wait_state_change(last_ver, timeout):
         return _STATE_VER
 
 
-def _new_id(prefix):
-    stamp = time.strftime("%Y%m%d-%H%M%S")
-    # 10k random suffixes are not unique under a burst of task/run creation.
-    # Reserve against both indexes and disk so a collision cannot silently
-    # overwrite a queued run and make one of several submissions disappear.
-    with LOCK:
-        for _ in range(100):
-            candidate = "%s-%s-%04d" % (prefix, stamp, secrets.randbelow(10000))
-            if candidate in _TASKS or candidate in _RUNS:
-                continue
-            if (paths.TASKS_DIR / (candidate + ".json")).exists():
-                continue
-            if (paths.RUNS_DIR / candidate).exists():
-                continue
-            return candidate
-    raise RuntimeError("无法生成唯一记录 ID")
-
-
-def _safe_name(s):
-    return re.sub(r"[^0-9A-Za-z_-]+", "-", str(s))[:40].strip("-") or "x"
-
-
-def _task_timeout_s(value=None):
-    """Resolve one bounded wall-clock budget for a task."""
-    raw = value
-    if raw in (None, ""):
-        raw = os.environ.get("TUTTI_TASK_TIMEOUT_S", DEFAULT_TASK_TIMEOUT_S)
-    try:
-        seconds = int(float(raw))
-    except (TypeError, ValueError):
-        seconds = DEFAULT_TASK_TIMEOUT_S
-    return max(MIN_TASK_TIMEOUT_S, min(MAX_TASK_TIMEOUT_S, seconds))
+def _new_id(prefix):
+    stamp = time.strftime("%Y%m%d-%H%M%S")
+    # 10k random suffixes are not unique under a burst of task/run creation.
+    # Reserve against both indexes and disk so a collision cannot silently
+    # overwrite a queued run and make one of several submissions disappear.
+    with LOCK:
+        for _ in range(100):
+            candidate = "%s-%s-%04d" % (prefix, stamp, secrets.randbelow(10000))
+            if candidate in _TASKS or candidate in _RUNS:
+                continue
+            if (paths.TASKS_DIR / (candidate + ".json")).exists():
+                continue
+            if (paths.RUNS_DIR / candidate).exists():
+                continue
+            return candidate
+    raise RuntimeError("无法生成唯一记录 ID")
+
+
+def _safe_name(s):
+    return re.sub(r"[^0-9A-Za-z_-]+", "-", str(s))[:40].strip("-") or "x"
+
+
+def _task_timeout_s(value=None):
+    """Resolve one bounded wall-clock budget for a task."""
+    raw = value
+    if raw in (None, ""):
+        raw = os.environ.get("TUTTI_TASK_TIMEOUT_S", DEFAULT_TASK_TIMEOUT_S)
+    try:
+        seconds = int(float(raw))
+    except (TypeError, ValueError):
+        seconds = DEFAULT_TASK_TIMEOUT_S
+    return max(MIN_TASK_TIMEOUT_S, min(MAX_TASK_TIMEOUT_S, seconds))
 
 
 # ---------------------------------------------------------------- 任务
@@ -158,8 +158,8 @@ def create_task(payload):
         "status": "created",
     }
     thinking = str(payload.get("thinking") or "standard").strip().lower()
-    task["thinking"] = thinking if thinking in ("auto", "low", "standard", "high") else "auto"
-    task["timeout_s"] = _task_timeout_s(payload.get("timeout_s"))
+    task["thinking"] = thinking if thinking in ("auto", "low", "standard", "high") else "auto"
+    task["timeout_s"] = _task_timeout_s(payload.get("timeout_s"))
     if flow["engine"] == "direct":
         task["direct_provider_id"] = _text(payload.get("direct_provider_id"),
                                             "direct_provider_id")[:80]
@@ -546,7 +546,7 @@ def load_all():
                 _save_json(paths.TASKS_DIR / (t["id"] + ".json"), t)
                 continue
             latest = max(runs, key=lambda r: r["id"])
-            if latest.get("status") in ("done", "failed", "cancelled", "timeout"):
+            if latest.get("status") in ("done", "failed", "cancelled", "timeout"):
                 t["status"] = latest["status"]
                 _save_json(paths.TASKS_DIR / (t["id"] + ".json"), t)
 
@@ -562,7 +562,7 @@ def set_run_estimator(estimator):
     _RUN_ESTIMATOR = estimator if callable(estimator) else None
 
 
-def create_run(kind, title, task_id=None, entry_id=None, op=None):
+def create_run(kind, title, task_id=None, entry_id=None, op=None):
     run = {
         "id": _new_id("r" if kind == "orchestration" else "m"),
         "kind": kind,  # orchestration | mgmt
@@ -570,14 +570,14 @@ def create_run(kind, title, task_id=None, entry_id=None, op=None):
         "task_id": task_id, "entry_id": entry_id, "op": op,
         "status": "queued", "steps": [], "messages": [],
         "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
-        "started_at": None, "ended_at": None,
-        "deadline_at": None,
+        "started_at": None, "ended_at": None,
+        "deadline_at": None,
         "cost_usd": 0.0, "tokens": 0, "error": "",
         "verdict": None, "summary": "",
     }
-    if kind == "orchestration" and task_id:
-        task = get_task(task_id) or {}
-        run["deadline_at"] = time.time() + _task_timeout_s(task.get("timeout_s"))
+    if kind == "orchestration" and task_id:
+        task = get_task(task_id) or {}
+        run["deadline_at"] = time.time() + _task_timeout_s(task.get("timeout_s"))
         try:
             eta = _RUN_ESTIMATOR(
                 task_type=task.get("type") or "", mode=task.get("mode") or "auto",
@@ -661,6 +661,37 @@ def task_runs(task_id):
     return runs
 
 
+def task_runs_page(task_id, offset=0, limit=3):
+    """分页读取任务运行，只复制当前页；全量轻统计在详情打开时按需计算。"""
+    with LOCK:
+        runs = [r for r in _RUNS.values() if r.get("task_id") == task_id]
+    runs.sort(key=lambda run: run["id"], reverse=True)
+    page = [dict(run) for run in runs[offset:offset + limit]]
+    total_steps = settled_steps = total_tokens = 0
+    total_cost = 0.0
+    for run in runs:
+        steps = run.get("steps") or []
+        total_steps += len(steps)
+        settled_steps += sum(1 for step in steps
+                             if step.get("status") not in ("running", "queued"))
+        try:
+            total_cost += float(run.get("cost_usd") or 0)
+        except (TypeError, ValueError):
+            pass
+        try:
+            total_tokens += int(run.get("tokens") or 0)
+        except (TypeError, ValueError):
+            pass
+    return {
+        "runs": page,
+        "total": len(runs),
+        "offset": offset,
+        "has_more": offset + len(page) < len(runs),
+        "totals": {"steps": total_steps, "settled_steps": settled_steps,
+                   "cost_usd": total_cost, "tokens": total_tokens},
+    }
+
+
 def task_side(task_id):
     """任务检查器（右缘停靠列）的轻量聚合：最新 run 摘要 + 进度步骤 +
     git 分支/裁决状态 + 变更行级统计 + 成品文件。
@@ -762,27 +793,27 @@ def update_run(run_id, expected_status=None, **fields):
         # 这套在落终态瞬间即时收口——打磨组长被取消/异常打断时 UI 不闪
         # 假「工作中」）。run 终态后不可能还有步骤在真跑。
         st = fields.get("status")
-        if st in ("done", "failed", "cancelled", "timeout"):
-            end_s = time.strftime("%H:%M:%S")
-            for s in run["steps"]:
-                if s.get("status") in ("queued", "running"):
-                    s["status"] = "timeout" if st == "timeout" else "cancelled"
-                    s["ended_at"] = s.get("ended_at") or end_s
-                    if not s.get("summary"):
-                        s["summary"] = ("步骤未正常收尾（任务总时限已到）"
-                                         if st == "timeout" else
-                                         "步骤未正常收尾（终态自动恢复）")
+        if st in ("done", "failed", "cancelled", "timeout"):
+            end_s = time.strftime("%H:%M:%S")
+            for s in run["steps"]:
+                if s.get("status") in ("queued", "running"):
+                    s["status"] = "timeout" if st == "timeout" else "cancelled"
+                    s["ended_at"] = s.get("ended_at") or end_s
+                    if not s.get("summary"):
+                        s["summary"] = ("步骤未正常收尾（任务总时限已到）"
+                                         if st == "timeout" else
+                                         "步骤未正常收尾（终态自动恢复）")
         _save_json(paths.RUNS_DIR / run_id / "run.json", run)
         # 状态回填：起跑与结束都同步任务状态。只回填终态的话，run 在跑、
         # 任务永远显示「排队中」（2026-09-18 实案：「# 重写·续」run 已 running
         # 写了一小时，任务卡 queued，用户以为卡死连点重试）。
-        if st in ("running", "done", "failed", "cancelled", "timeout"):
+        if st in ("running", "done", "failed", "cancelled", "timeout"):
             tid = run.get("task_id")
             task = _TASKS.get(tid) if tid else None
             if task:
                 task["status"] = st
                 _save_json(paths.TASKS_DIR / (tid + ".json"), task)
-        if st in ("done", "failed", "cancelled", "timeout"):
+        if st in ("done", "failed", "cancelled", "timeout"):
             # run_end 钩子（2026-09-22）：终态即触发，后台跑副作用型脚本
             # （回写知识库等）；失败/超时静默，绝不拖慢收尾路径
             try:
@@ -873,17 +904,17 @@ def recover_orphaned_runs():
     step_now = time.strftime("%H:%M:%S")
     with LOCK:
         for r in _RUNS.values():
-            if r.get("status") not in ("done", "failed", "cancelled", "timeout"):
-                continue
+            if r.get("status") not in ("done", "failed", "cancelled", "timeout"):
+                continue
             changed = False
             for s in r.get("steps") or []:
                 if s.get("status") in ("queued", "running"):
-                    s["status"] = "timeout" if r.get("status") == "timeout" else "cancelled"
+                    s["status"] = "timeout" if r.get("status") == "timeout" else "cancelled"
                     s["ended_at"] = s.get("ended_at") or step_now
                     if not s.get("summary"):
-                        s["summary"] = ("步骤未正常收尾（任务总时限已到）"
-                                         if r.get("status") == "timeout" else
-                                         "步骤未正常收尾（取消/中断自动恢复）")
+                        s["summary"] = ("步骤未正常收尾（任务总时限已到）"
+                                         if r.get("status") == "timeout" else
+                                         "步骤未正常收尾（取消/中断自动恢复）")
                     changed = True
             if changed:
                 _save_json(paths.RUNS_DIR / r["id"] / "run.json", r)

package/app/core/zentao.py

@@ -329,6 +329,10 @@ _TOKEN = {"v": "", "at": 0.0}
 _APIBASE = {}
 # 通道自适应：原始地址 → "rest"（≥15 REST v1）/ "old"（老版 module-method JSON 接口）
 _MODE = {}
+# web 端路由形态：原始地址 → "pathinfo"（伪静态 bug-view-N.html，官方默认）
+# / "get"（index.php?m=bug&f=view&bugID=N）。bug 详情链接用（2026-09-23 真机实证
+# 伪静态部署对 GET 式链接不路由）。
+_WEBSTYLE = {}
 _OLD = {"api": "", "sid": "", "at": 0.0}
 _OLD_FORM = {"form": ""}      # 命中的密码形态 "plain" | "md5chain"，缓存避免重复试
 _REST_LAST_ERR = {"msg": ""}
@@ -349,6 +353,37 @@ def resolved_base_url(base_url):
     return re.sub(r"/api\.php/v1$", "", hit)
 
 
+def probe_web_style(base_url):
+    """探测禅道 web 端路由形态（bug 详情链接用）：GET web 根（裸根 + 常见 /zentao
+    子路径都试），看登录跳转里是伪静态路由（user-login-xxx.html）还是 GET 式
+    （index.php?m=user）。尽力而为：任何网络/守卫异常回空串，绝不影响登录与
+    扫描主流程；探出即缓存。"""
+    try:
+        b = _raw_base(base_url)
+    except ZenError:
+        return ""
+    if _WEBSTYLE.get(b):
+        return _WEBSTYLE[b]
+    style = ""
+    for root in (b + "/", b + "/zentao/"):
+        body = ""
+        try:
+            req = urllib.request.Request(_guard_url(root), headers={"Accept": "text/html"})
+            with _no_redirect_opener().open(req, timeout=HTTP_TIMEOUT) as r:
+                body = (r.read(65536) or b"").decode("utf-8", "replace")
+        except Exception:
+            body = ""
+        if "user-login-" in body or re.search(r"[a-z]+-view-\d+[^\"]*\.html", body):
+            style = "pathinfo"
+        elif "index.php?m=" in body:
+            style = "get"
+        if style:
+            break
+    if style:
+        _WEBSTYLE[b] = style
+    return style
+
+
 def _raw_base(base_url):
     b = str(base_url or "").strip().rstrip("/")
     if not b:
@@ -415,6 +450,7 @@ def _rest_login(base_url, account, password):
             _APIBASE[b] = api
             _TOKEN["v"] = tok
             _TOKEN["at"] = time.time()
+            probe_web_style(b)      # bug 链接形态探测，失败不影响登录
             return tok
         # HTTP 200 但没有 token：REST 在但不认账密（如只认应用 code 的部署）
         _REST_LAST_ERR["msg"] = "REST 接口不认账密（%s）" % (
@@ -592,6 +628,7 @@ def _old_login(cfg, rest_err=""):
                 _OLD.update(api=api, sid=sid, at=time.time())
                 _OLD_FORM["form"] = form
                 _MODE[b] = "old"
+                probe_web_style(b)  # bug 链接形态探测，失败不影响登录
                 return
             last = err
         break       # 同一台服务，账密结果与子路径无关，别再烧尝试次数
@@ -897,6 +934,40 @@ def list_bugs(cfg, product_id, profile=None):
     return out[:MAX_BUGS]
 
 
+def weekly_brief(limit=12):
+    """本周工作素材（工作汇报起草注入用，2026-09-23 Weekly Report Generator 借鉴
+    ——「从工作系统取数入素材」）：分配给我的活跃任务 + 指派给我的活跃 Bug 摘要。
+    尽力而为：未配置/不可达/响应形状不对一律返回空串，绝不阻塞汇报起草。
+    多产品档案逐个聚合（同 _scan 口径），条目总量封顶 limit*2。"""
+    lines = []
+    try:
+        cfg = _cfg()
+        for profile in _profiles(cfg):
+            assigned = str(profile.get("assigned_to") or "").strip()
+            if not assigned:
+                continue
+            try:
+                d = _call("GET", "/tasks?%s" % urllib.parse.urlencode(
+                    {"assignedTo": assigned, "limit": limit}), cfg=cfg)
+                tasks = d.get("tasks") if isinstance(d, dict) else None
+                for t in (tasks or [])[:limit]:
+                    if isinstance(t, dict) and t.get("status") in ("wait", "doing"):
+                        lines.append("- [任务#%s] %s（%s）" % (
+                            t.get("id"), t.get("name") or "", t.get("status") or ""))
+            except Exception:
+                pass
+            try:
+                for b in list_bugs(cfg, profile.get("product"), profile)[:limit]:
+                    lines.append("- [Bug#%s] %s（严重级 %s）" % (
+                        b.get("id"), b.get("title") or "",
+                        b.get("severity") or b.get("status") or ""))
+            except Exception:
+                pass
+    except Exception:
+        return ""
+    return "\n".join(lines[:limit * 2])
+
+
 def fetch_modules(product_id):
     """拉产品模块清单（模块路由配置辅助）。接口不存在/失败报人话，提示手填 ID。"""
     _ensure_loaded()
@@ -1965,6 +2036,24 @@ def save_config(patch):
     return view()["config"]
 
 
+def bug_web_base(cfg=None):
+    """给前端拼 bug 详情页用的 web 根：探测出的有效地基（含自动补的 /zentao 子路径）
+    优先，没探测过回落用户填的原始地址。返回 stripped 根或空串。"""
+    c = dict(cfg) if cfg else _cfg()
+    hit = resolved_base_url(c.get("base_url"))
+    if hit:
+        return hit
+    b = re.sub(r"/api\.php/v1$", "", str(c.get("base_url") or "").strip().rstrip("/"))
+    return b if b.startswith(("http://", "https://")) else ""
+
+
+def bug_link_style(cfg=None):
+    """bug 详情链接形态：探测缓存优先，没探出来按伪静态（官方默认形态）。"""
+    c = dict(cfg) if cfg else _cfg()
+    b = str(c.get("base_url") or "").strip().rstrip("/")
+    return _WEBSTYLE.get(b) or "pathinfo"
+
+
 def view():
     """前端视图：配置脱敏（password 只回是否已设）+ claims 列表（新在前）。"""
     _ensure_loaded()
@@ -1973,9 +2062,12 @@ def view():
         has_pw = bool(cfg.get("password"))
         cfg["password"] = ""
         cfg["has_password"] = has_pw
+        bug_base = bug_web_base(cfg)
         claims = sorted(_STATE["claims"].values(),
                         key=lambda c: str(c.get("claimed_at") or ""), reverse=True)
         return {"config": cfg,
+                "bug_base": bug_base,
+                "bug_style": bug_link_style(cfg),
                 "claims": [dict(c) for c in claims],
                 "last_scan": _STATE.get("last_scan") or "",
                 "next_scan": _STATE.get("next_scan") or "",
@@ -1990,6 +2082,7 @@ def _test_reset():
         _STATE["last_scan"] = _STATE["next_scan"] = _STATE["last_error"] = ""
         _reset_token()
         _APIBASE.clear()
+        _WEBSTYLE.clear()
         _MODE.clear()
         _OLD.update(api="", sid="", at=0.0)
         _OLD_FORM["form"] = ""