ping reply `result.timestamp` is JSON number on Windows but JSON string on Linux at the same CLI version (1.0.51)

[lonegunmanb]

ping JSON-RPC reply: timestamp wire type differs across platforms at the same CLI version (1.0.51)

Summary

At the same CLI version (1.0.51 / 1.0.51-2) the ping JSON-RPC
reply serializes the timestamp field with two incompatible JSON
types depending on the host platform:

Host	copilot --version	Raw timestamp bytes	JSON type
Windows	GitHub Copilot CLI 1.0.51-2	1779352370134	NUMBER (epoch ms, fits int64)
Linux (container)	GitHub Copilot CLI 1.0.51	"2026-05-21T08:29:54.042Z"	STRING (ISO 8601)

Both samples are real captures via a hand-rolled JSON-RPC stdio harness
(no SDK, no wrapper) running the official flags
--headless --no-auto-update --log-level debug --stdio.

This breaks every typed downstream that expects a stable schema — most
notably copilot-sdk/go (filed sibling issue), where
PingResponse.Timestamp is int64 and the SDK refuses to start on
Linux at 1.0.51 with:

json: cannot unmarshal string into Go struct field PingResponse.timestamp of type int64

Beyond the SDK breakage, having the same RPC return two unrelated value
types depending on platform is a substantive schema violation in its own
right.

Reproduction

Tiny Go program at tmp/sdk-repro/cmd/captureping (no SDK
dependency — only encoding/json + os/exec):

$ go run ./cmd/captureping
=== HOST ===
go_os=...  go_arch=...  go_version=...
copilot_path=...
copilot_version=GitHub Copilot CLI 1.0.51...

spawning: copilot [--headless --no-auto-update --log-level debug --stdio]
writing request: {"id":1,"jsonrpc":"2.0","method":"ping","params":{"message":""}}
=== RAW RESPONSE BYTES ===
{"jsonrpc":"2.0","id":1,"result":{...}}
=== RESULT FIELD KINDS ===
  message          raw="pong" kind=STRING
  protocolVersion  raw=3 kind=NUMBER
  timestamp        raw=... kind=NUMBER | STRING

Run on both platforms with the same flags and compare the final
timestamp ... kind= line.

Actual captures

Windows host, copilot.bat 1.0.51-2:

copilot_version=GitHub Copilot CLI 1.0.51-2.

=== RAW RESPONSE BYTES ===
{"jsonrpc":"2.0","id":1,"result":{"message":"pong","timestamp":1779352370134,"protocolVersion":3}}

=== RESULT FIELD KINDS ===
  message          raw="pong"           kind=STRING
  protocolVersion  raw=3                kind=NUMBER
  timestamp        raw=1779352370134    kind=NUMBER

Linux container, copilot 1.0.51:

copilot_version=GitHub Copilot CLI 1.0.51

=== RAW RESPONSE BYTES ===
{"jsonrpc":"2.0","id":1,"result":{"message":"pong","timestamp":"2026-05-21T08:29:54.042Z","protocolVersion":3}}

=== RESULT FIELD KINDS ===
  message          raw="pong"                              kind=STRING
  protocolVersion  raw=3                                   kind=NUMBER
  timestamp        raw="2026-05-21T08:29:54.042Z"          kind=STRING

Why this is the CLI's problem, not the SDK's

• The CLI is the authoritative definition of the wire protocol. Whatever
  it sends is the schema for all client SDKs (Node, .NET, Python, Go).
• Asking every SDK to grow a per-field union type to absorb platform
  inconsistencies pushes downstream complexity outward forever.
• The platform delta proves the inconsistency is internal to the CLI
  build pipeline (most likely a Date#toJSON() vs
  Date.now() / BigInt codepath that gets compiled / bundled
  differently per OS target).

Suggested fix

Pick one canonical wire representation for result.timestamp and
emit it consistently on every platform. Either:

• A. Epoch milliseconds as a JSON number (matches what the Go SDK's
  PingResponse.Timestamp int64 and the field's existing
  semantics imply — and what the Windows build already does).
• B. ISO 8601 string (more self-documenting, but requires breaking
  schema changes in all SDKs).

(A) is the cheaper fix and aligns with what existing typed SDKs expect.

Either way, please also add a wire-format regression test that asserts
the JSON typeof of every public RPC result field, so that future
serializer / bundler changes can't reintroduce a platform-specific
divergence silently.

Sibling issue

github/copilot-sdk — request a tolerant UnmarshalJSON on
PingResponse so the Go SDK can survive both wire shapes during any
rollout / mixed-fleet window. (URL to be filled in once both issues are
opened.)

[lonegunmanb]

Sibling issue against the Go SDK side (tolerant UnmarshalJSON request so SDKs can survive both wire shapes): github/copilot-sdk#1356

[lonegunmanb]

Full reproducer source (live captures)

Both pieces below are self-contained — no need to clone anything. Drop
them into a fresh directory and run go run ./cmd/captureping on each
platform you care about.

go.mod

module sdk-repro

go 1.25

require github.com/github/copilot-sdk/go v0.3.0

(Run go mod tidy once to fill in indirect deps — google/uuid,
go.opentelemetry.io/otel, etc.)

cmd/captureping/main.go — live CLI capture, no SDK dep

This is the program that produced both wire-format samples. It does
not import the SDK; it spawns copilot --headless --stdio and writes
a hand-rolled JSON-RPC 2.0 ping frame, then dumps the raw bytes and
classifies every top-level result field as NUMBER / STRING / etc.
so Linux and Windows runs are trivially diffable.

// capture_ping.go — minimal harness that spawns `copilot --headless` (stdio
// JSON-RPC transport) and sends a hand-rolled `ping` request, then prints the
// raw response bytes verbatim so we can confirm exactly how the CLI serializes
// `timestamp`.
//
// Usage (inside the same container that exhibits the JJC error):
//   go run ./cmd/captureping [path-to-copilot]
//
// If no argument is given it falls back to `copilot` on PATH.
package main

import (
	"bufio"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"os"
	"os/exec"
	"runtime"
	"strconv"
	"strings"
	"time"
)

