@axium/client 0.5.0 → 0.7.0

package/assets/styles.css

@@ -65,6 +65,27 @@ textarea {
 	outline: none;
 }
 
+select,
+::picker(select) {
+	appearance: base-select;
+}
+
+::picker(select) {
+	border: 1px solid var(--border-accent);
+	padding: 1em;
+	border-radius: 0.5em;
+	background-color: var(--bg-menu);
+}
+
+option {
+	padding: 0.25em 0;
+	border-radius: 0.5em;
+}
+
+option:hover {
+	background-color: var(--bg-alt);
+}
+
 button {
 	cursor: pointer;
 }

package/axium-client.service

@@ -0,0 +1,22 @@
+[Unit]
+Description=Axium Client Daemon
+Wants=network-online.target
+After=network-online.target
+RequiresMountsFor=%Y
+StartLimitIntervalSec=1min
+StartLimitBurst=5
+StartLimitAction=none
+FailureAction=none
+
+[Service]
+Type=simple
+ExecStartPre=/usr/bin/env cd "%Y/../../.."
+ExecStart=/usr/bin/env npx --prefix "%Y/../../.." axium-client run
+ExecReload=kill -HUP $MAINPID
+SyslogIdentifier=axium-client
+Restart=on-failure
+RestartSec=3s
+TimeoutStopSec=15s
+
+[Install]
+WantedBy=default.target

package/dist/cli/config.d.ts

@@ -0,0 +1,24 @@
+export declare const configDir: string;
+export declare const cacheDir: string;
+export declare function session(): {
+    id: string;
+    userId: string;
+    expires: Date;
+    created: Date;
+    elevated: boolean;
+    user: {
+        id: string;
+        name: string;
+        email: string;
+        preferences: Record<string, any>;
+        roles: string[];
+        registeredAt: Date;
+        isAdmin: boolean;
+        emailVerified?: Date | null | undefined;
+        image?: string | null | undefined;
+    };
+};
+export declare function loadConfig(safe: boolean): Promise<void>;
+export declare function saveConfig(): void;
+export declare const _dayMs: number;
+export declare function updateCache(force: boolean): Promise<void>;

package/dist/cli/config.js

