Parcels 重写实验：从 bash 到 Go+Wails

parcels-go/
├── main.go                     # Wails 入口
├── app.go                      # Wails 暴露给前端的方法
├── internal/
│   ├── config/                 # 对应 bash 的 load_target
│   │   └── target.go
│   ├── agent/                  # 对应 bash 的 claude_dir/ship_claude
│   │   ├── agent.go            # Agent 接口
│   │   ├── claude.go
│   │   ├── codex.go
│   │   ├── pi.go
│   │   └── droid.go
│   ├── parcel/                 # 对应 bash 的 cmd_send
│   │   ├── sender.go           # 核心编排
│   │   ├── handoff.go          # HANDOFF.md 生成
│   │   └── sync.go             # rsync 封装
│   ├── remote/                 # 对应 bash 的 SSH 调用
│   │   ├── ssh.go              # SSH 客户端
│   │   └── tmux.go             # tmux 操作
│   └── ui/                     # Wails 前端
│       └── (React/Vue 文件)
├── frontend/                   # Wails 生成的前端工程
└── go.mod

// internal/config/target.go
package config

import (
    "fmt"
    "os"
    "path/filepath"

    "github.com/BurntSushi/toml"
)

type Target struct {
    Host     string `toml:"host"`      // SSH 主机(Tailscale 别名)
    DestBase string `toml:"dest_base"` // 远端存放目录,默认 "ai"
    Agent    string `toml:"agent"`     // 默认 agent: claude/codex/pi/droid
}

func ConfigDir() (string, error) {
    home, err := os.UserHomeDir()
    if err != nil {
        return "", err
    }
    return filepath.Join(home, ".parcels"), nil
}

// Load 加载单个 target 配置(对应 bash 的 load_target)
func Load(name string) (*Target, error) {
    dir, err := ConfigDir()
    if err != nil {
        return nil, err
    }
    path := filepath.Join(dir, "targets", name+".toml")
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("unknown target %q: %w", name, err)
    }
    var t Target
    if err := toml.Unmarshal(data, &t); err != nil {
        return nil, err
    }
    // 默认值(对应 bash 的 HOST="" DEST_BASE="ai" AGENT="claude")
    if t.DestBase == "" {
        t.DestBase = "ai"
    }
    if t.Agent == "" {
        t.Agent = "claude"
    }
    if t.Host == "" {
        return nil, fmt.Errorf("target %q has no host", name)
    }
    return &t, nil
}

// ListAll 列出所有 target(对应 bash 的 cmd_targets)
func ListAll() (map[string]*Target, error) {
    dir, err := ConfigDir()
    if err != nil {
        return nil, err
    }
    targetsDir := filepath.Join(dir, "targets")
    entries, err := os.ReadDir(targetsDir)
    if err != nil {
        return map[string]*Target{}, nil // 没配置返回空
    }
    out := make(map[string]*Target)
    for _, e := range entries {
        if e.IsDir() || filepath.Ext(e.Name()) != ".toml" {
            continue
        }
        name := e.Name()[:len(e.Name())-len(".toml")]
        t, err := Load(name)
        if err != nil {
            continue
        }
        out[name] = t
    }
    return out, nil
}

// internal/agent/agent.go
package agent

import "context"

// SessionInfo 描述一个待移植的 agent 会话
type Session struct {
    ID       string // 会话 UUID
    File     string // 本地会话文件路径(.jsonl)
    RemoteDir string // 远端存放会话的目录(相对 $HOME)
}

// ResumeCmd 远端启动 agent 的命令
type ResumeCmd struct {
    Cmd  string   // 完整命令行
    Args []string // 参数
}

// Agent 抽象一家 AI agent 的移植能力
// 对应 bash 的 ship_claude / ship_codex / ship_pi / ship_droid
type Agent interface {
    // Name 返回 agent 标识
    Name() string

    // FindSession 根据 repo 路径找最新会话(对应 bash 的 newest_session_jsonl)
    FindSession(repoPath, sessionID string) (*Session, error)

    // PrepareRemote 在远端准备接收会话(建目录、写配置等)
    // 对应 ship_* 里的 ssh mkdir + python 改 json
    PrepareRemote(ctx context.Context, host string, s *Session, remoteRepo string) error

    // ResumeCommand 拼出远端启动命令
    // 对应 ship_* 里设置的 RESUME_CMD
    ResumeCommand(sessionID, prompt string) *ResumeCmd
}

