openmausbot 0.1.90 → 0.1.91

package/dist-server/server/workspace-backup-policy.js

@@ -12,13 +12,29 @@ export function portableWorkspaceConfig(value) {
     const config = parseStoredConfig(value);
     return Object.fromEntries(PORTABLE_CONFIG_KEYS.filter((key) => config[key] !== undefined).map((key) => [key, config[key]]));
 }
+// Switches that belong to the machine even inside a portable section.
+// Computer sharing (lending a computer to this server) opens routes and a
+// desktop connector here, so a restored workspace never turns it on or off.
+const DESTINATION_FEATURES = ["sharedComputers"];
 export function restoredWorkspaceConfig(portable, destination) {
     if (!destination || typeof destination !== "object" || Array.isArray(destination))
         throw new Error("Invalid destination workspace configuration; connections were not changed.");
     const merged = { ...destination };
     for (const key of PORTABLE_CONFIG_KEYS)
         delete merged[key];
-    return { ...merged, ...portableWorkspaceConfig(portable) };
+    const restored = { ...merged, ...portableWorkspaceConfig(portable) };
+    const own = destination.features ?? {};
+    const features = { ...restored.features };
+    for (const key of DESTINATION_FEATURES) {
+        delete features[key];
+        if (own[key] !== undefined)
+            features[key] = own[key];
+    }
+    if (Object.keys(features).length)
+        restored.features = features;
+    else
+        delete restored.features;
+    return restored;
 }
 /** Exact app-owned authentication paths, not a scan of user document text. */
 export function excludedWorkspaceAuthPath(path) {
@@ -41,7 +57,10 @@ export function redownloadedOrgLibraryPath(path) {
 /** Per-turn engine hook bearers (`hook-tokens/<digest>.token`, written by the
  * Claude driver). They are dead once their turn settles, so they are never
  * exported. Unlike the saved auth paths above they are not refused on import:
- * v0.1.85 did export them, and such a backup must still restore, without them. */
+ * v0.1.85 did export them, and such a backup must still restore, without them.
+ * The same holds for the session registry's open marker: it describes the
+ * process that wrote it, so it is never exported or installed, and a restore
+ * leaves the destination's own marker where it is (workspace-backup.ts). */
 export function ephemeralWorkspaceTokenPath(path) {
-    return /^hook-tokens(?:\/|$)/.test(path);
+    return /^(?:hook-tokens(?:\/|$)|sessions\.json\.open$)/.test(path);
 }

package/dist-server/server/workspace-backup.js

@@ -26,6 +26,9 @@ const EXCLUDED = new Set([
     ".openmausbot-server-child", "environment-id", "sessions.json", "tunnel-account.json",
     "team-computers.json",
     "openmausbot-server.lease", "box-create-requests.lock", "messages.db-wal", "messages.db-shm",
+    // This machine's decision-model log (server/decider/log.ts): local
+    // measurement of what the classifier picked, not workspace data.
+    "decider-log",
 ]);
 const EXCLUSION_NOTES = [
     "Device pairing, server identity, live leases and runtime files (existing destination identities are preserved).",
@@ -49,6 +52,12 @@ function preserved(name) {
     const folded = name.toLowerCase();
     return excluded(folded) && folded !== "messages.db-wal" && folded !== "messages.db-shm";
 }
+/** Left where it is by a restore. The session registry's open marker is this
+ * machine's own (never exported or installed): a crash before the restore
+ * still costs account sign-ins, as it would have without one. */
+function keptInPlace(name) {
+    return preserved(name) || name.toLowerCase() === "sessions.json.open";
+}
 function folder(path) {
     mkdirSync(path, { recursive: true, mode: 0o700 });
     const stat = lstatSync(path);
@@ -544,22 +553,24 @@ async function decryptArchive(inputPath, plaintext, password) {
 }
 async function inspectTar(path) {
     const fd = openSync(path, "r");
-    const signature = Buffer.alloc(2);
+    const signature = Buffer.alloc(4);
     try {
-        readSync(fd, signature, 0, 2, 0);
+        readSync(fd, signature, 0, 4, 0);
     }
     finally {
         closeSync(fd);
     }
-    // This format is uncompressed tar. Reject auto-detected gzip before tar's
-    // parser can inflate an authenticated but malicious decompression bomb.
-    if (signature[0] === 0x1f && signature[1] === 0x8b)
+    // This format is uncompressed tar. Reject auto-detected gzip and zstd
+    // before tar's parser can inflate an authenticated but malicious
+    // decompression bomb; tar is also told never to decompress (below).
+    if ((signature[0] === 0x1f && signature[1] === 0x8b) || signature.equals(Buffer.from([0x28, 0xb5, 0x2f, 0xfd]))) {
         throw new Error("Compressed payloads are not supported in this workspace backup version.");
+    }
     const entries = new Map();
     const names = new Set();
     let bytes = 0;
     let problem = "";
-    await tar.t({ file: path, strict: true, onReadEntry(entry) {
+    await tar.t({ file: path, strict: true, brotli: false, zstd: false, onReadEntry(entry) {
             const name = entry.type === "Directory" ? entry.path.replace(/\/$/, "") : entry.path;
             const expectedRoot = name === "manifest.json" || name === "data" || name.startsWith("data/");
             // ReadEntry normalizes backslashes on Windows; inspect the raw header too
@@ -651,7 +662,7 @@ export async function stageWorkspaceBackup(dataDir, archivePath, options) {
         const expected = await inspectTar(plaintext);
         const staged = join(job.directory, "staged");
         folder(staged);
-        await tar.x({ file: plaintext, cwd: staged, strict: true, preservePaths: false, umask: 0o077, noChmod: true });
+        await tar.x({ file: plaintext, cwd: staged, strict: true, preservePaths: false, umask: 0o077, noChmod: true, brotli: false, zstd: false });
         const manifest = validateStaged(staged, expected);
         const versions = [manifest.summary.appVersion, options.currentAppVersion ?? ""].map((version) => /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version)?.slice(1).map(Number));
         if (versions[0] && versions[1]) {
@@ -1037,7 +1048,7 @@ export function applyPendingWorkspaceRestore(dataDir) {
     folder(join(safetyCopyPath, "data"));
     const journal = {
         id: pending.id, phase: "applying",
-        existing: readdirSync(dataDir).filter((name) => !preserved(name)).sort(),
+        existing: readdirSync(dataDir).filter((name) => !keptInPlace(name)).sort(),
         incoming: readdirSync(prepared).sort(),
     };
     // Top-level source and destination names are checked before recording any
@@ -1087,3 +1098,9 @@ export function removeWorkspaceBackupJob(dataDir, id) {
         throw new Error("Unsafe workspace backup cleanup target.");
     rmSync(path, { recursive: true, force: true });
 }
+/** Whether a snapshot leaves out this workspace-relative path, by the same
+ * rules as the export walk (cloud-move.ts sizes a move with it). Symbolic
+ * links are the caller's to skip. */
+export function omittedFromWorkspaceBackup(path) {
+    return excluded(path.split("/")[0]) || excludedWorkspaceAuthPath(path) || ephemeralWorkspaceTokenPath(path) || redownloadedOrgLibraryPath(path);
+}

package/dist-server/shared/cloud-home.js

@@ -0,0 +1,4 @@
+/** Whether a Cloud home offers this place at all. */
+export function cloudHomeOffersPlace(place) {
+    return place !== "local" && place !== "vm";
+}

package/dist-server/shared/package-format.js

@@ -161,7 +161,24 @@ const requirementsSchema = z.object({
     capabilities: z.array(requiredText(80)).max(20),
     platforms: z.array(requiredText(80)).max(10).optional(),
 });
-const roomSchema = z.object({
+const ROOM_RESPONDER_KINDS = new Set(["agent", "everyone", "mentions", "auto"]);
+/** A responder kind from a newer release degrades to the room's first member
+ * as lead, which is what a room without a responder does, instead of
+ * refusing the whole package. Malformed values still fail below. */
+function knownRoomResponder(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const room = value;
+    const responder = room.defaultResponder;
+    if (!responder || typeof responder !== "object" || Array.isArray(responder))
+        return value;
+    const kind = responder.kind;
+    if (typeof kind !== "string" || ROOM_RESPONDER_KINDS.has(kind))
+        return value;
+    const first = Array.isArray(room.members) && typeof room.members[0] === "string" ? room.members[0] : undefined;
+    return { ...room, defaultResponder: first ? { kind: "agent", agent: first } : { kind: "mentions" } };
+}
+const roomSchema = z.preprocess(knownRoomResponder, z.object({
     key,
     name: requiredText(100),
     members: z.array(key).min(1).max(200),
@@ -170,8 +187,11 @@ const roomSchema = z.object({
         z.object({ kind: z.literal("agent"), agent: key }),
         z.object({ kind: z.literal("everyone") }),
         z.object({ kind: z.literal("mentions") }),
+        // Read, not written: exports spell an Auto room as its lead (see
+        // server/package-export.ts) so every older app can still open them.
+        z.object({ kind: z.literal("auto"), agent: key.optional() }),
     ]),
-});
+}));
 const exampleSchema = z.object({
     title: requiredText(120),
     input: requiredText(4_000),
@@ -580,7 +600,8 @@ function checkV1References(pkg) {
             if (!agents.has(member))
                 throw invalid(`Room ${room.key} references unknown agent: ${member}`);
         }
-        if (room.defaultResponder.kind === "agent" && !members.has(room.defaultResponder.agent)) {
+        if ((room.defaultResponder.kind === "agent" || room.defaultResponder.kind === "auto") && room.defaultResponder.agent !== undefined &&
+            !members.has(room.defaultResponder.agent)) {
             throw invalid(`Room ${room.key} has an unknown default responder`);
         }
     }
@@ -637,7 +658,8 @@ function checkV2References(pkg) {
             if (!agents.has(member))
                 throw invalid(`Room ${room.key} references unknown agent: ${member}`);
         }
-        if (room.defaultResponder.kind === "agent" && !members.has(room.defaultResponder.agent)) {
+        if ((room.defaultResponder.kind === "agent" || room.defaultResponder.kind === "auto") && room.defaultResponder.agent !== undefined &&
+            !members.has(room.defaultResponder.agent)) {
             throw invalid(`Room ${room.key} has a default responder who is not a member: ${room.defaultResponder.agent}`);
         }
         roomMembers.set(room.key, members);
@@ -821,8 +843,12 @@ export function downgradeToV1(document) {
         return [{ ...kept, enabledAfterInstall: false }];
     });
     const { team, publisher: _publisher, notes: _notes, presets: _presets, connections: _connections, skills: _skills, agents: _agents, routines: _routines, ...rest } = pkg;
+    // Older apps know no Auto room: spell one as its lead, as exports do.
+    const rooms = rest.rooms?.map((room) => room.defaultResponder.kind !== "auto" ? room
+        : { ...room, defaultResponder: { kind: "agent", agent: room.defaultResponder.agent ?? room.members[0] } });
     const v1 = {
         ...rest,
+        ...(rooms ? { rooms } : {}),
         agents,
         ...(team.leader ? { chiefOfStaff: team.leader } : {}),
         ...(routines.length ? { routines } : {}),

package/dist-server/shared/team-backup.js

@@ -63,6 +63,20 @@ const memory = z.object({
  * against. Shareable exports never carry grants at all, and an import
  * always lands bots grant-less whatever the file says. */
 const connectorTools = z.record(z.string().regex(CONNECTOR_SLUG_PATTERN), z.object({ tools: z.union([z.literal("*"), z.array(z.string().regex(CONNECTOR_TOOL_NAME_PATTERN)).min(1).max(500)]) }));
+/** A responder kind from a newer release restores as the room's first
+ * member as lead (what a room without one does) instead of refusing the
+ * whole backup. Malformed values still fail the schema. */
+function knownRoomResponder(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const group = value;
+    const kind = group.defaultResponder && typeof group.defaultResponder === "object"
+        ? group.defaultResponder.kind : undefined;
+    if (typeof kind !== "string" || ["member", "everyone", "mentions", "auto"].includes(kind))
+        return value;
+    const first = Array.isArray(group.memberIds) && typeof group.memberIds[0] === "string" ? group.memberIds[0] : undefined;
+    return { ...group, defaultResponder: first ? { kind: "member", botId: first } : { kind: "mentions" } };
+}
 const backupSchema = z.object({
     format: z.literal("openmaus.backup"),
     version: z.literal(1),
@@ -86,7 +100,7 @@ const backupSchema = z.object({
         connectorTools: connectorTools.optional(),
         memory: memory.optional(),
     })).min(1).max(200),
-    groups: z.array(z.object({
+    groups: z.array(z.preprocess(knownRoomResponder, z.object({
         ...owner,
         memberIds: z.array(key).max(200),
         dm: z.boolean(),
@@ -95,8 +109,9 @@ const backupSchema = z.object({
             z.object({ kind: z.literal("member"), botId: key }),
             z.object({ kind: z.literal("everyone") }),
             z.object({ kind: z.literal("mentions") }),
+            z.object({ kind: z.literal("auto"), fallbackBotId: key.optional() }),
         ]),
-    })).max(2_000),
+    }))).max(2_000),
     routines: z.array(z.object({
         name, prompt: z.string().trim().min(1).max(200_000),
         target: z.enum(["bot", "room-goal"]), botId: key, groupId: key.optional(),
@@ -136,7 +151,9 @@ export function parseTeamBackup(input) {
         if (group.memberIds.some((id) => !bots.has(id)))
             throw new Error("Invalid backup: unknown room member");
         unique(group.memberIds, "room member");
-        if (group.defaultResponder.kind === "member" && !group.memberIds.includes(group.defaultResponder.botId)) {
+        const lead = group.defaultResponder.kind === "member" ? group.defaultResponder.botId
+            : group.defaultResponder.kind === "auto" ? group.defaultResponder.fallbackBotId : undefined;
+        if (lead !== undefined && !group.memberIds.includes(lead)) {
             throw new Error("Invalid backup: room responder is not a member");
         }
         if (group.dm && (group.memberIds.length !== 2 || group.tasks.length !== 1))

package/dist-server/vps-container-mcp.js

@@ -503,7 +503,7 @@ import { promisify } from "node:util";
 
 // server/config.ts
 import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 
 // node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -16023,6 +16023,72 @@ var remoteMutationSchema = remoteEntrySchema.extend({
 var CLOUD_SEAT_IDLE_STOP_MS = 5 * 6e4;
 var CLOUD_SEAT_SLEEP_RETRY_MAX_MS = 10 * 6e4;
 
+// server/proxy-paths.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+var SERVER_ROOT = dirname2(fileURLToPath(import.meta.url));
+function resolveProxy(relative) {
+  const source = join2(SERVER_ROOT, `${relative}.ts`);
+  return existsSync2(source) ? source : join2(SERVER_ROOT, `${relative}.js`);
+}
+var SPAWNED_PROXIES = {
+  browser: resolveProxy("browser-proxy"),
+  localComputer: resolveProxy("local-computer-proxy"),
+  permission: resolveProxy("permission-proxy"),
+  containerMcp: resolveProxy("container-mcp"),
+  vpsContainerMcp: resolveProxy("vps-container-mcp"),
+  agents: resolveProxy("drivers/agents-proxy"),
+  dweb: resolveProxy("drivers/dweb-proxy"),
+  connectors: resolveProxy("connector-proxy"),
+  mcpGate: resolveProxy("mcp-gate"),
+  phone: resolveProxy("drivers/phone-proxy"),
+  hook: resolveProxy("hooks/omb-hook"),
+  // Loaded by the external `pi` process via `-e`, not by this server — but
+  // resolved through the same single source of truth so the packaged layout
+  // check can assert it ships.
+  piMcpExtension: resolveProxy("drivers/pi-mcp-extension")
+};
+
+// server/enterprise.ts
+var layerSchema = external_exports.object({
+  customer: external_exports.string().min(1),
+  features: external_exports.array(external_exports.string().min(1)),
+  expiresAt: external_exports.string().nullable()
+});
+var DAY_MS = 24 * 60 * 6e4;
+
+// server/sessions.ts
+var PAIRING_CODE_TTL_MS = 5 * 6e4;
+function daysMs(value, fallbackDays) {
+  const days = Number(value);
+  const ok = Number.isInteger(days) && days >= 1 && days <= 3650;
+  return (ok ? days : fallbackDays) * 24 * 60 * 6e4;
+}
+var SESSION_TTL_MS = daysMs(process.env.OMB_SESSION_TTL_DAYS, 30);
+var SESSION_MAX_AGE_MS = daysMs(process.env.OMB_SESSION_MAX_DAYS, 180);
+var SESSION_RENEW_WHEN_LEFT_MS = SESSION_TTL_MS / 2;
+var STREAM_TICKET_TTL_MS = 5 * 6e4;
+var scopeSchema = external_exports.enum(["admin", "client"]);
+var sessionSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  tokenHash: external_exports.string().length(64),
+  label: external_exports.string().max(80),
+  scopes: external_exports.array(scopeSchema).min(1),
+  createdAt: external_exports.number(),
+  lastSeenAt: external_exports.number(),
+  expiresAt: external_exports.number(),
+  /** Set when the session came from an account sign-in rather than a code. */
+  userId: external_exports.string().max(256).optional(),
+  email: external_exports.string().max(320).optional(),
+  /** Set only by the internal verified-portal issuance path, never by email or pairing input. */
+  membershipAuthority: external_exports.literal("portal").optional()
+});
+var fileSchema = external_exports.object({ version: external_exports.literal(1), sessions: external_exports.array(sessionSchema) });
+
+// server/cloud-home.ts
+var CLOUD_PAIRING_NONCE_MS = 10 * 6e4;
+
 // server/config.ts
 var optionalText = external_exports.string().optional();
 var SSH_ALIAS = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/;
@@ -16354,6 +16420,19 @@ var appConfigSchema = external_exports.object({
     baseUrl: external_exports.string().trim().max(2048).refine((value) => !value || /^https?:\/\//i.test(value), "the Chatterbox server address must start with http:// or https://").optional(),
     model: optionalText
   }).optional(),
+  /** The decision model (server/decider): a fast classifier that picks
+   * things for bots, starting with who answers a room message. `key` is
+   * write-only like every credential; `baseUrl` points at a Jev-compatible
+   * server instead of TypeSafe's (an operator setting with no UI); `jobs`
+   * switches each decision on or off. Not `decisions`: that section is the
+   * authorization log's retention. */
+  decider: external_exports.object({
+    enabled: external_exports.boolean().optional(),
+    provider: external_exports.enum(["jev", "off"]).optional(),
+    key: optionalText,
+    baseUrl: external_exports.string().trim().max(2048).refine((value) => !value || /^https?:\/\//i.test(value), "the decision model address must start with http:// or https://").optional(),
+    jobs: external_exports.object({ roomRouting: external_exports.boolean().optional() }).optional()
+  }).optional(),
   /** Avatar provider credentials stay separate; choosing a router never reuses a cloud key. */
   imageGen: external_exports.object({
     provider: external_exports.enum(["openai", "xai", "custom"]).optional(),
@@ -16423,37 +16502,10 @@ var storedAppConfigSchema = appConfigSchema.extend({
 var appConfigPatchSchema = appConfigSchema.omit({ instances: true, mcpServers: true, cliStartup: true, customDomain: true }).extend({ threads: threadsPatchSchema.optional(), newBots: newBotsPatchSchema.optional() });
 var jsonObjectSchema = external_exports.record(external_exports.string(), external_exports.json());
 var DEFAULT_CAPTURE_QUIET_MS = 2 * 6e4;
-var DATA_DIR = process.env.OMB_DATA_DIR ?? join2(homedir2(), ".openmausbot");
-var LEGACY_DATA_DIR = join2(homedir2(), ".opengrokbot");
-var EVENTS_DIR = join2(DATA_DIR, "events");
-var NATIVE_DIR = join2(DATA_DIR, "native");
-
-// server/proxy-paths.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { dirname as dirname2, join as join3 } from "node:path";
-import { fileURLToPath } from "node:url";
-var SERVER_ROOT = dirname2(fileURLToPath(import.meta.url));
-function resolveProxy(relative) {
-  const source = join3(SERVER_ROOT, `${relative}.ts`);
-  return existsSync2(source) ? source : join3(SERVER_ROOT, `${relative}.js`);
-}
-var SPAWNED_PROXIES = {
-  browser: resolveProxy("browser-proxy"),
-  localComputer: resolveProxy("local-computer-proxy"),
-  permission: resolveProxy("permission-proxy"),
-  containerMcp: resolveProxy("container-mcp"),
-  vpsContainerMcp: resolveProxy("vps-container-mcp"),
-  agents: resolveProxy("drivers/agents-proxy"),
-  dweb: resolveProxy("drivers/dweb-proxy"),
-  connectors: resolveProxy("connector-proxy"),
-  mcpGate: resolveProxy("mcp-gate"),
-  phone: resolveProxy("drivers/phone-proxy"),
-  hook: resolveProxy("hooks/omb-hook"),
-  // Loaded by the external `pi` process via `-e`, not by this server — but
-  // resolved through the same single source of truth so the packaged layout
-  // check can assert it ships.
-  piMcpExtension: resolveProxy("drivers/pi-mcp-extension")
-};
+var DATA_DIR = process.env.OMB_DATA_DIR ?? join3(homedir2(), ".openmausbot");
+var LEGACY_DATA_DIR = join3(homedir2(), ".opengrokbot");
+var EVENTS_DIR = join3(DATA_DIR, "events");
+var NATIVE_DIR = join3(DATA_DIR, "native");
 
 // server/container-computer.ts
 var run = promisify(execFile2);