@nmzpy/pi-ember-stack 0.2.1 → 0.2.2

package/plugins/devin-auth/src/cloud-direct/index.ts

@@ -1,41 +1,41 @@
-/**
- * Public surface of the cloud-direct module.
- *
- * Usage:
- *   import { streamChat } from './cloud-direct/index.js';
- *
- *   for await (const delta of streamChat({
- *     apiKey: creds.apiKey,
- *     apiServerUrl: creds.apiServerUrl,
- *     modelUid: 'swe-1-6',
- *     messages: [{ role: 'user', content: 'hi' }],
- *   })) {
- *     process.stdout.write(delta);
- *   }
- */
-
-export {
-  streamChat,
-  streamChatEvents,
-  allocateCascadeId,
-  CloudChatError,
-  type CloudChatRequest,
-  type ChatHistoryItem,
-  type CloudChatEvent,
-  type ToolDef,
-} from './chat.js';
-
-export {
-  mintUserJwt,
-  getCachedUserJwt,
-  clearCachedUserJwt,
-  CloudAuthError,
-} from './auth.js';
-
-export {
-  getCachedCatalog,
-  clearCachedCatalog,
-  ModelNotAvailableError,
-  type ModelCatalogEntry,
-  type CacheEntry,
-} from './catalog.js';
+/**
+ * Public surface of the cloud-direct module.
+ *
+ * Usage:
+ *   import { streamChat } from './cloud-direct/index.js';
+ *
+ *   for await (const delta of streamChat({
+ *     apiKey: creds.apiKey,
+ *     apiServerUrl: creds.apiServerUrl,
+ *     modelUid: 'swe-1-6',
+ *     messages: [{ role: 'user', content: 'hi' }],
+ *   })) {
+ *     process.stdout.write(delta);
+ *   }
+ */
+
+export {
+  streamChat,
+  streamChatEvents,
+  allocateCascadeId,
+  CloudChatError,
+  type CloudChatRequest,
+  type ChatHistoryItem,
+  type CloudChatEvent,
+  type ToolDef,
+} from './chat.js';
+
+export {
+  mintUserJwt,
+  getCachedUserJwt,
+  clearCachedUserJwt,
+  CloudAuthError,
+} from './auth.js';
+
+export {
+  getCachedCatalog,
+  clearCachedCatalog,
+  ModelNotAvailableError,
+  type ModelCatalogEntry,
+  type CacheEntry,
+} from './catalog.js';

package/plugins/devin-auth/src/cloud-direct/metadata.ts