// registry 内部注册表
var registry = map[string]func() Agent{}

func Register(name string, factory func() Agent) {
    registry[name] = factory
}

func Get(name string) (Agent, error) {
    f, ok := registry[name]
    if !ok {
        return nil, fmt.Errorf("unknown agent %q", name)
    }
    return f(), nil
}

case "$AGENT" in
  claude) ship_claude ;;
  codex)  ship_codex ;;
  *) die "unknown agent" ;;
esac

a, err := agent.Get(cfg.Agent)  // 多态分发
a.PrepareRemote(ctx, host, session, remoteRepo)

// internal/agent/claude.go
package agent

import (
    "context"
    "encoding/json"
    "fmt"
    "os"
    "os/exec"
    "path/filepath"
    "regexp"
    "strings"
)

func init() {
    Register("claude", func() Agent { return &Claude{} })
}

type Claude struct{}

func (c *Claude) Name() string { return "claude" }

// claudeDir 对应 bash 的 claude_dir()
// Claude Code 把 repo 路径里的非字母数字替换成 -
var nonAlnum = regexp.MustCompile(`[^A-Za-z0-9]`)

func claudeProjectDir(repo string) string {
    return nonAlnum.ReplaceAllString(repo, "-")
}

func (c *Claude) FindSession(repoPath, sessionID string) (*Session, error) {
    dirName := claudeProjectDir(repoPath)
    sdir := filepath.Join(os.Getenv("HOME"), ".claude", "projects", dirName)

    var sfile string
    if sessionID != "" {
        sfile = filepath.Join(sdir, sessionID+".jsonl")
        if _, err := os.Stat(sfile); err != nil {
            return nil, fmt.Errorf("session %s not found: %w", sessionID, err)
        }
    } else {
        // 找最新的 UUID.jsonl(对应 bash 的 newest_session_jsonl)
        sfile = findNewestSession(sdir)
        if sfile == "" {
            return nil, fmt.Errorf("no claude session in %s", sdir)
        }
    }

    // 提取 session id
    base := filepath.Base(sfile)
    sid := strings.TrimSuffix(base, ".jsonl")

    return &Session{
        ID:        sid,
        File:      sfile,
        RemoteDir: filepath.Join(".claude", "projects", dirName),
    }, nil
}

// PrepareRemote 对应 ship_claude 里的三件事:
// 1. mkdir 远端目录
// 2. rsync 会话文件过去
// 3. 改 ~/.claude.json 设置 hasTrustDialogAccepted(绕过 trust dialog)
func (c *Claude) PrepareRemote(ctx context.Context, host string, s *Session, remoteRepo string) error {
    // 1. 建目录
    if err := runSSH(ctx, host, "mkdir -p "+quote(s.RemoteDir)); err != nil {
        return fmt.Errorf("mkdir remote: %w", err)
    }

    // 2. rsync 会话文件(对应 rsync -a "$sfile" "$HOST:$rdir/")
    cmd := exec.CommandContext(ctx, "rsync", "-a", s.File, host+":"+s.RemoteDir+"/")
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    if err := cmd.Run(); err != nil {
        return fmt.Errorf("rsync session: %w", err)
    }

    // 3. 改 ~/.claude.json 预信任目录(对应那段 python heredoc)
    // 用 Go 重写,不再依赖远端 python3
    trustScript := fmt.Sprintf(`
import json, os
p = os.path.expanduser("~/.claude.json")
try: cfg = json.load(open(p))
except: cfg = {}
proj = cfg.setdefault("projects", {}).setdefault(%q, {})
proj["hasTrustDialogAccepted"] = True
json.dump(cfg, open(p, "w"))
`, remoteRepo)
    if err := runSSHStdin(ctx, host, "python3 -", trustScript); err != nil {
        return fmt.Errorf("set trust flag: %w", err)
    }

    return nil
}

// ResumeCommand 对应 ship_claude 末尾的 RESUME_CMD
func (c *Claude) ResumeCommand(sessionID, prompt string) *ResumeCmd {
    return &ResumeCmd{
        Cmd:  "claude",
        Args: []string{"--resume", sessionID, "--dangerously-skip-permissions", prompt},
    }
}