func main() {
	cliPath := "copilot"
	if len(os.Args) > 1 {
		cliPath = os.Args[1]
	}

	// Banner: identify the host so Linux/Windows runs are trivially diffable.
	fmt.Println("=== HOST ===")
	fmt.Printf("go_os=%s go_arch=%s go_version=%s\n", runtime.GOOS, runtime.GOARCH, runtime.Version())
	if resolved, err := exec.LookPath(cliPath); err == nil {
		fmt.Printf("copilot_path=%s\n", resolved)
	} else {
		fmt.Printf("copilot_path=<not found on PATH: %s> err=%v\n", cliPath, err)
	}
	versionOut, _ := exec.Command(cliPath, "--version").CombinedOutput()
	fmt.Printf("copilot_version=%s\n", strings.TrimSpace(string(versionOut)))
	fmt.Println()

	// Same flags the Go SDK passes when running the CLI in stdio transport
	// mode (see copilot-sdk/go client.go:startCLIServer). The `--stdio` flag
	// is critical: without it the CLI defaults to TCP transport and never
	// reads from stdin, so the script appears to hang.
	cliArgs := []string{
		"--headless",
		"--no-auto-update",
		"--log-level", "debug",
		"--stdio",
	}
	fmt.Fprintf(os.Stderr, "spawning: %s %v\n", cliPath, cliArgs)
	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
	defer cancel()
	cmd := exec.CommandContext(ctx, cliPath, cliArgs...)
	stdin, err := cmd.StdinPipe()
	if err != nil {
		die("stdin pipe: %v", err)
	}
	stdout, err := cmd.StdoutPipe()
	if err != nil {
		die("stdout pipe: %v", err)
	}
	stderr, err := cmd.StderrPipe()
	if err != nil {
		die("stderr pipe: %v", err)
	}
	if err := cmd.Start(); err != nil {
		die("start %s: %v", cliPath, err)
	}
	defer cmd.Process.Kill()

	// Mirror stderr to our stderr so the operator can see CLI-side warnings
	// (package extraction, login state, debug log lines, etc.).
	go func() { _, _ = io.Copy(os.Stderr, stderr) }()

	// Give the CLI a moment to finish its self-extraction / startup banner
	// before we try the handshake. Pure cosmetic — doesn't change correctness.
	time.Sleep(500 * time.Millisecond)

	// JSON-RPC 2.0 ping request, framed with the LSP-style Content-Length header
	// that the Copilot CLI stdio transport expects (see SDK
	// internal/jsonrpc2/frame.go).
	req := map[string]any{
		"jsonrpc": "2.0",
		"id":      1,
		"method":  "ping",
		"params":  map[string]any{"message": ""},
	}
	payload, _ := json.Marshal(req)
	header := "Content-Length: " + strconv.Itoa(len(payload)) + "\r\n\r\n"
	fmt.Fprintf(os.Stderr, "writing request: %s\n", string(payload))
	if _, err := stdin.Write([]byte(header)); err != nil {
		die("write header: %v", err)
	}
	if _, err := stdin.Write(payload); err != nil {
		die("write body: %v", err)
	}

	// Read a single LSP-framed reply.
	r := bufio.NewReader(stdout)
	var contentLength int
	for {
		line, err := r.ReadString('\n')
		if err != nil {
			die("read header: %v", err)
		}
		line = trimCRLF(line)
		if line == "" {
			break
		}
		if v, ok := stripPrefix(line, "Content-Length: "); ok {
			n, perr := strconv.Atoi(v)
			if perr != nil {
				die("bad Content-Length %q: %v", v, perr)
			}
			contentLength = n
		}
	}
	if contentLength == 0 {
		die("no Content-Length header in reply")
	}
	body := make([]byte, contentLength)
	if _, err := io.ReadFull(r, body); err != nil {
		die("read body: %v", err)
	}

	fmt.Println("=== RAW RESPONSE BYTES ===")
	fmt.Println(string(body))

	// Pretty-print so the timestamp field type is obvious.
	var pretty any
	if err := json.Unmarshal(body, &pretty); err == nil {
		out, _ := json.MarshalIndent(pretty, "", "  ")
		fmt.Println("=== PARSED (generic) ===")
		fmt.Println(string(out))
	}

	// Inspect each top-level result field's JSON kind explicitly so we can
	// compare Linux vs Windows wire formats without eyeballing JSON.
	var probe struct {
		Result map[string]json.RawMessage `json:"result"`
	}
	if err := json.Unmarshal(body, &probe); err == nil {
		fmt.Println("=== RESULT FIELD KINDS ===")
		for _, k := range sortedKeys(probe.Result) {
			raw := string(probe.Result[k])
			fmt.Printf("  %-16s raw=%s kind=%s\n", k, raw, jsonKind(raw))
		}
	}

	fmt.Println("=== END ===")
}

func jsonKind(raw string) string {
	if len(raw) == 0 {
		return "EMPTY"
	}
	switch raw[0] {
	case '"':
		return "STRING"
	case '{':
		return "OBJECT"
	case '[':
		return "ARRAY"
	case 't', 'f':
		return "BOOL"
	case 'n':
		return "NULL"
	case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
		return "NUMBER"
	default:
		return "OTHER"
	}
}

func sortedKeys(m map[string]json.RawMessage) []string {
	keys := make([]string, 0, len(m))
	for k := range m {
		keys = append(keys, k)
	}
	// Lightweight insertion sort to avoid pulling in sort just for this.
	for i := 1; i < len(keys); i++ {
		for j := i; j > 0 && keys[j-1] > keys[j]; j-- {
			keys[j-1], keys[j] = keys[j], keys[j-1]
		}
	}
	return keys
}

