@linzumi/cli 0.0.44-beta → 0.0.45-beta

package/README.md

@@ -63,7 +63,7 @@ Install the CLI or run it with `npx`:
 
 ```bash
 npm install -g @linzumi/cli@latest
-npx -y @linzumi/cli@0.0.44-beta --version
+npx -y @linzumi/cli@0.0.45-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { existsSync as existsSync11, readFileSync as readFileSync10, realpathSync as realpathSync6 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync11, realpathSync as realpathSync6 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
 import { resolve as resolve9 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
@@ -6016,6 +6016,7 @@ function pathLooksAbsolute(pathValue) {
 
 // src/localForwarding.ts
 import { gzipSync } from "node:zlib";
+import NodeWebSocket from "ws";
 var maxForwardBodyBytes = 64 * 1024 * 1024;
 var gzipForwardThresholdBytes = 32 * 1024;
 async function handleForwardHttpRequest(control, allowedPorts) {
@@ -6059,15 +6060,15 @@ function isForwardHttpRequestControl(control) {
 function isForwardWebSocketControl(control) {
   return control.type === "forward_websocket_open" || control.type === "forward_websocket_send" || control.type === "forward_websocket_close";
 }
-function createForwardWebSocketManager(kandan, topic, allowedPorts) {
+function createForwardWebSocketManager(kandan, topic, allowedPorts, socketFactory = defaultForwardWebSocketFactory) {
   const sockets = new Map;
   const pushEvent = (payload) => kandan.push(topic, "forward:websocket_event", payload).catch(() => {
     return;
   });
   const closeSocket = (socketId) => {
-    const socket = sockets.get(socketId);
+    const stream = sockets.get(socketId);
     sockets.delete(socketId);
-    socket?.close();
+    stream?.socket.close();
   };
   return {
     handle: (control) => {
@@ -6081,12 +6082,12 @@ function createForwardWebSocketManager(kandan, topic, allowedPorts) {
             });
             return;
           }
-          openLocalWebSocket(control, sockets, pushEvent, "ws");
+          openLocalWebSocket(control, sockets, pushEvent, socketFactory, "ws");
           return;
         }
         case "forward_websocket_send": {
-          const socket = sockets.get(control.socketId);
-          if (socket === undefined || socket.readyState !== WebSocket.OPEN) {
+          const stream = sockets.get(control.socketId);
+          if (stream === undefined || stream.socket.readyState !== WebSocket.OPEN) {
             pushEvent({
               socketId: control.socketId,
               type: "error",
@@ -6097,12 +6098,12 @@ function createForwardWebSocketManager(kandan, topic, allowedPorts) {
           const body = Buffer.from(control.bodyBase64, "base64");
           switch (control.opcode) {
             case "text":
-              socket.send(body.toString());
+              stream.socket.send(body.toString());
               return;
             case "binary":
             case "ping":
             case "pong":
-              socket.send(body);
+              stream.socket.send(body);
               return;
           }
         }
@@ -6118,18 +6119,27 @@ function createForwardWebSocketManager(kandan, topic, allowedPorts) {
     }
   };
 }
-function openLocalWebSocket(control, sockets, pushEvent, scheme) {
+function openLocalWebSocket(control, sockets, pushEvent, socketFactory, scheme) {
   let opened = false;
-  const url = localForwardUrl(scheme === "ws" ? "http" : "https", control.port, control.path, control.queryString).replace(/^http/, scheme);
+  const url = localForwardWebSocketUrl(scheme, control.port, control.path, control.queryString);
   const protocols = webSocketProtocols(control.headers);
-  const websocket = protocols === undefined ? new WebSocket(url) : new WebSocket(url, protocols);
+  const headers = webSocketHeaders(control.headers);
+  const websocket = socketFactory(url, protocols, headers);
   websocket.binaryType = "arraybuffer";
-  sockets.set(control.socketId, websocket);
+  const previousStream = sockets.get(control.socketId);
+  previousStream?.socket.close();
+  sockets.set(control.socketId, { socket: websocket });
   websocket.addEventListener("open", () => {
+    if (!currentWebSocket(sockets, control.socketId, websocket)) {
+      return;
+    }
     opened = true;
     pushEvent({ socketId: control.socketId, type: "open" });
   });
   websocket.addEventListener("message", (event) => {
+    if (!currentWebSocket(sockets, control.socketId, websocket)) {
+      return;
+    }
     const body = typeof event.data === "string" ? Buffer.from(event.data) : Buffer.from(event.data);
     pushEvent({
       socketId: control.socketId,
@@ -6139,6 +6149,9 @@ function openLocalWebSocket(control, sockets, pushEvent, scheme) {
     });
   });
   websocket.addEventListener("close", (event) => {
+    if (!currentWebSocket(sockets, control.socketId, websocket)) {
+      return;
+    }
     sockets.delete(control.socketId);
     pushEvent({
       socketId: control.socketId,
@@ -6148,18 +6161,32 @@ function openLocalWebSocket(control, sockets, pushEvent, scheme) {
     });
   });
   websocket.addEventListener("error", () => {
+    if (!currentWebSocket(sockets, control.socketId, websocket)) {
+      return;
+    }
     sockets.delete(control.socketId);
     if (!opened && scheme === "ws") {
-      openLocalWebSocket(control, sockets, pushEvent, "wss");
+      openLocalWebSocket(control, sockets, pushEvent, socketFactory, "wss");
       return;
     }
     pushEvent({
       socketId: control.socketId,
       type: "error",
-      error: "websocket_error"
+      error: "websocket_error",
+      attemptedScheme: scheme
     });
   });
 }
+function defaultForwardWebSocketFactory(url, protocols, headers) {
+  if (headers === undefined) {
+    return protocols === undefined ? new WebSocket(url) : new WebSocket(url, protocols);
+  }
+  const options = { headers };
+  return protocols === undefined ? new NodeWebSocket(url, options) : new NodeWebSocket(url, protocols, options);
+}
+function currentWebSocket(sockets, socketId, socket) {
+  return sockets.get(socketId)?.socket === socket;
+}
 function webSocketProtocols(headers) {
   if (!Array.isArray(headers)) {
     return;
@@ -6172,6 +6199,21 @@ function webSocketProtocols(headers) {
   });
   return protocols.length === 0 ? undefined : protocols;
 }
+function webSocketHeaders(headers) {
+  if (!Array.isArray(headers)) {
+    return;
+  }
+  const forwarded = headers.reduce((acc, header) => {
+    if (isOctWebSocketHeader(header)) {
+      acc[header.name] = header.value;
+    }
+    return acc;
+  }, {});
+  return Object.keys(forwarded).length === 0 ? undefined : forwarded;
+}
+function isOctWebSocketHeader(value) {
+  return isHeader(value) && value.name.toLowerCase().startsWith("x-oct-");
+}
 function localForwardUrl(scheme, port, path, queryString) {
   const normalizedPath = path.startsWith("/") ? path : `/${path}`;
   const url = new URL(`${scheme}://127.0.0.1:${port}${normalizedPath}`);
