codebee 0.1.0

package/app/core/selfupdate.py

@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+"""Tutti 自更新：版本读取 / 新版本检测 / 一键升级 / 就地重启。
+
+安装模式判定（mode）：
+  npm   — 运行副本位于 node_modules 下且带 package.json（npm 全局安装的包），
+          可查新、可升级、可重启；
+  repo  — 带 .git 的开发仓库：**永不自动升级**（会覆盖开发中的代码），提示走 git pull；
+  other — 裸源码拷贝，提示手动替换。
+
+升级 = 在标准 mgmt run 里跑 `npm install -g codebee@latest`（日志实时落盘、
+SSE 可看进度）。npm 替换的是包目录文件，当前进程已加载进内存不受影响，装完后由
+「重启」换新代码：新进程先等旧端口释放再 bind（Windows SO_REUSEADDR 允许双 LISTEN
+同时存在，必须先验旧进程真退了），旧进程发送完重启响应后自退。
+
+安全：两处子进程命令的 argv 均为**行内字面量列表**（可执行文件与全部参数不来自任何
+外部输入；重启仅透传 argparse 校验过的整型端口），shell 全程 False，绝不拼接用户输入。
+改发布名时（见 test_selfupdate 与 package.json 的一致性断言）同步改 _PKG_NAME。
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import socket
+import subprocess
+import sys
+import threading
+import time
+
+from . import paths, runner
+
+_PKG_NAME = "codebee"   # npm 发布名；必须与 package.json 的 name 一致（单测断言）
+_UPDATE_TTL = 600   # 查新结果缓存（秒）
+_LOCK = threading.Lock()
+_CHECK_CACHE = {"ts": 0.0, "result": None}
+
+
+def package_version():
+    """读本包 package.json 的 version；读不到返回 ''（开发仓库未同步版本号时）。"""
+    try:
+        pj = (paths.ROOT / "package.json").resolve()
+        return str(json.loads(pj.read_text(encoding="utf-8")).get("version") or "")
+    except Exception:
+        return ""
+
+
+def install_mode():
+    """npm / repo / source / other（见模块 docstring）。"""
+    try:
+        parts = [p.lower() for p in paths.ROOT.resolve().parts]
+    except Exception:
+        return "other"
+    has_pkg = (paths.ROOT / "package.json").is_file()
+    if "node_modules" in parts and has_pkg:
+        return "npm"
+    if (paths.ROOT / ".git").exists():
+        return "repo"
+    return "source" if has_pkg else "other"
+
+
+def _ver_tuple(s):
+    return [int(x) for x in re.findall(r"\d+", str(s or ""))[:4]]
+
+
+def _npm_latest():
+    """npm view codebee version；返回 (latest, err)。
+    用 _PKG_NAME 变量而非行内字面量：发布名改过一次（tutti-orchestrator→codebee），
+    硬编码两处容易漏改；Mimosa 安全基线要求 argv 可执行文件为字面量，参数用变量不违反。"""
+    r = runner.run_process(
+        argv=["cmd", "/c", "npm", "view", _PKG_NAME, "version"], timeout=60)
+    if not r["ok"]:
+        return "", (r["stderr"] or r["stdout"] or "")[-200:] or "npm 命令失败"
+    m = re.search(r"\d+\.\d+\.\d+[\w.\-]*", r["stdout"] or "")
+    return (m.group(0) if m else ""), ("" if m else "npm 输出无法解析")
+
+
+def check(force=False):
+    """GET /api/selfupdate 载荷：{mode, current, latest, has_update, note}。"""
+    mode = install_mode()
+    cur = package_version()
+    out = {"mode": mode, "current": cur, "latest": "", "has_update": False, "note": ""}
+    if mode != "npm":
+        out["note"] = ("开发仓库模式：请用 git pull 更新（自动升级会覆盖未提交的代码）"
+                       if mode == "repo" else "非 npm 安装，无法自动更新")
+        return out
+    with _LOCK:
+        if not force and _CHECK_CACHE["result"] and \
+                time.time() - _CHECK_CACHE["ts"] < _UPDATE_TTL:
+            return dict(_CHECK_CACHE["result"])
+    latest, err = _npm_latest()
+    out["latest"] = latest
+    if err:
+        out["note"] = "查询新版本失败：" + err
+    elif latest and cur:
+        out["has_update"] = _ver_tuple(latest) > _ver_tuple(cur)
+    else:
+        out["note"] = "无法比较版本（本地或 registry 版本号缺失）"
+    with _LOCK:
+        _CHECK_CACHE["ts"] = time.time()
+        _CHECK_CACHE["result"] = dict(out)
+    return out
+
+
+def apply_upgrade():
+    """发起升级：建 mgmt run 异步跑 npm install -g @latest。返回 {run_id} 或 {error}。"""
+    if install_mode() != "npm":
+        return {"error": "当前安装方式不支持自动升级（见版本页说明）"}
+    from . import store, jobs
+    run = store.create_run("mgmt", "升级 CodeBee 本体（npm install -g %s@latest）" % _PKG_NAME,
+                           entry_id="__self__", op="selfupgrade")
+    jobs.enqueue({"kind": "selfupgrade", "run_id": run["id"]})
+    return {"run_id": run["id"]}
+
+
+def run_upgrade(run_id, log_path):
+    """worker 线程里执行升级命令（run/step 生命周期由 jobs 层管）。"""
+    res = runner.run_process(
+        argv=["cmd", "/c", "npm", "install", "-g", _PKG_NAME + "@latest"],
+        cwd=str(paths.ROOT), timeout=900, log_path=log_path)
+    if res["ok"]:
+        with _LOCK:  # 装完即过期查新缓存，重启后自然拿到新版本
+            _CHECK_CACHE["result"] = None
+    return {"ok": res["ok"], "exit_code": res["exit_code"],
+            "error": "" if res["ok"] else (res["stderr"][-800:] or "退出码 %s" % res["exit_code"])}
+
+
+def _port_free(port):
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    try:
+        s.settimeout(0.3)
+        return s.connect_ex(("127.0.0.1", int(port))) != 0
+    except Exception:
+        return True
+    finally:
+        s.close()
+
+
+def wait_port_before_bind(port):
+    """新进程入口（--wait-port）：轮询直到旧实例释放端口（最多 ~30 秒）。
+    超时也放行——旧进程若没退，bind 失败自会报错，不会出现双实例串流。"""
+    for _ in range(60):
+        if _port_free(port):
+            return
+        time.sleep(0.5)
+
+
+def relaunch(port):
+    """就地重启：拉起新实例（--wait-port 等新端口可 bind 时旧实例已自退）。
+    调用方发送完重启响应后应 self_quit()。port 经 int() 强校验，argv 全字面量。"""
+    port = int(port)
+    if port < 1 or port > 65535:
+        return False
+    subprocess.Popen(
+        [sys.executable, "main.py", "--port", str(port),
+         "--wait-port", "--no-browser"],
+        cwd=str(paths.APP_DIR),
+        stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+        close_fds=True,
+        creationflags=(0x00000008 | 0x00000200) if os.name == "nt" else 0)
+    return True
+
+
+def self_quit():
+    """旧进程体面自退（HTTP 响应已发出后调用）。"""
+    try:
+        from . import remote
+        remote.stop_quick_tunnel()
+    except Exception:
+        pass
+    os._exit(0)

package/app/core/session_log.py

@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+"""Surface 会话日志：只追加事件流 + surface 派生模型输入。
+
+设计稿：docs/migration/02-context-compaction.md §1A。
+参考 dsh packages/core/session/src/types.ts:222-271（SessionEvent）与
+surface.ts:140-167（append 同步校验 + replace generation）。
+
+核心不变量：
+  1. 只追加：append 是唯一写入口，seq 单调，写入即落盘（JSONL）。
+  2. 模型可见即已记录：模型输入一律由 derive_messages() 从日志折叠派生，
+     不存在"日志外的模型输入"。
+  3. surface replace：压缩通过 surface_op={"op":"replace",start,end} 把一段
+     事件折叠为单条摘要消息，replace_generation 单调递增（1D 重试守门用）。
+"""
+from __future__ import annotations
+
+import json
+import threading
+import time
+
+
+class SessionEvent:
+    __slots__ = ("seq", "type", "data", "ts", "surface_op", "turn_id")
+
+    def __init__(self, seq, ev_type, data, ts=None, surface_op=None, turn_id=None):
+        self.seq = seq
+        self.type = ev_type
+        self.data = data
+        self.ts = ts if ts is not None else time.time()
+        self.surface_op = surface_op
+        self.turn_id = turn_id
+
+    def to_dict(self):
+        d = {"seq": self.seq, "type": self.type, "data": self.data, "ts": self.ts}
+        if self.surface_op is not None:
+            d["surface_op"] = self.surface_op
+        if self.turn_id:
+            d["turn_id"] = self.turn_id
+        return d
+
+    @classmethod
+    def from_dict(cls, d):
+        return cls(d["seq"], d["type"], d.get("data") or {},
+                   ts=d.get("ts"), surface_op=d.get("surface_op"),
+                   turn_id=d.get("turn_id"))
+
+
+# 进入模型 surface 的事件类型（其余仅记录，不派生）
+_SURFACE_TYPES = ("system_message", "user_message", "assistant_message")
+
+
+class Session:
+    """一次 run 的会话日志。线程安全；落盘路径缺省不持久化（仅内存）。"""
+
+    def __init__(self, run_id: str, store_path=None):
+        self.run_id = run_id
+        self.store_path = str(store_path) if store_path else None
+        self._lock = threading.Lock()
+        self._events = []
+        self._seq = 0
+        self._replace_generation = 0
+        # surface 视图：list[SessionEvent]（已折叠）；惰性重建
+        self._surface = []
+        self._surface_dirty = True
+        if self.store_path:
+            self._load()
+
+    # ---- 写入 ----
+
+    def append(self, ev_type, data, *, surface_op=None, turn_id=None):
+        """追加事件。surface_op:
+          None                        -> 追加进 surface（若是 surface 类型）
+          "shadow"                    -> 仅记录，不进 surface（审计/中间产物）
+          {"op":"replace","start_seq":N,"end_seq":M} -> 把 [N,M] 折叠为本条
+        """
+        with self._lock:
+            self._seq += 1
+            ev = SessionEvent(self._seq, ev_type, data,
+                              surface_op=surface_op, turn_id=turn_id)
+            self._events.append(ev)
+            if isinstance(surface_op, dict) and surface_op.get("op") == "replace":
+                self._replace_generation += 1
+            self._surface_dirty = True
+            self._persist_one(ev)
+            return ev
+
+    # ---- 派生 ----
+
+    def _fold(self):
+        """按事件序重放 surface。replace 折叠 [start_seq, end_seq] 区间为该条摘要。"""
+        surface = []  # list[SessionEvent]
+        for ev in self._events:
+            op = ev.surface_op
+            if op == "shadow":
+                continue
+            if isinstance(op, dict) and op.get("op") == "replace":
+                start, end = op["start_seq"], op["end_seq"]
+                surface = [e for e in surface if not (start <= e.seq <= end)]
+                surface.append(ev)
+                continue
+            if ev.type in _SURFACE_TYPES:
+                surface.append(ev)
+        return surface
+
+    def derive_messages(self):
+        """模型输入消息列表 [{role, content}]。system 节点去重合并（保留最后一条同 role）。"""
+        with self._lock:
+            if self._surface_dirty:
+                self._surface = self._fold()
+                self._surface_dirty = False
+            snap = list(self._surface)
+        msgs = []
+        for ev in snap:
+            role = "system" if ev.type == "system_message" else (
+                "assistant" if ev.type == "assistant_message" else "user")
+            msgs.append({"role": role, "content": str(ev.data.get("content", "")),
+                         "seq": ev.seq})
+        # 同 role 连续合并（CLI 提示词偏好单条 system/user）
+        merged = []
+        for m in msgs:
+            if merged and merged[-1]["role"] == m["role"]:
+                merged[-1]["content"] += "\n\n" + m["content"]
+                merged[-1]["seq"] = m["seq"]
+            else:
+                merged.append(dict(m))
+        return merged
+
+    def replace_generation(self):
+        with self._lock:
+            return self._replace_generation
+
+    def events(self):
+        with self._lock:
+            return list(self._events)
+
+    # ---- 持久化 ----
+
+    def _persist_one(self, ev):
+        if not self.store_path:
+            return
+        with open(self.store_path, "a", encoding="utf-8") as f:
+            f.write(json.dumps(ev.to_dict(), ensure_ascii=False) + "\n")
+
+    def _load(self):
+        """启动恢复：逐行读 JSONL，坏行跳过（lazy skip）。"""
+        try:
+            with open(self.store_path, encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line.startswith("{"):
+                        continue
+                    try:
+                        self._events.append(SessionEvent.from_dict(json.loads(line)))
+                    except Exception:
+                        continue
+            if self._events:
+                self._seq = max(e.seq for e in self._events)
+                self._replace_generation = sum(
+                    1 for e in self._events
+                    if isinstance(e.surface_op, dict) and e.surface_op.get("op") == "replace")
+        except OSError:
+            pass

package/app/core/sessions.py

@@ -0,0 +1,312 @@
+# -*- coding: utf-8 -*-
+"""本地已有会话扫描：读取各家 CLI 落盘的会话记录，
+供任务"在已有会话上继续"选择。只读解析文件头部，扫描保持轻量。
+
+布局（2026-09 本机实测）：
+  codex  : ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<sid>.jsonl
+           首行 type=session_meta（payload.id / cwd）；用户消息为
+           event_msg(payload.type=user_message, payload.message=...)
+  claude : ~/.claude/projects/<项目slug>/<sid>.jsonl
+           队列行 {"type":"queue-operation","operation":"enqueue","content":...}
+           或消息行 {"type":"user","message":{"content":...}}
+  qwen   : ~/.qwen/projects/<项目slug>/chats/<sid>.jsonl
+           真实用户消息 type=user 且 provenance=real_user，文本在
+           message.parts[].text，行上带 cwd 原始项目路径
+  opencode / mimo-code : ~/.local/share/{opencode,mimocode}/*.db（SQLite，
+           两家同源同 schema）。只读打开（mode=ro，WAL 可并发读），
+           session 表取 id/directory/标题，message+part 取首条用户文本。
+"""
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+import time
+from pathlib import Path
+
+SCAN_LIMIT = 12       # 每个智能体最多返回条数
+SCAN_MAX_FILES = 60   # 最多检查的文件数
+HEAD_LINES = 80       # 每个文件最多读取行数
+LINE_CAP = 3000       # 单行读取字符上限
+
+# 与 catalog 的 orch.kind 对应的会话根目录
+_CACHE = {"data": None, "ts": 0.0}
+
+
+def codex_root():
+    return Path(os.path.expanduser("~/.codex/sessions"))
+
+
+def claude_root():
+    return Path(os.path.expanduser("~/.claude/projects"))
+
+
+def qwen_root():
+    return Path(os.path.expanduser("~/.qwen/projects"))
+
+
+def opencode_db():
+    return Path(os.path.expanduser("~/.local/share/opencode/opencode.db"))
+
+
+def mimo_db():
+    return Path(os.path.expanduser("~/.local/share/mimocode/mimocode.db"))
+
+
+def _fmt_ts(epoch):
+    return time.strftime("%m-%d %H:%M", time.localtime(epoch))
+
+
+def _preview_cut(text):
+    text = " ".join(str(text or "").split())
+    for prefix in ("<user_instructions", "<permissions", "<ENVIRONMENT", "<environment_context"):
+        if text.startswith(prefix):
+            return ""
+    return text[:140]
+
+
+def _scan_codex():
+    root = codex_root()
+    if not root.is_dir():
+        return []
+    files = sorted(root.rglob("*.jsonl"), key=lambda p: p.stat().st_mtime, reverse=True)
+    out = []
+    for f in files[:SCAN_MAX_FILES]:
+        sid, cwd, preview, turn_count = "", "", "", 0
+        try:
+            with open(f, encoding="utf-8", errors="replace") as fp:
+                for i, raw in enumerate(fp):
+                    if i >= HEAD_LINES:
+                        break
+                    line = raw.strip()
+                    if not line.startswith("{"):
+                        continue
+                    is_meta = '"session_meta"' in line[:300]
+                    # meta 行可能很长（含 base_instructions），完整解析；其余超长行截断尽力解析
+                    try:
+                        ev = json.loads(line if (is_meta or len(line) < 20000) else line[:LINE_CAP])
+                    except Exception:
+                        continue
+                    if ev.get("type") == "session_meta":
+                        payload = ev.get("payload") or {}
+                        sid = payload.get("id") or sid
+                        cwd = payload.get("cwd") or cwd
+                    elif ev.get("type") == "event_msg" and (ev.get("payload") or {}).get("type") == "user_message":
+                        turn_count += 1
+                        if not preview:
+                            preview = _preview_cut((ev.get("payload") or {}).get("message"))
+                    elif ev.get("type") == "response_item" and (ev.get("payload") or {}).get("role") == "user":
+                        if not preview:
+                            for c in (ev["payload"].get("content") or []):
+                                if isinstance(c, dict) and c.get("type") == "input_text":
+                                    pv = _preview_cut(c.get("text"))
+                                    if pv:
+                                        preview = pv
+                                    break
+                    if sid and cwd and turn_count > 2:
+                        break
+        except Exception:
+            continue
+        out.append({
+            "agent": "codex-cli",
+            "session_id": sid or f.stem,
+            "file": str(f),
+            "project": cwd,
+            "mtime": _fmt_ts(f.stat().st_mtime),
+            "turns": turn_count,
+            "preview": preview or "（未解析到用户消息）",
+        })
+        if len(out) >= SCAN_LIMIT:
+            break
+    return out
+
+
+def _scan_claude():
+    root = claude_root()
+    if not root.is_dir():
+        return []
+    files = []
+    for proj in root.iterdir():
+        if proj.is_dir():
+            files.extend(proj.glob("*.jsonl"))
+    files = sorted(files, key=lambda p: p.stat().st_mtime, reverse=True)
+    out = []
+    for f in files[:SCAN_MAX_FILES]:
+        preview, msg_count, cwd = "", 0, ""
+        try:
+            with open(f, encoding="utf-8", errors="replace") as fp:
+                for i, raw in enumerate(fp):
+                    if i >= HEAD_LINES:
+                        break
+                    line = raw[:LINE_CAP]
+                    if not line.startswith("{"):
+                        continue
+                    try:
+                        ev = json.loads(line)
+                    except Exception:
+                        continue
+                    # 行上的 cwd 是真实项目路径（目录名只是转义后的 slug，不能当路径用）
+                    if not cwd and ev.get("cwd"):
+                        cwd = ev["cwd"]
+                    if ev.get("type") == "queue-operation" and ev.get("operation") == "enqueue":
+                        if not preview:
+                            preview = _preview_cut(ev.get("content"))
+                    elif ev.get("type") == "user":
+                        msg_count += 1
+                        msg = (ev.get("message") or {})
+                        content = msg.get("content")
+                        if isinstance(content, list):
+                            content = " ".join(
+                                b.get("text", "") for b in content if isinstance(b, dict))
+                        if not preview:
+                            pv = _preview_cut(content)
+                            if pv and not str(content or "").startswith("<"):
+                                preview = pv
+                    if preview and msg_count > 1 and cwd:
+                        break
+        except Exception:
+            continue
+        out.append({
+            "agent": "claude-code",
+            "session_id": f.stem,
+            "file": str(f),
+            "project": cwd or f.parent.name,
+            "mtime": _fmt_ts(f.stat().st_mtime),
+            "turns": msg_count,
+            "preview": preview or "（未解析到用户消息）",
+        })
+        if len(out) >= SCAN_LIMIT:
+            break
+    return out
+
+
+def _scan_opencode_db(db_path, agent):
+    """opencode 系会话库（opencode / mimocode 同源同 schema）。
+
+    只读打开（mode=ro 不阻塞 WAL）；每会话取标题兜底，再找第一条
+    用户消息的首个文本 part 做预览。
+    """
+    if not db_path.is_file():
+        return []
+    uri = "file:%s?mode=ro" % str(db_path).replace("\\", "/")
+    try:
+        con = sqlite3.connect(uri, uri=True)
+    except Exception:
+        return []
+    out = []
+    try:
+        rows = con.execute(
+            "SELECT id, directory, title, time_updated FROM session "
+            "WHERE time_archived IS NULL "
+            "ORDER BY time_updated DESC LIMIT ?", (SCAN_LIMIT,)).fetchall()
+        for sid, directory, title, ts in rows:
+            preview = _preview_cut(title)
+            try:
+                for mid, mdata in con.execute(
+                        "SELECT id, data FROM message WHERE session_id=? "
+                        "ORDER BY time_created LIMIT 6", (sid,)):
+                    if json.loads(mdata).get("role") != "user":
+                        continue
+                    texts = []
+                    for (pdata,) in con.execute(
+                            "SELECT data FROM part WHERE session_id=? AND message_id=? "
+                            "ORDER BY time_created LIMIT 4", (sid, mid)):
+                        p = json.loads(pdata)
+                        if isinstance(p, dict) and p.get("text"):
+                            texts.append(p["text"])
+                    pv = _preview_cut(" ".join(texts))
+                    if pv:
+                        preview = pv
+                    break
+            except Exception:
+                pass
+            out.append({
+                "agent": agent,
+                "session_id": sid,
+                "file": str(db_path),
+                "project": directory or "",
+                "mtime": _fmt_ts(ts / 1000.0) if ts else "",
+                "preview": preview or "（未解析到用户消息）",
+            })
+    except Exception:
+        pass
+    finally:
+        try:
+            con.close()
+        except Exception:
+            pass
+    return out
+
+
+def _scan_qwen():
+    """QwenCode（gemini-cli 系）会话：~/.qwen/projects/<slug>/chats/<sid>.jsonl，
+    文件名即会话 id（--resume 直接用它）。"""
+    root = qwen_root()
+    if not root.is_dir():
+        return []
+    files = sorted(root.glob("*/chats/*.jsonl"),
+                   key=lambda p: p.stat().st_mtime, reverse=True)
+    out = []
+    for f in files[:SCAN_MAX_FILES]:
+        preview, project, turns = "", "", 0
+        try:
+            with open(f, encoding="utf-8", errors="replace") as fp:
+                for i, raw in enumerate(fp):
+                    if i >= HEAD_LINES:
+                        break
+                    line = raw.rstrip("\n")
+                    if len(line) > 2_000_000:  # 病理超长行跳过，不做解析
+                        continue
+                    if not line.startswith("{"):
+                        continue
+                    try:
+                        ev = json.loads(line)
+                    except Exception:
+                        continue
+                    if ev.get("type") != "user":
+                        continue
+                    if ev.get("provenance") not in (None, "real_user"):
+                        continue
+                    turns += 1
+                    if not project and ev.get("cwd"):
+                        project = ev["cwd"]
+                    if not preview:
+                        msg = ev.get("message") or {}
+                        texts = [p.get("text", "") for p in (msg.get("parts") or [])
+                                 if isinstance(p, dict) and p.get("text")]
+                        pv = _preview_cut(" ".join(texts))
+                        if pv:
+                            preview = pv
+                    if preview and turns > 1:
+                        break
+        except Exception:
+            continue
+        out.append({
+            "agent": "qwencode",
+            "session_id": f.stem,
+            "file": str(f),
+            "project": project or f.parent.parent.name,
+            "mtime": _fmt_ts(f.stat().st_mtime),
+            "turns": turns,
+            "preview": preview or "（未解析到用户消息）",
+        })
+        if len(out) >= SCAN_LIMIT:
+            break
+    return out
+
+
+def scan(force=False):
+    """扫描全部支持的会话源。60 秒缓存；键为 catalog 的智能体 id，
+    恒定包含五个已知源（无会话则空列表），UI 由此判断哪些工具可选。"""
+    if not force and _CACHE["data"] and time.time() - _CACHE["ts"] < 60:
+        return _CACHE["data"]
+    data = {
+        "codex-cli": _scan_codex(),
+        "claude-code": _scan_claude(),
+        "opencode": _scan_opencode_db(opencode_db(), "opencode"),
+        "qwencode": _scan_qwen(),
+        "mimo-code": _scan_opencode_db(mimo_db(), "mimo-code"),
+    }
+    _CACHE["data"] = data
+    _CACHE["ts"] = time.time()
+    return data