一个抖音遥控器的开发小记

最近折腾了一个很无聊的东西:给抖音做了一个遥控器。

需求也很简单,我想躺在客厅沙发上,用电视刷抖音。手机当然能刷,但电视屏幕更大,声音也好很多。电脑也能刷,不过既然已经躺在沙发上了,再抱着一台电脑有点奇怪。我家的电视接了一台 Apple TV,书房里还有一台常年开着的 Mac mini,所以最开始想的只是怎么把这几样东西拼起来。

一开始最直接的办法是 iPhone AirPlay。我用的是 iPhone 13,投屏没什么问题,但刷一会儿手机就很热,长时间投屏还会卡,基本得一直充电。

然后问题从「怎么在电视上刷抖音」变成了「怎么远程控制一台放在那里不能动的 iPhone」。苹果在 Accessibility 上做的东西比我以前想象得多得多,我试了 Switch Control,又研究了 Voice Control——它甚至让我看到一条理论上真能走通的路:让 Mac 播放一句「向上滑」,iPhone 自己听到以后,再通过 Voice Control 去操作抖音。做到这里事情已经有点离谱了,我本来只是想切下一条视频,现在变成一台电脑对着一台手机说话,然后手机听懂以后帮我滑一下屏幕。

真正让事情简单下来的是,我后来才发现 macOS 居然有官方抖音 App。于是 iPhone 可以完全退出播放链路,Mac mini 在书房跑抖音,把屏幕镜像到 Apple TV,电视负责最终的画面和声音。

现在剩下的问题只有一个:我躺在沙发上的时候,怎么控制书房里的 Mac mini?

Apple TV 遥控器控制不了正在投屏的 Mac。无线鼠标可以,但躺着拿鼠标找光标刷短视频,体验也好不到哪去。我真正需要的只有三个动作:上一条、播放暂停、下一条。

如果只看最终需求,这东西十分钟就能设计完:手机浏览器里放三个大按钮,Mac mini 上起一个 HTTP Server,收到请求发几个键盘事件,结束。这大概也是专门做一个抖音遥控器最合理的实现。

但我那段时间刚好一直在折腾 free4chat,于是这三个按钮最后走上了一条明显有点过度设计的路。下面就从这一条路讲起。

把 Agent 请进房间

Free4Chat 最早只是我很多年前做的一个 WebRTC 匿名聊天室,之前写过一篇《一个 WebRTC 聊天室的四次演进》,后来它慢慢加入了 Agent。现在我使用 Free4Chat,经常不是打开 Chat 页面问 Agent 一个问题,而是先开一个 Room,把运行在某台机器上的 Agent 接进来。这次也是一样。

Mac mini 上运行着 free4chat-agent,这是加入 Room、接收任务的本地 Agent Runtime。我在房间里创建 Task,并选择 Codex 作为这次执行任务的 Harness——也就是实际接手工作的 Agent 环境。需求只有一句:这台机器已经装好了抖音,我想在手机上遥控上一条、下一条和播放暂停。后面基本就让它自己干了。

只认能力,不管集成

Agent 已经进了房间、接下了任务,但要控制抖音,还差一层东西。

Codex 接到 Task 以后,先研究怎么控制 macOS 上的抖音。最后没什么黑科技,也没有逆向抖音协议:macOS 版抖音本身就支持键盘操作,所以底层还是 Accessibility 和 Keyboard Event。

有意思的是,Accessibility 这套东西本来不是给 Agent 准备的。苹果几十年来投入大量资源做它,是为了让那些不能正常用鼠标、键盘、触摸屏的人也能操作软件;结果 Agent 出现以后,这些能力突然多了一类完全没有预料到的使用者——Agent 也没有手。对一个没有 API 的桌面软件,Agent 同样需要知道界面上有什么、什么能操作、怎么触发,而 Accessibility Tree 和 Keyboard Event 恰好就是机器理解 GUI 的一个现成入口。所以这次抖音遥控器最后根本没用到多复杂的 Computer Vision,几个键盘事件就够了——苹果当年的这份善意,在 Agent 时代意外地得到了一份回报。

