socket-function 0.137.0 → 0.139.0

package/SocketFunctionTypes.ts

@@ -117,8 +117,11 @@ export type CallerContext = Readonly<CallerContextBase>;
 export type CallerContextBase = {
     // IMPORTANT! Do not pass nodeId to other nodes with the intention of having
     //  them call functions directly using nodeId. Instead pass location, and have them use connect.
-    //  - nodeId will be unique per thread, so is only useful for temporary communcation. If you want
+    //  - nodeId will be unique per thread, so is only useful for temporary communication. If you want
     //      a more permanent identity, you must derive it from certInfo yourself.
+    // ALSO IMPORTANT! DO NOT CHANGE THIS! Even though you might have a better id (a real domain name), and this might be a a weird id (`client:127.0.0.1:1758627917980.2603:0.08946007605096495`), IF you change this, it will break things.
+    //      1) It will break checks for client connections. This is used for security purposes. We do less security checks if WE established the connection, so if this is changed and it now looks like it is not a client, then it can create security vulnerabilities.
+    //      2) It will cause a connection to no longer appear to be === to it's past self.
     nodeId: string;
 
     // The nodeId they contacted. This is useful to determine their intention (otherwise

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.137.0",
+	"version": "0.139.0",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/require/require.ts

@@ -362,9 +362,8 @@ export function requireMain() {
         };
         try {
             resultObj = JSON.parse(rawText);
-        } catch (e) {
-            console.log(rawText);
-            throw e;
+        } catch (e: any) {
+            throw new Error(`require(${JSON.stringify(requests)}). Likely a permissions error, possibly fixed by restarting the local http server. Start of response was: ${JSON.stringify(rawText.slice(0, 100))}. Error is: ${e.stack}`);
         }
         let { modules, requestsResolvedPaths, requireSeqNumProcessId, error } = resultObj;
 

package/src/formatting/format.ts

@@ -230,6 +230,95 @@ export function formatDateTime(time: number) {
     return date.getFullYear() + "/" + p(date.getMonth() + 1) + "/" + p(date.getDate()) + " " + strTime;
 }
 
+export function formatDateTimeDetailed(time: number) {
+    function p(s: number) {
+        return s.toString().padStart(2, "0");
+    }
+    let date = new Date(time);
+    let hours = date.getHours();
+    let minutes = date.getMinutes();
+    let seconds = date.getSeconds();
+    let milliseconds = date.getMilliseconds();
+    let millisecondsString = milliseconds.toString().padStart(3, "0");
+
+    let timeString = time.toString();
+    let decimalIndex = timeString.indexOf(".");
+    if (decimalIndex !== -1) {
+        let fractionalPart = timeString.substring(decimalIndex + 1);
+        millisecondsString += fractionalPart;
+    }
+
+    let ampm = hours >= 12 ? "PM" : "AM";
+    hours = hours % 12;
+    hours = hours ? hours : 12; // the hour '0' should be '12'
+    let strTime = p(hours) + ":" + p(minutes) + ":" + p(seconds) + "." + millisecondsString + " " + ampm;
+    return date.getFullYear() + "/" + p(date.getMonth() + 1) + "/" + p(date.getDate()) + " " + strTime;
+}
+
+
+// Lookup table for common timezone abbreviations by UTC offset (in minutes)
+const timezoneAbbreviations: { [offsetMinutes: string]: string } = {
+    // UTC and GMT
+    "0": "UTC",
+
+    // US/Canada timezones
+    "300": "EST",     // UTC-5 (Eastern Standard Time)
+    "240": "EDT",     // UTC-4 (Eastern Daylight Time)
+    "360": "CST",     // UTC-6 (Central Standard Time) 
+    "420": "MST",     // UTC-7 (Mountain Standard Time)
+    "480": "PST",     // UTC-8 (Pacific Standard Time)
+
+    // European timezones
+    "-60": "CET",     // UTC+1 (Central European Time)
+    "-120": "CEST",   // UTC+2 (Central European Summer Time)
+
+    // Other common timezones
+    "-480": "CST",    // UTC+8 (China Standard Time)
+    "-540": "JST",    // UTC+9 (Japan Standard Time)
+    "-330": "IST",    // UTC+5:30 (India Standard Time)
+    "-570": "ACST",   // UTC+9:30 (Australian Central Standard Time)
+    "-600": "AEST",   // UTC+10 (Australian Eastern Standard Time)
+};
+
+
+// YYYY-MM-DD_HH-MM-SS.mmm TIMEZONE
+export function formatFileTimestampLocal(time: number): string {
+    function p(s: number) {
+        return s.toString().padStart(2, "0");
+    }
+
+    let date = new Date(time);
+    let year = date.getFullYear();
+    let month = p(date.getMonth() + 1);
+    let day = p(date.getDate());
+    let hours = p(date.getHours());
+    let minutes = p(date.getMinutes());
+    let seconds = p(date.getSeconds());
+    let milliseconds = date.getMilliseconds();
+    let millisecondsString = milliseconds.toString().padStart(3, "0");
+
+    let timeString = time.toString();
+    let decimalIndex = timeString.indexOf(".");
+    if (decimalIndex !== -1) {
+        let fractionalPart = timeString.substring(decimalIndex + 1);
+        millisecondsString += fractionalPart;
+    }
+    // Get timezone offset in minutes (negative of getTimezoneOffset because it returns opposite sign)
+    let timezoneOffsetMinutes = date.getTimezoneOffset();
+
+    // Look up the abbreviation or fallback to numeric format
+    let timezoneString = timezoneAbbreviations[timezoneOffsetMinutes.toString()];
+    if (!timezoneString) {
+        // Fallback: format as ±HHMM
+        let offsetSign = timezoneOffsetMinutes >= 0 ? "+" : "-";
+        let offsetHours = p(Math.floor(Math.abs(timezoneOffsetMinutes) / 60));
+        let offsetMins = p(Math.abs(timezoneOffsetMinutes) % 60);
+        timezoneString = `${offsetSign}${offsetHours}${offsetMins}`;
+    }
+
+    return `${year}-${month}-${day}_${hours}-${minutes}-${seconds}.${millisecondsString}_${timezoneString}`;
+}
+
 /** 2024 January 1, Monday, 12:53:02pm */
 export function formatNiceDateTime(time: number) {
     function p(s: number) {

package/time/trueTimeShim.ts

@@ -2,6 +2,8 @@ import { SocketFunction } from "../SocketFunction";
 import { blue, green, red, yellow } from "../src/formatting/logColors";
 import { isNode } from "../src/misc";
 
+// IMPOTRANT! We don't ensure that the times of return are unique. We cannot ensure they are unique because the amount of precision is only about ten thousand date times per millisecond, Which would mean if the calling code called date.now frequently enough, which doesn't even have to be that frequent, it could slowly drift farther and farther ahead of the real time, which would be really bad.
+
 module.allowclient = true;
 
 const UPDATE_INTERVAL = 1000 * 60 * 10;