@jsonstudio/zterm-daemon-darwin-arm64 0.0.0-stage → 0.1.4

package/support/terminal-config-command.cjs

@@ -0,0 +1,579 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server/terminal-config-command.ts
+var terminal_config_command_exports = {};
+__export(terminal_config_command_exports, {
+  runTerminalConfigCommand: () => runTerminalConfigCommand
+});
+module.exports = __toCommonJS(terminal_config_command_exports);
+var import_node_os2 = require("node:os");
+var import_node_util = require("node:util");
+
+// ../packages/shared/src/node/shared-config.ts
+var import_node_crypto = require("node:crypto");
+var import_promises = require("node:fs/promises");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var ConfigStoreError = class extends Error {
+  constructor(code, message, path, options) {
+    super(message);
+    Object.defineProperty(this, "cause", {
+      value: options?.cause,
+      writable: true,
+      configurable: true
+    });
+    this.name = "ConfigStoreError";
+    this.code = code;
+    this.path = path;
+    this.lockPath = options?.lockPath;
+  }
+};
+var DEFAULT_LOCK_TIMEOUT_MS = 5e3;
+var DEFAULT_LOCK_RETRY_MS = 20;
+function isJsonObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isErrno(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+function positiveDuration(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function waitForRetry(delayMs, signal, path, lockPath) {
+  if (signal?.aborted) {
+    return Promise.reject(
+      new ConfigStoreError("config_aborted", `Config transaction aborted: ${path}`, path, { lockPath })
+    );
+  }
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, delayMs);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(
+        new ConfigStoreError("config_aborted", `Config transaction aborted: ${path}`, path, { lockPath })
+      );
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function getSharedConfigPath(homeDir = (0, import_node_os.homedir)()) {
+  return (0, import_node_path.join)(homeDir, ".zterm", "config.json");
+}
+var SharedConfigStore = class {
+  constructor(options = {}) {
+    this.path = getSharedConfigPath(options.homeDir);
+    this.lockPath = `${this.path}.lock`;
+    this.lockTimeoutMs = positiveDuration(options.lockTimeoutMs, DEFAULT_LOCK_TIMEOUT_MS);
+    this.lockRetryMs = Math.max(1, positiveDuration(options.lockRetryMs, DEFAULT_LOCK_RETRY_MS));
+  }
+  async read() {
+    let raw;
+    try {
+      raw = await (0, import_promises.readFile)(this.path, "utf8");
+    } catch (error) {
+      if (isErrno(error, "ENOENT")) {
+        return { path: this.path, found: false, config: {} };
+      }
+      throw new ConfigStoreError(
+        "config_read_failed",
+        `Unable to read config: ${this.path}`,
+        this.path,
+        { cause: error }
+      );
+    }
+    if (!raw.trim()) {
+      throw new ConfigStoreError(
+        "invalid_json",
+        `Config is empty: ${this.path}`,
+        this.path
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      throw new ConfigStoreError(
+        "invalid_json",
+        `Config contains invalid JSON: ${this.path}`,
+        this.path,
+        { cause: error }
+      );
+    }
+    if (!isJsonObject(parsed)) {
+      throw new ConfigStoreError(
+        "invalid_config",
+        `Config root must be a JSON object: ${this.path}`,
+        this.path
+      );
+    }
+    return { path: this.path, found: true, config: parsed };
+  }
+  async update(mutate, signal) {
+    signal?.throwIfAborted();
+    await (0, import_promises.mkdir)((0, import_node_path.dirname)(this.path), { recursive: true, mode: 448 });
+    const lock = await this.acquireLock(signal);
+    let temporaryPath;
+    try {
+      const snapshot = await this.read();
+      const mutation = mutate(snapshot.config);
+      if (!mutation || typeof mutation.changed !== "boolean") {
+        throw new ConfigStoreError(
+          "invalid_config",
+          "Config mutation did not return { value, changed }: " + this.path,
+          this.path
+        );
+      }
+      if (!mutation.changed) {
+        return mutation.value;
+      }
+      signal?.throwIfAborted();
+      const body = `${JSON.stringify(snapshot.config, null, 2)}
+`;
+      temporaryPath = `${this.path}.${process.pid}.${(0, import_node_crypto.randomUUID)()}.tmp`;
+      const handle = await (0, import_promises.open)(temporaryPath, "wx", 384);
+      try {
+        await handle.writeFile(body, "utf8");
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await (0, import_promises.rename)(temporaryPath, this.path);
+      temporaryPath = void 0;
+      return mutation.value;
+    } catch (error) {
+      if (error instanceof ConfigStoreError) {
+        throw error;
+      }
+      if (signal?.aborted) {
+        throw new ConfigStoreError(
+          "config_aborted",
+          `Config transaction aborted: ${this.path}`,
+          this.path,
+          { lockPath: this.lockPath, cause: error }
+        );
+      }
+      throw new ConfigStoreError(
+        "config_write_failed",
+        `Unable to commit config: ${this.path}`,
+        this.path,
+        { lockPath: this.lockPath, cause: error }
+      );
+    } finally {
+      if (temporaryPath) {
+        await (0, import_promises.rm)(temporaryPath, { force: true }).catch(() => void 0);
+      }
+      await this.releaseLock(lock);
+    }
+  }
+  async acquireLock(signal) {
+    const deadline = Date.now() + this.lockTimeoutMs;
+    while (true) {
+      signal?.throwIfAborted();
+      try {
+        const handle = await (0, import_promises.open)(this.lockPath, "wx", 384);
+        try {
+          await handle.writeFile(
+            `pid=${process.pid}
+createdAt=${(/* @__PURE__ */ new Date()).toISOString()}
+`,
+            "utf8"
+          );
+          await handle.sync();
+        } catch (error) {
+          await handle.close().catch(() => void 0);
+          await (0, import_promises.rm)(this.lockPath, { force: true }).catch(() => void 0);
+          throw error;
+        }
+        return handle;
+      } catch (error) {
+        if (!isErrno(error, "EEXIST")) {
+          if (signal?.aborted) {
+            throw new ConfigStoreError(
+              "config_aborted",
+              `Config transaction aborted: ${this.path}`,
+              this.path,
+              { lockPath: this.lockPath, cause: error }
+            );
+          }
+          throw new ConfigStoreError(
+            "config_write_failed",
+            `Unable to acquire config lock: ${this.lockPath}`,
+            this.path,
+            { lockPath: this.lockPath, cause: error }
+          );
+        }
+        if (Date.now() >= deadline) {
+          throw new ConfigStoreError(
+            "config_busy",
+            `Config lock is held: ${this.lockPath}; stop the owning process or remove a confirmed stale lock`,
+            this.path,
+            { lockPath: this.lockPath }
+          );
+        }
+        await waitForRetry(this.lockRetryMs, signal, this.path, this.lockPath);
+      }
+    }
+  }
+  async releaseLock(handle) {
+    await handle.close().catch(() => void 0);
+    await (0, import_promises.rm)(this.lockPath, { force: true }).catch(() => void 0);
+  }
+};
+
+// ../packages/shared/src/connection/mobile-config.ts
+var MOBILE_BRIDGE_CONFIG = {
+  defaultBridgePort: 3333,
+  daemonHost: "0.0.0.0",
+  defaultTerminalCacheLines: 1e3
+};
+var DEFAULT_BRIDGE_PORT = MOBILE_BRIDGE_CONFIG.defaultBridgePort;
+var DEFAULT_DAEMON_HOST = MOBILE_BRIDGE_CONFIG.daemonHost;
+var DEFAULT_DAEMON_PORT = MOBILE_BRIDGE_CONFIG.defaultBridgePort;
+var DEFAULT_TERMINAL_CACHE_LINES = MOBILE_BRIDGE_CONFIG.defaultTerminalCacheLines;
+function buildDaemonSessionName(port = DEFAULT_DAEMON_PORT) {
+  return `zterm-daemon-${port}`;
+}
+var DEFAULT_DAEMON_SESSION_NAME = buildDaemonSessionName();
+var BRIDGE_URL_PLACEHOLDER = `ws://host:${DEFAULT_BRIDGE_PORT}`;
+
+// ../packages/shared/src/node/daemon-config-projection.ts
+var DEFAULT_DAEMON_CACHE_LINES = 3e3;
+function isJsonObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function asPositiveInteger(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.max(1, Math.floor(value));
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number.parseInt(value.trim(), 10);
+    if (Number.isFinite(parsed)) {
+      return Math.max(1, parsed);
+    }
+  }
+  return void 0;
+}
+function nestedObject(value, keys) {
+  let current = value;
+  for (const key of keys) {
+    if (!isJsonObject2(current)) {
+      return {};
+    }
+    current = current[key];
+  }
+  return isJsonObject2(current) ? current : {};
+}
+function fromEnvironment(env, primaryName, fallbackName) {
+  const primary = asString(env[primaryName]);
+  if (primary) {
+    return { value: primary, source: "env", sourceName: primaryName };
+  }
+  if (fallbackName) {
+    const fallback = asString(env[fallbackName]);
+    if (fallback) {
+      return { value: fallback, source: "env", sourceName: fallbackName };
+    }
+  }
+  return void 0;
+}
+function positiveEnvironment(env, primaryName, fallbackName) {
+  const primary = asPositiveInteger(env[primaryName]);
+  if (primary !== void 0) {
+    return { value: primary, source: "env", sourceName: primaryName };
+  }
+  if (fallbackName) {
+    const fallback = asPositiveInteger(env[fallbackName]);
+    if (fallback !== void 0) {
+      return { value: fallback, source: "env", sourceName: fallbackName };
+    }
+  }
+  return void 0;
+}
+function fileString(ztermDaemon, mobileDaemon, key, ztermSourceName, mobileSourceName) {
+  const ztermValue = asString(ztermDaemon[key]);
+  if (ztermValue) {
+    return { value: ztermValue, source: "file", sourceName: ztermSourceName };
+  }
+  const mobileValue = asString(mobileDaemon[key]);
+  if (mobileValue) {
+    return { value: mobileValue, source: "file", sourceName: mobileSourceName };
+  }
+  return void 0;
+}
+function filePositiveInteger(ztermDaemon, mobileDaemon, key, ztermSourceName, mobileSourceName) {
+  const ztermValue = asPositiveInteger(ztermDaemon[key]);
+  if (ztermValue !== void 0) {
+    return { value: ztermValue, source: "file", sourceName: ztermSourceName };
+  }
+  const mobileValue = asPositiveInteger(mobileDaemon[key]);
+  if (mobileValue !== void 0) {
+    return { value: mobileValue, source: "file", sourceName: mobileSourceName };
+  }
+  return void 0;
+}
+function projectDaemonConfig(snapshot, env = process.env) {
+  const zterm = nestedObject(snapshot.config, ["zterm"]);
+  const android = nestedObject(zterm, ["android"]);
+  const ztermDaemon = nestedObject(android, ["daemon"]);
+  const mobile = nestedObject(snapshot.config, ["mobile"]);
+  const mobileDaemon = nestedObject(mobile, ["daemon"]);
+  const host = fromEnvironment(env, "ZTERM_HOST", "HOST") ?? fileString(
+    ztermDaemon,
+    mobileDaemon,
+    "host",
+    "zterm.android.daemon.host",
+    "mobile.daemon.host"
+  ) ?? {
+    value: DEFAULT_DAEMON_HOST,
+    source: "default",
+    sourceName: "default"
+  };
+  const port = positiveEnvironment(env, "ZTERM_PORT", "PORT") ?? filePositiveInteger(
+    ztermDaemon,
+    mobileDaemon,
+    "port",
+    "zterm.android.daemon.port",
+    "mobile.daemon.port"
+  ) ?? {
+    value: DEFAULT_BRIDGE_PORT,
+    source: "default",
+    sourceName: "default"
+  };
+  const authTokenFromEnv = asString(env.ZTERM_AUTH_TOKEN);
+  const auth = authTokenFromEnv ? { configured: true, source: "env", sourceName: "ZTERM_AUTH_TOKEN" } : asString(ztermDaemon.authToken) ? {
+    configured: true,
+    source: "file",
+    sourceName: "zterm.android.daemon.authToken"
+  } : asString(mobileDaemon.authToken) ? {
+    configured: true,
+    source: "file",
+    sourceName: "mobile.daemon.authToken"
+  } : { configured: false, source: "default", sourceName: "default" };
+  const sessionName = fromEnvironment(env, "ZTERM_DAEMON_SESSION") ?? fileString(
+    ztermDaemon,
+    mobileDaemon,
+    "sessionName",
+    "zterm.android.daemon.sessionName",
+    "mobile.daemon.sessionName"
+  ) ?? {
+    value: buildDaemonSessionName(port.value),
+    source: "default",
+    sourceName: "default"
+  };
+  const cacheLines = positiveEnvironment(env, "ZTERM_TERMINAL_CACHE_LINES") ?? filePositiveInteger(
+    ztermDaemon,
+    mobileDaemon,
+    "terminalCacheLines",
+    "zterm.android.daemon.terminalCacheLines",
+    "mobile.daemon.terminalCacheLines"
+  ) ?? {
+    value: DEFAULT_DAEMON_CACHE_LINES,
+    source: "default",
+    sourceName: "default"
+  };
+  return {
+    configPath: snapshot.path,
+    configFound: snapshot.found,
+    runtimeLoaded: "unknown",
+    host,
+    port,
+    sessionName,
+    cacheLines,
+    auth
+  };
+}
+async function readDaemonConfigProjection(store, env = process.env) {
+  return projectDaemonConfig(await store.read(), env);
+}
+
+// src/server/terminal-config-command.ts
+function isJsonObject3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function requiredOption(args, index, name) {
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) {
+    throw new Error(`${name} requires a value`);
+  }
+  return value;
+}
+async function readStdin() {
+  let content = "";
+  for await (const chunk of process.stdin) {
+    content += String(chunk);
+  }
+  return content.replace(/\r?\n$/, "");
+}
+async function parseRelayInput(args) {
+  let relayUrl = "";
+  let username = "";
+  let hostId = "";
+  let deviceId;
+  let deviceName;
+  let passwordStdin = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    switch (argument) {
+      case "--relay-url":
+        relayUrl = requiredOption(args, index, argument);
+        index += 1;
+        break;
+      case "--username":
+        username = requiredOption(args, index, argument);
+        index += 1;
+        break;
+      case "--host-id":
+        hostId = requiredOption(args, index, argument);
+        index += 1;
+        break;
+      case "--device-id":
+        deviceId = requiredOption(args, index, argument);
+        index += 1;
+        break;
+      case "--device-name":
+        deviceName = requiredOption(args, index, argument);
+        index += 1;
+        break;
+      case "--password-stdin":
+        passwordStdin = true;
+        break;
+      case "--password":
+      case "--password-env":
+        throw new Error("relay password must be supplied on stdin with --password-stdin");
+      default:
+        throw new Error(`unknown configure-relay option: ${argument}`);
+    }
+  }
+  if (!passwordStdin) {
+    throw new Error("configure-relay requires --password-stdin");
+  }
+  const password = await readStdin();
+  if (!relayUrl || !username || !password || !hostId) {
+    throw new Error("configure-relay requires --relay-url, --username, --password-stdin, and --host-id");
+  }
+  return { relayUrl, username, password, hostId, deviceId, deviceName };
+}
+function writeHumanProjection(projection) {
+  process.stdout.write(`configPath=${projection.configPath}
+`);
+  process.stdout.write(`configFound=${projection.configFound ? "yes" : "no"}
+`);
+  for (const [name, value] of Object.entries({
+    host: projection.host,
+    port: projection.port,
+    sessionName: projection.sessionName,
+    cacheLines: projection.cacheLines
+  })) {
+    process.stdout.write(
+      `${name}=${String(value.value)} source=${value.sourceName}
+`
+    );
+  }
+  process.stdout.write(
+    `auth=${projection.auth.configured ? "configured" : "not-configured"} source=${projection.auth.sourceName}
+`
+  );
+  process.stdout.write("runtimeLoaded=unknown\n");
+}
+async function configureRelay(args) {
+  const input = await parseRelayInput(args);
+  const store = new SharedConfigStore();
+  await store.update((latest) => {
+    if (latest.mobile !== void 0 && !isJsonObject3(latest.mobile)) {
+      throw new ConfigStoreError("invalid_config", "mobile must be a JSON object", store.path);
+    }
+    const mobile = isJsonObject3(latest.mobile) ? latest.mobile : {};
+    latest.mobile = mobile;
+    if (mobile.relay !== void 0 && !isJsonObject3(mobile.relay)) {
+      throw new ConfigStoreError("invalid_config", "mobile.relay must be a JSON object", store.path);
+    }
+    const relay = isJsonObject3(mobile.relay) ? mobile.relay : {};
+    const next = {
+      ...relay,
+      relayUrl: input.relayUrl,
+      username: input.username,
+      password: input.password,
+      hostId: input.hostId,
+      deviceId: input.deviceId || input.hostId,
+      deviceName: input.deviceName || (0, import_node_os2.hostname)(),
+      platform: process.platform
+    };
+    const changed = !(0, import_node_util.isDeepStrictEqual)(relay, next);
+    mobile.relay = next;
+    return { value: void 0, changed };
+  }, void 0);
+  process.stdout.write(
+    `zterm relay configured: path=${store.path} relayUrl=${input.relayUrl} username=${input.username} hostId=${input.hostId} deviceName=${input.deviceName || (0, import_node_os2.hostname)()} passwordSet=true
+`
+  );
+}
+async function runTerminalConfigCommand(args) {
+  const [command, ...rest] = args;
+  if (command === "daemon-config" && rest.length === 0) {
+    writeHumanProjection(await readDaemonConfigProjection(new SharedConfigStore()));
+    return;
+  }
+  if (command === "daemon-config" && rest.length === 1 && rest[0] === "--shell") {
+    const projection = await readDaemonConfigProjection(new SharedConfigStore());
+    process.stdout.write(`HOST=${shellQuote(projection.host.value)}
+`);
+    process.stdout.write(`PORT=${shellQuote(String(projection.port.value))}
+`);
+    process.stdout.write(`SESSION_NAME=${shellQuote(projection.sessionName.value)}
+`);
+    process.stdout.write(`AUTH_SOURCE=${shellQuote(projection.auth.source === "file" ? "config" : projection.auth.source)}
+`);
+    process.stdout.write(`CONFIG_FOUND=${shellQuote(projection.configFound ? "1" : "0")}
+`);
+    process.stdout.write(`CONFIG_DISPLAY_PATH=${shellQuote(projection.configPath)}
+`);
+    return;
+  }
+  if (command === "configure-relay") {
+    await configureRelay(rest);
+    return;
+  }
+  throw new Error("usage: terminal-config-command daemon-config [--shell]|configure-relay ...");
+}
+if (typeof require !== "undefined" && require.main === module) {
+  runTerminalConfigCommand(process.argv.slice(2)).catch((error) => {
+    if (error instanceof ConfigStoreError) {
+      process.stderr.write(`zterm config ${error.code}: ${error.message}
+`);
+    } else {
+      process.stderr.write(`zterm config failed: ${error instanceof Error ? error.message : String(error)}
+`);
+    }
+    process.exitCode = 1;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runTerminalConfigCommand
+});