// --- 公共辅助函数 ---

var sessionFileRe = regexp.MustCompile(`/[0-9a-f]{8}-[0-9a-f-]{27}\.jsonl$`)

func findNewestSession(dir string) string {
    entries, err := os.ReadDir(dir)
    if err != nil {
        return ""
    }
    // 按 ModTime 倒序
    // (省略排序细节,选第一个匹配 UUID.jsonl 的)
    for _, e := range entries {
        if e.IsDir() {
            continue
        }
        full := filepath.Join(dir, e.Name())
        if sessionFileRe.MatchString(full) {
            return full // 实际应按时间排序
        }
    }
    return ""
}

func quote(s string) string {
    return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
}

func runSSH(ctx context.Context, host, cmd string) error {
    return exec.CommandContext(ctx, "ssh", host, cmd).Run()
}

func runSSHStdin(ctx context.Context, host, cmd, stdin string) error {
    c := exec.CommandContext(ctx, "ssh", host, cmd)
    c.Stdin = strings.NewReader(stdin)
    return c.Run()
}

// internal/parcel/sender.go
package parcel

import (
    "context"
    "fmt"
    "log"
    "os/exec"
    "path/filepath"
    "strings"
    "text/template"
    "time"

    "parcels-go/internal/agent"
    "parcels-go/internal/config"
)

type SendOptions struct {
    Target    string // 目标机器名
    AgentName string // claude/codex/pi/droid,空则用 target 默认
    SessionID string // 指定会话 ID,空则自动找最新
    Prompt    string // 自定义 prompt,空则用默认
    Dest      string // 自定义远端目录
    Idle      bool   // true = 只搬运不启动
}

type SendResult struct {
    Target     string
    RemoteRepo string
    Agent      string
    TmuxSession string
    Idle       bool
}

// 默认 prompt(对应 bash 的 DEFAULT_PROMPT)
const DefaultPrompt = `You have been handed off from another machine. Read HANDOFF.md at the repo root, verify the state it describes (git status, running processes), and continue the work. Update HANDOFF.md as you go.`

// Send 是核心入口,对应 bash 的 cmd_send
func Send(ctx context.Context, repoPath string, opts SendOptions) (*SendResult, error) {
    // 1. 加载 target
    target, err := config.Load(opts.Target)
    if err != nil {
        return nil, err
    }
    agentName := opts.AgentName
    if agentName == "" {
        agentName = target.Agent
    }
    prompt := opts.Prompt
    if prompt == "" {
        prompt = DefaultPrompt
    }

    // 2. 解析远端 repo 路径
    remoteHome, err := getRemoteHome(ctx, target.Host)
    if err != nil {
        return nil, fmt.Errorf("cannot reach %s: %w", target.Host, err)
    }
    repoName := filepath.Base(repoPath)
    remoteRepo := opts.Dest
    if remoteRepo == "" {
        remoteRepo = filepath.Join(remoteHome, target.DestBase, repoName)
    }

    // 3. 生成 HANDOFF.md(对应 bash 的 Step 1)
    if err := updateHandoff(repoPath, opts.Target, remoteRepo, agentName); err != nil {
        return nil, fmt.Errorf("update handoff: %w", err)
    }
    log.Println("· HANDOFF.md updated")

    // 4. rsync 整个工作树(对应 bash 的 Step 2)
    log.Printf("· rsync %s → %s:%s", repoPath, target.Host, remoteRepo)
    if err := syncRepo(ctx, repoPath, target.Host, remoteRepo); err != nil {
        return nil, fmt.Errorf("sync repo: %w", err)
    }

    // 5. 移植 agent 会话(对应 bash 的 Step 3 + ship_*)
    a, err := agent.Get(agentName)
    if err != nil {
        return nil, err
    }
    session, err := a.FindSession(repoPath, opts.SessionID)
    if err != nil {
        return nil, err
    }
    if err := a.PrepareRemote(ctx, target.Host, session, remoteRepo); err != nil {
        return nil, err
    }
    log.Printf("· %s session %s → %s", a.Name(), session.ID, target.Host)

    resumeCmd := a.ResumeCommand(session.ID, prompt)

    // 6. 启动 tmux(对应 bash 的 Step 4)
    result := &SendResult{
        Target:     opts.Target,
        RemoteRepo: remoteRepo,
        Agent:      agentName,
        TmuxSession: "parcel-" + repoName,
        Idle:       opts.Idle,
    }

    if opts.Idle {
        log.Println("[ok] parceled (idle)")
        return result, nil
    }

    if err := launchInTmux(ctx, target.Host, remoteRepo, resumeCmd, result.TmuxSession); err != nil {
        return nil, fmt.Errorf("launch tmux: %w", err)
    }

    // 7. 健康检查(对应 bash 的 sleep 3 + tmux ls grep)
    if err := waitForAlive(ctx, target.Host, result.TmuxSession); err != nil {
        return nil, err
    }

    log.Printf("[ok] running on %s in tmux '%s'", opts.Target, result.TmuxSession)
    return result, nil
}

