@ours.network/messenger-server 1.0.31-nightly.10 → 1.0.31-nightly.11

package/dist/chunks/{chunk-O34PQ4M6.js → chunk-Y5H3QIV5.js}

@@ -38,7 +38,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var define_MESSENGER_BUILD_INFO_default;
 var init_define_MESSENGER_BUILD_INFO = __esm({
   "<define:__MESSENGER_BUILD_INFO__>"() {
-    define_MESSENGER_BUILD_INFO_default = { name: "@ours.network/messenger-server", version: "1.0.31-nightly.10", sha: "8439d0b521650da63b97749c8bd7ebd48826ef05", dirty: true };
+    define_MESSENGER_BUILD_INFO_default = { name: "@ours.network/messenger-server", version: "1.0.31-nightly.11", sha: "0b84916c7fa85aa89cc5fcc004fb6b7cd79a26cd", dirty: true };
   }
 });
 

package/dist/chunks/{server-Q2BQSKMJ.js → server-T57VZPJ5.js}

@@ -10,7 +10,7 @@ import {
   publicEngineError,
   publicInternalError,
   reportFailure
-} from "./chunk-O34PQ4M6.js";
+} from "./chunk-Y5H3QIV5.js";
 
 // node_modules/bn.js/lib/bn.js
 var require_bn = __commonJS({
@@ -2990,7 +2990,7 @@ var require_reporter = __commonJS({
       if (state.obj !== null)
         state.obj[key] = value;
     };
-    Reporter.prototype.path = function path() {
+    Reporter.prototype.path = function path2() {
       return this._reporterState.path.join("/");
     };
     Reporter.prototype.enterObject = function enterObject() {
@@ -3031,8 +3031,8 @@ var require_reporter = __commonJS({
         errors: state.errors
       };
     };
-    function ReporterError(path, msg) {
-      this.path = path;
+    function ReporterError(path2, msg) {
+      this.path = path2;
       this.rethrow(msg);
     }
     inherits(ReporterError, Error);
@@ -3144,7 +3144,7 @@ var require_buffer = __commonJS({
       const isCompatible = typeof data === "object" && data.constructor.name === "EncoderBuffer" && typeof data.length === "number" && typeof data.join === "function";
       return isCompatible;
     };
-    EncoderBuffer.prototype.join = function join5(out, offset) {
+    EncoderBuffer.prototype.join = function join6(out, offset) {
       if (!out)
         out = Buffer2.alloc(this.length);
       if (!offset)
@@ -11676,7 +11676,7 @@ var MessengerNotificationProducer = class {
 };
 
 // src/server.ts
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 import { readFile, realpath, stat } from "node:fs/promises";
 import { createServer } from "node:http";
 import { dirname as dirname5, extname, isAbsolute as isAbsolute2, relative, resolve as resolve2, sep } from "node:path";
@@ -11686,6 +11686,44 @@ import { Worker } from "node:worker_threads";
 // src/api.ts
 init_define_MESSENGER_BUILD_INFO();
 
+// src/workspace-profile.ts
+init_define_MESSENGER_BUILD_INFO();
+import { existsSync as existsSync2, lstatSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { randomUUID } from "node:crypto";
+function profileName(value) {
+  if (typeof value !== "string" || !value.trim() || value.length > 100 || /[\x00-\x1f\x7f]/.test(value)) throw Error("Name and Surname require printable text");
+  return value.trim();
+}
+function path(dir, cid) {
+  if (!/^[a-f0-9]{64}$/i.test(cid)) throw Error("Invalid identity");
+  return join2(dir, "human-" + cid.toLowerCase() + ".json");
+}
+function readHumanProfile(dir, cid) {
+  if (!/^[a-f0-9]{64}$/i.test(cid)) return;
+  const file = path(dir, cid);
+  if (!existsSync2(file)) return;
+  const stat2 = lstatSync(file);
+  if (!stat2.isFile() || stat2.isSymbolicLink() || stat2.nlink !== 1 || stat2.uid !== process.getuid?.() || (stat2.mode & 63) !== 0) throw Error("Private profile path required");
+  const row = JSON.parse(readFileSync2(file, "utf8"));
+  return { name: profileName(row.name), surname: profileName(row.surname) };
+}
+function writeHumanProfile(dir, cid, value) {
+  const row = { name: profileName(value.name), surname: profileName(value.surname) };
+  mkdirSync2(dir, { recursive: true, mode: 448 });
+  const directory = lstatSync(dir);
+  if (!directory.isDirectory() || directory.isSymbolicLink() || directory.uid !== process.getuid?.() || (directory.mode & 63) !== 0) throw Error("Private profile directory required");
+  const file = path(dir, cid);
+  if (existsSync2(file)) {
+    const stat2 = lstatSync(file);
+    if (!stat2.isFile() || stat2.isSymbolicLink() || stat2.nlink !== 1 || stat2.uid !== process.getuid?.() || (stat2.mode & 63) !== 0) throw Error("Private profile path required");
+  }
+  const temporary = file + "." + randomUUID();
+  writeFileSync2(temporary, JSON.stringify(row) + "\n", { mode: 384, flag: "wx" });
+  renameSync2(temporary, file);
+  return row;
+}
+
 // src/conversation.ts
 init_define_MESSENGER_BUILD_INFO();
 
@@ -11956,8 +11994,8 @@ function toSse(event, identity) {
 // src/command-invocations.ts
 init_define_MESSENGER_BUILD_INFO();
 import { createHash as createHash2 } from "node:crypto";
-import { chmodSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join2 } from "node:path";
+import { chmodSync, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
 var MAX_INVOCATIONS = 4096;
 var InvocationConflictError = class extends Error {
 };
@@ -11984,10 +12022,10 @@ var CommandInvocationStore = class _CommandInvocationStore {
   }
   static open(stateDir, identityCid, capacity = MAX_INVOCATIONS) {
     if (!Number.isInteger(capacity) || capacity < 1) throw new Error("invocation capacity must be a positive integer");
-    const file = join2(stateDir, `typed-commands-${createHash2("sha256").update(identityCid).digest("hex").slice(0, 24)}.json`);
+    const file = join3(stateDir, `typed-commands-${createHash2("sha256").update(identityCid).digest("hex").slice(0, 24)}.json`);
     let state = { version: 1, records: {} };
     try {
-      const parsed = JSON.parse(readFileSync2(file, "utf8"));
+      const parsed = JSON.parse(readFileSync3(file, "utf8"));
       if (!parsed || typeof parsed !== "object" || parsed.version !== 1 || !parsed.records || typeof parsed.records !== "object" || !Object.values(parsed.records).every(validRecord)) {
         throw new Error("invalid typed command invocation state");
       }
@@ -12035,11 +12073,11 @@ var CommandInvocationStore = class _CommandInvocationStore {
     return record;
   }
   save() {
-    mkdirSync2(dirname2(this.file), { recursive: true, mode: 448 });
+    mkdirSync3(dirname2(this.file), { recursive: true, mode: 448 });
     const temp = `${this.file}.${process.pid}.tmp`;
-    writeFileSync2(temp, JSON.stringify(this.state), { mode: 384 });
+    writeFileSync3(temp, JSON.stringify(this.state), { mode: 384 });
     chmodSync(temp, 384);
-    renameSync2(temp, this.file);
+    renameSync3(temp, this.file);
   }
 };
 function statusFor(delivery, wireId) {
@@ -20977,7 +21015,47 @@ var ROUTES = {
   // ---- identity / profile --------------------------------------------------
   // The old browser surface called the read half `getProfileName`; the name is a
   // field on this result.
-  "GET /api/identity": async ({ client }) => publicIdentity(await client.currentIdentity()),
+  "GET /api/identity": async ({ client, deps }) => ({ ...publicIdentity(await client.currentIdentity()), humanProfile: readHumanProfile(deps.config.stateDir, deps.identityCid) }),
+  "POST /api/identity/profile": async ({ client, deps, body }) => {
+    const identity = await client.currentIdentity();
+    if (!identity.isRoot || identity.temporary) throw bad("Human profile requires the root identity");
+    return writeHumanProfile(deps.config.stateDir, deps.identityCid, { name: profileName(body.name), surname: profileName(body.surname) });
+  },
+  // First-party setup operation: daemon signs the command using this bound root.
+  "GET /api/workspace/enrollment-identity": async ({ client }) => {
+    const identity = await client.currentIdentity();
+    if (!identity.isRoot || identity.temporary) throw bad("Workspace proof requires the bound Human root");
+    return { cid: identity.cid };
+  },
+  "POST /api/workspace/enroll": async ({ client, deps, body }) => {
+    const identity = await client.currentIdentity();
+    if (!identity.isRoot || identity.temporary) throw bad("Workspace proof requires the bound Human root");
+    const serverCid = str(body, "serverCid").toUpperCase();
+    if (!/^[A-F0-9]{64}$/.test(serverCid) || !/^[A-Za-z0-9_-]{43}$/.test(str(body, "hostWorkspaceId"))) throw bad("Invalid workspace proof");
+    const challenge = body.challenge;
+    if (!challenge || !["nonce", "workspaceId", "accountId"].every((k3) => typeof challenge[k3] === "string" && /^[A-Za-z0-9_-]{43}$/.test(String(challenge[k3]))) || !Number.isFinite(challenge.expiresAt) || Number(challenge.expiresAt) <= Date.now() || Number(challenge.expiresAt) > Date.now() + 16 * 6e4) throw bad("Workspace challenge expired or invalid");
+    let humanProfile;
+    try {
+      humanProfile = { name: profileName(body.name), surname: profileName(body.surname) };
+    } catch {
+      throw bad("Name and Surname require printable text up to 100 characters");
+    }
+    const invitation = str(body, "invitation");
+    if (invitation.length > 8192) throw bad("Workspace invitation too large");
+    writeHumanProfile(deps.config.stateDir, deps.identityCid, humanProfile);
+    const peer = await client.addContact({ invite: invitation });
+    if (peer.cid.toUpperCase() !== serverCid) throw bad("Enrollment server identity mismatch");
+    const contactDeadline = Date.now() + 1e4;
+    while (!(await client.listContacts()).contacts.some((contact) => contact.container_id.toUpperCase() === serverCid)) {
+      if (Date.now() >= contactDeadline) throw bad("Enrollment contact is not ready; obtain a fresh setup payload before retrying");
+      await new Promise((resolve3) => setTimeout(resolve3, 100));
+    }
+    const argumentsValue = { type: "ours.app.bind-workspace.v1", accountId: String(challenge.accountId), workspaceId: String(challenge.workspaceId), nonce: String(challenge.nonce), hostWorkspaceId: String(body.hostWorkspaceId) };
+    const outcome = await client.sendCommand({ contact: serverCid, command: "bind-workspace", arguments: argumentsValue });
+    if (!("sent" in outcome) || !outcome.sent) throw bad("Workspace proof was not sent");
+    const invite = await client.generateInvite({ mode: "public" });
+    return { submitted: true, rootCid: identity.cid, ownerInvite: invite.blob };
+  },
   "GET /api/identities": async ({ client }) => client.listIdentities(),
   "POST /api/identity/bio": async ({ client, body }) => {
     const bio = body.bio;
@@ -21991,11 +22069,11 @@ async function G(e2 = {}) {
 init_define_MESSENGER_BUILD_INFO();
 import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
-import { isAbsolute, join as join3, resolve, dirname as dirname3 } from "node:path";
+import { isAbsolute, join as join4, resolve, dirname as dirname3 } from "node:path";
 import { spawnSync } from "node:child_process";
-function stateExists(path) {
+function stateExists(path2) {
   try {
-    fs.lstatSync(path);
+    fs.lstatSync(path2);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -22007,13 +22085,13 @@ var OwnerSession = class _OwnerSession {
   constructor(stateDir, selection) {
     this.stateDir = stateDir;
     this.selection = selection;
-    this.path = join3(stateDir, "owner-session.json");
+    this.path = join4(stateDir, "owner-session.json");
   }
   record;
   path;
   lockFd;
   static async open(stateDir, selection, attach) {
-    const saved = stateDir && stateExists(join3(stateDir, "owner-session.json"));
+    const saved = stateDir && stateExists(join4(stateDir, "owner-session.json"));
     if (!selection || process.platform !== "linux") {
       if (saved) throw new ConfigurationError("Saved messenger ownership requires its qualified V1 activation and original selection");
       return void 0;
@@ -22106,23 +22184,23 @@ var OwnerSession = class _OwnerSession {
     }
   }
   activate() {
-    for (let path2 = this.stateDir; ; path2 = dirname3(path2)) {
+    for (let path3 = this.stateDir; ; path3 = dirname3(path3)) {
       let st3;
       try {
-        st3 = fs.lstatSync(path2);
+        st3 = fs.lstatSync(path3);
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
       }
       if (st3 && (!st3.isDirectory() || st3.isSymbolicLink() || st3.uid !== 0 && st3.uid !== process.getuid() || (st3.mode & 18) !== 0 && !(st3.uid === 0 && (st3.mode & 512) !== 0))) {
         throw new ConfigurationError("Messenger ownership state requires safe private directory ancestry");
       }
-      if (path2 === dirname3(path2)) break;
+      if (path3 === dirname3(path3)) break;
     }
     fs.mkdirSync(this.stateDir, { recursive: true, mode: 448 });
     this.privateStat(this.stateDir, true);
-    const path = join3(this.stateDir, "owner-session.lock");
-    this.lockFd = fs.openSync(path, fs.constants.O_CREAT | fs.constants.O_RDWR | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK, 384);
-    const st2 = this.privateStat(path);
+    const path2 = join4(this.stateDir, "owner-session.lock");
+    this.lockFd = fs.openSync(path2, fs.constants.O_CREAT | fs.constants.O_RDWR | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK, 384);
+    const st2 = this.privateStat(path2);
     const opened = fs.fstatSync(this.lockFd);
     if (st2.dev !== opened.dev || st2.ino !== opened.ino) throw new Error("Messenger activation file changed");
     const acquired = spawnSync("flock", ["-n", "3"], {
@@ -22133,8 +22211,8 @@ var OwnerSession = class _OwnerSession {
       throw new ConfigurationError(acquired.status === 1 ? "Messenger application state is already active" : "Messenger state locking is unavailable on this runtime");
     }
   }
-  privateStat(path, directory = false) {
-    const st2 = fs.lstatSync(path);
+  privateStat(path2, directory = false) {
+    const st2 = fs.lstatSync(path2);
     if ((directory ? !st2.isDirectory() : !st2.isFile()) || st2.isSymbolicLink() || st2.uid !== process.getuid() || (st2.mode & 4095) !== (directory ? 448 : 384)) {
       throw new ConfigurationError("Messenger owner state must be private, regular and owned by this user");
     }
@@ -22285,9 +22363,9 @@ async function bindIdentity(runtime, cfg) {
 // src/push.ts
 init_define_MESSENGER_BUILD_INFO();
 var import_web_push = __toESM(require_src2(), 1);
-import { createHash as createHash3, randomUUID, timingSafeEqual } from "node:crypto";
-import { chmodSync as chmodSync2, lstatSync as lstatSync3, mkdirSync as mkdirSync5, readFileSync as readFileSync4, renameSync as renameSync4, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname4, join as join4 } from "node:path";
+import { createHash as createHash3, randomUUID as randomUUID2, timingSafeEqual } from "node:crypto";
+import { chmodSync as chmodSync2, lstatSync as lstatSync4, mkdirSync as mkdirSync6, readFileSync as readFileSync5, renameSync as renameSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname4, join as join5 } from "node:path";
 var MAX_BINDINGS = 32;
 var MAX_ENDPOINT_LENGTH = 2048;
 var MAX_LABEL_LENGTH = 160;
@@ -22483,15 +22561,15 @@ var PushStore = class _PushStore {
     const env = typeof identityCidOrEnv === "string" ? envOrDependencies : identityCidOrEnv;
     const deps = typeof identityCidOrEnv === "string" ? dependencies : envOrDependencies;
     if (!nonEmpty3(identityCid, 512)) throw new Error("push identity CID must be a non-empty bounded string");
-    const file = join4(stateDir, "push.json");
-    mkdirSync5(dirname4(file), { recursive: true, mode: 448 });
+    const file = join5(stateDir, "push.json");
+    mkdirSync6(dirname4(file), { recursive: true, mode: 448 });
     let parsed;
     try {
-      const stat2 = lstatSync3(file);
+      const stat2 = lstatSync4(file);
       if (!stat2.isFile() || stat2.isSymbolicLink()) throw preservedStateError(file, "not a safe regular file");
       let value;
       try {
-        value = JSON.parse(readFileSync4(file, "utf8"));
+        value = JSON.parse(readFileSync5(file, "utf8"));
       } catch (error) {
         throw preservedStateError(file, `corrupt or unreadable (${error instanceof Error ? error.message : String(error)})`);
       }
@@ -22569,7 +22647,7 @@ var PushStore = class _PushStore {
           [identityCid]: {
             ...newIdentityState(),
             bindings: (parsed?.subscriptions ?? []).map((row) => ({
-              bindingId: randomUUID(),
+              bindingId: randomUUID2(),
               endpoint: row.endpoint,
               keys: row.keys,
               createdAt: row.createdAt,
@@ -22590,9 +22668,9 @@ var PushStore = class _PushStore {
   }
   persist() {
     const tmp = `${this.file}.tmp`;
-    writeFileSync5(tmp, JSON.stringify(this.state, null, 2), { mode: 384 });
+    writeFileSync6(tmp, JSON.stringify(this.state, null, 2), { mode: 384 });
     chmodSync2(tmp, 384);
-    renameSync4(tmp, this.file);
+    renameSync5(tmp, this.file);
     chmodSync2(this.file, 384);
   }
   get publicKey() {
@@ -22641,7 +22719,7 @@ var PushStore = class _PushStore {
     const preview = input.preview === void 0 ? previous?.preview ?? "full" : previewMode(input.preview);
     if (!previous && owner.bindings.length >= MAX_BINDINGS) throw new Error(`push subscription limit is ${MAX_BINDINGS}`);
     const createdAt = previous?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
-    const bindingId = previous?.bindingId ?? randomUUID();
+    const bindingId = previous?.bindingId ?? randomUUID2();
     const record = {
       bindingId,
       endpoint,
@@ -22951,7 +23029,7 @@ var PushStore = class _PushStore {
   }
   /** Compatibility for tests/old callers; durable production delivery uses jobs. */
   async send(event) {
-    const wire = `compat-${randomUUID()}`;
+    const wire = `compat-${randomUUID2()}`;
     this.enqueueJob({ wireId: wire, kind: event.kind, contactId: event.contact_id });
     const id = `${this.identityCid}:${wire}:${event.kind}`;
     this.claimJob(id);
@@ -23120,7 +23198,7 @@ function liveFrame(event) {
   return JSON.stringify({ type: "event", event: { v: 1, ...event } });
 }
 function attachPresenceServer(server, registry, options) {
-  const path = options.path ?? "/api/presence";
+  const path2 = options.path ?? "/api/presence";
   const pingIntervalMs = options.pingIntervalMs ?? 3e4;
   const authTimeoutMs = options.authTimeoutMs ?? 5e3;
   const wss = new import_websocket_server.default({ noServer: true, maxPayload: 8 * 1024 });
@@ -23130,7 +23208,7 @@ function attachPresenceServer(server, registry, options) {
       pathname = new URL(request.url ?? "/", "http://localhost").pathname;
     } catch {
     }
-    if (pathname !== path || options.allowedOrigin && request.headers.origin !== options.allowedOrigin) {
+    if (pathname !== path2 || options.allowedOrigin && request.headers.origin !== options.allowedOrigin) {
       socket.destroy();
       return;
     }
@@ -23288,8 +23366,8 @@ async function redirectStaleEntryAsset(req, res, appDir, pathname, basePath = "/
     return false;
   }
 }
-async function readContainedFile(root, path) {
-  const [canonicalRoot, canonicalPath] = await Promise.all([realpath(root), realpath(path)]);
+async function readContainedFile(root, path2) {
+  const [canonicalRoot, canonicalPath] = await Promise.all([realpath(root), realpath(path2)]);
   const fromRoot = relative(canonicalRoot, canonicalPath);
   if (fromRoot === "" || fromRoot === ".." || fromRoot.startsWith(`..${sep}`) || isAbsolute2(fromRoot) || !(await stat(canonicalPath)).isFile()) {
     throw new Error("static asset is not a contained regular file");
@@ -23585,7 +23663,7 @@ async function start(cfg, buildInfo, dependencies = DEFAULT_START_DEPENDENCIES)
       resolve2(moduleDir, "../dist/web"),
       resolve2(moduleDir, "web")
     ];
-    const appDir = process.env.OURS_MESSENGER_WEB_DIR ?? appCandidates.find((candidate) => existsSync2(resolve2(candidate, "index.html")) && existsSync2(resolve2(candidate, "assets"))) ?? resolve2(moduleDir, "__messenger_web_not_built__");
+    const appDir = process.env.OURS_MESSENGER_WEB_DIR ?? appCandidates.find((candidate) => existsSync3(resolve2(candidate, "index.html")) && existsSync3(resolve2(candidate, "assets"))) ?? resolve2(moduleDir, "__messenger_web_not_built__");
     http = createServer((req, res) => {
       const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
       let serving;

package/dist/cli.js

@@ -7,7 +7,7 @@ import {
   normalizeBasePath,
   operatorError,
   reportFailure
-} from "./chunks/chunk-O34PQ4M6.js";
+} from "./chunks/chunk-Y5H3QIV5.js";
 
 // src/cli.ts
 init_define_MESSENGER_BUILD_INFO();
@@ -131,7 +131,7 @@ async function main() {
   }
   if (process.argv.length !== 3) throw new ConfigurationError("serve does not accept command-line options");
   const cfg = loadConfig();
-  const { start } = await import("./chunks/server-Q2BQSKMJ.js");
+  const { start } = await import("./chunks/server-T57VZPJ5.js");
   const handle = await start(cfg, BUILD_INFO);
   let closing = false;
   const shutdown = (signal) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/messenger-server",
-  "version": "1.0.31-nightly.10",
+  "version": "1.0.31-nightly.11",
   "description": "Self-hosted Messenger REST/SSE backend for one identity on a shared Ours daemon.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",