@akshar5/cohall 0.4.8 → 0.4.9

package/bin/cohall.js

@@ -17,10 +17,11 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // packages/protocol/src/index.ts
 import { Schema } from "effect";
-var version = "0.4.8", bounded = (maxLength) => Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(maxLength)), optionalText = (maxLength) => Schema.String.check(Schema.isMaxLength(maxLength)), boundedArray = (schema, maxLength) => Schema.Array(schema).check(Schema.isMaxLength(maxLength)), uuid = (name) => Schema.String.check(Schema.isUUID(4)).pipe(Schema.brand(name)), isoTimestamp = (name) => Schema.String.check(Schema.isPattern(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/, {
+var version = "0.4.9", maxSocketPayloadBytes, bounded = (maxLength) => Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(maxLength)), optionalText = (maxLength) => Schema.String.check(Schema.isMaxLength(maxLength)), boundedArray = (schema, maxLength) => Schema.Array(schema).check(Schema.isMaxLength(maxLength)), uuid = (name) => Schema.String.check(Schema.isUUID(4)).pipe(Schema.brand(name)), isoTimestamp = (name) => Schema.String.check(Schema.isPattern(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/, {
   expected: "an ISO-8601 UTC timestamp"
 })).pipe(Schema.brand(name)), DeviceId, ThreadId, MessageId, TaskId, AuthSessionId, Timestamp, Platform, Provider, DeviceStatus, TaskStatus, TaskTraceEventKind, MessageRole, ConnectionRole, AuthSession, CreatePairingInput, PairingCredential, ExchangePairingInput, SessionCredential, PairingResult, Capability, Workspace, Device, Thread, Message, Task, TaskTraceEvent, TaskTrace, ThreadContext, CreateTaskInput, SocketEvent, ErrorResponse, terminalTaskStatuses, isTerminalTask = (task) => terminalTaskStatuses.has(task.status), now = () => Timestamp.make(new Date().toISOString()), makeDeviceId = () => DeviceId.make(crypto.randomUUID()), makeThreadId = () => ThreadId.make(crypto.randomUUID()), makeMessageId = () => MessageId.make(crypto.randomUUID()), makeTaskId = () => TaskId.make(crypto.randomUUID()), makeAuthSessionId = () => AuthSessionId.make(crypto.randomUUID()), decodeCreatePairingInput, decodeExchangePairingInput, decodeCreateTaskInput, decodeDevice, decodeSocketEvent;
 var init_src = __esm(() => {
+  maxSocketPayloadBytes = 1024 * 1024;
   DeviceId = uuid("DeviceId");
   ThreadId = uuid("ThreadId");
   MessageId = uuid("MessageId");
@@ -202,7 +203,7 @@ var init_src = __esm(() => {
 
 // apps/relay/src/config.ts
 import { Effect as Effect8, Schema as Schema9 } from "effect";
-import { access as access3, chmod as chmod4, mkdir as mkdir4, readFile as readFile4, writeFile as writeFile5 } from "node:fs/promises";
+import { access as access4, chmod as chmod4, mkdir as mkdir4, readFile as readFile4, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir4, platform as platform4 } from "node:os";
 import { join as join5, resolve as resolve2 } from "node:path";
 var RelayConfiguration, defaultDataDirectory = () => {
@@ -214,7 +215,7 @@ var RelayConfiguration, defaultDataDirectory = () => {
   }
   return join5(process.env.XDG_DATA_HOME ?? join5(homedir4(), ".local", "share"), "cohall");
 }, generatedToken = () => Array.from(crypto.getRandomValues(new Uint8Array(32)), (value) => value.toString(16).padStart(2, "0")).join(""), tokenFrom = async (path) => {
-  if (await access3(path).then(() => true).catch(() => false)) {
+  if (await access4(path).then(() => true).catch(() => false)) {
     return (await readFile4(path, "utf8")).trim();
   }
   const token = generatedToken();
@@ -238,10 +239,11 @@ var init_config = __esm(() => {
   RelayConfiguration = Schema9.Struct({
     host: Schema9.NonEmptyString,
     port: Schema9.Int.check(Schema9.isBetween({ minimum: 1, maximum: 65535 })),
-    token: Schema9.NonEmptyString,
+    token: Schema9.String.check(Schema9.isMinLength(32)),
     dataDirectory: Schema9.NonEmptyString,
     databasePath: Schema9.NonEmptyString,
-    allowRemote: Schema9.Boolean
+    allowRemote: Schema9.Boolean,
+    historyTaskLimit: Schema9.Int.check(Schema9.isBetween({ minimum: 100, maximum: 1e5 }))
   });
   loadEnvironmentConfiguration = Effect8.tryPromise({
     try: async () => {
@@ -257,13 +259,18 @@ var init_config = __esm(() => {
         await chmod4(dataDirectory, 448);
       }
       const token = process.env.COHALL_TOKEN ?? await tokenFrom(join5(dataDirectory, "owner-token"));
+      if (token.length < 32) {
+        throw new Error("The Cohall relay owner token must be at least 32 characters");
+      }
+      const historyTaskLimit = Number(process.env.COHALL_HISTORY_TASK_LIMIT ?? "1000");
       return Schema9.decodeUnknownSync(RelayConfiguration)({
         host,
         port,
         token,
         dataDirectory,
         databasePath: join5(dataDirectory, "cohall.db"),
-        allowRemote
+        allowRemote,
+        historyTaskLimit
       });
     },
     catch: (cause) => cause instanceof Error ? cause : new Error(String(cause))
@@ -277,12 +284,27 @@ class Hub {
   #principals = new Map;
   #devices = new Map;
   #deviceIds = new Map;
+  #sessions = new Map;
+  #ownerSockets = new Set;
   attach(socket, principal) {
+    if (principal.sessionId === undefined) {
+      if (this.#ownerSockets.size >= 16) {
+        return false;
+      }
+      this.#ownerSockets.add(socket);
+    } else {
+      const existing = this.#sessions.get(principal.sessionId);
+      if (existing !== undefined && existing.readyState === WebSocket2.OPEN) {
+        return false;
+      }
+      this.#sessions.set(principal.sessionId, socket);
+    }
     this.#principals.set(socket, principal);
-    if (socket.data.authDeadline !== undefined) {
-      clearTimeout(socket.data.authDeadline);
-      socket.data.authDeadline = undefined;
+    if (socket.data.stageDeadline !== undefined) {
+      clearTimeout(socket.data.stageDeadline);
+      socket.data.stageDeadline = undefined;
     }
+    return true;
   }
   isAuthorized(socket) {
     const principal = this.#principals.get(socket);
@@ -299,19 +321,34 @@ class Hub {
     return this.#principals.get(socket)?.boundDeviceId;
   }
   registerDevice(deviceId, socket) {
+    if (this.#deviceIds.has(socket)) {
+      return false;
+    }
     const previous = this.#devices.get(deviceId);
     if (previous !== undefined && previous !== socket && previous.readyState === WebSocket2.OPEN) {
       return false;
     }
     this.#devices.set(deviceId, socket);
     this.#deviceIds.set(socket, deviceId);
+    if (socket.data.stageDeadline !== undefined) {
+      clearTimeout(socket.data.stageDeadline);
+      socket.data.stageDeadline = undefined;
+    }
     return true;
   }
+  pendingConnections() {
+    return this.#principals.size - this.#deviceIds.size;
+  }
   detach(socket) {
-    if (socket.data.authDeadline !== undefined) {
-      clearTimeout(socket.data.authDeadline);
+    if (socket.data.stageDeadline !== undefined) {
+      clearTimeout(socket.data.stageDeadline);
     }
+    const principal = this.#principals.get(socket);
     this.#principals.delete(socket);
+    this.#ownerSockets.delete(socket);
+    if (principal?.sessionId !== undefined && this.#sessions.get(principal.sessionId) === socket) {
+      this.#sessions.delete(principal.sessionId);
+    }
     const deviceId = this.#deviceIds.get(socket);
     this.#deviceIds.delete(socket);
     if (deviceId === undefined || this.#devices.get(deviceId) !== socket) {
@@ -527,7 +564,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     events.push(TaskTraceEvent.make({ kind: task.status, at: task.completedAt, detail }));
   }
   return events;
-}, makeService = (db) => {
+}, makeService = (db, retainedTerminalTasks = 1000) => {
   const recordTaskTraceEvent = (taskId, kind, detail, createdAt = now()) => {
     db.query(`INSERT INTO task_trace_events (task_id, kind, created_at, detail)
        VALUES (?, ?, ?, ?)`).run(taskId, kind, createdAt, detail);
@@ -535,6 +572,21 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
          SELECT id FROM task_trace_events WHERE task_id = ? ORDER BY id DESC LIMIT 1000
        )`).run(taskId, taskId);
   };
+  const pruneTerminalHistory = (preserveTaskId) => {
+    const exclusion = preserveTaskId === undefined ? "" : "AND id <> ?";
+    const offset = preserveTaskId === undefined ? retainedTerminalTasks : retainedTerminalTasks - 1;
+    const staleTasks = `SELECT id FROM tasks
+      WHERE status IN ('completed', 'failed', 'cancelled')
+        ${exclusion}
+      ORDER BY completed_at DESC, updated_at DESC, id DESC
+      LIMIT -1 OFFSET ?`;
+    const parameters = preserveTaskId === undefined ? [offset] : [preserveTaskId, offset];
+    db.query(`DELETE FROM messages WHERE task_id IN (${staleTasks})`).run(...parameters);
+    db.query(`DELETE FROM tasks WHERE id IN (${staleTasks})`).run(...parameters);
+    db.query(`DELETE FROM threads
+       WHERE NOT EXISTS (SELECT 1 FROM tasks WHERE tasks.thread_id = threads.id)
+         AND NOT EXISTS (SELECT 1 FROM messages WHERE messages.thread_id = threads.id)`).run();
+  };
   const queryTask = (taskId) => db.query("SELECT * FROM tasks WHERE id = ?").get(taskId);
   const getTask = Effect9.fn("RelayStore.getTask")(function* (taskId) {
     const row = yield* Effect9.try({
@@ -632,6 +684,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
         }
         db.query("DELETE FROM auth_pairings WHERE expires_at <= ? OR used_at IS NOT NULL").run(timestamp);
         db.query("UPDATE auth_sessions SET revoked_at = ? WHERE revoked_at IS NULL AND roles_json LIKE '%,%'").run(timestamp);
+        pruneTerminalHistory();
       })(),
       catch: operationError("RelayStore.recover")
     });
@@ -797,6 +850,9 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
         if (result.changes === 1 && event !== undefined) {
           recordTaskTraceEvent(taskId, event.kind, event.detail, timestamp);
         }
+        if (result.changes === 1 && update.status !== undefined && ["completed", "failed", "cancelled"].includes(update.status)) {
+          pruneTerminalHistory(taskId);
+        }
       })(),
       catch: operationError("RelayStore.transition")
     });
@@ -864,6 +920,7 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
               ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(makeMessageId(), current.threadId, role, status === "failed" ? "error" : "chat", deviceId, status === "completed" ? providerName(current.provider) : "Cohall", content, timestamp, taskId, deviceId);
           db.query("UPDATE threads SET updated_at = ? WHERE id = ?").run(timestamp, current.threadId);
         }
+        pruneTerminalHistory(taskId);
       })(),
       catch: operationError("RelayStore.terminal")
     });
@@ -1100,10 +1157,10 @@ var PersistenceError, Service2, operationError = (operation) => (cause) => new P
     }
   },
   catch: operationError("RelayStore.migrate")
-}), layer2 = (path) => Layer2.effect(Service2, Effect9.acquireRelease(Effect9.try({
+}), layer2 = (path, retainedTerminalTasks = 1000) => Layer2.effect(Service2, Effect9.acquireRelease(Effect9.try({
   try: () => new Database(path),
   catch: operationError("RelayStore.open")
-}).pipe(Effect9.tap(migrate)), (db) => Effect9.sync(() => db.close())).pipe(Effect9.map(makeService))), layerFromDatabase = (db) => Layer2.effect(Service2, migrate(db).pipe(Effect9.map(() => makeService(db))));
+}).pipe(Effect9.tap(migrate)), (db) => Effect9.sync(() => db.close())).pipe(Effect9.map((db) => makeService(db, retainedTerminalTasks)))), layerFromDatabase = (db) => Layer2.effect(Service2, migrate(db).pipe(Effect9.map(() => makeService(db))));
 var init_store = __esm(() => {
   init_src();
   init_database();
@@ -1122,7 +1179,7 @@ __export(exports_main, {
 });
 import { Effect as Effect10, ManagedRuntime, Schema as Schema11 } from "effect";
 import { createHash as createHash2, timingSafeEqual } from "node:crypto";
-import { access as access4, chmod as chmod5 } from "node:fs/promises";
+import { access as access5, chmod as chmod5 } from "node:fs/promises";
 import { createServer } from "node:http";
 import { platform as platform5 } from "node:os";
 import { WebSocketServer } from "ws";
@@ -1258,13 +1315,13 @@ Content-Length: 0\r
 }), runRelay = async () => {
   const configuration = await Effect10.runPromise(loadEnvironmentConfiguration);
   process.umask(63);
-  const runtime = ManagedRuntime.make(exports_store.layer(configuration.databasePath));
+  const runtime = ManagedRuntime.make(exports_store.layer(configuration.databasePath, configuration.historyTaskLimit));
   const run2 = (effect) => runtime.runPromise(effect);
   await run2(Effect10.gen(function* () {
     const store = yield* exports_store.Service;
     yield* store.recover();
   }));
-  if (platform5() !== "win32" && await access4(configuration.databasePath).then(() => true).catch(() => false)) {
+  if (platform5() !== "win32" && await access5(configuration.databasePath).then(() => true).catch(() => false)) {
     await chmod5(configuration.databasePath, 384);
   }
   const hub = new Hub;
@@ -1346,11 +1403,24 @@ Content-Length: 0\r
         socket.close(4003, "Authentication failed");
         return;
       }
-      hub.attach(socket, {
+      if (hub.pendingConnections() >= 64) {
+        socket.close(4008, "Pending device connection limit reached");
+        return;
+      }
+      const attached = hub.attach(socket, {
         ...principal === "owner" ? {} : { sessionId: principal.id },
         ...principal === "owner" || principal.deviceId === undefined ? {} : { boundDeviceId: principal.deviceId },
         ...principal === "owner" ? {} : { expiresAt: principal.expiresAt }
       });
+      if (!attached) {
+        socket.close(4008, "Credential connection limit reached");
+        return;
+      }
+      socket.data.stageDeadline = setTimeout(() => {
+        if (hub.deviceId(socket) === undefined) {
+          socket.close(4003, "Device registration timeout");
+        }
+      }, 5000);
       socket.send(JSON.stringify(SocketEvent.make({ _tag: "Connected", serverVersion: version, connectedAt: now() })));
       return;
     }
@@ -1516,20 +1586,20 @@ Content-Length: 0\r
   };
   const websocketServer = new WebSocketServer({
     noServer: true,
-    maxPayload: 256 * 1024,
+    maxPayload: maxSocketPayloadBytes,
     perMessageDeflate: false
   });
   websocketServer.on("connection", (rawSocket) => {
     const socket = rawSocket;
     socket.data = {
       processing: Promise.resolve(),
-      authDeadline: undefined,
+      stageDeadline: undefined,
       preAuthFrameReceived: false,
       queuedMessages: 0,
       closed: false
     };
     connections += 1;
-    socket.data.authDeadline = setTimeout(() => {
+    socket.data.stageDeadline = setTimeout(() => {
       if (!hub.isAuthorized(socket)) {
         socket.close(4003, "Authentication timeout");
       }
@@ -1539,6 +1609,9 @@ Content-Length: 0\r
       alive = true;
     });
     const heartbeat = setInterval(() => {
+      if (!hub.isAuthorized(socket)) {
+        return;
+      }
       if (!alive) {
         socket.terminate();
         return;
@@ -1809,7 +1882,7 @@ import { accessSync, constants } from "node:fs";
 import { chmod, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { homedir, platform, tmpdir } from "node:os";
 import { delimiter, extname, isAbsolute, join } from "node:path";
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 
 class ProviderUnavailableError extends Schema3.TaggedErrorClass()("CohallProvider.Unavailable", { provider: Provider, message: Schema3.String }) {
 }
@@ -2116,6 +2189,50 @@ var parse = async (options, stdout, onFailure) => {
   }
 };
 var byteLength = (value) => new TextEncoder().encode(value).byteLength;
+var processExists = (pid) => {
+  try {
+    process.kill(-pid, 0);
+    return true;
+  } catch (cause) {
+    if (typeof cause === "object" && cause !== null && "code" in cause && cause.code === "ESRCH") {
+      return false;
+    }
+    throw cause;
+  }
+};
+var waitForProcessGroup = async (pid, timeoutMs) => {
+  const deadline = Date.now() + timeoutMs;
+  while (processExists(pid)) {
+    if (Date.now() >= deadline) {
+      return false;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+  return true;
+};
+var terminateWindowsTree = (pid) => new Promise((resolve) => {
+  const systemRoot = process.env.SystemRoot ?? "C:\\Windows";
+  execFile(join(systemRoot, "System32", "taskkill.exe"), ["/PID", String(pid), "/T", "/F"], { windowsHide: true }, () => resolve());
+});
+var terminateProcessTree = async (pid) => {
+  if (platform() === "win32") {
+    await terminateWindowsTree(pid);
+    return;
+  }
+  try {
+    process.kill(-pid, "SIGTERM");
+  } catch (cause) {
+    if (typeof cause === "object" && cause !== null && "code" in cause && cause.code === "ESRCH") {
+      return;
+    }
+    throw cause;
+  }
+  if (await waitForProcessGroup(pid, 5000)) {
+    return;
+  }
+  process.kill(-pid, "SIGKILL");
+  await waitForProcessGroup(pid, 1000);
+};
 var run = (options) => Effect2.tryPromise({
   try: async (signal) => {
     const executable = findExecutable(executables[options.provider]);
@@ -2126,72 +2243,74 @@ var run = (options) => Effect2.tryPromise({
       });
     }
     const prepared = await prepareCommand(options);
-    const [, ...arguments_] = prepared.command;
-    const child = spawn(executable, arguments_, {
-      cwd: options.cwd,
-      env: {
-        ...providerEnvironment(),
-        COHALL_PROVIDER: options.provider,
-        COHALL_THREAD_ID: options.threadId
-      },
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const exited = new Promise((resolve, reject) => {
-      child.once("error", reject);
-      child.once("exit", (code) => resolve(code ?? 1));
-    });
-    let killTimer;
-    const terminate = () => {
-      if (child.exitCode !== null) {
-        return;
+    try {
+      await options.beforeSpawn?.();
+      const [, ...arguments_] = prepared.command;
+      const child = spawn(executable, arguments_, {
+        cwd: options.cwd,
+        env: {
+          ...providerEnvironment(),
+          COHALL_PROVIDER: options.provider,
+          COHALL_THREAD_ID: options.threadId
+        },
+        detached: platform() !== "win32",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const exited = new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("exit", (code) => resolve(code ?? 1));
+      });
+      let termination;
+      const terminate = () => {
+        if (child.pid === undefined || termination !== undefined) {
+          return;
+        }
+        termination = terminateProcessTree(child.pid);
+      };
+      signal.addEventListener("abort", terminate, { once: true });
+      if (signal.aborted) {
+        terminate();
       }
-      child.kill("SIGTERM");
-      killTimer ??= setTimeout(() => {
+      child.stdin.end(prepared.input);
+      try {
+        const [result, stderr, exitCode] = await Promise.all([
+          parse(options, child.stdout, terminate),
+          captureText(child.stderr, 64 * 1024),
+          exited
+        ]);
+        if (exitCode !== 0) {
+          throw new ProviderRunError({
+            provider: options.provider,
+            message: failureMessage(executables[options.provider], stderr, exitCode),
+            exitCode
+          });
+        }
+        if (byteLength(result.result) > 131072) {
+          throw new ProviderRunError({
+            provider: options.provider,
+            message: "Provider result exceeded 128 KiB"
+          });
+        }
+        if (result.sessionId !== undefined && byteLength(result.sessionId) > 4096) {
+          throw new ProviderRunError({
+            provider: options.provider,
+            message: "Provider session ID exceeded 4 KiB"
+          });
+        }
+        return result;
+      } finally {
+        signal.removeEventListener("abort", terminate);
         if (child.exitCode === null) {
-          child.kill("SIGKILL");
+          terminate();
+          await exited.catch(() => {
+            return;
+          });
         }
-      }, 5000);
-      killTimer.unref();
-    };
-    signal.addEventListener("abort", terminate, { once: true });
-    child.stdin.end(prepared.input);
-    try {
-      const [result, stderr, exitCode] = await Promise.all([
-        parse(options, child.stdout, terminate),
-        captureText(child.stderr, 64 * 1024),
-        exited
-      ]);
-      if (exitCode !== 0) {
-        throw new ProviderRunError({
-          provider: options.provider,
-          message: failureMessage(executables[options.provider], stderr, exitCode),
-          exitCode
-        });
-      }
-      if (byteLength(result.result) > 131072) {
-        throw new ProviderRunError({
-          provider: options.provider,
-          message: "Provider result exceeded 128 KiB"
-        });
-      }
-      if (result.sessionId !== undefined && byteLength(result.sessionId) > 4096) {
-        throw new ProviderRunError({
-          provider: options.provider,
-          message: "Provider session ID exceeded 4 KiB"
-        });
-      }
-      return result;
-    } finally {
-      signal.removeEventListener("abort", terminate);
-      if (child.exitCode === null) {
-        terminate();
-        await exited.catch(() => {
+        await termination?.catch(() => {
           return;
         });
       }
-      if (killTimer !== undefined) {
-        clearTimeout(killTimer);
-      }
+    } finally {
       await prepared.cleanup();
     }
   },
@@ -2208,7 +2327,7 @@ var run = (options) => Effect2.tryPromise({
 
 // apps/device/src/cli.ts
 import { Effect as Effect5, Schema as Schema7 } from "effect";
-import { access as access2, mkdir as mkdir3, readFile as readFile3, stat, writeFile as writeFile4 } from "node:fs/promises";
+import { access as access3, mkdir as mkdir3, readFile as readFile3, stat as stat2, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
 import { dirname as dirname3, join as join4 } from "node:path";
 
@@ -2342,7 +2461,8 @@ cohall thread <thread-id>
 \`\`\`
 
 This returns a byte-bounded recent window of prompts, final responses, and task
-states. Check \`truncated\`; older history remains on the relay when it is true.
+states. Check \`truncated\`; older entries may be outside the returned window or
+pruned by the relay's terminal-task retention limit.
 
 ## Input forms
 
@@ -2571,6 +2691,9 @@ var loadOwnerConfiguration = Effect3.tryPromise({
     if (token === undefined || token.length === 0) {
       throw new Error("No owner credential. Run this command on the relay host or set COHALL_TOKEN.");
     }
+    if (token.length < 32) {
+      throw new Error("The Cohall relay owner token must be at least 32 characters");
+    }
     return ClientConfiguration.make({
       relayUrl: normalizeRelayUrl(process.env.COHALL_RELAY_URL ?? stored.relayUrl),
       token
@@ -2704,9 +2827,20 @@ var threadContext = Effect4.fn("Cohall.threadContext")(function* (client, thread
 
 // apps/device/src/upgrade.ts
 import { Schema as Schema6 } from "effect";
-import { execFile } from "node:child_process";
-import { chmod as chmod3, mkdir as mkdir2, readFile as readFile2, realpath as realpath2, rename as rename2, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { execFile as execFile2 } from "node:child_process";
+import { constants as constants2 } from "node:fs";
+import {
+  access as access2,
+  chmod as chmod3,
+  mkdir as mkdir2,
+  readFile as readFile2,
+  realpath as realpath2,
+  rename as rename2,
+  rm as rm2,
+  stat,
+  writeFile as writeFile3
+} from "node:fs/promises";
+import { delimiter as delimiter2, dirname as dirname2, extname as extname2, isAbsolute as isAbsolute2, join as join3 } from "node:path";
 import { platform as operatingSystem } from "node:os";
 var packageName = "@akshar5/cohall";
 var semanticVersion = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
@@ -2744,7 +2878,7 @@ var packageInstallation = (canonicalEntrypoint, entrypoint = canonicalEntrypoint
   if (path.includes("/.bun/install/global/node_modules/")) {
     return { manager: "bun", entrypoint };
   }
-  if (path.includes("/pnpm/global/") || path.includes("/.pnpm/")) {
+  if (path.includes("/pnpm/global/")) {
     return { manager: "pnpm", entrypoint };
   }
   const nodeModulesParent = path.slice(0, packageIndex);
@@ -2770,6 +2904,80 @@ var packageInstallCommand = (installation, target) => {
       };
   }
 };
+var executableNames = (command) => {
+  if (operatingSystem() !== "win32" || extname2(command).length > 0) {
+    return [command];
+  }
+  return (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean).map((extension) => `${command}${extension.toLowerCase()}`);
+};
+var trustedExecutable = async (command) => {
+  const candidates = isAbsolute2(command) ? [command] : (process.env.PATH ?? "").split(delimiter2).filter(Boolean).flatMap((directory) => executableNames(command).map((name) => join3(directory, name)));
+  let selected;
+  for (const path of candidates) {
+    const available2 = await access2(path, operatingSystem() === "win32" ? constants2.F_OK : constants2.X_OK).then(() => true).catch(() => false);
+    if (available2) {
+      selected = path;
+      break;
+    }
+  }
+  if (selected === undefined) {
+    throw new Error(`Could not find ${command} on PATH`);
+  }
+  const canonical = await realpath2(selected);
+  if (operatingSystem() === "win32") {
+    return canonical;
+  }
+  const uid = process.getuid?.();
+  for (let path = canonical;; path = dirname2(path)) {
+    const metadata = await stat(path);
+    if ((metadata.mode & 18) !== 0) {
+      throw new Error(`Refusing executable beneath group- or world-writable path ${path}`);
+    }
+    if (uid !== undefined && metadata.uid !== 0 && metadata.uid !== uid) {
+      throw new Error(`Refusing executable owned by another user at ${path}`);
+    }
+    const parent = dirname2(path);
+    if (parent === path) {
+      break;
+    }
+  }
+  return canonical;
+};
+var trustedServices = async (services, resolveExecutable) => {
+  const resolved = new Map;
+  const invocation = async (value) => {
+    let command = resolved.get(value.command);
+    if (command === undefined) {
+      command = resolveExecutable(value.command);
+      resolved.set(value.command, command);
+    }
+    return { ...value, command: await command };
+  };
+  const secured = [];
+  for (const service of services) {
+    let check;
+    try {
+      check = await invocation(service.check);
+    } catch (cause) {
+      if (cause instanceof Error && cause.message.startsWith("Could not find ")) {
+        continue;
+      }
+      throw cause;
+    }
+    secured.push({
+      ...service,
+      check,
+      ...service.entrypoint === undefined ? {} : {
+        entrypoint: {
+          ...service.entrypoint,
+          inspect: await invocation(service.entrypoint.inspect)
+        }
+      },
+      restart: await Promise.all(service.restart.map(invocation))
+    });
+  }
+  return secured;
+};
 var serviceCandidates = (runtimePlatform, uid) => {
   if (runtimePlatform === "linux") {
     const systemd = (manager, unit, device) => {
@@ -2831,11 +3039,11 @@ var serviceCandidates = (runtimePlatform, uid) => {
         },
         restart: [
           {
-            command: "schtasks",
+            command: "schtasks.exe",
             arguments: ["/End", "/TN", "Cohall Device"],
             allowFailure: true
           },
-          { command: "schtasks", arguments: ["/Run", "/TN", "Cohall Device"] }
+          { command: "schtasks.exe", arguments: ["/Run", "/TN", "Cohall Device"] }
         ]
       }
     ];
@@ -2844,7 +3052,7 @@ var serviceCandidates = (runtimePlatform, uid) => {
 };
 var defaultRunner = {
   run: (command, arguments_, timeoutMs = 300000) => new Promise((resolve2) => {
-    execFile(command, [...arguments_], { encoding: "utf8", maxBuffer: 1024 * 1024, timeout: timeoutMs, windowsHide: true }, (error, stdout, stderr) => {
+    execFile2(command, [...arguments_], { encoding: "utf8", maxBuffer: 1024 * 1024, timeout: timeoutMs, windowsHide: true }, (error, stdout, stderr) => {
       resolve2({
         exitCode: typeof error?.code === "number" ? error.code : error === null ? 0 : 1,
         stdout,
@@ -2953,9 +3161,10 @@ var restartServices = async (runner, services, statePath, state, preserveDeviceR
 var reportedRestartServices = (receipt) => receipt.restartingService === undefined || receipt.restartedServices.includes(receipt.restartingService) ? receipt.restartedServices : [...receipt.restartedServices, receipt.restartingService];
 var upgrade = async (options) => {
   const runner = options.runner ?? defaultRunner;
+  const resolveExecutable = options.resolveExecutable ?? trustedExecutable;
   const runtimePlatform = options.platform ?? process.platform;
   const uid = options.uid ?? process.getuid?.();
-  const candidates = serviceCandidates(runtimePlatform, uid);
+  const candidates = await trustedServices(serviceCandidates(runtimePlatform, uid), resolveExecutable);
   const statePath = options.statePath ?? restartReceiptPath();
   const previous = await readReceipt(statePath);
   if (previous?.version === options.currentVersion) {
@@ -3035,7 +3244,7 @@ var upgrade = async (options) => {
       dry_run: true
     };
   }
-  await checked(runner, install);
+  await checked(runner, { ...install, command: await resolveExecutable(install.command) });
   const nextVersion = await installedVersion(entrypoint);
   if (target !== "latest" && nextVersion !== target) {
     throw new Error(`Installed Cohall ${nextVersion}, expected ${target}`);
@@ -3225,10 +3434,10 @@ var readInput = async (arguments_, name) => {
     throw new Error(`Use either --${name} or --${name}-file, not both`);
   }
   if (path !== undefined) {
-    if (!await access2(path).then(() => true).catch(() => false)) {
+    if (!await access3(path).then(() => true).catch(() => false)) {
       throw new Error(`File does not exist: ${path}`);
     }
-    if ((await stat(path)).size > 131072) {
+    if ((await stat2(path)).size > 131072) {
       throw new Error(`${name} file exceeds 128 KiB`);
     }
     return readFile3(path, "utf8");
@@ -3261,10 +3470,10 @@ var timeout = (arguments_) => {
 };
 var pairingToken = async (arguments_) => {
   const path = option(arguments_, "token-file");
-  if (path !== undefined && !await access2(path).then(() => true).catch(() => false)) {
+  if (path !== undefined && !await access3(path).then(() => true).catch(() => false)) {
     throw new Error(`Pairing token file does not exist: ${path}`);
   }
-  if (path !== undefined && (await stat(path)).size > 512) {
+  if (path !== undefined && (await stat2(path)).size > 512) {
     throw new Error("Pairing token file exceeds 512 bytes");
   }
   const token = (path === undefined ? await readStdin(512, "Pairing token") : await readFile3(path, "utf8")).trim();
@@ -3351,14 +3560,23 @@ var runCli = async (command, raw) => {
     const clientToken = paired.credentials.find((credential) => credential.session.role === "client")?.token;
     const deviceToken = paired.credentials.find((credential) => credential.session.role === "device")?.token;
     const deviceId = paired.credentials.find((credential) => credential.session.role === "device")?.session.deviceId;
-    if (!arguments_.options.has("client-only") && deviceToken === undefined) {
+    const clientOnly = arguments_.options.has("client-only");
+    if (clientOnly && clientToken === undefined) {
+      throw new Error("The pairing credential did not include client access");
+    }
+    if (!clientOnly && deviceToken === undefined) {
       throw new Error("The pairing credential did not include device access");
     }
+    const {
+      clientToken: _retainedClientToken,
+      deviceToken: _retainedDeviceToken,
+      ...configurationDraft
+    } = draft;
     const configuration2 = StoredConfiguration.make({
-      ...draft,
-      deviceId: deviceId ?? draft.deviceId,
+      ...configurationDraft,
+      deviceId: clientOnly ? configurationDraft.deviceId : deviceId ?? configurationDraft.deviceId,
       ...clientToken === undefined ? {} : { clientToken },
-      ...deviceToken === undefined ? {} : { deviceToken }
+      ...clientOnly || deviceToken === undefined ? {} : { deviceToken }
     });
     await writeStoredConfiguration(configuration2);
     print({
@@ -3366,7 +3584,7 @@ var runCli = async (command, raw) => {
       config_path: configurationPath(),
       relay_url: configuration2.relayUrl,
       device_id: configuration2.deviceId,
-      roles: paired.credentials.map((credential) => credential.session.role),
+      roles: clientOnly ? paired.credentials.map((credential) => credential.session.role).filter((role) => role === "client") : paired.credentials.map((credential) => credential.session.role),
       workspaces: configuration2.workspaces
     });
     return;
@@ -3618,11 +3836,11 @@ var runCli = async (command, raw) => {
 // apps/device/src/daemon.ts
 init_src();
 import { Effect as Effect6, Schedule as Schedule2, Schema as Schema8 } from "effect";
-import { realpath as realpath3 } from "node:fs/promises";
+import { constants as constants3 } from "node:fs";
+import { open, realpath as realpath3, stat as stat3 } from "node:fs/promises";
 import { arch, hostname as hostname2, platform as platform3 } from "node:os";
-import { basename, isAbsolute as isAbsolute2, relative } from "node:path";
+import { basename, isAbsolute as isAbsolute3, relative } from "node:path";
 import { WebSocket } from "ws";
-var maxRelayPayloadBytes = 256 * 1024;
 var maxQueuedRelayMessages = 8;
 
 class DeviceConnectionError extends Schema8.TaggedErrorClass()("Device.ConnectionError", { message: Schema8.String }) {
@@ -3691,13 +3909,42 @@ var allowedWorkspace = async (configuration, requested) => {
   const candidate = await realpath3(selected);
   const allowed = configuration.workspaces.some((root) => {
     const child = relative(root, candidate);
-    return child === "" || !child.startsWith("..") && !isAbsolute2(child);
+    return child === "" || !child.startsWith("..") && !isAbsolute3(child);
   });
   if (!allowed) {
     throw new Error(`Workspace ${candidate} is outside this device's configured workspace roots`);
   }
   return candidate;
 };
+var openAllowedWorkspace = async (configuration, requested) => {
+  const path = await allowedWorkspace(configuration, requested);
+  const operatingSystem2 = platform3();
+  const flags = constants3.O_RDONLY | (operatingSystem2 === "win32" ? 0 : constants3.O_DIRECTORY | constants3.O_NOFOLLOW);
+  const handle = await open(path, flags);
+  const identity = await handle.stat();
+  if (!identity.isDirectory()) {
+    await handle.close();
+    throw new Error(`Workspace ${path} is not a directory`);
+  }
+  const cwd = operatingSystem2 === "linux" ? `/proc/self/fd/${handle.fd}` : operatingSystem2 === "darwin" ? `/dev/fd/${handle.fd}` : path;
+  return {
+    cwd,
+    validate: async () => {
+      const current = await handle.stat();
+      if (!current.isDirectory() || current.dev !== identity.dev || current.ino !== identity.ino) {
+        throw new Error(`Workspace ${path} changed before provider startup`);
+      }
+      if (operatingSystem2 === "win32") {
+        const currentPath = await realpath3(path);
+        const currentPathIdentity = await stat3(currentPath);
+        if (currentPathIdentity.dev !== identity.dev || currentPathIdentity.ino !== identity.ino) {
+          throw new Error(`Workspace ${path} changed before provider startup`);
+        }
+      }
+    },
+    close: () => handle.close()
+  };
+};
 var promptFor = (task, deviceName) => {
   const context = task.context === undefined ? "" : `
 
@@ -3746,8 +3993,8 @@ var execute = (configuration, state, task) => {
   state.tasks.set(task.id, controller);
   send(state, SocketEvent.make({ _tag: "TaskAccepted", taskId: task.id }));
   const workflow = Effect6.gen(function* () {
-    const cwd = yield* Effect6.tryPromise({
-      try: () => allowedWorkspace(configuration, task.workspace),
+    const workspace = yield* Effect6.tryPromise({
+      try: () => openAllowedWorkspace(configuration, task.workspace),
       catch: (cause) => new ProviderRunError({
         provider: task.provider,
         message: cause instanceof Error ? cause.message : String(cause)
@@ -3758,11 +4005,14 @@ var execute = (configuration, state, task) => {
       provider: task.provider,
       threadId: task.threadId,
       prompt: promptFor(task, configuration.name),
-      cwd,
+      cwd: workspace.cwd,
+      beforeSpawn: workspace.validate,
       ...sessionId === undefined ? {} : { sessionId },
       ...configuration.model === undefined ? {} : { model: configuration.model },
       ...configuration.sandbox === undefined ? {} : { sandbox: configuration.sandbox }
-    });
+    }).pipe(Effect6.ensuring(Effect6.promise(() => workspace.close().catch(() => {
+      return;
+    }))));
   });
   Effect6.runPromise(workflow, { signal: controller.signal }).then((result) => {
     if (result.sessionId !== undefined) {
@@ -3823,7 +4073,7 @@ var cancel = (state, taskId) => {
 var connect = (configuration, state) => Effect6.tryPromise({
   try: (signal) => new Promise((complete) => {
     const socket = new WebSocket(socketUrl(configuration), {
-      maxPayload: maxRelayPayloadBytes,
+      maxPayload: maxSocketPayloadBytes,
       perMessageDeflate: false
     });
     const heartbeat = setInterval(() => {
@@ -4014,12 +4264,12 @@ var main = async () => {
     console.log(version);
     return;
   }
+  const commandArguments = process.argv.slice(3);
+  if (commandArguments.length === 1 && ["--help", "-h", "help"].includes(commandArguments[0] ?? "")) {
+    printHelp();
+    return;
+  }
   if (["device", "relay", "mcp"].includes(command) && process.argv.length > 3) {
-    const arguments_ = process.argv.slice(3);
-    if (arguments_.length === 1 && ["--help", "-h", "help"].includes(arguments_[0] ?? "")) {
-      printHelp();
-      return;
-    }
     throw new Error(`${command} does not accept arguments`);
   }
   if (command === "relay") {
@@ -4037,11 +4287,11 @@ var main = async () => {
     await runMcp(configuration);
     return;
   }
-  await runCli(command, process.argv.slice(3));
+  await runCli(command, commandArguments);
 };
 await main().catch((cause) => {
   console.error(JSON.stringify({ error: cause instanceof Error ? cause.message : String(cause) }, null, 2));
   process.exitCode = 1;
 });
 
-//# debugId=DD6CA056CEE6744B64756E2164756E21
+//# debugId=1A046C86E8783E4364756E2164756E21