// syncRepo 封装 rsync 调用(对应 bash 的 rsync -az --delete ...)
func syncRepo(ctx context.Context, local, host, remote string) error {
    args := []string{
        "-az", "--delete",
        "--exclude", "node_modules",
        "--exclude", ".venv", "--exclude", "venv",
        "--exclude", "__pycache__",
        "--exclude", ".DS_Store",
        "--exclude", ".next",
        "--exclude", "target/debug", "--exclude", "target/release",
        local + "/", host + ":" + remote + "/",
    }
    cmd := exec.CommandContext(ctx, "rsync", args...)
    cmd.Stdout = log.Writer()
    cmd.Stderr = log.Writer()
    return cmd.Run()
}

// launchInTmux 对应 bash 的"写 launch.sh + tmux new-session -d"
func launchInTmux(ctx context.Context, host, remoteRepo string, rc *agent.ResumeCmd, sessionName string) error {
    // 写 launch.sh(避免引号地狱,bash 版的精髓保留)
    launchContent := fmt.Sprintf("#!/usr/bin/env bash\ncd '%s' || exit 1\n%s %s\n",
        remoteRepo, rc.Cmd, strings.Join(rc.Args, " "))

    // 通过 SSH 写到远端
    remotePath := filepath.Join(remoteRepo, ".parcel", "launch.sh")
    writeCmd := exec.CommandContext(ctx, "ssh", host,
        fmt.Sprintf("mkdir -p '%s/.parcel' && cat > '%s' && chmod +x '%s'",
            remoteRepo, remotePath, remotePath))
    writeCmd.Stdin = strings.NewReader(launchContent)
    if err := writeCmd.Run(); err != nil {
        return fmt.Errorf("write launch.sh: %w", err)
    }

    // 先杀旧 session,再 new -d(对应 bash 的 kill-session + new-session -d)
    launchCmd := fmt.Sprintf(
        "tmux kill-session -t '%s' 2>/dev/null; tmux new-session -d -s '%s' \"bash -lc '%s'\"",
        sessionName, sessionName, remotePath,
    )
    return exec.CommandContext(ctx, "ssh", host, launchCmd).Run()
}

// waitForAlive 改进的存活检查(替代 bash 的 sleep 3)
// 用轮询替代魔法数字
func waitForAlive(ctx context.Context, host, sessionName string) error {
    timeout := time.After(10 * time.Second)
    ticker := time.NewTicker(500 * time.Millisecond)
    defer ticker.Stop()

    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        case <-timeout:
            return fmt.Errorf("tmux session %q did not survive 10s", sessionName)
        case <-ticker.C:
            out, err := exec.CommandContext(ctx, "ssh", host, "tmux ls 2>/dev/null").Output()
            if err == nil && strings.Contains(string(out), sessionName+":") {
                return nil
            }
        }
    }
}

// internal/parcel/handoff.go
package parcel

import (
    "fmt"
    "os"
    "os/exec"
    "path/filepath"
    "strings"
    "time"
)

const machineStateMarker = "## Machine state (auto-generated by parcel"

