openmates 0.15.0-alpha.99 → 0.16.0-alpha.0

package/README.md

@@ -144,9 +144,12 @@ review the spend confirmation before live runs.
 ### Local source bridge
 
 ```bash
-openmates remote-access
-openmates remote-access --path ./my-repo --path ../shared
-openmates remote-access --path ./my-repo --json
+openmates remote-access --personal
+openmates remote-access --team <team> --path ./my-repo --path ../shared
+openmates remote-access --personal --path ./my-repo --json
+openmates projects files list <project> --personal --json
+openmates projects files search <project> <query> --team <team> --source <source-id> --json
+openmates projects files read <project> <relative-path> --team <team> --source <source-id> --json
 ```
 
 The command discovers Git repositories below the current folder by default;
@@ -157,6 +160,14 @@ selected text previews. The bridge is read-only, excludes ignored, protected,
 binary, and out-of-root files, and never uploads a preview unless you explicitly
 choose to upload it.
 
+Interactive hosting confirms Personal or Team context before discovery.
+Non-interactive/JSON hosting and live file requests require `--personal` or
+`--team <team>`. Team permissions are enforced by the API; live filesystem
+methods remain CLI-only and are not exposed by the npm SDK.
+Project deletion requires the exact Project ID, and source removal requires the
+exact source ID, both in the CLI prompt and in the server request. Generic
+boolean confirmation is not supported.
+
 Project keys authenticate end-to-end encryption between trusted clients. The
 backend receives routing metadata and opaque ciphertext, not filesystem paths,
 queries, snippets, file contents, or encryption keys. Local source associations
@@ -304,12 +315,12 @@ intentionally want the chat saved to the OpenMates account.
 
 ## Versioning
 
-OpenMates shows the short product line, for example `v0.15`, in the web app.
+OpenMates shows the short product line, for example `v0.16`, in the web app.
 The npm package uses exact artifact versions:
 
-- `0.15.0-alpha.N` is a prerelease from the `dev` branch published under the
+- `0.16.0-alpha.N` is a prerelease from the `dev` branch published under the
   `alpha` npm tag.
-- `0.15.0` is a stable release from `main` published under the `latest` npm tag.
+- `0.16.0` is a stable release from `main` published under the `latest` npm tag.
 
 Install stable releases with `npm install -g openmates`. Install prereleases with
 `npm install -g openmates@alpha`.

package/dist/chunk-IWKP55ZB.js

