workbite 0.1.8 → 0.1.10

package/README.md

@@ -3,22 +3,20 @@
 WorkBite installs and opens **Work Stack** (organizes the work) and
 **StackBite** (gets it moving) as one native suite.
 
-Launcher 0.1.8 (native bundle 0.1.8) is a **Windows x64 only** release. It
-opens the familiar TypeScript Work Stack UI by default, which has
-`9 Execution` in the same window: select a Task, start its agent, and see and
-control its native terminal without leaving the UI. New in 0.1.8: a one-screen
-launch panel (provider/model/effort, work folder with recent folders and an
-optional workspace default), `9` / `a` to show every Run again, `Ctrl+B` to
-hide the side menu in Execution, and typed, retained StackBite launch-refusal
-diagnostics. The unified Rust UI stays
+Launcher 0.1.10 (native bundle 0.1.10) supports **Windows x64 and Linux x64**
+(glibc 2.28+). It opens the familiar TypeScript Work Stack UI by default, which
+has `9 Execution` in the same window: select a Task, start its agent, and see
+and control its native terminal without leaving the UI. New in 0.1.10: Cursor
+CLI as a raw native provider in opted-in Rooms (you approve its trust; its
+lifecycle/resume is not verified yet). The unified Rust UI stays
 an explicit alternative per open: `workbite open --frontend rust` (or bare
 `workbite --frontend rust`). Either frontend reuses the same owner and
 StackBite backend; the choice is not saved. Leaving the view or closing the UI
 keeps the agent running, and Task completion stays an explicit action.
 
-Linux x64: keep using `workbite@0.1.6` (native bundle 0.1.6, glibc 2.28+)
-until separate Linux compatibility work for this feature is done; 0.1.8 does
-not install on Linux. Updating from the 0.1.4 native bundle requires an
+Linux x64 support is verified for the glibc 2.28 ELF build and the POSIX PTY
+in an AlmaLinux 8 userspace; real AI agent turns on Linux, a booted AlmaLinux 8
+kernel and SSH/VM use are not yet proven. Updating from the 0.1.4 native bundle requires an
 operator handover of existing backend processes; the launcher does not stop
 them or clear startup records automatically.
 
