llm-tuner 0.4.4 → 0.5.0

package/src/core/settings.js

@@ -9,6 +9,11 @@ import { PROFILES } from './profiles.js';
 export const THEMES = Object.freeze(['system', 'light', 'dark']);
 export const DEFAULT_THEME = 'system';
 
+export const DEFAULT_SERVERS = Object.freeze([
+  Object.freeze({ id: 'local', name: 'Local Machine', url: 'http://127.0.0.1:7860', token: null }),
+]);
+export const DEFAULT_ACTIVE_SERVER_ID = 'local';
+
 /** Returns the value if it is a valid profile, otherwise null. */
 function storedProfile(value) {
   return PROFILES.includes(value) ? value : null;
@@ -18,15 +23,47 @@ export function normalizeTheme(theme) {
   return THEMES.includes(theme) ? theme : DEFAULT_THEME;
 }
 
+export function normalizeServers(servers) {
+  if (!Array.isArray(servers)) return [...DEFAULT_SERVERS];
+  const list = servers
+    .filter((s) => s && typeof s === 'object' && s.id)
+    .map((s) => ({
+      id: String(s.id),
+      name: String(s.name || s.id),
+      url: String(s.url || '').replace(/\/+$/, ''),
+      token: s.token ? String(s.token) : null,
+    }));
+  if (list.length === 0) return [...DEFAULT_SERVERS];
+  if (!list.some((s) => s.id === 'local')) {
+    list.unshift(DEFAULT_SERVERS[0]);
+  }
+  return list;
+}
+
+export function normalizeActiveServerId(activeId, servers) {
+  const list = normalizeServers(servers);
+  return list.some((s) => s.id === activeId) ? activeId : DEFAULT_ACTIVE_SERVER_ID;
+}
+
+export function getActiveServer(settings) {
+  const servers = normalizeServers(settings?.servers);
+  const activeId = normalizeActiveServerId(settings?.activeServerId, servers);
+  return servers.find((s) => s.id === activeId) || servers[0];
+}
+
 export const settingsPath = () => path.join(configDir(), 'settings.json');
 
 /** Current settings. A missing, corrupt or hand-edited file yields the defaults; never throws. */
 export async function readSettings() {
   const s = await readJson(settingsPath(), null);
+  const servers = normalizeServers(s?.servers);
+  const activeServerId = normalizeActiveServerId(s?.activeServerId, servers);
   return {
     lang: normalizeLocale(s?.lang),
     theme: normalizeTheme(s?.theme),
     profile: storedProfile(s?.profile),
+    servers,
+    activeServerId,
   };
 }
 
@@ -37,8 +74,19 @@ export async function writeSettings(patch) {
   const lang = normalizeLocale(patch?.lang !== undefined ? patch.lang : base.lang);
   const theme = normalizeTheme(patch?.theme !== undefined ? patch.theme : base.theme);
   const profile = storedProfile(patch?.profile) ?? base.profile;
-  const next = { ...base, ...patch, lang, theme, profile };
+  const servers = patch?.servers !== undefined ? normalizeServers(patch.servers) : normalizeServers(base.servers);
+  const activeServerId = patch?.activeServerId !== undefined
+    ? normalizeActiveServerId(patch.activeServerId, servers)
+    : normalizeActiveServerId(base.activeServerId, servers);
+
+  const next = { ...base, ...patch, lang, theme, profile, servers, activeServerId };
   await fs.mkdir(configDir(), { recursive: true });
   await fs.writeFile(settingsPath(), JSON.stringify(next, null, 2));
-  return { lang: next.lang, theme: next.theme, profile: storedProfile(next.profile) };
+  return {
+    lang: next.lang,
+    theme: next.theme,
+    profile: storedProfile(next.profile),
+    servers: next.servers,
+    activeServerId: next.activeServerId,
+  };
 }

package/src/core/util.js

@@ -146,3 +146,29 @@ export function cpuBusyPercent(a, b) {
   }
   return total > 0 ? 100 * (1 - idle / total) : 0;
 }
+
+export function resolveConnectableHost(host = '127.0.0.1', networkInterfaces = os.networkInterfaces) {
+  if (host !== '0.0.0.0' && host !== '::') {
+    return host;
+  }
+
+  let interfaces;
+  if (typeof networkInterfaces === 'function') {
+    interfaces = networkInterfaces();
+  } else if (networkInterfaces && typeof networkInterfaces.networkInterfaces === 'function') {
+    interfaces = networkInterfaces.networkInterfaces();
+  } else {
+    interfaces = os.networkInterfaces();
+  }
+
+  for (const name of Object.keys(interfaces || {})) {
+    const list = interfaces[name] || [];
+    const addr = list.find((info) => (info.family === 'IPv4' || info.family === 4) && !info.internal);
+    if (addr) {
+      return addr.address;
+    }
+  }
+
+  return '127.0.0.1';
+}
+

