aicodeman 1.28.2 → 1.29.1

package/dist/session.js

@@ -23,7 +23,7 @@
  *   ralph-tracker (todo/completion parsing), bash-tool-parser (tool invocation tracking),
  *   task-tracker (background tasks), mux-interface (tmux abstraction)
  * @consumedby session-manager, web/server, respawn-controller
- * @emits session:terminal, session:idle, session:working, session:completion, session:exit
+ * @emits session:terminal, session:idle, session:working, session:completion, session:promptSubmitted, session:exit
  *
  * @module session
  */
@@ -52,6 +52,7 @@ import { SessionAutoOps } from './session-auto-ops.js';
 import { detectUsageLimitPause } from './usage-limit-patterns.js';
 import { SessionTaskCache } from './session-task-cache.js';
 import { InteractivePtyExitBreaker } from './session-pty-exit-breaker.js';
+import { isGeneratedSessionName, SubmittedPromptTracker } from './session-auto-name.js';
 import { parseTerminalAttachmentRequests } from './attachment-magic.js';
 import { sanitizeAttachmentHistory, upsertAttachmentHistory as upsertAttachmentHistoryList, } from './session-attachment-history.js';
 /** Line buffer flush interval (100ms) - forces processing of partial lines */
@@ -288,6 +289,15 @@ export class Session extends EventEmitter {
     // Task description cache (extracted to SessionTaskCache)
     _taskCache = new SessionTaskCache();
     _name;
+    _nameSource;
+    /**
+     * Reconstructs the composer draft from USER keystrokes so the first real
+     * prompt can name the tab. Fed only when a write says `fromUser`, and never
+     * for a CLI whose Enter runs a command rather than submitting a prompt
+     * (`startMode: 'shell'`), so a shell tab is not renamed after every `ls`.
+     */
+    _submittedPromptTracker = new SubmittedPromptTracker();
+    _acceptsPrompts;
     ptyProcess = null;
     _pid = null;
     _status = 'idle';
@@ -423,6 +433,18 @@ export class Session extends EventEmitter {
     // user can still switch in-session via /effort (incl. ultracode). Never carried as
     // the CLAUDE_CODE_EFFORT_LEVEL env var, which would hard-lock the session.
     _effort;
+    // Custom Model Endpoint Profiles (docs/custom-model-endpoints-plan.md). `envKeys`,
+    // `configDir` and `launchModel` are internal bookkeeping ONLY (never surfaced via
+    // toState()/the customModel getter): they are what setCustomModel() needs to undo a
+    // previous injection (remove exactly the env keys it added, delete a previous isolated
+    // config dir) without guessing what it once wrote. Persisted disk-only (`__customModel`).
+    _customModel;
+    // Env keys a retired custom-model selection injected that the NEXT respawn must
+    // `tmux setenv -u`. Deleting a key from `_envOverrides` alone does nothing to the
+    // tmux session, which keeps every `setenv` and hands it to `respawn-pane`, so the
+    // relaunched CLI would come back still pointed at the old endpoint (measured, see
+    // TmuxManager.applyEnvOverrides). Drained after a successful respawn.
+    _pendingEnvUnsets = new Set();
     // tmux history-limit (scrollback lines) allocated when this session's pane is created.
     _tmuxHistoryLimit;
     // Remote execution metadata, present when this session runs over SSH through local tmux.
@@ -465,6 +487,9 @@ export class Session extends EventEmitter {
         this.createdAt = config.createdAt || Date.now();
         this.mode = config.mode || 'claude';
         this._name = config.name || '';
+        this._nameSource =
+            config.nameSource ?? (!this._name || isGeneratedSessionName(this._name) ? 'placeholder' : 'manual');
+        this._acceptsPrompts = getCli(this.mode)?.capabilities.startMode !== 'shell';
         this._resumeSessionId = config.resumeSessionId;
         // NOW, not `createdAt`: recovery passes the ORIGINAL creation time of a
         // days-old tmux session, and seeding last-activity from it would report a
@@ -936,6 +961,62 @@ export class Session extends EventEmitter {
             this._color = color;
         }
     }
+    // Custom Model Endpoint Profiles (docs/custom-model-endpoints-plan.md) — public-safe
+    // subset only (never envKeys/configDir/launchModel, the bookkeeping for setCustomModel).
+    get customModel() {
+        if (!this._customModel)
+            return undefined;
+        const { endpointId, modelId, label } = this._customModel;
+        return { endpointId, modelId, label };
+    }
+    /**
+     * The full selection incl. bookkeeping, for state.json ONLY (`__customModel`, the
+     * same disk-only convention as `getEnvOverridesForPersist()`). Carries no env values,
+     * so nothing secret lands on disk; recovery re-derives them from the endpoint store.
+     * Without this a Codeman restart left the pane on the custom endpoint (tmux keeps
+     * its `setenv`s) while `customModel` came back undefined, so the state was wrong and
+     * clearing had nothing to unset. Must NOT be included in any API-bound serializer.
+     */
+    getCustomModelForPersist() {
+        return this._customModel ? { ...this._customModel, envKeys: [...this._customModel.envKeys] } : undefined;
+    }
+    /**
+     * Update this session's custom-model selection and merge the endpoint's injected env
+     * vars into `_envOverrides` — first UNDOING whatever the previous selection injected
+     * (removing exactly those env keys), so switching endpoints, or clearing back to the
+     * harness's native cloud default, never leaves a stale key behind. Synchronous and
+     * side-effect-free beyond mutating state, matching `setNice`/`setColor` above — this
+     * class does no file IO, so it reports the PREVIOUS `configDir` (if any) for the
+     * caller to clean up on disk (custom-model-injection.ts's configDir kind).
+     *
+     * Keys the previous selection injected that the new one does not re-set are queued
+     * for `tmux setenv -u` on the next respawn (`_pendingEnvUnsets`, threaded through
+     * `_buildRespawnPaneOptions().unsetEnvKeys`): the tmux session inherits every
+     * `setenv` into `respawn-pane`, so dropping them from the map alone would relaunch
+     * the CLI still pointed at the old endpoint — and for the `configDir` kinds, at a
+     * `HOME`/`CODEX_HOME`/`GROK_HOME` the caller has just deleted.
+     */
+    setCustomModel(next, envOverrides) {
+        const previousConfigDir = this._customModel?.configDir;
+        const removedEnvKeys = [];
+        if (this._customModel) {
+            for (const key of this._customModel.envKeys) {
+                if (this._envOverrides)
+                    delete this._envOverrides[key];
+                removedEnvKeys.push(key);
+                this._pendingEnvUnsets.add(key);
+            }
+        }
+        this._customModel = next ? { ...next, envKeys: [...next.envKeys] } : undefined;
+        if (envOverrides && Object.keys(envOverrides).length > 0) {
+            this._envOverrides = { ...(this._envOverrides ?? {}), ...envOverrides };
+            // A key the new selection sets again does not need an unset (applyEnvOverrides
+            // would set it right back anyway); keep the list to what actually goes away.
+            for (const key of Object.keys(envOverrides))
+                this._pendingEnvUnsets.delete(key);
+        }
+        return { removedEnvKeys, previousConfigDir };
+    }
     // Token tracking getters and setters
     get totalTokens() {
         return this._totalInputTokens + this._totalOutputTokens;
@@ -979,8 +1060,32 @@ export class Session extends EventEmitter {
     get name() {
         return this._name;
     }
+    /** An explicit rename: the name is the user's from here on and auto-naming never touches it. */
     set name(value) {
         this._name = value;
+        this._nameSource = 'manual';
+    }
+    /**
+     * Names the tab after its first prompt. Only a placeholder is eligible, and
+     * the session stops being one whether or not the string changed: "first
+     * prompt" means the first, not "every prompt until a rename". Returns
+     * whether the name changed, so the caller knows whether to persist and
+     * broadcast.
+     */
+    applyAutoName(value) {
+        if (this._nameSource !== 'placeholder')
+            return false;
+        const name = value.trim();
+        if (!name)
+            return false;
+        this._nameSource = 'auto';
+        if (this._name === name)
+            return false;
+        this._name = name;
+        return true;
+    }
+    get nameSource() {
+        return this._nameSource;
     }
     setAutoClear(enabled, threshold) {
         this._autoOps.setAutoClear(enabled, threshold);
@@ -1100,6 +1205,7 @@ export class Session extends EventEmitter {
             // attach repaint, so the home screens' quiet ordering survives a restart.
             lastActivityAt: this._wireActivityAt,
             name: this._name,
+            nameSource: this._nameSource,
             mode: this.mode,
             autoClearEnabled: this._autoOps.autoClearEnabled,
             autoClearThreshold: this._autoOps.autoClearThreshold,
@@ -1138,6 +1244,7 @@ export class Session extends EventEmitter {
             ompConfig: this._ompConfig,
             resumeSessionId: this._resumeSessionId,
             effort: this._effort,
+            customModel: this.customModel,
             // COD-118: runtime-only — surfaced so the frontend can require explicit user
             // intent before restarting a crash-looped session. Deliberately NOT restored
             // by the constructor: a Codeman restart starts with a fresh breaker so boot
@@ -1270,6 +1377,7 @@ export class Session extends EventEmitter {
                 needsNewSession = true;
             }
             else {
+                this._pendingEnvUnsets.clear();
                 // Wait a moment for the respawned process to fully start
                 await new Promise((resolve) => setTimeout(resolve, MUX_STARTUP_DELAY_MS));
             }
@@ -1358,14 +1466,66 @@ export class Session extends EventEmitter {
         console.log('[Session] reattachRemote: reattached remote session', this._muxSession.muxName, 'pid', newPid);
         return true;
     }
+    /**
+     * Kill and relaunch this session's CLI process IN PLACE — same pane, same tmux
+     * session, fresh env/args from current state. Custom Model Endpoint Profiles
+     * (docs/custom-model-endpoints-plan.md) is the first caller: after `setCustomModel()` merges new
+     * env vars into `_envOverrides`, the running CLI process still has the OLD env
+     * (inherited at its own process start, not live-reloaded), so switching a
+     * session's model/endpoint requires this restart to actually take effect.
+     *
+     * A GENERALIZED {@link reattachRemote} with the `!this._remote` guard dropped —
+     * `_buildRespawnPaneOptions()` already passes `remote: this._remote` through
+     * unconditionally, so `mux.respawnPane()` builds the right command either way
+     * (a local session gets `respawn-pane -k` + the real launch line, which is the
+     * kill-and-relaunch this method exists for; a remote session gets the existing
+     * reattach-to-durable-tmux behavior). Deliberately does NOT check `isBusy()` —
+     * that's the caller's job (mirrors `/interactive`'s guard), since a raw restart
+     * primitive shouldn't itself decide when it's safe to use.
+     *
+     * @returns true if the pane was respawned, false otherwise (no mux session, or
+     *   the mux session is gone — see {@link reattachRemote} for that reasoning).
+     */
+    async restartCli() {
+        if (!this._useMux || !this._mux || !this._muxSession)
+            return false;
+        const mux = this._mux;
+        if (!mux.muxSessionExists(this._muxSession.muxName)) {
+            console.log('[Session] restartCli: mux session gone, skipping:', this._muxSession.muxName);
+            return false;
+        }
+        this._pinOmpRespawnId();
+        const options = this._buildRespawnPaneOptions();
+        // Unlike the dead-pane respawn, this one kills a WORKING pane whose conversation
+        // already has a transcript, and a CLI that launches with `--session-id <id>` refuses
+        // an id that is already in use (claude: `Error: Session ID ... is already in use.`),
+        // which turned an endpoint switch into a dead pane and a lost session. A launch that
+        // declares a `fallback` chain renders `resume || new` once a resume id is set, the
+        // same `--resume <id> || --session-id <id>` shape the docker and remote pane commands
+        // already use, so pin the live conversation id for THIS respawn only. The registry
+        // shape is the gate, not the CLI's name: an entry whose resume id is minted by the
+        // CLI itself (codex/pi/omp/grok) never declares that chain, and its resume field is
+        // read from its own `<Mode>Config` rather than this top-level one anyway.
+        if (!options.resumeSessionId && getCli(this.mode)?.launch.chain === 'fallback') {
+            options.resumeSessionId = this._claudeSessionId ?? this.id;
+        }
+        const newPid = await mux.respawnPane(options);
+        if (!newPid) {
+            console.error('[Session] restartCli: respawnPane failed for', this._muxSession.muxName);
+            return false;
+        }
+        this._pendingEnvUnsets.clear();
+        console.log('[Session] restartCli: restarted CLI for', this._muxSession.muxName, 'pid', newPid);
+        return true;
+    }
     /**
      * Assemble the {@link RespawnPaneOptions} for this session. Single source of
      * truth shared by interactive start, shell start (via their inline copies),
-     * and {@link reattachRemote} so the remote reattach path can never drift from
+     * {@link reattachRemote}, and {@link restartCli} so no respawn path can drift from
      * the spawn path.
      */
     _buildRespawnPaneOptions() {
-        return {
+        const options = {
             sessionId: this.id,
             workingDir: this.workingDir,
             mode: this.mode,
@@ -1393,12 +1553,37 @@ export class Session extends EventEmitter {
             ompConfig: this._ompConfig,
             resumeSessionId: this._resumeSessionId,
             envOverrides: this._envOverrides,
+            unsetEnvKeys: this._pendingEnvUnsets.size > 0 ? [...this._pendingEnvUnsets] : undefined,
             effort: this._effort,
             historyLimit: this._tmuxHistoryLimit,
             remote: this._remote,
             docker: this._docker,
             owner: this._owner,
         };
+        return this._withCustomModelLaunchModel(options);
+    }
+    /**
+     * Force the custom-model selection's `launchModel` (pi/omp `custom/<id>`, grok's
+     * `[model.<name>]` block name) onto the CLI's `model` launch param. Where that param
+     * lives is registry DATA — the entry's `legacyConfigField` (`piConfig`, `grokConfig`,
+     * ...) or the top-level `model` for an entry that declares none — so this stays a
+     * generic reader rather than a branch per CLI. Applied on the OPTIONS only: the stored
+     * `<Mode>Config` keeps whatever model the user chose at create, which is exactly what a
+     * later clear must fall back to.
+     */
+    _withCustomModelLaunchModel(options) {
+        const launchModel = this._customModel?.launchModel;
+        if (!launchModel)
+            return options;
+        const entry = getCli(this.mode);
+        if (!entry)
+            return options;
+        const field = entry.launch.legacyConfigField;
+        if (!field)
+            return { ...options, model: launchModel };
+        const bag = options;
+        const existing = (bag[field] ?? {});
+        return { ...options, [field]: { ...existing, model: launchModel } };
     }
     /**
      * OMP-only: resolve and PIN the exact conversation to continue when
@@ -2879,11 +3064,12 @@ export class Session extends EventEmitter {
      * discards the data, but it used to do so with no signal at all — which is how
      * input could disappear while the caller believed it had been delivered.
      */
-    write(data) {
-        this._trackSubmit(data);
+    write(data, options = {}) {
+        const submittedPrompt = this._trackSubmit(data, options);
         if (!this.ptyProcess)
             return false;
         this.ptyProcess.write(data);
+        this._emitSubmittedPrompt(submittedPrompt);
         return true;
     }
     // ── Conversation tracking ─────────────────────────────────────────────
@@ -2897,10 +3083,34 @@ export class Session extends EventEmitter {
     get lastSubmitAt() {
         return this._lastSubmitAt;
     }
-    _trackSubmit(data) {
+    /**
+     * Stamps the pane's last Enter for EVERY write, and feeds the auto-name
+     * tracker only for user-originated input on a prompt-taking CLI. Ralph
+     * kick-starts, respawn `/clear`s, cron launches, approval answers and the
+     * trust-dialog keys all arrive without `fromUser` and so can never name a tab.
+     */
+    _trackSubmit(data, options) {
+        const submitted = options.fromUser && this._acceptsPrompts ? this._submittedPromptTracker.feed(data) : [];
         if (data.includes('\r') || data.includes('\n')) {
             this._lastSubmitAt = Date.now();
         }
+        return submitted;
+    }
+    /**
+     * Feeds user input that reaches the pane AROUND the write paths: the
+     * send-key route injects Shift+Enter's line feed through `tmux send-keys -H`
+     * directly, and without this the two lines of a prompt joined with no
+     * separator. Reports submissions like a write would (a line feed never is one).
+     */
+    trackUserInput(data) {
+        if (!this._acceptsPrompts)
+            return;
+        this._emitSubmittedPrompt(this._submittedPromptTracker.feed(data));
+    }
+    _emitSubmittedPrompt(prompts) {
+        for (const prompt of prompts) {
+            this.emit('promptSubmitted', prompt);
+        }
     }
     /**
      * A prompt was submitted, reported by the CLI's own UserPromptSubmit hook.
@@ -2933,6 +3143,20 @@ export class Session extends EventEmitter {
      * half-open socket silently drops frames with no error) would type a prompt
      * twice whenever an ACK is lost after the write landed.
      */
+    /**
+     * The highest input seq recorded for `clientId`, or 0 when this session has
+     * never seen it.
+     *
+     * Reported back on a REJECTED (duplicate) frame so the client can lift its own
+     * counter above this watermark. Without that number a client whose persisted
+     * counter fell behind ours has no way to find its way out: every fresh
+     * keystroke it sends lands at or below the watermark, is dropped as a
+     * duplicate, and is ACKed anyway — so the UI looks healthy while nothing is
+     * delivered, and a reload restores the same stale counter from localStorage.
+     */
+    lastInputSeq(clientId) {
+        return this._appliedInputSeq.get(clientId) ?? 0;
+    }
     shouldApplyInput(clientId, seq) {
         const last = this._appliedInputSeq.get(clientId);
         if (last !== undefined && seq <= last)
@@ -2980,14 +3204,18 @@ export class Session extends EventEmitter {
      * session.writeViaMux('/init\r');   // Send /init command
      * ```
      */
-    async writeViaMux(data) {
-        this._trackSubmit(data);
+    async writeViaMux(data, options = {}) {
+        const submittedPrompt = this._trackSubmit(data, options);
         if (this._mux && this._muxSession) {
-            return this._mux.sendInput(this.id, data);
+            const sent = await this._mux.sendInput(this.id, data);
+            if (sent)
+                this._emitSubmittedPrompt(submittedPrompt);
+            return sent;
         }
         // Fallback to PTY write
         if (this.ptyProcess) {
             this.ptyProcess.write(data);
+            this._emitSubmittedPrompt(submittedPrompt);
             return true;
         }
         return false;