但我不希望 Runtime 看到的是 pressArrowDown()、pressSpace()、pressArrowUp() 这类东西,更不希望 Free4Chat 服务端里出现一个 DouyinIntegration。最后 Agent 做的是一个很薄的本地 Adapter。这个 Adapter 是 Codex 在 Room 里设计、实现、测试出来的,就一个 Objective-C 的 .m 文件,打包成一个本地 App 装到了 Mac 上。它对 Runtime 只暴露几个语义动作:

douyin_remote
|-- previous
|-- play_pause
`-- next

Runtime 只需要知道这里有一个 Capability,可以列出来、描述、调用,必要时观察状态。至于这个 Capability 底下到底是 Accessibility、AppleScript、CUPS、串口、局域网 HTTP、厂商 SDK,还是以后某个 ESP32,Runtime 不需要理解。真正和厂商、设备、操作系统协议打交道的是 Adapter。

flowchart TB
    Runtime["Agent Runtime<br/>Capability calls"]
    Adapter["External Adapter<br/>douyin_remote"]
    OS["macOS<br/>Accessibility / Keyboard"]
    App["Douyin.app"]

    Runtime -->|"describe / invoke / observe"| Adapter
    Adapter --> OS
    OS --> App

这条边界我后来概括成一句话:Runtime knows capabilities, not integrations.

这个区别看起来很小,但它决定了 Free4Chat 会不会慢慢变成另一个 Home Assistant,或者另一个 Zapier。如果每接一个东西都往服务端写 Integration——打印机一套、抖音一套、B 站一套、智能灯再一套——最后 Runtime 必须知道所有厂商协议,服务端还得替大家保存各种 Credential。我不太想走这条路。能力属于 Participant,自定义 Integration 也属于 Participant,Free4Chat 只需要知道当前 Room 里某个 Participant 愿意临时暴露哪些能力。

之前我拿一台 Epson 打印机做过类似实验,底层 Adapter 走本机 CUPS,但对 Runtime 来说它只是一项类似 printer_status 的语义能力。打印机和抖音看起来完全没有关系,到了 Runtime 这一层其实是一样的:

printer_status
douyin_remote

一个读打印机状态,一个控制本地 App。至于后面是硬件还是软件,对 Room 不重要。

交回来的不只是一段文字

到这里 Agent 自己已经能控制抖音了,我在 Room 里说「下一条」,它调用 douyin_remote.next,书房里的抖音就真的会切换。但这显然不是一个遥控器,如果每看完一条视频都要给 Codex 发一句 next,还不如回去研究小爱同学。

所以我继续让它做手机界面。Codex 根据刚刚接好的本地控制接口,生成了一个简单遥控器,全屏以后大概就是三个按钮:Previous、Play / Pause、Next。

第一版其实很丑,不过它能在同一个 Task 里一直改:让 Codex 接着调,界面实时更新,手机这边不用刷新。

我在 iPhone 上打开这个遥控器,按下 Next,电视上的视频几乎马上切到了下一条。响应很快,实际用起来就像普通遥控器,没有「等 Codex 想一下」这一步。后来我又在第二台设备上打开它,两端可以共享遥控器状态并控制 Mac mini。

顺便说一句,Chat 产品很容易默认 Agent 的结果就是一条 Message,但 Task 的产出远不止这一种:设计文档是 Artifact,需要人观察的运行程序是 Live View,需要人继续操作的就是一个 App。抖音遥控器属于最后一种,而且这三个按钮背后控制的不是 Mock API,是一台真的放在书房里的 Mac mini。

到这里,这个需求其实已经完成了。手机上还是三个按钮,我点一下,电视上的抖音就动一下。但那个 Next 按钮按下去以后到底发生了什么,才是这次真正想说的。

按下 Next 之后发生了什么

先看这次原型的完整链路:

flowchart TB
    subgraph Phone["iPhone / Browser"]
        App["Generated Task App<br/>Previous / Play / Next"]
        Host["Task App Host"]
        App --> Host
    end

    subgraph Room["Free4Chat Room"]
        Presence["Presence / Identity"]
        Task["Task State"]
        Permission["Authorization"]
        Projection["Capability discovery metadata"]
        AppState["App Metadata / Shared State"]
    end

    subgraph Mac["Mac mini / Agent Participant"]
        Runtime["Agent Runtime"]
        Router["Capability Router"]
        Adapter["douyin_remote Adapter"]
        Accessibility["macOS Accessibility / Keyboard"]
        Douyin["Douyin.app"]

        Runtime --> Router
        Router --> Adapter
        Adapter --> Accessibility
        Accessibility --> Douyin
    end

    Host -. "Host context / Room authorization" .-> Room
    Host == "Reliable WebRTC DataChannel" ==> Runtime
    Room -. "Addressed Task event / authorization context" .-> Runtime

    Douyin -->|"AirPlay"| ATV["Apple TV"]
    ATV --> TV["Television"]

这个图里最容易让人误解的一点,是中间那个 Room。看到一个云端 Room,直觉上很容易认为这个按钮的调用也要这样走:

iPhone → Cloudflare Worker → RoomSession(这个 Room 的 Durable Object)→ Mac mini

但在这个设计里,按钮调用不经过 Room 转发。Room 的确是这个协作空间的状态中心——每个 Room 对应一个 RoomSession(Durable Object),负责协调成员、Task 和权限——但手机发起的按钮操作是要送到 Mac mini 的本地控制接口,不需要由 Room 一次次转发。这里实际上有两条不同的路径。

请求不再经过 Room 中转

Free4Chat 本来就是一个实时协作系统,所以浏览器和 Room 会持续交换协作状态:谁加入或离开、Task 进行到哪一步、Agent 是否还在工作,这些都属于 Room 的状态。浏览器通过 WebSocket 同步这些状态,RoomSession 负责协调。谁能参加、谁能操作属于这条控制链路。

但按下 Next 是另外一回事。它最终要触发的是 Mac mini 上的本地操作,如果每次按钮点击都走 Browser → Worker → RoomSession → Agent → Runtime → Adapter,那 Room 很快就会变成一个万能远程调用代理:所有 Participant-local 数据都要绕云端,实时调用的延迟和成本都会增加,服务端开始承担本来属于 Participant 的 Integration 责任,更麻烦的是,本地 Credential 和隐私边界也容易慢慢向中心移动。

所以我把这两件事拆开了:

flowchart TB
    subgraph CP["Control Plane"]
        WS["Room WebSocket"]
        DO["RoomSession<br/>Durable Object"]
        Presence["Presence / Identity"]
        Tasks["Task Lifecycle"]
        Perm["Permissions"]
        Apps["App Metadata / Shared State"]
        Cap["Capability discovery metadata"]

        WS --> DO
        DO --> Presence
        DO --> Tasks
        DO --> Perm
        DO --> Apps
        DO --> Cap
    end

    subgraph DP["Participant Data Plane"]
        Browser["Human Browser"]
        Host["Task App + bounded Host API"]
        DC["Reliable WebRTC DataChannel"]
        Runtime["Agent Runtime"]
        Adapter["Local Adapter"]

        Browser --> Host
        Host --> DC
        DC --> Runtime
        Runtime --> Adapter
    end

    CP -. "identity / addressing / authorization" .-> DP

控制面负责维护 Room 成员、Task 状态和操作权限;数据面负责把按钮操作送到 Mac mini。授权关系由控制面确认,按钮调用本身走 Participant 之间的数据面,RoomSession 不再做逐次应用层中转。

这里说的「直达」,不是浏览器和 Mac mini 建立纯 P2P 连接,而是调用不再经过 RoomSession 做应用层 RPC 中转。Human 和 Agent 仍然通过 Free4Chat 的 WebRTC / SFU participant transport 通信,按钮命令走可靠 DataChannel;Mac mini 上的 Go Runtime 则通过 Pion 作为一个无头 Participant 接入这条实时链路。

对一个 next 来说,这个区别当然感觉不到。但当以后本地能力变成实时控制、连续状态同步、硬件传感器,或者 Room 里同时出现很多 Participant 时,这条边界会越来越重要。Free4Chat 最早做 WebRTC 时,我考虑的是音频媒体怎么在 Participant 之间流动;这次本地控制让我想到,可以用可靠 DataChannel 把按钮命令送到 Agent Runtime。聊天室和 Agent Runtime 就这样慢慢连到了一起。

一次生成,反复使用

还有一个我比较在意的设计:点击 Next 以后,不应该再调用一次 Codex。如果路径是「Human Click → LLM → 理解 Next → 选择 Tool → Capability Invoke」,那做遥控器就非常奇怪——模型推理有延迟、有成本,还不是完全确定性的,一个三个按钮的遥控器没有理由每按一次都重新让模型思考。

所以这次其实有两个完全不同的阶段:

flowchart TB
    subgraph Build["Build Time - selected Harness via ACP"]
        Req["Human Requirement"]
        RuntimeBuild["Agent Runtime"]
        Harness["Selected Harness<br/>Codex"]
        Inspect["Inspect Environment"]
        BuildAdapter["Build Adapter"]
        Register["Register Capability"]
        Generate["Generate Task App"]

        Req --> RuntimeBuild
        RuntimeBuild --> Harness
        Harness --> Inspect
        Harness --> BuildAdapter
        BuildAdapter --> Register
        Harness --> Generate
    end

    subgraph Run["Run Time - deterministic hot path"]
        Human["Human Click"]
        App["Task App"]
        Host["Task App Host"]
        DC["DataChannel"]
        Runtime["Agent Runtime"]
        Adapter["douyin_remote"]
        Action["Accessibility / Keyboard"]

        Human --> App
        App --> Host
        Host --> DC
        DC --> Runtime
        Runtime --> Adapter
        Adapter --> Action
    end

    Register --> Runtime
    Generate --> App

构建期里,Codex 这个 Harness 通过 ACP(Agent Client Protocol)研究环境、写 Adapter、生成界面。ACP 管的是 Host 怎么控制一个 Agent——Session、Streaming、Permission、Cancellation;MCP(Model Context Protocol)在另一侧,管 Agent 怎么发现和使用工具。东西做完以后,Agent 就退出 Runtime 热路径,Human 每一次点击都只是普通的确定性 RPC;换一个支持的 Harness,Room 与 Runtime 的边界不变。

这个设计和我最近在其他 Agent 项目里越来越常用的一种思路其实很像:让模型负责模糊的、高层的、一次性的生成和决策,让传统程序负责高频、确定、可验证的执行。只不过这次这个分界非常直观,模型最后留下来的就是三个按钮。

这个分界,我在《Jev 的边界》里详细写过。三个动作的规则完全能写死,所以运行期连 Decision Model 都用不上。

一个按钮背后的状态

前面已经画了不少图,但还有一个地方特别容易被忽略:从用户角度,这个遥控器的状态非常少,最多就是 Ready / Unavailable。然而要让 Next 真的工作,背后至少同时存在很多不同生命周期的状态,而且它们不属于同一个进程:

层 状态
协作层(Room) Room membership、Human session、Agent participant session、Task lifecycle、Task execution state、Permission state
界面层(浏览器) Task App lifecycle、Task App Host state、Shared App state、Room WebSocket
传输层(RTC) WebRTC PeerConnection、Publisher / Subscriber session、DataChannel
运行时层(Mac) Agent harness session、Capability projection、Capability authorization、Runtime transport、Adapter process
系统层(OS / 设备) macOS Accessibility permission、Douyin application state、AirPlay session

把这些状态串起来,才是那次点击背后真正的依赖链:

flowchart TB
    A["Human / Task ready"]
    B["Participant transport ready"]
    C["Capability authorized"]
    D["Runtime route ready"]
    E["Local Adapter / OS permission ready"]
    F["TV picture changes"]

    A --> B
    B --> C
    C --> D
    D --> E
    E --> F

任何一个条件不成立,Human 最后看到的可能都只是一个按钮不可用。麻烦也就在这里:状态不是越多越高级,能删当然应该删,但很多边界是客观存在的——Human 和 Agent 是不同 Participant,浏览器和 Runtime 是不同进程,Room 和本地机器不在同一个网络,Task 和 Agent Session 也不是同一个生命周期。把文件拆得再漂亮,也不会让这些状态消失。最后真正要搞清楚的,是每个状态属于谁,谁有权推进下一次转换,失败以后又由谁负责恢复。

Room 是一个临时的信任边界

上面这些状态里,最值得先说清楚的是「属于谁」。遥控器做完后,我注意到一个顺手得到的效果:它并不属于我的 iPhone。我用自己的手机进 Room 可以控制,换另外一台设备也可以,同一个 Room 里的另一个 Human,如果有权限,也可以打开同一个 Task App 去控制 Mac mini。

但这不代表 douyin_remote 被复制到了他们的手机,更不代表我把 Mac mini 变成了一个永久公开的 HTTP API。几个东西其实属于不同的 Owner:

Capability    → Mac mini Participant
Adapter       → Mac mini / Agent
Task App      → Task
Authorization → Room
Human         → 临时使用 Capability

能力一直留在 Mac mini,Adapter 也只在 Mac mini 本地运行。Room 只是知道:当前这个 Agent Participant 投影出了什么 Capability,当前这些 Human 在这个临时协作空间里是否可以使用它。这段关系仍然是临时的:Participant / Runtime 离开、Adapter 不可用或者 Room 失效以后,这条调用链也就不存在了。

所以我现在越来越倾向把 Room 理解成一个 Trust Boundary。它不是 Integration 的 Owner,也不应该成为本地 Credential 的仓库。这对抖音当然没那么重要,但如果以后接的是公司内网、家里的智能设备、打印机、本地文件或者其他不能直接暴露到公网的东西,这个模型会比「给每个东西做一个云端 Integration」舒服很多。

到了这一步,再叫 Free4Chat 一个「AI 聊天室」已经不太准确了。Room 里同时存在 Human、Agent、Task、App 和本地 Capability,它们各自有生命周期,也各自有权限边界。Room 做的事情,越来越像是在这些东西之间临时建立一段可撤销的协作关系。

生成容易,信任难

把边界讲清楚以后,还剩下最后一个问题:Agent 生成的界面应该拿到多少权限。

让 Agent 生成 HTML 并不困难,现在随便一个 Coding Agent 都可以十几秒写一个遥控器界面。麻烦的是,我为什么敢运行它?如果一个 Agent 生成的 JavaScript 可以直接拿到 Room 的内部对象、Agent Credential、本机 Runtime,甚至任意调用系统能力,那 Generated App 越强,安全问题就越大。

所以 Task App 不是「Agent 生成一段 JS,然后浏览器随便执行」,中间还有一个 App Host:

flowchart TB
    Generated["Agent Generated Task App"]
    Sandbox["Sandboxed iframe"]
    Host["Task App Host<br/>bounded MessagePort API"]
    State["Room shared-state API"]
    Lane["Reliable WebRTC DataChannel"]
    Runtime["Agent Runtime<br/>capability route"]
    Adapter["Local Adapter"]
    Room["RoomSession<br/>Task / authorization state"]

    Generated --> Sandbox
    Sandbox --> Host
    Host -->|"bounded shared-state calls"| State
    State --> Room
    Host -->|"explicit Human click"| Lane
    Lane --> Runtime
    Runtime --> Adapter
    Room -. "binds Task / Agent / Human authorization" .-> Runtime

App 运行在一个受限的 Host Contract 里面,它不应该知道 Mac mini 上的 Adapter 怎么启动,也不应该直接拥有本地系统权限。它看到的是 Host 暴露出来的有限能力,比如共享状态,或者对已经授权 Capability 的调用。像 douyin_remote.next 这种会在真实机器上产生 Side Effect 的操作,调用还需要满足 Human Interaction 的安全边界:Agent 可以生成那个按钮,但不等于它生成的 App 就可以在后台悄悄无限触发本地动作。

这个区别在一个抖音遥控器里有点小题大做,但如果把 next 换成 open_door、start_printer、move_robot、delete_file,事情一下就不一样了。所以对 Generated UI 来说,<button> 本身没什么难度,难的是怎么把它放进一个可控的执行边界里。

从抖音到 B 站,再到打印机

抖音跑通以后,B 站、打印机、以后某个只在局域网里能访问的 ESP32,其实都是同一个模式——不同的只是 Capability:douyin_remote 是三个按钮,bilibili_remote 多了 fullscreen 和 favorite,printer_status 是 state 和 accepting_jobs。

复用的其实不是「怎么按抖音的下一条」,而是这一整条路径:

Local Integration → Semantic Capability → Participant Runtime → Temporary Room → Agent-generated Human Interface

所以抖音本身没那么重要。能力由参与者带来,Room 只是在需要协作的时候,把这些 Human、Agent 和 Capability 临时接起来。

当软件可以现做现用

如果把前面所有东西重新压回去,最后留在手机上的还是三个按钮。

Previous、Play / Pause、Next。

我按下 Next,电视切到下一条视频。不到一秒,也不需要再经过一次 LLM。

如果只是为了做这个遥控器,一个 HTTP Server 显然简单得多。之所以绕了这么大一圈,是因为做到最后,我发现真正有意思的已经不是这个遥控器了。

这个 App 在几分钟前其实还不存在。

没有人为它立项,没有产品经理写需求,没有工程师排期,没有发版,没有 App Store 审核,也没有成千上万的人先替我用过一遍。

我只是说,我想要三个按钮。

Agent 看了这台 Mac 上有什么,找到了控制抖音的方法,做了一个 Adapter,把它变成几个语义 Capability,又根据这些 Capability 生成了一个界面。

然后我就开始用了。

做到这里,我才意识到,变化可能不只是 Agent 帮人写代码。

过去我们习惯的软件,有一个很长的生产过程:

需求 → 设计 → 开发 → 测试 → 发布 → 安装 → 使用。

Agent 正在把中间这一大段不断压缩。

需求出现,软件出现。

前段时间写《置身 Agent 时代》的时候,我把这种变化概括成 Engineering scarcity 正在下降。以前一个想法值不值得做,首先要考虑它需要多少工程时间;现在越来越多时候,真正的问题已经不是「做不做得出来」。

这个遥控器把那件事又往前推了一步。

再往前走一点,也许很多软件甚至不会被「发布」。它只在某个任务里临时出现,解决一个非常具体的问题,用完以后就消失。

如果软件真的可以在需求出现以后临时生成,那么接下来的问题就不只是「谁还需要写这些软件」,而是:这些刚刚出生的软件,凭什么立刻获得作用于真实世界的能力?

做一个三个按钮的遥控器当然只是个很傻的例子。

但如果生成出来的不是遥控器,而是一个可以读公司内部文件的工具、一个能控制家里设备的面板、一个能操作机器人和打印机的界面,或者一个能够修改真实数据的临时应用,事情就会变得完全不同。

因为软件生成得再快,也不意味着我应该让它想干什么就干什么。

这也是为什么前面那些看起来有点过度设计的东西最后都留了下来:Sandbox、Human Interaction、Capability ownership、Room authorization、Participant-local Adapter、确定性的 Runtime hot path。

它们没有让那个 Next 按钮变得更聪明。

它们解决的是另一个问题:

一段几秒前才出生的软件,凭什么现在就可以碰真实世界?

以前我们很大一部分信任来自软件的上游。我们知道是谁开发的,从哪里下载的,有没有被审核过,多少人已经用过。

但如果软件越来越多是在使用的那一刻才被 Agent 临时生成,这套信任方式可能会越来越不够用。

代码本身会越来越便宜。

界面会越来越便宜。

甚至很多 Integration 也可以临时生成。

真正没有一起变便宜的,也许是那条把软件和真实世界隔开的边界。

于是三个按钮最后留下来的问题,反而不是 Agent 还能生成多少软件。

而是:

如果未来的软件不是我们提前选择、安装并长期信任的产品,而是在需求出现的那一刻由 Agent 临时生成——我们对软件的信任,会不会也从「它是谁做的」,逐渐转向「它能看见什么、能调用什么、能影响到哪里,以及什么时候必须失效」?


代码:free4chat · 体验:https://free4.chat

内容来自 构建我的被动收入,版权归原作者所有。

阅读原文 ↗

把喜欢的内容,留在你的新标签页。

打开我的订阅