@@ -1,78 +1,78 @@
-/**
- * `exa.codeium_common_pb.Metadata` proto builder.
- *
- * Field numbers come from src/plugin/discovery.ts (which reads the bundled
- * extension.js for live numbers). For cloud-direct we hard-code the canonical
- * set of fields the LS always populates — the IDE-extracted dynamic numbers
- * would help if Windsurf renumbers, but we don't have a way to refresh those
- * without the bundled extension.js path being present.
- *
- * Captured from real LS upstream traffic via mitm reverse-proxy. See
- * docs/CLOUD_DIRECT.md → "The exact captured request body (annotated)".
- */
-
-import {
-  encodeMessage,
-  encodeString,
-  encodeTimestampBody,
-  encodeVarintField,
-} from './wire.js';
-
-/**
- * extension_version + ide_version sent to the cloud. MUST be a string the
- * cloud recognizes as a real Windsurf release — Cognition's API silently
- * rejects unknown version strings with `failed_precondition: "an internal
- * error occurred"`. We previously tried pulling our package.json version
- * (e.g. "0.3.0") and the cloud rejected every request. Stays pinned to a
- * known-good "2.0.0" until/unless someone explicitly overrides via
- * `MetadataInput.windsurfVersion`.
- */
-const WINDSURF_VERSION_STRING = '2.0.0';
-
-export interface MetadataInput {
-  /** Persistent api_key from OAuth (`devin-session-token$<JWT>`). */
-  apiKey: string;
-  /** Fresh user_jwt from GetUserJwt — required for chat methods. */
-  userJwt?: string;
-  /** UUID — one per opencode session is fine. */
-  sessionId: string;
-  /** Monotonic, milliseconds since epoch. */
-  requestId: bigint;
-  /** UUID — one per RPC call. */
-  triggerId: string;
-  /** Optional override for the version string. Cosmetic. */
-  windsurfVersion?: string;
-  /** Optional override for the host OS string. */
-  osName?: string;
-}
-
-function osString(): string {
-  switch (process.platform) {
-    case 'darwin': return 'darwin';
-    case 'linux': return 'linux';
-    case 'win32': return 'windows';
-    default: return String(process.platform);
-  }
-}
-
-export function buildMetadata(input: MetadataInput): Buffer {
-  const version = input.windsurfVersion ?? WINDSURF_VERSION_STRING;
-  const os = input.osName ?? osString();
-  const parts: Buffer[] = [
-    encodeString(1, 'windsurf'),                     // ide_name
-    encodeString(2, version),                         // extension_version
-    encodeString(3, input.apiKey),                    // api_key
-    encodeString(4, 'en'),                            // locale
-    encodeString(5, os),                              // os
-    encodeString(7, version),                         // ide_version
-    encodeVarintField(9, input.requestId),            // request_id (uint64 monotonic)
-    encodeString(10, input.sessionId),                // session_id
-    encodeString(12, 'windsurf'),                     // extension_name
-    encodeMessage(16, encodeTimestampBody()),         // ls_timestamp (google.protobuf.Timestamp)
-    encodeString(25, input.triggerId),                // trigger_id
-    encodeString(26, 'Unset'),                        // plan_name
-    encodeString(28, 'windsurf'),                     // ide_type
-  ];
-  if (input.userJwt) parts.push(encodeString(21, input.userJwt));   // user_jwt
-  return Buffer.concat(parts);
-}
+/**
+ * `exa.codeium_common_pb.Metadata` proto builder.
+ *
+ * Field numbers come from src/plugin/discovery.ts (which reads the bundled
+ * extension.js for live numbers). For cloud-direct we hard-code the canonical
+ * set of fields the LS always populates — the IDE-extracted dynamic numbers
+ * would help if Windsurf renumbers, but we don't have a way to refresh those
+ * without the bundled extension.js path being present.
+ *
+ * Captured from real LS upstream traffic via mitm reverse-proxy. See
+ * docs/CLOUD_DIRECT.md → "The exact captured request body (annotated)".
+ */
+
+import {
+  encodeMessage,
+  encodeString,
+  encodeTimestampBody,
+  encodeVarintField,
+} from './wire.js';
+
+/**
+ * extension_version + ide_version sent to the cloud. MUST be a string the
+ * cloud recognizes as a real Windsurf release — Cognition's API silently
+ * rejects unknown version strings with `failed_precondition: "an internal
+ * error occurred"`. We previously tried pulling our package.json version
+ * (e.g. "0.3.0") and the cloud rejected every request. Stays pinned to a
+ * known-good "2.0.0" until/unless someone explicitly overrides via
+ * `MetadataInput.windsurfVersion`.
+ */
+const WINDSURF_VERSION_STRING = '2.0.0';
+
+export interface MetadataInput {
+  /** Persistent api_key from OAuth (`devin-session-token$<JWT>`). */
+  apiKey: string;
+  /** Fresh user_jwt from GetUserJwt — required for chat methods. */
+  userJwt?: string;
+  /** UUID — one per opencode session is fine. */
+  sessionId: string;
+  /** Monotonic, milliseconds since epoch. */
+  requestId: bigint;
+  /** UUID — one per RPC call. */
+  triggerId: string;
+  /** Optional override for the version string. Cosmetic. */
+  windsurfVersion?: string;
+  /** Optional override for the host OS string. */
+  osName?: string;
+}
+
+function osString(): string {
+  switch (process.platform) {
+    case 'darwin': return 'darwin';
+    case 'linux': return 'linux';
+    case 'win32': return 'windows';
+    default: return String(process.platform);
+  }
+}
+
+export function buildMetadata(input: MetadataInput): Buffer {
+  const version = input.windsurfVersion ?? WINDSURF_VERSION_STRING;
+  const os = input.osName ?? osString();
+  const parts: Buffer[] = [
+    encodeString(1, 'windsurf'),                     // ide_name
+    encodeString(2, version),                         // extension_version
+    encodeString(3, input.apiKey),                    // api_key
+    encodeString(4, 'en'),                            // locale
+    encodeString(5, os),                              // os
+    encodeString(7, version),                         // ide_version
+    encodeVarintField(9, input.requestId),            // request_id (uint64 monotonic)
+    encodeString(10, input.sessionId),                // session_id
+    encodeString(12, 'windsurf'),                     // extension_name
+    encodeMessage(16, encodeTimestampBody()),         // ls_timestamp (google.protobuf.Timestamp)
+    encodeString(25, input.triggerId),                // trigger_id
+    encodeString(26, 'Unset'),                        // plan_name
+    encodeString(28, 'windsurf'),                     // ide_type
+  ];
+  if (input.userJwt) parts.push(encodeString(21, input.userJwt));   // user_jwt
+  return Buffer.concat(parts);
+}