package/src/i18n/en.js

@@ -1,5 +1,25 @@
 // English catalog: the base language. Every key here must also exist in es.js.
 export default {
+  "web.localServerSettings": "Local Server Settings",
+  "web.serverAutostartLabel": "Start server after login",
+  "web.serverStartupEnabled": "Automatic server startup is enabled",
+  "web.serverStartupDisabled": "Automatic server startup is disabled",
+  "web.serverStartupUnknown": "Automatic server startup state is unknown",
+  "web.serverStartupSaved": "Startup setting saved for next login",
+  "web.serverTokenLabel": "Server authentication token",
+  "web.serverTokenReveal": "Reveal token",
+  "web.serverTokenHide": "Hide token",
+  "web.serverTokenCopy": "Copy token",
+  "web.serverTokenCopied": "Token copied",
+  "web.serverNoConfig": "No server configuration yet. Run /serve or enable automatic startup first.",
+  "web.serverConnectionInfo": "Server listens on {host}:{port}. On another computer use this computer LAN IP with port {port}, not 0.0.0.0 or localhost.",
+  "web.serverStartupUnconfirmed": "Could not confirm startup state.",
+  "web.serverTokenCopyFailed": "Could not confirm token copy.",
+  "cli.serverConnection": "View server connection details and token",
+  "cli.serverConnectionDetails": "Listen address: {host}:{port}; Authentication Token: {token}; From another computer use the server LAN IP with port {port}, not 0.0.0.0 or localhost.",
+  "cli.serverNoConfig": "No server configuration yet. Run /serve or enable automatic startup first.",
+  "cli.serverConnectionInvalid": "Saved server configuration is invalid.",
+  "cli.serverConnectionHelp": "In /settings, select View server connection details and token to retrieve the saved token. Desktop Settings also provides explicit reveal and copy actions.",
   // Engine choice
   'engine.reason.onlyInstalled': '{name} is the only one installed.',
   'engine.reason.multiGpu': 'You have several GPUs: LM Studio lets you set the GPU order and the KV type per model.',
@@ -85,6 +105,8 @@ export default {
   'errors.unknownLocale': 'Unknown language "{lang}". Valid values: {list}',
   'errors.unknownTheme': 'Unknown theme "{theme}". Valid values: {list}',
   'errors.unknownProfile': 'Unknown profile "{profile}". Valid values: {list}',
+  'errors.unauthorized': 'Unauthorized: a valid Bearer token is required.',
+  'errors.forbiddenRemote': 'Forbidden: this operation cannot be performed remotely.',
   'errors.installNotFinished': 'The installation did not finish. Run llm-tuner again when it is done.',
   'errors.modelDownloadFailed': 'Could not download the model',
   'errors.noInstaller': 'There is no automatic installer for this system.',
@@ -114,7 +136,7 @@ Commands:
   /load                        Tune and load a model with optimal hardware settings
   /mcp                         Connect local engine to AI coding agents as MCP server
   /presets                     List saved presets
-  /settings                    Interactive settings menu (language and theme)
+  /settings                    Interactive settings menu (language, theme, and server startup)
   /help                        Show this help message
   /exit                        Exit the interactive menu
 
@@ -132,6 +154,8 @@ Options:
   --lang <en|es>               Interface language (saved for next time)
   --theme <system|light|dark>  Interface theme (saved for next time)
 
+Server startup can be enabled or disabled after login in /settings. It starts on your next login, not immediately.
+
 Ollama service changes may ask for administrator authorization in the terminal.
 Unchanged settings do not restart the service. JSON/noninteractive mode never asks for a password.
 
@@ -141,6 +165,16 @@ Presets are saved in {presetsDir}`,
   'cli.settingsMenu': 'Select an option to configure:',
   'cli.settingsLanguage': 'Language',
   'cli.settingsTheme': 'Theme',
+  'cli.settingsAutostart': 'Automatic server startup after login',
+  'cli.settingsAutostartEnable': 'Enable',
+  'cli.settingsAutostartDisable': 'Disable',
+  'cli.enabled': 'Enabled',
+  'cli.disabled': 'Disabled',
+  'cli.unknown': 'Unknown',
+  'cli.autostartEnabled': 'Server startup is enabled for your next login.',
+  'cli.autostartDisabled': 'Server startup is disabled.',
+  'cli.autostartFailed': 'Could not update automatic server startup: {error}',
+  'cli.settingsServers': 'Active Server',
   'cli.settingsExit': 'Save and return',
   'cli.settingsSaved': 'Settings saved.',
   'cli.langNotSaved': 'Could not save the language preference: {error}',
@@ -284,12 +318,25 @@ Presets are saved in {presetsDir}`,
   'web.mcpAlreadyConfigured': 'Configured',
   'web.mcpSuccess': 'Successfully configured MCP in: {agents}',
   'web.mcpSaveBtn': 'Save & Configure',
+  'web.servers': 'Servers',
+  'web.addServer': 'Add Server',
+  'web.removeServer': 'Remove',
+  'web.addServerModalTitle': 'Add Remote Server',
+  'web.serverName': 'Server Name',
+  'web.serverUrl': 'Server URL',
+  'web.serverToken': 'Authentication Token',
+  'web.testConnection': 'Test Connection',
+  'web.saveServer': 'Save Server',
+  'web.serverConnected': 'Connection successful!',
+  'web.serverConnectionFailed': 'Could not connect to server: {error}',
+  'web.serverActive': 'Active',
 
   // CLI Slash Commands
   'cli.menuTitle': 'Select a command:',
   'cli.cmdLoadDesc': 'Tune and load a model with optimal hardware settings',
   'cli.cmdMcpDesc': 'Connect local engine to AI coding agents as MCP server',
   'cli.cmdPresetsDesc': 'View saved tuning presets',
+  'cli.cmdServeDesc': 'Start remote server mode with API authentication',
   'cli.cmdSettingsDesc': 'Configure interface language and visual theme',
   'cli.cmdHelpDesc': 'View usage help and CLI flags',
   'cli.cmdExitDesc': 'Exit',

package/src/i18n/es.js

@@ -1,5 +1,25 @@
 // Spanish catalog. Same keys and {params} as en.js.
 export default {
+  "web.localServerSettings": "Configuración del servidor local",
+  "web.serverAutostartLabel": "Iniciar servidor después del inicio de sesión",
+  "web.serverStartupEnabled": "El inicio automático del servidor está habilitado",
+  "web.serverStartupDisabled": "El inicio automático del servidor está deshabilitado",
+  "web.serverStartupUnknown": "El estado del inicio automático del servidor es desconocido",
+  "web.serverStartupSaved": "Configuración de inicio guardada para el próximo inicio de sesión",
+  "web.serverTokenLabel": "Token de autenticación del servidor",
+  "web.serverTokenReveal": "Mostrar token",
+  "web.serverTokenHide": "Ocultar token",
+  "web.serverTokenCopy": "Copiar token",
+  "web.serverTokenCopied": "Token copiado",
+  "web.serverNoConfig": "Aún no hay configuración del servidor. Ejecute /serve o habilite el inicio automático primero.",
+  "web.serverConnectionInfo": "El servidor escucha en {host}:{port}. Desde otro ordenador, use la IP LAN de este equipo con el puerto {port}, no 0.0.0.0 ni localhost.",
+  "web.serverStartupUnconfirmed": "No se pudo confirmar el estado del inicio.",
+  "web.serverTokenCopyFailed": "No se pudo confirmar la copia del token.",
+  "cli.serverConnection": "Ver detalles de conexión del servidor y token",
+  "cli.serverConnectionDetails": "Dirección de escucha: {host}:{port}; Token de autenticación: {token}; Desde otro ordenador, use la IP LAN del servidor con el puerto {port}, no 0.0.0.0 ni localhost.",
+  "cli.serverNoConfig": "Aún no hay configuración del servidor. Ejecute /serve o habilite el inicio automático primero.",
+  "cli.serverConnectionInvalid": "La configuración del servidor guardada no es válida.",
+  "cli.serverConnectionHelp": "En /settings, seleccione 'Ver detalles de conexión del servidor y token' para recuperar el token guardado. Los Ajustes de escritorio también ofrecen acciones explícitas de mostrar y copiar.",
   // Engine choice
   'engine.reason.onlyInstalled': '{name} es el único instalado.',
   'engine.reason.multiGpu': 'Tienes varias GPUs: LM Studio permite fijar el orden de GPUs y el tipo de KV por modelo.',
@@ -85,6 +105,8 @@ export default {
   'errors.unknownLocale': 'Idioma desconocido "{lang}". Valores válidos: {list}',
   'errors.unknownTheme': 'Tema desconocido "{theme}". Valores válidos: {list}',
   'errors.unknownProfile': 'Perfil desconocido "{profile}". Valores válidos: {list}',
+  'errors.unauthorized': 'No autorizado: se requiere un token Bearer válido.',
+  'errors.forbiddenRemote': 'Prohibido: esta operación no se puede ejecutar de forma remota.',
   'errors.installNotFinished': 'La instalación no terminó. Vuelve a ejecutar llm-tuner cuando acabe.',
   'errors.modelDownloadFailed': 'No se pudo descargar el modelo',
   'errors.noInstaller': 'No hay un instalador automático para este sistema.',
@@ -114,7 +136,7 @@ Comandos:
   /load                        Ajustar y cargar un modelo con la configuración óptima
   /mcp                         Conectar motor local con agentes de IA como servidor MCP
   /presets                     Listar presets guardados
-  /settings                    Menú interactivo de configuración (idioma y tema)
+  /settings                    Menú interactivo de configuración (idioma, tema e inicio del servidor)
   /help                        Mostrar esta ayuda
   /exit                        Salir del menú interactivo
 
@@ -132,6 +154,8 @@ Opciones:
   --lang <en|es>               Idioma de la interfaz (se guarda para la próxima vez)
   --theme <system|light|dark>  Tema de la interfaz (se guarda para la próxima)
 
+El inicio del servidor se habilita o deshabilita después de iniciar sesión desde /settings. Se ejecuta en el próximo inicio de sesión, no de inmediato.
+
 Los cambios del servicio de Ollama pueden solicitar autorización de administrador en la terminal.
 Si los ajustes no cambian, el servicio no se reinicia. El modo JSON/no interactivo nunca pide contraseña.
 
@@ -141,6 +165,16 @@ Los presets se guardan en {presetsDir}`,
   'cli.settingsMenu': 'Selecciona una opción para configurar:',
   'cli.settingsLanguage': 'Idioma',
   'cli.settingsTheme': 'Tema',
+  'cli.settingsAutostart': 'Inicio automático del servidor después de iniciar sesión',
+  'cli.settingsAutostartEnable': 'Habilitar',
+  'cli.settingsAutostartDisable': 'Deshabilitar',
+  'cli.enabled': 'Habilitado',
+  'cli.disabled': 'Deshabilitado',
+  'cli.unknown': 'Desconocido',
+  'cli.autostartEnabled': 'El inicio del servidor quedó habilitado para tu próximo inicio de sesión.',
+  'cli.autostartDisabled': 'El inicio del servidor quedó deshabilitado.',
+  'cli.autostartFailed': 'No se pudo actualizar el inicio automático del servidor: {error}',
+  'cli.settingsServers': 'Servidor activo',
   'cli.settingsExit': 'Guardar y volver',
   'cli.settingsSaved': 'Configuración guardada.',
   'cli.langNotSaved': 'No se pudo guardar la preferencia de idioma: {error}',
@@ -284,12 +318,25 @@ Los presets se guardan en {presetsDir}`,
   'web.mcpAlreadyConfigured': 'Configurado',
   'web.mcpSuccess': 'MCP configurado con éxito en: {agents}',
   'web.mcpSaveBtn': 'Guardar y configurar',
+  'web.servers': 'Servidores',
+  'web.addServer': 'Agregar servidor',
+  'web.removeServer': 'Eliminar',
+  'web.addServerModalTitle': 'Agregar servidor remoto',
+  'web.serverName': 'Nombre del servidor',
+  'web.serverUrl': 'URL del servidor',
+  'web.serverToken': 'Token de autenticación',
+  'web.testConnection': 'Probar conexión',
+  'web.saveServer': 'Guardar servidor',
+  'web.serverConnected': '¡Conexión exitosa!',
+  'web.serverConnectionFailed': 'No se pudo conectar al servidor: {error}',
+  'web.serverActive': 'Activo',
 
   // CLI Slash Commands
   'cli.menuTitle': 'Selecciona un comando:',
   'cli.cmdLoadDesc': 'Ajustar y cargar un modelo con la configuración óptima',
   'cli.cmdMcpDesc': 'Conectar motor local con agentes de IA como servidor MCP',
   'cli.cmdPresetsDesc': 'Ver presets de configuración guardados',
+  'cli.cmdServeDesc': 'Iniciar en modo servidor remoto con autenticación de API',
   'cli.cmdSettingsDesc': 'Configurar idioma y tema de la interfaz',
   'cli.cmdHelpDesc': 'Ver ayuda de uso y opciones',
   'cli.cmdExitDesc': 'Salir',

package/src/platform/server-autostart.js

@@ -0,0 +1,187 @@
+import { randomBytes } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { run as runCommand } from '../core/util.js';
+
+const ENTRY_NAME = 'dev.llm-tuner.server';
+
+function missing(error) {
+  return error?.code === 'ENOENT';
+}
+
+function validConfig(config) {
+  return config && typeof config === 'object' && !Array.isArray(config)
+    && typeof config.host === 'string' && config.host.length > 0
+    && Number.isInteger(config.port) && config.port > 0 && config.port <= 65535
+    && typeof config.token === 'string' && config.token.length > 0;
+}
+
+function desktopArgument(value) {
+  const execEscaped = String(value).replace(/([\\"$`])/g, '\\$1').replace(/%/g, '%%');
+  return `"${execEscaped.replace(/\\/g, '\\\\')}"`;
+}
+
+function assertNoControlCharacters(values) {
+  if (values.some((value) => /[\u0000-\u001f\u007f-\u009f]/u.test(String(value)))) {
+    throw new Error('Startup command paths cannot contain control characters.');
+  }
+}
+
+function xml(value) {
+  return String(value).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+function powershellLiteral(value) {
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+function windowsArgument(value) {
+  const text = String(value);
+  if (!/[\s"]/.test(text)) return text;
+  let quoted = '"';
+  let slashes = 0;
+  for (const character of text) {
+    if (character === '\\') {
+      slashes += 1;
+    } else if (character === '"') {
+      quoted += `${'\\'.repeat(slashes * 2 + 1)}"`;
+      slashes = 0;
+    } else {
+      quoted += `${'\\'.repeat(slashes)}${character}`;
+      slashes = 0;
+    }
+  }
+  return `${quoted}${'\\'.repeat(slashes * 2)}"`;
+}
+
+function plist(argumentsList) {
+  const values = argumentsList.map((value) => `    <string>${xml(value)}</string>`).join('\n');
+  return `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0">\n<dict>\n  <key>Label</key>\n  <string>${ENTRY_NAME}</string>\n  <key>ProgramArguments</key>\n  <array>\n${values}\n  </array>\n  <key>RunAtLoad</key>\n  <true/>\n</dict>\n</plist>\n`;
+}
+
+export function createServerAutostart({
+  platform = process.platform,
+  home = os.homedir(),
+  env = process.env,
+  execPath = process.execPath,
+  entryPath = fileURLToPath(new URL('../cli/server-login.js', import.meta.url)),
+  configPath,
+  fileSystem = fs,
+  run = runCommand,
+} = {}) {
+  let artifactPath;
+  if (platform === 'linux') {
+    artifactPath = path.join(env.XDG_CONFIG_HOME || path.join(home, '.config'), 'autostart', 'llm-tuner-server.desktop');
+  } else if (platform === 'darwin') {
+    artifactPath = path.join(home, 'Library', 'LaunchAgents', `${ENTRY_NAME}.plist`);
+  } else if (platform === 'win32') {
+    artifactPath = path.join(env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup', 'LLM Tuner Server.lnk');
+  } else {
+    throw new Error(`Automatic server startup is not supported on ${platform}.`);
+  }
+  const defaultConfigRoot = platform === 'win32'
+    ? (env.APPDATA || path.join(home, 'AppData', 'Roaming'))
+    : platform === 'darwin'
+      ? path.join(home, 'Library', 'Application Support')
+      : (env.XDG_CONFIG_HOME || path.join(home, '.config'));
+  const resolvedConfigPath = configPath || path.join(env.LLM_TUNER_CONFIG_DIR || path.join(defaultConfigRoot, 'llm-tuner'), 'server.json');
+
+  async function ensureConfig() {
+    let contents;
+    try {
+      contents = await fileSystem.readFile(resolvedConfigPath, 'utf8');
+    } catch (error) {
+      if (!missing(error)) throw error;
+      const initial = { host: '0.0.0.0', port: 7860, token: randomBytes(32).toString('hex') };
+      await fileSystem.mkdir(path.dirname(resolvedConfigPath), { recursive: true });
+      try {
+        await fileSystem.writeFile(resolvedConfigPath, JSON.stringify(initial, null, 2), { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+        return initial;
+      } catch (writeError) {
+        if (writeError?.code !== 'EEXIST') throw writeError;
+        contents = await fileSystem.readFile(resolvedConfigPath, 'utf8');
+      }
+    }
+    let config;
+    try {
+      config = JSON.parse(contents);
+    } catch {
+      throw new Error(`Server configuration at ${resolvedConfigPath} is malformed; automatic startup was not registered.`);
+    }
+    if (!validConfig(config)) {
+      throw new Error(`Server configuration at ${resolvedConfigPath} is invalid; automatic startup was not registered.`);
+    }
+    return config;
+  }
+
+  async function register() {
+    const configDirectory = path.dirname(resolvedConfigPath);
+    assertNoControlCharacters([execPath, entryPath, configDirectory, artifactPath]);
+    await ensureConfig();
+    if (platform === 'linux') {
+      const entry = `[Desktop Entry]\nType=Application\nName=LLM Tuner Server\nComment=Start the LLM Tuner server after login\nExec=${desktopArgument(execPath)} ${desktopArgument(entryPath)} --config-dir ${desktopArgument(configDirectory)}\nTerminal=false\n`;
+      await fileSystem.mkdir(path.dirname(artifactPath), { recursive: true });
+      await fileSystem.writeFile(artifactPath, entry, { encoding: 'utf8', mode: 0o600 });
+      if (!(await status())) throw new Error('The Linux startup entry was not created.');
+      return;
+    }
+    if (platform === 'darwin') {
+      await fileSystem.mkdir(path.dirname(artifactPath), { recursive: true });
+      await fileSystem.writeFile(artifactPath, plist([execPath, entryPath, '--config-dir', configDirectory]), { encoding: 'utf8', mode: 0o600 });
+      if (!(await status())) throw new Error('The macOS startup entry was not created.');
+      return;
+    }
+
+    await fileSystem.mkdir(path.dirname(artifactPath), { recursive: true });
+    const args = `--config-dir ${windowsArgument(configDirectory)}`;
+    const script = [
+      `$ErrorActionPreference = 'Stop'`,
+      `$expectedTarget = ${powershellLiteral(execPath)}`,
+      `$expectedArguments = ${powershellLiteral(`${windowsArgument(entryPath)} ${args}`)}`,
+      `$expectedWorkingDirectory = ${powershellLiteral(path.dirname(entryPath))}`,
+      `try {`,
+      `$shell = New-Object -ComObject WScript.Shell`,
+      `$shortcut = $shell.CreateShortcut(${powershellLiteral(artifactPath)})`,
+      `$shortcut.TargetPath = $expectedTarget`,
+      `$shortcut.Arguments = $expectedArguments`,
+      `$shortcut.WorkingDirectory = $expectedWorkingDirectory`,
+      `$shortcut.Save()`,
+      `$saved = $shell.CreateShortcut(${powershellLiteral(artifactPath)})`,
+      `if ($saved.TargetPath -ne $expectedTarget -or $saved.Arguments -ne $expectedArguments -or $saved.WorkingDirectory -ne $expectedWorkingDirectory) { throw 'The saved startup shortcut did not match the requested settings.' }`,
+      `} catch { [Console]::Error.WriteLine($_.Exception.Message); exit 1 }`,
+    ].join('\n');
+    const result = await run('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(script, 'utf16le').toString('base64')], { windowsHide: true });
+    if (result.code !== 0) throw new Error(`Could not create the Windows startup shortcut: ${result.stderr || `PowerShell exited with code ${result.code}`}`);
+    try {
+      await fileSystem.access(artifactPath);
+    } catch (error) {
+      if (missing(error)) throw new Error('PowerShell reported success but did not create the Windows startup shortcut.');
+      throw error;
+    }
+  }
+
+  async function status() {
+    try {
+      await fileSystem.access(artifactPath);
+      return true;
+    } catch (error) {
+      if (missing(error)) return false;
+      throw error;
+    }
+  }
+
+  return {
+    status,
+    async setEnabled(enabled) {
+      if (typeof enabled !== 'boolean') throw new TypeError('enabled must be a boolean.');
+      if (enabled) {
+        await register();
+      } else {
+        await fileSystem.rm(artifactPath, { force: true });
+      }
+      return status();
+    },
+  };
+}