trickle-observe 0.2.104 → 0.2.106

package/dist/transport.js

@@ -54,6 +54,13 @@ let localFilePath = '';
 let queue = [];
 let flushTimer = null;
 let isFlushing = false;
+// Cloud streaming: when TRICKLE_CLOUD_URL + TRICKLE_CLOUD_TOKEN are set,
+// observations are also streamed to the cloud backend in real-time.
+let cloudUrl = process.env.TRICKLE_CLOUD_URL || '';
+let cloudToken = process.env.TRICKLE_CLOUD_TOKEN || '';
+let cloudProject = '';
+let cloudBuffer = [];
+let cloudFlushTimer = null;
 /**
  * Configure the transport layer with global options.
  */
@@ -63,6 +70,34 @@ function configure(opts) {
     maxBatchSize = opts.maxBatchSize || DEFAULT_MAX_BATCH_SIZE;
     enabled = opts.enabled !== false;
     debug = opts.debug === true;
+    // Load cloud config from ~/.trickle/cloud.json if env vars not set
+    if (!cloudUrl || !cloudToken) {
+        try {
+            const configPath = pathMod.join(process.env.HOME || '~', '.trickle', 'cloud.json');
+            if (fs.existsSync(configPath)) {
+                const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                if (!cloudUrl && config.url)
+                    cloudUrl = config.url;
+                if (!cloudToken && config.token)
+                    cloudToken = config.token;
+            }
+        }
+        catch { }
+    }
+    cloudProject = process.env.TRICKLE_CLOUD_PROJECT || pathMod.basename(process.cwd());
+    // Start cloud streaming if configured
+    if (cloudUrl && cloudToken && !cloudFlushTimer) {
+        cloudFlushTimer = setInterval(() => {
+            flushCloud().catch(() => { });
+        }, 5000); // Flush to cloud every 5 seconds
+        if (cloudFlushTimer.unref)
+            cloudFlushTimer.unref();
+        if (debug) {
+            console.log(`[trickle] Cloud streaming enabled → ${cloudUrl}`);
+        }
+        // Flush cloud buffer on exit
+        process.on('beforeExit', () => { flushCloud().catch(() => { }); });
+    }
     // Check for local/file-based mode
     if (process.env.TRICKLE_LOCAL === '1') {
         localMode = true;
@@ -93,7 +128,12 @@ function enqueue(payload) {
     // Local file mode: append directly to JSONL file
     if (localMode && localFilePath) {
         try {
-            fs.appendFileSync(localFilePath, JSON.stringify(payload) + '\n');
+            const line = JSON.stringify(payload) + '\n';
+            fs.appendFileSync(localFilePath, line);
+            // Also buffer for cloud if configured
+            if (cloudUrl && cloudToken) {
+                cloudBuffer.push(line);
+            }
         }
         catch {
             // Never crash user's app
@@ -200,6 +240,32 @@ function stopTimer() {
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
+/**
+ * Flush buffered observations to the cloud backend.
+ */
+async function flushCloud() {
+    if (cloudBuffer.length === 0 || !cloudUrl || !cloudToken)
+        return;
+    const lines = cloudBuffer.splice(0);
+    try {
+        await fetch(`${cloudUrl}/api/v1/ingest`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${cloudToken}`,
+            },
+            body: JSON.stringify({
+                project: cloudProject,
+                file: 'observations.jsonl',
+                lines: lines.join(''),
+            }),
+            signal: AbortSignal.timeout(10000),
+        });
+    }
+    catch {
+        // Silent — never crash user's app. Data is still saved locally.
+    }
+}
 function silentError() {
     // Intentionally empty — never crash user's app
 }

package/dist/type-inference.js

@@ -153,6 +153,23 @@ function inferObject(obj, depth, seen) {
             },
         };
     }
+    // Known complex framework objects — use class name instead of deep introspection.
+    // These types have dozens of internal properties that generate unusably verbose stubs.
+    const className = obj.constructor?.name;
+    const OPAQUE_CLASSES = new Set([
+        // Node.js HTTP internals
+        'IncomingMessage', 'ServerResponse', 'Socket', 'Server',
+        'ReadableState', 'WritableState',
+        // Express
+        'IncomingMessage', // Express req extends this
+        // Streams
+        'Readable', 'Writable', 'Duplex', 'Transform', 'PassThrough',
+        // EventEmitter
+        'EventEmitter',
+    ]);
+    if (className && OPAQUE_CLASSES.has(className)) {
+        return { kind: 'object', properties: {}, class_name: className };
+    }
     // Plain objects
     return inferPlainObject(obj, depth, seen);
 }
@@ -167,7 +184,7 @@ function inferArray(arr, depth, seen) {
     }
     return { kind: 'array', element: unifyTypes(elementTypes) };
 }
-const MAX_PROPERTIES = 20;
+const MAX_PROPERTIES = 12;
 function inferPlainObject(obj, depth, seen) {
     const properties = {};
     const keys = Object.keys(obj);

package/dist/types.d.ts

@@ -7,6 +7,7 @@ export type TypeNode = {
 } | {
     kind: "object";
     properties: Record<string, TypeNode>;
+    class_name?: string;
 } | {
     kind: "union";
     members: TypeNode[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-observe",
-  "version": "0.2.104",
+  "version": "0.2.106",
   "description": "Runtime type observability for JavaScript applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/transport.ts

@@ -19,6 +19,14 @@ let queue: IngestPayload[] = [];
 let flushTimer: ReturnType<typeof setInterval> | null = null;
 let isFlushing = false;
 
+// Cloud streaming: when TRICKLE_CLOUD_URL + TRICKLE_CLOUD_TOKEN are set,
+// observations are also streamed to the cloud backend in real-time.
+let cloudUrl = process.env.TRICKLE_CLOUD_URL || '';
+let cloudToken = process.env.TRICKLE_CLOUD_TOKEN || '';
+let cloudProject = '';
+let cloudBuffer: string[] = [];
+let cloudFlushTimer: ReturnType<typeof setInterval> | null = null;
+
 /**
  * Configure the transport layer with global options.
  */
@@ -29,6 +37,33 @@ export function configure(opts: GlobalOpts): void {
   enabled = opts.enabled !== false;
   debug = opts.debug === true;
 
+  // Load cloud config from ~/.trickle/cloud.json if env vars not set
+  if (!cloudUrl || !cloudToken) {
+    try {
+      const configPath = pathMod.join(process.env.HOME || '~', '.trickle', 'cloud.json');
+      if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        if (!cloudUrl && config.url) cloudUrl = config.url;
+        if (!cloudToken && config.token) cloudToken = config.token;
+      }
+    } catch {}
+  }
+  cloudProject = process.env.TRICKLE_CLOUD_PROJECT || pathMod.basename(process.cwd());
+
+  // Start cloud streaming if configured
+  if (cloudUrl && cloudToken && !cloudFlushTimer) {
+    cloudFlushTimer = setInterval(() => {
+      flushCloud().catch(() => {});
+    }, 5000); // Flush to cloud every 5 seconds
+    if (cloudFlushTimer.unref) cloudFlushTimer.unref();
+    if (debug) {
+      console.log(`[trickle] Cloud streaming enabled → ${cloudUrl}`);
+    }
+
+    // Flush cloud buffer on exit
+    process.on('beforeExit', () => { flushCloud().catch(() => {}); });
+  }
+
   // Check for local/file-based mode
   if (process.env.TRICKLE_LOCAL === '1') {
     localMode = true;
@@ -58,7 +93,12 @@ export function enqueue(payload: IngestPayload): void {
   // Local file mode: append directly to JSONL file
   if (localMode && localFilePath) {
     try {
-      fs.appendFileSync(localFilePath, JSON.stringify(payload) + '\n');
+      const line = JSON.stringify(payload) + '\n';
+      fs.appendFileSync(localFilePath, line);
+      // Also buffer for cloud if configured
+      if (cloudUrl && cloudToken) {
+        cloudBuffer.push(line);
+      }
     } catch {
       // Never crash user's app
     }
@@ -175,6 +215,32 @@ function sleep(ms: number): Promise<void> {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+/**
+ * Flush buffered observations to the cloud backend.
+ */
+async function flushCloud(): Promise<void> {
+  if (cloudBuffer.length === 0 || !cloudUrl || !cloudToken) return;
+
+  const lines = cloudBuffer.splice(0);
+  try {
+    await fetch(`${cloudUrl}/api/v1/ingest`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${cloudToken}`,
+      },
+      body: JSON.stringify({
+        project: cloudProject,
+        file: 'observations.jsonl',
+        lines: lines.join(''),
+      }),
+      signal: AbortSignal.timeout(10000),
+    });
+  } catch {
+    // Silent — never crash user's app. Data is still saved locally.
+  }
+}
+
 function silentError(): void {
   // Intentionally empty — never crash user's app
 }

package/src/type-inference.ts

@@ -168,6 +168,24 @@ function inferObject(obj: object, depth: number, seen: WeakSet<object>): TypeNod
     };
   }
 
+  // Known complex framework objects — use class name instead of deep introspection.
+  // These types have dozens of internal properties that generate unusably verbose stubs.
+  const className = obj.constructor?.name;
+  const OPAQUE_CLASSES = new Set([
+    // Node.js HTTP internals
+    'IncomingMessage', 'ServerResponse', 'Socket', 'Server',
+    'ReadableState', 'WritableState',
+    // Express
+    'IncomingMessage', // Express req extends this
+    // Streams
+    'Readable', 'Writable', 'Duplex', 'Transform', 'PassThrough',
+    // EventEmitter
+    'EventEmitter',
+  ]);
+  if (className && OPAQUE_CLASSES.has(className)) {
+    return { kind: 'object', properties: {}, class_name: className };
+  }
+
   // Plain objects
   return inferPlainObject(obj, depth, seen);
 }
@@ -187,7 +205,7 @@ function inferArray(arr: unknown[], depth: number, seen: WeakSet<object>): TypeN
   return { kind: 'array', element: unifyTypes(elementTypes) };
 }
 
-const MAX_PROPERTIES = 20;
+const MAX_PROPERTIES = 12;
 
 function inferPlainObject(obj: object, depth: number, seen: WeakSet<object>): TypeNode {
   const properties: Record<string, TypeNode> = {};

package/src/types.ts

@@ -1,7 +1,7 @@
 export type TypeNode =
   | { kind: "primitive"; name: "string" | "number" | "boolean" | "null" | "undefined" | "bigint" | "symbol" }
   | { kind: "array"; element: TypeNode }
-  | { kind: "object"; properties: Record<string, TypeNode> }
+  | { kind: "object"; properties: Record<string, TypeNode>; class_name?: string }
   | { kind: "union"; members: TypeNode[] }
   | { kind: "function"; params: TypeNode[]; returnType: TypeNode }
   | { kind: "promise"; resolved: TypeNode }