workbite 0.1.0 → 0.1.1

package/README.md

@@ -6,8 +6,8 @@ WorkBite installs and opens **Work Stack** (organizes the work) and
 ```sh
 npm install -g workbite
 workbite install
-workbite open --workspace /abs/path/new-folder --init
-workbite open --workspace /abs/path/existing-workspace
+workbite open --workspace /abs/path/new-folder --init      # first time, once
+workbite                                                   # afterwards
 ```
 
 Node.js 20+ on Windows x64 or Linux x64 (glibc 2.28+).
@@ -21,6 +21,11 @@ Node.js 20+ on Windows x64 or Linux x64 (glibc 2.28+).
   workspace's Work Stack owner and a StackBite backend (only processes it can
   prove it started), then runs the Work Stack terminal UI. Backends keep
   running after the UI exits.
+- `workbite` (or `workbite open` without `--workspace`) reopens the last
+  workspace that opened successfully; an explicit `--workspace` always wins.
+  It refuses, starting nothing, if that workspace is missing, moved or its
+  `workspace.json` id changed, and never picks another folder by itself.
+  `--init` always needs an explicit `--workspace`.
 - Each backend's startup record (private token, launch id, port) is saved in
   the state folder *before* the process is started. A later `open` reuses
   that same attempt once it authenticates (also after a slow start), and

package/lib/cli.js

@@ -12,13 +12,20 @@ Usage:
   workbite open --workspace ABS [--init] [--no-ui]
                                          start or reuse this workspace's Work Stack owner and the
                                          StackBite backend, then run the Work Stack terminal UI
+  workbite [open] [--no-ui]              reopen the last workspace WorkBite opened successfully
   workbite --version | --help
 
 open:
-  --workspace ABS  absolute workspace folder
-  --init           create a new Work Stack workspace in a new or empty folder
+  --workspace ABS  absolute workspace folder; always wins over the remembered one
+  --init           create a new Work Stack workspace in a new or empty folder (needs --workspace)
   --no-ui          start or reuse the backends, print one JSON summary and exit
 
+First time, name the workspace once:
+  workbite open --workspace /abs/path/new-folder --init
+  workbite open --workspace /abs/path/existing-workspace
+Afterwards just run:
+  workbite
+
 The Work Stack owner and StackBite backend keep running after the UI exits, so
 agents continue. WorkBite never auto-updates, installs dependencies, approves
 provider trust or stops processes it cannot prove are its own.
@@ -30,9 +37,9 @@ Locations (override with absolute WORKBITE_HOME / WORKBITE_STATE_DIR):
 
 function parseArguments(argv) {
   if (argv.length === 1 && ['--help', '-h', 'help'].includes(argv[0])) return { command: 'help' };
-  if (!argv.length) return { command: 'help' };
   if (argv.length === 1 && ['--version', '-v', 'version'].includes(argv[0])) return { command: 'version' };
-  const [command, ...rest] = argv;
+  // Bare `workbite` (or only open options) means `workbite open`.
+  const [command, ...rest] = argv.length && !argv[0].startsWith('--') ? argv : ['open', ...argv];
   if ((command === 'install' || command === 'check') && !rest.length) return { command };
   if (command === 'open') {
     const options = { command, init: false, ui: true };
@@ -44,7 +51,11 @@ function parseArguments(argv) {
           && !rest[index + 1].startsWith('--')) options.workspace = rest[++index];
       else fail(`Unknown or repeated open option: ${String(argument).slice(0, 64)}. See workbite --help.`);
     }
-    if (options.workspace === undefined) fail('workbite open needs --workspace ABS');
+    // Without --workspace the remembered workspace is reopened; --init never picks a folder by itself.
+    if (options.workspace === undefined) {
+      if (options.init) fail('--init needs --workspace ABS naming the new or empty folder');
+      return options;
+    }
     if (!path.isAbsolute(options.workspace)) fail('--workspace must be an absolute path');
     return options;
   }

package/lib/install.js

@@ -49,16 +49,25 @@ function platformTarget(platform = process.platform, arch = process.arch, runtim
   return target;
 }
 