package/plugins/devin-auth/src/cloud-direct/wire.ts

@@ -1,202 +1,202 @@
-/**
- * Manual protobuf + Connect-RPC streaming envelope helpers.
- *
- * Connect-RPC streaming wire format (HTTPS POST body):
- *   ┌─────────────┬────────────────┬──────────────┐
- *   │ flags 1byte │ length 4B BE   │   payload    │
- *   └─────────────┴────────────────┴──────────────┘
- *   flags bit 0x01 = payload is gzip-compressed
- *   flags bit 0x02 = end-of-stream (trailer frame — JSON {error} or empty {})
- *
- * All `Get*` methods on `exa.api_server_pb.ApiServerService` that the
- * language_server calls upstream use this format, content-type
- * `application/connect+proto`, with `Connect-Protocol-Version: 1`.
- *
- * Kept tiny and dependency-free — same philosophy as src/plugin/protobuf.ts.
- */
-
-import * as zlib from 'zlib';
-
-// ----------------------------------------------------------------------------
-// Proto wire encode
-// ----------------------------------------------------------------------------
-
-export function encodeVarint(value: number | bigint): Buffer {
-  const v0 = BigInt(value);
-  // Reject negatives at the boundary. Proto3 spec encodes signed types as
-  // 10-byte sign-extended varints; we don't support that here and the
-  // current call sites never need it (tags, lengths, request ids — all
-  // strictly positive). The old loop body would have terminated with
-  // `Number(-1n)` = -1, producing a malformed single 0xFF byte that the
-  // server would misparse silently. Throw instead so future regressions
-  // surface immediately.
-  if (v0 < 0n) {
-    throw new RangeError(`encodeVarint: negative input not supported (got ${value})`);
-  }
-  const bytes: number[] = [];
-  let v = v0;
-  while (v > 127n) {
-    bytes.push(Number(v & 0x7fn) | 0x80);
-    v >>= 7n;
-  }
-  bytes.push(Number(v));
-  return Buffer.from(bytes);
-}
-
-export function encodeTag(fieldNum: number, wire: number): Buffer {
-  return encodeVarint((fieldNum << 3) | wire);
-}
-
-export function encodeString(fieldNum: number, s: string): Buffer {
-  const buf = Buffer.from(s, 'utf8');
-  return Buffer.concat([encodeTag(fieldNum, 2), encodeVarint(buf.length), buf]);
-}
-
-export function encodeMessage(fieldNum: number, body: Buffer): Buffer {
-  return Buffer.concat([encodeTag(fieldNum, 2), encodeVarint(body.length), body]);
-}
-
-export function encodeVarintField(fieldNum: number, v: number | bigint): Buffer {
-  return Buffer.concat([encodeTag(fieldNum, 0), encodeVarint(v)]);
-}
-
-export function encodeFixed64Field(fieldNum: number, v: number): Buffer {
-  const b = Buffer.alloc(8);
-  b.writeDoubleLE(v, 0);
-  return Buffer.concat([encodeTag(fieldNum, 1), b]);
-}
-
-export function encodeTimestampBody(): Buffer {
-  const now = Date.now();
-  const seconds = Math.floor(now / 1000);
-  const nanos = (now % 1000) * 1_000_000;
-  return Buffer.concat([
-    encodeVarintField(1, seconds),
-    nanos > 0 ? encodeVarintField(2, nanos) : Buffer.alloc(0),
-  ]);
-}
-
-// ----------------------------------------------------------------------------
-// Proto wire decode
-// ----------------------------------------------------------------------------
-
-export function decodeVarint(buf: Buffer, offset: number): [bigint, number] {
-  let res = 0n;
-  let shift = 0n;
-  let i = offset;
-  while (i < buf.length) {
-    const b = buf[i++];
-    res |= BigInt(b & 0x7f) << shift;
-    if (!(b & 0x80)) return [res, i];
-    shift += 7n;
-  }
-  throw new Error('truncated varint');
-}
-
-export interface ProtoField {
-  num: number;
-  wire: number;
-  /** varint → bigint, fixed → 8/4 byte Buffer, length-delim → payload Buffer. */
-  value: bigint | Buffer;
-}
-
-export function* iterFields(buf: Buffer): Generator<ProtoField> {
-  let i = 0;
-  while (i < buf.length) {
-    const [tagBig, ai] = decodeVarint(buf, i);
-    i = ai;
-    const tag = Number(tagBig);
-    const num = tag >> 3;
-    const wire = tag & 0x7;
-    if (wire === 0) {
-      const [v, bi] = decodeVarint(buf, i);
-      i = bi;
-      yield { num, wire, value: v };
-    } else if (wire === 1) {
-      // Bounds-check: a truncated frame mustn't yield a short fixed64 slice
-      // that downstream readers treat as a full 8-byte value. Stop iterating
-      // cleanly instead.
-      if (i + 8 > buf.length) return;
-      yield { num, wire, value: buf.slice(i, i + 8) };
-      i += 8;
-    } else if (wire === 2) {
-      const [n, ci] = decodeVarint(buf, i);
-      i = ci;
-      const len = Number(n);
-      // Bounds-check: when the declared length runs past the buffer, the
-      // frame is corrupt or truncated. Returning short-buffered slices to
-      // downstream parsers used to misparse silently (M12).
-      if (len < 0 || i + len > buf.length) return;
-      yield { num, wire, value: buf.slice(i, i + len) };
-      i += len;
-    } else if (wire === 5) {
-      if (i + 4 > buf.length) return;
-      yield { num, wire, value: buf.slice(i, i + 4) };
-      i += 4;
-    } else if (wire === 3 || wire === 4) {
-      // Wire types 3 (start group) and 4 (end group) are deprecated in
-      // proto3 but show up in some Codeium server-generated messages. They
-      // carry no length info; the safe behavior is to stop iterating
-      // gracefully rather than tear down the whole frame parse.
-      return;
-    } else {
-      // Unknown wire type — bail rather than misalign.
-      return;
-    }
-  }
-}
-
-// ----------------------------------------------------------------------------
-// Connect-streaming envelope
-// ----------------------------------------------------------------------------
-
-/**
- * Wrap `body` (a serialized proto message) in a Connect-streaming envelope.
- * If `compress` is true, gzip the payload and set the 0x01 flag.
- */
-export function frameConnectStream(body: Buffer, compress = true): Buffer {
-  let payload = body;
-  let flags = 0;
-  if (compress) {
-    payload = zlib.gzipSync(body);
-    flags |= 0x01;
-  }
-  const header = Buffer.alloc(5);
-  header[0] = flags;
-  header.writeUInt32BE(payload.length, 1);
-  return Buffer.concat([header, payload]);
-}
-
-export interface ConnectFrame {
-  flags: number;
-  /** Decompressed payload (gzip handled here if flags & 0x01). */
-  payload: Buffer;
-  /** Frame is the trailer (end-of-stream). */
-  eos: boolean;
-}
-
-/**
- * Parse all Connect-streaming frames out of a response body.
- *
- * Returns array of decoded frames. Each frame's payload is already gzip-decoded
- * if the compression flag was set.
- */
-export function parseConnectFrames(buf: Buffer): ConnectFrame[] {
-  const out: ConnectFrame[] = [];
-  let i = 0;
-  while (i + 5 <= buf.length) {
-    const flags = buf[i];
-    const len = buf.readUInt32BE(i + 1);
-    if (i + 5 + len > buf.length) break;
-    let payload = buf.slice(i + 5, i + 5 + len);
-    if (flags & 0x01) {
-      // Compressed frame. If gunzip fails the frame is genuinely corrupt
-      // — surfacing as a thrown error beats parsing raw gzip bytes as proto
-      // (which previously produced misleading "yielded bad wire type" downstream).
-      payload = zlib.gunzipSync(payload);
-    }
-    out.push({ flags, payload, eos: (flags & 0x02) !== 0 });
-    i += 5 + len;
-  }
-  return out;
-}
+/**
+ * Manual protobuf + Connect-RPC streaming envelope helpers.
+ *
+ * Connect-RPC streaming wire format (HTTPS POST body):
+ *   ┌─────────────┬────────────────┬──────────────┐
+ *   │ flags 1byte │ length 4B BE   │   payload    │
+ *   └─────────────┴────────────────┴──────────────┘
+ *   flags bit 0x01 = payload is gzip-compressed
+ *   flags bit 0x02 = end-of-stream (trailer frame — JSON {error} or empty {})
+ *
+ * All `Get*` methods on `exa.api_server_pb.ApiServerService` that the
+ * language_server calls upstream use this format, content-type
+ * `application/connect+proto`, with `Connect-Protocol-Version: 1`.
+ *
+ * Kept tiny and dependency-free — same philosophy as src/plugin/protobuf.ts.
+ */
+
+import * as zlib from 'zlib';
+
+// ----------------------------------------------------------------------------
+// Proto wire encode
+// ----------------------------------------------------------------------------
+
+export function encodeVarint(value: number | bigint): Buffer {
+  const v0 = BigInt(value);
+  // Reject negatives at the boundary. Proto3 spec encodes signed types as
+  // 10-byte sign-extended varints; we don't support that here and the
+  // current call sites never need it (tags, lengths, request ids — all
+  // strictly positive). The old loop body would have terminated with
+  // `Number(-1n)` = -1, producing a malformed single 0xFF byte that the
+  // server would misparse silently. Throw instead so future regressions
+  // surface immediately.
+  if (v0 < 0n) {
+    throw new RangeError(`encodeVarint: negative input not supported (got ${value})`);
+  }
+  const bytes: number[] = [];
+  let v = v0;
+  while (v > 127n) {
+    bytes.push(Number(v & 0x7fn) | 0x80);
+    v >>= 7n;
+  }
+  bytes.push(Number(v));
+  return Buffer.from(bytes);
+}
+
+export function encodeTag(fieldNum: number, wire: number): Buffer {
+  return encodeVarint((fieldNum << 3) | wire);
+}
+
+export function encodeString(fieldNum: number, s: string): Buffer {
+  const buf = Buffer.from(s, 'utf8');
+  return Buffer.concat([encodeTag(fieldNum, 2), encodeVarint(buf.length), buf]);
+}
+
+export function encodeMessage(fieldNum: number, body: Buffer): Buffer {
+  return Buffer.concat([encodeTag(fieldNum, 2), encodeVarint(body.length), body]);
+}
+
+export function encodeVarintField(fieldNum: number, v: number | bigint): Buffer {
+  return Buffer.concat([encodeTag(fieldNum, 0), encodeVarint(v)]);
+}
+
+export function encodeFixed64Field(fieldNum: number, v: number): Buffer {
+  const b = Buffer.alloc(8);
+  b.writeDoubleLE(v, 0);
+  return Buffer.concat([encodeTag(fieldNum, 1), b]);
+}
+
+export function encodeTimestampBody(): Buffer {
+  const now = Date.now();
+  const seconds = Math.floor(now / 1000);
+  const nanos = (now % 1000) * 1_000_000;
+  return Buffer.concat([
+    encodeVarintField(1, seconds),
+    nanos > 0 ? encodeVarintField(2, nanos) : Buffer.alloc(0),
+  ]);
+}
+
+// ----------------------------------------------------------------------------
+// Proto wire decode
+// ----------------------------------------------------------------------------
+
+export function decodeVarint(buf: Buffer, offset: number): [bigint, number] {
+  let res = 0n;
+  let shift = 0n;
+  let i = offset;
+  while (i < buf.length) {
+    const b = buf[i++];
+    res |= BigInt(b & 0x7f) << shift;
+    if (!(b & 0x80)) return [res, i];
+    shift += 7n;
+  }
+  throw new Error('truncated varint');
+}
+
+export interface ProtoField {
+  num: number;
+  wire: number;
+  /** varint → bigint, fixed → 8/4 byte Buffer, length-delim → payload Buffer. */
+  value: bigint | Buffer;
+}
+
+export function* iterFields(buf: Buffer): Generator<ProtoField> {
+  let i = 0;
+  while (i < buf.length) {
+    const [tagBig, ai] = decodeVarint(buf, i);
+    i = ai;
+    const tag = Number(tagBig);
+    const num = tag >> 3;
+    const wire = tag & 0x7;
+    if (wire === 0) {
+      const [v, bi] = decodeVarint(buf, i);
+      i = bi;
+      yield { num, wire, value: v };
+    } else if (wire === 1) {
+      // Bounds-check: a truncated frame mustn't yield a short fixed64 slice
+      // that downstream readers treat as a full 8-byte value. Stop iterating
+      // cleanly instead.
+      if (i + 8 > buf.length) return;
+      yield { num, wire, value: buf.slice(i, i + 8) };
+      i += 8;
+    } else if (wire === 2) {
+      const [n, ci] = decodeVarint(buf, i);
+      i = ci;
+      const len = Number(n);
+      // Bounds-check: when the declared length runs past the buffer, the
+      // frame is corrupt or truncated. Returning short-buffered slices to
+      // downstream parsers used to misparse silently (M12).
+      if (len < 0 || i + len > buf.length) return;
+      yield { num, wire, value: buf.slice(i, i + len) };
+      i += len;
+    } else if (wire === 5) {
+      if (i + 4 > buf.length) return;
+      yield { num, wire, value: buf.slice(i, i + 4) };
+      i += 4;
+    } else if (wire === 3 || wire === 4) {
+      // Wire types 3 (start group) and 4 (end group) are deprecated in
+      // proto3 but show up in some Codeium server-generated messages. They
+      // carry no length info; the safe behavior is to stop iterating
+      // gracefully rather than tear down the whole frame parse.
+      return;
+    } else {
+      // Unknown wire type — bail rather than misalign.
+      return;
+    }
+  }
+}
+
+// ----------------------------------------------------------------------------
+// Connect-streaming envelope
+// ----------------------------------------------------------------------------
+
+/**
+ * Wrap `body` (a serialized proto message) in a Connect-streaming envelope.
+ * If `compress` is true, gzip the payload and set the 0x01 flag.
+ */
+export function frameConnectStream(body: Buffer, compress = true): Buffer {
+  let payload = body;
+  let flags = 0;
+  if (compress) {
+    payload = zlib.gzipSync(body);
+    flags |= 0x01;
+  }
+  const header = Buffer.alloc(5);
+  header[0] = flags;
+  header.writeUInt32BE(payload.length, 1);
+  return Buffer.concat([header, payload]);
+}
+
+export interface ConnectFrame {
+  flags: number;
+  /** Decompressed payload (gzip handled here if flags & 0x01). */
+  payload: Buffer;
+  /** Frame is the trailer (end-of-stream). */
+  eos: boolean;
+}
+
+/**
+ * Parse all Connect-streaming frames out of a response body.
+ *
+ * Returns array of decoded frames. Each frame's payload is already gzip-decoded
+ * if the compression flag was set.
+ */
+export function parseConnectFrames(buf: Buffer): ConnectFrame[] {
+  const out: ConnectFrame[] = [];
+  let i = 0;
+  while (i + 5 <= buf.length) {
+    const flags = buf[i];
+    const len = buf.readUInt32BE(i + 1);
+    if (i + 5 + len > buf.length) break;
+    let payload = buf.slice(i + 5, i + 5 + len);
+    if (flags & 0x01) {
+      // Compressed frame. If gunzip fails the frame is genuinely corrupt
+      // — surfacing as a thrown error beats parsing raw gzip bytes as proto
+      // (which previously produced misleading "yielded bad wire type" downstream).
+      payload = zlib.gunzipSync(payload);
+    }
+    out.push({ flags, payload, eos: (flags & 0x02) !== 0 });
+    i += 5 + len;
+  }
+  return out;
+}