@@ -0,0 +1,205 @@
+// src/remoteAccessCrypto.ts
+import { webcrypto } from "crypto";
+import nacl from "tweetnacl";
+var cryptoApi = globalThis.crypto ?? webcrypto;
+var KEY_BYTES = 32;
+var NONCE_BYTES = 12;
+var MAX_PAYLOAD_BYTES = 200 * 1024;
+var RemoteAccessReplayGuard = class {
+  seen = /* @__PURE__ */ new Set();
+  assertUnused(nonce) {
+    if (this.seen.has(nonce)) throw new Error("replayed remote-access envelope");
+  }
+  markUsed(nonce) {
+    this.seen.add(nonce);
+  }
+};
+async function createRemoteAccessHandshake(projectKey, identity, role) {
+  assertProjectKey(projectKey);
+  validateIdentity(identity);
+  const protocolVersion = protocolVersionForIdentity(identity);
+  const privateKey = cryptoApi.getRandomValues(new Uint8Array(KEY_BYTES));
+  const publicKey = nacl.scalarMult.base(privateKey);
+  const publicKeyText = toBase64Url(publicKey);
+  return {
+    privateKey: toBase64Url(privateKey),
+    handshake: {
+      version: protocolVersion,
+      role,
+      publicKey: publicKeyText,
+      authenticationTag: await authenticateHandshake(projectKey, identity, role, publicKeyText)
+    }
+  };
+}
+async function deriveRemoteAccessSessionKey(projectKey, identity, localRole, localPrivateKey, localHandshake, remoteHandshake) {
+  assertProjectKey(projectKey);
+  validateIdentity(identity);
+  const protocolVersion = protocolVersionForIdentity(identity);
+  const remoteRole = localRole === "requester" ? "source" : "requester";
+  if (localHandshake.role !== localRole || remoteHandshake.role !== remoteRole) {
+    throw new Error("handshake authentication failed");
+  }
+  await verifyHandshake(projectKey, identity, localHandshake);
+  await verifyHandshake(projectKey, identity, remoteHandshake);
+  const privateKey = fromBase64Url(localPrivateKey, KEY_BYTES);
+  const remotePublicKey = fromBase64Url(remoteHandshake.publicKey, KEY_BYTES);
+  const sharedSecret = nacl.scalarMult(privateKey, remotePublicKey);
+  if (sharedSecret.every((value) => value === 0)) throw new Error("handshake shared secret invalid");
+  const requesterPublicKey = localRole === "requester" ? localHandshake.publicKey : remoteHandshake.publicKey;
+  const sourcePublicKey = localRole === "source" ? localHandshake.publicKey : remoteHandshake.publicKey;
+  return hkdf(
+    sharedSecret,
+    new TextEncoder().encode(`openmates:project-remote-access:v${protocolVersion}`),
+    await digest(transcript(identity, requesterPublicKey, sourcePublicKey))
+  );
+}
+async function sealRemoteAccessEnvelope(sessionKey, identity, requestId, direction, plaintext) {
+  assertSessionKey(sessionKey);
+  validateIdentity(identity);
+  const protocolVersion = protocolVersionForIdentity(identity);
+  if (!requestId || plaintext.length > MAX_PAYLOAD_BYTES) throw new Error("invalid remote-access envelope payload");
+  const nonce = cryptoApi.getRandomValues(new Uint8Array(NONCE_BYTES));
+  const key = await cryptoApi.subtle.importKey("raw", arrayBuffer(sessionKey), "AES-GCM", false, ["encrypt"]);
+  const ciphertext = await cryptoApi.subtle.encrypt(
+    { name: "AES-GCM", iv: arrayBuffer(nonce), additionalData: arrayBuffer(envelopeAad(identity, requestId, direction)) },
+    key,
+    arrayBuffer(plaintext)
+  );
+  return { version: protocolVersion, nonce: toBase64Url(nonce), ciphertext: toBase64Url(new Uint8Array(ciphertext)) };
+}
+async function openRemoteAccessEnvelope(sessionKey, identity, requestId, direction, envelope, replayGuard) {
+  assertSessionKey(sessionKey);
+  validateIdentity(identity);
+  if (envelope.version !== protocolVersionForIdentity(identity) || !requestId) throw new Error("invalid remote-access envelope");
+  replayGuard.assertUnused(envelope.nonce);
+  const nonce = fromBase64Url(envelope.nonce, NONCE_BYTES);
+  const ciphertext = fromBase64Url(envelope.ciphertext);
+  if (ciphertext.length > MAX_PAYLOAD_BYTES + 16) throw new Error("invalid remote-access envelope");
+  try {
+    const key = await cryptoApi.subtle.importKey("raw", arrayBuffer(sessionKey), "AES-GCM", false, ["decrypt"]);
+    const plaintext = await cryptoApi.subtle.decrypt(
+      { name: "AES-GCM", iv: arrayBuffer(nonce), additionalData: arrayBuffer(envelopeAad(identity, requestId, direction)) },
+      key,
+      arrayBuffer(ciphertext)
+    );
+    replayGuard.markUsed(envelope.nonce);
+    return new Uint8Array(plaintext);
+  } catch {
+    throw new Error("envelope authentication failed");
+  }
+}
+async function authenticateHandshake(projectKey, identity, role, publicKey) {
+  const key = await cryptoApi.subtle.importKey("raw", arrayBuffer(projectKey), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  const tag = await cryptoApi.subtle.sign("HMAC", key, arrayBuffer(handshakeAad(identity, role, publicKey)));
+  return toBase64Url(new Uint8Array(tag));
+}
+async function verifyHandshake(projectKey, identity, handshake) {
+  if (handshake.version !== protocolVersionForIdentity(identity)) throw new Error("handshake authentication failed");
+  fromBase64Url(handshake.publicKey, KEY_BYTES);
+  const expected = await authenticateHandshake(projectKey, identity, handshake.role, handshake.publicKey);
+  const actualBytes = fromBase64Url(handshake.authenticationTag, KEY_BYTES);
+  const expectedBytes = fromBase64Url(expected, KEY_BYTES);
+  if (!constantTimeEqual(actualBytes, expectedBytes)) throw new Error("handshake authentication failed");
+}
+function handshakeAad(identity, role, publicKey) {
+  const version = protocolVersionForIdentity(identity);
+  return encode([`OMRA-HANDSHAKE-${version}`, ...identityValues(identity), role, publicKey]);
+}
+function transcript(identity, requesterPublicKey, sourcePublicKey) {
+  const version = protocolVersionForIdentity(identity);
+  return encode([`OMRA-TRANSCRIPT-${version}`, ...identityValues(identity), requesterPublicKey, sourcePublicKey]);
+}
+function envelopeAad(identity, requestId, direction) {
+  const version = protocolVersionForIdentity(identity);
+  return encode([`OMRA-ENVELOPE-${version}`, ...identityValues(identity), requestId, direction]);
+}
+function identityValues(identity) {
+  if (protocolVersionForIdentity(identity) === 1) {
+    return [
+      identity.ownerId,
+      identity.projectId,
+      identity.sourceId,
+      identity.sourceSessionId,
+      identity.requestingClientId,
+      identity.keyEpoch
+    ];
+  }
+  return [
+    identity.ownerId,
+    identity.contextType ?? "personal",
+    identity.contextId ?? identity.ownerId,
+    identity.projectId,
+    identity.sourceId,
+    identity.sourceSessionId,
+    identity.requestingClientId,
+    identity.hostMemberId ?? identity.ownerId,
+    identity.hostDeviceId ?? identity.sourceSessionId,
+    identity.requesterMemberId ?? identity.ownerId,
+    identity.requesterDeviceId ?? identity.requestingClientId,
+    identity.keyEpoch
+  ];
+}
+function protocolVersionForIdentity(identity) {
+  return identity.contextType === "team" ? 2 : 1;
+}
+function encode(values) {
+  return new TextEncoder().encode(JSON.stringify(values));
+}
+async function hkdf(secret, salt, info) {
+  const key = await cryptoApi.subtle.importKey("raw", arrayBuffer(secret), "HKDF", false, ["deriveBits"]);
+  const bits = await cryptoApi.subtle.deriveBits(
+    { name: "HKDF", hash: "SHA-256", salt: arrayBuffer(salt), info: arrayBuffer(info) },
+    key,
+    256
+  );
+  return new Uint8Array(bits);
+}
+async function digest(value) {
+  return new Uint8Array(await cryptoApi.subtle.digest("SHA-256", arrayBuffer(value)));
+}
+function validateIdentity(identity) {
+  const strings = identityValues(identity).filter((value) => typeof value === "string");
+  if (identity.contextType !== void 0 && !["personal", "team"].includes(identity.contextType)) {
+    throw new Error("invalid remote-access identity");
+  }
+  if (identity.contextType === "team" && (!identity.contextId || !identity.hostMemberId || !identity.hostDeviceId || !identity.requesterMemberId || !identity.requesterDeviceId)) throw new Error("invalid remote-access identity");
+  if (strings.some((value) => !value || value.length > 128) || !Number.isInteger(identity.keyEpoch) || identity.keyEpoch < 1) {
+    throw new Error("invalid remote-access identity");
+  }
+}
+function assertProjectKey(value) {
+  if (value.length !== KEY_BYTES) throw new Error("Project key must be 32 bytes");
+}
+function assertSessionKey(value) {
+  if (value.length !== KEY_BYTES) throw new Error("source-session key must be 32 bytes");
+}
+function toBase64Url(value) {
+  return Buffer.from(value).toString("base64url");
+}
+function fromBase64Url(value, expectedLength) {
+  if (!value || value.includes("=") || !/^[A-Za-z0-9_-]+$/.test(value)) {
+    throw new Error("invalid remote-access key or envelope field");
+  }
+  const decoded = new Uint8Array(Buffer.from(value, "base64url"));
+  if (toBase64Url(decoded) !== value || expectedLength !== void 0 && decoded.length !== expectedLength) {
+    throw new Error("invalid remote-access key or envelope field");
+  }
+  return decoded;
+}
+function constantTimeEqual(left, right) {
+  if (left.length !== right.length) return false;
+  let difference = 0;
+  for (let index = 0; index < left.length; index += 1) difference |= left[index] ^ right[index];
+  return difference === 0;
+}
+function arrayBuffer(value) {
+  return value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+}
+
+export {
+  RemoteAccessReplayGuard,
+  createRemoteAccessHandshake,
+  deriveRemoteAccessSessionKey,
+  sealRemoteAccessEnvelope,
+  openRemoteAccessEnvelope
+};