// updateHandoff 对应 bash 的 Step 1
func updateHandoff(repoPath, targetName, remoteRepo, agentName string) error {
    snap := buildMachineState(repoPath, targetName, remoteRepo, agentName)
    handoffPath := filepath.Join(repoPath, "HANDOFF.md")

    body, err := os.ReadFile(handoffPath)
    if err != nil {
        if os.IsNotExist(err) {
            // 不存在,创建(对应 bash 的 else 分支)
            content := fmt.Sprintf("# HANDOFF\n\n(No agent-written context; resuming from session history alone.)\n\n%s\n", snap)
            return os.WriteFile(handoffPath, []byte(content), 0644)
        }
        return err
    }

    // 存在,半结构化合并(对应 bash 的 python 脚本)
    content := string(body)
    if idx := strings.Index(content, machineStateMarker); idx >= 0 {
        content = strings.TrimRight(content[:idx], "\n") + "\n\n" + snap + "\n"
    } else {
        content = strings.TrimRight(content, "\n") + "\n\n" + snap + "\n"
    }
    return os.WriteFile(handoffPath, []byte(content), 0644)
}

func buildMachineState(repoPath, targetName, remoteRepo, agentName string) string {
    branch := gitOutput(repoPath, "branch", "--show-current")
    if branch == "" {
        branch = "detached"
    }
    lastCommit := gitOutput(repoPath, "log", "--oneline", "-1")
    if lastCommit == "" {
        lastCommit = "none"
    }
    status := gitOutput(repoPath, "status", "--short")
    if len(strings.Split(status, "\n")) > 50 {
        lines := strings.Split(status, "\n")[:50]
        status = strings.Join(lines, "\n")
    }

    hostname, _ := os.Hostname()

    return fmt.Sprintf(`%s - do not edit)
- shipped: %s from %s:%s
- target: %s → %s (agent: %s)
- branch: %s
- last commit: %s
` + "```\n%s\n```",
        machineStateMarker,
        time.Now().Format("2006-01-02 15:04 MST"),
        hostname, repoPath,
        targetName, remoteRepo, agentName,
        branch, lastCommit,
        status,
    )
}

func gitOutput(repoPath string, args ...string) string {
    cmd := exec.Command("git", append([]string{"-C", repoPath}, args...)...)
    out, err := cmd.Output()
    if err != nil {
        return ""
    }
    return strings.TrimSpace(string(out))
}

// app.go
package main

import (
    "context"
    "fmt"
    "log"
    "path/filepath"

    "parcels-go/internal/config"
    "parcels-go/internal/parcel"
    "parcels-go/internal/remote"
)

type App struct {
    ctx context.Context
    lg  *log.Logger
}

func NewApp() *App {
    return &App{lg: log.Default()}
}

// 前端可调用的方法

// ListTargets 返回所有 target,给 GUI 下拉框用
func (a *App) ListTargets() (map[string]TargetInfo, error) {
    targets, err := config.ListAll()
    if err != nil {
        return nil, err
    }
    out := make(map[string]TargetInfo)
    for name, t := range targets {
        out[name] = TargetInfo{
            Host:        t.Host,
            DestBase:    t.DestBase,
            DefaultAgent: t.Agent,
        }
    }
    return out, nil
}

type TargetInfo struct {
    Host         string `json:"host"`
    DestBase     string `json:"destBase"`
    DefaultAgent string `json:"defaultAgent"`
}

// SendResult 给前端的返回
type SendResultUI struct {
    Success      bool   `json:"success"`
    TmuxSession  string `json:"tmuxSession"`
    RemoteRepo   string `json:"remoteRepo"`
    Error        string `json:"error,omitempty"`
}

// Send 触发一次 parcel send,前端调
// 用 Wails 的 EventsEmit 推送实时进度
func (a *App) Send(req SendRequest) SendResultUI {
    a.lg.Printf("send: %+v", req)

    repoPath, err := filepath.Abs(req.RepoPath)
    if err != nil {
        return SendResultUI{Error: err.Error()}
    }

    result, err := parcel.Send(a.ctx, repoPath, parcel.SendOptions{
        Target:    req.Target,
        AgentName: req.Agent,
        SessionID: req.SessionID,
        Prompt:    req.Prompt,
        Dest:      req.Dest,
        Idle:      req.Idle,
    })
    if err != nil {
        return SendResultUI{Error: err.Error()}
    }
    return SendResultUI{
        Success:     true,
        TmuxSession: result.TmuxSession,
        RemoteRepo:  result.RemoteRepo,
    }
}

