@rebon/cli-win32-x64 1.2.0 → 1.4.0

package/payload/plugin-host/src/ownership.mjs

@@ -1,57 +1,57 @@
-// Which entry a stray promise belonged to.
-//
-// Node does not stop this process for an unhandled rejection, and before T20
-// nothing looked either: a plugin could start an async task, have it fail, and
-// leave no trace anywhere rebon reads. T20 made it visible but unattributed,
-// on the belief that a failed promise cannot say who created it.
-//
-// Measured on Node 24.19.0, it can. An `AsyncLocalStorage` store survives
-// `setTimeout`, `queueMicrotask` and `await`, and the `unhandledRejection`
-// handler reads it directly — so wrapping each `plugin/load` is enough, with no
-// per-promise `async_hooks` and therefore no standing cost.
-//
-// **The store follows the async chain, not the clock**, and that distinction is
-// the whole reason `loading` exists. A timer started during `apply` that
-// rejects ten seconds later still carries its entry, long after that load
-// returned. So there are two questions, not one:
-//
-//   * whose is it — `entry`, always, whenever the chain reaches back;
-//   * does it fail the load — `loading`, true only while the load is in flight,
-//     because a load that already succeeded cannot be un-failed.
-//
-// The flag is flipped on the same object rather than by entering a second
-// store: a new store would not be seen by promises already rooted in the first.
-import { AsyncLocalStorage } from 'node:async_hooks';
-
-const owners = new AsyncLocalStorage();
-
-/// Runs `fn` as `entry`'s work, with the load marked in flight for its
-/// duration. Returns whatever `fn` returns; the flag is cleared either way,
-/// because a load that threw is over too.
-export async function asEntryLoad(entry, fn) {
-  const store = { entry, loading: true };
-  try {
-    const value = await owners.run(store, fn);
-    // One turn of the loop before deciding. `unhandledRejection` fires after
-    // the microtask queue drains, so a task this load started that failed
-    // immediately has not been reported yet at the moment `fn` resolves —
-    // checking without this yield would call a broken load a good one.
-    await new Promise((resolve) => setImmediate(resolve));
-    if (store.rejection !== undefined) {
-      throw new Error(`[ENTRY_FAILED] ${entry} left a rejection unhandled while loading: ${store.rejection}`);
-    }
-    return value;
-  } finally {
-    store.loading = false;
-  }
-}
-
-/// The entry whose async chain this code is on, or `undefined` outside one.
-///
-/// Undefined is normal and not a failure: a rejection can escape the chain
-/// through an `EventEmitter`, a native callback or a third-party library, and
-/// "could not be determined" is a truthful answer worth keeping distinct from a
-/// wrong one.
-export function currentOwner() {
-  return owners.getStore();
-}
+// Which entry a stray promise belonged to.
+//
+// Node does not stop this process for an unhandled rejection, and nothing else
+// looks either: a plugin could start an async task, have it fail, and leave no
+// trace anywhere rebon reads. Making it visible is not the same as attributing
+// it — a failed promise does not carry who created it.
+//
+// Measured on Node 24.19.0, an `AsyncLocalStorage` store survives
+// `setTimeout`, `queueMicrotask` and `await`, and the `unhandledRejection`
+// handler reads it directly — so wrapping each `plugin/load` is enough, with no
+// per-promise `async_hooks` and therefore no standing cost.
+//
+// **The store follows the async chain, not the clock**, and that distinction is
+// the whole reason `loading` exists. A timer started during `apply` that
+// rejects ten seconds later still carries its entry, long after that load
+// returned. So there are two questions, not one:
+//
+//   * whose is it — `entry`, always, whenever the chain reaches back;
+//   * does it fail the load — `loading`, true only while the load is in flight,
+//     because a load that already succeeded cannot be un-failed.
+//
+// The flag is flipped on the same object rather than by entering a second
+// store: a new store would not be seen by promises already rooted in the first.
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+const owners = new AsyncLocalStorage();
+
+/// Runs `fn` as `entry`'s work, with the load marked in flight for its
+/// duration. Returns whatever `fn` returns; the flag is cleared either way,
+/// because a load that threw is over too.
+export async function asEntryLoad(entry, fn) {
+  const store = { entry, loading: true };
+  try {
+    const value = await owners.run(store, fn);
+    // One turn of the loop before deciding. `unhandledRejection` fires after
+    // the microtask queue drains, so a task this load started that failed
+    // immediately has not been reported yet at the moment `fn` resolves —
+    // checking without this yield would call a broken load a good one.
+    await new Promise((resolve) => setImmediate(resolve));
+    if (store.rejection !== undefined) {
+      throw new Error(`[ENTRY_FAILED] ${entry} left a rejection unhandled while loading: ${store.rejection}`);
+    }
+    return value;
+  } finally {
+    store.loading = false;
+  }
+}
+
+/// The entry whose async chain this code is on, or `undefined` outside one.
+///
+/// Undefined is normal and not a failure: a rejection can escape the chain
+/// through an `EventEmitter`, a native callback or a third-party library, and
+/// "could not be determined" is a truthful answer worth keeping distinct from a
+/// wrong one.
+export function currentOwner() {
+  return owners.getStore();
+}

