npm - codeharbor - Versions diffs - 0.1.18 → 0.1.20 - Mend

codeharbor 0.1.18 → 0.1.20

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/.env.example +5 -0
package/README.md +19 -0
package/dist/cli.js +335 -56
package/package.json +3 -1
package/scripts/postinstall-restart.cjs +134 -0

package/.env.example CHANGED Viewed

@@ -63,6 +63,11 @@ CLI_COMPAT_PRESERVE_WHITESPACE=true
 CLI_COMPAT_DISABLE_REPLY_CHUNK_SPLIT=false
 CLI_COMPAT_PROGRESS_THROTTLE_MS=300
 CLI_COMPAT_FETCH_MEDIA=true
+# Optional audio transcription for Matrix m.audio attachments.
+CLI_COMPAT_TRANSCRIBE_AUDIO=false
+CLI_COMPAT_AUDIO_TRANSCRIBE_MODEL=gpt-4o-mini-transcribe
+CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS=120000
+CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS=6000
 # Optional JSONL output path for executed prompt recording (for replay benchmarking).
 CLI_COMPAT_RECORD_PATH=

package/README.md CHANGED Viewed

@@ -93,6 +93,8 @@ Notes:
 - Service commands auto-elevate with `sudo` when root privileges are required.
 - `codeharbor service install --with-admin` and `install-linux-easy.sh --enable-admin-service` now install
   `/etc/sudoers.d/codeharbor-restart` for non-root service users, so Admin UI restart actions work out-of-box.
+- `npm install -g codeharbor@latest` now performs best-effort restart for active `codeharbor(.service)` units on Linux
+  so upgrades take effect immediately (set `CODEHARBOR_SKIP_POSTINSTALL_RESTART=1` to disable).
 - If your environment blocks interactive `sudo`, use explicit fallback:
   - `sudo <node-bin> <codeharbor-cli-script> service ...`
@@ -458,6 +460,14 @@ To make IM behavior closer to local `codex` CLI interaction, enable:
   - lower update throttle for near-real-time progress
 - `CLI_COMPAT_FETCH_MEDIA=true|false`
   - download Matrix `mxc://` media (image) to temp file and pass it to codex via `--image`
+- `CLI_COMPAT_TRANSCRIBE_AUDIO=true|false`
+  - download Matrix `m.audio` attachments and transcribe them into prompt context
+- `CLI_COMPAT_AUDIO_TRANSCRIBE_MODEL`
+  - OpenAI transcription model (default `gpt-4o-mini-transcribe`)
+- `CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS`
+  - timeout for each audio transcription request
+- `CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS`
+  - max transcript length appended to prompt for one attachment
 - `CLI_COMPAT_RECORD_PATH=/abs/path/records.jsonl`
   - append executed prompts as JSONL for replay benchmarking
@@ -501,6 +511,15 @@ When image attachments are present and `CLI_COMPAT_FETCH_MEDIA=true`, CodeHarbor
 3. best-effort cleanup temp files after the request
 4. optional prompt record append (`CLI_COMPAT_RECORD_PATH`) for deterministic replay input
+When audio attachments are present and both `CLI_COMPAT_FETCH_MEDIA=true` and `CLI_COMPAT_TRANSCRIBE_AUDIO=true`, CodeHarbor will:
+1. download `m.audio` media to a temp file
+2. call OpenAI audio transcription API and append transcript to `[audio_transcripts]` prompt block
+3. continue request even if transcription fails (warn log + no transcript)
+4. best-effort cleanup temp files after the request
+`OPENAI_API_KEY` is required only when audio transcription is enabled.
 ## Replay Benchmark
 Replay recorded prompts directly against codex CLI to quantify drift and latency:

package/dist/cli.js CHANGED Viewed

@@ -26,7 +26,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // src/cli.ts
 var import_node_child_process7 = require("child_process");
 var import_node_fs11 = __toESM(require("fs"));
-var import_node_path14 = __toESM(require("path"));
+var import_node_path15 = __toESM(require("path"));
 var import_commander = require("commander");
 // src/app.ts
@@ -353,6 +353,19 @@ var ADMIN_CONSOLE_HTML = `<!doctype html>
             <input id="global-cli-throttle" type="number" min="0" />
           </label>
           <label class="checkbox"><input id="global-cli-fetch-media" type="checkbox" /><span>Fetch media attachments</span></label>
+          <label class="checkbox"><input id="global-cli-transcribe-audio" type="checkbox" /><span>Transcribe audio attachments</span></label>
+          <label class="field">
+            <span class="field-label">Audio transcribe model</span>
+            <input id="global-cli-audio-model" type="text" />
+          </label>
+          <label class="field">
+            <span class="field-label">Audio transcribe timeout (ms)</span>
+            <input id="global-cli-audio-timeout" type="number" min="1" />
+          </label>
+          <label class="field">
+            <span class="field-label">Audio transcript max chars</span>
+            <input id="global-cli-audio-max-chars" type="number" min="1" />
+          </label>
           <label class="checkbox"><input id="global-agent-enabled" type="checkbox" /><span>Enable multi-agent workflow</span></label>
           <label class="field">
             <span class="field-label">Workflow auto-repair rounds</span>
@@ -687,6 +700,10 @@ var ADMIN_CONSOLE_HTML = `<!doctype html>
             document.getElementById("global-cli-disable-split").checked = Boolean(cliCompat.disableReplyChunkSplit);
             document.getElementById("global-cli-throttle").value = String(cliCompat.progressThrottleMs || 0);
             document.getElementById("global-cli-fetch-media").checked = Boolean(cliCompat.fetchMedia);