type SendRequest struct {
    RepoPath  string `json:"repoPath"`
    Target    string `json:"target"`
    Agent     string `json:"agent"`
    SessionID string `json:"sessionId"`
    Prompt    string `json:"prompt"`
    Dest      string `json:"dest"`
    Idle      bool   `json:"idle"`
}

// Status 查询某 target 的 tmux 状态(对应 bash cmd_status)
func (a *App) Status(target string) ([]remote.SessionStatus, error) {
    return remote.ListParcelSessions(a.ctx, target)
}

// Doctor 远端体检(对应 bash cmd_doctor)
func (a *App) Doctor(target string) (*remote.Diagnostic, error) {
    return remote.RunDoctor(a.ctx, target)
}

// Attach 生成 attach 命令(给前端复制用)
func (a *App) Attach(target, sessionName string) string {
    t, err := config.Load(target)
    if err != nil {
        return ""
    }
    return fmt.Sprintf("ssh -t %s tmux attach -t %s", t.Host, sessionName)
}

// main.go
package main

import (
    "embed"

    "github.com/wailsapp/wails/v2"
    "github.com/wailsapp/wails/v2/pkg/options"
    "github.com/wailsapp/wails/v2/pkg/options/assetserver"
    "github.com/wailsapp/wails/v2/pkg/options/mac"
)

//go:embed all:frontend/dist
var assets embed.FS

func main() {
    app := NewApp()

    err := wails.Run(&options.App{
        Title:  "Parcels",
        Width:  900,
        Height: 650,
        AssetServer: &assetserver.Options{
            Assets: assets,
        },
        BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
        OnStartup: func(ctx context.Context) {
            app.ctx = ctx
        },
        Mac: &mac.Options{
            About: &mac.AboutInfo{
                Title:   "Parcels",
                Message: "Ship AI agent work to remote machines over Tailscale",
            },
        },
        Bindings: []interface{}{app},
    })
    if err != nil {
        println("Error:", err.Error())
    }
}

// frontend/src/App.jsx
import { useState, useEffect } from "react";
import { ListTargets, Send, Status, Doctor } from "../wailsjs/go/main/App";

