joshuafhiggins/jumpstart
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: joshuafhiggins/jumpstart:main
joshuafhiggins/jumpstart:main joshuafhiggins/jumpstart:t3/fix-eas-npm-version
..
compare: joshuafhiggins/jumpstart:3bb2ed0fb17f9127d073486e7563970da146daa2
joshuafhiggins/jumpstart:main joshuafhiggins/jumpstart:t3/fix-eas-npm-version
2 Commits
main .. 3bb2ed0fb1
6 changed files with 977 additions and 955 deletions
Expand all files Collapse all files

No files matched your search

app.json
+3 -7
View File
@@ -2,7 +2,7 @@
"expo": {
"name": "Jumpstart",
"slug": "remote-wol",
"version": "1.0.3",
"version": "1.0.2",
"orientation": "portrait",
"icon": "./assets/images/icon.png",
"scheme": "remotewol-upsnap",
@@ -61,10 +61,7 @@
"displayName": "Device Control",
"description": "Control your devices with wake, sleep, restart, and shutdown actions.",
"ios": {
"supportedFamilies": [
"systemSmall",
"systemMedium"
],
"supportedFamilies": ["systemSmall", "systemMedium"],
"initialLayout": "./src/widgets/DeviceControl.tsx",
"configuration": {
"title": "Device Control",
@@ -92,8 +89,7 @@
"expo-font",
"expo-image",
"expo-web-browser",
"expo-app-intents",
"expo-status-bar"
"expo-app-intents"
],
"experiments": {
"typedRoutes": true,
package-lock.json
Generated
+834 -405
View File
File diff suppressed because it is too large. Load diff
package.json
+7 -7
View File
@@ -11,22 +11,22 @@
"lint": "expo lint"
},
"dependencies": {
"@expo/ui": "~58.0.22",
"@expo/ui": "~58.0.21",
"@expo/vector-icons": "^15.0.3",
"@react-native-async-storage/async-storage": "^2.2.0",
"burnt": "^0.13.0",
"expo": "^58.0.17",
"expo-app-intents": "~0.5.11",
"expo": "^58.0.16",
"expo-app-intents": "~0.5.10",
"expo-constants": "~58.0.12",
"expo-dev-client": "~58.0.14",
"expo-font": "~58.0.9",
"expo-glass-effect": "~58.0.4",
"expo-haptics": "~58.0.7",
"expo-image": "~58.0.16",
"expo-linking": "~58.0.14",
"expo-router": "~58.0.25",
"expo-splash-screen": "~58.0.11",
"expo-status-bar": "~58.0.4",
"expo-linking": "~58.0.13",
"expo-router": "~58.0.24",
"expo-splash-screen": "~58.0.10",
"expo-status-bar": "~58.0.3",
"expo-symbols": "~58.0.4",
"expo-system-ui": "~58.0.6",
"expo-web-browser": "~58.0.6",
src/context/AuthContext.tsx
+36 -244
View File
@@ -1,8 +1,6 @@
import React, { createContext, useContext, useState, useEffect, useCallback, useRef } from 'react';
import { AppState } from 'react-native';
import React, { createContext, useContext, useState, useEffect, useCallback } from 'react';
import AsyncStorage from '@react-native-async-storage/async-storage';
import api, { isAuthCollection, isRevokedAuthError } from '../services/api';
import { getJwtExpiryMs } from '../services/jwtExpiry';
import api from '../services/api';
import { syncDevicesToWidget } from '../services/widgetSync';
import { AuthResponse, User } from '../types';
@@ -19,22 +17,6 @@ interface AuthContextType {
const AuthContext = createContext<AuthContextType | undefined>(undefined);
const AUTH_COLLECTION_KEY = 'auth_collection';
const REFRESH_BEFORE_EXPIRY_MS = 60_000;
const MAX_REFRESH_DELAY_MS = 2_147_483_647;
const REFRESH_RETRY_MS = 30_000;
const REFRESH_BACKOFF_MS = 15_000;
function msUntilRefresh(token: string): number | null {
const expiresAt = getJwtExpiryMs(token);
if (expiresAt == null) return null;
return expiresAt - Date.now() - REFRESH_BEFORE_EXPIRY_MS;
}
function collectionFromUser(user: User | null): 'users' | '_superusers' | null {
return isAuthCollection(user?.collectionName) ? user.collectionName : null;
}
export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
const [user, setUser] = useState<User | null>(null);
const [serverAddress, setServerAddress] = useState<string | null>(null);
@@ -42,192 +24,44 @@ export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children
const [isLoading, setIsLoading] = useState(true);
const [canCreate, setCanCreate] = useState<boolean | null>(null);
const refreshTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
const refreshingRef = useRef(false);
const sessionWriteRef = useRef<Promise<void>>(Promise.resolve());
const refreshSessionRef = useRef<() => Promise<void>>(async () => {});
const armRefreshTimerRef = useRef<(token: string, overdueDelay?: number) => void>(() => {});
const enqueueSessionWrite = useCallback((task: () => Promise<void>) => {
const run = sessionWriteRef.current.then(task, task);
sessionWriteRef.current = run.then(
() => undefined,
() => undefined,
);
return run;
}, []);
const clearRefreshTimer = useCallback(() => {
if (refreshTimerRef.current != null) {
clearTimeout(refreshTimerRef.current);
refreshTimerRef.current = null;
}
}, []);
const clearSession = useCallback(async () => {
clearRefreshTimer();
await AsyncStorage.multiRemove(['auth_token', 'auth_user', 'auth_can_create']);
api.clearToken();
api.clearCanCreate();
api.clearAuthCollection();
setToken(null);
setUser(null);
setCanCreate(null);
await enqueueSessionWrite(async () => {
await AsyncStorage.multiRemove([
'auth_token',
'auth_user',
'auth_can_create',
AUTH_COLLECTION_KEY,
]);
});
}, [clearRefreshTimer, enqueueSessionWrite]);
const armRefreshTimer = useCallback((nextToken: string, overdueDelay = 0) => {
clearRefreshTimer();
const untilRefresh = msUntilRefresh(nextToken);
if (untilRefresh == null) return;
const delay = untilRefresh <= 0 ? overdueDelay : Math.min(untilRefresh, MAX_REFRESH_DELAY_MS);
const rescheduleOnly = untilRefresh > MAX_REFRESH_DELAY_MS;
refreshTimerRef.current = setTimeout(() => {
refreshTimerRef.current = null;
const latest = api.getToken();
if (!latest) return;
if (rescheduleOnly) {
armRefreshTimerRef.current(latest);
return;
}
void refreshSessionRef.current();
}, delay);
}, [clearRefreshTimer]);
const refreshSession = useCallback(async () => {
if (refreshingRef.current || !api.getToken()) return;
refreshingRef.current = true;
try {
await api.refreshAuth();
} catch {
// The failure listener either keeps the session and retries, or signs out.
} finally {
refreshingRef.current = false;
}
}, []);
const handleRefreshFailure = useCallback(async (error: unknown) => {
if (isRevokedAuthError(error)) {
await clearSession();
return;
}
if (!api.getToken()) return;
clearRefreshTimer();
refreshTimerRef.current = setTimeout(() => {
refreshTimerRef.current = null;
void refreshSessionRef.current();
}, REFRESH_RETRY_MS);
}, [clearRefreshTimer, clearSession]);
const persistRefreshedAuth = useCallback(async (auth: AuthResponse) => {
await enqueueSessionWrite(async () => {
if (api.getToken() !== auth.token) return;
const collection = api.getAuthCollection();
const pairs: [string, string][] = [
['auth_token', auth.token],
['auth_user', JSON.stringify(auth.record)],
];
if (collection) {
pairs.push([AUTH_COLLECTION_KEY, collection]);
}
if (collection === '_superusers') {
pairs.push(['auth_can_create', 'true']);
}
await AsyncStorage.multiSet(pairs);
if (api.getToken() !== auth.token) return;
setToken(auth.token);
setUser(auth.record);
if (collection === '_superusers') {
setCanCreate(true);
}
armRefreshTimerRef.current(auth.token, REFRESH_BACKOFF_MS);
});
}, [enqueueSessionWrite]);
const watchToken = useCallback((nextToken: string) => {
const untilRefresh = msUntilRefresh(nextToken);
if (untilRefresh != null && untilRefresh <= 0) {
void refreshSessionRef.current();
return;
}
armRefreshTimerRef.current(nextToken);
}, []);
useEffect(() => {
refreshSessionRef.current = refreshSession;
armRefreshTimerRef.current = armRefreshTimer;
}, [armRefreshTimer, refreshSession]);
useEffect(() => {
api.setUnauthorizedHandler(clearSession);
api.setAuthUpdateListener(persistRefreshedAuth);
api.setAuthFailureListener(handleRefreshFailure);
return () => {
api.setUnauthorizedHandler(null);
api.setAuthUpdateListener(null);
api.setAuthFailureListener(null);
clearRefreshTimer();
};
}, [clearRefreshTimer, clearSession, handleRefreshFailure, persistRefreshedAuth]);
}, [clearSession]);
useEffect(() => {
let cancelled = false;
void (async () => {
try {
const [
[, storedToken],
[, storedUser],
[, storedServerAddress],
[, storedCanCreate],
[, storedCollection],
] = await AsyncStorage.multiGet([
'auth_token',
'auth_user',
'auth_server_address',
'auth_can_create',
AUTH_COLLECTION_KEY,
]);
void AsyncStorage.multiGet([
'auth_token',
'auth_user',
'auth_server_address',
'auth_can_create',
]).then(
([[, storedToken], [, storedUser], [, storedServerAddress], [, storedCanCreate]]) => {
if (cancelled) return;
let restoredUser: User | null = null;
if (storedCanCreate) {
setCanCreate(storedCanCreate === 'true');
}
if (storedToken && storedUser) {
restoredUser = JSON.parse(storedUser) as User;
api.setToken(storedToken);
setToken(storedToken);
setUser(restoredUser);
}
const collection = isAuthCollection(storedCollection)
? storedCollection
: collectionFromUser(restoredUser);
if (collection) {
api.setAuthCollection(collection);
}
if (collection === '_superusers') {
api.setCanCreate(true);
setCanCreate(true);
} else if (storedCanCreate) {
const restoredCanCreate = storedCanCreate === 'true';
api.setCanCreate(restoredCanCreate);
setCanCreate(restoredCanCreate);
api.setToken(storedToken);
setUser(JSON.parse(storedUser));
}
if (storedServerAddress) {
@@ -235,78 +69,36 @@ export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children
api.setAddress(storedServerAddress + '/api');
}
const untilRefresh = storedToken ? msUntilRefresh(storedToken) : null;
const refreshIsDue = !!storedToken && !!restoredUser && untilRefresh != null && untilRefresh <= 0;
if (refreshIsDue) {
try {
// Hold the loading gate so an expired token does not flash the device list.
await api.refreshAuth();
} catch {
// Revoked tokens sign out; transient failures keep the session and retry.
}
} else if (storedToken && restoredUser) {
watchToken(storedToken);
}
if (!cancelled) {
setIsLoading(false);
}
} catch (error) {
setIsLoading(false);
},
error => {
if (cancelled) return;
console.error('Failed to load auth', error);
setIsLoading(false);
}
})();
);
return () => {
cancelled = true;
};
}, [watchToken]);
useEffect(() => {
const subscription = AppState.addEventListener('change', nextState => {
if (nextState !== 'active') return;
const currentToken = api.getToken();
if (!currentToken) return;
const untilRefresh = msUntilRefresh(currentToken);
if (untilRefresh == null) return;
if (untilRefresh <= 0) {
void refreshSessionRef.current();
return;
}
armRefreshTimerRef.current(currentToken);
});
return () => {
subscription.remove();
};
}, []);
const login = async (nextServerAddress: string, identity: string, password: string) => {
const response: AuthResponse = await api.authenticate(nextServerAddress, identity, password);
const collection = api.getAuthCollection();
const login = async (serverAddress: string, identity: string, password: string) => {
try {
const response: AuthResponse = await api.authenticate(serverAddress, identity, password);
await enqueueSessionWrite(async () => {
const pairs: [string, string][] = [
['auth_token', response.token],
['auth_user', JSON.stringify(response.record)],
['auth_server_address', nextServerAddress],
['auth_can_create', api.getCanCreate() ? 'true' : 'false'],
];
if (collection) {
pairs.push([AUTH_COLLECTION_KEY, collection]);
}
await AsyncStorage.multiSet(pairs);
});
await AsyncStorage.setItem('auth_token', response.token);
await AsyncStorage.setItem('auth_user', JSON.stringify(response.record));
await AsyncStorage.setItem('auth_server_address', serverAddress);
await AsyncStorage.setItem('auth_can_create', api.getCanCreate() ? 'true' : 'false');
setToken(response.token);
setUser(response.record);
setServerAddress(nextServerAddress);
setCanCreate(api.getCanCreate() || false);
watchToken(response.token);
setToken(response.token);
setUser(response.record);
setServerAddress(serverAddress);
setCanCreate(api.getCanCreate() || false);
} catch (error) {
throw error;
}
};
const logout = async () => {
src/services/api.ts
+97 -251
View File
@@ -5,47 +5,12 @@ import {
PermissionResponse,
} from '../types';
export type AuthCollection = 'users' | '_superusers';
export type ApiError = Error & {
status?: number;
isAuthError?: boolean;
};
export type AuthUpdateListener = (auth: AuthResponse) => void | Promise<void>;
export type AuthFailureListener = (error: unknown) => void | Promise<void>;
const AUTH_ERROR_MESSAGE = /authorization token|invalid token|unauthorized|not authenticated/i;
export function isAuthCollection(value: unknown): value is AuthCollection {
return value === 'users' || value === '_superusers';
}
export function isRevokedAuthError(error: unknown): boolean {
if (typeof error !== 'object' || error === null) return false;
const status = (error as { status?: unknown }).status;
return status === 401 || status === 403 || status === 404;
}
function isSessionChanged(error: unknown): boolean {
return (
typeof error === 'object' &&
error !== null &&
(error as { sessionChanged?: boolean }).sessionChanged === true
);
}
class UpSnapAPI {
private token: string | null = null;
private address: string | null = null;
private canCreate: boolean | null = null;
private authCollection: AuthCollection | null = null;
private authEpoch = 0;
private unauthorizedHandler: (() => Promise<void>) | null = null;
private authUpdateListener: AuthUpdateListener | null = null;
private authFailureListener: AuthFailureListener | null = null;
private isHandlingUnauthorized = false;
private refreshInFlight: Promise<AuthResponse> | null = null;
setToken(token: string) {
this.token = token;
@@ -57,7 +22,6 @@ class UpSnapAPI {
clearToken() {
this.token = null;
this.authEpoch += 1;
}
setAddress(address: string) {
@@ -84,30 +48,10 @@ class UpSnapAPI {
this.canCreate = null;
}
setAuthCollection(collection: AuthCollection | null) {
this.authCollection = collection;
}
getAuthCollection(): AuthCollection | null {
return this.authCollection;
}
clearAuthCollection() {
this.authCollection = null;
}
setUnauthorizedHandler(handler: (() => Promise<void>) | null) {
this.unauthorizedHandler = handler;
}
setAuthUpdateListener(listener: AuthUpdateListener | null) {
this.authUpdateListener = listener;
}
setAuthFailureListener(listener: AuthFailureListener | null) {
this.authFailureListener = listener;
}
private async handleUnauthorized() {
if (!this.unauthorizedHandler || this.isHandlingUnauthorized) {
return;
@@ -122,7 +66,7 @@ class UpSnapAPI {
}
}
private async errorFromResponse(response: Response, fallbackMessage: string): Promise<ApiError> {
private async throwApiError(response: Response, fallbackMessage: string): Promise<never> {
let message = fallbackMessage;
try {
@@ -132,26 +76,23 @@ class UpSnapAPI {
// Ignore JSON parsing errors and use the fallback message.
}
const apiError = new Error(message) as ApiError;
apiError.status = response.status;
apiError.isAuthError =
const isAuthError =
response.status === 401 ||
response.status === 403 ||
AUTH_ERROR_MESSAGE.test(message);
return apiError;
}
/authorization token|invalid token|unauthorized|not authenticated/i.test(message);
private async throwApiError(
response: Response,
fallbackMessage: string,
skipUnauthorizedHandler = false,
): Promise<never> {
const error = await this.errorFromResponse(response, fallbackMessage);
if (error.isAuthError && !skipUnauthorizedHandler) {
if (isAuthError) {
await this.handleUnauthorized();
}
const error = new Error(message) as Error & {
status?: number;
isAuthError?: boolean;
};
error.status = response.status;
error.isAuthError = isAuthError;
throw error;
}
@@ -167,166 +108,11 @@ class UpSnapAPI {
return headers;
}
private sessionChanged(): ApiError {
const error = new Error('Auth session changed') as ApiError & { sessionChanged: true };
error.sessionChanged = true;
error.isAuthError = true;
return error;
}
/**
* One refresh is shared by the expiry timer and every request that receives a 401.
* PocketBase returns a new auth token and record for the same collection.
*/
async refreshAuth(): Promise<AuthResponse> {
if (!this.refreshInFlight) {
this.refreshInFlight = this.performRefresh().finally(() => {
this.refreshInFlight = null;
});
}
return this.refreshInFlight;
}
private async performRefresh(): Promise<AuthResponse> {
const epoch = this.authEpoch;
const tokenAtStart = this.token;
try {
if (!tokenAtStart || !this.address) {
throw Object.assign(new Error('Not authenticated'), {
status: 401,
isAuthError: true,
}) as ApiError;
}
const collections: AuthCollection[] = this.authCollection
? [this.authCollection]
: ['users', '_superusers'];
let lastError: ApiError | null = null;
for (let index = 0; index < collections.length; index += 1) {
const collection = collections[index];
const response = await fetch(
`${this.address}/collections/${collection}/auth-refresh`,
{
method: 'POST',
headers: this.getHeaders(),
},
);
if (this.authEpoch !== epoch || this.token !== tokenAtStart) {
throw this.sessionChanged();
}
if (response.ok) {
const data = (await response.json()) as AuthResponse;
if (this.authEpoch !== epoch || this.token !== tokenAtStart) {
throw this.sessionChanged();
}
if (!data?.token) {
throw Object.assign(new Error('Auth refresh failed'), {
status: 401,
isAuthError: true,
}) as ApiError;
}
this.authCollection = isAuthCollection(data.record?.collectionName)
? data.record.collectionName
: collection;
this.token = data.token;
if (this.authCollection === '_superusers') {
this.canCreate = true;
}
try {
await this.authUpdateListener?.(data);
} catch (error) {
console.error('Failed to persist refreshed auth', error);
}
return data;
}
lastError = await this.errorFromResponse(response, 'Auth refresh failed');
const tryNextCollection =
!this.authCollection && index < collections.length - 1 && response.status === 403;
if (!tryNextCollection) {
throw lastError;
}
}
throw (
lastError ??
(Object.assign(new Error('Auth refresh failed'), {
status: 401,
isAuthError: true,
}) as ApiError)
);
} catch (error) {
if (!isSessionChanged(error)) {
try {
await this.authFailureListener?.(error);
} catch (listenerError) {
console.error('Failed to handle auth refresh failure', listenerError);
}
}
throw error;
}
}
/**
* On 401, refresh once and retry the original request.
* A second 401, or a refresh the server rejects, ends the session.
*/
private async request(url: string, fallbackMessage: string, init?: RequestInit): Promise<Response> {
const send = () =>
fetch(url, {
...init,
headers: this.getHeaders(),
});
const response = await send();
if (response.ok) {
return response;
}
if (response.status === 401 && this.token) {
try {
await this.refreshAuth();
} catch (error) {
if (isSessionChanged(error)) {
throw error;
}
if (!isRevokedAuthError(error)) {
throw error;
}
await this.handleUnauthorized();
return this.throwApiError(response, fallbackMessage, true);
}
const retried = await send();
if (!retried.ok) {
if (retried.status === 401) {
await this.handleUnauthorized();
return this.throwApiError(retried, fallbackMessage, true);
}
return this.throwApiError(retried, fallbackMessage);
}
return retried;
}
return this.throwApiError(response, fallbackMessage);
}
async authenticate(
serverAddress: string,
identity: string,
password: string
): Promise<AuthResponse> {
this.authEpoch += 1;
this.token = null;
this.authCollection = null;
this.address = serverAddress + '/api';
const response = await fetch(
@@ -339,7 +125,7 @@ class UpSnapAPI {
);
if (!response.ok) {
const superuserResponse = await fetch(
const response = await fetch(
`${this.address}/collections/_superusers/auth-with-password`,
{
method: 'POST',
@@ -348,20 +134,18 @@ class UpSnapAPI {
}
);
if (!superuserResponse.ok) {
await this.throwApiError(superuserResponse, 'Authentication failed');
if (!response.ok) {
await this.throwApiError(response, 'Authentication failed');
}
const data: AuthResponse = await superuserResponse.json();
const data: AuthResponse = await response.json();
this.token = data.token;
this.authCollection = '_superusers';
this.canCreate = true;
return data;
}
const data: AuthResponse = await response.json();
this.token = data.token;
this.authCollection = 'users';
const userID = data.record.id;
const userPermissionResponse = await fetch(
@@ -381,80 +165,142 @@ class UpSnapAPI {
}
async getDevices(page = 1, perPage = 100): Promise<Device[]> {
const response = await this.request(
const response = await fetch(
`${this.address}/collections/devices/records?page=${page}&perPage=${perPage}`,
'Failed to fetch devices',
{
headers: this.getHeaders(),
}
);
if (!response.ok) {
await this.throwApiError(response, 'Failed to fetch devices');
}
const data = await response.json();
return data.items;
}
async getDevice(id: string): Promise<Device> {
const response = await this.request(
const response = await fetch(
`${this.address}/collections/devices/records/${id}`,
'Failed to fetch device',
{
headers: this.getHeaders(),
}
);
if (!response.ok) {
await this.throwApiError(response, 'Failed to fetch device');
}
return response.json();
}
async createDevice(device: Partial<Device>): Promise<Device> {
const response = await this.request(
const response = await fetch(
`${this.address}/collections/devices/records`,
'Failed to create device',
{
method: 'POST',
headers: this.getHeaders(),
body: JSON.stringify(device),
},
}
);
if (!response.ok) {
await this.throwApiError(response, 'Failed to create device');
}
return response.json();
}
async updateDevice(id: string, device: Partial<Device>): Promise<Device> {
const response = await this.request(
const response = await fetch(
`${this.address}/collections/devices/records/${id}`,
'Failed to update device',
{
method: 'PATCH',
headers: this.getHeaders(),
body: JSON.stringify(device),
},
}
);
if (!response.ok) {
await this.throwApiError(response, 'Failed to update device');
}
return response.json();
}
async deleteDevice(id: string): Promise<void> {
await this.request(
const response = await fetch(
`${this.address}/collections/devices/records/${id}`,
'Failed to delete device',
{ method: 'DELETE' },
{
method: 'DELETE',
headers: this.getHeaders(),
}
);
if (!response.ok) {
await this.throwApiError(response, 'Failed to delete device');
}
}
async wakeDevice(id: string): Promise<void> {
await this.request(`${this.address}/upsnap/wake/${id}`, 'Failed to wake device');
const response = await fetch(`${this.address}/upsnap/wake/${id}`, {
headers: this.getHeaders(),
});
if (!response.ok) {
await this.throwApiError(response, 'Failed to wake device');
}
}
async wakeGroup(id: string): Promise<void> {
await this.request(`${this.address}/upsnap/wakegroup/${id}`, 'Failed to wake group');
const response = await fetch(`${this.address}/upsnap/wakegroup/${id}`, {
headers: this.getHeaders(),
});
if (!response.ok) {
await this.throwApiError(response, 'Failed to wake group');
}
}
async sleepDevice(id: string): Promise<void> {
await this.request(`${this.address}/upsnap/sleep/${id}`, 'Failed to sleep device');
const response = await fetch(`${this.address}/upsnap/sleep/${id}`, {
headers: this.getHeaders(),
});
if (!response.ok) {
await this.throwApiError(response, 'Failed to sleep device');
}
}
async rebootDevice(id: string): Promise<void> {
await this.request(`${this.address}/upsnap/reboot/${id}`, 'Failed to reboot device');
const response = await fetch(`${this.address}/upsnap/reboot/${id}`, {
headers: this.getHeaders(),
});
if (!response.ok) {
await this.throwApiError(response, 'Failed to reboot device');
}
}
async shutdownDevice(id: string): Promise<void> {
await this.request(`${this.address}/upsnap/shutdown/${id}`, 'Failed to shutdown device');
const response = await fetch(`${this.address}/upsnap/shutdown/${id}`, {
headers: this.getHeaders(),
});
if (!response.ok) {
await this.throwApiError(response, 'Failed to shutdown device');
}
}
async scanNetwork(): Promise<NetworkScanResult[]> {
const response = await this.request(`${this.address}/upsnap/scan`, 'Failed to scan network');
const response = await fetch(`${this.address}/upsnap/scan`, {
headers: this.getHeaders(),
});
if (!response.ok) {
await this.throwApiError(response, 'Failed to scan network');
}
const data = await response.json();
if (data.devices && Array.isArray(data.devices)) {
src/services/jwtExpiry.ts
-41
View File
@@ -1,41 +0,0 @@
const BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
function decodeBase64Url(segment: string): string {
const normalized = segment.replace(/-/g, '+').replace(/_/g, '/');
const padded = normalized + '='.repeat((4 - (normalized.length % 4)) % 4);
const bytes: number[] = [];
for (let index = 0; index < padded.length; index += 4) {
const a = BASE64_ALPHABET.indexOf(padded[index]);
const b = BASE64_ALPHABET.indexOf(padded[index + 1]);
const c = padded[index + 2] === '=' ? 0 : BASE64_ALPHABET.indexOf(padded[index + 2]);
const d = padded[index + 3] === '=' ? 0 : BASE64_ALPHABET.indexOf(padded[index + 3]);
if (a < 0 || b < 0 || c < 0 || d < 0) {
throw new Error('Invalid base64url');
}
const chunk = (a << 18) | (b << 12) | (c << 6) | d;
bytes.push((chunk >> 16) & 255);
if (padded[index + 2] !== '=') bytes.push((chunk >> 8) & 255);
if (padded[index + 3] !== '=') bytes.push(chunk & 255);
}
return String.fromCharCode(...bytes);
}
/**
* Reads the JWT `exp` claim in milliseconds.
* Scheduling only; the signature is not verified.
*/
export function getJwtExpiryMs(token: string): number | null {
const segment = token.split('.')[1];
if (!segment) return null;
try {
const payload = JSON.parse(decodeBase64Url(segment)) as { exp?: unknown };
if (typeof payload.exp !== 'number' || !Number.isFinite(payload.exp)) return null;
return payload.exp * 1000;
} catch {
return null;
}
}