@danielblomma/cortex-mcp 2.2.5 → 2.4.1

package/scaffold/mcp/src/core/license.ts

@@ -1,6 +1,18 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import {
+  chmodSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  existsSync,
+  renameSync,
+  unlinkSync,
+} from "node:fs";
 import { join } from "node:path";
 import { resolveTelemetryStateDir, telemetryStatePath } from "./telemetry/state-dir.js";
+import { isAllowedEnterpriseEndpoint } from "./secure-endpoint.js";
+
+export { isAllowedEnterpriseEndpoint as isAllowedLicenseEndpoint };
 
 export type LicenseVerification =
   | {
@@ -20,6 +32,9 @@ export type LicenseVerification =
     };
 
 type CacheEntry = {
+  version: 2;
+  endpoint: string;
+  api_key_sha256: string;
   result: LicenseVerification;
   // ISO timestamp for cache freshness window
   cached_at: string;
@@ -34,23 +49,83 @@ function cachePath(contextDir: string): string {
   return telemetryStatePath(contextDir, CACHE_FILE);
 }
 
+function isIsoTimestamp(value: unknown): value is string {
+  if (typeof value !== "string") return false;
+  const timestamp = new Date(value).getTime();
+  return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value;
+}
+
 function readCache(contextDir: string): CacheEntry | null {
   const path = cachePath(contextDir);
   if (!existsSync(path)) return null;
   try {
     const raw = readFileSync(path, "utf8");
-    return JSON.parse(raw) as CacheEntry;
+    const parsed = JSON.parse(raw) as Partial<CacheEntry>;
+    if (
+      !parsed ||
+      typeof parsed !== "object" ||
+      parsed.version !== 2 ||
+      typeof parsed.endpoint !== "string" ||
+      !parsed.endpoint ||
+      typeof parsed.api_key_sha256 !== "string" ||
+      !/^[a-f0-9]{64}$/.test(parsed.api_key_sha256) ||
+      !parsed.result ||
+      typeof parsed.result !== "object" ||
+      typeof parsed.result.valid !== "boolean" ||
+      !isIsoTimestamp(parsed.cached_at)
+    ) {
+      deleteCache(contextDir);
+      return null;
+    }
+    if (parsed.result.valid) {
+      if (
+        typeof parsed.result.edition !== "string" ||
+        !Array.isArray(parsed.result.features) ||
+        !parsed.result.features.every((feature) => typeof feature === "string") ||
+        !isIsoTimestamp(parsed.result.expires_at) ||
+        typeof parsed.result.max_repos !== "number" ||
+        !Number.isFinite(parsed.result.max_repos) ||
+        parsed.result.max_repos < 0 ||
+        !isIsoTimestamp(parsed.result.verified_at) ||
+        !["remote", "cache"].includes(parsed.result.source)
+      ) {
+        deleteCache(contextDir);
+        return null;
+      }
+    } else if (
+      typeof parsed.result.reason !== "string" ||
+      !isIsoTimestamp(parsed.result.verified_at) ||
+      !["remote", "cache", "grace_expired"].includes(parsed.result.source)
+    ) {
+      deleteCache(contextDir);
+      return null;
+    }
+    return parsed as CacheEntry;
   } catch {
+    deleteCache(contextDir);
     return null;
   }
 }
 
 function writeCache(contextDir: string, entry: CacheEntry): void {
   const path = cachePath(contextDir);
+  const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
   try {
     mkdirSync(resolveTelemetryStateDir(contextDir), { recursive: true });
-    writeFileSync(path, JSON.stringify(entry, null, 2), "utf8");
+    writeFileSync(
+      temporaryPath,
+      JSON.stringify(entry, null, 2) + "\n",
+      { encoding: "utf8", mode: 0o600, flag: "wx" },
+    );
+    chmodSync(temporaryPath, 0o600);
+    renameSync(temporaryPath, path);
+    chmodSync(path, 0o600);
   } catch {
+    try {
+      unlinkSync(temporaryPath);
+    } catch {
+      // Best effort.
+    }
     // Cache failures are non-fatal — license check just won't be cached.
   }
 }
@@ -69,6 +144,48 @@ function ageMs(isoTimestamp: string): number {
   return Date.now() - new Date(isoTimestamp).getTime();
 }
 
+export function normalizeLicenseEndpoint(endpoint: string): string {
+  return endpoint.trim().replace(/\/+$/, "");
+}
+
+function apiKeyFingerprint(apiKey: string): string {
+  return createHash("sha256").update(apiKey, "utf8").digest("hex");
+}
+
+function cacheMatchesCredential(
+  cached: CacheEntry,
+  endpoint: string,
+  apiKey: string,
+): boolean {
+  return (
+    cached.version === 2 &&
+    cached.endpoint === normalizeLicenseEndpoint(endpoint) &&
+    cached.api_key_sha256 === apiKeyFingerprint(apiKey)
+  );
+}
+
+export function enterpriseCredentialId(
+  endpoint: string,
+  apiKey: string,
+): string {
+  return createHash("sha256")
+    .update(normalizeLicenseEndpoint(endpoint), "utf8")
+    .update("\0", "utf8")
+    .update(apiKey, "utf8")
+    .digest("hex");
+}
+
+function cacheResultIsUnexpired(cached: CacheEntry): boolean {
+  if (!cached.result.valid) return false;
+  const expiresAt = new Date(cached.result.expires_at).getTime();
+  return Number.isFinite(expiresAt) && expiresAt > Date.now();
+}
+
+function cacheAgeIsWithin(cached: CacheEntry, limitMs: number): boolean {
+  const age = ageMs(cached.cached_at);
+  return Number.isFinite(age) && age >= 0 && age < limitMs;
+}
+
 async function fetchLicense(
   endpoint: string,
   apiKey: string,
@@ -93,21 +210,41 @@ async function fetchLicense(
       signal: controller.signal,
     });
 
+    if (res.status === 401 || res.status === 403) {
+      return {
+        valid: false,
+        reason: "authentication_rejected",
+        verified_at: new Date().toISOString(),
+        source: "remote",
+      };
+    }
+
     if (!res.ok) {
-      // 401/429/5xx — treat as transient, surface null so caller can fall back.
+      // Rate limiting, server failures, and other transport-level responses
+      // may use an identity-matched positive cache during the grace period.
       return null;
     }
 
     const json = (await res.json()) as Record<string, unknown>;
     const verifiedAt = new Date().toISOString();
 
-    if (json.valid === true) {
+    if (
+      json.valid === true &&
+      typeof json.edition === "string" &&
+      Array.isArray(json.features) &&
+      json.features.every((feature) => typeof feature === "string") &&
+      isIsoTimestamp(json.expires_at) &&
+      new Date(json.expires_at).getTime() > Date.now() &&
+      typeof json.max_repos === "number" &&
+      Number.isFinite(json.max_repos) &&
+      json.max_repos >= 0
+    ) {
       return {
         valid: true,
-        edition: String(json.edition ?? "unknown"),
-        features: Array.isArray(json.features) ? json.features.map(String) : [],
-        expires_at: String(json.expires_at ?? ""),
-        max_repos: typeof json.max_repos === "number" ? json.max_repos : 0,
+        edition: json.edition,
+        features: json.features,
+        expires_at: json.expires_at,
+        max_repos: json.max_repos,
         verified_at: verifiedAt,
         source: "remote",
       };
@@ -115,7 +252,9 @@ async function fetchLicense(
 
     return {
       valid: false,
-      reason: String(json.reason ?? "unknown"),
+      reason: json.valid === true
+        ? "malformed_license_response"
+        : String(json.reason ?? "unknown"),
       verified_at: verifiedAt,
       source: "remote",
     };
@@ -129,7 +268,8 @@ async function fetchLicense(
 
 /**
  * Verify the license for the given api_key. Layered fallback:
- *   1. If a positive cache (valid:true) is fresh (<24h) → use cache
+ *   1. If a positive cache (valid:true) is fresh (<24h), unexpired, and
+ *      bound to this endpoint + API-key fingerprint → use cache
  *      Negative cache entries are never trusted; if one is encountered
  *      it's deleted on the spot so a since-fixed remote can heal.
  *   2. Otherwise try remote endpoint
@@ -138,8 +278,9 @@ async function fetchLicense(
  *        cache (so a revoked/expired key doesn't keep masquerading as
  *        valid past its remote-side fail), return result, do NOT
  *        cache the negative.
- *      - On transient failure → fall back to positive cache if within
- *        grace period (7d). If only a negative cache exists, ignore it.
+ *      - On transient failure → fall back to the same identity-bound positive
+ *        cache if within the grace period (7d). Authentication rejection is
+ *        authoritative and never uses grace.
  *   3. If no usable cache and endpoint unreachable → return invalid
  *      (grace_expired).
  *
@@ -153,6 +294,16 @@ export async function verifyLicense(
   apiKey: string,
   options: { instance_id?: string; client_version?: string } = {},
 ): Promise<LicenseVerification> {
+  if (!isAllowedEnterpriseEndpoint(endpoint)) {
+    deleteCache(contextDir);
+    return {
+      valid: false,
+      reason: "insecure_or_invalid_endpoint",
+      verified_at: new Date().toISOString(),
+      source: "remote",
+    };
+  }
+
   let cached = readCache(contextDir);
 
   // Defensive: a previous version of this code wrote negative results
@@ -163,9 +314,19 @@ export async function verifyLicense(
     cached = null;
   }
 
+  const matchingCache =
+    cached && cacheMatchesCredential(cached, endpoint, apiKey)
+      ? cached
+      : null;
+
   // Fresh positive cache: skip remote.
-  if (cached && cached.result.valid === true && ageMs(cached.cached_at) < CACHE_TTL_MS) {
-    return { ...cached.result, source: "cache" };
+  if (
+    matchingCache &&
+    matchingCache.result.valid === true &&
+    cacheResultIsUnexpired(matchingCache) &&
+    cacheAgeIsWithin(matchingCache, CACHE_TTL_MS)
+  ) {
+    return { ...matchingCache.result, source: "cache" };
   }
 
   const remote = await fetchLicense(
@@ -178,6 +339,9 @@ export async function verifyLicense(
   if (remote) {
     if (remote.valid) {
       writeCache(contextDir, {
+        version: 2,
+        endpoint: normalizeLicenseEndpoint(endpoint),
+        api_key_sha256: apiKeyFingerprint(apiKey),
         result: remote,
         cached_at: new Date().toISOString(),
       });
@@ -190,8 +354,13 @@ export async function verifyLicense(
   }
 
   // Remote unreachable. Fall back to positive cache if within grace.
-  if (cached && cached.result.valid === true && ageMs(cached.cached_at) < GRACE_PERIOD_MS) {
-    return { ...cached.result, source: "cache" };
+  if (
+    matchingCache &&
+    matchingCache.result.valid === true &&
+    cacheResultIsUnexpired(matchingCache) &&
+    cacheAgeIsWithin(matchingCache, GRACE_PERIOD_MS)
+  ) {
+    return { ...matchingCache.result, source: "cache" };
   }
 
   return {

package/scaffold/mcp/src/core/secure-endpoint.ts

@@ -0,0 +1,23 @@
+/**
+ * Enterprise bearer credentials may travel only over TLS. Loopback HTTP is
+ * retained for local development because the connection cannot leave the
+ * host. Embedded URL credentials are never accepted.
+ */
+export function isAllowedEnterpriseEndpoint(endpoint: string): boolean {
+  let parsed: URL;
+  try {
+    parsed = new URL(endpoint);
+  } catch {
+    return false;
+  }
+  if (parsed.username || parsed.password) return false;
+  if (parsed.protocol === "https:") return true;
+  if (parsed.protocol !== "http:") return false;
+  const host = parsed.hostname.toLowerCase();
+  return (
+    host === "localhost" ||
+    host === "127.0.0.1" ||
+    host === "::1" ||
+    host === "[::1]"
+  );
+}

package/scaffold/mcp/src/core/workflow/enforcement.ts

@@ -5,6 +5,7 @@ import { DEFAULT_CAPABILITIES, type CapabilityDefinition } from "./capabilities.
 import { workflowDefinitionSchema, type WorkflowDefinition } from "./schemas.js";
 import { DEFAULT_WORKFLOWS } from "./default-workflows.js";
 import { loadSyncedCapabilities } from "./synced-capability-registry.js";
+import { configuredEnterpriseCredentialId } from "../enterprise-identity.js";
 
 /**
  * Pre-tool-use enforcement for the harness. Pure function: takes the tool
@@ -89,7 +90,13 @@ export function evaluateToolCall(options: EvaluateOptions): EnforcementResult {
   // capabilities, with synced ones taking precedence on name collisions
   // so org overrides actually override.
   const capabilities =
-    options.capabilities ?? { ...DEFAULT_CAPABILITIES, ...loadSyncedCapabilities() };
+    options.capabilities ?? {
+      ...DEFAULT_CAPABILITIES,
+      ...loadSyncedCapabilities(
+        undefined,
+        configuredEnterpriseCredentialId(options.cwd) ?? undefined,
+      ),
+    };
   const capability = capabilities[stage.capability];
   if (!capability) {
     return {

package/scaffold/mcp/src/core/workflow/mcp-tools.ts

@@ -96,6 +96,7 @@ export function runWorkflowStart(
 ) {
   const resolved = resolveWorkflowDefinition(input.workflow_id, {
     registry: ctx.workflows,
+    cwd: ctx.cwd,
     bundledFallbackPolicy: ctx.bundledFallbackPolicy,
   });
   const workflow = resolved.workflow;
@@ -130,6 +131,7 @@ export function runWorkflowAdvance(
   }
   const workflow = resolveWorkflowDefinition(state.workflow_id, {
     registry: ctx.workflows,
+    cwd: ctx.cwd,
   }).workflow;
   const stage = workflow.stages.find((s) => s.name === input.stage);
   if (!stage) {
@@ -210,6 +212,7 @@ export function runWorkflowEnvelope(
   }
   const workflow = resolveWorkflowDefinition(state.workflow_id, {
     registry: ctx.workflows,
+    cwd: ctx.cwd,
   }).workflow;
   const envelope = composeStageEnvelope({
     cwd: ctx.cwd,

package/scaffold/mcp/src/core/workflow/resolution.ts

@@ -1,5 +1,6 @@
 import { DEFAULT_WORKFLOWS } from "./default-workflows.js";
 import { loadSyncedWorkflows } from "./synced-registry.js";
+import { configuredEnterpriseCredentialId } from "../enterprise-identity.js";
 import type { WorkflowDefinition } from "./schemas.js";
 
 export type WorkflowSource = "bundled" | "synced" | "injected";
@@ -24,6 +25,7 @@ export type WorkflowResolution = {
 type ResolveWorkflowOptions = {
   registry?: Record<string, WorkflowDefinition>;
   syncedDir?: string;
+  cwd?: string;
   emitBundledFallbackWarning?: boolean;
   bundledFallbackPolicy?: "allow" | "warn" | "block";
 };
@@ -59,7 +61,13 @@ export function resolveWorkflowDefinition(
   }
 
   const bundled = DEFAULT_WORKFLOWS;
-  const synced = loadSyncedWorkflows(options.syncedDir);
+  const expectedCredentialId = options.syncedDir
+    ? undefined
+    : configuredEnterpriseCredentialId(options.cwd ?? process.cwd()) ?? undefined;
+  const synced = loadSyncedWorkflows(
+    options.syncedDir,
+    expectedCredentialId,
+  );
   const bundledIds = sortIds(Object.keys(bundled));
   const syncedIds = sortIds(Object.keys(synced));
   const merged = { ...bundled, ...synced };

package/scaffold/mcp/src/core/workflow/synced-capability-registry.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { configuredEnterpriseCredentialId } from "../enterprise-identity.js";
 import {
   capabilityDefinitionSchema,
   type CapabilityDefinition,
@@ -27,6 +28,7 @@ type LocalCapabilityRecord = {
 };
 
 type LocalCapabilitiesState = {
+  credential_id?: string;
   capabilities?: Record<string, LocalCapabilityRecord>;
 };
 
@@ -42,6 +44,7 @@ export function syncedCapabilitiesCachePath(dir?: string): string {
  */
 export function loadSyncedCapabilities(
   dir?: string,
+  expectedCredentialId?: string,
 ): Record<string, CapabilityDefinition> {
   const path = syncedCapabilitiesCachePath(dir);
   if (!existsSync(path)) return {};
@@ -52,6 +55,18 @@ export function loadSyncedCapabilities(
   } catch {
     return {};
   }
+  const requiredCredentialId =
+    expectedCredentialId ??
+    (dir ? undefined : configuredEnterpriseCredentialId(process.cwd()));
+  if (!dir && !requiredCredentialId) {
+    return {};
+  }
+  if (
+    requiredCredentialId &&
+    parsed.credential_id !== requiredCredentialId
+  ) {
+    return {};
+  }
   const records = parsed.capabilities;
   if (!records || typeof records !== "object") return {};
 

package/scaffold/mcp/src/core/workflow/synced-registry.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { configuredEnterpriseCredentialId } from "../enterprise-identity.js";
 import { workflowDefinitionSchema, type WorkflowDefinition } from "./schemas.js";
 
 /**
@@ -25,6 +26,7 @@ type LocalWorkflowRecord = {
 };
 
 type LocalWorkflowsState = {
+  credential_id?: string;
   workflows?: Record<string, LocalWorkflowRecord>;
 };
 
@@ -40,6 +42,7 @@ export function syncedWorkflowsCachePath(dir?: string): string {
  */
 export function loadSyncedWorkflows(
   dir?: string,
+  expectedCredentialId?: string,
 ): Record<string, WorkflowDefinition> {
   const path = syncedWorkflowsCachePath(dir);
   if (!existsSync(path)) return {};
@@ -50,6 +53,18 @@ export function loadSyncedWorkflows(
   } catch {
     return {};
   }
+  const requiredCredentialId =
+    expectedCredentialId ??
+    (dir ? undefined : configuredEnterpriseCredentialId(process.cwd()));
+  if (!dir && !requiredCredentialId) {
+    return {};
+  }
+  if (
+    requiredCredentialId &&
+    parsed.credential_id !== requiredCredentialId
+  ) {
+    return {};
+  }
   const records = parsed.workflows;
   if (!records || typeof records !== "object") return {};
 

package/scaffold/mcp/src/daemon/capability-sync-checker.ts

@@ -6,6 +6,11 @@ import {
 import { hostname } from "node:os";
 import { join } from "node:path";
 import { loadEnterpriseConfig } from "../core/config.js";
+import { matchesEnterpriseHostIdentity } from "../core/enterprise-host-identity.js";
+import {
+  enterpriseCredentialId,
+  isAllowedLicenseEndpoint,
+} from "../core/license.js";
 import {
   capabilityDefinitionSchema,
   type CapabilityDefinition,
@@ -51,6 +56,7 @@ type LocalCapabilityRecord = {
 };
 
 type LocalCapabilitiesState = {
+  credential_id?: string;
   capabilities: Record<string, LocalCapabilityRecord>;
   last_synced_at?: string;
 };
@@ -75,6 +81,10 @@ function readSyncedCapabilitiesState(): LocalCapabilitiesState {
   try {
     const parsed = JSON.parse(readFileSync(path, "utf8")) as LocalCapabilitiesState;
     return {
+      credential_id:
+        typeof parsed.credential_id === "string"
+          ? parsed.credential_id
+          : undefined,
       capabilities: parsed.capabilities ?? {},
       last_synced_at: parsed.last_synced_at,
     };
@@ -145,6 +155,28 @@ export async function runCapabilitySyncOnce(
     await writeAudit(cwd, outcome);
     return outcome;
   }
+  if (!isAllowedLicenseEndpoint(baseUrl)) {
+    const outcome: CapabilitySyncOutcome = {
+      kind: "failed",
+      error: "insecure or invalid enterprise endpoint",
+    };
+    await writeAudit(cwd, outcome);
+    return outcome;
+  }
+
+  const credentialId = enterpriseCredentialId(baseUrl, apiKey);
+  if (!matchesEnterpriseHostIdentity(credentialId)) {
+    const outcome: CapabilitySyncOutcome = {
+      kind: "failed",
+      error:
+        "enterprise identity conflict: this user profile is already enrolled to another endpoint or API key",
+    };
+    await writeAudit(cwd, outcome);
+    return outcome;
+  }
+  const state = readSyncedCapabilitiesState();
+  const identityChanged = state.credential_id !== credentialId;
+  state.credential_id = credentialId;
 
   let manifest: ManifestEntry[];
   try {
@@ -158,7 +190,6 @@ export async function runCapabilitySyncOnce(
     return outcome;
   }
 
-  const state = readSyncedCapabilitiesState();
   const remoteByName = new Map(manifest.map((e) => [e.capability_name, e]));
 
   const added: string[] = [];
@@ -169,7 +200,8 @@ export async function runCapabilitySyncOnce(
     const local = state.capabilities[entry.capability_name];
     const isNew = !local;
     const isChanged =
-      Boolean(local) && local.updated_at !== entry.updated_at;
+      Boolean(local) &&
+      (identityChanged || local.updated_at !== entry.updated_at);
     if (!isNew && !isChanged) continue;
 
     let fetched: FetchedCapability;
@@ -218,6 +250,10 @@ export async function runCapabilitySyncOnce(
 
   const totalChanged = added.length + changed.length + removed.length;
   if (totalChanged === 0) {
+    if (identityChanged) {
+      state.last_synced_at = new Date().toISOString();
+      writeSyncedCapabilitiesState(state);
+    }
     const outcome: CapabilitySyncOutcome = {
       kind: "unchanged",
       count: manifest.length,

package/scaffold/mcp/src/daemon/egress-proxy.ts

@@ -14,8 +14,9 @@ import { writeHostAuditEvent } from "./ungoverned-scanner.js";
  * Per privacy boundary v3 we never send payload bytes to cortex-web —
  * only SNI + destination + bytes-transferred counters. The audit lands
  * in .context/audit/host-events-YYYY-MM-DD.jsonl as event_type =
- * "egress_connection". The host-events pusher (Fas 7) then forwards
- * those to cortex-web on the periodic timer.
+ * "egress_connection" only when a caller supplies an attributable project
+ * cwd. The shared daemon proxy intentionally omits cwd and therefore emits
+ * no project audit record rather than misattributing cross-project traffic.
  *
  * Plain HTTP (non-CONNECT) is also supported but logged with the Host
  * header in place of SNI.
@@ -103,7 +104,7 @@ export function parseSni(buf: Buffer): string | null {
 }
 
 export type ProxyOptions = {
-  cwd: string;
+  cwd?: string;
   port?: number;
   hostId?: string;
 };
@@ -118,7 +119,8 @@ const HTTP_OK = "HTTP/1.1 200 Connection Established\r\nProxy-Agent: cortex-egre
 const HTTP_BAD = "HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n";
 const HTTP_BAD_GATEWAY = "HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\n\r\n";
 
-function emit(cwd: string, evt: EgressEvent): void {
+function emit(cwd: string | undefined, evt: EgressEvent): void {
+  if (!cwd) return;
   void writeHostAuditEvent(cwd, evt as unknown as Record<string, unknown>).catch((err) => {
     process.stderr.write(
       `[cortex-egress] audit emit failed: ${err instanceof Error ? err.message : String(err)}\n`,
@@ -147,7 +149,7 @@ function pipeWithCounting(
   client: Socket,
   upstream: Socket,
   evt: EgressEvent,
-  cwd: string,
+  cwd: string | undefined,
   start: number,
 ): void {
   let firstClientChunk = true;
@@ -193,7 +195,7 @@ function handleConnect(
   client: Socket,
   host: string,
   port: number,
-  cwd: string,
+  cwd: string | undefined,
   hostId: string,
 ): void {
   const evt = newEvent(host, port, "https", hostId, client.remotePort ?? null);
@@ -220,7 +222,7 @@ function handleHttp(
   client: Socket,
   url: URL,
   initialChunk: Buffer,
-  cwd: string,
+  cwd: string | undefined,
   hostId: string,
 ): void {
   const port = url.port ? parseInt(url.port, 10) : 80;
@@ -245,7 +247,11 @@ function handleHttp(
   });
 }
 
-function handleConnection(client: Socket, cwd: string, hostId: string): void {
+function handleConnection(
+  client: Socket,
+  cwd: string | undefined,
+  hostId: string,
+): void {
   let buffer = Buffer.alloc(0);
 
   const onFirstChunk = (chunk: Buffer) => {