-function releaseSpec(manifest, platform = process.platform, arch = process.arch, runtime = {}) {
+const SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+function canonicalVersion(value) { return typeof value === 'string' && SEMVER.test(value); }
+
+// manifest.version names the sealed native artifact (asset, tag, URL, bundle, cache directory).
+// An explicit launcherVersion lets a launcher-only npm patch reuse that artifact unchanged;
+// without it the legacy binding (artifact version == package version) still applies.
+function releaseSpec(manifest, platform = process.platform, arch = process.arch, runtime = {}, launcher = packageVersion) {
   const target = platformTarget(platform, arch, runtime);
-  if (manifest.schema !== 'workbite.release.v1' || manifest.product !== 'WorkBite' || manifest.version !== packageVersion
+  const bound = Object.hasOwn(manifest, 'launcherVersion')
+    ? canonicalVersion(manifest.launcherVersion) && manifest.launcherVersion === launcher
+    : manifest.version === launcher;
+  if (manifest.schema !== 'workbite.release.v1' || manifest.product !== 'WorkBite' || !canonicalVersion(manifest.version) || !bound
       || manifest.repository !== REPOSITORY || manifest.tag !== `v${manifest.version}`) fail('Invalid pinned WorkBite release identity');
   const spec = manifest.platforms?.[target];
   const asset = `workbite-${manifest.version}-${target}${platform === 'win32' ? '.zip' : '.tar.gz'}`;
   if (!spec || spec.asset !== asset
       || spec.url !== `https://github.com/${manifest.repository}/releases/download/${manifest.tag}/${asset}`) fail('Invalid pinned release asset');
   if (spec.sha256 === null || spec.size === null || spec.bundleSha256 === null) {
-    fail(`This workbite ${manifest.version} package has no sealed ${target} release artifact yet. Nothing was downloaded.`);
+    fail(`This workbite ${launcher} package has no sealed ${target} release artifact yet. Nothing was downloaded.`);
   }
   if (![spec.sha256, spec.bundleSha256].every(value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value))
       || !Number.isSafeInteger(spec.size) || spec.size <= 0 || spec.size > LIMITS.download) fail('Invalid pinned release asset');

package/lib/runtime.js

@@ -17,6 +17,7 @@ const BACKEND_SCHEMA = 'stackbite.workstack-backend.v1';
 const CONNECTION_SCHEMA = 'workstack.helm-connection.v1';
 const OWNER_SCHEMA = 'workbite.owner.v2';
 const STACKBITE_SCHEMA = 'workbite.stackbite-backend.v2';
+const SELECTION_SCHEMA = 'workbite.workspace-selection.v1';
 const LOOPBACK = /^http:\/\/127\.0\.0\.1:([1-9][0-9]{0,4})$/;
 // Ports of the existing official StackBite and its previews are never chosen.
 const RESERVED_PORTS = new Set([8089, 8090, 8091, 54036, 54039, 54236, 54239]);
@@ -46,7 +47,8 @@ function stateLayout(root) {
   return { root, stackbite: path.join(root, 'stackbite'), workstackRuntime: path.join(root, 'workstack-runtime'),
     journal: path.join(root, 'deploy-journal'), tuiState: path.join(root, 'workstack-tui'), owners: path.join(root, 'owners'),
     logs: path.join(root, 'logs'), dock: path.join(root, 'execution-dock.json'),
-    stackbiteRecord: path.join(root, 'stackbite-backend.json'), lock: path.join(root, 'open.lock') };
+    stackbiteRecord: path.join(root, 'stackbite-backend.json'), lock: path.join(root, 'open.lock'),
+    selection: path.join(root, 'last-workspace.json') };
 }
 async function prepareState(layout) {
   for (const directory of [layout.root, layout.stackbite, layout.workstackRuntime, layout.journal, layout.tuiState,
@@ -118,6 +120,58 @@ async function initializeWorkspace(commands, workspace, environment) {
   return uid;
 }
 
+// The workspace a bare `workbite` reopens: the last one opened successfully, or, for
+// state from 0.1.0 with no saved selection, the single owner record it holds. It is
+// never guessed (no CWD, mtime or default folder) and never silently replaced by
+// another workspace; the genuine workspace.json id must still match.
+const EXPLICIT = 'Open it once with: workbite open --workspace ABS';
+async function currentUid(workspace, what) {
+  try { return await readWorkspaceUid(workspace); } catch (error) {
+    fail(`The ${what} ${workspace} is missing, moved or no longer a valid Work Stack workspace (${error.message}) ${EXPLICIT}`);
+  }
+}
+async function rememberedWorkspace(layout) {
+  let saved;
+  try { saved = await readJson(layout.selection, 8192); } catch (error) {
+    if (error.code !== 'ENOENT') fail(`The saved workspace selection ${layout.selection} is unreadable. ${EXPLICIT}`);
+    return ownerWorkspace(layout);
+  }
+  if (saved === null || typeof saved !== 'object' || Array.isArray(saved) || Object.keys(saved).length !== 3
+      || saved.schema !== SELECTION_SCHEMA || typeof saved.workspace !== 'string' || !path.isAbsolute(saved.workspace)
+      || typeof saved.workspace_uid !== 'string' || !UUID.test(saved.workspace_uid)) {
+    fail(`The saved workspace selection ${layout.selection} is invalid. ${EXPLICIT}`);
+  }
+  if (await currentUid(saved.workspace, 'last opened workspace') !== saved.workspace_uid) {
+    fail(`The last opened workspace ${saved.workspace} was replaced (its workspace.json id changed); WorkBite does not open it silently. ${EXPLICIT}`);
+  }
+  return { workspace: saved.workspace, uid: saved.workspace_uid };
+}
+async function ownerWorkspace(layout) {
+  let names = [];
+  try { names = (await fs.readdir(layout.owners)).filter(name => /^[0-9a-f]{24}\.json$/.test(name)); } catch (error) {
+    if (error.code !== 'ENOENT') fail(`WorkBite owner records are unreadable. ${EXPLICIT}`);
+  }
+  if (!names.length) fail(`No workspace has been opened yet. ${EXPLICIT} (add --init for a new or empty folder).`);
+  if (names.length > 1) fail(`WorkBite has ${names.length} workspace owner records and will not guess which one to open. ${EXPLICIT}`);
+  const file = path.join(layout.owners, names[0]);
+  let record;
+  try { record = await readJson(file); } catch { fail(`The Work Stack owner record ${file} is unreadable. ${EXPLICIT}`); }
+  if (!isRecord(record) || record.schema !== OWNER_SCHEMA || typeof record.workspace !== 'string' || !path.isAbsolute(record.workspace)
+      || `${workspaceKey(record.workspace)}.json` !== names[0] || typeof record.workspace_uid !== 'string' || !UUID.test(record.workspace_uid)) {
+    fail(`The Work Stack owner record ${file} is not a valid owner record. ${EXPLICIT}`);
+  }
+  if (await currentUid(record.workspace, 'workspace recorded in the owner record') !== record.workspace_uid) {
+    fail(`The workspace recorded in ${file} was replaced (its workspace.json id changed); WorkBite does not open it silently. ${EXPLICIT}`);
+  }
+  return { workspace: record.workspace, uid: record.workspace_uid };
+}
+async function rememberWorkspace(layout, workspace, uid) {
+  const bytes = Buffer.from(JSON.stringify({ schema: SELECTION_SCHEMA, workspace, workspace_uid: uid }, null, 2) + '\n');
+  let current = null;
+  try { current = await readSmall(layout.selection, 8192); } catch { current = null; }
+  if (!current || !current.equals(bytes)) await writeAtomic(layout.selection, bytes);
+}
+
 function request(url, { method = 'GET', headers = {}, body, timeout = 5000 } = {}) {
   const match = LOOPBACK.exec(url.origin);
   if (!match) return Promise.reject(new Error('not a loopback origin'));
@@ -370,18 +424,27 @@ 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, spawnImpl = spawn, stdout = process.stdout, timeouts = {} }) {
-  workspace = checkedWorkspace(workspace);
+  if (workspace !== undefined) workspace = checkedWorkspace(workspace);
+  else if (init) fail('--init needs --workspace ABS naming the new or empty folder');
   commands = commands || Object.fromEntries(Object.entries(installed.executables).map(([name, file]) => [name, [file]]));
   const layout = stateLayout(path.resolve(stateRoot));
   await prepareState(layout);
   const base = cleanEnvironment(environment);
   const engineEnvironment = { ...base, WORK_STACK_RUNTIME: layout.workstackRuntime };
   const session = await withLock(layout.lock, async () => {
+    let remembered = null;
+    if (workspace === undefined) {
+      remembered = await rememberedWorkspace(layout);
+      workspace = checkedWorkspace(remembered.workspace);
+    }
     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 engine = await ensureEngine({ commands, workspace, uid, layout, environment: engineEnvironment, spawnImpl, timeout: timeouts.engine });
     const stackbite = await ensureStackbite({ commands, layout, backendId, environment: base, spawnImpl, timeout: timeouts.stackbite });
     await writeDockConfig(layout, stackbite.url);
+    // Only after the owner, StackBite and dock config are proven ready, and before the UI.
+    await rememberWorkspace(layout, workspace, uid);
     return { uid, backendId, engine, stackbite };
   });
   const summary = { schema: 'workbite.open.v1', workspace, workspace_uid: session.uid, endpoint: session.engine.endpoint,
@@ -399,4 +462,4 @@ async function openSuite({ installed, commands, workspace, init = false, stateRo
 
 module.exports = { cleanEnvironment, stateLayout, prepareState, ensureBackendId, workspaceKey, readWorkspaceUid,
   initializeWorkspace, engineIdentity, stackbiteIdentity, freePort, ensureEngine, ensureStackbite, writeDockConfig,
-  withLock, uiEnvironment, openSuite, RESERVED_PORTS };
+  withLock, uiEnvironment, openSuite, rememberedWorkspace, RESERVED_PORTS, SELECTION_SCHEMA };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workbite",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "WorkBite (Work Stack + StackBite) verified native suite installer and launcher",
   "license": "UNLICENSED",
   "engines": {

package/release.json

@@ -2,6 +2,7 @@
   "schema": "workbite.release.v1",
   "product": "WorkBite",
   "version": "0.1.0",
+  "launcherVersion": "0.1.1",
   "repository": "Shinick-Han/WorkBite-releases",
   "tag": "v0.1.0",
   "platforms": {