package/payload/plugin-host/src/protocol.mjs

@@ -1,129 +1,129 @@
-export const PROTOCOL_VERSION = 1;
-export const MAX_FRAME_BYTES = 8 * 1024 * 1024;
-export const MAX_SAFE_WIRE_INTEGER = Number.MAX_SAFE_INTEGER;
-export const PLATFORM_PLUGIN_ID = '$rebon/platform';
-export const PLATFORM_CONTROL_SCOPE_ID = '$rebon/control';
-export const PLATFORM_CONTROL_GENERATION = 0;
-export const CALL_CANCEL_METHOD = 'call/cancel';
-
-export class ProtocolError extends Error {
-  constructor(code, message) { super(message); this.name = 'ProtocolError'; this.code = code; }
-}
-
-export class RawJsonNumber {
-  constructor(raw) { this.raw = raw; Object.freeze(this); }
-  valueOf() { return Number(this.raw); }
-  toJSON() { throw new ProtocolError('raw_number', 'raw JSON number cannot be emitted without an explicit schema conversion'); }
-}
-
-const own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
-export const plain = (value) => value !== null && typeof value === 'object' && !Array.isArray(value)
-  && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
-
-function exact(value, keys, where) {
-  if (!plain(value)) throw new ProtocolError('wrong_shape', `${where} must be a plain object`);
-  const actual = Object.keys(value).sort();
-  const expected = [...keys].sort();
-  if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
-    throw new ProtocolError('unknown_field', `${where} must have exactly: ${expected.join(', ')}`);
-  }
-  for (const key of expected) if (!own(value, key)) throw new ProtocolError('wrong_shape', `${where}.${key} is required`);
-}
-
-function wireInteger(value, field) {
-  if (!Number.isSafeInteger(value) || value < 0) throw new ProtocolError('unsafe_integer', `${field} must be a safe non-negative integer`);
-  return Object.is(value, -0) ? 0 : value;
-}
-function string(value, field) {
-  if (typeof value !== 'string') throw new ProtocolError('wrong_shape', `${field} must be a string`);
-  return value;
-}
-function cloneJson(value, seen = new Set()) {
-  if (value instanceof RawJsonNumber) return value;
-  if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
-  if (typeof value === 'number') {
-    if (!Number.isFinite(value)) throw new ProtocolError('invalid_payload', 'payload numbers must be finite JSON numbers');
-    return Object.is(value, -0) ? 0 : value;
-  }
-  if (typeof value !== 'object') throw new ProtocolError('invalid_payload', 'payload must be JSON-compatible');
-  if (seen.has(value)) throw new ProtocolError('invalid_payload', 'payload must not be cyclic');
-  seen.add(value);
-  let copy;
-  if (Array.isArray(value)) copy = value.map((item) => cloneJson(item, seen));
-  else {
-    if (!plain(value)) throw new ProtocolError('invalid_payload', 'payload objects must have a plain prototype');
-    copy = Object.create(null);
-    for (const key of Object.keys(value)) copy[key] = cloneJson(value[key], seen);
-  }
-  seen.delete(value);
-  return Object.freeze(copy);
-}
-
-/// Every name a message object may carry, whatever its variant.
-const MESSAGE_FIELDS = ['type', 'method', 'status', 'payload'];
-
-/// Checks a message object in the order the other language does.
-///
-/// The order is the contract, not an implementation detail. A name nobody knows
-/// is refused before the variant is even decided; then the fields every variant
-/// needs; only then a name that is real but belongs to a different variant.
-/// Collapsing these into one set comparison would report "you left out payload"
-/// as "unknown field", which sends a sender to the wrong place — and would say
-/// something different from the Rust side for the same bytes.
-function messageShape(message, fields) {
-  if (!plain(message)) throw new ProtocolError('wrong_shape', 'message must be a plain object');
-  for (const key of Object.keys(message)) {
-    if (!MESSAGE_FIELDS.includes(key)) throw new ProtocolError('unknown_field', `message has unknown field ${JSON.stringify(key)}`);
-  }
-  for (const key of ['type', 'payload']) {
-    if (!own(message, key)) throw new ProtocolError('wrong_shape', `message.${key} is required`);
-  }
-  for (const key of Object.keys(message)) {
-    if (!fields.includes(key)) throw new ProtocolError('unknown_field', `message must have exactly: ${[...fields].sort().join(', ')}`);
-  }
-  for (const key of fields) {
-    if (!own(message, key)) throw new ProtocolError('wrong_shape', `message.${key} is required`);
-  }
-}
-
-export function validateEnvelope(input) {
-  exact(input, ['protocol_version','host_epoch','plugin_id','scope_id','scope_generation','call_id','message'], 'envelope');
-  if (input.protocol_version !== PROTOCOL_VERSION) throw new ProtocolError('bad_version', `protocol_version must be ${PROTOCOL_VERSION}`);
-  const type = plain(input.message) ? input.message.type : undefined;
-  // A chunk carries no method: it belongs to the call whose identity it rides,
-  // and that call's method already said what it means.
-  const fields = type === 'terminal' ? ['type','status','payload']
-    : type === 'chunk' ? ['type','payload']
-    : ['type','method','payload'];
-  if (!['request','terminal','notification','chunk'].includes(type)) throw new ProtocolError('wrong_shape', 'message.type is invalid');
-  messageShape(input.message, fields);
-  const message = type === 'terminal'
-    ? Object.freeze({ type, status: terminalStatus(input.message.status), payload: cloneJson(input.message.payload) })
-    : type === 'chunk'
-      ? Object.freeze({ type, payload: cloneJson(input.message.payload) })
-      : Object.freeze({ type, method: string(input.message.method, 'message.method'), payload: cloneJson(input.message.payload) });
-  return Object.freeze({
-    protocol_version: PROTOCOL_VERSION,
-    host_epoch: wireInteger(input.host_epoch, 'host_epoch'),
-    plugin_id: string(input.plugin_id, 'plugin_id'),
-    scope_id: string(input.scope_id, 'scope_id'),
-    scope_generation: wireInteger(input.scope_generation, 'scope_generation'),
-    call_id: string(input.call_id, 'call_id'),
-    message,
-  });
-}
-function terminalStatus(status) {
-  if (!['success','error','cancelled'].includes(status)) throw new ProtocolError('bad_status', 'terminal status is invalid');
-  return status;
-}
-export function identityOf(envelope) {
-  return Object.freeze({ host_epoch: envelope.host_epoch, plugin_id: envelope.plugin_id, scope_id: envelope.scope_id,
-    scope_generation: envelope.scope_generation, call_id: envelope.call_id });
-}
-export function envelope(identity, message) { return validateEnvelope({ protocol_version: PROTOCOL_VERSION, ...identity, message }); }
-export function terminal(identity, status, payload) { return envelope(identity, { type: 'terminal', status, payload }); }
-export function request(identity, method, payload) { return envelope(identity, { type: 'request', method, payload }); }
-export function notification(identity, method, payload) { return envelope(identity, { type: 'notification', method, payload }); }
-export function chunk(identity, payload) { return envelope(identity, { type: 'chunk', payload }); }
-export function cancel(target) { return notification(target, CALL_CANCEL_METHOD, null); }
-export function isPlatformControl(value) { return value.plugin_id === PLATFORM_PLUGIN_ID && value.scope_id === PLATFORM_CONTROL_SCOPE_ID && value.scope_generation === 0; }
+export const PROTOCOL_VERSION = 1;
+export const MAX_FRAME_BYTES = 8 * 1024 * 1024;
+export const MAX_SAFE_WIRE_INTEGER = Number.MAX_SAFE_INTEGER;
+export const PLATFORM_PLUGIN_ID = '$rebon/platform';
+export const PLATFORM_CONTROL_SCOPE_ID = '$rebon/control';
+export const PLATFORM_CONTROL_GENERATION = 0;
+export const CALL_CANCEL_METHOD = 'call/cancel';
+
+export class ProtocolError extends Error {
+  constructor(code, message) { super(message); this.name = 'ProtocolError'; this.code = code; }
+}
+
+export class RawJsonNumber {
+  constructor(raw) { this.raw = raw; Object.freeze(this); }
+  valueOf() { return Number(this.raw); }
+  toJSON() { throw new ProtocolError('raw_number', 'raw JSON number cannot be emitted without an explicit schema conversion'); }
+}
+
+const own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+export const plain = (value) => value !== null && typeof value === 'object' && !Array.isArray(value)
+  && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+
+function exact(value, keys, where) {
+  if (!plain(value)) throw new ProtocolError('wrong_shape', `${where} must be a plain object`);
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
+    throw new ProtocolError('unknown_field', `${where} must have exactly: ${expected.join(', ')}`);
+  }
+  for (const key of expected) if (!own(value, key)) throw new ProtocolError('wrong_shape', `${where}.${key} is required`);
+}
+
+function wireInteger(value, field) {
+  if (!Number.isSafeInteger(value) || value < 0) throw new ProtocolError('unsafe_integer', `${field} must be a safe non-negative integer`);
+  return Object.is(value, -0) ? 0 : value;
+}
+function string(value, field) {
+  if (typeof value !== 'string') throw new ProtocolError('wrong_shape', `${field} must be a string`);
+  return value;
+}
+function cloneJson(value, seen = new Set()) {
+  if (value instanceof RawJsonNumber) return value;
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) throw new ProtocolError('invalid_payload', 'payload numbers must be finite JSON numbers');
+    return Object.is(value, -0) ? 0 : value;
+  }
+  if (typeof value !== 'object') throw new ProtocolError('invalid_payload', 'payload must be JSON-compatible');
+  if (seen.has(value)) throw new ProtocolError('invalid_payload', 'payload must not be cyclic');
+  seen.add(value);
+  let copy;
+  if (Array.isArray(value)) copy = value.map((item) => cloneJson(item, seen));
+  else {
+    if (!plain(value)) throw new ProtocolError('invalid_payload', 'payload objects must have a plain prototype');
+    copy = Object.create(null);
+    for (const key of Object.keys(value)) copy[key] = cloneJson(value[key], seen);
+  }
+  seen.delete(value);
+  return Object.freeze(copy);
+}
+
+/// Every name a message object may carry, whatever its variant.
+const MESSAGE_FIELDS = ['type', 'method', 'status', 'payload'];
+
+/// Checks a message object in the order the other language does.
+///
+/// The order is the contract, not an implementation detail. A name nobody knows
+/// is refused before the variant is even decided; then the fields every variant
+/// needs; only then a name that is real but belongs to a different variant.
+/// Collapsing these into one set comparison would report "you left out payload"
+/// as "unknown field", which sends a sender to the wrong place — and would say
+/// something different from the Rust side for the same bytes.
+function messageShape(message, fields) {
+  if (!plain(message)) throw new ProtocolError('wrong_shape', 'message must be a plain object');
+  for (const key of Object.keys(message)) {
+    if (!MESSAGE_FIELDS.includes(key)) throw new ProtocolError('unknown_field', `message has unknown field ${JSON.stringify(key)}`);
+  }
+  for (const key of ['type', 'payload']) {
+    if (!own(message, key)) throw new ProtocolError('wrong_shape', `message.${key} is required`);
+  }
+  for (const key of Object.keys(message)) {
+    if (!fields.includes(key)) throw new ProtocolError('unknown_field', `message must have exactly: ${[...fields].sort().join(', ')}`);
+  }
+  for (const key of fields) {
+    if (!own(message, key)) throw new ProtocolError('wrong_shape', `message.${key} is required`);
+  }
+}
+
+export function validateEnvelope(input) {
+  exact(input, ['protocol_version','host_epoch','plugin_id','scope_id','scope_generation','call_id','message'], 'envelope');
+  if (input.protocol_version !== PROTOCOL_VERSION) throw new ProtocolError('bad_version', `protocol_version must be ${PROTOCOL_VERSION}`);
+  const type = plain(input.message) ? input.message.type : undefined;
+  // A chunk carries no method: it belongs to the call whose identity it rides,
+  // and that call's method already said what it means.
+  const fields = type === 'terminal' ? ['type','status','payload']
+    : type === 'chunk' ? ['type','payload']
+    : ['type','method','payload'];
+  if (!['request','terminal','notification','chunk'].includes(type)) throw new ProtocolError('wrong_shape', 'message.type is invalid');
+  messageShape(input.message, fields);
+  const message = type === 'terminal'
+    ? Object.freeze({ type, status: terminalStatus(input.message.status), payload: cloneJson(input.message.payload) })
+    : type === 'chunk'
+      ? Object.freeze({ type, payload: cloneJson(input.message.payload) })
+      : Object.freeze({ type, method: string(input.message.method, 'message.method'), payload: cloneJson(input.message.payload) });
+  return Object.freeze({
+    protocol_version: PROTOCOL_VERSION,
+    host_epoch: wireInteger(input.host_epoch, 'host_epoch'),
+    plugin_id: string(input.plugin_id, 'plugin_id'),
+    scope_id: string(input.scope_id, 'scope_id'),
+    scope_generation: wireInteger(input.scope_generation, 'scope_generation'),
+    call_id: string(input.call_id, 'call_id'),
+    message,
+  });
+}
+function terminalStatus(status) {
+  if (!['success','error','cancelled'].includes(status)) throw new ProtocolError('bad_status', 'terminal status is invalid');
+  return status;
+}
+export function identityOf(envelope) {
+  return Object.freeze({ host_epoch: envelope.host_epoch, plugin_id: envelope.plugin_id, scope_id: envelope.scope_id,
+    scope_generation: envelope.scope_generation, call_id: envelope.call_id });
+}
+export function envelope(identity, message) { return validateEnvelope({ protocol_version: PROTOCOL_VERSION, ...identity, message }); }
+export function terminal(identity, status, payload) { return envelope(identity, { type: 'terminal', status, payload }); }
+export function request(identity, method, payload) { return envelope(identity, { type: 'request', method, payload }); }
+export function notification(identity, method, payload) { return envelope(identity, { type: 'notification', method, payload }); }
+export function chunk(identity, payload) { return envelope(identity, { type: 'chunk', payload }); }
+export function cancel(target) { return notification(target, CALL_CANCEL_METHOD, null); }
+export function isPlatformControl(value) { return value.plugin_id === PLATFORM_PLUGIN_ID && value.scope_id === PLATFORM_CONTROL_SCOPE_ID && value.scope_generation === 0; }

