@awak-app/simy-cli 0.5.14 → 0.5.16

package/src/windows-bootstrap.js

@@ -0,0 +1,28 @@
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { maintainWindowsUpdate, selectedWindowsRoot } from './windows-update.js';
+const installation = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const stateRoot = path.join(process.env.LOCALAPPDATA, 'SIMY CLI', 'updates');
+const argv = process.argv.slice(2);
+let root = await selectedWindowsRoot(installation, stateRoot);
+const updating = argv[0] === 'update';
+try {
+  if (updating || (!argv.includes('--no-auto-update') && process.env.SIMY_AUTO_UPDATE !== '0' && !argv.includes('--help') && !argv.includes('-h'))) {
+    root = await maintainWindowsUpdate({ installation, stateRoot, force: updating, rollback: updating && argv.includes('--rollback'), checkOnly: updating && argv.includes('--check'), allowMajor: updating && argv.includes('--yes'), report: version => { if (updating) console.log(`Latest Windows release: ${version}`); } });
+  }
+} catch (error) {
+  console.error(`SIMY Windows update: ${error.message}. Keeping the current installation.`);
+  if (updating) process.exitCode = 1;
+}
+if (updating) {
+  if (!process.exitCode) console.log(`SIMY Windows installation ready: ${root}`);
+} else {
+  const child = spawn(path.join(root, 'runtime/node.exe'), [path.join(root, 'cli/src/index.js'), ...argv], {
+    stdio: 'inherit', env: { ...process.env, SIMY_AUTO_UPDATE: '0' },
+  });
+  // Windows console signals are already delivered to both processes.
+  process.on('SIGINT', () => {});
+  child.on('error', error => { console.error(error.message); process.exitCode = 1; });
+  child.on('exit', code => { process.exitCode = code ?? 1; });
+}

package/src/windows-candidate-probe.js

@@ -0,0 +1,10 @@
+import { readFile } from 'node:fs/promises';
+const expected = JSON.parse(await readFile(new URL('../package.json', import.meta.url))).version;
+import { startAgent } from './agent.js';
+import { closeAgent } from './shutdown.js';
+const agent = await startAgent({ requestedPort: 0, quiet: true, sessionRoot: process.env.SIMY_HOME });
+try {
+  const response = await fetch(`http://127.0.0.1:${agent.port}/v1/health`);
+  const health = await response.json();
+  if (!response.ok || !health.ok || health.session_valid || health.cli_version !== expected) throw new Error('Candidate health failed');
+} finally { await closeAgent(agent); }

package/src/windows-update.js