@@ -6180,6 +6222,12 @@ function localForwardUrl(scheme, port, path, queryString) {
   }
   return url.toString();
 }
+function localForwardWebSocketUrl(scheme, port, path, queryString) {
+  const httpScheme = scheme === "ws" ? "http" : "https";
+  const url = new URL(localForwardUrl(httpScheme, port, path, queryString));
+  url.protocol = `${scheme}:`;
+  return url.toString();
+}
 async function fetchWithHttpsFallback(port, path, queryString, request) {
   try {
     return await fetch(localForwardUrl("http", port, path, queryString), request);
@@ -6292,8 +6340,10 @@ var blockedForwardHeaderNames = new Set([
   "connection",
   "content-encoding",
   "content-length",
+  "cookie",
   "host",
   "keep-alive",
+  "authorization",
   "proxy-authenticate",
   "proxy-authorization",
   "te",
@@ -6305,10 +6355,12 @@ var blockedForwardHeaderNames = new Set([
 // src/localEditor.ts
 import { spawn as spawn2 } from "node:child_process";
 import {
+  copyFileSync,
   cpSync,
   existsSync as existsSync2,
   mkdirSync as mkdirSync3,
   mkdtempSync,
+  readFileSync as readFileSync2,
   realpathSync as realpathSync3,
   writeFileSync as writeFileSync2
 } from "node:fs";
@@ -6510,6 +6562,7 @@ function prepareCodeServerProfile(collaboration, editorRuntime) {
     mkdirSync3(collaborationServerDir, { recursive: true });
     mkdirSync3(tempDir, { recursive: true });
     if (editorRuntime !== undefined) {
+      ensureCodeServerBrowserExtensionAssets(editorRuntime);
       installDirectory(editorRuntime.assets.documentStateExtensionDir, join4(extensionsDir, "kandan.document-state-telemetry"));
     }
     writeFileSync2(join4(userSettingsDir, "settings.json"), JSON.stringify(codeServerSettings(collaboration), null, 2));
@@ -6518,6 +6571,68 @@ function prepareCodeServerProfile(collaboration, editorRuntime) {
     return { ok: false, reason: "code_server_spawn_failed" };
   }
 }
+function ensureCodeServerBrowserExtensionAssets(runtime) {
+  const vscodeRoot = codeServerVscodeRoot(runtime);
+  const repairs = [
+    {
+      source: join4(vscodeRoot, "extensions", "git-base", "dist", "extension.js"),
+      target: join4(vscodeRoot, "extensions", "git-base", "dist", "browser", "extension.js"),
+      required: true
+    },
+    {
+      source: join4(vscodeRoot, "extensions", "git-base", "dist", "extension.js.map"),
+      target: join4(vscodeRoot, "extensions", "git-base", "dist", "browser", "extension.js.map"),
+      required: false
+    },
+    {
+      source: join4(vscodeRoot, "extensions", "merge-conflict", "dist", "mergeConflictMain.js"),
+      target: join4(vscodeRoot, "extensions", "merge-conflict", "dist", "browser", "mergeConflictMain.js"),
+      required: true
+    },
+    {
+      source: join4(vscodeRoot, "extensions", "merge-conflict", "dist", "mergeConflictMain.js.map"),
+      target: join4(vscodeRoot, "extensions", "merge-conflict", "dist", "browser", "mergeConflictMain.js.map"),
+      required: false
+    }
+  ];
+  repairs.forEach(({ source, target, required }) => {
+    switch (true) {
+      case existsSync2(target):
+        return;
+      case (!required && !existsSync2(source)):
+        return;
+      default:
+        mkdirSync3(dirname2(target), { recursive: true });
+        copyFileSync(source, target);
+        return;
+    }
+  });
+}
+function codeServerVscodeRoot(runtime) {
+  const roots = uniquePaths([
+    join4(runtime.root, "lib", "vscode"),
+    join4(dirname2(dirname2(runtime.codeServerBin)), "lib", "vscode"),
+    ...wrappedCodeServerBin(runtime.codeServerBin).map((codeServerBin) => join4(dirname2(dirname2(codeServerBin)), "lib", "vscode"))
+  ]);
+  const rootWithRequiredAssets = roots.find((root) => codeServerBrowserAssetSources(root).every((source) => existsSync2(source)));
+  return rootWithRequiredAssets ?? roots[0];
+}
+function wrappedCodeServerBin(codeServerBin) {
+  try {
+    const script = readFileSync2(codeServerBin, "utf8");
+    const match = script.match(/exec\s+(?:"([^"]+)"|'([^']+)'|([^\s]+))\s+"\$@"/u);
+    const target = match?.[1] ?? match?.[2] ?? match?.[3];
+    return target === undefined || target.trim() === "" ? [] : [target];
+  } catch (_error) {
+    return [];
+  }
+}
+function codeServerBrowserAssetSources(vscodeRoot) {
+  return [
+    join4(vscodeRoot, "extensions", "git-base", "dist", "extension.js"),
+    join4(vscodeRoot, "extensions", "merge-conflict", "dist", "mergeConflictMain.js")
+  ];
+}
 function prepareCodeServerLaunch(options) {
   const platform = options.platform ?? process.platform;
   if (platform === "linux") {
@@ -6650,12 +6765,16 @@ function prepareLocalEditorCollaboration(collaboration, runnerId, serverPort, br
   }
   const targetPath = `/local-codex-runners/${encodeURIComponent(runnerId)}/forwards/${serverPort}/preview-target`;
   const serverUrl = new URL(targetPath, `${browserBaseUrl}/`).toString();
-  const bootstrapServerUrl = collaboration.bootstrapToken === undefined || collaboration.bootstrapToken === "" ? serverUrl : new URL(`${targetPath}/_kandan-collaboration/${encodeURIComponent(collaboration.bootstrapToken)}`, `${browserBaseUrl}/`).toString();
+  const collaborationStatePath = `/api/v2/editor/sessions/${collaboration.editorSessionId}/collaboration-state`;
+  const collaborationBootstrapPath = collaboration.bootstrapToken === undefined || collaboration.bootstrapToken === "" ? undefined : `${targetPath}/_kandan-collaboration/${encodeURIComponent(collaboration.bootstrapToken)}`;
+  const collaborationStateUrl = collaborationBootstrapPath === undefined ? collaborationStatePath : `${collaborationBootstrapPath}${collaborationStatePath}`;
+  const bootstrapServerUrl = collaborationBootstrapPath === undefined ? serverUrl : new URL(collaborationBootstrapPath, `${browserBaseUrl}/`).toString();
   return {
     ...collaboration,
     serverPort,
     serverUrl,
-    bootstrapServerUrl
+    bootstrapServerUrl,
+    collaborationStateUrl
   };
 }
 function codeServerSettings(collaboration) {
@@ -6668,6 +6787,7 @@ function codeServerSettings(collaboration) {
     "oct.joinAcceptMode": "auto",
     ...collaboration === undefined ? {} : {
       "oct.kandanEditorSessionId": collaboration.editorSessionId,
+      "oct.kandanCollaborationStateUrl": collaboration.collaborationStateUrl,
       "oct.serverUrl": collaboration.bootstrapServerUrl
     },
     "security.workspace.trust.enabled": false,
@@ -6746,6 +6866,7 @@ async function startCollaborationSidecar(collaboration, profile, editorRuntime,
         serverPort: collaboration.serverPort,
         serverUrl: collaboration.serverUrl,
         bootstrapServerUrl: collaboration.bootstrapServerUrl,
+        collaborationStateUrl: collaboration.collaborationStateUrl,
         process: child,
         exited
       }
@@ -6986,7 +7107,7 @@ import {
   existsSync as existsSync3,
   mkdirSync as mkdirSync4,
   mkdtempSync as mkdtempSync2,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   renameSync,
   rmSync,
   writeFileSync as writeFileSync3
@@ -7474,7 +7595,7 @@ function installedRuntime(cacheRoot, manifest) {
     return { ok: false };
   }
   try {
-    const installed = JSON.parse(readFileSync2(manifestPath, "utf8"));
+    const installed = JSON.parse(readFileSync3(manifestPath, "utf8"));
     if (isJsonObject(installed) && installed.version === manifest.version && installed.platform === manifest.platform && (installed.archiveSha256 === undefined || installed.archiveSha256 === manifest.archiveSha256)) {
       return {
         ok: true,
@@ -7705,7 +7826,7 @@ function manifestAssetChecksums(assets) {
   return checksums;
 }
 function fileSha256Sync(path) {
-  return createHash2("sha256").update(readFileSync2(path)).digest("hex");
+  return createHash2("sha256").update(readFileSync3(path)).digest("hex");
 }
 function defaultEditorRuntimeCacheRoot() {
   return join5(homedir4(), ".linzumi", "editor-runtimes");
@@ -7884,6 +8005,7 @@ function firstNonBlank(...values) {
 }
 
 // src/phoenix.ts
+var defaultPushTimeoutMs = 30000;
 function phoenixWebsocketUrl(baseUrl, token) {
   const parsed = new URL(baseUrl);
   switch (parsed.protocol) {
@@ -7899,7 +8021,7 @@ function phoenixWebsocketUrl(baseUrl, token) {
   parsed.searchParams.set("vsn", "2.0.0");
   return parsed.toString();
 }
-async function connectPhoenixClient(baseUrl, token, socketFactory = (url) => new WebSocket(url)) {
+async function connectPhoenixClient(baseUrl, token, socketFactory = (url) => new WebSocket(url), options = {}) {
   const pending = new Map;
   const joins = new Map;
   const controlCallbacks = new Set;
@@ -7917,9 +8039,13 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url) => new
     rejectReady: undefined,
     reconnectTimer: undefined
   };
+  const pushTimeoutMs = options.pushTimeoutMs ?? defaultPushTimeoutMs;
   const rejectPending = (message) => {
     const error = new Error(message);
-    pending.forEach((pendingPush) => pendingPush.reject(error));
+    pending.forEach((pendingPush) => {
+      clearTimeout(pendingPush.timer);
+      pendingPush.reject(error);
+    });
     pending.clear();
   };
   const resetReady = () => {
@@ -7935,6 +8061,7 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url) => new
       const pendingPush = pending.get(ref);
       if (pendingPush !== undefined) {
         pending.delete(ref);
+        clearTimeout(pendingPush.timer);
         if (name === "phx_error") {
           pendingPush.reject(new Error("phoenix push failed"));
         } else if (isNonOkPushReply(payload) && pendingPush.event !== "phx_join") {
@@ -7960,7 +8087,12 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url) => new
     state.nextRef += 1;
     const frame = [null, ref, topic, event, payload];
     return new Promise((resolve5, reject) => {
-      pending.set(ref, { event, resolve: resolve5, reject });
+      const timer = setTimeout(() => {
+        if (pending.delete(ref)) {
+          reject(new Error(`phoenix push timed out after ${pushTimeoutMs}ms: ${event}`));
+        }
+      }, pushTimeoutMs);
+      pending.set(ref, { event, timer, resolve: resolve5, reject });
       websocket.send(JSON.stringify(frame));
     });
   };
@@ -8035,10 +8167,10 @@ async function connectPhoenixClient(baseUrl, token, socketFactory = (url) => new
     return pushOnOpenSocket(topic, event, payload);
   };
   return {
-    join: async (topic, payload, options) => {
+    join: async (topic, payload, options2) => {
       const reply = await push(topic, "phx_join", payload);
       if (isJoinReply(reply)) {
-        joins.set(topic, { payload: options?.rejoinPayload ?? (() => payload) });
+        joins.set(topic, { payload: options2?.rejoinPayload ?? (() => payload) });
         return reply.response;
       }
       throw new Error(`phoenix join failed: ${joinErrorMessage(reply)}`);
@@ -8110,7 +8242,7 @@ import {
   existsSync as existsSync5,
   mkdirSync as mkdirSync6,
   openSync as openSync2,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   unlinkSync as unlinkSync2,
   writeSync
 } from "node:fs";
@@ -8122,27 +8254,38 @@ import {
   existsSync as existsSync4,
   linkSync,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   realpathSync as realpathSync4,
   unlinkSync,
   writeFileSync as writeFileSync4
 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import { basename as basename4, dirname as dirname4, join as join6, resolve as resolve5 } from "node:path";
+
+// src/defaultUrls.ts
+var defaultLinzumiHttpUrl = "https://serve.linzumi.com";
+var defaultLinzumiWebSocketUrl = "wss://serve.linzumi.com";
+
+// src/localConfig.ts
+var prodConfigScope = "prod";
 function localConfigPath(env = process.env) {
   const override = env.LINZUMI_CONFIG_FILE;
   return override !== undefined && override.trim() !== "" ? resolve5(expandUserPath(override)) : resolve5(homedir5(), ".linzumi", "config.json");
 }
+function localConfigScopeKey(linzumiUrl) {
+  const normalizedUrl = kandanHttpBaseUrl(linzumiUrl);
+  const normalizedProdUrl = kandanHttpBaseUrl(defaultLinzumiWebSocketUrl);
+  return normalizedUrl === normalizedProdUrl ? prodConfigScope : normalizedUrl;
+}
+function localConfigScopeFileStem(linzumiUrl) {
+  const scopeKey = localConfigScopeKey(linzumiUrl);
+  return scopeKey === prodConfigScope ? prodConfigScope : Buffer.from(scopeKey).toString("base64url");
+}
 function readLocalConfig(path = localConfigPath()) {
-  if (!existsSync4(path)) {
-    return { version: 1, allowedCwds: [] };
-  }
-  const parsed = JSON.parse(readFileSync3(path, "utf8"));
-  if (!isConfigPayload(parsed)) {
-    throw new Error(`invalid Linzumi config: ${path}`);
-  }
-  const allowedCwds = uniqueStrings(parsed.allowedCwds);
-  return parsed.machineId === undefined ? { version: 1, allowedCwds } : { version: 1, machineId: parsed.machineId, allowedCwds };
+  return readLocalConfigSection(path);
+}
+function readLocalConfigForLinzumiUrl(linzumiUrl, path = localConfigPath()) {
+  return readLocalConfigSection(path, linzumiUrl);
 }
 function ensureLocalMachineId(path = localConfigPath(), createMachineId = randomUUID2) {
   const config = readLocalConfig(path);
@@ -8158,13 +8301,36 @@ function ensureLocalMachineId(path = localConfigPath(), createMachineId = random
   writeLocalConfig({ ...latestConfig, machineId }, path);
   return machineId;
 }
-function localMachineIdSeedPath(configPath = localConfigPath()) {
+function ensureLocalMachineIdForLinzumiUrl(linzumiUrl, path = localConfigPath(), createMachineId = randomUUID2) {
+  if (localConfigScopeKey(linzumiUrl) === prodConfigScope) {
+    return ensureLocalMachineId(path, createMachineId);
+  }
+  const config = readLocalConfigForLinzumiUrl(linzumiUrl, path);
+  if (config.machineId !== undefined) {
+    return config.machineId;
+  }
+  const machineId = ensureLocalMachineIdSeed(path, createMachineId, linzumiUrl);
+  const latestConfig = readLocalConfigForLinzumiUrl(linzumiUrl, path);
+  const latestMachineId = latestConfig.machineId;
+  if (latestMachineId !== undefined) {
+    return latestMachineId;
+  }
+  writeLocalConfigSection({ ...latestConfig, machineId }, path, linzumiUrl);
+  return machineId;
+}
+function localMachineIdSeedPath(configPath = localConfigPath(), linzumiUrl) {
+  if (linzumiUrl !== undefined && localConfigScopeKey(linzumiUrl) !== prodConfigScope) {
+    return join6(dirname4(configPath), `${basename4(configPath)}.${localConfigScopeFileStem(linzumiUrl)}.machine-id`);
+  }
   return join6(dirname4(configPath), `${basename4(configPath)}.machine-id`);
 }
-function readConfiguredAllowedCwdDetails(path = localConfigPath()) {
+function readConfiguredAllowedCwdDetailsForLinzumiUrl(linzumiUrl, path = localConfigPath()) {
+  return readConfiguredAllowedCwdDetailsFromConfig(readLocalConfigForLinzumiUrl(linzumiUrl, path));
+}
+function readConfiguredAllowedCwdDetailsFromConfig(config) {
   const allowedCwds = [];
   const missingAllowedCwds = [];
-  for (const cwd of readLocalConfig(path).allowedCwds) {
+  for (const cwd of config.allowedCwds) {
     const absolutePath = resolve5(expandUserPath(cwd));
     try {
       const realPath = realpathSync4(absolutePath);
@@ -8183,36 +8349,91 @@ function readConfiguredAllowedCwdDetails(path = localConfigPath()) {
   };
 }
 function addAllowedCwd(pathValue, path = localConfigPath()) {
+  return addAllowedCwdToConfig(pathValue, path);
+}
+function addAllowedCwdForLinzumiUrl(pathValue, linzumiUrl, path = localConfigPath()) {
+  return addAllowedCwdToConfig(pathValue, path, linzumiUrl);
+}
+function addAllowedCwdToConfig(pathValue, path, linzumiUrl) {
   const normalizedPath = realpathSync4(resolve5(expandUserPath(pathValue)));
-  const config = readLocalConfig(path);
+  const config = readLocalConfigSection(path, linzumiUrl);
   const allowedCwds = uniqueStrings([...config.allowedCwds, normalizedPath]);
-  writeLocalConfig({ ...config, version: 1, allowedCwds }, path);
+  writeLocalConfigSection({ ...config, version: 1, allowedCwds }, path, linzumiUrl);
   return allowedCwds;
 }
 function removeAllowedCwd(pathValue, path = localConfigPath()) {
+  return removeAllowedCwdFromConfig(pathValue, path);
+}
+function removeAllowedCwdForLinzumiUrl(pathValue, linzumiUrl, path = localConfigPath()) {
+  return removeAllowedCwdFromConfig(pathValue, path, linzumiUrl);
+}
+function removeAllowedCwdFromConfig(pathValue, path, linzumiUrl) {
   const requestedPath = resolve5(expandUserPath(pathValue));
   const normalizedRequest = realpathOrResolved(requestedPath);
-  const config = readLocalConfig(path);
+  const config = readLocalConfigSection(path, linzumiUrl);
   const allowedCwds = config.allowedCwds.filter((cwd) => {
     const normalizedExisting = realpathOrResolved(cwd);
     return cwd !== pathValue && normalizedExisting !== normalizedRequest;
   });
-  writeLocalConfig({ ...config, version: 1, allowedCwds }, path);
+  writeLocalConfigSection({ ...config, version: 1, allowedCwds }, path, linzumiUrl);
   return allowedCwds;
 }
 function writeLocalConfig(config, path = localConfigPath()) {
+  writeLocalConfigSection(config, path);
+}
+function readLocalConfigFile(path) {
+  if (!existsSync4(path)) {
+    return { version: 1, allowedCwds: [] };
+  }
+  const parsed = JSON.parse(readFileSync4(path, "utf8"));
+  if (!isConfigPayload(parsed)) {
+    throw new Error(`invalid Linzumi config: ${path}`);
+  }
+  return parsed;
+}
+function readLocalConfigSection(path, linzumiUrl) {
+  const parsed = readLocalConfigFile(path);
+  const scopeKey = linzumiUrl === undefined ? prodConfigScope : localConfigScopeKey(linzumiUrl);
+  const section = scopeKey === prodConfigScope ? parsed : parsed[scopeKey] ?? emptySection();
+  if (!isConfigSection(section)) {
+    throw new Error(`invalid Linzumi config section ${scopeKey}: ${path}`);
+  }
+  const allowedCwds = uniqueStrings(section.allowedCwds);
+  return section.machineId === undefined ? { version: 1, allowedCwds } : { version: 1, machineId: section.machineId, allowedCwds };
+}
+function writeLocalConfigSection(config, path, linzumiUrl) {
+  const scopeKey = linzumiUrl === undefined ? prodConfigScope : localConfigScopeKey(linzumiUrl);
+  const nextSection = normalizedConfigSection(config);
+  const next = scopeKey === prodConfigScope ? { ...readLocalConfigFile(path), ...nextSection, version: 1 } : {
+    ...readLocalConfigFile(path),
+    version: 1,
+    [scopeKey]: nextSection
+  };
   mkdirSync5(dirname4(path), { recursive: true });
-  writeFileSync4(path, `${JSON.stringify(config, null, 2)}
+  writeFileSync4(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
 }
 function isConfigPayload(value) {
-  return typeof value === "object" && value !== null && value.version === 1 && Array.isArray(value.allowedCwds) && machineIdValid(value.machineId) && value.allowedCwds.every((cwd) => typeof cwd === "string" && cwd.trim() !== "");
+  return typeof value === "object" && value !== null && value.version === 1 && isConfigSection(value);
+}
+function isConfigSection(value) {
+  return typeof value === "object" && value !== null && Array.isArray(value.allowedCwds) && machineIdValid(value.machineId) && value.allowedCwds.every((cwd) => typeof cwd === "string" && cwd.trim() !== "");
+}
+function normalizedConfigSection(config) {
+  if (!isConfigPayload(config)) {
+    throw new Error("invalid Linzumi config");
+  }
+  const allowedCwds = uniqueStrings(config.allowedCwds);
+  return config.machineId === undefined ? { allowedCwds } : { machineId: config.machineId, allowedCwds };
+}
+function emptySection() {
+  return { allowedCwds: [] };
 }
 function machineIdValid(value) {
   return value === undefined || typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
 }
-function ensureLocalMachineIdSeed(configPath, createMachineId) {
-  const seedPath = localMachineIdSeedPath(configPath);
+function ensureLocalMachineIdSeed(configPath, createMachineId, linzumiUrl) {
+  const seedPath = localMachineIdSeedPath(configPath, linzumiUrl);
   if (existsSync4(seedPath)) {
     return readMachineIdSeed(seedPath);
   }
@@ -8237,7 +8458,7 @@ function ensureLocalMachineIdSeed(configPath, createMachineId) {
   }
 }
 function readMachineIdSeed(seedPath) {
-  const machineId = readFileSync3(seedPath, "utf8").trim();
+  const machineId = readFileSync4(seedPath, "utf8").trim();
   if (!machineIdValid(machineId)) {
     throw new Error(`invalid Linzumi machine id seed: ${seedPath}`);
   }
@@ -8263,15 +8484,16 @@ function realpathOrResolved(pathValue) {
 }
 
 // src/version.ts
-var linzumiCliVersion = "0.0.44-beta";
+var linzumiCliVersion = "0.0.45-beta";
 var linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
 
 // src/runnerLock.ts
-function runnerLockPath(machineId, configPath = localConfigPath()) {
-  return join7(dirname5(configPath), "runners", `${encodeURIComponent(machineId)}.lock`);
+function runnerLockPath(machineId, configPath = localConfigPath(), linzumiUrl) {
+  const lockName = linzumiUrl === undefined ? encodeURIComponent(machineId) : localConfigScopeFileStem(linzumiUrl);
+  return join7(dirname5(configPath), "runners", `${lockName}.lock`);
 }
 function acquireRunnerLock(options) {
-  const path = runnerLockPath(options.machineId, options.configPath);
+  const path = runnerLockPath(options.machineId, options.configPath, options.linzumiUrl);
   const isPidAlive = options.isPidAlive ?? processIsAlive;
   const record = {
     version: 1,
@@ -8280,9 +8502,11 @@ function acquireRunnerLock(options) {
     pid: options.pid ?? process.pid,
     cwd: options.cwd,
     workspace: options.workspace,
+    ...options.linzumiUrl === undefined ? {} : { linzumiUrl: kandanHttpBaseUrl(options.linzumiUrl) },
     startedAt: (options.now ?? (() => new Date))().toISOString(),
     cliVersion: options.cliVersion ?? linzumiCliVersion
   };
+  rejectLiveLegacyProductionRunnerLock(options.machineId, options.configPath, options.linzumiUrl, isPidAlive);
   writeLockOrHandleExisting(path, record, isPidAlive, options.beforeReadExistingLock, options.beforeReplaceStaleLock);
   return {
     path,
@@ -8290,6 +8514,28 @@ function acquireRunnerLock(options) {
     release: () => releaseRunnerLock(path, record)
   };
 }
+function rejectLiveLegacyProductionRunnerLock(machineId, configPath, linzumiUrl, isPidAlive) {
+  if (linzumiUrl === undefined || localConfigScopeKey(linzumiUrl) !== localConfigScopeKey(defaultLinzumiHttpUrl)) {
+    return;
+  }
+  const legacyPath = runnerLockPath(machineId, configPath);
+  const existing = readRunnerLockIfPresent(legacyPath);
+  if (existing === undefined) {
+    return;
+  }
+  if (isPidAlive(existing.pid)) {
+    throw new Error(activeRunnerLockMessage(legacyPath, existing));
+  }
+  withStaleReplacementLock(legacyPath, isPidAlive, () => {
+    const latest = existsSync5(legacyPath) ? readRunnerLock(legacyPath) : undefined;
+    if (latest !== undefined && isPidAlive(latest.pid)) {
+      throw new Error(activeRunnerLockMessage(legacyPath, latest));
+    }
+    if (latest !== undefined) {
+      unlinkSync2(legacyPath);
+    }
+  });
+}
 function writeLockOrHandleExisting(path, record, isPidAlive, beforeReadExistingLock, beforeReplaceStaleLock) {
   if (tryCreateLock(path, record)) {
     return;
@@ -8375,7 +8621,7 @@ function withStaleReplacementLock(path, isPidAlive, callback) {
 function readReplacementLockPidIfPresent(path) {
   let value;
   try {
-    value = readFileSync4(path, "utf8").trim();
+    value = readFileSync5(path, "utf8").trim();
   } catch (error) {
     if (isNodeErrorCode2(error, "ENOENT")) {
       return;
@@ -8415,14 +8661,17 @@ function readRunnerLockIfPresent(path) {
   }
 }
 function readRunnerLock(path) {
-  const parsed = JSON.parse(readFileSync4(path, "utf8"));
+  const parsed = JSON.parse(readFileSync5(path, "utf8"));
   if (!isRunnerLockRecord(parsed)) {
     throw new Error(`invalid Linzumi runner lock: ${path}`);
   }
   return parsed;
 }
 function isRunnerLockRecord(value) {
-  return typeof value === "object" && value !== null && value.version === 1 && typeof value.machineId === "string" && value.machineId.trim() !== "" && typeof value.runnerId === "string" && value.runnerId.trim() !== "" && Number.isInteger(value.pid) && value.pid > 0 && typeof value.cwd === "string" && value.cwd.trim() !== "" && workspaceValid(value.workspace) && typeof value.startedAt === "string" && value.startedAt.trim() !== "" && typeof value.cliVersion === "string" && value.cliVersion.trim() !== "";
+  return typeof value === "object" && value !== null && value.version === 1 && typeof value.machineId === "string" && value.machineId.trim() !== "" && typeof value.runnerId === "string" && value.runnerId.trim() !== "" && Number.isInteger(value.pid) && value.pid > 0 && typeof value.cwd === "string" && value.cwd.trim() !== "" && workspaceValid(value.workspace) && linzumiUrlValid(value.linzumiUrl) && typeof value.startedAt === "string" && value.startedAt.trim() !== "" && typeof value.cliVersion === "string" && value.cliVersion.trim() !== "";
+}
+function linzumiUrlValid(value) {
+  return value === undefined || typeof value === "string" && value.trim() !== "";
 }
 function workspaceValid(value) {
   return value === null || typeof value === "string" && value.trim() !== "";
@@ -8437,8 +8686,10 @@ function processIsAlive(pid) {
 }
 function activeRunnerLockMessage(path, record) {
   const workspace = record.workspace === null ? "workspace: unknown" : `workspace: ${record.workspace}`;
+  const linzumiUrl = record.linzumiUrl === undefined ? undefined : `linzumi url: ${displayLinzumiUrl(record.linzumiUrl)}`;
   return [
-    "another Linzumi runner is already running for this machine",
+    record.linzumiUrl === undefined ? "another Linzumi runner is already running for this machine" : "another Linzumi runner is already running for this Linzumi URL",
+    ...linzumiUrl === undefined ? [] : [linzumiUrl],
     `runner id: ${record.runnerId}`,
     `pid: ${record.pid}`,
     `cwd: ${record.cwd}`,
@@ -8450,6 +8701,12 @@ function activeRunnerLockMessage(path, record) {
   ].join(`
 `);
 }
+function displayLinzumiUrl(linzumiUrl) {
+  if (linzumiUrl === localConfigScopeKey(defaultLinzumiHttpUrl)) {
+    return defaultLinzumiHttpUrl;
+  }
+  return localConfigScopeKey(linzumiUrl) === localConfigScopeKey(defaultLinzumiHttpUrl) ? defaultLinzumiHttpUrl : linzumiUrl;
+}
 function isNodeErrorCode2(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
@@ -8611,6 +8868,7 @@ async function runLocalCodexRunner(options) {
         runnerId: options.runnerId,
         cwd: options.cwd,
         workspace: runnerWorkspaceSlug(options) ?? null,
+        linzumiUrl: options.kandanUrl,
         configPath: options.runnerLockConfigPath
       });
       cleanup.actions.push(() => runnerLock.release());
@@ -10005,7 +10263,7 @@ function allowedCwdSuggestions(cwd, allowedCwds) {
 }
 
 // src/authCache.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 import { dirname as dirname6, join as join9 } from "node:path";
 function defaultAuthFilePath() {
@@ -10016,7 +10274,7 @@ function readCachedLocalRunnerToken(kandanUrl, authFilePath = defaultAuthFilePat
   if (!existsSync6(authFilePath)) {
     return;
   }
-  const authFile = parseAuthFile(readFileSync5(authFilePath, "utf8"));
+  const authFile = parseAuthFile(readFileSync6(authFilePath, "utf8"));
   const kandanBaseUrl = kandanHttpBaseUrl(kandanUrl);
   const entry = authFile.local_codex_runner?.[kandanBaseUrl];
   if (entry === undefined || entry.access_token.trim() === "") {
@@ -10034,7 +10292,7 @@ function readCachedLocalRunnerToken(kandanUrl, authFilePath = defaultAuthFilePat
 }
 function writeCachedLocalRunnerToken(args) {
   const authFilePath = args.authFilePath ?? defaultAuthFilePath();
-  const existing = existsSync6(authFilePath) ? parseAuthFile(readFileSync5(authFilePath, "utf8")) : { version: 1 };
+  const existing = existsSync6(authFilePath) ? parseAuthFile(readFileSync6(authFilePath, "utf8")) : { version: 1 };
   const kandanBaseUrl = kandanHttpBaseUrl(args.kandanUrl);
   const issuedAt = new Date;
   const expiresAt = args.expiresInSeconds === undefined ? undefined : new Date(issuedAt.getTime() + args.expiresInSeconds * 1000).toISOString();
@@ -10143,12 +10401,8 @@ async function acquireAndCacheToken(args) {
   return token.accessToken;
 }
 
-// src/defaultUrls.ts
-var defaultLinzumiHttpUrl = "https://serve.linzumi.com";
-var defaultLinzumiWebSocketUrl = "wss://serve.linzumi.com";
-
 // src/kandanTls.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
 import { Agent } from "undici";
 import { WebSocket as WsWebSocket } from "ws";
 function kandanTlsTrustFromEnv() {
@@ -10162,7 +10416,7 @@ function kandanTlsTrustFromCaFile(caFile) {
   if (!existsSync7(trimmed)) {
     throw new Error(`KANDAN_TLS_CA_FILE does not exist: ${trimmed}`);
   }
-  const ca = readFileSync6(trimmed, "utf8");
+  const ca = readFileSync7(trimmed, "utf8");
   return {
     caFile: trimmed,
     ca,
@@ -10191,7 +10445,7 @@ function trustedWebSocketFactory(trust, WebSocketImpl = WsWebSocket) {
 }
 
 // src/agentBootstrap.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "node:fs";
 import { dirname as dirname7, join as join10 } from "node:path";
 import { homedir as homedir7 } from "node:os";
 async function runAgentCliCommand(args, deps = {
@@ -10801,7 +11055,7 @@ function authorizationHeaders(token) {
   return { authorization: `Bearer ${token}` };
 }
 function readOptionalTextFile(path) {
-  return existsSync8(path) ? readFileSync7(path, "utf8") : undefined;
+  return existsSync8(path) ? readFileSync8(path, "utf8") : undefined;
 }
 function writeTextFile(path, content) {
   mkdirSync8(dirname7(path), { recursive: true });
@@ -10881,7 +11135,7 @@ Launch target:
 }
 
 // src/helloLinzumiProject.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync9, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "node:fs";
 import { dirname as dirname8, join as join11, resolve as resolve7 } from "node:path";
 import { fileURLToPath } from "node:url";
 var defaultHelloLinzumiProjectDir = "/tmp/hello_linzumi";
@@ -10891,7 +11145,7 @@ var defaultHelloLinzumiPort = 8787;
 var defaultHelloLinzumiHost = "0.0.0.0";
 var markerFile = ".linzumi-demo-project";
 var moduleDir = dirname8(fileURLToPath(import.meta.url));
-var linzumiLogoSvg = readFileSync8(join11(moduleDir, "assets", "linzumi-logo.svg"), "utf8");
+var linzumiLogoSvg = readFileSync9(join11(moduleDir, "assets", "linzumi-logo.svg"), "utf8");
 function createHelloLinzumiProject(input = {}) {
   const options = typeof input === "string" ? { rootPath: input } : input;
   const root = resolveHelloProjectRoot(options);
@@ -10946,7 +11200,7 @@ function assertWritableDemoRoot(root, reset) {
     return;
   }
   const markerPath = join11(root, markerFile);
-  const isDemoRoot = existsSync9(markerPath) && readFileSync8(markerPath, "utf8").trim() === "hello-linzumi";
+  const isDemoRoot = existsSync9(markerPath) && readFileSync9(markerPath, "utf8").trim() === "hello-linzumi";
   if (isDemoRoot && reset) {
     rmSync2(root, { recursive: true, force: true });
     return;
@@ -11449,7 +11703,7 @@ import {
   closeSync as closeSync2,
   mkdirSync as mkdirSync10,
   openSync as openSync3,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync10,
   watch,
   writeFileSync as writeFileSync8
 } from "node:fs";
@@ -11534,12 +11788,12 @@ function commanderDaemonStatus(runnerId, statusDir = commanderStatusDir(), proce
   if (!existsSync10(statusFile)) {
     return { status: "missing", runnerId, statusFile };
   }
-  const record = parseRecord(readFileSync9(statusFile, "utf8"));
+  const record = parseRecord(readFileSync10(statusFile, "utf8"));
   return processIsRunning(record.pid) && processMatchesRecord(record, processIdentityReader) ? { status: "running", record } : { status: "stopped", record };
 }
 async function waitForCommanderDaemon(options) {
   const now = options.now ?? (() => Date.now());
-  const readTextFile = options.readTextFile ?? ((path) => existsSync10(path) ? readFileSync9(path, "utf8") : undefined);
+  const readTextFile = options.readTextFile ?? ((path) => existsSync10(path) ? readFileSync10(path, "utf8") : undefined);
   const statusImpl = options.statusImpl ?? commanderDaemonStatus;
   const deadline = now() + options.timeoutMs;
   while (now() <= deadline) {
@@ -11794,7 +12048,7 @@ async function main(args) {
     }
     case "start": {
       const options = await parseStartRunnerArgs(parsed.args);
-      addAllowedCwd(options.cwd);
+      addAllowedCwdForLinzumiUrl(options.cwd, options.kandanUrl);
       await runLocalCodexRunner(withLocalMachineId(options));
       return;
     }
@@ -11897,19 +12151,16 @@ function runHelloCommand(args) {
 `);
 }
 function runPathsCommand(args) {
-  const [subcommand, pathValue, ...rest] = args;
-  if (subcommand === undefined || subcommand === "help" || subcommand === "--help") {
+  const { subcommand, pathValue, linzumiUrl, help } = parsePathsCommandArgs(args);
+  if (help || subcommand === undefined || subcommand === "help") {
     process.stdout.write(pathsHelpText());
     return;
   }
-  if (rest.length > 0) {
-    throw new Error("linzumi paths accepts one path argument");
-  }
   switch (subcommand) {
     case "list": {
-      const config = readLocalConfig();
+      const config = linzumiUrl === undefined ? readLocalConfig() : readLocalConfigForLinzumiUrl(linzumiUrl);
       if (config.allowedCwds.length === 0) {
-        process.stdout.write(`No trusted paths configured in ${localConfigPath()}
+        process.stdout.write(`No trusted paths configured in ${localConfigPath()}${pathsScopeSuffix(linzumiUrl)}
 `);
         return;
       }
@@ -11923,7 +12174,11 @@ function runPathsCommand(args) {
         throw new Error("missing path for linzumi paths add");
       }
       const trustedPath = realpathSync6(resolve9(expandUserPath(pathValue)));
-      addAllowedCwd(pathValue);
+      if (linzumiUrl === undefined) {
+        addAllowedCwd(pathValue);
+      } else {
+        addAllowedCwdForLinzumiUrl(pathValue, linzumiUrl);
+      }
       process.stdout.write(`Trusted ${trustedPath}
 `);
       return;
@@ -11932,7 +12187,11 @@ function runPathsCommand(args) {
       if (pathValue === undefined || pathValue.trim() === "") {
         throw new Error("missing path for linzumi paths remove");
       }
-      removeAllowedCwd(pathValue);
+      if (linzumiUrl === undefined) {
+        removeAllowedCwd(pathValue);
+      } else {
+        removeAllowedCwdForLinzumiUrl(pathValue, linzumiUrl);
+      }
       process.stdout.write(`Removed trusted path ${pathValue}
 `);
       return;
@@ -11941,6 +12200,46 @@ function runPathsCommand(args) {
       throw new Error(`invalid paths command: ${subcommand}`);
   }
 }
+function parsePathsCommandArgs(args) {
+  const positional = [];
+  let linzumiUrl;
+  let help = false;
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    switch (arg) {
+      case "--help":
+        help = true;
+        break;
+      case "--linzumi-url":
+      case "--kandan-url": {
+        const value = args[index + 1];
+        if (value === undefined || value.startsWith("--")) {
+          throw new Error(`missing value for ${arg}`);
+        }
+        linzumiUrl = value;
+        index += 1;
+        break;
+      }
+      default:
+        if (arg !== undefined && arg.startsWith("--")) {
+          throw new Error(`invalid flag: ${arg}`);
+        }
+        positional.push(arg ?? "");
+    }
+  }
+  if (positional.length > 2) {
+    throw new Error("linzumi paths accepts one path argument");
+  }
+  return {
+    subcommand: positional[0],
+    pathValue: positional[1],
+    linzumiUrl,
+    help
+  };
+}
+function pathsScopeSuffix(linzumiUrl) {
+  return linzumiUrl === undefined ? "" : ` for ${linzumiUrl}`;
+}
 async function runCommanderDaemonCommand(args) {
   const [subcommand, ...rest] = args;
   switch (subcommand) {
@@ -12172,7 +12471,7 @@ async function parseAgentRunnerArgs(args, deps = {
   const kandanUrl = stringValue3(values, "linzumi-url") ?? agentApiUrlToKandanUrl(tokenFile.apiUrl);
   const requestedCwdValue = cwdArg ?? stringValue3(values, "cwd");
   const requestedCwd = resolveUserPath(requestedCwdValue ?? process.cwd());
-  const configuredAllowedCwds2 = requestedCwdValue === undefined && !values.has("allowed-cwd") ? readConfiguredAllowedCwdDetails() : { allowedCwds: [], missingAllowedCwds: [] };
+  const configuredAllowedCwds2 = requestedCwdValue === undefined && !values.has("allowed-cwd") ? readConfiguredAllowedCwdDetailsForLinzumiUrl(kandanUrl) : { allowedCwds: [], missingAllowedCwds: [] };
   const allowedCwds = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(parseAllowedCwdList(stringValue3(values, "allowed-cwd"))) : requestedCwdValue === undefined ? configuredAllowedCwds2.allowedCwds.length > 0 ? [...configuredAllowedCwds2.allowedCwds] : assertConfiguredAllowedCwds([requestedCwd]) : assertConfiguredAllowedCwds([requestedCwd]);
   const cwd = allowedCwds[0] ?? requestedCwd;
   const codexBin = stringValue3(values, "codex-bin") ?? "codex";
@@ -12219,7 +12518,7 @@ async function parseAgentRunnerArgs(args, deps = {
   };
 }
 function readAgentTokenTextFile(path) {
-  return existsSync11(path) ? readFileSync10(path, "utf8") : undefined;
+  return existsSync11(path) ? readFileSync11(path, "utf8") : undefined;
 }
 function rejectAgentRunnerTargetingFlags(values) {
   const unsupportedFlags = [
@@ -12303,7 +12602,7 @@ async function parseRunnerArgs(args, deps = {
   const kandanUrl = stringValue3(values, "linzumi-url") ?? defaultLinzumiWebSocketUrl;
   const cwd = stringValue3(values, "cwd") ?? process.cwd();
   const cwdAllowedCwds = assertConfiguredAllowedCwds([cwd]);
-  const localConfiguredAllowedCwds = values.has("allowed-cwd") ? { allowedCwds: [], missingAllowedCwds: [] } : readConfiguredAllowedCwdDetails();
+  const localConfiguredAllowedCwds = values.has("allowed-cwd") ? { allowedCwds: [], missingAllowedCwds: [] } : readConfiguredAllowedCwdDetailsForLinzumiUrl(kandanUrl);
   const configuredAllowedCwds2 = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(parseAllowedCwdList(stringValue3(values, "allowed-cwd"))) : [...localConfiguredAllowedCwds.allowedCwds];
   const codexBin = stringValue3(values, "codex-bin") ?? "codex";
   const customCodeServerBin = stringValue3(values, "code-server-bin");
@@ -12516,7 +12815,7 @@ function parseChannelPath(channel) {
 function withLocalMachineId(options) {
   return {
     ...options,
-    machineId: ensureLocalMachineId()
+    machineId: localConfigScopeKey(options.kandanUrl) === localConfigScopeKey(defaultLinzumiWebSocketUrl) ? ensureLocalMachineId() : ensureLocalMachineIdForLinzumiUrl(options.kandanUrl)
   };
 }
 function required(values, key) {
@@ -12698,13 +12997,13 @@ function pathsHelpText() {
   return `Linzumi trusted paths
 
 Usage:
-  linzumi paths list
-  linzumi paths add <path>
-  linzumi paths remove <path>
+  linzumi paths [--linzumi-url <ws-url>] list
+  linzumi paths [--linzumi-url <ws-url>] add <path>
+  linzumi paths [--linzumi-url <ws-url>] remove <path>
 
-Trusted paths are stored in ~/.linzumi/config.json. linzumi connect always
-trusts its selected cwd for that runner process and also uses configured paths
-unless --allowed-cwd is passed with explicit extra roots.
+Trusted paths are stored in ~/.linzumi/config.json. Production/default paths
+use the root config fields; explicit --linzumi-url paths use a URL-scoped config
+section so local, staging, and production runners do not share trust state.
 `;
 }
 function startHelpText() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.44-beta",
+  "version": "0.0.45-beta",
   "description": "Linzumi CLI — point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {