cngkit 1.1.21 → 1.1.23

package/dist/{chunk-CVF2ODLP.js → chunk-BXS4IKUA.js}

@@ -1,20 +1,16 @@
 import {
+  createCngApiClient,
   readBackendHealth
-} from "./chunk-YJXAH7D5.js";
+} from "./chunk-GYRLVNJX.js";
 import {
-  createPeerId,
-  createRoomCode,
   resolveApiBaseUrl
-} from "./chunk-DIJEVOVN.js";
+} from "./chunk-67FUBMNB.js";
 
 // src/features/coderoom/run-coderoom-command.ts
-import process2 from "process";
+import process3 from "process";
 
 // src/features/coderoom/sync/client.ts
-import process from "process";
-import fs2 from "fs";
-import chokidar from "chokidar";
-import WebSocket from "ws";
+import WebSocket2 from "ws";
 
 // src/features/coderoom/sync/files.ts
 import fs from "fs/promises";
@@ -98,10 +94,10 @@ function createSuppressionTracker(windowMs = 1500) {
     }
   };
 }
-async function* collectSnapshotMessages(context, peerId) {
-  yield* collectDirectorySnapshot(context, context.rootDir, peerId);
+async function* collectSnapshotMessages(context) {
+  yield* collectDirectorySnapshot(context, context.rootDir);
 }
-async function* collectDirectorySnapshot(context, directoryPath, peerId) {
+async function* collectDirectorySnapshot(context, directoryPath) {
   const entries = await fs.opendir(directoryPath);
   for await (const entry of entries) {
     const absolutePath = path2.join(directoryPath, entry.name);
@@ -110,7 +106,7 @@ async function* collectDirectorySnapshot(context, directoryPath, peerId) {
       continue;
     }
     if (entry.isDirectory()) {
-      yield* collectDirectorySnapshot(context, absolutePath, peerId);
+      yield* collectDirectorySnapshot(context, absolutePath);
       continue;
     }
     if (!entry.isFile()) {
@@ -119,15 +115,13 @@ async function* collectDirectorySnapshot(context, directoryPath, peerId) {
     const [content, stat] = await Promise.all([fs.readFile(absolutePath), fs.stat(absolutePath)]);
     yield {
       type: "file",
-      peerId,
       path: relativePath,
       contentBase64: content.toString("base64"),
-      mtimeMs: stat.mtimeMs,
-      sentAt: Date.now()
+      mtimeMs: stat.mtimeMs
     };
   }
 }
-async function buildFileMessage(context, peerId, relativePath) {
+async function buildFileMessage(context, relativePath) {
   if (!await shouldSyncRelativePath(context, relativePath)) {
     return void 0;
   }
@@ -142,11 +136,9 @@ async function buildFileMessage(context, peerId, relativePath) {
   const content = await fs.readFile(absolutePath);
   return {
     type: "file",
-    peerId,
     path: relativePath,
     contentBase64: content.toString("base64"),
-    mtimeMs: stat.mtimeMs,
-    sentAt: Date.now()
+    mtimeMs: stat.mtimeMs
   };
 }
 async function applyRemoteMessage(context, message, suppressionTracker) {
@@ -163,102 +155,195 @@ async function applyRemoteMessage(context, message, suppressionTracker) {
   await fs.writeFile(absolutePath, Buffer.from(message.contentBase64, "base64"));
 }
 
+// src/features/coderoom/sync/local-events.ts
+import fs2 from "fs";
+import chokidar from "chokidar";
+
+// src/features/coderoom/sync/session.ts
+import os from "os";
+import process from "process";
+import WebSocket from "ws";
+
 // src/features/coderoom/sync/protocol.ts
 import { z } from "zod";
-var SyncBaseMessageSchema = z.object({
-  peerId: z.string().min(1),
-  sentAt: z.number().finite()
-});
-var SyncHelloMessageSchema = SyncBaseMessageSchema.extend({
-  type: z.literal("hello"),
-  role: z.union([z.literal("share"), z.literal("join")])
-});
-var SyncFileMessageSchema = SyncBaseMessageSchema.extend({
+var ClientFileMessageSchema = z.object({
   type: z.literal("file"),
   path: z.string().min(1),
   contentBase64: z.string(),
   mtimeMs: z.number().finite()
 });
-var SyncDeleteMessageSchema = SyncBaseMessageSchema.extend({
+var ClientDeleteMessageSchema = z.object({
   type: z.literal("delete"),
   path: z.string().min(1),
   mtimeMs: z.number().finite()
 });
-var SyncSnapshotCompleteMessageSchema = SyncBaseMessageSchema.extend({
-  type: z.literal("snapshot-complete"),
+var ClientJoinApprovalMessageSchema = z.object({
+  type: z.literal("join-approval"),
+  joinRequestId: z.string().min(1),
+  approved: z.boolean()
+});
+var ClientMessageSchema = z.discriminatedUnion("type", [
+  ClientFileMessageSchema,
+  ClientDeleteMessageSchema,
+  ClientJoinApprovalMessageSchema
+]);
+var ServerConnectedMessageSchema = z.object({
+  type: z.literal("connected"),
+  roomCode: z.string(),
+  participantId: z.string(),
+  role: z.union([z.literal("host"), z.literal("guest")]),
+  status: z.union([z.literal("approved"), z.literal("pending"), z.literal("denied")])
+});
+var ServerJoinPendingMessageSchema = z.object({
+  type: z.literal("join-pending"),
+  participantId: z.string(),
+  joinRequestId: z.string(),
+  roomCode: z.string()
+});
+var ServerJoinRequestMessageSchema = z.object({
+  type: z.literal("join-request"),
+  joinRequestId: z.string(),
+  participantId: z.string(),
+  displayName: z.string(),
+  requestedAt: z.number().finite()
+});
+var ServerJoinApprovedMessageSchema = z.object({
+  type: z.literal("join-approved"),
+  participantId: z.string()
+});
+var ServerJoinDeniedMessageSchema = z.object({
+  type: z.literal("join-denied"),
+  participantId: z.string(),
+  reason: z.string()
+});
+var ServerFileMessageSchema = z.object({
+  type: z.literal("file"),
+  fileId: z.string(),
+  path: z.string().min(1),
+  sha256: z.string(),
+  size: z.number().int().nonnegative(),
+  contentBase64: z.string(),
+  mtimeMs: z.number().finite(),
+  updatedByParticipantId: z.string()
+});
+var ServerDeleteMessageSchema = z.object({
+  type: z.literal("delete"),
+  fileId: z.string().optional(),
+  path: z.string().min(1),
+  mtimeMs: z.number().finite(),
+  updatedByParticipantId: z.string()
+});
+var ServerFileAckMessageSchema = z.object({
+  type: z.literal("file-ack"),
+  fileId: z.string(),
+  path: z.string().min(1),
+  sha256: z.string(),
+  size: z.number().int().nonnegative(),
+  storage: z.union([z.literal("durable-object"), z.literal("r2")])
+});
+var ServerTreeStartMessageSchema = z.object({
+  type: z.literal("tree-start"),
   fileCount: z.number().int().nonnegative()
 });
-var SyncMessageSchema = z.discriminatedUnion("type", [
-  SyncHelloMessageSchema,
-  SyncFileMessageSchema,
-  SyncDeleteMessageSchema,
-  SyncSnapshotCompleteMessageSchema
+var ServerTreeCompleteMessageSchema = z.object({
+  type: z.literal("tree-complete"),
+  fileCount: z.number().int().nonnegative()
+});
+var ServerErrorMessageSchema = z.object({
+  type: z.literal("error"),
+  error: z.string()
+});
+var ServerMessageSchema = z.discriminatedUnion("type", [
+  ServerConnectedMessageSchema,
+  ServerJoinPendingMessageSchema,
+  ServerJoinRequestMessageSchema,
+  ServerJoinApprovedMessageSchema,
+  ServerJoinDeniedMessageSchema,
+  ServerFileMessageSchema,
+  ServerDeleteMessageSchema,
+  ServerFileAckMessageSchema,
+  ServerTreeStartMessageSchema,
+  ServerTreeCompleteMessageSchema,
+  ServerErrorMessageSchema
 ]);
-function encodeSyncMessage(message) {
-  return JSON.stringify(SyncMessageSchema.parse(message));
+function encodeClientMessage(message) {
+  return JSON.stringify(ClientMessageSchema.parse(message));
 }
-function decodeSyncMessage(value) {
+function decodeServerMessage(value) {
   if (typeof value !== "string") {
     return void 0;
   }
   try {
-    return SyncMessageSchema.parse(JSON.parse(value));
+    return ServerMessageSchema.parse(JSON.parse(value));
   } catch {
     return void 0;
   }
 }
 
-// src/features/coderoom/sync/client.ts
-function createSyncWebSocketUrl(apiBaseUrl, roomCode) {
-  const url = new URL(apiBaseUrl);
+// src/features/coderoom/sync/session.ts
+function createSyncWebSocketUrl(options) {
+  const url = new URL(options.apiBaseUrl);
   url.protocol = url.protocol === "http:" ? "ws:" : "wss:";
-  url.pathname = `/api/cng/sync/${encodeURIComponent(roomCode)}`;
+  url.pathname = `/api/cng/coderoom/rooms/${encodeURIComponent(options.roomCode)}/ws`;
   url.search = "";
   url.hash = "";
+  url.searchParams.set("role", options.role);
+  url.searchParams.set("displayName", createDisplayName());
+  if (options.creatorToken) {
+    url.searchParams.set("creatorToken", options.creatorToken);
+  }
   return url.toString();
 }
 function sendMessage(socket, message) {
   if (socket.readyState === WebSocket.OPEN) {
-    socket.send(encodeSyncMessage(message));
+    socket.send(encodeClientMessage(message));
   }
 }
-async function startSyncSession(options) {
-  const repoContext = await resolveRepoContext(options.cwd);
-  const peerId = createPeerId();
-  const suppressionTracker = createSuppressionTracker();
-  const webSocketUrl = createSyncWebSocketUrl(options.apiBaseUrl, options.roomCode);
-  const socket = new WebSocket(webSocketUrl);
-  options.output.success(`Room: ${options.roomCode}`);
-  options.output.info(`Repo: ${repoContext.rootDir}`);
-  options.output.muted(`Peer: ${peerId}`);
-  const watcherContext = {
-    repoContext,
-    socket,
-    peerId,
-    suppressionTracker,
-    output: options.output
-  };
-  const watcher = createRepoWatcher(watcherContext);
-  socket.on("open", () => {
-    sendMessage(socket, {
-      type: "hello",
-      peerId,
-      role: options.role,
-      sentAt: Date.now()
+function createDisplayName() {
+  const username = os.userInfo().username || "user";
+  return `${username}@${os.hostname()}`;
+}
+async function waitForSessionClose(socket, watcher) {
+  await new Promise((resolve, reject) => {
+    let settled = false;
+    const closeSession = async () => {
+      await watcher.close();
+      if (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING) {
+        socket.close();
+      }
+    };
+    const finish = async () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+      await closeSession();
+      resolve();
+    };
+    const onSignal = () => {
+      void finish();
+    };
+    socket.on("error", async (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+      await closeSession();
+      reject(error);
     });
-    void sendInitialSnapshot(socket, repoContext, peerId, options.output);
-  });
-  socket.on("message", (data) => {
-    void handleRemoteMessage({
-      data,
-      repoContext,
-      peerId,
-      suppressionTracker,
-      output: options.output
+    socket.on("close", () => {
+      void finish();
     });
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
   });
-  await waitForSessionClose(socket, watcher);
 }
+
+// src/features/coderoom/sync/local-events.ts
 function createRepoWatcher(context) {
   const watcher = chokidar.watch(context.repoContext.rootDir, {
     ignoreInitial: true,
@@ -285,30 +370,29 @@ function createRepoWatcher(context) {
     void sendLocalDelete(context, absolutePath);
   });
   watcher.on("error", (watcherError) => {
-    context.output.warning(`watcher error: ${watcherError instanceof Error ? watcherError.message : String(watcherError)}`);
+    context.output.warning(
+      `watcher error: ${watcherError instanceof Error ? watcherError.message : String(watcherError)}`
+    );
   });
   return watcher;
 }
-async function sendInitialSnapshot(socket, repoContext, peerId, output) {
+async function sendInitialSnapshot(socket, repoContext, output) {
   let fileCount = 0;
-  for await (const message of collectSnapshotMessages(repoContext, peerId)) {
+  for await (const message of collectSnapshotMessages(repoContext)) {
     sendMessage(socket, message);
     fileCount += 1;
   }
-  sendMessage(socket, {
-    type: "snapshot-complete",
-    peerId,
-    sentAt: Date.now(),
-    fileCount
-  });
   output.success(`sent snapshot ${fileCount} files`);
 }
 async function sendLocalFileChange(context, absolutePath) {
+  if (!context.state.approved) {
+    return;
+  }
   const relativePath = toRepoRelativePath(context.repoContext.rootDir, absolutePath);
   if (!relativePath || context.suppressionTracker.isSuppressed(relativePath)) {
     return;
   }
-  const message = await buildFileMessage(context.repoContext, context.peerId, relativePath);
+  const message = await buildFileMessage(context.repoContext, relativePath);
   if (!message) {
     return;
   }
@@ -316,6 +400,9 @@ async function sendLocalFileChange(context, absolutePath) {
   context.output.muted(`sent file ${relativePath}`);
 }
 async function sendLocalDelete(context, absolutePath) {
+  if (!context.state.approved) {
+    return;
+  }
   const relativePath = toRepoRelativePath(context.repoContext.rootDir, absolutePath);
   if (!relativePath || context.suppressionTracker.isSuppressed(relativePath)) {
     return;
@@ -325,82 +412,147 @@ async function sendLocalDelete(context, absolutePath) {
   }
   sendMessage(context.socket, {
     type: "delete",
-    peerId: context.peerId,
     path: relativePath,
-    mtimeMs: Date.now(),
-    sentAt: Date.now()
+    mtimeMs: Date.now()
   });
   context.output.warning(`sent delete ${relativePath}`);
 }
-async function handleRemoteMessage(options) {
-  const decodedMessage = decodeSyncMessage(options.data.toString());
-  if (!decodedMessage || decodedMessage.peerId === options.peerId) {
+
+// src/features/coderoom/sync/remote-handler.ts
+import process2 from "process";
+import readline from "readline/promises";
+async function handleServerMessage(options) {
+  const decodedMessage = decodeServerMessage(options.data.toString());
+  if (!decodedMessage) {
+    return;
+  }
+  if (decodedMessage.type === "connected") {
+    options.state.participantId = decodedMessage.participantId;
+    options.state.approved = decodedMessage.status === "approved";
+    options.output.muted(`Participant: ${decodedMessage.participantId}`);
     return;
   }
-  if (decodedMessage.type === "hello") {
-    options.output.info(`peer joined ${decodedMessage.peerId}`);
+  if (decodedMessage.type === "join-pending") {
+    options.output.info(`Join request sent: ${decodedMessage.joinRequestId}`);
     return;
   }
-  if (decodedMessage.type === "snapshot-complete") {
-    options.output.success(`peer snapshot complete ${decodedMessage.fileCount} files`);
+  if (decodedMessage.type === "join-request") {
+    await approveJoinRequest(options.socket, decodedMessage, options.output);
+    return;
+  }
+  if (decodedMessage.type === "join-approved") {
+    options.state.approved = true;
+    options.output.success("Join approved. Applying room file tree...");
+    return;
+  }
+  if (decodedMessage.type === "join-denied") {
+    options.output.warning(`Join denied: ${decodedMessage.reason}`);
+    options.socket.close();
+    return;
+  }
+  if (decodedMessage.type === "tree-start") {
+    options.output.info(`receiving room tree ${decodedMessage.fileCount} files`);
+    return;
+  }
+  if (decodedMessage.type === "tree-complete") {
+    options.output.success(`room tree complete ${decodedMessage.fileCount} files`);
+    return;
+  }
+  if (decodedMessage.type === "file-ack") {
+    options.output.muted(
+      `stored ${decodedMessage.storage} ${decodedMessage.path} ${decodedMessage.sha256}`
+    );
+    return;
+  }
+  if (decodedMessage.type === "error") {
+    options.output.warning(`server error: ${decodedMessage.error}`);
     return;
   }
   await applyRemoteMessage(options.repoContext, decodedMessage, options.suppressionTracker);
   options.output.success(`applied ${decodedMessage.type} ${decodedMessage.path}`);
 }
-async function waitForSessionClose(socket, watcher) {
-  await new Promise((resolve, reject) => {
-    let settled = false;
-    const closeSession = async () => {
-      await watcher.close();
-      if (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING) {
-        socket.close();
-      }
-    };
-    const finish = async () => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      process.off("SIGINT", onSignal);
-      process.off("SIGTERM", onSignal);
-      await closeSession();
-      resolve();
-    };
-    const onSignal = () => {
-      void finish();
-    };
-    socket.on("error", async (error) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      process.off("SIGINT", onSignal);
-      process.off("SIGTERM", onSignal);
-      await closeSession();
-      reject(error);
-    });
-    socket.on("close", () => {
-      void finish();
+async function approveJoinRequest(socket, message, output) {
+  const approved = await askForApproval(message, output);
+  sendMessage(socket, {
+    type: "join-approval",
+    joinRequestId: message.joinRequestId,
+    approved
+  });
+  output[approved ? "success" : "warning"](
+    `${approved ? "approved" : "denied"} ${message.displayName}`
+  );
+}
+async function askForApproval(message, output) {
+  output.info(`Join request: ${message.displayName} (${message.joinRequestId})`);
+  if (!process2.stdin.isTTY) {
+    output.warning("No interactive terminal available. Denying join request.");
+    return false;
+  }
+  const interfaceReader = readline.createInterface({
+    input: process2.stdin,
+    output: process2.stdout
+  });
+  try {
+    const answer = await interfaceReader.question("Approve join request? [y/N] ");
+    return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+  } finally {
+    interfaceReader.close();
+  }
+}
+
+// src/features/coderoom/sync/client.ts
+async function startSyncSession(options) {
+  const repoContext = await resolveRepoContext(options.cwd);
+  const suppressionTracker = createSuppressionTracker();
+  const webSocketUrl = createSyncWebSocketUrl(options);
+  const socket = new WebSocket2(webSocketUrl);
+  const state = {
+    approved: options.role === "host",
+    participantId: void 0
+  };
+  options.output.success(`Room: ${options.roomCode}`);
+  options.output.info(`Repo: ${repoContext.rootDir}`);
+  const watcherContext = {
+    repoContext,
+    socket,
+    state,
+    suppressionTracker,
+    output: options.output
+  };
+  const watcher = createRepoWatcher(watcherContext);
+  socket.on("open", () => {
+    if (options.role === "host") {
+      void sendInitialSnapshot(socket, repoContext, options.output);
+      return;
+    }
+    options.output.info("Waiting for host approval...");
+  });
+  socket.on("message", (data) => {
+    void handleServerMessage({
+      data,
+      socket,
+      repoContext,
+      state,
+      suppressionTracker,
+      output: options.output
     });
-    process.on("SIGINT", onSignal);
-    process.on("SIGTERM", onSignal);
   });
+  await waitForSessionClose(socket, watcher);
 }
 
 // src/features/coderoom/run-coderoom-command.ts
-async function runShareCommand(roomCode, options, output) {
-  const syncRoomCode = roomCode ?? createRoomCode();
-  output.success(`Share code: ${syncRoomCode}`);
+async function runShareCommand(options, output) {
+  const room = await createCoderoomRoom(options);
+  output.success(`Share code: ${room.roomCode}`);
   await printBackendStatus(options, output);
-  await runSyncSession("share", syncRoomCode, options, output);
+  await runSyncSession("host", room.roomCode, room.creatorToken, options, output);
 }
 async function runJoinCommand(roomCode, options, output) {
   if (!roomCode) {
     throw new Error("Missing room code. Usage: cngkit coderoom join <room-code>");
   }
   await printBackendStatus(options, output);
-  await runSyncSession("join", roomCode, options, output);
+  await runSyncSession("guest", roomCode, void 0, options, output);
 }
 async function printBackendStatus(options, output) {
   const health = await readBackendHealth(options);
@@ -410,18 +562,23 @@ async function printBackendStatus(options, output) {
   }
   output.warning(`API: unavailable (${health.message})`);
 }
-async function runSyncSession(role, roomCode, options, output) {
+async function runSyncSession(role, roomCode, creatorToken, options, output) {
   await startSyncSession({
     apiBaseUrl: resolveApiBaseUrl(options),
     roomCode,
+    creatorToken,
     role,
-    cwd: process2.cwd(),
+    cwd: process3.cwd(),
     output
   });
 }
+async function createCoderoomRoom(options) {
+  const client = createCngApiClient(options);
+  return client.coderoom.createCoderoomRoom();
+}
 
 export {
   runShareCommand,
   runJoinCommand
 };
-//# sourceMappingURL=chunk-CVF2ODLP.js.map
+//# sourceMappingURL=chunk-BXS4IKUA.js.map