@xfey/tutti 0.1.33 → 0.1.34

package/dist/server-shell/local-console/session.d.ts

@@ -1,33 +1,28 @@
+import type { LocalConsoleInvocationContext } from "./invocation-context.js";
 export declare const LOCAL_CONSOLE_SESSION_COOKIE = "tutti_local_console_session";
-type ExpiringValue = {
-    hash: string;
-    expiresAt: number;
-};
-type LocalConsoleSession = ExpiringValue & {
-    csrfToken: string;
-    currentDirectory: string;
-};
 export type IssuedLocalConsoleAccessToken = {
     token: string;
     expires_at: string;
 };
 export type ExchangedLocalConsoleSession = {
-    sessionToken: string;
+    sessionToken?: string;
+    contextToken: string;
     csrfToken: string;
     expires_at: string;
 };
+export type ReadLocalConsoleSession = {
+    csrfToken: string;
+    context: LocalConsoleInvocationContext;
+};
 export declare class LocalConsoleSessionRegistry {
     #private;
     constructor(options?: {
         now?: () => Date;
     });
-    issueAccessToken(options: {
-        currentDirectory: string;
-    }): IssuedLocalConsoleAccessToken;
-    exchangeAccessToken(token: string): ExchangedLocalConsoleSession | null;
-    readSession(token: string | undefined): LocalConsoleSession | null;
+    issueAccessToken(context: LocalConsoleInvocationContext): IssuedLocalConsoleAccessToken;
+    exchangeAccessToken(token: string, existingSessionToken?: string): ExchangedLocalConsoleSession | null;
+    readSession(token: string | undefined, contextToken?: string): ReadLocalConsoleSession | null;
 }
 export declare function parseCookieHeader(header: string | undefined): Record<string, string>;
 export declare function localConsoleSessionCookie(token: string, expiresAt: string): string;
-export {};
 //# sourceMappingURL=session.d.ts.map

package/dist/server-shell/local-console/session.js

@@ -16,22 +16,24 @@ function secretEquals(value, expectedHash) {
 export class LocalConsoleSessionRegistry {
     #accessTokens = new Map();
     #sessions = new Map();
+    #contexts = new Map();
     #now;
+    #browserSessionToken;
     constructor(options = {}) {
         this.#now = options.now ?? (() => new Date());
     }
-    issueAccessToken(options) {
+    issueAccessToken(context) {
         this.#purgeExpired();
         const token = createSecret();
         const expiresAt = this.#now().getTime() + ACCESS_TOKEN_TTL_MS;
         this.#accessTokens.set(hashSecret(token), {
             hash: hashSecret(token),
             expiresAt,
-            currentDirectory: options.currentDirectory,
+            context,
         });
         return { token, expires_at: new Date(expiresAt).toISOString() };
     }
-    exchangeAccessToken(token) {
+    exchangeAccessToken(token, existingSessionToken) {
         this.#purgeExpired();
         const accessTokenHash = hashSecret(token);
         const accessToken = this.#accessTokens.get(accessTokenHash);
@@ -41,25 +43,58 @@ export class LocalConsoleSessionRegistry {
             return null;
         }
         this.#accessTokens.delete(accessTokenHash);
-        const sessionToken = createSecret();
-        const expiresAt = this.#now().getTime() + SESSION_TTL_MS;
-        this.#sessions.set(hashSecret(sessionToken), {
-            hash: hashSecret(sessionToken),
-            csrfToken: createSecret(),
-            expiresAt,
-            currentDirectory: accessToken.currentDirectory,
-        });
-        const session = this.#sessions.get(hashSecret(sessionToken));
+        let sessionToken;
+        let sessionHash = "";
+        let session;
+        if (existingSessionToken !== undefined) {
+            sessionHash = hashSecret(existingSessionToken);
+            const existingSession = this.#sessions.get(sessionHash);
+            if (existingSession !== undefined &&
+                existingSession.expiresAt > this.#now().getTime() &&
+                secretEquals(existingSessionToken, existingSession.hash)) {
+                session = existingSession;
+            }
+        }
+        if (session === undefined && this.#browserSessionToken !== undefined) {
+            const sharedSessionHash = hashSecret(this.#browserSessionToken);
+            const sharedSession = this.#sessions.get(sharedSessionHash);
+            if (sharedSession !== undefined &&
+                sharedSession.expiresAt > this.#now().getTime() &&
+                secretEquals(this.#browserSessionToken, sharedSession.hash)) {
+                sessionToken = this.#browserSessionToken;
+                sessionHash = sharedSessionHash;
+                session = sharedSession;
+            }
+        }
         if (session === undefined) {
-            return null;
+            sessionToken = createSecret();
+            this.#browserSessionToken = sessionToken;
+            sessionHash = hashSecret(sessionToken);
+            session = {
+                hash: sessionHash,
+                csrfToken: createSecret(),
+                expiresAt: this.#now().getTime() + SESSION_TTL_MS,
+                defaultContextHash: "",
+            };
+            this.#sessions.set(sessionHash, session);
         }
+        const contextToken = createSecret();
+        const contextHash = hashSecret(contextToken);
+        session.defaultContextHash = contextHash;
+        this.#contexts.set(contextHash, {
+            hash: contextHash,
+            expiresAt: session.expiresAt,
+            sessionHash,
+            context: accessToken.context,
+        });
         return {
-            sessionToken,
+            ...(sessionToken === undefined ? {} : { sessionToken }),
+            contextToken,
             csrfToken: session.csrfToken,
-            expires_at: new Date(expiresAt).toISOString(),
+            expires_at: new Date(session.expiresAt).toISOString(),
         };
     }
-    readSession(token) {
+    readSession(token, contextToken) {
         this.#purgeExpired();
         if (token === undefined || token.trim() === "") {
             return null;
@@ -70,7 +105,15 @@ export class LocalConsoleSessionRegistry {
             !secretEquals(token, session.hash)) {
             return null;
         }
-        return session;
+        const contextHash = contextToken === undefined ? session.defaultContextHash : hashSecret(contextToken);
+        const context = this.#contexts.get(contextHash);
+        if (context === undefined ||
+            context.sessionHash !== hashSecret(token) ||
+            context.expiresAt <= this.#now().getTime() ||
+            (contextToken !== undefined && !secretEquals(contextToken, context.hash))) {
+            return null;
+        }
+        return { csrfToken: session.csrfToken, context: context.context };
     }
     #purgeExpired() {
         const now = this.#now().getTime();
@@ -84,6 +127,15 @@ export class LocalConsoleSessionRegistry {
                 this.#sessions.delete(key);
             }
         }
+        if (this.#browserSessionToken !== undefined &&
+            !this.#sessions.has(hashSecret(this.#browserSessionToken))) {
+            this.#browserSessionToken = undefined;
+        }
+        for (const [key, value] of this.#contexts) {
+            if (value.expiresAt <= now || !this.#sessions.has(value.sessionHash)) {
+                this.#contexts.delete(key);
+            }
+        }
     }
 }
 export function parseCookieHeader(header) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfey/tutti",
-  "version": "0.1.33",
+  "version": "0.1.34",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",