@akshar5/cohall 0.4.0 → 0.4.2

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.4.2](https://github.com/AksharP5/cohall/compare/v0.4.1...v0.4.2) (2026-08-07)
+
+
+### Bug Fixes
+
+* **upgrade:** detect service installation mismatches ([19bf066](https://github.com/AksharP5/cohall/commit/19bf06674d6fac87576f804e92d863d5c673dda0))
+
+## [0.4.1](https://github.com/AksharP5/cohall/compare/v0.4.0...v0.4.1) (2026-08-07)
+
+
+### Bug Fixes
+
+* **device:** bound relay message buffering ([15b975e](https://github.com/AksharP5/cohall/commit/15b975eb658ac8b1140ed0481ab4726543265ca4))
+* **providers:** bound JSON events while streaming ([7e0a4fc](https://github.com/AksharP5/cohall/commit/7e0a4fccc1b68e630b0b8bb553bbb66b84795798))
+* **providers:** preserve custom config for nested delegation ([#21](https://github.com/AksharP5/cohall/issues/21)) ([63c95f8](https://github.com/AksharP5/cohall/commit/63c95f84f00ad03ad8d017696a5a87cbb8c6c05d))
+* **upgrade:** restart already-current services ([a2c775f](https://github.com/AksharP5/cohall/commit/a2c775fe48a4dffda54ea7537f34b1a2b6d1e6ed))
+
 ## [0.4.0](https://github.com/AksharP5/cohall/compare/v0.3.4...v0.4.0) (2026-08-07)
 
 

package/README.md

@@ -223,7 +223,10 @@ status, provider selection, executable paths, and version information.
 
 For a global installation used by services, `cohall upgrade` updates through
 the same npm, Bun, or pnpm installation and restarts only active Cohall relay
-and device jobs. Use `cohall upgrade --dry-run` to inspect the plan or
+and device jobs. Active jobs restart even when the installed files are already
+current, ensuring an older loaded process is replaced. Cohall refuses to restart
+a service configured to use a different global installation; run that service's
+executable directly or update its service definition first. Use `cohall upgrade --dry-run` to inspect the plan or
 `cohall upgrade --no-restart` to update files without restarting services.
 Environment variables override stored values:
 

package/bin/cohall.js

@@ -17,7 +17,7 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // packages/protocol/src/index.ts
 import { Schema } from "effect";
-var version = "0.4.0", 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.2", 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(() => {
@@ -1742,7 +1742,6 @@ 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 { createInterface } from "node:readline";
 
 class ProviderUnavailableError extends Schema3.TaggedErrorClass()("CohallProvider.Unavailable", { provider: Provider, message: Schema3.String }) {
 }
@@ -1759,7 +1758,7 @@ var executables = {
   opencode: "opencode"
 };
 var providerEnvironment = () => ({
-  ...Object.fromEntries(Object.entries(process.env).filter(([name]) => !name.startsWith("COHALL_"))),
+  ...Object.fromEntries(Object.entries(process.env).filter(([name]) => !name.startsWith("COHALL_") || name === "COHALL_CONFIG")),
   PATH: executableDirectories().join(delimiter)
 });
 var record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? Object.fromEntries(Object.entries(value)) : undefined;
@@ -1927,22 +1926,43 @@ var prepareCommand = async (options) => {
   }
 };
 var forEachJsonEvent = async (stdout, onEvent) => {
-  const lines = createInterface({ input: stdout, crlfDelay: Infinity });
-  try {
-    for await (const line of lines) {
-      if (line.trim().length === 0) {
-        continue;
-      }
-      if (Buffer.byteLength(line) > 1024 * 1024) {
-        throw new Error("Provider event exceeded 1024 KiB");
-      }
-      const event = record(JSON.parse(line));
-      if (event !== undefined) {
-        onEvent(event);
-      }
+  const limit = 1024 * 1024;
+  let chunks = [];
+  let size = 0;
+  const append = (chunk) => {
+    if (size + chunk.byteLength > limit) {
+      throw new Error("Provider event exceeded 1024 KiB");
+    }
+    if (chunk.byteLength > 0) {
+      chunks.push(chunk);
+      size += chunk.byteLength;
+    }
+  };
+  const emit = () => {
+    const line = Buffer.concat(chunks, size).toString("utf8");
+    chunks = [];
+    size = 0;
+    if (line.trim().length === 0) {
+      return;
+    }
+    const event = record(JSON.parse(line));
+    if (event !== undefined) {
+      onEvent(event);
+    }
+  };
+  for await (const chunk of stdout) {
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+    let start = 0;
+    for (let newline = bytes.indexOf(10, start);newline !== -1; ) {
+      append(bytes.subarray(start, newline));
+      emit();
+      start = newline + 1;
+      newline = bytes.indexOf(10, start);
     }
-  } finally {
-    lines.close();
+    append(bytes.subarray(start));
+  }
+  if (size > 0) {
+    emit();
   }
 };
 var parseCodex = async (stdout, existingSession) => {
@@ -2596,6 +2616,7 @@ var normalizeUpgradeTarget = (target) => {
   }
   return normalized;
 };
+var deviceVersionWarning = (cliVersion, deviceVersion) => deviceVersion === undefined || deviceVersion === cliVersion ? undefined : `Running device daemon uses Cohall ${deviceVersion}, while this CLI is ${cliVersion}. Run upgrade through the executable configured by the device service.`;
 var packageInstallation = (canonicalEntrypoint, entrypoint = canonicalEntrypoint) => {
   const path = normalizePath(canonicalEntrypoint);
   const marker = `/node_modules/${packageName}/`;
@@ -2645,6 +2666,13 @@ var serviceCandidates = (runtimePlatform, uid) => {
         manager,
         device,
         check: { command: "systemctl", arguments: [...user, "is-active", "--quiet", unit] },
+        entrypoint: {
+          inspect: {
+            command: "systemctl",
+            arguments: [...user, "show", "--property=ExecStart", "--value", unit]
+          },
+          parse: (output) => output.match(/\bpath=(.*?)\s*;/)?.[1]?.trim()
+        },
         restart: [{ command: "systemctl", arguments: [...user, "restart", unit] }]
       };
     };
@@ -2663,6 +2691,10 @@ var serviceCandidates = (runtimePlatform, uid) => {
       device,
       check: { command: "launchctl", arguments: ["print", `${domain}/${label}`] },
       activeOutput: /\bstate\s*=\s*running\b/,
+      entrypoint: {
+        inspect: { command: "launchctl", arguments: ["print", `${domain}/${label}`] },
+        parse: (output) => output.match(/^\s*program\s*=\s*(.+)$/m)?.[1]?.trim()
+      },
       restart: [{ command: "launchctl", arguments: ["kickstart", "-k", `${domain}/${label}`] }]
     });
     return [launchd("com.cohall.relay", false), launchd("com.cohall.device", true)];
@@ -2727,6 +2759,26 @@ ${result.stderr}`))) {
   }
   return active;
 };
+var assertServiceInstallations = async (runner, services, canonicalEntrypoint, entrypoint) => {
+  for (const service of services) {
+    if (service.entrypoint === undefined) {
+      continue;
+    }
+    const result = await checked(runner, service.entrypoint.inspect, 1e4);
+    const serviceEntrypoint = service.entrypoint.parse(`${result.stdout}
+${result.stderr}`);
+    if (serviceEntrypoint === undefined) {
+      throw new Error(`Could not determine the executable used by active ${service.label}`);
+    }
+    const canonicalServiceEntrypoint = await realpath2(serviceEntrypoint).catch((cause) => {
+      throw new Error(`Could not resolve the executable used by active ${service.label}: ${cause instanceof Error ? cause.message : String(cause)}`);
+    });
+    if (canonicalServiceEntrypoint === canonicalEntrypoint) {
+      continue;
+    }
+    throw new Error(`Active ${service.label} uses ${serviceEntrypoint}, but this Cohall CLI uses ${entrypoint}. Run the service executable's upgrade command so its installation is updated before restart.`);
+  }
+};
 var readReceipt = async (path) => readFile2(path, "utf8").then((content) => Schema6.decodeUnknownOption(RestartReceipt)(JSON.parse(content))).then((decoded) => decoded._tag === "Some" ? decoded.value : undefined).catch(() => {
   return;
 });
@@ -2827,9 +2879,11 @@ var upgrade = async (options) => {
   if (entrypoint === undefined) {
     throw new Error("Could not resolve the Cohall executable path");
   }
-  const installation = packageInstallation(await realpath2(entrypoint), entrypoint);
+  const canonicalEntrypoint = await realpath2(entrypoint);
+  const installation = packageInstallation(canonicalEntrypoint, entrypoint);
   const install = packageInstallCommand(installation, target);
   const services = await activeServices(runner, candidates);
+  await assertServiceInstallations(runner, services, canonicalEntrypoint, entrypoint);
   if (options.dryRun) {
     return {
       upgraded: false,
@@ -2849,7 +2903,7 @@ var upgrade = async (options) => {
     throw new Error(`Installed Cohall ${nextVersion}, expected ${target}`);
   }
   const upgraded = nextVersion !== options.currentVersion;
-  if (!upgraded || !options.restart || services.length === 0) {
+  if (!options.restart || services.length === 0) {
     return {
       upgraded,
       from_version: options.currentVersion,
@@ -2857,7 +2911,7 @@ var upgrade = async (options) => {
       requested_version: target,
       package_manager: installation.manager,
       services_restarted: [],
-      services_pending_restart: upgraded && !options.restart ? services.map((service) => service.id) : [],
+      services_pending_restart: options.restart ? [] : services.map((service) => service.id),
       resumed_after_restart: false,
       dry_run: false
     };
@@ -2873,7 +2927,7 @@ var upgrade = async (options) => {
   const completed = await restartServices(runner, services, statePath, initial);
   await rm2(statePath, { force: true });
   return {
-    upgraded: true,
+    upgraded,
     from_version: options.currentVersion,
     installed_version: nextVersion,
     requested_version: target,
@@ -3279,8 +3333,10 @@ var runCli = async (command, raw) => {
     const currentDevice = response?.ok !== true || clientToken === undefined || deviceId === undefined ? undefined : await Effect5.runPromise(exports_src.make({ baseUrl: relayUrl, token: clientToken }).devices()).then((devices) => devices.find((device) => device.id === deviceId)).catch(() => {
       return;
     });
+    const versionWarning = deviceVersionWarning(version, currentDevice?.version);
     const warnings = [
       ...response?.ok === true ? [] : ["Relay is unreachable"],
+      ...versionWarning === undefined ? [] : [versionWarning],
       ...hasDeviceCredential && response?.ok === true && currentDevice?.status !== "online" && currentDevice?.status !== "busy" ? [
         clientToken === undefined ? "Device status cannot be checked without a client credential" : "Device daemon is not connected or is not registered with the relay"
       ] : [],
@@ -3420,6 +3476,8 @@ import { realpath as realpath3 } 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 { WebSocket } from "ws";
+var maxRelayPayloadBytes = 256 * 1024;
+var maxQueuedRelayMessages = 8;
 
 class DeviceConnectionError extends Schema8.TaggedErrorClass()("Device.ConnectionError", { message: Schema8.String }) {
 }
@@ -3618,7 +3676,10 @@ var cancel = (state, taskId) => {
 };
 var connect = (configuration, state) => Effect6.tryPromise({
   try: (signal) => new Promise((complete) => {
-    const socket = new WebSocket(socketUrl(configuration));
+    const socket = new WebSocket(socketUrl(configuration), {
+      maxPayload: maxRelayPayloadBytes,
+      perMessageDeflate: false
+    });
     const heartbeat = setInterval(() => {
       send(state, SocketEvent.make({
         _tag: "DeviceHeartbeat",
@@ -3627,6 +3688,7 @@ var connect = (configuration, state) => Effect6.tryPromise({
       }));
     }, 15000);
     let closed = false;
+    let queuedMessages = 0;
     const close = () => {
       if (closed) {
         return;
@@ -3646,8 +3708,16 @@ var connect = (configuration, state) => Effect6.tryPromise({
       socket.send(JSON.stringify(SocketEvent.make({ _tag: "Authenticate", token: configuration.token })));
     });
     socket.on("message", (message) => {
-      const text2 = Buffer.isBuffer(message) ? message.toString("utf8") : message instanceof ArrayBuffer ? Buffer.from(message).toString("utf8") : Array.isArray(message) ? Buffer.concat(message).toString("utf8") : Buffer.from(message).toString("utf8");
+      if (queuedMessages >= maxQueuedRelayMessages) {
+        socket.close(4008, "Message queue limit reached");
+        return;
+      }
+      queuedMessages += 1;
       state.processing = state.processing.then(async () => {
+        if (closed) {
+          return;
+        }
+        const text2 = Buffer.isBuffer(message) ? message.toString("utf8") : message instanceof ArrayBuffer ? Buffer.from(message).toString("utf8") : Array.isArray(message) ? Buffer.concat(message).toString("utf8") : Buffer.from(message).toString("utf8");
         const event = await Effect6.runPromise(Effect6.try({
           try: () => JSON.parse(text2),
           catch: () => new DeviceConnectionError({ message: "Relay sent invalid JSON" })
@@ -3680,6 +3750,8 @@ var connect = (configuration, state) => Effect6.tryPromise({
         }
       }).catch((cause) => {
         console.error(`Invalid relay event: ${cause instanceof Error ? cause.message : String(cause)}`);
+      }).finally(() => {
+        queuedMessages = Math.max(0, queuedMessages - 1);
       });
     });
     socket.once("close", close);
@@ -3826,4 +3898,4 @@ await main().catch((cause) => {
   process.exitCode = 1;
 });
 
-//# debugId=C3D1F939F21B764D64756E2164756E21
+//# debugId=D69D718E229B95B264756E2164756E21