@opencode-cockpit/daemon 0.2.0 → 0.2.1

package/dist/modules/shell/methods.js

@@ -4,6 +4,9 @@ import { waitFor } from "./wait.js";
 import { PRESETS, presetByName, presetForCommand } from "./watch/presets.js";
 import { compileRule, Watcher } from "./watch/watcher.js";
 
+/** Preset name for a watcher with no patterns: it only reports the process dying. */
+const EXIT_ONLY = "exit";
+
 /**
  * The `shell.*` methods, kept apart from the module's lifecycle and bookkeeping so each file has
  * one job: this one maps protocol calls onto the module, `module.ts` owns the shells.
@@ -71,18 +74,28 @@ export function shellMethods(module) {
       id,
       signal,
       graceMs
+    }, {
+      peer
     }) => {
       const shell = module.require(id);
-      await shell.stop(signal, graceMs);
+      await shell.stop(signal, graceMs, {
+        reason: "request",
+        by: peer.name
+      });
       await shell.exited;
       return shell.info();
     },
     restart: async ({
       id
+    }, {
+      peer
     }) => {
       const shell = module.require(id);
       if (shell.running) {
-        await shell.stop("SIGTERM", 3000);
+        await shell.stop("SIGTERM", 3000, {
+          reason: "request",
+          by: peer.name
+        });
         await shell.exited;
       }
       module.spawn(shell);
@@ -90,10 +103,15 @@ export function shellMethods(module) {
     },
     remove: async ({
       id
+    }, {
+      peer
     }) => {
       const shell = module.require(id);
       if (shell.running) {
-        await shell.stop("SIGTERM", 3000);
+        await shell.stop("SIGTERM", 3000, {
+          reason: "request",
+          by: peer.name
+        });
         await shell.exited;
       }
       module.forget(shell);
@@ -140,14 +158,14 @@ export function shellMethods(module) {
     }) => {
       const shell = module.require(id);
       const command = [shell.spec.command, ...shell.spec.args].join(" ");
-      const chosen = rule ? undefined : preset && preset !== "auto" ? presetByName(preset) ?? invalidParams(`unknown preset "${preset}"; call shell.presets for the list`) : presetForCommand(command);
+      const named = preset && preset !== "auto" && preset !== EXIT_ONLY;
+      const chosen = rule ? undefined : named ? presetByName(preset) ?? invalidParams(`no watch preset named "${preset}". Call shell.presets for the list, or pass your own rule (done/fail/ok patterns).`) : preset === EXIT_ONLY ? undefined : presetForCommand(command);
       if (chosen instanceof Error) throw chosen;
-      const watchRule = rule ?? chosen?.rule;
-      if (!watchRule) {
-        throw invalidParams(`no watch preset matches "${command.slice(0, 80)}"; pass a rule (done/fail/ok patterns) or a preset name`);
-      }
+      // No pattern fits a command like `sleep 300`, and that is still worth watching: an empty rule
+      // reports nothing until the process dies, which is exactly crash detection.
+      const watchRule = rule ?? chosen?.rule ?? {};
       try {
-        shell.watcher = new Watcher(compileRule(watchRule), chosen?.name);
+        shell.watcher = new Watcher(compileRule(watchRule), chosen?.name ?? (rule ? undefined : EXIT_ONLY));
       } catch (err) {
         throw invalidParams(`invalid watch pattern: ${err instanceof Error ? err.message : String(err)}`);
       }

package/dist/modules/shell/module.js

@@ -43,7 +43,9 @@ export class ShellModule {
   }
   async stop() {
     for (const id of [...this.idleTimers.keys()]) this.clearIdle(id);
-    await Promise.all([...this.shells.values()].map(s => s.stop("SIGTERM", 2000).catch(() => {})));
+    await Promise.all([...this.shells.values()].map(s => s.stop("SIGTERM", 2000, {
+      reason: "shutdown"
+    }).catch(() => {})));
     for (const detach of this.attachments.values()) detach();
     for (const shell of this.shells.values()) shell.dispose();
     this.attachments.clear();

package/dist/modules/shell/shell.js

@@ -64,6 +64,8 @@ export class Shell {
     }
     this.runStartLine = this.log.lastLine + 1;
     this.stoppedBecause = undefined;
+    this.stopReason = undefined;
+    this.stoppedBy = undefined;
     if (this.spec.logFile && !this.logWriter) {
       mkdirSync(dirname(this.spec.logFile), {
         recursive: true
@@ -111,6 +113,7 @@ export class Shell {
     if (this.spec.timeoutMs) {
       this.timeout = setTimeout(() => {
         this.stoppedBecause = `reached its ${Math.round((this.spec.timeoutMs ?? 0) / 1000)}s time limit`;
+        this.stopReason = "timeout";
         void this.stop("SIGTERM", 3000);
       }, this.spec.timeoutMs);
     }
@@ -119,6 +122,7 @@ export class Shell {
       this.idleTimer = setInterval(() => {
         if (!this.running || Date.now() - this.lastOutputAt < idleMs) return;
         this.stoppedBecause = `produced no output for ${Math.round(idleMs / 1000)}s`;
+        this.stopReason = "idle";
         void this.stop("SIGTERM", 3000);
       }, Math.max(500, Math.floor(idleMs / 4)));
     }
@@ -134,11 +138,18 @@ export class Shell {
     if (this.running) this.pty?.resize(cols, rows);
   }
 
-  /** Signal the group, escalate to SIGKILL after `graceMs`, and reap stragglers. */
-  async stop(signal = "SIGTERM", graceMs = 3000) {
+  /**
+   * Signal the group, escalate to SIGKILL after `graceMs`, and reap stragglers. `cause` says who
+   * asked, so an exit can be reported as a stop rather than as an unexplained kill.
+   */
+  async stop(signal = "SIGTERM", graceMs = 3000, cause = {
+    reason: "request"
+  }) {
     const pty = this.pty;
     if (!pty || !this.running) return;
     this.stopRequested = true;
+    this.stopReason ??= cause.reason;
+    this.stoppedBy ??= cause.by;
     pty.signal(signal);
     const exited = await Promise.race([this.exitPromise.then(() => true), Bun.sleep(graceMs).then(() => false)]);
     if (!exited) {
@@ -174,6 +185,8 @@ export class Shell {
     if (this.exit?.signal) info.signal = this.exit.signal;
     if (this.error) info.error = this.error;
     if (this.summary) info.summary = this.summary;
+    if (this.stopReason) info.stopReason = this.stopReason;
+    if (this.stoppedBy) info.stoppedBy = this.stoppedBy;
     if (this.spec.logFile) info.logFile = this.spec.logFile;
     if (this.watcher) info.watch = this.watcher.state();
     if (this.endedAt) info.endedAt = this.endedAt;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-cockpit/daemon",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "cockpitd: the process host behind opencode-cockpit (PTY shells, clean logs, wait conditions)",
   "type": "module",
   "license": "MIT",
@@ -41,7 +41,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@opencode-cockpit/protocol": "0.2.0",
+    "@opencode-cockpit/protocol": "0.2.1",
     "@xterm/headless": "6.0.0"
   },
   "engines": {

package/types/modules/shell/shell.d.ts

@@ -1,4 +1,4 @@
-import type { LogLine, Owner, ScreenResult, ShellInfo, ShellStatus } from "@opencode-cockpit/protocol/shell";
+import type { LogLine, Owner, ScreenResult, ShellInfo, ShellStatus, StopReason } from "@opencode-cockpit/protocol/shell";
 import { LineLog } from "./output/line-log.ts";
 import { RawRing } from "./output/raw-ring.ts";
 import { Screen } from "./output/screen.ts";
@@ -59,6 +59,8 @@ export declare class Shell {
     private error;
     /** Why the daemon stopped it, when it was not a user or agent request. */
     private stoppedBecause;
+    private stopReason;
+    private stoppedBy;
     private summary;
     private stopRequested;
     private timeout;
@@ -76,8 +78,14 @@ export declare class Shell {
     start(): void;
     write(data: string): number;
     resize(cols: number, rows: number): void;
-    /** Signal the group, escalate to SIGKILL after `graceMs`, and reap stragglers. */
-    stop(signal?: NodeJS.Signals, graceMs?: number): Promise<void>;
+    /**
+     * Signal the group, escalate to SIGKILL after `graceMs`, and reap stragglers. `cause` says who
+     * asked, so an exit can be reported as a stop rather than as an unexplained kill.
+     */
+    stop(signal?: NodeJS.Signals, graceMs?: number, cause?: {
+        reason: StopReason;
+        by?: string;
+    }): Promise<void>;
     snapshot(): Promise<ScreenResult>;
     info(): ShellInfo;
     dispose(): void;