func trimCRLF(s string) string {
	for len(s) > 0 && (s[len(s)-1] == '\n' || s[len(s)-1] == '\r') {
		s = s[:len(s)-1]
	}
	return s
}

func stripPrefix(s, prefix string) (string, bool) {
	if len(s) < len(prefix) {
		return "", false
	}
	if s[:len(prefix)] != prefix {
		return "", false
	}
	return s[len(prefix):], true
}

func die(format string, a ...any) {
	fmt.Fprintf(os.Stderr, "FATAL: "+format+"\n", a...)
	os.Exit(1)
}

repro_test.go — pure SDK-side reproducer (no CLI needed)

Drops both real captures into json.Unmarshal against the exported
copilot.PingResponse. The string-form test fails today and is the
canonical assertion for "the SDK can't accept this wire shape".

// Package repro is a minimal, dependency-isolated reproducer for the
// PingResponse.timestamp unmarshal failure observed when the Copilot Go SDK
// (github.com/github/copilot-sdk/go v0.3.0) talks to a Copilot CLI that
// emits the JSON-RPC `ping` response with `timestamp` serialized as a JSON
// string (ISO 8601) instead of a JSON number (epoch milliseconds).
//
// Both payloads below are REAL captures taken via
// cmd/captureping using the same flags the SDK uses to start
// the CLI (`--headless --no-auto-update --log-level debug --stdio`):
//
//   - payloadIntTimestamp     — Windows host, copilot CLI 1.0.51-2  → NUMBER
//   - payloadStringTimestamp  — Linux container, copilot CLI 1.0.51 → STRING
//
// Same CLI version, different platforms, different wire shapes.
package repro

import (
	"encoding/json"
	"strings"
	"testing"

	copilot "github.com/github/copilot-sdk/go"
)

const payloadStringTimestamp = `{"message":"pong","timestamp":"2026-05-21T08:29:54.042Z","protocolVersion":3}`
const payloadIntTimestamp    = `{"message":"pong","timestamp":1779352370134,"protocolVersion":3}`

func TestPingResponse_NumericTimestamp_OK(t *testing.T) {
	var resp copilot.PingResponse
	if err := json.Unmarshal([]byte(payloadIntTimestamp), &resp); err != nil {
		t.Fatalf("baseline numeric-timestamp unmarshal should succeed, got: %v", err)
	}
	if resp.Timestamp != 1779352370134 {
		t.Fatalf("Timestamp mismatch: got %d", resp.Timestamp)
	}
	t.Logf("baseline OK: %+v", resp)
}

func TestPingResponse_StringTimestamp_Reproduces(t *testing.T) {
	var resp copilot.PingResponse
	err := json.Unmarshal([]byte(payloadStringTimestamp), &resp)
	if err == nil {
		t.Fatalf("expected unmarshal to fail with the SDK's int64 Timestamp field, got nil; resp=%+v", resp)
	}
	t.Logf("reproduced error: %v", err)

	const want = "cannot unmarshal string into Go struct field PingResponse.timestamp of type int64"
	if !strings.Contains(err.Error(), want) {
		t.Fatalf("error message mismatch:\n got: %v\nwant substring: %s", err, want)
	}
}

How to run

# Pure SDK-side repro (no CLI needed; works inside golang:latest):
go test -v ./...

# Live CLI capture (run on both Windows and Linux to compare):
go run ./cmd/captureping
# or with an explicit binary:
go run ./cmd/captureping /usr/local/bin/copilot

[examon]

This should be resolved as of v1.0.51. The ping JSON-RPC reply's result.timestamp field is now consistently emitted as an ISO 8601 string on all platforms, and the published schema declares it as such. Updating to stable v1.0.51 on both Windows and Linux and rerunning your captureping harness should yield identical wire output. If you still see the mismatch after upgrading, please comment with details and we'll take another look.