openmates 0.15.0-alpha.97 → 0.15.0-alpha.99

package/README.md

@@ -144,14 +144,23 @@ review the spend confirmation before live runs.
 ### Local source bridge
 
 ```bash
-openmates remote-access start --path ./my-repo --source-id repo-1 --local-only
-openmates remote-access status --json
-openmates remote-access search --source repo-1 "TODO" --limit 20
+openmates remote-access
+openmates remote-access --path ./my-repo --path ../shared
+openmates remote-access --path ./my-repo --json
 ```
 
-`openmates remote-access` stores source metadata under
-`~/.openmates/remote-sources.json`, searches with `rg` inside the approved root,
-and does not upload repository files by default.
+The command discovers Git repositories below the current folder by default;
+explicit `--path` values replace that scope. It remains in the foreground,
+reconnects after temporary network loss, and marks sources offline when it
+stops. OpenMates can request bounded directory listings, text search, and
+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.
+
+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
+are stored with owner-only permissions under `~/.openmates/remote-sources.json`.
 
 ## Self-Host Server Management
 

package/dist/{chunk-YRIKOMBJ.js → chunk-3ZTRVFOG.js}

@@ -1165,8 +1165,8 @@ function buildSession(onDisk, masterKey, emailEncryptionKey) {
 var SYNC_CACHE_FILE = "sync_cache.json";
 var LOCAL_TEAM_KEYS_FILE = "team_keys.json";
 function teamKeyStorageId(hashedEmail, teamId) {
-  const digest = createHash3("sha256").update(teamId).digest("hex").slice(0, 32);
-  return `${hashedEmail}:team:${digest}`;
+  const digest2 = createHash3("sha256").update(teamId).digest("hex").slice(0, 32);
+  return `${hashedEmail}:team:${digest2}`;
 }
 function saveLocalTeamKey(hashedEmail, teamId, teamKeyB64) {
   const storageId = teamKeyStorageId(hashedEmail, teamId);
@@ -1224,8 +1224,8 @@ function pruneLocalTeamArtifacts(hashedEmail, teamIds) {
 }
 function syncCacheFile(teamId) {
   if (!teamId) return SYNC_CACHE_FILE;
-  const digest = createHash3("sha256").update(teamId).digest("hex").slice(0, 32);
-  return `sync_cache.team.${digest}.json`;
+  const digest2 = createHash3("sha256").update(teamId).digest("hex").slice(0, 32);
+  return `sync_cache.team.${digest2}.json`;
 }
 function saveSyncCache(cache, teamId) {
   const filePath = join(ensureStateDir(), syncCacheFile(teamId));
@@ -1567,6 +1567,27 @@ var OpenMatesWsClient = class {
     this.socket.on("message", onMessage);
     return () => this.socket.off("message", onMessage);
   }
+  onProjectRemoteAccessRequest(handler) {
+    const onMessage = (rawData) => {
+      try {
+        const parsed = JSON.parse(rawData.toString());
+        if (parsed.type !== "project_remote_access_request") return;
+        const payload = parsed.payload ?? {};
+        if (typeof payload.request_id !== "string" || typeof payload.project_id !== "string" || typeof payload.source_id !== "string" || typeof payload.source_session_id !== "string" || typeof payload.requesting_client_id !== "string" || !["list", "search", "read_text"].includes(String(payload.operation)) || typeof payload.key_epoch !== "number" || typeof payload.encrypted_envelope !== "string") return;
+        void handler(payload);
+      } catch {
+      }
+    };
+    this.socket.on("message", onMessage);
+    return () => this.socket.off("message", onMessage);
+  }
+  waitForClose() {
+    return new Promise((resolve10) => {
+      this.socket.once("close", (code, reason) => {
+        resolve10({ code, reason: reason.toString("utf-8") });
+      });
+    });
+  }
   bufferPassiveTaskUpdateJobs(rawData) {
     try {
       const parsed = JSON.parse(rawData.toString());
@@ -4843,8 +4864,8 @@ function parseStringArray(value) {
 function deriveShortId(record) {
   const prefix = record.short_id_prefix || DEFAULT_STANDALONE_PREFIX;
   const source = record.task_id || `${record.created_at ?? ""}-${record.position ?? ""}`;
-  const digest = createHash7("sha256").update(source).digest("hex").slice(0, 4).toUpperCase();
-  return `${prefix}-${parseInt(digest, 16) % 1e4}`;
+  const digest2 = createHash7("sha256").update(source).digest("hex").slice(0, 4).toUpperCase();
+  return `${prefix}-${parseInt(digest2, 16) % 1e4}`;
 }
 function nowSeconds() {
   return Math.floor(Date.now() / 1e3);
@@ -5842,8 +5863,8 @@ function parseEmbedContentObject(rawContent) {
 }
 async function encodeEmbedContentObject(content) {
   try {
-    const { encode } = await import("@toon-format/toon");
-    return encode(content);
+    const { encode: encode2 } = await import("@toon-format/toon");
+    return encode2(content);
   } catch {
     return JSON.stringify(content);
   }
@@ -7271,7 +7292,7 @@ var OpenMatesClient = class _OpenMatesClient {
       session,
       { chatId, requestId: audioEmbed.embed.embedId }
     );
-    const transcript = transcription.transcript_corrected ?? transcription.transcript ?? transcription.transcript_original ?? "";
+    const transcript2 = transcription.transcript_corrected ?? transcription.transcript ?? transcription.transcript_original ?? "";
     audioEmbed.embed.content = toonEncodeContent({
       app_id: "audio",
       skill_id: "transcribe",
@@ -7302,7 +7323,7 @@ var OpenMatesClient = class _OpenMatesClient {
     const audioMarkdown = [
       `Audio: ${audioEmbed.displayName}`,
       referenceBlock,
-      transcript ? `Transcript: ${transcript}` : null
+      transcript2 ? `Transcript: ${transcript2}` : null
     ].filter((line) => Boolean(line)).join("\n");
     return await this.addIdeaBucketPreparedIdeas({
       chatId,
@@ -7313,12 +7334,12 @@ var OpenMatesClient = class _OpenMatesClient {
       preparedEmbeds: [audioEmbed.embed],
       ideas: [{
         content: audioMarkdown,
-        preview: transcript || audioEmbed.displayName,
+        preview: transcript2 || audioEmbed.displayName,
         payload: {
           type: "audio",
           filename: audioEmbed.displayName,
           embed_ref: embedRef,
-          transcript,
+          transcript: transcript2,
           transcript_original: transcription.transcript_original,
           transcript_corrected: transcription.transcript_corrected,
           use_corrected: transcription.use_corrected,
@@ -10418,6 +10439,14 @@ var OpenMatesClient = class _OpenMatesClient {
     }
     return response.data.source;
   }
+  async openProjectRemoteAccessWebSocket() {
+    const opened = await this.openWsClient({ taskUpdateJobs: false });
+    if (!opened.ownerId) {
+      opened.ws.close();
+      throw new Error("Authenticated user identity unavailable for remote access");
+    }
+    return { ws: opened.ws, ownerId: opened.ownerId };
+  }
   async createProjectItem(projectId, input) {
     this.requireSession();
     const response = await this.http.post(
@@ -18270,8 +18299,8 @@ function parseStringArray2(value) {
 }
 function deriveShortId2(record) {
   const source = record.plan_id || `${record.created_at ?? ""}-${record.updated_at ?? ""}`;
-  const digest = createHash10("sha256").update(source).digest("hex").slice(0, 6).toUpperCase();
-  return `${DEFAULT_PLAN_PREFIX}-${digest}`;
+  const digest2 = createHash10("sha256").update(source).digest("hex").slice(0, 6).toUpperCase();
+  return `${DEFAULT_PLAN_PREFIX}-${digest2}`;
 }
 function nowSeconds2() {
   return Math.floor(Date.now() / 1e3);
@@ -23201,8 +23230,8 @@ function renderVideoTranscriptFullscreen(c) {
   if (url) process.stdout.write(`\x1B[2m${url}\x1B[0m
 `);
   console.log();
-  const transcript = str(c.transcript) ?? str(c.text) ?? "";
-  if (transcript) console.log(transcript);
+  const transcript2 = str(c.transcript) ?? str(c.text) ?? "";
+  if (transcript2) console.log(transcript2);
   else console.log("No transcript available.");
 }
 async function renderHealthSearchPreview(c, ln, _client) {
@@ -67303,8 +67332,22 @@ function clamp(value, min, max) {
 
 // src/remoteAccess.ts
 import { homedir as homedir7 } from "os";
-import { chmodSync as chmodSync4, existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync8, realpathSync, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
-import { spawn as spawn2 } from "child_process";
+import {
+  chmodSync as chmodSync4,
+  closeSync as closeSync2,
+  constants,
+  existsSync as existsSync10,
+  fstatSync,
+  mkdirSync as mkdirSync6,
+  openSync as openSync2,
+  readFileSync as readFileSync8,
+  readdirSync as readdirSync5,
+  readSync as readSync2,
+  realpathSync,
+  statSync as statSync2,
+  writeFileSync as writeFileSync6
+} from "fs";
+import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
 import { join as join8, resolve as resolve8, relative as relative2 } from "path";
 
 // src/projectFileRisk.ts
@@ -67354,9 +67397,492 @@ var BUILT_IN_PATTERNS = [
   { reason: "migration_schema_or_ci_file", patterns: MIGRATION_SCHEMA_CI_PATTERNS }
 ];
 var PROJECT_HIGH_RISK_GLOBS = BUILT_IN_PATTERNS.flatMap((group) => group.patterns);
+function classifyProjectFileRisk(path, userProtectedPatterns = []) {
+  const normalizedPath = normalizePath(path);
+  const reasons = [];
+  for (const group of BUILT_IN_PATTERNS) {
+    if (group.patterns.some((pattern) => matchesPattern2(normalizedPath, pattern))) {
+      reasons.push(group.reason);
+    }
+  }
+  if (userProtectedPatterns.some((pattern) => matchesPattern2(normalizedPath, normalizePath(pattern)))) {
+    reasons.push("user_protected_pattern");
+  }
+  return { isHighRisk: reasons.length > 0, reasons: [...new Set(reasons)] };
+}
+function normalizePath(path) {
+  return path.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function matchesPattern2(path, pattern) {
+  const regex = new RegExp(`^${globToRegex(pattern)}$`);
+  return regex.test(path);
+}
+function globToRegex(pattern) {
+  let output = "";
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    const next = pattern[index + 1];
+    if (char === "*" && next === "*") {
+      output += ".*";
+      index += 1;
+    } else if (char === "*") {
+      output += "[^/]*";
+    } else {
+      output += escapeRegex(char ?? "");
+    }
+  }
+  return output;
+}
+function escapeRegex(value) {
+  return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+
+// src/remoteAccessCrypto.ts
+import { webcrypto as webcrypto6 } from "crypto";
+import nacl2 from "tweetnacl";
+var cryptoApi4 = globalThis.crypto ?? webcrypto6;
+var PROTOCOL_VERSION = 1;
+var KEY_BYTES = 32;
+var NONCE_BYTES = 12;
+var MAX_PAYLOAD_BYTES = 200 * 1024;
+async function createRemoteAccessHandshake(projectKey, identity, role) {
+  assertProjectKey(projectKey);
+  validateIdentity(identity);
+  const privateKey = cryptoApi4.getRandomValues(new Uint8Array(KEY_BYTES));
+  const publicKey = nacl2.scalarMult.base(privateKey);
+  const publicKeyText = toBase64Url(publicKey);
+  return {
+    privateKey: toBase64Url(privateKey),
+    handshake: {
+      version: PROTOCOL_VERSION,
+      role,
+      publicKey: publicKeyText,
+      authenticationTag: await authenticateHandshake(projectKey, identity, role, publicKeyText)
+    }
+  };
+}
+async function deriveRemoteAccessSessionKey(projectKey, identity, localRole, localPrivateKey, localHandshake, remoteHandshake) {
+  assertProjectKey(projectKey);
+  validateIdentity(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 = nacl2.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:v1"),
+    await digest(transcript(identity, requesterPublicKey, sourcePublicKey))
+  );
+}
+async function sealRemoteAccessEnvelope(sessionKey, identity, requestId, direction, plaintext) {
+  assertSessionKey(sessionKey);
+  validateIdentity(identity);
+  if (!requestId || plaintext.length > MAX_PAYLOAD_BYTES) throw new Error("invalid remote-access envelope payload");
+  const nonce = cryptoApi4.getRandomValues(new Uint8Array(NONCE_BYTES));
+  const key = await cryptoApi4.subtle.importKey("raw", arrayBuffer(sessionKey), "AES-GCM", false, ["encrypt"]);
+  const ciphertext = await cryptoApi4.subtle.encrypt(
+    { name: "AES-GCM", iv: arrayBuffer(nonce), additionalData: arrayBuffer(envelopeAad(identity, requestId, direction)) },
+    key,
+    arrayBuffer(plaintext)
+  );
+  return { version: PROTOCOL_VERSION, nonce: toBase64Url(nonce), ciphertext: toBase64Url(new Uint8Array(ciphertext)) };
+}
+async function authenticateHandshake(projectKey, identity, role, publicKey) {
+  const key = await cryptoApi4.subtle.importKey("raw", arrayBuffer(projectKey), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  const tag = await cryptoApi4.subtle.sign("HMAC", key, arrayBuffer(handshakeAad(identity, role, publicKey)));
+  return toBase64Url(new Uint8Array(tag));
+}
+async function verifyHandshake(projectKey, identity, handshake) {
+  if (handshake.version !== PROTOCOL_VERSION) 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) {
+  return encode(["OMRA-HANDSHAKE-1", ...identityValues(identity), role, publicKey]);
+}
+function transcript(identity, requesterPublicKey, sourcePublicKey) {
+  return encode(["OMRA-TRANSCRIPT-1", ...identityValues(identity), requesterPublicKey, sourcePublicKey]);
+}
+function envelopeAad(identity, requestId, direction) {
+  return encode(["OMRA-ENVELOPE-1", ...identityValues(identity), requestId, direction]);
+}
+function identityValues(identity) {
+  return [
+    identity.ownerId,
+    identity.projectId,
+    identity.sourceId,
+    identity.sourceSessionId,
+    identity.requestingClientId,
+    identity.keyEpoch
+  ];
+}
+function encode(values) {
+  return new TextEncoder().encode(JSON.stringify(values));
+}
+async function hkdf(secret, salt, info) {
+  const key = await cryptoApi4.subtle.importKey("raw", arrayBuffer(secret), "HKDF", false, ["deriveBits"]);
+  const bits = await cryptoApi4.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 cryptoApi4.subtle.digest("SHA-256", arrayBuffer(value)));
+}
+function validateIdentity(identity) {
+  const strings = [identity.ownerId, identity.projectId, identity.sourceId, identity.sourceSessionId, identity.requestingClientId];
+  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);
+}
 
 // src/remoteAccess.ts
+var DEFAULT_MAX_SEARCH_RESULTS = 20;
+var MAX_SEARCH_SNIPPET_CHARS = 500;
+var SEARCH_TIMEOUT_MS = 1e4;
+var MAX_APPROVED_ROOTS = 16;
+var DEFAULT_MAX_DIRECTORY_ENTRIES = 500;
+var DEFAULT_MAX_READ_BYTES = 200 * 1024;
+var DEFAULT_MAX_READ_LINES = 4e3;
+var BINARY_PROBE_BYTES = 8 * 1024;
 var MAX_SOURCE_ID_LENGTH = 128;
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".pdf",
+  ".zip",
+  ".gz",
+  ".tar",
+  ".mp3",
+  ".mp4",
+  ".mov"
+]);
+function resolveRemoteAccessRoots(pathFlag, cwd = process.cwd()) {
+  const requested = pathFlag === void 0 ? [cwd] : pathFlag.split("\n");
+  if (requested.some((value) => !value)) throw new Error("--path requires a non-empty folder value");
+  if (requested.length > MAX_APPROVED_ROOTS) {
+    throw new Error(`remote-access accepts at most ${MAX_APPROVED_ROOTS} approved roots`);
+  }
+  const roots = [];
+  for (const value of requested) {
+    const candidate = resolve8(cwd, value);
+    if (!existsSync10(candidate) || !statSync2(candidate).isDirectory()) {
+      throw new Error(`Remote source path does not exist or is not a directory: ${candidate}`);
+    }
+    const canonical = realpathSync(candidate);
+    if (!roots.includes(canonical)) roots.push(canonical);
+  }
+  return roots;
+}
+function discoverRemoteAccessRepositories(roots) {
+  const repositoryRoots = /* @__PURE__ */ new Set();
+  const permissionDenied = [];
+  const visit = (directory, approvedRoot) => {
+    let entries;
+    try {
+      entries = readdirSync5(directory, { withFileTypes: true });
+    } catch (error) {
+      const code = error.code;
+      if (code === "EACCES" || code === "EPERM") {
+        permissionDenied.push(relative2(approvedRoot, directory) || ".");
+        return;
+      }
+      throw error;
+    }
+    if (entries.some((entry) => entry.name === ".git" && (entry.isDirectory() || entry.isFile()))) {
+      repositoryRoots.add(realpathSync(directory));
+    }
+    for (const entry of entries) {
+      if (entry.name === ".git" || entry.isSymbolicLink() || !entry.isDirectory()) continue;
+      visit(join8(directory, entry.name), approvedRoot);
+    }
+  };
+  for (const root of roots) visit(root, root);
+  return {
+    repositories: [...repositoryRoots].sort().map((rootPath) => ({ rootPath, displayName: rootPath.split(/[\\/]/).filter(Boolean).pop() ?? rootPath })),
+    permissionDenied: permissionDenied.sort()
+  };
+}
+function remoteAccessSourceType(rootPath) {
+  const gitMarker = join8(rootPath, ".git");
+  return existsSync10(gitMarker) ? "local_git_repository" : "local_folder";
+}
+function listRemoteAccessDirectory(options) {
+  const root = realpathSync(options.sourceRoot);
+  const directory = resolveApprovedPath(root, options.relativePath);
+  if (!statSync2(directory).isDirectory()) throw new Error("Remote source path is not a directory");
+  const maxEntries = options.maxEntries ?? DEFAULT_MAX_DIRECTORY_ENTRIES;
+  if (!Number.isInteger(maxEntries) || maxEntries <= 0 || maxEntries > DEFAULT_MAX_DIRECTORY_ENTRIES) {
+    throw new Error(`Remote directory entry limit must be between 1 and ${DEFAULT_MAX_DIRECTORY_ENTRIES}`);
+  }
+  const entries = [];
+  let omitted = 0;
+  let excluded = 0;
+  for (const entry of readdirSync5(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    const entryPath = relative2(root, join8(directory, entry.name)).replace(/\\/g, "/");
+    if (entry.name === ".git" || entry.isSymbolicLink() || isGitIgnoredPath(root, entryPath) || classifyProjectFileRisk(entryPath, options.userProtectedPatterns ?? []).isHighRisk || entry.isFile() && isBinaryFile(join8(directory, entry.name))) {
+      excluded += 1;
+      continue;
+    }
+    if (!entry.isFile() && !entry.isDirectory()) {
+      excluded += 1;
+      continue;
+    }
+    if (entries.length >= maxEntries) {
+      omitted += 1;
+      continue;
+    }
+    entries.push({ path: entryPath, kind: entry.isDirectory() ? "directory" : "file" });
+  }
+  return { entries, omitted, excluded };
+}
+function readRemoteAccessTextFile(options) {
+  const root = realpathSync(options.sourceRoot);
+  const normalizedRelative = options.relativePath.replace(/\\/g, "/");
+  if (classifyProjectFileRisk(normalizedRelative, options.userProtectedPatterns ?? []).isHighRisk) {
+    throw new Error("Remote source file is protected");
+  }
+  if (isGitIgnoredPath(root, normalizedRelative)) throw new Error("Remote source file is ignored");
+  const requested = resolveApprovedPath(root, normalizedRelative);
+  options.beforeOpen?.();
+  const maxBytes = normalizeBound(options.maxBytes, DEFAULT_MAX_READ_BYTES, "byte");
+  const maxLines = normalizeBound(options.maxLines, DEFAULT_MAX_READ_LINES, "line");
+  let descriptor;
+  try {
+    descriptor = openSync2(requested, constants.O_RDONLY | constants.O_NOFOLLOW);
+    const openedPath = openedDescriptorPath(descriptor, requested);
+    assertInsideRoot(root, openedPath);
+    const stats = fstatSync(descriptor);
+    if (!stats.isFile()) throw new Error("Remote source path is not a regular file");
+    const bytesToRead = Math.min(stats.size, maxBytes + 1);
+    const buffer = Buffer.alloc(bytesToRead);
+    const bytesRead = readSync2(descriptor, buffer, 0, bytesToRead, 0);
+    const bytes = new Uint8Array(buffer.subarray(0, bytesRead));
+    if (bytes.subarray(0, BINARY_PROBE_BYTES).includes(0)) throw new Error("Remote source file is binary or unsupported");
+    let decoded;
+    try {
+      decoded = new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, Math.min(bytes.length, maxBytes)));
+    } catch {
+      throw new Error("Remote source file is binary or unsupported");
+    }
+    const lines = decoded.split(/(?<=\n)/);
+    const content = lines.slice(0, maxLines).join("");
+    return {
+      content,
+      truncated: stats.size > maxBytes || lines.length > maxLines,
+      sizeBytes: stats.size,
+      lineCount: decoded.length === 0 ? 0 : decoded.split("\n").length
+    };
+  } catch (error) {
+    const code = error.code;
+    if (code === "ELOOP") throw new Error("Remote source path is a symbolic link");
+    throw error;
+  } finally {
+    if (descriptor !== void 0) closeSync2(descriptor);
+  }
+}
+async function runRemoteAccessBridge(options) {
+  let reconnectAttempt = 0;
+  while (!options.signal.aborted) {
+    options.onLifecycle?.({ state: reconnectAttempt === 0 ? "connecting" : "reconnecting", attempt: reconnectAttempt });
+    let ws = null;
+    let removeRequestListener = null;
+    let heartbeatTimer = null;
+    try {
+      const opened = await options.client.openProjectRemoteAccessWebSocket();
+      ws = opened.ws;
+      await ws.sendAsync("project_remote_access_register", {
+        source_session_id: options.sourceSessionId,
+        confirmed_takeover: options.confirmedTakeover === true,
+        bindings: options.bindings.map((binding) => ({
+          project_id: binding.source.projectId,
+          source_id: binding.source.sourceId,
+          capabilities: ["read", "search", "import"],
+          key_epoch: binding.keyEpoch
+        }))
+      });
+      await ws.waitForMessage("project_remote_access_registered", void 0, 2e4);
+      reconnectAttempt = 0;
+      options.onLifecycle?.({ state: "connected" });
+      removeRequestListener = ws.onProjectRemoteAccessRequest((frame) => {
+        void handleLiveRemoteAccessRequest(ws, opened.ownerId, options.sourceSessionId, options.bindings, frame);
+      });
+      heartbeatTimer = setInterval(() => {
+        void ws?.sendAsync("project_remote_access_heartbeat", { source_session_id: options.sourceSessionId });
+      }, 15e3);
+      await Promise.race([ws.waitForClose(), waitForAbort2(options.signal)]);
+      if (options.signal.aborted) {
+        await ws.sendAsync("project_remote_access_disconnect", { source_session_id: options.sourceSessionId }).catch(() => void 0);
+        options.onLifecycle?.({ state: "disconnected" });
+        return;
+      }
+    } catch (error) {
+      if (error instanceof WebSocketProtocolError) throw error;
+      const message = error instanceof Error ? error.message : String(error);
+      if (/session expired|invalid|not logged in/i.test(message)) throw error;
+    } finally {
+      if (heartbeatTimer) clearInterval(heartbeatTimer);
+      removeRequestListener?.();
+      ws?.close();
+    }
+    reconnectAttempt += 1;
+    const delayMs = reconnectDelayMs(reconnectAttempt);
+    options.onLifecycle?.({ state: "reconnecting", attempt: reconnectAttempt, delayMs });
+    await waitForAbort2(options.signal, delayMs);
+  }
+}
+async function handleLiveRemoteAccessRequest(ws, ownerId, sourceSessionId, bindings, frame) {
+  const binding = bindings.find(
+    (item) => item.source.sourceId === frame.source_id && item.source.projectId === frame.project_id
+  );
+  if (!binding || frame.source_session_id !== sourceSessionId || frame.key_epoch !== binding.keyEpoch) return;
+  const bootstrapText = await decryptWithAesGcmCombined(frame.encrypted_envelope, binding.projectKey);
+  if (!bootstrapText) return;
+  let bootstrap;
+  try {
+    bootstrap = JSON.parse(bootstrapText);
+  } catch {
+    return;
+  }
+  if (!bootstrap.requesting_client_id || bootstrap.requesting_client_id !== frame.requesting_client_id || !bootstrap.requester_handshake || bootstrap.operation !== frame.operation || !bootstrap.arguments) return;
+  const identity = {
+    ownerId,
+    projectId: frame.project_id,
+    sourceId: frame.source_id,
+    sourceSessionId,
+    requestingClientId: bootstrap.requesting_client_id,
+    keyEpoch: binding.keyEpoch
+  };
+  try {
+    const sourceHandshake = await createRemoteAccessHandshake(binding.projectKey, identity, "source");
+    const sessionKey = await deriveRemoteAccessSessionKey(
+      binding.projectKey,
+      identity,
+      "source",
+      sourceHandshake.privateKey,
+      sourceHandshake.handshake,
+      bootstrap.requester_handshake
+    );
+    let response;
+    try {
+      response = {
+        ok: true,
+        result: await executeRemoteAccessOperation(binding.source.rootPath, frame.operation, bootstrap.arguments)
+      };
+    } catch (error) {
+      response = { ok: false, error: remoteAccessOperationErrorCode(error) };
+    }
+    const envelope = await sealRemoteAccessEnvelope(
+      sessionKey,
+      identity,
+      frame.request_id,
+      "result",
+      new TextEncoder().encode(JSON.stringify(response))
+    );
+    await ws.sendAsync("project_remote_access_complete", {
+      source_session_id: sourceSessionId,
+      project_id: frame.project_id,
+      source_id: frame.source_id,
+      request_id: frame.request_id,
+      key_epoch: binding.keyEpoch,
+      encrypted_envelope: JSON.stringify({ source_handshake: sourceHandshake.handshake, envelope })
+    });
+  } catch {
+  }
+}
+async function executeRemoteAccessOperation(sourceRoot, operation, args) {
+  const relativePath = typeof args.path === "string" ? args.path : ".";
+  if (operation === "list") {
+    return listRemoteAccessDirectory({ sourceRoot, relativePath });
+  }
+  if (operation === "read_text") {
+    return readRemoteAccessTextFile({ sourceRoot, relativePath });
+  }
+  const query = typeof args.query === "string" ? args.query : "";
+  if (!query) throw new Error("Search query is required");
+  return searchRemoteSource({ query, sourceRoot, runRg: runRgCommand });
+}
+function remoteAccessOperationErrorCode(error) {
+  const message = error instanceof Error ? error.message : "";
+  if (/protected|ignored/i.test(message)) return "protected_path";
+  if (/binary|unsupported/i.test(message)) return "unsupported_file";
+  if (/symbolic link|approved source root|not a directory|not a regular file|ENOENT/i.test(message)) return "invalid_path";
+  if (/Search query is required/i.test(message)) return "search_query_required";
+  return "operation_failed";
+}
+function isGitIgnoredPath(sourceRoot, relativePath) {
+  if (!existsSync10(join8(sourceRoot, ".git"))) return false;
+  const result = spawnSync2("git", ["check-ignore", "--quiet", "--", relativePath], {
+    cwd: sourceRoot,
+    stdio: "ignore"
+  });
+  if (result.error) throw result.error;
+  if (result.status === 0) return true;
+  if (result.status === 1) return false;
+  throw new Error("Could not evaluate Git ignored-file policy");
+}
+function reconnectDelayMs(attempt) {
+  const base = Math.min(3e4, 1e3 * 2 ** Math.max(0, attempt - 1));
+  return Math.round(base * (0.8 + Math.random() * 0.4));
+}
+function waitForAbort2(signal, timeoutMs) {
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolvePromise) => {
+    const onAbort = () => {
+      if (timer) clearTimeout(timer);
+      resolvePromise();
+    };
+    const timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolvePromise();
+    }, timeoutMs);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
 function resolveRemoteCachePath(sourceId, homeDirectory = homedir7()) {
   assertSafeSourceId(sourceId);
   return join8(homeDirectory, ".openmates", "remote-cache", sourceId);
@@ -67377,7 +67903,7 @@ function startRemoteAccessSource(input) {
     rootPath,
     displayName: input.displayName ?? input.sourceId,
     cachePath: resolveRemoteCachePath(input.sourceId, homeDirectory),
-    status: "connected",
+    status: "offline",
     createdAt: now,
     updatedAt: now
   };
@@ -67401,11 +67927,190 @@ function listRemoteAccessSources(homeDirectory = homedir7()) {
     throw new Error(`Failed to read remote source store at ${filePath}: ${message}`);
   }
 }
+async function searchRemoteSource(options) {
+  const sourceRoot = resolve8(options.sourceRoot);
+  const maxResults = normalizeMaxResults(options.maxResults);
+  const output = await options.runRg(
+    buildRgSearchArgs(options.query, options.userProtectedPatterns ?? []),
+    sourceRoot,
+    maxResults + 1
+  );
+  const matches2 = [];
+  let omitted = 0;
+  let excluded = 0;
+  for (const line of output.split("\n")) {
+    if (!line.trim()) continue;
+    const match = parseRgMatch(line);
+    if (!match) continue;
+    if (shouldExcludePath(sourceRoot, match.path, options.userProtectedPatterns ?? [])) {
+      excluded += 1;
+      continue;
+    }
+    if (matches2.length >= maxResults) {
+      omitted += 1;
+      continue;
+    }
+    matches2.push(match);
+  }
+  return { matches: matches2, omitted, excluded };
+}
 function assertSafeSourceId(sourceId) {
   if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(sourceId) || sourceId.length > MAX_SOURCE_ID_LENGTH) {
     throw new Error("Remote source ID must be 1-128 characters and contain only letters, numbers, dot, underscore, or hyphen");
   }
 }
+function normalizeMaxResults(value) {
+  const maxResults = value ?? DEFAULT_MAX_SEARCH_RESULTS;
+  if (!Number.isInteger(maxResults) || maxResults <= 0 || maxResults > DEFAULT_MAX_SEARCH_RESULTS) {
+    throw new Error(`Remote source search limit must be between 1 and ${DEFAULT_MAX_SEARCH_RESULTS}`);
+  }
+  return maxResults;
+}
+function buildRgSearchArgs(query, userProtectedPatterns) {
+  const args = ["--json", "--line-number"];
+  for (const pattern of [...PROJECT_HIGH_RISK_GLOBS, ...binaryRgGlobs(), ...userProtectedPatterns]) {
+    args.push("--glob", `!${pattern.replace(/\\/g, "/")}`);
+  }
+  args.push("--", query, ".");
+  return args;
+}
+function binaryRgGlobs() {
+  return [...BINARY_EXTENSIONS].flatMap((extension) => [`*${extension}`, `**/*${extension}`]);
+}
+async function runRgCommand(args, cwd, maxOutputMatches) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn2("rg", args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutLines = [];
+    const stderrChunks = [];
+    let pendingStdout = "";
+    let matchCount = 0;
+    let killedForCap = false;
+    let timedOut = false;
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+    }, SEARCH_TIMEOUT_MS);
+    child.stdout.setEncoding("utf-8");
+    child.stdout.on("data", (chunk) => {
+      pendingStdout += chunk;
+      const lines = pendingStdout.split("\n");
+      pendingStdout = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line) continue;
+        stdoutLines.push(line);
+        if (line.includes('"type":"match"')) {
+          matchCount += 1;
+        }
+        if (maxOutputMatches !== void 0 && matchCount >= maxOutputMatches) {
+          killedForCap = true;
+          child.kill();
+          break;
+        }
+      }
+    });
+    child.stderr.setEncoding("utf-8");
+    child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+    child.on("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timeout);
+      if (pendingStdout) stdoutLines.push(pendingStdout);
+      if (timedOut) {
+        reject(new Error("Remote source search timed out"));
+        return;
+      }
+      if (code === 0 || code === 1 || killedForCap) {
+        resolvePromise(stdoutLines.join("\n"));
+        return;
+      }
+      reject(new Error(`rg failed with exit code ${code}: ${stderrChunks.join("").trim()}`));
+    });
+  });
+}
+function shouldExcludePath(sourceRoot, relativePath, userProtectedPatterns) {
+  if (!isPathInsideRoot(sourceRoot, relativePath)) return true;
+  if (isBinaryPath(relativePath)) return true;
+  return classifyProjectFileRisk(relativePath, userProtectedPatterns).isHighRisk;
+}
+function isPathInsideRoot(sourceRoot, relativePath) {
+  const resolvedPath = resolve8(sourceRoot, relativePath);
+  const relation = relative2(sourceRoot, resolvedPath);
+  return relation === "" || !relation.startsWith("..") && !resolve8(relation).startsWith("/..");
+}
+function isBinaryPath(path) {
+  const lowerPath = path.toLowerCase();
+  for (const extension of BINARY_EXTENSIONS) {
+    if (lowerPath.endsWith(extension)) return true;
+  }
+  return false;
+}
+function parseRgMatch(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (parsed.type !== "match") return null;
+    const path = parsed.data?.path?.text;
+    const lineNumber = parsed.data?.line_number;
+    const snippet = parsed.data?.lines?.text;
+    if (typeof path !== "string" || typeof lineNumber !== "number" || typeof snippet !== "string") {
+      return null;
+    }
+    return { path, line: lineNumber, snippet: snippet.slice(0, MAX_SEARCH_SNIPPET_CHARS) };
+  } catch {
+    return null;
+  }
+}
+function resolveApprovedPath(sourceRoot, relativePath) {
+  if (!relativePath || relativePath.includes("\0")) throw new Error("Remote source path is invalid");
+  const lexical = resolve8(sourceRoot, relativePath);
+  assertInsideRoot(sourceRoot, lexical);
+  const canonical = realpathSync(lexical);
+  assertInsideRoot(sourceRoot, canonical);
+  return canonical;
+}
+function assertInsideRoot(sourceRoot, path) {
+  const relation = relative2(sourceRoot, path);
+  if (relation.startsWith("..") || resolve8(sourceRoot, relation) !== resolve8(path)) {
+    throw new Error("Remote source path escapes the approved source root");
+  }
+}
+function openedDescriptorPath(descriptor, requestedPath) {
+  const procPath = `/proc/self/fd/${descriptor}`;
+  if (existsSync10(procPath)) return realpathSync(procPath);
+  return realpathSync(requestedPath);
+}
+function isBinaryFile(path) {
+  let descriptor;
+  try {
+    descriptor = openSync2(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    const stats = fstatSync(descriptor);
+    const buffer = Buffer.alloc(Math.min(stats.size, BINARY_PROBE_BYTES));
+    const bytesRead = readSync2(descriptor, buffer, 0, buffer.length, 0);
+    const bytes = new Uint8Array(buffer.subarray(0, bytesRead));
+    if (bytes.includes(0)) return true;
+    try {
+      new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+      return false;
+    } catch {
+      return true;
+    }
+  } catch {
+    return true;
+  } finally {
+    if (descriptor !== void 0) closeSync2(descriptor);
+  }
+}
+function normalizeBound(value, maximum, label) {
+  const result = value ?? maximum;
+  if (!Number.isInteger(result) || result <= 0 || result > maximum) {
+    throw new Error(`Remote source ${label} limit must be between 1 and ${maximum}`);
+  }
+  return result;
+}
 function remoteAccessStorePath(homeDirectory) {
   return join8(homeDirectory, ".openmates", "remote-sources.json");
 }
@@ -67434,7 +68139,7 @@ function assertRemoteAccessSourceRecord(value, index) {
 }
 
 // src/selfUpdate.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 import { readFileSync as readFileSync9 } from "fs";
 var PACKAGE_NAME = "openmates";
 var DEFAULT_TARGET = "latest";
@@ -67481,7 +68186,7 @@ function checkSelfUpdateStatus(plan) {
 }
 function runSelfUpdate(plan, options = {}) {
   if (plan.dryRun) return;
-  const result = spawnSync2(plan.command, plan.args, {
+  const result = spawnSync3(plan.command, plan.args, {
     encoding: "utf-8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -67503,7 +68208,7 @@ function resolveTargetVersion(target) {
   if (/^\d+\.\d+\.\d+(?:[-+][a-zA-Z0-9._-]+)?$/.test(target)) {
     return { version: target, error: null };
   }
-  const result = spawnSync2(commandName("npm"), ["view", `${PACKAGE_NAME}@${target}`, "version"], {
+  const result = spawnSync3(commandName("npm"), ["view", `${PACKAGE_NAME}@${target}`, "version"], {
     encoding: "utf-8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -69940,34 +70645,62 @@ async function handleRemoteAccess(client, subcommand, rest, flags) {
       printRemoteAccessHelp();
       return;
     }
-    const rootPath = parseRemoteAccessRootPath(flags);
-    const sourceId = typeof flags["source-id"] === "string" ? flags["source-id"] : randomUUID10();
-    const projectId = typeof flags.project === "string" ? flags.project : void 0;
-    validateRemoteSourceRegistrationFlags(projectId, flags);
-    const sourceType = parseRemoteAccessSourceType(flags.type);
-    const displayName = typeof flags.name === "string" ? flags.name : sourceId;
-    const source = startRemoteAccessSource({ sourceId, projectId, rootPath, sourceType, displayName });
-    await maybeRegisterRemoteSource(client, source, flags);
-    if (flags.json === true) {
-      printJson2({ source, foreground: true });
-    } else {
-      console.log(`Remote access foreground session started: ${source.sourceId}`);
-      console.log(`Root: ${source.rootPath}`);
-      console.log(`Cache: ${source.cachePath}`);
+    assertRemoteAccessPublicFlags(flags);
+    const roots = resolveRemoteAccessRoots(typeof flags.path === "string" ? flags.path : void 0);
+    const discovery = discoverRemoteAccessRepositories(roots);
+    const candidateRoots = typeof flags.path === "string" ? roots : discovery.repositories.length > 0 ? discovery.repositories.map((candidate) => candidate.rootPath) : roots;
+    const masterKey = client.getMasterKeyBytes();
+    const projects = await loadProjects(client, masterKey, flags);
+    const bindings = await resolveRemoteAccessBindings(client, masterKey, projects, candidateRoots, flags);
+    if (bindings.length === 0) throw new Error("No Project folders were approved for remote access.");
+    const sourceSessionId = randomUUID10();
+    const controller = new AbortController();
+    const stop = () => controller.abort();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    if (flags.json !== true) {
+      console.log(`Remote access connecting ${bindings.length} Project source${bindings.length === 1 ? "" : "s"}.`);
       console.log("Keep this terminal open. For long-running work, start it inside zellij, tmux, or screen.");
+      if (discovery.permissionDenied.length > 0) {
+        console.warn(`Skipped ${discovery.permissionDenied.length} unreadable folder${discovery.permissionDenied.length === 1 ? "" : "s"}.`);
+      }
+    }
+    try {
+      let confirmedTakeover = false;
+      while (!controller.signal.aborted) {
+        try {
+          await runRemoteAccessBridge({
+            client,
+            sourceSessionId,
+            bindings,
+            signal: controller.signal,
+            confirmedTakeover,
+            onLifecycle: (event) => {
+              if (flags.json === true) printJson2({ type: "remote_access_lifecycle", ...event });
+              else if (event.state === "connected") console.log("Remote access connected.");
+              else if (event.state === "reconnecting") console.log(`Remote access reconnecting in ${event.delayMs ?? 0}ms.`);
+              else if (event.state === "disconnected") console.log("Remote access disconnected.");
+            }
+          });
+          break;
+        } catch (error) {
+          if (!(error instanceof WebSocketProtocolError) || error.code !== "takeover_confirmation_required") throw error;
+          if (flags.json === true || !process.stdin.isTTY) {
+            throw new Error("Another remote-access process owns one of these sources; rerun interactively to confirm takeover.");
+          }
+          const answer = (await promptLine2("Another process owns one of these sources. Take over? [y/N] ")).trim().toLowerCase();
+          if (answer !== "y" && answer !== "yes") throw new Error("Remote access takeover cancelled.");
+          confirmedTakeover = true;
+        }
+      }
+    } finally {
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
     }
     return;
   }
   throw new Error("openmates remote-access does not accept public subcommands. Run 'openmates remote-access --help'.");
 }
-function parseRemoteAccessRootPath(flags) {
-  const rootPath = flags.path;
-  if (rootPath === void 0) return process.cwd();
-  if (typeof rootPath !== "string") {
-    throw new Error("--path requires a folder value.");
-  }
-  return rootPath;
-}
 function parsePositiveIntegerFlag(value, flagName) {
   if (value === void 0) return void 0;
   if (typeof value !== "string") {
@@ -69983,38 +70716,101 @@ function parseResponseTimeoutMs2(flags) {
   const seconds = parsePositiveIntegerFlag(flags["response-timeout-seconds"], "--response-timeout-seconds");
   return seconds === void 0 ? void 0 : seconds * 1e3;
 }
-function parseRemoteAccessSourceType(value) {
-  if (value === void 0) return "local_folder";
-  if (value === "local_folder" || value === "local_git_repository") {
-    return value;
+function assertRemoteAccessPublicFlags(flags) {
+  const internalFlags = ["source-id", "project", "type", "local-only", "encrypted-display-name", "encrypted-metadata"];
+  const supplied = internalFlags.filter((name) => flags[name] !== void 0);
+  if (supplied.length > 0) {
+    throw new Error(`Unsupported remote-access option${supplied.length === 1 ? "" : "s"}: ${supplied.map((name) => `--${name}`).join(", ")}`);
   }
-  throw new Error("--type must be one of local_folder or local_git_repository for the local remote-access bridge");
 }
-async function maybeRegisterRemoteSource(client, source, flags) {
-  if (!source.projectId || flags["local-only"] === true) return;
-  const encryptedDisplayName = flags["encrypted-display-name"];
-  const encryptedMetadata = flags["encrypted-metadata"];
-  if (typeof encryptedDisplayName !== "string" || typeof encryptedMetadata !== "string") {
-    throw new Error("Missing encrypted Project source metadata after registration validation");
+async function resolveRemoteAccessBindings(client, masterKey, projects, candidateRoots, flags) {
+  const stored = listRemoteAccessSources();
+  const resolved = [];
+  const unresolved = [];
+  for (const rootPath of candidateRoots) {
+    const existingSource = stored.find((source) => source.rootPath === rootPath && source.projectId);
+    const project = existingSource ? projects.find((item) => item.projectId === existingSource.projectId) : void 0;
+    if (existingSource && project) {
+      resolved.push({ rootPath, project, sourceId: existingSource.sourceId });
+    } else {
+      unresolved.push(rootPath);
+    }
+  }
+  if (unresolved.length > 0) {
+    if (flags.json === true || !process.stdin.isTTY) {
+      throw new Error(`Remote access needs interactive Project review for: ${unresolved.join(", ")}`);
+    }
+    console.log("The following folders need OpenMates Projects:");
+    unresolved.forEach((rootPath) => console.log(`  - ${rootPath}`));
+    const answer = (await promptLine2(`Create ${unresolved.length} missing Project${unresolved.length === 1 ? "" : "s"}? [y/N] `)).trim().toLowerCase();
+    if (answer !== "y" && answer !== "yes") throw new Error("Remote access Project creation cancelled.");
+    for (const rootPath of unresolved) {
+      const project = await createEncryptedRemoteAccessProject(client, masterKey, basename3(rootPath));
+      resolved.push({ rootPath, project, sourceId: randomUUID10() });
+    }
+  }
+  const bindings = [];
+  for (const item of resolved) {
+    const sourceType = remoteAccessSourceType(item.rootPath);
+    const source = startRemoteAccessSource({
+      sourceId: item.sourceId,
+      projectId: item.project.projectId,
+      rootPath: item.rootPath,
+      sourceType,
+      displayName: basename3(item.rootPath)
+    });
+    const remoteSources = await client.listProjectSources(item.project.projectId);
+    const remoteSource = remoteSources.find((entry) => entry.source_id === source.sourceId);
+    if (!remoteSource) {
+      const timestamp = Math.floor(Date.now() / 1e3);
+      await client.createProjectSource(item.project.projectId, {
+        source_id: source.sourceId,
+        source_type: sourceType,
+        encrypted_display_name: await encryptWithAesGcmCombined(source.displayName, item.project.projectKey),
+        encrypted_metadata: await encryptWithAesGcmCombined(
+          JSON.stringify({ root: source.rootPath, binding_root: source.rootPath }),
+          item.project.projectKey
+        ),
+        capabilities: ["read", "search", "import"],
+        status: "offline",
+        created_at: timestamp,
+        updated_at: timestamp
+      });
+    }
+    bindings.push({ source, projectKey: item.project.projectKey, keyEpoch: 1 });
   }
+  return bindings;
+}
+async function createEncryptedRemoteAccessProject(client, masterKey, name) {
+  const projectKey = randomBytes8(32);
+  const projectId = randomUUID10();
   const timestamp = Math.floor(Date.now() / 1e3);
-  await client.createProjectSource(source.projectId, {
-    source_id: source.sourceId,
-    source_type: source.sourceType,
-    encrypted_display_name: encryptedDisplayName,
-    encrypted_metadata: encryptedMetadata,
-    capabilities: ["read", "search", "import"],
-    status: source.status,
+  const payload = {
+    project_id: projectId,
+    encrypted_project_key: await encryptBytesWithAesGcm(projectKey, masterKey),
+    encrypted_name: await encryptWithAesGcmCombined(name, projectKey),
+    encrypted_description: await encryptWithAesGcmCombined("", projectKey),
+    encrypted_icon: await encryptWithAesGcmCombined("folder", projectKey),
+    encrypted_color: await encryptWithAesGcmCombined("default", projectKey),
+    pinned: false,
+    archived: false,
     created_at: timestamp,
-    updated_at: timestamp
-  });
-}
-function validateRemoteSourceRegistrationFlags(projectId, flags) {
-  if (!projectId || flags["local-only"] === true) return;
-  if (typeof flags["encrypted-display-name"] === "string" && typeof flags["encrypted-metadata"] === "string") return;
-  throw new Error(
-    "remote-access with --project requires --local-only or both --encrypted-display-name and --encrypted-metadata"
-  );
+    updated_at: timestamp,
+    last_opened_at: timestamp
+  };
+  await client.createProject(payload);
+  return {
+    projectId,
+    name,
+    description: "",
+    icon: "folder",
+    color: "default",
+    pinned: false,
+    archived: false,
+    version: 1,
+    projectKey,
+    encrypted: payload
+  };
 }
 function shouldInitializeRedactor(command, subcommand) {
   return command === "chats" && ["new", "send", "answer-interactive", "incognito"].includes(subcommand ?? "");
@@ -76851,21 +77647,20 @@ Options:
 }
 function printRemoteAccessHelp() {
   console.log(`Remote access command:
-  openmates remote-access [--path <folder>] [--source-id <id>] [--project <id>] [--type <type>] [--local-only] [--json]
+  openmates remote-access [--path <folder>]... [--json]
 
 Behavior:
-  Runs in the foreground and defaults to the current working directory when
-  --path is omitted. Keep the terminal open; use zellij, tmux, or screen for
-  long-running access sessions.
-
-Source types:
-  local_folder, local_git_repository
+  Discovers repository Projects below the current working directory by default.
+  Repeated --path values replace default discovery. Missing Projects are created
+  only after interactive review. The command remains connected in the foreground;
+  keep the terminal open or use zellij, tmux, or screen.
 
 Security:
   Source metadata is stored locally under ~/.openmates/remote-sources.json.
   Preview cache defaults to ~/.openmates/remote-cache/<source-id>.
-  Local searches are internal bridge capability only and run inside the approved
-  source root with high-risk, binary, and out-of-root paths excluded by default.`);
+  Project metadata and bridge payloads are encrypted automatically. List, search,
+  and text preview stay inside approved roots and exclude protected, ignored,
+  binary, symlink-escaped, and out-of-root paths.`);
 }
 function printConnectedAccountsHelp() {
   console.log(`Connected account commands:

package/dist/cli.js

@@ -3,7 +3,7 @@ import {
   buildTravelConnectionsRequest,
   getExtForLang,
   serializeToYaml
-} from "./chunk-YRIKOMBJ.js";
+} from "./chunk-3ZTRVFOG.js";
 import "./chunk-MLWBMJEN.js";
 export {
   buildTravelConnectionsRequest,

package/dist/index.d.ts

@@ -69,6 +69,16 @@ interface ForceLogoutPayload {
     reason?: string;
     revoked_session_id?: string | null;
 }
+interface ProjectRemoteAccessRequestFrame {
+    request_id: string;
+    project_id: string;
+    source_id: string;
+    source_session_id: string;
+    requesting_client_id: string;
+    operation: "list" | "search" | "read_text";
+    key_epoch: number;
+    encrypted_envelope: string;
+}
 /** Streaming event dispatched for each chunk or lifecycle event. */
 interface StreamEvent {
     /** Event type. */
@@ -198,6 +208,11 @@ declare class OpenMatesWsClient {
     send(type: string, payload: unknown): void;
     sendAsync(type: string, payload: unknown): Promise<void>;
     onLocalConnectorRequest(handler: (payload: LocalConnectorRequestFrame) => void | Promise<void>): () => void;
+    onProjectRemoteAccessRequest(handler: (payload: ProjectRemoteAccessRequestFrame) => void | Promise<void>): () => void;
+    waitForClose(): Promise<{
+        code: number;
+        reason: string;
+    }>;
     private bufferPassiveTaskUpdateJobs;
     private handleForceLogout;
     drainPassiveTaskUpdateJobs(): PendingTaskUpdateJobFrame[];
@@ -2173,6 +2188,10 @@ declare class OpenMatesClient {
     }): Promise<Record<string, unknown>>;
     listProjectSources(projectId: string): Promise<ProjectSourceRecord[]>;
     createProjectSource(projectId: string, input: ProjectSourceCreateInput): Promise<ProjectSourceRecord>;
+    openProjectRemoteAccessWebSocket(): Promise<{
+        ws: OpenMatesWsClient;
+        ownerId: string;
+    }>;
     createProjectItem(projectId: string, input: ProjectItemCreateInput): Promise<ProjectItemRecord>;
     deleteProjectItemByTarget(projectId: string, itemType: "embed" | "chat" | "workflow", targetId: string): Promise<{
         deleted: boolean;

package/dist/index.js

@@ -36,7 +36,7 @@ import {
   renderPlanList,
   renderSupportInfo,
   serializeToYaml
-} from "./chunk-YRIKOMBJ.js";
+} from "./chunk-3ZTRVFOG.js";
 import "./chunk-MLWBMJEN.js";
 export {
   APP_SKILL_METADATA,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmates",
-  "version": "0.15.0-alpha.97",
+  "version": "0.15.0-alpha.99",
   "description": "OpenMates CLI and SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -30,6 +30,7 @@
     "test:unit:workflows": "node --test --experimental-strip-types --loader ./tests/loader.mjs tests/workflows.test.ts",
     "test:unit:sdk-workflows": "node --test --experimental-strip-types --loader ./tests/loader.mjs tests/sdk-workflows.test.ts",
     "test:unit:remote-access": "node --test --experimental-strip-types --loader ./tests/loader.mjs tests/remoteSources.test.ts tests/remoteAccess.test.ts",
+    "test:unit:remote-access-crypto": "node --test --experimental-strip-types --loader ./tests/loader.mjs tests/remoteAccessCrypto.test.ts",
     "test:unit:teams": "node --test --experimental-strip-types --loader ./tests/loader.mjs tests/teams-permissions.test.ts",
     "test:unit:proton-bridge-connector": "node --test --experimental-strip-types --loader ./tests/loader.mjs tests/protonBridgeConnector.test.ts",
     "test:unit:proton-bridge-connector-integration": "node --test --experimental-strip-types --loader ./tests/loader.mjs tests/protonBridgeConnector.integration.test.ts",