termdock 1.3.1 → 1.4.1

package/dist/server/ptyhost/protocol.js

@@ -0,0 +1,80 @@
+/**
+ * Framed wire protocol between the termdock server and the pty-host daemon
+ * over a Unix-domain socket. （架构移植自 tty7 daemon/protocol.rs，Apache-2.0）
+ *
+ * Frame layout: `[1B type][4B BE length][payload]`.
+ * Per-channel payloads (DATA/INPUT/REPLAY) start with `[1B idLen][id utf8]`.
+ * CONTROL payloads are a single JSON document.
+ *
+ * The host owns the PTYs and a bounded per-channel replay ring, and counts
+ * output in *chars* (both sides count JS string length, so multibyte text
+ * never desyncs the offset). Attach carries `since`; the host replays only
+ * newer output, then live data.
+ */
+export const PTY_HOST_PROTOCOL_VERSION = 1;
+export const FRAME_DATA = 0x01; // host → server: live PTY output
+export const FRAME_INPUT = 0x02; // server → host: client keystrokes
+export const FRAME_CONTROL = 0x03; // both ways: JSON control message
+export const FRAME_REPLAY = 0x04; // host → server: historical ring output
+const HEADER_LEN = 5;
+const MAX_FRAME = 4 * 1024 * 1024;
+export function encodeDataFrame(type, id, data) {
+    const idBuf = Buffer.from(id, 'utf8');
+    if (idBuf.length > 255)
+        throw new Error('channel id too long');
+    const dataBuf = Buffer.from(data, 'utf8');
+    const frame = Buffer.allocUnsafe(HEADER_LEN + 1 + idBuf.length + dataBuf.length);
+    frame.writeUInt8(type, 0);
+    frame.writeUInt32BE(1 + idBuf.length + dataBuf.length, 1);
+    frame.writeUInt8(idBuf.length, HEADER_LEN);
+    idBuf.copy(frame, HEADER_LEN + 1);
+    dataBuf.copy(frame, HEADER_LEN + 1 + idBuf.length);
+    return frame;
+}
+export function encodeControl(msg) {
+    const json = Buffer.from(JSON.stringify(msg), 'utf8');
+    const frame = Buffer.allocUnsafe(HEADER_LEN + json.length);
+    frame.writeUInt8(FRAME_CONTROL, 0);
+    frame.writeUInt32BE(json.length, 1);
+    json.copy(frame, HEADER_LEN);
+    return frame;
+}
+/** Incremental frame decoder: feed chunks, drain complete frames. */
+export class FrameDecoder {
+    buf = Buffer.alloc(0);
+    feed(chunk) {
+        this.buf = this.buf.length === 0 ? chunk : Buffer.concat([this.buf, chunk]);
+        const out = [];
+        for (;;) {
+            if (this.buf.length < HEADER_LEN)
+                break;
+            const type = this.buf.readUInt8(0);
+            const len = this.buf.readUInt32BE(1);
+            if (len > MAX_FRAME) {
+                // Desync guard: drop everything, let the connection reset.
+                this.buf = Buffer.alloc(0);
+                break;
+            }
+            if (this.buf.length < HEADER_LEN + len)
+                break;
+            const payload = this.buf.subarray(HEADER_LEN, HEADER_LEN + len);
+            this.buf = this.buf.subarray(HEADER_LEN + len);
+            if (type === FRAME_CONTROL) {
+                try {
+                    out.push({ type, id: null, data: null, control: JSON.parse(payload.toString('utf8')) });
+                }
+                catch { /* malformed control frame: skip */ }
+                continue;
+            }
+            if (type === FRAME_DATA || type === FRAME_INPUT || type === FRAME_REPLAY) {
+                const idLen = payload.readUInt8(0);
+                const id = payload.subarray(1, 1 + idLen).toString('utf8');
+                const data = payload.subarray(1 + idLen).toString('utf8');
+                out.push({ type, id, data, control: null });
+                continue;
+            }
+            // Unknown frame type: skip payload (forward compatibility).
+        }
+        return out;
+    }
+}

package/dist/server/routes/filesystem.js

@@ -2795,10 +2795,9 @@ router.get('/diff', async (req, res) => {
                     args.push('--', pathspec);
                 return args;
             };
-            // Default sidebar diffs should represent every changed file from the list:
-            // staged-only changes, unstaged changes, and untracked files. Plain
-            // `git diff` only shows unstaged tracked edits, which made staged-only
-            // additions/deletions/renames look empty in the UI.
+            // Use `git diff HEAD` to present a merged view of all worktree changes
+            // (staged + unstaged) against HEAD. Untracked files are handled separately
+            // with `--no-index` below.
             let truncatedByGit = false;
             const readLimitedDiff = async (args, maxBytes = MAX_DIFF_BYTES) => {
                 const gitResult = await execGitLimited(args, gitCwd, maxBytes, false, controller.signal, { id: requestId, action, op: 'git.diff', path: requestedPath, extra: { traceId, interactionId, requestSlotId } });
@@ -2812,12 +2811,15 @@ router.get('/diff', async (req, res) => {
                     truncatedByGit = true;
                 return gitResult.stdout;
             };
+            const buildHeadDiffArgs = () => {
+                const args = ['diff', '-M', ...diffOptionArgs, 'HEAD'];
+                if (pathspec)
+                    args.push('--', pathspec);
+                return args;
+            };
             let diff = cached
                 ? await readLimitedDiff(buildDiffArgs(true))
-                : [
-                    await readLimitedDiff(buildDiffArgs(true)),
-                    await readLimitedDiff(buildDiffArgs(false)),
-                ].filter(Boolean).join('\n');
+                : await readLimitedDiff(buildHeadDiffArgs());
             let totalBytes = getDiffByteLength(diff);
             // If git diff produced no output for a specific file, it might be an
             // untracked (new) file.  Use `git diff --no-index /dev/null <path>` to