@@ -30,7 +28,7 @@ workbite                                                   # afterwards (TypeScr
 workbite --frontend rust                                   # unified Rust UI with 9 Execution
 ```
 
-Node.js 20+ on Windows x64 (Linux x64: `npm install -g workbite@0.1.6`).
+Node.js 20+ on Windows x64 or Linux x64 (glibc 2.28+).
 
 - `workbite install` downloads the pinned bundle for your platform from
   `github.com/Shinick-Han/WorkBite-releases`, verifies its size and SHA-256 and

package/lib/boot-provenance.js

@@ -0,0 +1,54 @@
+'use strict';
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { execFile } = require('node:child_process');
+// WMI LastBootUpTime is the OS boot time, not wall-clock minus uptime:
+// https://learn.microsoft.com/en-us/windows/win32/cimwin32prov/win32-operatingsystem
+// Use the framework WMI API directly, with no profile, PATH or module lookup.
+const SCRIPT = String.raw`$ErrorActionPreference='Stop'
+Add-Type -AssemblyName System.Management
+$q = [System.Management.ManagementObjectSearcher]::new('SELECT LastBootUpTime FROM Win32_OperatingSystem')
+try {
+  $rows = @($q.Get())
+  if ($rows.Count -ne 1) { throw 'ambiguous operating system' }
+  $r = $rows[0]
+  $t = [System.Management.ManagementDateTimeConverter]::ToDateTime([string]$r.LastBootUpTime).ToUniversalTime().Ticks
+  $key = [Microsoft.Win32.Registry]::LocalMachine.OpenSubKey('SOFTWARE\Microsoft\Cryptography')
+  try { $hostId = [string]$key.GetValue('MachineGuid') } finally { $key.Dispose() }
+  [Console]::Out.Write($hostId.ToLowerInvariant() + ':' + $t.ToString([Globalization.CultureInfo]::InvariantCulture))
+} finally { $q.Dispose() }`;
+function validBoot(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 3
+    && value.host !== '0'.repeat(32) && value.id !== '00000000-0000-0000-0000-000000000000'
+    && typeof value.host === 'string' && /^[0-9a-f]{32}$/.test(value.host)
+    && typeof value.id === 'string'
+    && ((value.source === 'linux-boot-id' && /^[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(value.id))
+      || (value.source === 'windows-wmi-boot-time' && /^[1-9][0-9]{17}$/.test(value.id)));
+}
+async function bootIdentity({ platform = process.platform, environment = process.env, execImpl = execFile,
+  readImpl = fs.readFile } = {}) {
+  let result;
+  try {
+    if (platform === 'linux') result = { source: 'linux-boot-id',
+      host: (await readImpl('/etc/machine-id', 'utf8')).trim(),
+      id: (await readImpl('/proc/sys/kernel/random/boot_id', 'utf8')).trim() };
+    else if (platform === 'win32') {
+      const root = environment.SystemRoot || environment.SYSTEMROOT || 'C:\\Windows';
+      if (!/^[A-Za-z]:\\[^\x00-\x1f"*?<>|]*$/.test(root)) return null;
+      const id = await new Promise(resolve => execImpl(path.win32.join(root, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe'),
+        ['-NoLogo', '-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(SCRIPT, 'utf16le').toString('base64')],
+        { env: { SystemRoot: root }, shell: false, windowsHide: true, timeout: 5000, maxBuffer: 4096, encoding: 'utf8' },
+        (error, stdout) => resolve(error ? '' : String(stdout).trim())));
+      const [host, ticks, extra] = id.split(':');
+      if (extra !== undefined || !/^[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(host || '')) return null;
+      result = { source: 'windows-wmi-boot-time', host: host.replace(/-/g, ''), id: ticks };
+    }
+  } catch { return null; }
+  return validBoot(result) ? result : null;
+}
+function previousBoot(saved, current) {
+  if (!validBoot(saved) || !validBoot(current) || saved.source !== current.source || saved.host !== current.host) return false;
+  if (saved.source === 'linux-boot-id') return saved.id !== current.id;
+  return BigInt(saved.id) < BigInt(current.id);
+}
+module.exports = { bootIdentity, validBoot, previousBoot };

package/lib/runtime.js

@@ -12,6 +12,7 @@ const path = require('node:path');
 const { spawn, execFile } = require('node:child_process');
 const { randomBytes, randomUUID } = require('node:crypto');
 const { fail, exists, safeDirectory, writeAtomic, readJson, readSmall, sha256, UUID, BACKEND_ID } = require('./common');
+const { bootIdentity, validBoot, previousBoot } = require('./boot-provenance');
 const { BUNDLE_V2 } = require('./install');
 const { protectPrivateDirectories } = require('./private-state');
 
@@ -284,14 +285,17 @@ async function readyRecord(log) {
 // Startup intent (private token, launch id, port) is saved before any child is
 // spawned, so an attempt that timed out or crashed is never followed by a second
 // manager on the same state: a later open either authenticates that same attempt
-// or refuses. Records are never cleared and nothing is stopped automatically.
+// or refuses. Proven previous-boot records are archived; nothing is stopped automatically.
 const RECOVERY = 'WorkBite never starts a second one on the same state. If it is still starting, open again shortly; '
   + 'if you have confirmed no process from this state is running, move that record aside and open again.';
 const LAUNCH = /^[0-9a-f]{16}$/;
 // Distinct from every JSON value (including null): only an absent file is "missing".
 const MISSING = Symbol('missing record');
 async function savedRecord(file, what) {
-  try { return await readJson(file); } catch (error) {
+  try {
+    const bytes = await readSmall(file, 65536);
+    return { record: JSON.parse(bytes.toString('utf8')), bytes };
+  } catch (error) {
     if (error.code === 'ENOENT') return MISSING;
     fail(`The ${what} record ${file} is unreadable; WorkBite does not replace it. ${RECOVERY}`);
   }
@@ -300,6 +304,31 @@ const isRecord = value => value !== null && typeof value === 'object' && !Array.
   && (value.state === 'starting' || value.state === 'ready') && typeof value.launch === 'string' && LAUNCH.test(value.launch);
 const recordBytes = value => Buffer.from(JSON.stringify(value, null, 2) + '\n');
 
+// Called under open.lock. Compare the exact bytes, retain a private backup before
+// renaming the record, and refuse if it changed. Logs and native intent stay put.
+async function archivePreviousRecord(file, saved, original, boot) {
+  if (!previousBoot(saved.boot, boot)) return false;
+  const current = await readSmall(file, 65536);
+  if (!current.equals(original)) fail('Startup record changed during recovery; refusing another launch.');
+  const backup = `${file}.previous-boot-${randomBytes(12).toString('hex')}`;
+  await fs.copyFile(file, backup, fsSync.constants.COPYFILE_EXCL);
+  if (!(await readSmall(backup, 65536)).equals(original)
+      || !(await readSmall(file, 65536)).equals(original)) {
+    fail('Startup record changed during recovery; backup retained, launch refused.');
+  }
+  // The rename retains the original record's ACL. A separate backup survives a
+  // crash before the new current-boot intent is persisted.
+  await fs.rename(file, `${backup}.record`);
+  if (!(await readSmall(`${backup}.record`, 65536)).equals(original)) {
+    fail('Startup record changed during quarantine; archived evidence retained, launch refused.');
+  }
+  return true;
+}
+function checkBoot(saved, recordPath) {
+  if (Object.hasOwn(saved, 'boot') && !validBoot(saved.boot)) {
+    fail(`The startup boot provenance in ${recordPath} is invalid; WorkBite does not replace it.`);
+  }
+}
 // A v2 (execution UI) bundle reuses only processes its own startup intent marked: the owner needs
 // this bundle's execution commands, the StackBite backend its native launch opt-in (read once at
 // startup). A matching token or UID alone is not that proof. Checked from the record before any
@@ -322,30 +351,38 @@ function requireExecutionMarker(saved, execution, recordPath, what, extra = {})
 const executionFields = (execution, extra = {}) => (execution ? { execution_bundle_version: execution.bundleVersion, ...extra } : {});
 const NATIVE_LAUNCH = { native_launch: true };
 
-async function ensureEngine({ commands, workspace, uid, layout, environment, spawnImpl, timeout = 60000, execution = null }) {
+async function ensureEngine({ commands, workspace, uid, layout, environment, spawnImpl, timeout = 60000, execution = null, boot = null, identityImpl = engineIdentity }) {
   const key = workspaceKey(workspace);
   const recordPath = path.join(layout.owners, `${key}.json`);
   const logFor = launch => path.join(layout.logs, `workstack-engine-${key}-${launch}.log`);
-  const saved = await savedRecord(recordPath, 'Work Stack owner');
+  const snapshot = await savedRecord(recordPath, 'Work Stack owner');
+  const saved = snapshot === MISSING ? MISSING : snapshot.record;
+  const original = snapshot === MISSING ? null : snapshot.bytes;
   if (saved !== MISSING) {
     if (!isRecord(saved) || saved.schema !== OWNER_SCHEMA || typeof saved.workspace !== 'string'
         || workspaceKey(saved.workspace) !== key || saved.workspace_uid !== uid
-        || typeof saved.token !== 'string' || !/^[0-9a-f]{64}$/.test(saved.token)) {
+        || typeof saved.token !== 'string' || !/^[0-9a-f]{64}$/.test(saved.token)
+        || (saved.state === 'ready' && (typeof saved.endpoint !== 'string' || !LOOPBACK.test(saved.endpoint)))) {
       fail(`The Work Stack owner record ${recordPath} is invalid for this workspace; WorkBite does not replace it. ${RECOVERY}`);
     }
+    checkBoot(saved, recordPath);
     requireExecutionMarker(saved, execution, recordPath, 'Work Stack owner');
     let endpoint = saved.state === 'ready' ? saved.endpoint : null;
     if (saved.state === 'starting') {
       const ready = await readyRecord(logFor(saved.launch));
       if (ready?.workspace_uid === uid && ready.protocol_version === 1) endpoint = ready.endpoint;
     }
-    if (!await engineIdentity(endpoint, saved.token, uid)) {
-      fail(`The Work Stack owner recorded in ${recordPath} could not be authenticated (still starting, or stopped). ${RECOVERY}`);
+    if (!await identityImpl(endpoint, saved.token, uid)) {
+      if (!await archivePreviousRecord(recordPath, saved, original, boot))
+        fail(`The Work Stack owner recorded in ${recordPath} could not be authenticated (still starting, or stopped). ${RECOVERY}`);
+    } else {
+      if (saved.state === 'starting' || validBoot(boot))
+        await writeAtomic(recordPath, recordBytes({ ...saved, ...(validBoot(boot) ? { boot } : {}), state: 'ready', endpoint }));
+      return { endpoint, reused: true, pid: saved.pid };
     }
-    if (saved.state === 'starting') await writeAtomic(recordPath, recordBytes({ ...saved, state: 'ready', endpoint }));
-    return { endpoint, reused: true, pid: saved.pid };
   }
-  const intent = { schema: OWNER_SCHEMA, state: 'starting', workspace, workspace_uid: uid,
+  if (!validBoot(boot)) fail('Trusted OS boot provenance is unavailable; no owner was started.');
+  const intent = { boot, schema: OWNER_SCHEMA, state: 'starting', workspace, workspace_uid: uid,
     launch: randomBytes(8).toString('hex'), token: randomBytes(32).toString('hex'), ...executionFields(execution) };
   const log = logFor(intent.launch);
   await writeAtomic(recordPath, recordBytes(intent));
@@ -355,30 +392,37 @@ async function ensureEngine({ commands, workspace, uid, layout, environment, spa
   await writeAtomic(recordPath, recordBytes({ ...intent, pid: child.pid }));
   const ready = await waitFor(() => readyRecord(log), exited, timeout, 'Work Stack native owner', log);
   if (ready.workspace_uid !== uid || ready.protocol_version !== 1 || !LOOPBACK.test(ready.endpoint)
-      || !await engineIdentity(ready.endpoint, intent.token, uid)) fail(`Work Stack native owner identity was not proven; see ${log}`);
+      || !await identityImpl(ready.endpoint, intent.token, uid)) fail(`Work Stack native owner identity was not proven; see ${log}`);
   await writeAtomic(recordPath, recordBytes({ ...intent, pid: child.pid, state: 'ready', endpoint: ready.endpoint }));
   return { endpoint: ready.endpoint, reused: false, pid: child.pid };
 }
 
-async function ensureStackbite({ commands, layout, backendId, environment, spawnImpl, timeout = 120000, execution = null }) {
+async function ensureStackbite({ commands, layout, backendId, environment, spawnImpl, timeout = 120000, execution = null, boot = null, identityImpl = stackbiteIdentity }) {
   const recordPath = layout.stackbiteRecord;
   const logFor = launch => path.join(layout.logs, `stackbite-backend-${launch}.log`);
-  const saved = await savedRecord(recordPath, 'StackBite backend');
+  const snapshot = await savedRecord(recordPath, 'StackBite backend');
+  const saved = snapshot === MISSING ? MISSING : snapshot.record;
+  const original = snapshot === MISSING ? null : snapshot.bytes;
   if (saved !== MISSING) {
     if (!isRecord(saved) || saved.schema !== STACKBITE_SCHEMA || saved.backend_id !== backendId
         || typeof saved.url !== 'string' || LOOPBACK.exec(saved.url)?.[1] !== String(saved.port)) {
       fail(`The StackBite backend record ${recordPath} is invalid for this state; WorkBite does not replace it. ${RECOVERY}`);
     }
+    checkBoot(saved, recordPath);
     requireExecutionMarker(saved, execution, recordPath, 'StackBite backend', NATIVE_LAUNCH);
-    if (!await stackbiteIdentity(saved.url, layout.stackbite, backendId)) {
-      fail(`The StackBite backend recorded in ${recordPath} could not be authenticated (still starting, or stopped). ${RECOVERY}`);
+    if (!await identityImpl(saved.url, layout.stackbite, backendId)) {
+      if (!await archivePreviousRecord(recordPath, saved, original, boot))
+        fail(`The StackBite backend recorded in ${recordPath} could not be authenticated (still starting, or stopped). ${RECOVERY}`);
+    } else {
+      if (saved.state === 'starting' || validBoot(boot))
+        await writeAtomic(recordPath, recordBytes({ ...saved, ...(validBoot(boot) ? { boot } : {}), state: 'ready' }));
+      return { url: saved.url, reused: true, pid: saved.pid };
     }
-    if (saved.state === 'starting') await writeAtomic(recordPath, recordBytes({ ...saved, state: 'ready' }));
-    return { url: saved.url, reused: true, pid: saved.pid };
   }
+  if (!validBoot(boot)) fail('Trusted OS boot provenance is unavailable; no backend was started.');
   const port = await freePort();
   const url = `http://127.0.0.1:${port}`;