+            document.getElementById("global-cli-transcribe-audio").checked = Boolean(cliCompat.transcribeAudio);
+            document.getElementById("global-cli-audio-model").value = cliCompat.audioTranscribeModel || "gpt-4o-mini-transcribe";
+            document.getElementById("global-cli-audio-timeout").value = String(cliCompat.audioTranscribeTimeoutMs || 120000);
+            document.getElementById("global-cli-audio-max-chars").value = String(cliCompat.audioTranscribeMaxChars || 6000);
             document.getElementById("global-agent-enabled").checked = Boolean(agentWorkflow.enabled);
             document.getElementById("global-agent-repair-rounds").value = String(
               typeof agentWorkflow.autoRepairMaxRounds === "number" ? agentWorkflow.autoRepairMaxRounds : 1
@@ -728,7 +745,11 @@ var ADMIN_CONSOLE_HTML = `<!doctype html>
                 preserveWhitespace: asBool("global-cli-whitespace"),
                 disableReplyChunkSplit: asBool("global-cli-disable-split"),
                 progressThrottleMs: asNumber("global-cli-throttle", 300),
-                fetchMedia: asBool("global-cli-fetch-media")
+                fetchMedia: asBool("global-cli-fetch-media"),
+                transcribeAudio: asBool("global-cli-transcribe-audio"),
+                audioTranscribeModel: asText("global-cli-audio-model") || "gpt-4o-mini-transcribe",
+                audioTranscribeTimeoutMs: asNumber("global-cli-audio-timeout", 120000),
+                audioTranscribeMaxChars: asNumber("global-cli-audio-max-chars", 6000)
               },
               agentWorkflow: {
                 enabled: asBool("global-agent-enabled"),
@@ -1966,6 +1987,44 @@ var AdminServer = class {
         envUpdates.CLI_COMPAT_FETCH_MEDIA = String(value);
         updatedKeys.push("cliCompat.fetchMedia");
       }
+      if ("transcribeAudio" in compat) {
+        const value = normalizeBoolean(compat.transcribeAudio, this.config.cliCompat.transcribeAudio);
+        this.config.cliCompat.transcribeAudio = value;
+        envUpdates.CLI_COMPAT_TRANSCRIBE_AUDIO = String(value);
+        updatedKeys.push("cliCompat.transcribeAudio");
+      }
+      if ("audioTranscribeModel" in compat) {
+        const value = normalizeString(
+          compat.audioTranscribeModel,
+          this.config.cliCompat.audioTranscribeModel,
+          "cliCompat.audioTranscribeModel"
+        );
+        this.config.cliCompat.audioTranscribeModel = value || "gpt-4o-mini-transcribe";
+        envUpdates.CLI_COMPAT_AUDIO_TRANSCRIBE_MODEL = this.config.cliCompat.audioTranscribeModel;
+        updatedKeys.push("cliCompat.audioTranscribeModel");
+      }
+      if ("audioTranscribeTimeoutMs" in compat) {
+        const value = normalizePositiveInt(
+          compat.audioTranscribeTimeoutMs,
+          this.config.cliCompat.audioTranscribeTimeoutMs,
+          1,
+          Number.MAX_SAFE_INTEGER
+        );
+        this.config.cliCompat.audioTranscribeTimeoutMs = value;
+        envUpdates.CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS = String(value);
+        updatedKeys.push("cliCompat.audioTranscribeTimeoutMs");
+      }
+      if ("audioTranscribeMaxChars" in compat) {
+        const value = normalizePositiveInt(
+          compat.audioTranscribeMaxChars,
+          this.config.cliCompat.audioTranscribeMaxChars,
+          1,
+          Number.MAX_SAFE_INTEGER
+        );
+        this.config.cliCompat.audioTranscribeMaxChars = value;
+        envUpdates.CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS = String(value);
+        updatedKeys.push("cliCompat.audioTranscribeMaxChars");
+      }
     }
     if ("agentWorkflow" in body) {
       const workflow = asObject(body.agentWorkflow, "agentWorkflow");
@@ -2621,6 +2680,7 @@ var MatrixChannel = class {
   splitReplies;
   preserveWhitespace;
   fetchMedia;
+  transcribeAudio;
   client;
   handler = null;
   started = false;
@@ -2631,6 +2691,7 @@ var MatrixChannel = class {
     this.splitReplies = !config.cliCompat.disableReplyChunkSplit;
     this.preserveWhitespace = config.cliCompat.preserveWhitespace;
     this.fetchMedia = config.cliCompat.fetchMedia;
+    this.transcribeAudio = config.cliCompat.transcribeAudio;
     this.client = (0, import_matrix_js_sdk.createClient)({
       baseUrl: config.matrixHomeserver,
       accessToken: config.matrixAccessToken,
@@ -2875,7 +2936,7 @@ var MatrixChannel = class {
     }
     const hydrated = await Promise.all(
       attachments.map(async (attachment, index) => {
-        if (attachment.kind !== "image" || !attachment.mxcUrl) {
+        if (!shouldHydrateAttachment(attachment.kind, this.transcribeAudio) || !attachment.mxcUrl) {
           return attachment;
         }
         try {
@@ -3093,6 +3154,15 @@ function parseMxcUrl(mxcUrl) {
   const mediaId = stripped.slice(slashIndex + 1);
   return { serverName, mediaId };
 }
+function shouldHydrateAttachment(kind, transcribeAudio) {
+  if (kind === "image") {
+    return true;
+  }
+  if (kind === "audio") {
+    return transcribeAudio;
+  }
+  return false;
+}
 function sanitizeFilename(value) {
   return value.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 80);
 }
@@ -3110,6 +3180,21 @@ function resolveFileExtension(fileName, mimeType) {
   if (mimeType === "image/webp") {
     return ".webp";
   }
+  if (mimeType === "audio/mpeg") {
+    return ".mp3";
+  }
+  if (mimeType === "audio/mp4" || mimeType === "audio/x-m4a") {
+    return ".m4a";
+  }
+  if (mimeType === "audio/wav" || mimeType === "audio/x-wav") {
+    return ".wav";
+  }
+  if (mimeType === "audio/ogg") {
+    return ".ogg";
+  }
+  if (mimeType === "audio/flac") {
+    return ".flac";
+  }
   return ".bin";
 }
 function buildMatrixRichMessageContent(body, msgtype) {
@@ -3627,17 +3712,100 @@ function stringify(value) {
 // src/orchestrator.ts
 var import_async_mutex = require("async-mutex");
-var import_promises4 = __toESM(require("fs/promises"));
+var import_promises5 = __toESM(require("fs/promises"));
+// src/audio-transcriber.ts
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_path8 = __toESM(require("path"));
+var AudioTranscriber = class {
+  enabled;
+  apiKey;
+  model;
+  timeoutMs;
+  maxChars;
+  constructor(options) {
+    this.enabled = options.enabled;
+    this.apiKey = options.apiKey;
+    this.model = options.model;
+    this.timeoutMs = options.timeoutMs;
+    this.maxChars = options.maxChars;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  async transcribeMany(attachments) {
+    if (!this.enabled || attachments.length === 0) {
+      return [];
+    }
+    if (!this.apiKey) {
+      throw new Error(
+        "Audio transcription is enabled but OPENAI_API_KEY is missing. Set OPENAI_API_KEY or disable CLI_COMPAT_TRANSCRIBE_AUDIO."
+      );
+    }
+    const transcripts = [];
+    for (const attachment of attachments) {
+      const text = await this.transcribeOne(attachment);
+      if (!text) {
+        continue;
+      }
+      transcripts.push({
+        name: attachment.name,
+        text
+      });
+    }
+    return transcripts;
+  }
+  async transcribeOne(attachment) {
+    const buffer = await import_promises3.default.readFile(attachment.localPath);
+    const formData = new FormData();
+    formData.append("model", this.model);
+    formData.append("response_format", "json");
+    formData.append(
+      "file",
+      new Blob([buffer], { type: attachment.mimeType ?? "application/octet-stream" }),
+      import_node_path8.default.basename(attachment.localPath)
+    );
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    timer.unref?.();
+    let response;
+    try {
+      response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: formData,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      const message = typeof payload?.error?.message === "string" ? payload.error.message : `HTTP ${response.status} ${response.statusText}`;
+      throw new Error(`Audio transcription failed for ${attachment.name}: ${message}`);
+    }
+    const text = typeof payload.text === "string" ? payload.text.trim() : "";
+    if (!text) {
+      return "";
+    }
+    if (text.length > this.maxChars) {
+      return `${text.slice(0, this.maxChars)}...`;
+    }
+    return text;
+  }
+};
 // src/compat/cli-compat-recorder.ts
 var import_node_fs6 = __toESM(require("fs"));
-var import_node_path8 = __toESM(require("path"));
+var import_node_path9 = __toESM(require("path"));
 var CliCompatRecorder = class {
   filePath;
   chain = Promise.resolve();
   constructor(filePath) {
-    this.filePath = import_node_path8.default.resolve(filePath);
-    import_node_fs6.default.mkdirSync(import_node_path8.default.dirname(this.filePath), { recursive: true });
+    this.filePath = import_node_path9.default.resolve(filePath);
+    import_node_fs6.default.mkdirSync(import_node_path9.default.dirname(this.filePath), { recursive: true });
   }
   append(entry) {
     const payload = `${JSON.stringify(entry)}
@@ -4122,8 +4290,8 @@ function createIdleWorkflowSnapshot() {
 }
 // src/workflow/autodev.ts
-var import_promises3 = __toESM(require("fs/promises"));
-var import_node_path9 = __toESM(require("path"));
+var import_promises4 = __toESM(require("fs/promises"));
+var import_node_path10 = __toESM(require("path"));
 function parseAutoDevCommand(text) {
   const normalized = text.trim();
   if (!/^\/autodev(?:\s|$)/i.test(normalized)) {
@@ -4143,8 +4311,8 @@ function parseAutoDevCommand(text) {
   };
 }
 async function loadAutoDevContext(workdir) {
-  const requirementsPath = import_node_path9.default.join(workdir, "REQUIREMENTS.md");
-  const taskListPath = import_node_path9.default.join(workdir, "TASK_LIST.md");
+  const requirementsPath = import_node_path10.default.join(workdir, "REQUIREMENTS.md");
+  const taskListPath = import_node_path10.default.join(workdir, "TASK_LIST.md");
   const requirementsContent = await readOptionalFile(requirementsPath);
   const taskListContent = await readOptionalFile(taskListPath);
   return {
@@ -4234,7 +4402,7 @@ function statusToSymbol(status) {
   return "\u{1F6AB}";
 }
 async function updateAutoDevTaskStatus(taskListPath, task, nextStatus) {
-  const content = await import_promises3.default.readFile(taskListPath, "utf8");
+  const content = await import_promises4.default.readFile(taskListPath, "utf8");
   const lines = splitLines(content);
   if (task.lineIndex < 0 || task.lineIndex >= lines.length) {
     throw new Error(`task ${task.id} line index out of range`);
@@ -4244,7 +4412,7 @@ async function updateAutoDevTaskStatus(taskListPath, task, nextStatus) {
     throw new Error(`failed to update task status for ${task.id}`);
   }
   lines[task.lineIndex] = updatedLine;
-  await import_promises3.default.writeFile(taskListPath, lines.join("\n"), "utf8");
+  await import_promises4.default.writeFile(taskListPath, lines.join("\n"), "utf8");
   return {
     ...task,
     status: nextStatus
@@ -4252,7 +4420,7 @@ async function updateAutoDevTaskStatus(taskListPath, task, nextStatus) {
 }
 async function readOptionalFile(filePath) {
   try {
-    return await import_promises3.default.readFile(filePath, "utf8");
+    return await import_promises4.default.readFile(filePath, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return null;
@@ -4483,6 +4651,7 @@ var Orchestrator = class {
   logger;
   sessionLocks = /* @__PURE__ */ new Map();
   runningExecutions = /* @__PURE__ */ new Map();
+  pendingStopRequests = /* @__PURE__ */ new Set();
   lockTtlMs;
   lockPruneIntervalMs;
   progressUpdatesEnabled;
@@ -4499,6 +4668,7 @@ var Orchestrator = class {
   rateLimiter;
   cliCompat;
   cliCompatRecorder;
+  audioTranscriber;
   workflowRunner;
   workflowSnapshots = /* @__PURE__ */ new Map();
   autoDevSnapshots = /* @__PURE__ */ new Map();
@@ -4519,9 +4689,20 @@ var Orchestrator = class {
       disableReplyChunkSplit: false,
       progressThrottleMs: 300,
       fetchMedia: false,
+      transcribeAudio: false,
+      audioTranscribeModel: "gpt-4o-mini-transcribe",
+      audioTranscribeTimeoutMs: 12e4,
+      audioTranscribeMaxChars: 6e3,
       recordPath: null
     };
     this.cliCompatRecorder = this.cliCompat.recordPath ? new CliCompatRecorder(this.cliCompat.recordPath) : null;
+    this.audioTranscriber = options?.audioTranscriber ?? new AudioTranscriber({
+      enabled: this.cliCompat.transcribeAudio,
+      apiKey: process.env.OPENAI_API_KEY?.trim() || null,
+      model: this.cliCompat.audioTranscribeModel,
+      timeoutMs: this.cliCompat.audioTranscribeTimeoutMs,
+      maxChars: this.cliCompat.audioTranscribeMaxChars
+    });
     const defaultProgressInterval = options?.progressMinIntervalMs ?? 2500;
     this.progressMinIntervalMs = this.cliCompat.enabled ? this.cliCompat.progressThrottleMs : defaultProgressInterval;
     this.typingTimeoutMs = options?.typingTimeoutMs ?? 1e4;
@@ -4556,7 +4737,7 @@ var Orchestrator = class {
     this.sessionRuntime = new CodexSessionRuntime(this.executor);
   }
   async handleMessage(message) {
-    const attachmentPaths = collectImagePaths(message);
+    const attachmentPaths = collectLocalAttachmentPaths(message);
     try {
       const receivedAt = Date.now();
       const requestId = message.requestId || message.eventId;
@@ -4691,7 +4872,8 @@ var Orchestrator = class {
         }
         this.stateStore.activateSession(sessionKey, this.sessionActiveWindowMs);
         const previousCodexSessionId = this.stateStore.getCodexSessionId(sessionKey);
-        const executionPrompt = this.buildExecutionPrompt(route.prompt, message);
+        const audioTranscripts = await this.transcribeAudioAttachments(message, requestId, sessionKey);
+        const executionPrompt = this.buildExecutionPrompt(route.prompt, message, audioTranscripts);
         const imagePaths = collectImagePaths(message);
         let lastProgressAt = 0;
         let lastProgressText = "";
@@ -4701,7 +4883,7 @@ var Orchestrator = class {
         let executionDurationMs = 0;
         let sendDurationMs = 0;
         const requestStartedAt = Date.now();
-        let cancelRequested = false;
+        let cancelRequested = this.consumePendingStopRequest(sessionKey);
         this.runningExecutions.set(sessionKey, {
           requestId,
           startedAt: requestStartedAt,
@@ -5208,6 +5390,7 @@ var Orchestrator = class {
     this.sessionRuntime.clearSession(sessionKey);
     const running = this.runningExecutions.get(sessionKey);
     if (running) {
+      this.pendingStopRequests.delete(sessionKey);
       this.sessionRuntime.cancelRunningExecution(sessionKey);
       running.cancel();
       await this.channel.sendNotice(
@@ -5222,11 +5405,32 @@ var Orchestrator = class {
       });
       return;
     }
+    const lockEntry = this.sessionLocks.get(sessionKey);
+    if (lockEntry?.mutex.isLocked()) {
+      this.pendingStopRequests.add(sessionKey);
+      await this.channel.sendNotice(
+        message.conversationId,
+        "[CodeHarbor] \u5DF2\u8BF7\u6C42\u505C\u6B62\u5F53\u524D\u4EFB\u52A1\uFF0C\u5E76\u5DF2\u6E05\u7406\u4F1A\u8BDD\u4E0A\u4E0B\u6587\u3002"
+      );
+      this.logger.info("Stop command queued for pending execution", {
+        requestId,
+        sessionKey
+      });
+      return;
+    }
+    this.pendingStopRequests.delete(sessionKey);
     await this.channel.sendNotice(
       message.conversationId,
       "[CodeHarbor] \u4F1A\u8BDD\u5DF2\u505C\u6B62\u3002\u540E\u7EED\u5728\u7FA4\u804A\u4E2D\u8BF7\u63D0\u53CA/\u56DE\u590D\u6211\uFF0C\u6216\u5728\u79C1\u804A\u76F4\u63A5\u53D1\u9001\u6D88\u606F\u3002"
     );
   }
+  consumePendingStopRequest(sessionKey) {
+    if (!this.pendingStopRequests.has(sessionKey)) {
+      return false;
+    }
+    this.pendingStopRequests.delete(sessionKey);
+    return true;
+  }
   startTypingHeartbeat(conversationId) {
     let stopped = false;
     const refreshIntervalMs = Math.max(1e3, Math.floor(this.typingTimeoutMs / 2));
@@ -5328,8 +5532,41 @@ var Orchestrator = class {
     }
     return this.configService.resolveRoomConfig(conversationId, fallbackPolicy);
   }
-  buildExecutionPrompt(prompt, message) {
-    if (message.attachments.length === 0) {
+  async transcribeAudioAttachments(message, requestId, sessionKey) {
+    if (!this.audioTranscriber.isEnabled()) {
+      return [];
+    }
+    const audioAttachments = message.attachments.filter((attachment) => attachment.kind === "audio" && Boolean(attachment.localPath)).map((attachment) => ({
+      name: attachment.name,
+      mimeType: attachment.mimeType,
+      localPath: attachment.localPath
+    }));
+    if (audioAttachments.length === 0) {
+      return [];
+    }
+    try {
+      const transcripts = await this.audioTranscriber.transcribeMany(audioAttachments);
+      if (transcripts.length > 0) {
+        this.logger.info("Audio transcription completed", {
+          requestId,
+          sessionKey,
+          attachmentCount: audioAttachments.length,
+          transcriptCount: transcripts.length
+        });
+      }
+      return transcripts;
+    } catch (error) {
+      this.logger.warn("Audio transcription failed, continuing without transcripts", {
+        requestId,
+        sessionKey,
+        attachmentCount: audioAttachments.length,
+        error: formatError3(error)
+      });
+      return [];
+    }
+  }
+  buildExecutionPrompt(prompt, message, audioTranscripts) {
+    if (message.attachments.length === 0 && audioTranscripts.length === 0) {
       return prompt;
     }
     const attachmentSummary = message.attachments.map((attachment) => {
@@ -5340,11 +5577,19 @@ var Orchestrator = class {
       return `- kind=${attachment.kind} name=${attachment.name} mime=${mime} size=${size} source=${source} local=${local}`;
     }).join("\n");
     const promptBody = prompt.trim() ? prompt : "(no text body)";
-    return `${promptBody}
-[attachments]
+    const sections = [promptBody];
+    if (attachmentSummary) {
+      sections.push(`[attachments]
 ${attachmentSummary}
-[/attachments]`;
+[/attachments]`);
+    }
+    if (audioTranscripts.length > 0) {
+      const transcriptSummary = audioTranscripts.map((transcript) => `- name=${transcript.name} text=${transcript.text.replace(/\s+/g, " ").trim()}`).join("\n");
+      sections.push(`[audio_transcripts]
+${transcriptSummary}
+[/audio_transcripts]`);
+    }
+    return sections.join("\n\n");
   }
   async recordCliCompatPrompt(entry) {
     if (!this.cliCompatRecorder) {
@@ -5489,11 +5734,21 @@ function collectImagePaths(message) {
   }
   return [...seen];
 }
-async function cleanupAttachmentFiles(imagePaths) {
+function collectLocalAttachmentPaths(message) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const attachment of message.attachments) {
+    if (!attachment.localPath) {
+      continue;
+    }
+    seen.add(attachment.localPath);
+  }
+  return [...seen];
+}
+async function cleanupAttachmentFiles(attachmentPaths) {
   await Promise.all(
-    imagePaths.map(async (imagePath) => {
+    attachmentPaths.map(async (attachmentPath) => {
       try {
-        await import_promises4.default.unlink(imagePath);
+        await import_promises5.default.unlink(attachmentPath);
       } catch {
       }
     })
@@ -5610,7 +5865,7 @@ ${result.review}
 // src/store/state-store.ts
 var import_node_fs7 = __toESM(require("fs"));
-var import_node_path10 = __toESM(require("path"));
+var import_node_path11 = __toESM(require("path"));
 var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
 var PRUNE_INTERVAL_MS = 5 * 60 * 1e3;
 var SQLITE_MODULE_ID = `node:${"sqlite"}`;
@@ -5636,7 +5891,7 @@ var StateStore = class {
     this.maxProcessedEventsPerSession = maxProcessedEventsPerSession;
     this.maxSessionAgeMs = maxSessionAgeDays * ONE_DAY_MS;
     this.maxSessions = maxSessions;
-    import_node_fs7.default.mkdirSync(import_node_path10.default.dirname(this.dbPath), { recursive: true });
+    import_node_fs7.default.mkdirSync(import_node_path11.default.dirname(this.dbPath), { recursive: true });
     this.db = new DatabaseSync(this.dbPath);
     this.initializeSchema();
     this.importLegacyStateIfNeeded();
@@ -6159,7 +6414,7 @@ function isNonLoopbackHost(host) {
 // src/config.ts
 var import_node_fs8 = __toESM(require("fs"));
-var import_node_path11 = __toESM(require("path"));
+var import_node_path12 = __toESM(require("path"));
 var import_dotenv2 = __toESM(require("dotenv"));
 var import_zod = require("zod");
 var configSchema = import_zod.z.object({
@@ -6206,6 +6461,10 @@ var configSchema = import_zod.z.object({
   CLI_COMPAT_DISABLE_REPLY_CHUNK_SPLIT: import_zod.z.string().default("false").transform((v) => v.toLowerCase() === "true"),
   CLI_COMPAT_PROGRESS_THROTTLE_MS: import_zod.z.string().default("300").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().nonnegative()),
   CLI_COMPAT_FETCH_MEDIA: import_zod.z.string().default("true").transform((v) => v.toLowerCase() === "true"),
+  CLI_COMPAT_TRANSCRIBE_AUDIO: import_zod.z.string().default("false").transform((v) => v.toLowerCase() === "true"),
+  CLI_COMPAT_AUDIO_TRANSCRIBE_MODEL: import_zod.z.string().default("gpt-4o-mini-transcribe"),
+  CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS: import_zod.z.string().default("120000").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
+  CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS: import_zod.z.string().default("6000").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
   CLI_COMPAT_RECORD_PATH: import_zod.z.string().default(""),
   DOCTOR_HTTP_TIMEOUT_MS: import_zod.z.string().default("10000").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
   ADMIN_BIND_HOST: import_zod.z.string().default("127.0.0.1"),
@@ -6222,7 +6481,7 @@ var configSchema = import_zod.z.object({
   matrixCommandPrefix: v.MATRIX_COMMAND_PREFIX,
   codexBin: v.CODEX_BIN,
   codexModel: v.CODEX_MODEL?.trim() || null,
-  codexWorkdir: import_node_path11.default.resolve(v.CODEX_WORKDIR),
+  codexWorkdir: import_node_path12.default.resolve(v.CODEX_WORKDIR),
   codexDangerousBypass: v.CODEX_DANGEROUS_BYPASS,
   codexExecTimeoutMs: v.CODEX_EXEC_TIMEOUT_MS,
   codexSandboxMode: v.CODEX_SANDBOX_MODE?.trim() || null,
@@ -6233,8 +6492,8 @@ var configSchema = import_zod.z.object({
     enabled: v.AGENT_WORKFLOW_ENABLED,
     autoRepairMaxRounds: v.AGENT_WORKFLOW_AUTO_REPAIR_MAX_ROUNDS
   },
-  stateDbPath: import_node_path11.default.resolve(v.STATE_DB_PATH),
-  legacyStateJsonPath: v.STATE_PATH.trim() ? import_node_path11.default.resolve(v.STATE_PATH) : null,
+  stateDbPath: import_node_path12.default.resolve(v.STATE_DB_PATH),
+  legacyStateJsonPath: v.STATE_PATH.trim() ? import_node_path12.default.resolve(v.STATE_PATH) : null,
   maxProcessedEventsPerSession: v.MAX_PROCESSED_EVENTS_PER_SESSION,
   maxSessionAgeDays: v.MAX_SESSION_AGE_DAYS,
   maxSessions: v.MAX_SESSIONS,
@@ -6266,7 +6525,11 @@ var configSchema = import_zod.z.object({
     disableReplyChunkSplit: v.CLI_COMPAT_DISABLE_REPLY_CHUNK_SPLIT,
     progressThrottleMs: v.CLI_COMPAT_PROGRESS_THROTTLE_MS,
     fetchMedia: v.CLI_COMPAT_FETCH_MEDIA,
-    recordPath: v.CLI_COMPAT_RECORD_PATH.trim() ? import_node_path11.default.resolve(v.CLI_COMPAT_RECORD_PATH) : null
+    transcribeAudio: v.CLI_COMPAT_TRANSCRIBE_AUDIO,
+    audioTranscribeModel: v.CLI_COMPAT_AUDIO_TRANSCRIBE_MODEL.trim() || "gpt-4o-mini-transcribe",
+    audioTranscribeTimeoutMs: v.CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS,
+    audioTranscribeMaxChars: v.CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS,
+    recordPath: v.CLI_COMPAT_RECORD_PATH.trim() ? import_node_path12.default.resolve(v.CLI_COMPAT_RECORD_PATH) : null
   },
   doctorHttpTimeoutMs: v.DOCTOR_HTTP_TIMEOUT_MS,
   adminBindHost: v.ADMIN_BIND_HOST.trim() || "127.0.0.1",
@@ -6277,7 +6540,7 @@ var configSchema = import_zod.z.object({
   adminAllowedOrigins: parseCsvList(v.ADMIN_ALLOWED_ORIGINS),
   logLevel: v.LOG_LEVEL
 }));
-function loadEnvFromFile(filePath = import_node_path11.default.resolve(process.cwd(), ".env"), env = process.env) {
+function loadEnvFromFile(filePath = import_node_path12.default.resolve(process.cwd(), ".env"), env = process.env) {
   import_dotenv2.default.config({
     path: filePath,
     processEnv: env,
@@ -6290,9 +6553,9 @@ function loadConfig(env = process.env) {
     const message = parsed.error.issues.map((issue) => `${issue.path.join(".") || "config"}: ${issue.message}`).join("; ");
     throw new Error(`Invalid configuration: ${message}`);
   }
-  import_node_fs8.default.mkdirSync(import_node_path11.default.dirname(parsed.data.stateDbPath), { recursive: true });
+  import_node_fs8.default.mkdirSync(import_node_path12.default.dirname(parsed.data.stateDbPath), { recursive: true });
   if (parsed.data.legacyStateJsonPath) {
-    import_node_fs8.default.mkdirSync(import_node_path11.default.dirname(parsed.data.legacyStateJsonPath), { recursive: true });
+    import_node_fs8.default.mkdirSync(import_node_path12.default.dirname(parsed.data.legacyStateJsonPath), { recursive: true });
   }
   return parsed.data;
 }
@@ -6460,7 +6723,7 @@ function parseAdminTokens(raw) {
 // src/config-snapshot.ts
 var import_node_fs9 = __toESM(require("fs"));
-var import_node_path12 = __toESM(require("path"));
+var import_node_path13 = __toESM(require("path"));
 var import_zod2 = require("zod");
 var CONFIG_SNAPSHOT_SCHEMA_VERSION = 1;
 var CONFIG_SNAPSHOT_ENV_KEYS = [
@@ -6507,6 +6770,10 @@ var CONFIG_SNAPSHOT_ENV_KEYS = [
   "CLI_COMPAT_DISABLE_REPLY_CHUNK_SPLIT",
   "CLI_COMPAT_PROGRESS_THROTTLE_MS",
   "CLI_COMPAT_FETCH_MEDIA",
+  "CLI_COMPAT_TRANSCRIBE_AUDIO",
+  "CLI_COMPAT_AUDIO_TRANSCRIBE_MODEL",
+  "CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS",
+  "CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS",
   "CLI_COMPAT_RECORD_PATH",
   "DOCTOR_HTTP_TIMEOUT_MS",
   "ADMIN_BIND_HOST",
@@ -6573,6 +6840,14 @@ var envSnapshotSchema = import_zod2.z.object({
   CLI_COMPAT_DISABLE_REPLY_CHUNK_SPLIT: booleanStringSchema("CLI_COMPAT_DISABLE_REPLY_CHUNK_SPLIT"),
   CLI_COMPAT_PROGRESS_THROTTLE_MS: integerStringSchema("CLI_COMPAT_PROGRESS_THROTTLE_MS", 0),
   CLI_COMPAT_FETCH_MEDIA: booleanStringSchema("CLI_COMPAT_FETCH_MEDIA"),
+  CLI_COMPAT_TRANSCRIBE_AUDIO: booleanStringSchema("CLI_COMPAT_TRANSCRIBE_AUDIO").default("false"),
+  CLI_COMPAT_AUDIO_TRANSCRIBE_MODEL: import_zod2.z.string().default("gpt-4o-mini-transcribe"),
+  CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS: integerStringSchema("CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS", 1).default(
+    "120000"
+  ),
+  CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS: integerStringSchema("CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS", 1).default(
+    "6000"
+  ),
   CLI_COMPAT_RECORD_PATH: import_zod2.z.string(),
   DOCTOR_HTTP_TIMEOUT_MS: integerStringSchema("DOCTOR_HTTP_TIMEOUT_MS", 1),
   ADMIN_BIND_HOST: import_zod2.z.string(),
@@ -6651,8 +6926,8 @@ async function runConfigExportCommand(options = {}) {
     const snapshot = buildConfigSnapshot(config, stateStore.listRoomSettings(), options.now ?? /* @__PURE__ */ new Date());
     const serialized = serializeConfigSnapshot(snapshot);
     if (options.outputPath) {
-      const targetPath = import_node_path12.default.resolve(cwd, options.outputPath);
-      import_node_fs9.default.mkdirSync(import_node_path12.default.dirname(targetPath), { recursive: true });
+      const targetPath = import_node_path13.default.resolve(cwd, options.outputPath);
+      import_node_fs9.default.mkdirSync(import_node_path13.default.dirname(targetPath), { recursive: true });
       import_node_fs9.default.writeFileSync(targetPath, serialized, "utf8");
       output.write(`Exported config snapshot to ${targetPath}
 `);
@@ -6667,7 +6942,7 @@ async function runConfigImportCommand(options) {
   const cwd = options.cwd ?? process.cwd();
   const output = options.output ?? process.stdout;
   const actor = options.actor?.trim() || "cli:config-import";
-  const sourcePath = import_node_path12.default.resolve(cwd, options.filePath);
+  const sourcePath = import_node_path13.default.resolve(cwd, options.filePath);
   if (!import_node_fs9.default.existsSync(sourcePath)) {
     throw new Error(`Config snapshot file not found: ${sourcePath}`);
   }
@@ -6698,7 +6973,7 @@ async function runConfigImportCommand(options) {
     synchronizeRoomSettings(stateStore, normalizedRooms);
     stateStore.appendConfigRevision(
       actor,
-      `import config snapshot from ${import_node_path12.default.basename(sourcePath)}`,
+      `import config snapshot from ${import_node_path13.default.basename(sourcePath)}`,
       JSON.stringify({
         type: "config_snapshot_import",
         sourcePath,
@@ -6712,7 +6987,7 @@ async function runConfigImportCommand(options) {
   output.write(
     [
       `Imported config snapshot from ${sourcePath}`,
-      `- updated .env in ${import_node_path12.default.resolve(cwd, ".env")}`,
+      `- updated .env in ${import_node_path13.default.resolve(cwd, ".env")}`,
       `- synchronized room settings: ${normalizedRooms.length}`,
       "- restart required: yes (global env settings are restart-scoped)"
     ].join("\n") + "\n"
@@ -6763,6 +7038,10 @@ function buildSnapshotEnv(config) {
     CLI_COMPAT_DISABLE_REPLY_CHUNK_SPLIT: String(config.cliCompat.disableReplyChunkSplit),
     CLI_COMPAT_PROGRESS_THROTTLE_MS: String(config.cliCompat.progressThrottleMs),
     CLI_COMPAT_FETCH_MEDIA: String(config.cliCompat.fetchMedia),
+    CLI_COMPAT_TRANSCRIBE_AUDIO: String(config.cliCompat.transcribeAudio),
+    CLI_COMPAT_AUDIO_TRANSCRIBE_MODEL: config.cliCompat.audioTranscribeModel,
+    CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS: String(config.cliCompat.audioTranscribeTimeoutMs),
+    CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS: String(config.cliCompat.audioTranscribeMaxChars),
     CLI_COMPAT_RECORD_PATH: config.cliCompat.recordPath ?? "",
     DOCTOR_HTTP_TIMEOUT_MS: String(config.doctorHttpTimeoutMs),
     ADMIN_BIND_HOST: config.adminBindHost,
@@ -6788,10 +7067,10 @@ function parseJsonFile(filePath) {
 function normalizeSnapshotEnv(env, cwd) {
   return {
     ...env,
-    CODEX_WORKDIR: import_node_path12.default.resolve(cwd, env.CODEX_WORKDIR),
-    STATE_DB_PATH: import_node_path12.default.resolve(cwd, env.STATE_DB_PATH),
-    STATE_PATH: env.STATE_PATH.trim() ? import_node_path12.default.resolve(cwd, env.STATE_PATH) : "",
-    CLI_COMPAT_RECORD_PATH: env.CLI_COMPAT_RECORD_PATH.trim() ? import_node_path12.default.resolve(cwd, env.CLI_COMPAT_RECORD_PATH) : ""
+    CODEX_WORKDIR: import_node_path13.default.resolve(cwd, env.CODEX_WORKDIR),
+    STATE_DB_PATH: import_node_path13.default.resolve(cwd, env.STATE_DB_PATH),
+    STATE_PATH: env.STATE_PATH.trim() ? import_node_path13.default.resolve(cwd, env.STATE_PATH) : "",
+    CLI_COMPAT_RECORD_PATH: env.CLI_COMPAT_RECORD_PATH.trim() ? import_node_path13.default.resolve(cwd, env.CLI_COMPAT_RECORD_PATH) : ""
   };
 }
 function normalizeSnapshotRooms(rooms, cwd) {
@@ -6806,7 +7085,7 @@ function normalizeSnapshotRooms(rooms, cwd) {
       throw new Error(`Duplicate roomId in snapshot: ${roomId}`);
     }
     seen.add(roomId);
-    const workdir = import_node_path12.default.resolve(cwd, room.workdir);
+    const workdir = import_node_path13.default.resolve(cwd, room.workdir);
     ensureDirectory2(workdir, `room workdir (${roomId})`);
     normalized.push({
       roomId,
@@ -6833,8 +7112,8 @@ function synchronizeRoomSettings(stateStore, rooms) {
   }
 }
 function persistEnvSnapshot(cwd, env) {
-  const envPath = import_node_path12.default.resolve(cwd, ".env");
-  const examplePath = import_node_path12.default.resolve(cwd, ".env.example");
+  const envPath = import_node_path13.default.resolve(cwd, ".env");
+  const examplePath = import_node_path13.default.resolve(cwd, ".env.example");
   const template = import_node_fs9.default.existsSync(envPath) ? import_node_fs9.default.readFileSync(envPath, "utf8") : import_node_fs9.default.existsSync(examplePath) ? import_node_fs9.default.readFileSync(examplePath, "utf8") : "";
   const overrides = {};
   for (const key of CONFIG_SNAPSHOT_ENV_KEYS) {
@@ -6919,7 +7198,7 @@ function jsonArrayStringSchema(key, allowEmpty) {
 // src/preflight.ts
 var import_node_child_process6 = require("child_process");
 var import_node_fs10 = __toESM(require("fs"));
-var import_node_path13 = __toESM(require("path"));
+var import_node_path14 = __toESM(require("path"));
 var import_node_util4 = require("util");
 var execFileAsync4 = (0, import_node_util4.promisify)(import_node_child_process6.execFile);
 var REQUIRED_ENV_KEYS = ["MATRIX_HOMESERVER", "MATRIX_USER_ID", "MATRIX_ACCESS_TOKEN"];
@@ -6930,7 +7209,7 @@ async function runStartupPreflight(options = {}) {
   const fileExists = options.fileExists ?? import_node_fs10.default.existsSync;
   const isDirectory = options.isDirectory ?? defaultIsDirectory;
   const issues = [];
-  const envPath = import_node_path13.default.resolve(cwd, ".env");
+  const envPath = import_node_path14.default.resolve(cwd, ".env");
   let resolvedCodexBin = null;
   let usedCodexFallback = false;
   if (!fileExists(envPath)) {
@@ -7007,7 +7286,7 @@ async function runStartupPreflight(options = {}) {
     }
   }
   const configuredWorkdir = readEnv(env, "CODEX_WORKDIR");
-  const workdir = import_node_path13.default.resolve(cwd, configuredWorkdir || cwd);
+  const workdir = import_node_path14.default.resolve(cwd, configuredWorkdir || cwd);
   if (!fileExists(workdir) || !isDirectory(workdir)) {
     issues.push({
       level: "error",
@@ -7276,7 +7555,7 @@ function ensureRuntimeHomeOrExit() {
 `);
     process.exit(1);
   }
-  loadEnvFromFile(import_node_path14.default.resolve(home, ".env"));
+  loadEnvFromFile(import_node_path15.default.resolve(home, ".env"));
   runtimeHome = home;
   return runtimeHome;
 }
@@ -7291,7 +7570,7 @@ function parsePortOption(raw, fallback) {
 }
 function resolveCliVersion() {
   try {
-    const packagePath = import_node_path14.default.resolve(__dirname, "..", "package.json");
+    const packagePath = import_node_path15.default.resolve(__dirname, "..", "package.json");
     const content = import_node_fs11.default.readFileSync(packagePath, "utf8");
     const parsed = JSON.parse(content);
     return typeof parsed.version === "string" && parsed.version.trim() ? parsed.version : "0.0.0";
@@ -7302,9 +7581,9 @@ function resolveCliVersion() {
 function resolveCliScriptPath() {
   const argvPath = process.argv[1];
   if (argvPath && argvPath.trim()) {
-    return import_node_path14.default.resolve(argvPath);
+    return import_node_path15.default.resolve(argvPath);
   }
-  return import_node_path14.default.resolve(__dirname, "cli.js");
+  return import_node_path15.default.resolve(__dirname, "cli.js");
 }
 function maybeReexecServiceCommandWithSudo() {
   if (typeof process.getuid !== "function" || process.getuid() === 0) {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "codeharbor",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Instant-messaging bridge for Codex CLI sessions",
   "license": "MIT",
   "main": "dist/cli.js",
@@ -17,6 +17,7 @@
   },
   "files": [
     "dist",
+    "scripts/postinstall-restart.cjs",
     ".env.example",
     "README.md",
     "LICENSE"
@@ -55,6 +56,7 @@
     "e2e:install": "playwright install chromium",
     "test:watch": "vitest test",
     "test:legacy": "bash ./scripts/run-legacy-tests.sh",
+    "postinstall": "node ./scripts/postinstall-restart.cjs",
     "prepare": "npm run build",
     "prepublishOnly": "npm run changelog:check && npm run typecheck && npm run lint && npm run test:coverage && npm run build",
     "changelog:check": "bash ./scripts/check-changelog.sh",

package/scripts/postinstall-restart.cjs ADDED Viewed

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+"use strict";
+const { execFileSync } = require("node:child_process");
+const LOG_PREFIX = "[codeharbor postinstall]";
+const MAIN_SERVICE = "codeharbor.service";
+const ADMIN_SERVICE = "codeharbor-admin.service";
+function isTruthy(value) {
+  if (!value) {
+    return false;
+  }
+  const normalized = String(value).trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+function isGlobalInstall() {
+  return isTruthy(process.env.npm_config_global);
+}
+function hasRootPrivileges() {
+  if (typeof process.getuid !== "function") {
+    return true;
+  }
+  return process.getuid() === 0;
+}
+function commandExists(file) {
+  try {
+    execFileSync(file, ["--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runCommand(file, args, options) {
+  return execFileSync(file, args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    ...options,
+  });
+}
+function listUnitFiles(unitName) {
+  try {
+    return runCommand("systemctl", ["list-unit-files", unitName, "--no-legend", "--no-pager"]);
+  } catch {
+    return "";
+  }
+}
+function isUnitInstalled(unitName) {
+  const output = listUnitFiles(unitName).trim();
+  if (!output) {
+    return false;
+  }
+  return output.split(/\r?\n/).some((line) => line.trim().startsWith(unitName));
+}
+function isUnitActive(unitName) {
+  try {
+    const output = runCommand("systemctl", ["is-active", unitName], {}).trim();
+    return output === "active";
+  } catch {
+    return false;
+  }
+}
+function restartUnit(unitName) {
+  if (hasRootPrivileges()) {
+    runCommand("systemctl", ["restart", unitName], {});
+    return;
+  }
+  runCommand("sudo", ["-n", "systemctl", "restart", unitName], {});
+}
+function main() {
+  if (isTruthy(process.env.CODEHARBOR_SKIP_POSTINSTALL_RESTART)) {
+    console.log(`${LOG_PREFIX} skip restart: CODEHARBOR_SKIP_POSTINSTALL_RESTART is set.`);
+    return;
+  }
+  const forceRestart = isTruthy(process.env.CODEHARBOR_FORCE_POSTINSTALL_RESTART);
+  if (!forceRestart && !isGlobalInstall()) {
+    return;
+  }
+  if (process.platform !== "linux") {
+    return;
+  }
+  if (!commandExists("systemctl")) {
+    return;
+  }
+  const candidates = [MAIN_SERVICE, ADMIN_SERVICE].filter((unitName) => isUnitInstalled(unitName));
+  const activeUnits = candidates.filter((unitName) => isUnitActive(unitName));
+  if (activeUnits.length === 0) {
+    return;
+  }
+  const restarted = [];
+  const failed = [];
+  for (const unitName of activeUnits) {
+    try {
+      restartUnit(unitName);
+      restarted.push(unitName);
+    } catch (error) {
+      failed.push({ unitName, error });
+    }
+  }
+  if (restarted.length > 0) {
+    console.log(`${LOG_PREFIX} restarted: ${restarted.join(", ")}`);
+  }
+  if (failed.length > 0) {
+    for (const failure of failed) {
+      const message = failure.error instanceof Error ? failure.error.message : String(failure.error);
+      console.warn(`${LOG_PREFIX} failed to restart ${failure.unitName}: ${message}`);
+    }
+    console.warn(`${LOG_PREFIX} run "codeharbor service restart --with-admin" manually if needed.`);
+  }
+}
+try {
+  main();
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(`${LOG_PREFIX} unexpected error: ${message}`);
+}