package/payload/plugin-host/src/sdk.mjs

@@ -1,7 +1,7 @@
-export function createPluginApi(boundBridge) {
-  if (!boundBridge || typeof boundBridge.call !== 'function' || typeof boundBridge.notify !== 'function') throw new TypeError('boundBridge is invalid');
-  return Object.freeze({
-    call(method, payload, options = {}) { return boundBridge.call(method, payload, options); },
-    notify(method, payload) { return boundBridge.notify(method, payload); },
-  });
-}
+export function createPluginApi(boundBridge) {
+  if (!boundBridge || typeof boundBridge.call !== 'function' || typeof boundBridge.notify !== 'function') throw new TypeError('boundBridge is invalid');
+  return Object.freeze({
+    call(method, payload, options = {}) { return boundBridge.call(method, payload, options); },
+    notify(method, payload) { return boundBridge.notify(method, payload); },
+  });
+}

package/payload/rebon.exe

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/payload/rebon.exe
-size: 71994880 bytes
-sha256: 8bc368970303b3d0410c6d7905dc50bd4945260160c45d38859c4602e2ddaa7a
+size: 73743360 bytes
+sha256: 06ad89a7bfb9c17c8b5731da3069a8a08e0d05366d13a0bd4eab86a7ba526cf6

package/scripts/postinstall.js