-  const intent = { schema: STACKBITE_SCHEMA, state: 'starting', backend_id: backendId, launch: randomBytes(8).toString('hex'), url, port,
+  const intent = { boot, schema: STACKBITE_SCHEMA, state: 'starting', backend_id: backendId, launch: randomBytes(8).toString('hex'), url, port,
     ...executionFields(execution, NATIVE_LAUNCH) };
   const log = logFor(intent.launch);
   const home = path.dirname(commands.stackbite[commands.stackbite.length - 1]);
@@ -395,7 +439,7 @@ async function ensureStackbite({ commands, layout, backendId, environment, spawn
       ...(execution ? { STACKBITE_WORKBITE_NATIVE_LAUNCH: '1' } : {}) }, home),
     cwd: home, log, spawnImpl });
   await writeAtomic(recordPath, recordBytes({ ...intent, pid: child.pid }));
-  await waitFor(() => stackbiteIdentity(url, layout.stackbite, backendId), exited, timeout, 'StackBite backend', log);
+  await waitFor(() => identityImpl(url, layout.stackbite, backendId), exited, timeout, 'StackBite backend', log);
   await writeAtomic(recordPath, recordBytes({ ...intent, pid: child.pid, state: 'ready' }));
   return { url, reused: false, pid: child.pid };
 }
