import fs from 'node:fs' import os from 'node:os' import path from 'node:path' import { spawnSync } from 'node:child_process' import { newerVersion, parseClientRelease, releaseUrl, renderClientInstaller, type ClientRelease, type DownloadableRelease } from './client-release.ts' export const CLIENT_ROOT = path.resolve(import.meta.dirname, '..') export interface ClientInstall extends ClientRelease { service: string; binDir: string } export function installedClient(root = CLIENT_ROOT): ClientInstall | undefined { try { if (fs.existsSync(path.join(root, '.git'))) return undefined const raw = JSON.parse(fs.readFileSync(path.join(root, 'client-install.json'), 'utf8').replace(/^\uFEFF/, '')) const release = parseClientRelease(raw) if (typeof raw.binDir !== 'string' || !path.isAbsolute(raw.binDir) || /[\x00-\x1f]/.test(raw.binDir)) return undefined return { ...release, service: releaseUrl(raw.service), binDir: raw.binDir } } catch { return undefined } } export async function latestClient(service: string, timeout = 5000): Promise { const response = await fetch(`${releaseUrl(service)}/client-release.json`, { signal: AbortSignal.timeout(timeout), redirect: 'error' }) if (!response.ok) throw new Error(`could not check client releases (HTTP ${response.status})`) const text = await response.text() if (text.length > 16384) throw new Error('client release response is too large') const raw = JSON.parse(text) return { ...parseClientRelease(raw), tarball: releaseUrl(raw.tarball) } } export function clientVersion(root = CLIENT_ROOT): string { const installed = installedClient(root) return installed ? `${installed.version} (${installed.revision.slice(0, 12)})` : 'development / unmanaged installation' } /** Best-effort, bounded, at most once daily. Never downloads or executes an update. */ export async function clientUpdateNotice(cacheDir: string, root = CLIENT_ROOT): Promise { if (process.env.LANGUID_NO_UPDATE_CHECK === '1') return undefined const installed = installedClient(root) if (!installed) return undefined const cacheFile = path.join(cacheDir, 'client-update.json') let release: ClientRelease | undefined try { let cached: any try { cached = JSON.parse(fs.readFileSync(cacheFile, 'utf8')) } catch {} const age = Date.now() - cached?.checkedAt if (cached?.service === installed.service && age >= 0 && age < 86400_000) { if (cached.release) release = parseClientRelease(cached.release) } else { try { release = await latestClient(installed.service, 800) } catch {} fs.mkdirSync(cacheDir, { recursive: true, mode: 0o700 }) const temporary = `${cacheFile}.${process.pid}.tmp` fs.writeFileSync(temporary, JSON.stringify({ service: installed.service, checkedAt: Date.now(), release }), { mode: 0o600 }) fs.renameSync(temporary, cacheFile) } } catch { return undefined } if (release && newerVersion(release.version, installed.version)) return `Languid ${release.version} is available (installed: ${installed.version}). Run languid update when ready.` return undefined } export async function clientUpdateCommand(args: string[], root = CLIENT_ROOT): Promise { if (args.includes('--help') || args.includes('-h')) { console.log('languid update [--check]\n Check for a stable client release, or install it explicitly. Restarts managed runners; reopen terminal chats afterward.\n Developer checkouts are never overwritten.'); return 0 } if (args.some(a => a !== '--check') || args.length > 1) { console.error('usage: languid update [--check]'); return 1 } const installed = installedClient(root) if (!installed && !args.includes('--check')) { console.error('This is a development or legacy/unmanaged installation; it will not be overwritten.\nUpdate its checkout yourself, or rerun your service’s installer once to adopt versioned updates.'); return 1 } try { const service = installed?.service ?? process.env.LANGUID_SERVER ?? 'https://languid.ai' const release = await latestClient(service) console.log(`Installed: ${installed?.version ?? 'development / unmanaged'}; latest stable: ${release.version}`) if (args.includes('--check')) return 0 if (!newerVersion(release.version, installed!.version)) { if (release.version === installed!.version && (release.revision !== installed!.revision || release.sha256 !== installed!.sha256)) throw new Error('the service changed an existing release version; refusing to overwrite it') console.log('No newer client release.'); return 0 } const kind = process.platform === 'win32' ? 'ps1' : 'sh' const template = fs.readFileSync(path.join(root, 'scripts', `install.${kind}`), 'utf8') const script = renderClientInstaller(template, installed!.service, release) const temporary = fs.mkdtempSync(path.join(os.tmpdir(), 'languid-update-')) try { const file = path.join(temporary, `install.${kind}`) fs.writeFileSync(file, script, { mode: 0o600 }) console.log(`Installing ${release.version}; managed runners may restart. Existing terminal chats keep their old code until reopened.`) const env = { ...process.env, LANGUID_NO_LOGIN: '1', LANGUID_SERVER: installed!.service, LANGUID_APP_DIR: root, LANGUID_BIN_DIR: installed!.binDir, LANGUID_TARBALL: release.tarball, LANGUID_RELEASE_VERSION: release.version, LANGUID_RELEASE_REVISION: release.revision, LANGUID_RELEASE_SHA256: release.sha256 } const child = process.platform === 'win32' ? spawnSync('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', file], { stdio: 'inherit', env }) : spawnSync('/bin/sh', [file], { stdio: 'inherit', env }) if (child.error) throw child.error if (child.status !== 0) throw new Error(`installer failed (${child.signal ?? child.status}); see its output above`) console.log(`Updated to ${release.version}. Reopen terminal chats to use it.`) return 0 } finally { fs.rmSync(temporary, { recursive: true, force: true }) } } catch (e: any) { console.error(`languid update: ${e.message}`); return 1 } }