@@ -1,112 +1,112 @@
-"use strict";
-
-const childProcess = require("child_process");
-const fs = require("fs");
-const path = require("path");
-
-const INSTALL_SUPERVISOR_ENV = "REBON_INSTALL_SUPERVISOR";
-
-function log(message) {
-  console.log(`[rebon postinstall] ${message}`);
-}
-
-function envFlagEnabled(value) {
-  return /^(1|true|yes|on)$/i.test(String(value || "").trim());
-}
-
-function supervisorHintMessage() {
-  return "background supervisor scheduler was not registered; run `rebon agents service install` to keep queued jobs moving after login, or set REBON_INSTALL_SUPERVISOR=1 before install to opt in.";
-}
-
-function packageRootFromScript() {
-  return path.resolve(__dirname, "..");
-}
-
-function installWindowsPayload(packageRoot) {
-  const {
-    installManagedPackage,
-    readPackageInfo,
-    requireManagedBinDir,
-  } = require("../lib/windows-managed");
-
-  requireManagedBinDir();
-  const packageInfo = readPackageInfo(packageRoot);
-  if (!fs.existsSync(packageInfo.payloadPath)) {
-    throw new Error(`payload executable is missing: ${packageInfo.payloadPath}`);
-  }
-
-  const managedExe = installManagedPackage(packageInfo);
-  if (!managedExe) {
-    throw new Error("could not install payload executable into managed bin directory");
-  }
-  return managedExe;
-}
-
-function packageExecutable(packageRoot, platform) {
-  if (platform === "win32") {
-    return installWindowsPayload(packageRoot);
-  }
-
-  const exePath = path.join(packageRoot, "bin", "rebon");
-  if (!fs.existsSync(exePath)) {
-    throw new Error(`payload executable is missing: ${exePath}`);
-  }
-
-  try {
-    fs.chmodSync(exePath, 0o755);
-  } catch (_) {
-  }
-  return exePath;
-}
-
-function installSupervisorScheduler(exePath, spawnSyncImpl) {
-  const result = spawnSyncImpl(exePath, ["agents", "service", "install"], {
-    stdio: "inherit",
-    windowsHide: true,
-  });
-
-  if (result.error) {
-    throw result.error;
-  }
-  if (result.status !== 0) {
-    throw new Error(`supervisor scheduler install exited with status ${result.status}`);
-  }
-}
-
-function runPostinstall(options = {}) {
-  const platform = options.platform || process.platform;
-  const env = options.env || process.env;
-  const logger = options.log || log;
-  const spawnSyncImpl = options.spawnSync || childProcess.spawnSync;
-  const packageRoot = options.packageRoot || packageRootFromScript();
-  const exePath = packageExecutable(packageRoot, platform);
-
-  logger(`installed ${exePath}`);
-
-  if (envFlagEnabled(env[INSTALL_SUPERVISOR_ENV])) {
-    logger(`registering per-user background supervisor scheduler because ${INSTALL_SUPERVISOR_ENV} is enabled`);
-    installSupervisorScheduler(exePath, spawnSyncImpl);
-    logger("registered background supervisor scheduler");
-    return;
-  }
-
-  logger(supervisorHintMessage());
-}
-
-try {
-  if (require.main === module) {
-    runPostinstall();
-  }
-} catch (error) {
-  console.error(`[rebon postinstall] ${error.message}`);
-  process.exit(1);
-}
-
-module.exports = {
-  INSTALL_SUPERVISOR_ENV,
-  envFlagEnabled,
-  installSupervisorScheduler,
-  packageExecutable,
-  runPostinstall,
-  supervisorHintMessage,
-};
+"use strict";
+
+const childProcess = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const INSTALL_SUPERVISOR_ENV = "REBON_INSTALL_SUPERVISOR";
+
+function log(message) {
+  console.log(`[rebon postinstall] ${message}`);
+}
+
+function envFlagEnabled(value) {
+  return /^(1|true|yes|on)$/i.test(String(value || "").trim());
+}
+
+function supervisorHintMessage() {
+  return "background supervisor scheduler was not registered; run `rebon agents service install` to keep queued jobs moving after login, or set REBON_INSTALL_SUPERVISOR=1 before install to opt in.";
+}
+
+function packageRootFromScript() {
+  return path.resolve(__dirname, "..");
+}
+
+function installWindowsPayload(packageRoot) {
+  const {
+    installManagedPackage,
+    readPackageInfo,
+    requireManagedBinDir,
+  } = require("../lib/windows-managed");
+
+  requireManagedBinDir();
+  const packageInfo = readPackageInfo(packageRoot);
+  if (!fs.existsSync(packageInfo.payloadPath)) {
+    throw new Error(`payload executable is missing: ${packageInfo.payloadPath}`);
+  }
+
+  const managedExe = installManagedPackage(packageInfo);
+  if (!managedExe) {
+    throw new Error("could not install payload executable into managed bin directory");
+  }
+  return managedExe;
+}
+
+function packageExecutable(packageRoot, platform) {
+  if (platform === "win32") {
+    return installWindowsPayload(packageRoot);
+  }
+
+  const exePath = path.join(packageRoot, "bin", "rebon");
+  if (!fs.existsSync(exePath)) {
+    throw new Error(`payload executable is missing: ${exePath}`);
+  }
+
+  try {
+    fs.chmodSync(exePath, 0o755);
+  } catch (_) {
+  }
+  return exePath;
+}
+
+function installSupervisorScheduler(exePath, spawnSyncImpl) {
+  const result = spawnSyncImpl(exePath, ["agents", "service", "install"], {
+    stdio: "inherit",
+    windowsHide: true,
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(`supervisor scheduler install exited with status ${result.status}`);
+  }
+}
+
+function runPostinstall(options = {}) {
+  const platform = options.platform || process.platform;
+  const env = options.env || process.env;
+  const logger = options.log || log;
+  const spawnSyncImpl = options.spawnSync || childProcess.spawnSync;
+  const packageRoot = options.packageRoot || packageRootFromScript();
+  const exePath = packageExecutable(packageRoot, platform);
+
+  logger(`installed ${exePath}`);
+
+  if (envFlagEnabled(env[INSTALL_SUPERVISOR_ENV])) {
+    logger(`registering per-user background supervisor scheduler because ${INSTALL_SUPERVISOR_ENV} is enabled`);
+    installSupervisorScheduler(exePath, spawnSyncImpl);
+    logger("registered background supervisor scheduler");
+    return;
+  }
+
+  logger(supervisorHintMessage());
+}
+
+try {
+  if (require.main === module) {
+    runPostinstall();
+  }
+} catch (error) {
+  console.error(`[rebon postinstall] ${error.message}`);
+  process.exit(1);
+}
+
+module.exports = {
+  INSTALL_SUPERVISOR_ENV,
+  envFlagEnabled,
+  installSupervisorScheduler,
+  packageExecutable,
+  runPostinstall,
+  supervisorHintMessage,
+};