@@ -555,7 +599,7 @@ function runForeground(command, args, environment, { spawnImpl = spawn, signalSo
 // commands maps each bundle executable to its argv prefix; tests substitute fixtures.
 async function openSuite({ installed, commands, workspace, init = false, stateRoot, environment = process.env,
   ui = true, frontend = 'typescript', spawnImpl = spawn, execImpl = execFile, platform = process.platform,
-  stdout = process.stdout, timeouts = {} }) {
+  stdout = process.stdout, timeouts = {}, bootImpl = bootIdentity }) {
   if (!FRONTENDS.includes(frontend)) fail(`--frontend must be one of: ${FRONTENDS.join(', ')}`);
   if (workspace !== undefined) workspace = checkedWorkspace(workspace);
   else if (init) fail('--init needs --workspace ABS naming the new or empty folder');
@@ -596,10 +640,11 @@ async function openSuite({ installed, commands, workspace, init = false, stateRo
     const uid = init ? await initializeWorkspace(commands, workspace, engineEnvironment) : await readWorkspaceUid(workspace);
     if (remembered && uid !== remembered.uid) fail(`The workspace ${workspace} changed while opening. ${EXPLICIT}`);
     const backendId = await ensureBackendId(layout);
+    const boot = await bootImpl({ platform, environment: base });
     const engine = await ensureEngine({ commands, workspace, uid, layout, environment: engineEnvironment, spawnImpl,
-      timeout: timeouts.engine, execution });
+      timeout: timeouts.engine, execution, boot });
     const stackbite = await ensureStackbite({ commands, layout, backendId, environment: base, spawnImpl,
-      timeout: timeouts.stackbite, execution });
+      timeout: timeouts.stackbite, execution, boot });
     if (execution) {
       await initializeNativeRuntime({ commands, layout, url: stackbite.url, environment: base, execImpl,
         timeout: timeouts.nativeInit });

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "workbite",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "WorkBite (Work Stack + StackBite) verified native suite installer and launcher",
   "license": "UNLICENSED",
   "engines": {
     "node": ">=20"
   },
   "os": [
-    "win32"
+    "win32",
+    "linux"
   ],
   "cpu": [
     "x64"

package/release.json

@@ -1,17 +1,24 @@
 {
   "schema": "workbite.release.v1",
   "product": "WorkBite",
-  "version": "0.1.8",
-  "launcherVersion": "0.1.8",
+  "version": "0.1.10",
+  "launcherVersion": "0.1.10",
   "repository": "Shinick-Han/WorkBite-releases",
-  "tag": "v0.1.8",
+  "tag": "v0.1.10",
   "platforms": {
     "windows-x64": {
-      "asset": "workbite-0.1.8-windows-x64.zip",
-      "sha256": "236a80d01b4630f8c70924bb8e56c743b7564fc59c025c5ba88a19635d38a517",
-      "size": 97538305,
-      "bundleSha256": "9971dc8ff0619f3f5a9cf6e4b3bec60d88da7127d8306f37fa80e5f415d72c61",
-      "url": "https://github.com/Shinick-Han/WorkBite-releases/releases/download/v0.1.8/workbite-0.1.8-windows-x64.zip"
+      "asset": "workbite-0.1.10-windows-x64.zip",
+      "sha256": "c3d86b7bae3226e5f9c63d70680998ec297253baa94aa1c1f39f887a12eafc9e",
+      "size": 97557746,
+      "bundleSha256": "1e89d35d4ec3efb816ee9a536fce1de6786c800804c8e03c2b5df3acfdf9399f",
+      "url": "https://github.com/Shinick-Han/WorkBite-releases/releases/download/v0.1.10/workbite-0.1.10-windows-x64.zip"
+    },
+    "linux-x64": {
+      "asset": "workbite-0.1.10-linux-x64.tar.gz",
+      "sha256": "9297ada2dbc30cc3fc7a14d74d85af0e1b4e49c8e7d6fb7d0bed230a51ca3e63",
+      "size": 81924111,
+      "bundleSha256": "a02994da01602e36e866411bc81d49632c9285c952c90b5cc50b252880c6123a",
+      "url": "https://github.com/Shinick-Han/WorkBite-releases/releases/download/v0.1.10/workbite-0.1.10-linux-x64.tar.gz"
     }
   }
 }