@@ -0,0 +1,129 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, writeFile, rename, rm, stat } from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const exec = promisify(execFile);
+export const WINDOWS_MANIFEST_URL = "https://simy.one/downloads/simy-cli/windows/latest.json";
+const stable = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+const sha = /^[a-f0-9]{64}$/;
+export function compareWindowsVersions(a, b) {
+  if (!stable.test(a) || !stable.test(b)) throw new Error("Invalid release version");
+  const aa = a.split('.').map(Number), bb = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) if (aa[i] !== bb[i]) return aa[i] - bb[i];
+  return 0;
+}
+export function validateWindowsRelease(value) {
+  if (value?.schemaVersion !== 1 || !stable.test(value.version) || value.artifacts?.length !== 1) throw new Error("Invalid Windows manifest");
+  const artifact = value.artifacts[0];
+  if (artifact.platform !== "win32" || artifact.arch !== "x64" || typeof artifact.signed !== "boolean") throw new Error("Invalid platform");
+  for (const [item, suffix] of [[artifact, '-setup.exe'], [artifact.updater, '.zip']]) {
+    const url = new URL(item?.url);
+    if (url.origin !== 'https://simy.one' || url.username || url.password || url.search || url.hash ||
+      url.pathname !== `/downloads/simy-cli/windows/${value.version}/SIMY-CLI-${value.version}-windows-x64${suffix}` ||
+      !sha.test(item.sha256) || !Number.isSafeInteger(item.size) || item.size <= 0 || item.size > 256 * 1024 * 1024) throw new Error("Invalid Windows artifact");
+  }
+  return value;
+}
+async function json(file, fallback = null) { try { return JSON.parse(await readFile(file, 'utf8')); } catch { return fallback; } }
+async function atomicJson(file, data) {
+  const temporary = `${file}.${randomUUID()}.tmp`;
+  await writeFile(temporary, JSON.stringify(data));
+  await rename(temporary, file);
+}
+export async function selectedWindowsRoot(installation, stateRoot) {
+  const installed = await json(path.join(installation, 'cli/package.json'));
+  const state = await json(path.join(stateRoot, 'current.json'));
+  if (!state || !stable.test(state.version) || compareWindowsVersions(state.version, installed.version) < 0) return installation;
+  const candidate = path.join(stateRoot, 'releases', state.version);
+  if ((await json(path.join(candidate, 'cli/package.json')))?.version !== state.version) return installation;
+  try { await stat(path.join(candidate, 'runtime/node.exe')); } catch { return installation; }
+  return candidate;
+}
+export async function downloadWindowsArtifact(item, destination, fetchImpl = fetch) {
+  const response = await fetchImpl(item.url, { signal: AbortSignal.timeout(120_000), redirect: 'error' });
+  if (!response.ok || !response.body) throw new Error('Update download failed');
+  const chunks = []; let size = 0;
+  for await (const chunk of response.body) { size += chunk.length; if (size > item.size) throw new Error('Oversized update'); chunks.push(chunk); }
+  const bytes = Buffer.concat(chunks);
+  if (size !== item.size || createHash('sha256').update(bytes).digest('hex') !== item.sha256) throw new Error('Update checksum mismatch');
+  await writeFile(destination, bytes);
+}
+export async function applyWindowsUpdate({ installation, stateRoot, release, fetchImpl = fetch, verifyCandidate = verifyWindowsCandidate, extract = extractWindowsZip }) {
+  validateWindowsRelease(release);
+  const current = await selectedWindowsRoot(installation, stateRoot);
+  const currentVersion = (await json(path.join(current, 'cli/package.json'))).version;
+  if (compareWindowsVersions(release.version, currentVersion) <= 0) return current;
+  const marker = await json(path.join(installation, 'installation.json'));
+  if (marker?.signed && !release.artifacts[0].signed) throw new Error('Refusing unsigned update of signed installation');
+  const staging = path.join(stateRoot, `staging-${randomUUID()}`);
+  await mkdir(staging, { recursive: true });
+  try {
+    const archive = path.join(staging, 'update.zip');
+    await downloadWindowsArtifact(release.artifacts[0].updater, archive, fetchImpl);
+    const candidate = path.join(staging, 'payload');
+    await extract(archive, candidate, installation);
+    if ((await json(path.join(candidate, 'cli/package.json')))?.version !== release.version) throw new Error('Candidate version mismatch');
+    await verifyCandidate(candidate, marker);
+    const target = path.join(stateRoot, 'releases', release.version);
+    await mkdir(path.dirname(target), { recursive: true });
+    // Immutable directory: never replace a running or previously staged version.
+    try { await stat(target); throw new Error('Release directory already exists'); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+    await rename(candidate, target);
+    await atomicJson(path.join(stateRoot, 'current.json'), { version: release.version, previous: currentVersion });
+    return target;
+  } finally { await rm(staging, { recursive: true, force: true }); }
+}
+const powershell = () => path.join(process.env.SystemRoot || 'C:\\Windows', 'System32/WindowsPowerShell/v1.0/powershell.exe');
+async function extractWindowsZip(archive, destination, installation) {
+  await exec(powershell(), ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', path.join(installation, 'extract-update.ps1'), '-Archive', archive, '-Destination', destination], { timeout: 120_000, windowsHide: true });
+}
+async function verifyWindowsCandidate(candidate, marker) {
+  if (marker?.signed) {
+    if (!/^[A-Fa-f0-9]{40}$/.test(marker.thumbprint || '')) throw new Error('Missing trusted signer');
+    // Paths are passed through environment values, never inserted into shell source.
+    await exec(powershell(), ['-NoProfile', '-NonInteractive', '-Command', "$ErrorActionPreference='Stop';foreach($file in @('simy.exe','runtime/node.exe')){$s=Get-AuthenticodeSignature (Join-Path $env:SIMY_CANDIDATE $file);if($s.Status -ne 'Valid'){throw 'Invalid signature'};if($file -eq 'simy.exe' -and $s.SignerCertificate.Thumbprint -ne $env:SIMY_SIGNER){throw 'Unexpected signer'}}"], { env: { ...process.env, SIMY_CANDIDATE: candidate, SIMY_SIGNER: marker.thumbprint }, timeout: 30_000, windowsHide: true });
+  }
+  const probeHome = path.join(candidate, '.update-probe');
+  try {
+    await exec(path.join(candidate, 'runtime/node.exe'), [path.join(candidate, 'cli/src/windows-candidate-probe.js')], { env: { ...process.env, SIMY_HOME: probeHome, SIMY_AUTO_UPDATE: '0' }, timeout: 30_000, windowsHide: true });
+  } finally { await rm(probeHome, { recursive: true, force: true }); }
+}
+export async function maintainWindowsUpdate({ installation, stateRoot, force = false, rollback = false, checkOnly = false, allowMajor = false, report = () => {}, fetchImpl = fetch } = {}) {
+  await mkdir(stateRoot, { recursive: true });
+  const lock = path.join(stateRoot, 'update.lock');
+  // The OS releases this per-process lock file on exit only through finally; stale
+  // locks defer updates safely, and can be removed when no SIMY process is running.
+  try { await mkdir(lock); } catch (error) {
+    if (error.code !== 'EEXIST') throw error;
+    return selectedWindowsRoot(installation, stateRoot);
+  }
+  try {
+    if (rollback) {
+      const state = await json(path.join(stateRoot, 'current.json'));
+      if (!state?.previous || !stable.test(state.previous)) throw new Error('No previous version to restore');
+      const installed = (await json(path.join(installation, 'cli/package.json'))).version;
+      if (state.previous !== installed && (await json(path.join(stateRoot, 'releases', state.previous, 'cli/package.json')))?.version !== state.previous) throw new Error('Previous version missing');
+      await atomicJson(path.join(stateRoot, 'current.json'), { version: state.previous, blocked: state.version });
+      return selectedWindowsRoot(installation, stateRoot);
+    }
+    const check = await json(path.join(stateRoot, 'checked.json'));
+    if (!force && Date.now() - Number(check?.at) < 60 * 60_000) return selectedWindowsRoot(installation, stateRoot);
+    const response = await fetchImpl(WINDOWS_MANIFEST_URL, { signal: AbortSignal.timeout(5_000), redirect: 'error' });
+    if (!response.ok) throw new Error('Windows release discovery unavailable');
+    const text = await response.text();
+    if (text.length > 128 * 1024) throw new Error('Oversized manifest');
+    const release = validateWindowsRelease(JSON.parse(text));
+    report(release.version);
+    const selected = await selectedWindowsRoot(installation, stateRoot);
+    if (checkOnly) return selected;
+    const currentVersion = (await json(path.join(selected, 'cli/package.json'))).version;
+    if (!allowMajor && Number(release.version.split('.')[0]) > Number(currentVersion.split('.')[0])) throw new Error('Major update requires simy update --yes');
+    const state = await json(path.join(stateRoot, 'current.json'));
+    if (state?.blocked === release.version) return selectedWindowsRoot(installation, stateRoot);
+    const root = await applyWindowsUpdate({ installation, stateRoot, release, fetchImpl });
+    await atomicJson(path.join(stateRoot, 'checked.json'), { at: Date.now() });
+    return root;
+  } finally { await rm(lock, { recursive: true, force: true }); }
+}