export default function App() {
    const [targets, setTargets] = useState({});
    const [form, setForm] = useState({
        repoPath: "",
        target: "",
        agent: "claude",
        sessionId: "",
        prompt: "",
        idle: false,
    });
    const [status, setStatus] = useState([]);
    const [result, setResult] = useState(null);
    const [loading, setLoading] = useState(false);

    useEffect(() => {
        ListTargets().then(setTargets);
    }, []);

    const handleSend = async () => {
        setLoading(true);
        const res = await Send(form);
        setResult(res);
        setLoading(false);
    };

    const handleStatus = async () => {
        if (!form.target) return;
        const s = await Status(form.target);
        setStatus(s);
    };

    return (
        <div className="min-h-screen bg-slate-900 text-slate-100 p-6">
            <h1 className="text-2xl font-bold mb-6">Parcels</h1>

            <div className="grid grid-cols-2 gap-6">
                {/* 左栏:发送表单 */}
                <div className="bg-slate-800 rounded-lg p-5 space-y-4">
                    <h2 className="text-lg font-semibold">Send</h2>

                    <Field label="Repo Path">
                        <input className="input" value={form.repoPath}
                            onChange={e => setForm({...form, repoPath: e.target.value})}
                            placeholder="path/to/your/repo" />
                    </Field>

                    <Field label="Target">
                        <select className="input" value={form.target}
                            onChange={e => setForm({...form, target: e.target.value})}>
                            <option value="">select target</option>
                            {Object.entries(targets).map(([name, t]) => (
                                <option key={name} value={name}>
                                    {name} ({t.host})
                                </option>
                            ))}
                        </select>
                    </Field>

                    <Field label="Agent">
                        <select className="input" value={form.agent}
                            onChange={e => setForm({...form, agent: e.target.value})}>
                            <option value="claude">claude</option>
                            <option value="codex">codex</option>
                            <option value="pi">pi</option>
                            <option value="droid">droid</option>
                        </select>
                    </Field>

                    <Field label="Session ID (optional)">
                        <input className="input" value={form.sessionId}
                            onChange={e => setForm({...form, sessionId: e.target.value})}
                            placeholder="auto-pick newest if empty" />
                    </Field>

                    <Field label="Prompt (optional)">
                        <textarea className="input h-20" value={form.prompt}
                            onChange={e => setForm({...form, prompt: e.target.value})}
                            placeholder="leave empty for default HANDOFF prompt" />
                    </Field>

                    <label className="flex items-center gap-2 text-sm">
                        <input type="checkbox" checked={form.idle}
                            onChange={e => setForm({...form, idle: e.target.checked})} />
                        Idle (sync only, don't launch)
                    </label>

                    <button onClick={handleSend} disabled={loading}
                        className="w-full bg-blue-600 hover:bg-blue-500 disabled:opacity-50 py-2 rounded">
                        {loading ? "Sending..." : "Send Parcel"}
                    </button>

                    {result && (
                        <div className={`p-3 rounded text-sm ${
                            result.success ? "bg-green-900/50 text-green-200" : "bg-red-900/50 text-red-200"
                        }`}>
                            {result.success ? (
                                <>
                                    Running in <code>{result.tmuxSession}</code>
                                    <br/>
                                    Attach: <code>ssh -t {targets[form.target]?.host} tmux attach -t {result.tmuxSession}</code>
                                </>
                            ) : (
                                `Error: ${result.error}`
                            )}
                        </div>
                    )}
                </div>

                {/* 右栏:状态和工具 */}
                <div className="bg-slate-800 rounded-lg p-5 space-y-4">
                    <div className="flex justify-between items-center">
                        <h2 className="text-lg font-semibold">Status</h2>
                        <button onClick={handleStatus}
                            className="text-sm bg-slate-700 px-3 py-1 rounded">
                            Refresh
                        </button>
                    </div>

                    {status.length === 0 ? (
                        <p className="text-slate-500 text-sm">No active parcels. Click Refresh.</p>
                    ) : (
                        <div className="space-y-3">
                            {status.map(s => (
                                <div key={s.name} className="bg-slate-900 rounded p-3">
                                    <div className="font-mono text-sm text-blue-300">{s.name}</div>
                                    <pre className="text-xs text-slate-400 mt-2 whitespace-pre-wrap">
                                        {s.lastOutput}
                                    </pre>
                                </div>
                            ))}
                        </div>
                    )}
                </div>
            </div>
        </div>
    );
}

function Field({ label, children }) {
    return (
        <div>
            <label className="block text-xs text-slate-400 mb-1">{label}</label>
            {children}
        </div>
    );
}

# 1. 写路径推导
newagent_dir()  { echo "$HOME/.newagent/projects/$(echo "$1" | tr '/' '-')"; }

# 2. 写 ship 函数
ship_newagent() {
  # 30 行实现
}

# 3. 在 case 加一行
case "$AGENT" in
  newagent) ship_newagent ;;
esac

// internal/agent/newagent.go
package agent

func init() {
    Register("newagent", func() Agent { return &NewAgent{} })
}

type NewAgent struct{}

func (n *NewAgent) Name() string { return "newagent" }

func (n *NewAgent) FindSession(repoPath, sessionID string) (*Session, error) {
    // ...
}

func (n *NewAgent) PrepareRemote(ctx context.Context, host string, s *Session, remoteRepo string) error {
    // ...
}

func (n *NewAgent) ResumeCommand(sessionID, prompt string) *ResumeCmd {
    // ...
}

你的用户群体是谁?
│
├─ 自己 + 几个开发者朋友
│   └─→ bash 版完胜
│        (293 行 vs 1800 行,启动快,改起来快)
│
├─ 想做成开源项目给非技术用户用
│   └─→ Go + Wails 值得
│        (单二进制分发 + GUI 友好)
│
├─ 企业内部工具,要审计/测试
│   └─→ Go(不一定 Wails,可以纯 cobra CLI)
│        (类型安全 + 可测试 + 可维护)
│
└─ 想做成 SaaS / 多用户平台
    └─→ 完全不同的架构(Server + Web)
        (这两个版本都不合适)