@codexhost/cli-win32-arm64 0.11.0 → 0.12.1

package/app/plugins/claude-code/plugin.mjs

@@ -6,6 +6,7 @@ var __export = (target, all) => {
 };
 
 // ../../harness-broker/dist/client.js
+import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { lstat, readFile } from "node:fs/promises";
 import net, {} from "node:net";
@@ -14594,6 +14595,20 @@ var harnessDisplaySetSchema = external_exports.strictObject({
   initializeOnly: external_exports.boolean().optional()
 });
 
+// ../../shared-contracts/dist/ids.js
+var opaqueIdSchema = external_exports.string().refine((value) => value.trim().length > 0, {
+  message: "Identifier must not be empty or whitespace"
+});
+var harnessIdSchema = opaqueIdSchema.brand();
+var hostThreadIdSchema = opaqueIdSchema.brand();
+var hostTurnIdSchema = opaqueIdSchema.brand();
+var hostItemIdSchema = opaqueIdSchema.brand();
+var hostInteractionIdSchema = opaqueIdSchema.brand();
+
+// ../../shared-contracts/dist/thread-prewarm.js
+var threadPrewarmDiscardParamsSchema = external_exports.object({ threadId: hostThreadIdSchema });
+var threadPrewarmDiscardResultSchema = external_exports.object({ discarded: external_exports.boolean() });
+
 // ../../shared-contracts/dist/console.js
 var consoleAnnouncementSchema = external_exports.strictObject({
   title: external_exports.string().trim().min(1).max(200),
@@ -14606,10 +14621,14 @@ var consoleOpenResultSchema = external_exports.strictObject({
   url: external_exports.string().max(2048).regex(/^http:\/\/(?:127\.0\.0\.1|localhost):\d{1,5}\/(?:\?.*)?$/u)
 });
 var CONSOLE_HOST_METHODS = Object.freeze([
+  "codexhost/console/remote-connections",
+  "codexhost/runtime/status",
+  "codexhost/remote/ssh-setup",
   "codexhost/harness/plugins/list",
   "codexhost/harness/display-settings/get",
   "codexhost/harness/display-settings/set",
   "codexhost/harness/inspect",
+  "codexhost/harness/installation",
   "codexhost/harness/launch-settings/get",
   "codexhost/harness/launch-settings/set",
   "codexhost/harness/web-ui/open",
@@ -14671,16 +14690,6 @@ var loadedSessionsSchema = external_exports.array(external_exports.strictObject(
   inactiveMs: external_exports.number().nonnegative()
 }));
 
-// ../../shared-contracts/dist/ids.js
-var opaqueIdSchema = external_exports.string().refine((value) => value.trim().length > 0, {
-  message: "Identifier must not be empty or whitespace"
-});
-var harnessIdSchema = opaqueIdSchema.brand();
-var hostThreadIdSchema = opaqueIdSchema.brand();
-var hostTurnIdSchema = opaqueIdSchema.brand();
-var hostItemIdSchema = opaqueIdSchema.brand();
-var hostInteractionIdSchema = opaqueIdSchema.brand();
-
 // ../../shared-contracts/dist/manual-compaction.js
 var threadManualCompactionStartedSchema = external_exports.strictObject({
   threadId: hostThreadIdSchema,
@@ -15256,14 +15265,17 @@ var harnessLaunchSettingsSchema = external_exports.object({
 // ../../shared-contracts/dist/harness-installation.js
 var harnessInstallationParamsSchema = external_exports.object({
   harnessId: harnessIdSchema,
-  action: external_exports.enum(["check", "update"])
+  action: external_exports.enum(["check", "update", "install"])
 }).strict();
 var harnessInstallationStateSchema = external_exports.object({
   currentVersion: external_exports.string().min(1).max(128),
   latestVersion: external_exports.string().min(1).max(128),
   updateAvailable: external_exports.boolean(),
   canUpdate: external_exports.boolean(),
-  message: external_exports.string().max(2048).optional()
+  // Adapter-owned diagnostic text; UI uses messageCode rather than displaying it verbatim.
+  message: external_exports.string().max(2048).optional(),
+  messageCode: external_exports.string().min(1).max(128).optional(),
+  latestVersionKind: external_exports.enum(["unknown", "tracking-branch"]).optional()
 }).strict();
 
 // ../../shared-contracts/dist/codex-accounts.js
@@ -15565,6 +15577,80 @@ var updateStatusResultSchema = external_exports.strictObject({
   status: updateStatusSchema.nullable()
 });
 
+// ../../shared-contracts/dist/remote-runtime.js
+var remoteUpdatePhaseSchema = external_exports.enum([
+  "idle",
+  "installing",
+  "restarting",
+  "succeeded",
+  "failed"
+]);
+var runtimeStatusSchema = external_exports.object({
+  runningVersion: external_exports.string().nullable(),
+  installedVersion: external_exports.string().nullable(),
+  restartRequired: external_exports.boolean(),
+  remote: external_exports.boolean(),
+  updateSupported: external_exports.boolean(),
+  update: external_exports.object({
+    phase: remoteUpdatePhaseSchema,
+    targetVersion: external_exports.string().nullable(),
+    error: external_exports.string().nullable()
+  })
+});
+var remoteUpdateParamsSchema = external_exports.object({
+  version: external_exports.string().regex(/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u)
+}).strict();
+var remoteSshSetupParamsSchema = external_exports.object({
+  hostname: external_exports.string().min(1).max(1024).refine((value) => !value.startsWith("-") && !/\s/u.test(value)),
+  port: external_exports.number().int().min(1).max(65535).nullable(),
+  identity: external_exports.string().max(4096).nullable(),
+  action: external_exports.enum(["inspect", "install", "update", "repair", "uninstall"]),
+  uninstallPackage: external_exports.boolean().optional(),
+  version: external_exports.string().regex(/^\d+\.\d+\.\d+$/u).nullable()
+}).strict();
+var remoteSshSetupResultSchema = external_exports.object({ state: external_exports.enum(["installed", "not-installed"]) }).strict();
+
+// ../../shared-contracts/dist/remote-connections.js
+var hostId = external_exports.string().min(1).max(1024);
+var codexSshConnectionSchema = external_exports.object({
+  hostId,
+  displayName: external_exports.string().min(1).max(1024),
+  source: external_exports.enum(["codex-managed", "discovered"]),
+  sshAlias: external_exports.string().max(1024).nullable(),
+  sshHost: external_exports.string().min(1).max(1024),
+  sshPort: external_exports.number().int().min(1).max(65535).nullable(),
+  identity: external_exports.string().max(4096).nullable(),
+  autoConnect: external_exports.boolean(),
+  connectionAnalyticsId: external_exports.string().max(1024).optional()
+});
+var codexSshDraftSchema = external_exports.strictObject({
+  displayName: external_exports.string().min(1).max(1024),
+  hostname: external_exports.string().min(1).max(1024),
+  sshPort: external_exports.number().int().min(1).max(65535).nullable(),
+  identity: external_exports.string().max(4096).nullable()
+});
+var remoteConnectionsRequestSchema = external_exports.discriminatedUnion("action", [
+  external_exports.strictObject({ action: external_exports.literal("list") }),
+  external_exports.strictObject({
+    action: external_exports.literal("save"),
+    draft: codexSshDraftSchema,
+    previous: codexSshConnectionSchema.nullable()
+  }),
+  external_exports.strictObject({ action: external_exports.literal("remove"), previous: codexSshConnectionSchema }),
+  external_exports.strictObject({ action: external_exports.literal("connect"), hostId, enabled: external_exports.boolean() }),
+  external_exports.strictObject({ action: external_exports.literal("state"), hostId }),
+  external_exports.strictObject({ action: external_exports.literal("runtime"), hostId }),
+  external_exports.strictObject({
+    action: external_exports.literal("update"),
+    hostId: hostId.refine((id) => id !== "local"),
+    version: remoteUpdateParamsSchema.shape.version
+  })
+]);
+var remoteConnectionsReplySchema = external_exports.union([
+  external_exports.strictObject({ result: jsonValueSchema }),
+  external_exports.strictObject({ error: external_exports.strictObject({ code: external_exports.number().int(), message: external_exports.string() }) })
+]);
+
 // ../../shared-contracts/dist/index.js
 var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
@@ -15883,9 +15969,12 @@ var HARNESS_BROKER_PROTOCOL_VERSION = 1;
 var HARNESS_BROKER_MAX_FRAME_BYTES = 8 * 1024 * 1024;
 var HARNESS_BROKER_MAX_PENDING_REQUESTS = 32;
 var HARNESS_BROKER_REQUEST_TIMEOUT_MS = 15e3;
+var HARNESS_BROKER_IDLE_TIMEOUT_MS = 60 * 60 * 1e3;
+var HARNESS_BROKER_RETIRING_ERROR_CODE = "brokerRetiring";
 var harnessBrokerMethodSchema = external_exports.enum([
   "adapter.inspect",
   "adapter.inspectAccount",
+  "adapter.credits",
   "adapter.open",
   "adapter.subagent.readSnapshot",
   "session.readSnapshot",
@@ -16003,6 +16092,14 @@ function defaultHarnessBrokerDescriptorPath(environment = process.env, harnessId
     return path.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
   return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
 }
+function harnessBrokerLaunchAgentLabel(harnessId = "claude-code") {
+  harnessPluginIdSchema.parse(harnessId);
+  return harnessId === "claude-code" ? "ai.bytepioneer.codexhost.native-harness-broker" : `ai.bytepioneer.codexhost.${harnessId}-broker`;
+}
+function harnessBrokerLaunchAgentPlistPath(environment = process.env, harnessId = "claude-code") {
+  const home = environment.HOME || os.homedir();
+  return path.join(home, "Library", "LaunchAgents", `${harnessBrokerLaunchAgentLabel(harnessId)}.plist`);
+}
 
 // ../../harness-broker/dist/validation.js
 var cwdSchema = external_exports.string().min(1).max(16384);
@@ -16308,10 +16405,55 @@ async function readDescriptor(descriptorPath) {
   try {
     process.kill(descriptor.ownerPid, 0);
   } catch {
-    throw new Error("Aqua Harness broker owner process is unavailable");
+    throw new BrokerNotRunningError("its owner process has exited");
   }
   return descriptor;
 }
+var BrokerNotRunningError = class extends Error {
+};
+var BrokerRetiringError = class extends Error {
+};
+var BrokerRequestNotDeliveredError = class extends Error {
+};
+var HarnessNotInstalledError = class extends Error {
+};
+var BROKER_NOT_RUNNING_CODES = /* @__PURE__ */ new Set(["ENOENT", "ECONNREFUSED"]);
+var BROKER_START_TIMEOUT_MS = 15e3;
+var BROKER_START_POLL_MS = 250;
+function classifyConnectFailure(error52) {
+  if (error52 instanceof BrokerNotRunningError)
+    return error52;
+  const code = error52?.code;
+  if (code && BROKER_NOT_RUNNING_CODES.has(code)) {
+    return new BrokerNotRunningError(code === "ENOENT" ? "its descriptor or socket is missing" : "its socket refused the connection");
+  }
+  return error52 instanceof Error ? error52 : new Error(String(error52));
+}
+function describeBrokerFailure(error52, harnessId) {
+  if (error52 instanceof BrokerNotRunningError) {
+    return `The ${harnessId} Aqua Harness broker on this Mac could not be started (${error52.message}). Keep the desktop user logged in, then repair the remote service or run on this Mac: codexhost broker install --harness ${harnessId}`;
+  }
+  return error52 instanceof Error ? error52.message : String(error52);
+}
+function runLaunchctl(arguments_) {
+  return new Promise((resolve2) => {
+    execFile("/bin/launchctl", arguments_, { timeout: 1e4 }, (error52) => resolve2(!error52));
+  });
+}
+async function startBrokerLaunchAgent(harnessId, environment) {
+  const uid = process.getuid?.();
+  if (uid === void 0)
+    return;
+  const target = `gui/${uid}/${harnessBrokerLaunchAgentLabel(harnessId)}`;
+  if (await runLaunchctl(["kickstart", target]))
+    return;
+  await runLaunchctl([
+    "bootstrap",
+    `gui/${uid}`,
+    harnessBrokerLaunchAgentPlistPath(environment, harnessId)
+  ]);
+  await runLaunchctl(["kickstart", target]);
+}
 var BrokerConnection = class _BrokerConnection {
   #onClose;
   onClose(callback) {
@@ -16335,21 +16477,31 @@ var BrokerConnection = class _BrokerConnection {
     socket.once("error", (error52) => this.#fail(error52));
   }
   static async connect(descriptorPath, harnessId) {
-    const descriptor = await readDescriptor(descriptorPath);
-    if (descriptor.harnessId !== harnessId)
-      throw new Error("Aqua broker belongs to another Harness");
-    const socket = net.createConnection(descriptor.socketPath);
-    await new Promise((resolve2, reject) => {
-      const timeout = setTimeout(() => reject(new Error("Timed out connecting to Aqua Harness broker")), HARNESS_BROKER_REQUEST_TIMEOUT_MS);
-      socket.once("connect", () => {
-        clearTimeout(timeout);
-        resolve2();
-      });
-      socket.once("error", (error52) => {
-        clearTimeout(timeout);
-        reject(error52);
+    let descriptor;
+    let socket;
+    let connecting;
+    try {
+      descriptor = await readDescriptor(descriptorPath);
+      if (descriptor.harnessId !== harnessId)
+        throw new Error("Aqua broker belongs to another Harness");
+      connecting = net.createConnection(descriptor.socketPath);
+      const pending = connecting;
+      await new Promise((resolve2, reject) => {
+        const timeout = setTimeout(() => reject(new Error("Timed out connecting to Aqua Harness broker")), HARNESS_BROKER_REQUEST_TIMEOUT_MS);
+        pending.once("connect", () => {
+          clearTimeout(timeout);
+          resolve2();
+        });
+        pending.once("error", (error52) => {
+          clearTimeout(timeout);
+          reject(error52);
+        });
       });
-    });
+      socket = pending;
+    } catch (error52) {
+      connecting?.destroy();
+      throw classifyConnectFailure(error52);
+    }
     const connection = new _BrokerConnection(descriptor, socket);
     const hello = connection.#waitForHello();
     await writeBrokerFrame(socket, {
@@ -16402,15 +16554,24 @@ var BrokerConnection = class _BrokerConnection {
       }, HARNESS_BROKER_REQUEST_TIMEOUT_MS);
       this.#pending.set(id, { resolve: resolve2, reject, timeout });
     });
-    await writeBrokerFrame(this.#socket, {
-      version: HARNESS_BROKER_PROTOCOL_VERSION,
-      generation: this.#descriptor.generation,
-      sequence: this.#inputSequence,
-      kind: "request",
-      id,
-      method,
-      params
-    });
+    try {
+      await writeBrokerFrame(this.#socket, {
+        version: HARNESS_BROKER_PROTOCOL_VERSION,
+        generation: this.#descriptor.generation,
+        sequence: this.#inputSequence,
+        kind: "request",
+        id,
+        method,
+        params
+      });
+    } catch (error52) {
+      const pending = this.#pending.get(id);
+      if (pending)
+        clearTimeout(pending.timeout);
+      this.#pending.delete(id);
+      response.catch(() => void 0);
+      throw new BrokerRequestNotDeliveredError(error52 instanceof Error ? error52.message : String(error52));
+    }
     return response;
   }
   close() {
@@ -16454,6 +16615,8 @@ var BrokerConnection = class _BrokerConnection {
     this.#pending.delete(frame.id);
     if (frame.ok)
       pending.resolve(frame.value);
+    else if (frame.error?.code === HARNESS_BROKER_RETIRING_ERROR_CODE)
+      pending.reject(new BrokerRetiringError(frame.error.message));
     else
       pending.reject(new Error(frame.error?.message ?? "Broker request failed"));
   }
@@ -16679,17 +16842,19 @@ var BrokeredHarnessAdapter = class {
   harnessId;
   #descriptorPath;
   #forwardEnvironment;
+  #isInstalled;
+  #startBroker;
+  #startTimeoutMs;
   #connection = null;
   #closed = false;
+  #credits = null;
+  #creditsRefresh = null;
   subagents = {
     readSnapshot: async (input) => {
       try {
-        return parseHarnessResult(await (await this.#connect()).request("adapter.subagent.readSnapshot", input));
+        return parseHarnessResult(await this.#request("adapter.subagent.readSnapshot", input));
       } catch (error52) {
-        return {
-          ok: false,
-          error: unavailable(error52 instanceof Error ? error52.message : String(error52))
-        };
+        return { ok: false, error: this.#error(error52) };
       }
     }
   };
@@ -16701,12 +16866,39 @@ var BrokeredHarnessAdapter = class {
     if (input.liveCommandCatalog)
       this.liveCommandCatalog = true;
     this.#descriptorPath = input.descriptorPath ?? defaultHarnessBrokerDescriptorPath(input.environment, this.harnessId);
+    this.#isInstalled = input.isInstalled;
+    const environment = input.environment ?? process.env;
+    this.#startBroker = input.startBroker === false ? void 0 : input.startBroker ?? (process.platform === "darwin" && !input.descriptorPath ? () => startBrokerLaunchAgent(this.harnessId, environment) : void 0);
+    this.#startTimeoutMs = input.startTimeoutMs ?? BROKER_START_TIMEOUT_MS;
+  }
+  credits() {
+    return this.#credits;
+  }
+  refreshCredits() {
+    if (this.#closed)
+      return Promise.resolve(null);
+    if (this.#creditsRefresh)
+      return this.#creditsRefresh;
+    this.#creditsRefresh = this.#readCredits().finally(() => {
+      this.#creditsRefresh = null;
+    });
+    return this.#creditsRefresh;
+  }
+  async #readCredits() {
+    try {
+      const value = await this.#request("adapter.credits", {}, true);
+      const credits = accountCreditsSnapshotSchema.nullable().parse(value);
+      if (!this.#closed)
+        this.#credits = credits;
+    } catch {
+    }
+    return this.#credits;
   }
   async inspectAccount() {
     if (this.#closed)
       return null;
     try {
-      const value = await (await this.#connect()).request("adapter.inspectAccount", {});
+      const value = await this.#request("adapter.inspectAccount", {}, true);
       return harnessAccountSnapshotSchema.nullable().parse(value);
     } catch {
       return null;
@@ -16716,33 +16908,46 @@ var BrokeredHarnessAdapter = class {
     if (this.#closed)
       return failedInspection("Aqua Harness broker adapter is closed");
     try {
-      return harnessInspectionSchema.parse(await (await this.#connect()).request("adapter.inspect", input));
+      return harnessInspectionSchema.parse(await this.#request("adapter.inspect", input, true));
     } catch (error52) {
       this.#connection = null;
-      return failedInspection(error52 instanceof Error ? error52.message : String(error52));
+      if (error52 instanceof HarnessNotInstalledError)
+        return { status: "notInstalled", error: this.#error(error52) };
+      return failedInspection(describeBrokerFailure(error52, this.harnessId));
     }
   }
   async open(input) {
     if (this.#closed)
       return { ok: false, error: unavailable("Aqua Harness broker adapter is closed", false) };
+    const safeInput = { ...input };
+    delete safeInput.environment;
+    if (this.#forwardEnvironment && input.environment) {
+      const allowed2 = [
+        "CODEXHOST_CLI_PATH",
+        "CODEXHOST_CLI_NODE_PATH",
+        "CODEXHOST_RUNTIME_ENDPOINT",
+        "CODEXHOST_RUNTIME_TOKEN",
+        "CODEXHOST_THREAD_ID"
+      ];
+      const environment = Object.fromEntries(Object.entries(input.environment).filter(([key, value]) => allowed2.includes(key) && value !== void 0));
+      if (Object.keys(environment).length)
+        safeInput.environment = environment;
+    }
     let connection;
     try {
-      const safeInput = { ...input };
-      delete safeInput.environment;
-      if (this.#forwardEnvironment && input.environment) {
-        const allowed2 = [
-          "CODEXHOST_CLI_PATH",
-          "CODEXHOST_CLI_NODE_PATH",
-          "CODEXHOST_RUNTIME_ENDPOINT",
-          "CODEXHOST_RUNTIME_TOKEN",
-          "CODEXHOST_THREAD_ID"
-        ];
-        const environment = Object.fromEntries(Object.entries(input.environment).filter(([key, value]) => allowed2.includes(key) && value !== void 0));
-        if (Object.keys(environment).length)
-          safeInput.environment = environment;
-      }
-      connection = await this.#connect();
-      const result = parseHarnessResult(await connection.request("adapter.open", safeInput));
+      let value;
+      for (let attempt = 0; ; attempt += 1) {
+        connection = await this.#connect();
+        try {
+          value = await connection.request("adapter.open", safeInput);
+          break;
+        } catch (error52) {
+          if (attempt > 0 || !(error52 instanceof BrokerRetiringError || error52 instanceof BrokerRequestNotDeliveredError))
+            throw error52;
+          this.#connection = null;
+        }
+      }
+      const result = parseHarnessResult(value);
       if (!result.ok)
         return result;
       const session = new BrokeredHarnessSession(connection, parseSessionMetadata(result.value), this.harnessId, safeInput, () => this.#connect(), () => {
@@ -16753,25 +16958,51 @@ var BrokeredHarnessAdapter = class {
     } catch (error52) {
       connection?.close();
       this.#connection = null;
-      return {
-        ok: false,
-        error: unavailable(error52 instanceof Error ? error52.message : String(error52))
-      };
+      return { ok: false, error: this.#error(error52) };
     }
   }
   async close() {
     this.#closed = true;
+    this.#credits = null;
     await Promise.allSettled([...this.#sessions].map((session) => session.close()));
     this.#sessions.clear();
     const connection = await this.#connection?.catch(() => null);
     await connection?.dispose();
     this.#connection = null;
   }
+  #error(error52) {
+    if (error52 instanceof HarnessNotInstalledError)
+      return {
+        code: "notInstalled",
+        message: error52.message,
+        retryable: false,
+        stage: "harnessBroker"
+      };
+    return unavailable(describeBrokerFailure(error52, this.harnessId));
+  }
+  /**
+   * Sends one adapter-level request. A broker that retired between requests refuses it
+   * unprocessed, so it is retried once on a fresh broker. Idempotent reads also retry
+   * once after a plain disconnect.
+   */
+  async #request(method, params, idempotent = false) {
+    for (let attempt = 0; ; attempt += 1) {
+      const connection = await this.#connect();
+      try {
+        return await connection.request(method, params);
+      } catch (error52) {
+        const retryable = error52 instanceof BrokerRetiringError || error52 instanceof BrokerRequestNotDeliveredError || idempotent && connection.closed;
+        if (attempt > 0 || !retryable)
+          throw error52;
+        this.#connection = null;
+      }
+    }
+  }
   #connect() {
     if (this.#closed)
       return Promise.reject(new Error("Aqua Harness broker adapter is closed"));
     if (!this.#connection) {
-      const pending = BrokerConnection.connect(this.#descriptorPath, this.harnessId).then((connection) => {
+      const pending = this.#establish().then((connection) => {
         connection.onClose(() => {
           if (this.#connection === pending)
             this.#connection = null;
@@ -16786,6 +17017,28 @@ var BrokeredHarnessAdapter = class {
     }
     return this.#connection;
   }
+  async #establish() {
+    try {
+      return await BrokerConnection.connect(this.#descriptorPath, this.harnessId);
+    } catch (error52) {
+      if (!(error52 instanceof BrokerNotRunningError) || !this.#startBroker)
+        throw error52;
+    }
+    if (this.#isInstalled && !this.#isInstalled()) {
+      throw new HarnessNotInstalledError(`${this.harnessId} is not installed on this Mac`);
+    }
+    const deadline = Date.now() + this.#startTimeoutMs;
+    for (; ; ) {
+      await this.#startBroker();
+      try {
+        return await BrokerConnection.connect(this.#descriptorPath, this.harnessId);
+      } catch (error52) {
+        if (!(error52 instanceof BrokerNotRunningError) || Date.now() >= deadline)
+          throw error52;
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, BROKER_START_POLL_MS));
+    }
+  }
 };
 
 // dist/claude-code-adapter.js
@@ -42487,32 +42740,109 @@ import { opendir, realpath, stat } from "node:fs/promises";
 import os2 from "node:os";
 import path2 from "node:path";
 import { createInterface } from "node:readline";
-var CLAUDE_SESSION_IMPORT_TITLE_MAX_LENGTH = 120;
-var CLAUDE_INTERNAL_USER_TEXT = /^<(?:local-command-|command-)/u;
-var ClaudeSessionChangedError = class extends Error {
-  constructor() {
-    super("Claude Code Session changed during discovery; refresh and retry");
+
+// ../../harness-adapter/dist/session-import.js
+var SessionImportChangedError = class extends Error {
+  constructor(message = "Native Session changed during discovery; refresh and retry") {
+    super(message);
+    this.name = "SessionImportChangedError";
   }
 };
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function missing(error52) {
-  return isRecord2(error52) && error52.code === "ENOENT";
+function isMissingFileError(error52) {
+  return typeof error52 === "object" && error52 !== null && "code" in error52 && error52.code === "ENOENT";
 }
-function sameFile(left, right) {
-  return left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs && left.ino === right.ino && left.dev === right.dev;
+function sameFileFingerprint(left, right) {
+  return left === null || right === null ? left === right : left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
 }
-function cleanText(value) {
+function sessionImportTitle(value, maxLength = HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH) {
   if (typeof value !== "string")
     return null;
   const normalized = value.replaceAll("\0", "").replaceAll(/\s+/gu, " ").trim();
   if (!normalized)
     return null;
+  if (normalized.length <= maxLength)
+    return normalized;
   const characters = [...normalized];
-  if (characters.length <= CLAUDE_SESSION_IMPORT_TITLE_MAX_LENGTH)
+  if (characters.length <= maxLength)
     return normalized;
-  return `${characters.slice(0, CLAUDE_SESSION_IMPORT_TITLE_MAX_LENGTH - 1).join("").trimEnd()}…`;
+  return `${characters.slice(0, maxLength - 1).join("").trimEnd()}…`;
+}
+function sessionImportCandidate(input) {
+  const time3 = typeof input.updatedAt === "number" ? input.updatedAt : typeof input.updatedAt === "string" ? Date.parse(input.updatedAt) : Number.NaN;
+  const parsed = harnessSessionImportCandidateSchema.safeParse({
+    nativeSessionId: input.nativeSessionId,
+    cwd: input.cwd,
+    title: typeof input.title === "string" && input.title.trim().length > 0 ? input.title : null,
+    updatedAt: Math.floor(time3),
+    // Unknown must stay unknown; only an explicit boolean is a native statement.
+    running: typeof input.running === "boolean" ? input.running : null
+  });
+  return parsed.success ? parsed.data : null;
+}
+var SessionImportScope = class {
+  #abort = new AbortController();
+  #options;
+  #pending = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.#options = options;
+  }
+  #closed() {
+    return {
+      ok: false,
+      error: { code: "invalidState", message: this.#options.closedMessage, retryable: false }
+    };
+  }
+  read(operation) {
+    const signal = this.#abort.signal;
+    if (signal.aborted)
+      return Promise.resolve(this.#closed());
+    let started;
+    try {
+      started = operation(signal);
+    } catch (error52) {
+      started = Promise.reject(error52 instanceof Error ? error52 : new Error("Session read failed"));
+    }
+    const request = started.then((value) => signal.aborted ? this.#closed() : { ok: true, value }).catch(() => signal.aborted ? this.#closed() : {
+      ok: false,
+      error: {
+        code: "unavailable",
+        message: this.#options.unavailableMessage,
+        retryable: true
+      }
+    }).finally(() => this.#pending.delete(request));
+    this.#pending.add(request);
+    return request;
+  }
+  /** `read` for `resolveCandidate`: a null source is the selected Session having disappeared. */
+  async resolve(operation) {
+    const result = await this.read(operation);
+    if (!result.ok)
+      return result;
+    return result.value ? { ok: true, value: result.value } : {
+      ok: false,
+      error: {
+        code: "sessionNotFound",
+        message: this.#options.notFoundMessage,
+        retryable: false
+      }
+    };
+  }
+  /** Idempotent. Resolves after every started read has settled. */
+  async close() {
+    this.#abort.abort();
+    await Promise.allSettled(this.#pending);
+  }
+};
+
+// dist/claude-session-import.js
+var CLAUDE_SESSION_IMPORT_TITLE_MAX_LENGTH = 120;
+var CLAUDE_INTERNAL_USER_TEXT = /^<(?:local-command-|command-)/u;
+var CLAUDE_SESSION_CHANGED = "Claude Code Session changed during discovery; refresh and retry";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cleanText(value) {
+  return sessionImportTitle(value, CLAUDE_SESSION_IMPORT_TITLE_MAX_LENGTH);
 }
 function userText(message) {
   if (!isRecord2(message) || message.role !== "user")
@@ -42528,7 +42858,7 @@ function claudeProjectsDirectory(environment) {
 async function sessionFiles(directory, signal) {
   signal.throwIfAborted();
   const projects = await opendir(directory).catch((error52) => {
-    if (missing(error52))
+    if (isMissingFileError(error52))
       return null;
     throw error52;
   });
@@ -42540,7 +42870,7 @@ async function sessionFiles(directory, signal) {
     if (!project.isDirectory())
       continue;
     const entries = await opendir(path2.join(directory, project.name)).catch((error52) => {
-      if (missing(error52))
+      if (isMissingFileError(error52))
         return null;
       throw error52;
     });
@@ -42607,24 +42937,23 @@ async function readCandidate(file2, signal) {
   if (!hasConversation || !cwd)
     return null;
   const after = await stat(file2);
-  if (!sameFile(before, after))
-    throw new ClaudeSessionChangedError();
+  if (!sameFileFingerprint(before, after))
+    throw new SessionImportChangedError(CLAUDE_SESSION_CHANGED);
   const resolvedCwd = await realpath(cwd);
   if (!(await stat(resolvedCwd)).isDirectory())
     return null;
-  const candidate = harnessSessionImportCandidateSchema.safeParse({
+  const candidate = sessionImportCandidate({
     nativeSessionId,
     title: customTitle ?? generatedTitle ?? firstPrompt,
-    updatedAt: Math.floor(before.mtimeMs),
-    cwd: resolvedCwd,
-    running: null
+    updatedAt: before.mtimeMs,
+    cwd: resolvedCwd
   });
   const nativeRef = nativeSessionRefSchema.safeParse({
     harnessId: "claude-code",
     nativeSessionId,
     formatVersion: 1
   });
-  return candidate.success && nativeRef.success ? { candidate: candidate.data, nativeRef: nativeRef.data } : null;
+  return candidate && nativeRef.success ? { candidate, nativeRef: nativeRef.data } : null;
 }
 var ClaudeSessionImportIndex = class {
   #directory;
@@ -42648,7 +42977,7 @@ var ClaudeSessionImportIndex = class {
       try {
         const fingerprint = await stat(file2);
         const cached2 = this.#cache.get(file2);
-        const source = cached2 && sameFile(cached2.fingerprint, fingerprint) ? cached2.source : await readCandidate(file2, signal);
+        const source = cached2 && sameFileFingerprint(cached2.fingerprint, fingerprint) ? cached2.source : await readCandidate(file2, signal);
         if (!source)
           continue;
         if (!(await stat(source.candidate.cwd)).isDirectory())
@@ -42660,7 +42989,7 @@ var ClaudeSessionImportIndex = class {
         next.set(file2, { fingerprint, source });
         sources.push(source);
       } catch (error52) {
-        if (!missing(error52) && !(error52 instanceof ClaudeSessionChangedError))
+        if (!isMissingFileError(error52) && !(error52 instanceof SessionImportChangedError))
           throw error52;
       }
     }
@@ -42685,7 +43014,7 @@ var ClaudeSessionImportIndex = class {
       const source = await readCandidate(selected, signal);
       return source?.candidate.nativeSessionId === nativeSessionId ? source : null;
     } catch (error52) {
-      if (missing(error52))
+      if (isMissingFileError(error52))
         return null;
       throw error52;
     }
@@ -42935,13 +43264,13 @@ function resolveHarnessExecutable(spec, input, dependencies = {}) {
 }
 
 // ../../harness-discovery/dist/installation.js
-import { execFile } from "node:child_process";
+import { execFile as execFile2 } from "node:child_process";
 import { homedir } from "node:os";
 function runInstallationCommand(command, args, environment, timeout = 3e4) {
   const env = withNodeRuntimeOnPath(environment);
   const invocation = /\.[cm]?js$/i.test(command) ? commandInvocation(process.execPath, [command, ...args], env) : commandInvocation(command, args, env);
   return new Promise((resolve2, reject) => {
-    const child = execFile(invocation.command, invocation.arguments, {
+    const child = execFile2(invocation.command, invocation.arguments, {
       env,
       cwd: env.HOME ?? env.USERPROFILE ?? homedir(),
       encoding: "utf8",
@@ -43123,6 +43452,60 @@ async function npmInstallation(command, packages, environment) {
   return null;
 }
 
+// ../../harness-discovery/dist/installer.js
+import { mkdtemp, rm as rm2, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+function createHarnessInstaller(environment, source) {
+  return async () => {
+    if (!["darwin", "linux", "win32"].includes(process.platform))
+      throw new Error("Unsupported installation platform");
+    const env = withNodeRuntimeOnPath(environment);
+    if ("npm" in source) {
+      const npm = resolveHarnessExecutable({
+        id: "npm",
+        command: "npm",
+        installRoots: {
+          posix: [
+            "~/.npm-global/bin",
+            "~/.local/bin",
+            VERSION_MANAGER_ROOTS,
+            "/opt/homebrew/bin",
+            "/usr/local/bin",
+            "/usr/bin"
+          ],
+          windows: [
+            "${APPDATA}/npm",
+            VERSION_MANAGER_ROOTS,
+            "${ProgramFiles}/nodejs",
+            "${LOCALAPPDATA}/Programs/nodejs"
+          ]
+        }
+      }, { environment: env });
+      if (!npm)
+        throw new Error("Install Node.js and npm first");
+      await runInstallationCommand(npm.executable, ["install", "--global", source.npm], {
+        ...env,
+        ...source.allowScripts ? { npm_config_allow_scripts: source.allowScripts } : {}
+      }, 6e5);
+      return;
+    }
+    const windows = process.platform === "win32";
+    const url2 = windows ? source.windows : source.posix;
+    if (new URL(url2).protocol !== "https:")
+      throw new Error("Installer requires HTTPS");
+    const script = await fetchInstallationText(url2);
+    const directory = await mkdtemp(join2(tmpdir(), "codexhost-installer-"));
+    try {
+      const file2 = join2(directory, windows ? "install.ps1" : "install.sh");
+      await writeFile(file2, script, { mode: 384 });
+      await runInstallationCommand(windows ? "powershell.exe" : source.shell ?? "bash", windows ? ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", file2] : [file2], env, 6e5);
+    } finally {
+      await rm2(directory, { recursive: true, force: true });
+    }
+  };
+}
+
 // dist/command.js
 var ClaudeCodeExecutableError = class extends Error {
   code = "CLAUDE_NOT_FOUND";
@@ -43174,7 +43557,7 @@ function resolveClaudeCodeExecutable(input = {}, dependencies = {}) {
 
 // dist/pending-session.js
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { mkdir, open, readFile as readFile3, rename, rm as rm2, stat as stat2, unlink } from "node:fs/promises";
+import { mkdir, open, readFile as readFile3, rename, rm as rm3, stat as stat2, unlink } from "node:fs/promises";
 import os4 from "node:os";
 import path8 from "node:path";
 var reservationSchema = external_exports.strictObject({
@@ -43222,7 +43605,7 @@ var ClaudePendingSessions = class {
         await file2.close();
       }
     } catch (error52) {
-      await rm2(directory, { recursive: true, force: true });
+      await rm3(directory, { recursive: true, force: true });
       throw error52;
     }
     await this.#sync(directory);
@@ -43267,7 +43650,7 @@ var ClaudePendingSessions = class {
       await rename(temporary, path8.join(directory, "session.json"));
       await this.#sync(directory);
     } finally {
-      await rm2(temporary, { force: true });
+      await rm3(temporary, { force: true });
     }
   }
   async #sync(directory) {
@@ -43296,7 +43679,7 @@ var ClaudePendingSessions = class {
     await this.#sync(this.#path(ref, cwd));
   }
   async discard(ref, cwd) {
-    await rm2(this.#path(ref, cwd), { recursive: true, force: true });
+    await rm3(this.#path(ref, cwd), { recursive: true, force: true });
   }
 };
 
@@ -45219,11 +45602,11 @@ function projectClaudeAccountUsage(usage, account) {
 }
 
 // dist/process-fence.js
-import { execFile as execFile2 } from "node:child_process";
+import { execFile as execFile3 } from "node:child_process";
 import path13 from "node:path";
 import { setTimeout as setTimeout2 } from "node:timers/promises";
 import { promisify } from "node:util";
-var executeFile = promisify(execFile2);
+var executeFile = promisify(execFile3);
 function signalGroup(pid, signal) {
   try {
     process.kill(-pid, signal);
@@ -47073,6 +47456,9 @@ var ClaudeHarnessSession = class {
     this.#statePublished = durable;
     this.outputs = this.#channel.outputs;
   }
+  get nativeWriterRef() {
+    return this.#nativeRef;
+  }
   async readSnapshot() {
     if (this.#phase !== "open") {
       return { ok: false, error: invalidState("Claude Code Session is not open") };
@@ -48749,22 +49135,10 @@ var ClaudeCodeAdapter = class {
   harnessId = claudeCodeHarnessId2;
   sessionImport = Object.freeze({
     listCandidates: async () => {
-      const result = await this.#readImport((signal) => this.#importIndex.list(signal));
+      const result = await this.#importScope.read((signal) => this.#importIndex.list(signal));
       return result.ok ? { ok: true, value: result.value.map(({ candidate }) => candidate) } : result;
     },
-    resolveCandidate: async (nativeSessionId) => {
-      const result = await this.#readImport((signal) => this.#importIndex.resolve(nativeSessionId, signal));
-      if (!result.ok)
-        return result;
-      return result.value ? { ok: true, value: result.value } : {
-        ok: false,
-        error: {
-          code: "sessionNotFound",
-          message: "Claude Code Session is no longer importable",
-          retryable: false
-        }
-      };
-    }
+    resolveCandidate: (nativeSessionId) => this.#importScope.resolve((signal) => this.#importIndex.resolve(nativeSessionId, signal))
   });
   subagents = {
     readSnapshot: async (input) => {
@@ -48809,9 +49183,12 @@ var ClaudeCodeAdapter = class {
   #cancelTimeoutMs;
   #closeTimeoutMs;
   #dependencies;
-  #importAbort = new AbortController();
   #importIndex;
-  #importRequests = /* @__PURE__ */ new Set();
+  #importScope = new SessionImportScope({
+    closedMessage: "Claude Code Adapter is closed",
+    unavailableMessage: "Claude Code Session discovery failed; check storage access and duplicate Session identities, then retry after closing native clients",
+    notFoundMessage: "Claude Code Session is no longer importable"
+  });
   #pendingSessions;
   #toolOutputLimit;
   #continuationQuiescenceMs;
@@ -48880,24 +49257,6 @@ var ClaudeCodeAdapter = class {
       readSubagentMessages: ({ cwd, sessionId, nativeSubagentId: nativeSubagentId2 }) => jkt(sessionId, nativeSubagentId2, { dir: cwd })
     };
   }
-  #readImport(operation) {
-    if (this.#importAbort.signal.aborted) {
-      return Promise.resolve({
-        ok: false,
-        error: invalidState("Claude Code Adapter is closed")
-      });
-    }
-    const request = operation(this.#importAbort.signal).then((value) => ({ ok: true, value })).catch(() => ({
-      ok: false,
-      error: {
-        code: "unavailable",
-        message: "Claude Code Session discovery failed; check storage access and duplicate Session identities, then retry after closing native clients",
-        retryable: true
-      }
-    })).finally(() => this.#importRequests.delete(request));
-    this.#importRequests.add(request);
-    return request;
-  }
   async inspect(input = {}) {
     if (this.#closePromise) {
       return {
@@ -49213,10 +49572,9 @@ var ClaudeCodeAdapter = class {
   }
   close() {
     if (!this.#closePromise) {
-      this.#importAbort.abort();
       this.#inspectionCache.clear();
       this.#closePromise = Promise.all([
-        ...this.#importRequests,
+        this.#importScope.close(),
         ...[...this.#inspectors].map((inspector) => inspector.close()),
         ...[...this.#sessions].map((session) => session.close()),
         ...this.#inspectionInFlight.values()
@@ -49281,6 +49639,7 @@ function createClaudeInstallation(environment, command) {
         updateAvailable: newerInstallationVersion(currentVersion, latestVersion),
         canUpdate,
         ...!canUpdate ? {
+          messageCode: blocked ? "claude-policy-restricted" : "original-installer",
           message: blocked ? "Claude updates are restricted by the installation's settings or policy." : "Use the original installer or package manager for this Claude installation."
         } : {}
       };
@@ -49293,7 +49652,7 @@ function createClaudeInstallation(environment, command) {
 
 // dist/user-shell-environment.js
 import path16 from "node:path";
-import { execFile as execFile3 } from "node:child_process";
+import { execFile as execFile4 } from "node:child_process";
 var ENVIRONMENT_MARKER = Buffer.from("\0CODEXHOST_USER_SHELL_ENV_V1\0");
 var ENVIRONMENT_COMMAND = "printf '\\0CODEXHOST_USER_SHELL_ENV_V1\\0'; /usr/bin/env -0";
 var SHELL_ENVIRONMENT_TIMEOUT_MS = 3e3;
@@ -49342,7 +49701,7 @@ async function withUserShellEnvironment(environment, dependencies) {
   if (cached2)
     return mergeMissingEnvironment(environment, cached2);
   const run = dependencies?.run ?? ((command, arguments_, options) => new Promise((resolve2) => {
-    const child = execFile3(command, arguments_, {
+    const child = execFile4(command, arguments_, {
       ...options,
       encoding: "buffer",
       killSignal: "SIGKILL"
@@ -49376,15 +49735,34 @@ async function createHarnessAdapter(context) {
       commandCatalog: claudeCommandCatalog,
       liveCommandCatalog: true,
       environment,
+      isInstalled: () => {
+        try {
+          resolveClaudeCodeExecutable({
+            ...environment[CLAUDE_CODE_COMMAND_ENV] ? { command: environment[CLAUDE_CODE_COMMAND_ENV] } : {},
+            environment
+          });
+          return true;
+        } catch (error52) {
+          return !(error52 instanceof ClaudeCodeExecutableError);
+        }
+      },
       ...context.brokerDescriptorPath ? { descriptorPath: context.brokerDescriptorPath } : {}
     });
   }
   return Object.assign(new ClaudeCodeAdapter({
     ...environment[CLAUDE_CODE_COMMAND_ENV] ? { command: environment[CLAUDE_CODE_COMMAND_ENV] } : {},
     environment
-  }), { installation: createClaudeInstallation(environment, environment[CLAUDE_CODE_COMMAND_ENV]) });
+  }), {
+    installation: createClaudeInstallation(environment, environment[CLAUDE_CODE_COMMAND_ENV]),
+    install: createHarnessInstaller(environment, {
+      posix: "https://claude.ai/install.sh",
+      windows: "https://claude.ai/install.ps1"
+    })
+  });
 }
 async function warmup(adapter) {
+  if (adapter instanceof BrokeredHarnessAdapter)
+    return;
   try {
     await adapter.inspect();
   } catch {