@@ -0,0 +1,54 @@
+import * as io from '@axium/core/node/io';
+import { loadPlugin } from '@axium/core/node/plugins';
+import { mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path/posix';
+import * as z from 'zod';
+import { ClientConfig, config } from '../config.js';
+import { fetchAPI, setPrefix, setToken } from '../requests.js';
+import { getCurrentSession } from '../user.js';
+export const configDir = join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'axium');
+mkdirSync(configDir, { recursive: true });
+const axcConfig = join(configDir, 'config.json');
+export const cacheDir = join(process.env.XDG_CACHE_HOME || join(homedir(), '.cache'), 'axium');
+mkdirSync(cacheDir, { recursive: true });
+export function session() {
+    if (!config.token)
+        io.exit('Not logged in.', 4);
+    if (!config.cache)
+        io.exit('No session data available.', 3);
+    return config.cache.session;
+}
+export async function loadConfig(safe) {
+    try {
+        Object.assign(config, io.readJSON(axcConfig, ClientConfig));
+        if (config.server)
+            setPrefix(config.server);
+        if (config.token)
+            setToken(config.token);
+        for (const plugin of config.plugins ?? [])
+            await loadPlugin('client', plugin, axcConfig, safe);
+    }
+    catch (e) {
+        io.warn('Failed to load config: ' + (e instanceof z.core.$ZodError ? z.prettifyError(e) : io._debugOutput ? e.stack : e.message));
+    }
+}
+export function saveConfig() {
+    io.writeJSON(axcConfig, config);
+    io.debug('Saved config to ' + axcConfig);
+}
+export const _dayMs = 24 * 3600_000;
+export async function updateCache(force) {
+    if (!force && config.cache && config.cache.fetched + _dayMs > Date.now())
+        return;
+    io.start('Fetching metadata');
+    const [session, apps] = await Promise.all([getCurrentSession(), fetchAPI('GET', 'apps')]).catch(err => io.exit(err.message));
+    try {
+        config.cache = { fetched: Date.now(), session, apps };
+        saveConfig();
+        io.done();
+    }
+    catch {
+        return;
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#! /usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,244 @@
+#! /usr/bin/env node
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { outputDaemonStatus, io, pluginText } from '@axium/core/node';
+import { _findPlugin, plugins } from '@axium/core/plugins';
+import { program } from 'commander';
+import { createServer } from 'node:http';
+import { createInterface } from 'node:readline/promises';
+import { styleText } from 'node:util';
+import * as z from 'zod';
+import $pkg from '../../package.json' with { type: 'json' };
+import { config, resolveServerURL } from '../config.js';
+import { prefix, setPrefix, setToken } from '../requests.js';
+import { getCurrentSession, logout } from '../user.js';
+import { loadConfig, saveConfig, updateCache } from './config.js';
+const safe = z.stringbool().default(false).parse(process.env.SAFE?.toLowerCase()) || process.argv.includes('--safe');
+await loadConfig(safe);
+process.on('SIGHUP', () => {
+    io.info('Reloading configuration due to SIGHUP.');
+    void loadConfig(safe);
+});
+var rl, axiumPlugin;
+const env_1 = { stack: [], error: void 0, hasError: false };
+try {
+    rl = __addDisposableResource(env_1, createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    }), false);
+    rl.on('SIGINT', () => io.exit('Aborted.', 7));
+    program
+        .version($pkg.version)
+        .name('axium-client')
+        .alias('axc')
+        .description('Axium client CLI')
+        .configureHelp({ showGlobalOptions: true })
+        .option('--debug', 'override debug mode')
+        .option('--no-debug', 'override debug mode')
+        .option('--refresh-session', 'Force a refresh of session and user metadata from server')
+        .option('--cache-only', 'Run entirely from local cache, even if it is expired.')
+        .option('--safe', 'do not execute code from plugins');
+    program.on('option:debug', () => io._setDebugOutput(true));
+    program.hook('preAction', async (_, action) => {
+        const opt = action.optsWithGlobals();
+        if (!config.token)
+            return;
+        if (!opt.cacheOnly && action.name() != 'login')
+            await updateCache(opt.refreshSession);
+    });
+    program
+        .command('login')
+        .description('Log in to your account on an Axium server')
+        .argument('[server]', 'Axium server URL')
+        .action(async (url) => {
+        if (prefix[0] != '/')
+            url ||= prefix;
+        url ||= await rl.question('Axium server URL: ');
+        url = resolveServerURL(url);
+        setPrefix(url);
+        const sessionReady = Promise.withResolvers();
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        const server = createServer(async (req, res) => {
+            res.setHeader('access-control-allow-origin', '*');
+            res.setHeader('access-control-allow-methods', '*');
+            res.setHeader('access-control-allow-headers', '*');
+            if (req.method == 'HEAD' || req.method == 'OPTIONS') {
+                res.writeHead(200).end();
+                return;
+            }
+            if (!req.headers['content-type']?.endsWith('/json')) {
+                res.writeHead(415).end('Unexpected content type');
+                return;
+            }
+            if (req.method !== 'POST') {
+                res.writeHead(405).end('Unexpected request method');
+                return;
+            }
+            const { promise: bodyReady, resolve, reject } = Promise.withResolvers();
+            let body = '';
+            req.on('data', chunk => (body += chunk.toString()));
+            req.on('end', resolve);
+            req.on('error', reject);
+            try {
+                await bodyReady;
+                sessionReady.resolve(JSON.parse(body));
+                res.writeHead(200).end();
+            }
+            catch (e) {
+                res.statusCode = 500;
+                res.end('Internal server error: ' + e.message);
+                sessionReady.reject(e.message);
+            }
+        });
+        const serverReady = Promise.withResolvers();
+        server.listen(() => {
+            const { port } = server.address();
+            serverReady.resolve(port);
+        });
+        server.on('error', e => io.exit('Failed to start local callback server: ' + e.message, 5));
+        const port = await serverReady.promise;
+        const authURL = new URL('/login/client?port=' + port, url).href;
+        console.log('Authenticate by visiting this URL in your browser: ' + styleText('underline', authURL));
+        const { token } = await sessionReady.promise.catch(e => io.exit('Failed to obtain session: ' + e, 6));
+        setToken(token);
+        server.close();
+        io.start('Verifying session');
+        const session = await getCurrentSession().catch(e => io.exit(e.message, 6));
+        io.done();
+        io.debug('Session UUID: ' + session.id);
+        console.log(`Welcome ${session.user.name}! Your session is valid until ${session.expires.toLocaleDateString()}.`);
+        config.token = token;
+        config.server = url;
+        saveConfig();
+        await updateCache(true);
+    });
+    program.command('logout').action(async () => {
+        if (!config.token)
+            io.exit('Not logged in.', 4);
+        if (!config.cache)
+            io.exit('No session data available.', 3);
+        await logout(config.cache.session.userId, config.cache.session.id);
+    });
+    program.command('status').action(() => {
+        if (!config.token)
+            return console.log('Not logged in.');
+        if (!config.cache)
+            return console.log('No session data available.');
+        console.log('Logged in to', new URL(prefix).host);
+        console.log(styleText('whiteBright', 'Session ID:'), config.cache.session.id);
+        const { user } = config.cache.session;
+        console.log(styleText('whiteBright', 'User:'), user.name, `<${user.email}>`, styleText('dim', `(${user.id})`));
+        outputDaemonStatus('axium-client');
+    });
+    program
+        .command('run')
+        .argument('[plugin]', 'The plugin to run')
+        .action(async (name) => {
+        if (name) {
+            const plugin = _findPlugin(name);
+            await plugin._client?.run();
+            return;
+        }
+        for (const plugin of plugins.values())
+            await plugin._client?.run();
+    });
+    axiumPlugin = program.command('plugin').alias('plugins').description('Manage plugins');
+    axiumPlugin
+        .command('list')
+        .alias('ls')
+        .description('List loaded plugins')
+        .option('-l, --long', 'use the long listing format')
+        .option('--no-versions', 'do not show plugin versions')
+        .action((opt) => {
+        if (!plugins.size) {
+            console.log('No plugins loaded.');
+            return;
+        }
+        if (!opt.long) {
+            console.log(Array.from(plugins.keys()).join(', '));
+            return;
+        }
+        console.log(styleText('whiteBright', plugins.size + ' plugin(s) loaded:'));
+        for (const plugin of plugins.values()) {
+            console.log(plugin.name, opt.versions ? plugin.version : '');
+        }
+    });
+    axiumPlugin
+        .command('info')
+        .description('Get information about a plugin')
+        .argument('<plugin>', 'the plugin to get information about')
+        .action((search) => {
+        const plugin = _findPlugin(search);
+        for (const line of pluginText(plugin))
+            console.log(line);
+    });
+    axiumPlugin
+        .command('remove')
+        .alias('rm')
+        .description('Remove a plugin')
+        .argument('<plugin>', 'the plugin to remove')
+        .action((search) => {
+        const plugin = _findPlugin(search);
+        config.plugins = config.plugins.filter(p => p !== plugin.specifier);
+        plugins.delete(plugin.name);
+        saveConfig();
+    });
+    await program.parseAsync();
+}
+catch (e_1) {
+    env_1.error = e_1;
+    env_1.hasError = true;
+}
+finally {
+    __disposeResources(env_1);
+}

package/dist/config.d.ts

@@ -0,0 +1,37 @@
+import * as z from 'zod';
+export declare const ClientConfig: z.ZodObject<{
+    token: z.ZodOptional<z.ZodNullable<z.ZodBase64>>;
+    server: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+    cache: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        fetched: z.ZodInt;
+        session: z.ZodObject<{
+            id: z.ZodUUID;
+            userId: z.ZodUUID;
+            expires: z.ZodCoercedDate<unknown>;
+            created: z.ZodCoercedDate<unknown>;
+            elevated: z.ZodBoolean;
+            user: z.ZodObject<{
+                id: z.ZodUUID;
+                name: z.ZodString;
+                email: z.ZodEmail;
+                emailVerified: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+                image: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+                preferences: z.ZodRecord<z.ZodString, z.ZodAny>;
+                roles: z.ZodArray<z.ZodString>;
+                registeredAt: z.ZodCoercedDate<unknown>;
+                isAdmin: z.ZodBoolean;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        apps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            image: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$loose>>>;
+    plugins: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export interface ClientConfig extends z.infer<typeof ClientConfig> {
+}
+export declare const config: ClientConfig;
+export declare function resolveServerURL(server: string): string;

package/dist/config.js

@@ -0,0 +1,33 @@
+import { debug, warn } from '@axium/core/io';
+import { App, Session, User } from '@axium/core';
+import * as z from 'zod';
+export const ClientConfig = z.looseObject({
+    token: z.base64().nullish(),
+    server: z.url().nullish(),
+    // Cache to reduce server load:
+    cache: z
+        .looseObject({
+        fetched: z.int(),
+        session: Session.extend({ user: User }),
+        apps: App.array(),
+    })
+        .nullish(),
+    plugins: z.string().array().default([]),
+});
+export const config = {
+    plugins: [],
+};
+export function resolveServerURL(server) {
+    if (!server.startsWith('http://') && !server.startsWith('https://'))
+        server = 'https://' + server;
+    const url = new URL(server);
+    if (url.pathname.endsWith('/api'))
+        url.pathname += '/';
+    else if (url.pathname.at(-1) == '/' && !url.pathname.endsWith('/api/'))
+        url.pathname += 'api/';
+    if (url.pathname != '/api/')
+        warn('Resolved server URL is not at the top level: ' + url.href);
+    else
+        debug('Resolved server URL: ' + url.href);
+    return url.href;
+}

package/dist/user.d.ts

@@ -13,7 +13,7 @@ export declare function getSessions(userId: string): Promise<Session[]>;
 export declare function logout(userId: string, ...sessionId: string[]): Promise<Session[]>;
 export declare function logoutAll(userId: string): Promise<Session[]>;
 export declare function logoutCurrentSession(): Promise<Session>;
-export declare function register(_data: Record<string, FormDataEntryValue>): Promise<void>;
+export declare function register(_data: Record<string, unknown>): Promise<void>;
 export declare function userInfo(userId: string): Promise<UserPublic & Partial<User>>;
 export declare function updateUser(userId: string, data: Record<string, FormDataEntryValue>): Promise<User>;
 export declare function fullUserInfo(userId: string): Promise<User & {

package/lib/AccessControlDialog.svelte

@@ -1,10 +1,9 @@
 <script lang="ts">
-	import FormDialog from './FormDialog.svelte';
+	import type { User } from '@axium/core';
 	import { permissionNames, type AccessControllable } from '@axium/core/access';
 	import type { Entries } from 'utilium';
+	import FormDialog from './FormDialog.svelte';
 	import UserCard from './UserCard.svelte';
-	import type { Permission, AccessControl } from '@axium/core/access';
-	import type { User } from '@axium/core';
 
 	let {
 		item = $bindable(),

package/lib/FormDialog.svelte

@@ -1,14 +1,6 @@
 <script lang="ts">
 	import Dialog from './Dialog.svelte';
 
-	function resolveRedirectAfter() {
-		const url = new URL(location.href);
-		const maybe = url.searchParams.get('after');
-		if (!maybe || maybe == url.pathname) return '/';
-		for (const prefix of ['/api/']) if (maybe.startsWith(prefix)) return '/';
-		return maybe || '/';
-	}
-
 	let {
 		children,
 		dialog = $bindable(),
@@ -52,8 +44,7 @@
 		const data = Object.fromEntries(new FormData(e.currentTarget));
 		submit(data)
 			.then(result => {
-				if (pageMode) window.location.href = resolveRedirectAfter();
-				else dialog!.close();
+				if (!pageMode) dialog!.close();
 			})
 			.catch((e: any) => {
 				if (!e) error = 'An unknown error occurred';

package/lib/Login.svelte

@@ -1,15 +1,17 @@
 <script lang="ts">
 	import { loginByEmail } from '@axium/client/user';
 	import FormDialog from './FormDialog.svelte';
+	import redirectAfter from './auth_redirect.js';
 
 	let { dialog = $bindable(), fullPage = false }: { dialog?: HTMLDialogElement; fullPage?: boolean } = $props();
 
-	function submit(data: { email: string }) {
+	async function submit(data: { email: string }) {
 		if (typeof data.email != 'string') {
 			throw 'Tried to upload a file for an email. Huh?!';
 		}
 
-		return loginByEmail(data.email);
+		await loginByEmail(data.email);
+		if (fullPage && redirectAfter) location.href = redirectAfter;
 	}
 </script>
 

package/lib/Register.svelte

@@ -1,11 +1,17 @@
 <script lang="ts">
 	import { register } from '@axium/client/user';
 	import FormDialog from './FormDialog.svelte';
+	import redirectAfter from './auth_redirect.js';
 
 	let { dialog = $bindable(), fullPage = false }: { dialog?: HTMLDialogElement; fullPage?: boolean } = $props();
+
+	async function submit(data: Record<string, FormDataEntryValue>) {
+		await register(data);
+		if (fullPage && redirectAfter) location.href = redirectAfter;
+	}
 </script>
 
-<FormDialog bind:dialog submitText="Register" submit={register} pageMode={fullPage}>
+<FormDialog bind:dialog submitText="Register" {submit} pageMode={fullPage}>
 	<div>
 		<label for="name">Display Name</label>
 		<input name="name" type="text" required />

package/lib/auth_redirect.ts

@@ -0,0 +1,28 @@
+import { getCurrentSession } from '@axium/client/user';
+
+function resolveRedirect(): string | false {
+	const url = new URL(location.href);
+	const maybe = url.searchParams.get('after');
+	if (!['/login', '/register'].includes(url.pathname)) return false;
+	if (!maybe || maybe == url.pathname) return '/';
+
+	if (maybe[0] != '/' || maybe[1] == '/') {
+		console.error('Ignoring potentially malicious redirect:', maybe);
+		return false;
+	}
+
+	const redirect = new URL(maybe, location.origin);
+
+	return redirect.pathname + redirect.search || '/';
+}
+
+const redirect = resolveRedirect();
+
+try {
+	if (!redirect) throw 'No redirect';
+	// Auto-redirect if already logged in.
+	const session = await getCurrentSession();
+	if (session) location.href = redirect;
+} catch {}
+
+export default redirect;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/client",
-	"version": "0.5.0",
+	"version": "0.7.0",
 	"author": "James Prevett <jp@jamespre.dev>",
 	"funding": {
 		"type": "individual",
@@ -15,6 +15,10 @@
 	"bugs": {
 		"url": "https://github.com/james-pre/axium/issues"
 	},
+	"bin": {
+		"axium-client": "dist/cli/index.js",
+		"axc": "dist/cli/index.js"
+	},
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -22,7 +26,8 @@
 		"assets",
 		"dist",
 		"lib",
-		"styles"
+		"styles",
+		"axium-client.service"
 	],
 	"exports": {
 		".": "./dist/index.js",
@@ -35,7 +40,7 @@
 		"build": "tsc"
 	},
 	"peerDependencies": {
-		"@axium/core": ">=0.6.0",
+		"@axium/core": ">=0.10.0",
 		"utilium": "^2.3.8",
 		"zod": "^4.0.5",
 		"svelte": "^5.36.0"