dsh-ssh-tui 0.8.4-rc.1 → 0.8.4

package/lib/tui.js

@@ -48,7 +48,7 @@ import { resolveTheme, setActiveTheme, themeByName, themeEmphasisToken, themeExt
 import { presetLabel, profileFromArgv } from './preset-label.js';
 import { flattenGroups, groupPresets, optionMatches } from './preset-picker.js';
 import { isRefusal, planCopy, planDelete, planMetadata, presetDirectory, } from './preset-authoring.js';
-import { ensureRosterRows, planDuplicateRepair, planRosterRepair, formsRowsDeclared, rosterPatchPath, rosterRows, writePatchWithBackup, ALL_ROSTER_ROWS, } from './preset-rows.js';
+import { ensureRosterRows, planDuplicateRepair, planRosterRepair, rosterPatchPath, rosterRows, writePatchWithBackup, ALL_ROSTER_ROWS, } from './preset-rows.js';
 import { SessionStatsTracker, sessionTokenTotal, statsRowOf, } from './stats.js';
 import { QUESTION_OPTION_KEYS, applyQuestionFilter, backspaceQuestionFilter, clearQuestionFilter, typeQuestionFilter, visibleQuestionIndexes, confirmAnswer, inspectClosesOn, moveQuestionCursor, optionsLength, questionOptionIndex, initialQuestionSelection, questionOptionMarker, questionSubmit, selectQuestionOptionByKey, windowInteractionLines, PICKER_ROLE, interactionRole, stallsTask, surfacePriority, isSurfaceDialog, } from './dialogs.js';
 import { commandSuggestions, localizedCommands } from './commands.js';
@@ -2241,6 +2241,7 @@ export class SshTui {
         const credentials = this.ctx.get('credentials');
         const provider = this.currentProviderId();
         if (providerUsesLocalOAuth(provider)) {
+            await this.repairAgentPlaneAtBoot();
             // Workspace feedback *about* setup — not the wizard's own surface, which is the
             // setup Screen (B2.6 §12). These rows are the command plane's.
             this.pushRow(represent('command-status', {
@@ -2276,6 +2277,7 @@ export class SshTui {
         }
         if (envKey !== undefined && envKey !== '') {
             if (stored || existsSync(DSH_ENV_FILE) || this.resume) {
+                await this.repairAgentPlaneAtBoot();
                 this.pushRow(represent('command-status', {
                     kind: 'system',
                     text: t('onboard.envInUse', { env: envRef }),
@@ -2301,8 +2303,10 @@ export class SshTui {
         // got an empty workspace, a provider that cannot answer, and no hint that
         // `/setup` exists. The launch flag is not evidence of configuration; the
         // credential store is, and that is what `stored` reads.
-        if (stored)
+        if (stored) {
+            await this.repairAgentPlaneAtBoot();
             return;
+        }
         this.pushRow(represent('command-status', { kind: 'system', text: t('onboard.needSetup') }));
         await this.runOnboarding();
     }
@@ -2519,10 +2523,29 @@ export class SshTui {
         const models = Array.isArray(providers[provider]?.models) ? providers[provider]?.models ?? [] : [];
         const model = this.agent.options.model ?? this.selectionRef?.current?.model;
         const sub = this.subagentSelection.current;
+        // The official DeepSeek adapter is registered through `ctx.llm`, not through
+        // `llm-pi-ai`; the adapter directory is the same source `src/index.ts` uses
+        // for route availability. Keep the configured list too: a pi-ai gateway may
+        // be configured before its adapter has finished registering. Doctor is
+        // best-effort, so an unavailable directory falls back to that list rather
+        // than failing the report.
+        let adapterRoutes = [];
+        const llm = this.ctx.get('llm');
+        if (llm !== undefined) {
+            try {
+                adapterRoutes = llm.listProviders()
+                    .map(entry => entry.id.trim())
+                    .filter(id => id !== '');
+            }
+            catch {
+                // Keep the configured set; `/doctor` must still render what it knows.
+            }
+        }
+        const routes = [...new Set([...Object.keys(providers), ...adapterRoutes])];
         return {
             provider,
             ...(model === undefined ? {} : { model }),
-            routes: Object.keys(providers),
+            routes,
             routeModels: models.map(modelEntryId).filter((id) => id !== undefined),
             ...(sub.provider === undefined ? {} : { subProvider: this.displayProviderId(sub.provider) }),
             ...(sub.model === undefined ? {} : { subModel: sub.model }),
@@ -2531,6 +2554,7 @@ export class SshTui {
     /** One collected `/doctor` snapshot, from this process's own services. */
     async collectDoctorFacts(profile) {
         const routing = this.doctorRouting();
+        const tools = this.agentPlaneTools();
         return collectDoctor({
             profile,
             dshHome: resolveDshHome(),
@@ -2538,6 +2562,8 @@ export class SshTui {
             services: {
                 roster: this.ctx.get('agentPresets') !== undefined,
                 codeRuntime: this.hasHostService('codeRuntime'),
+                askUserTool: tools.askUser,
+                presentTool: tools.present,
             },
             generation: hostSettingsGeneration(this.ctx),
             anchors: [process.argv[1], this.ctx.baseUrl],
@@ -2620,7 +2646,7 @@ export class SshTui {
                 backup = await writePatchWithBackup(facts.patchPath, text);
             }
             else {
-                await ensureRosterRows(facts.dshHome, facts.profile, rows);
+                await ensureRosterRows(facts.dshHome, facts.profile, rows, facts.generation ?? 'legacy');
             }
             const done = [
                 t('doctor.fix.applied', {
@@ -8391,6 +8417,13 @@ export class SshTui {
         const options = {
             provider,
             model,
+            // The reviewer is a direct LLM call outside the Agent loop; the loop normally
+            // supplies this identity. OpenCode requires a per-conversation session
+            // signal: pi-ai's built-in provider turns this into `x-opencode-session`,
+            // while the configured openai-responses route sends `session_id`. Other
+            // providers may use it for their own affinity/cache routing. It must be the
+            // Session that actually asked for approval, never a shared or random id.
+            sessionId: request.agent.session.id,
             messages: [createUserMessage({
                     content: [{ type: 'text', text: buildReviewUserMessage({
                                 userText,
@@ -10922,18 +10955,91 @@ export class SshTui {
         this.markDirty();
     }
     /**
-     * `/mode fix`: write the roster row into this profile's user patch layer.
+     * The two tools a 0.1.7 terminal profile mounts itself, read from the running
+     * composition. The profile patch is only the instruction; this is the answer
+     * to whether the instruction actually produced a tool.
+     */
+    agentPlaneTools() {
+        const tools = this.ctx.get('tools');
+        return {
+            askUser: tools?.get('ask_user_question') !== undefined,
+            present: tools?.get('present') !== undefined,
+        };
+    }
+    /** Whether this process's agent plane has both tools. */
+    agentPlaneReady() {
+        const tools = this.agentPlaneTools();
+        return tools.askUser && tools.present;
+    }
+    /**
+     * Repair an already-configured profile at boot and say a restart is needed.
      *
-     * The write only takes effect on the next launch — the loader composes the
-     * patch tree once at boot — so the report says so instead of pretending the
-     * running session gained a roster.
+     * A first run deliberately does not call this: its wizard save is the point
+     * where settings and credentials exist, and `onboardDone` repairs immediately
+     * after that write. This method serves the old/partial profile upgrade path,
+     * where there is no wizard to wait for.
      */
+    async repairAgentPlaneAtBoot() {
+        const profile = profileFromArgv();
+        try {
+            const repaired = await this.ensureProfileAgentPlane(profile);
+            if (repaired === 'written') {
+                this.pushRow(represent('boot', {
+                    kind: 'system',
+                    text: t('onboard.agentPlaneAdded', {
+                        path: rosterPatchPath(resolveDshHome(), profile),
+                        profile,
+                    }),
+                }));
+                this.refreshRosterHealth();
+                this.markDirty();
+            }
+        }
+        catch (error) {
+            // A broken or unwritable patch must not be swallowed: the workspace can
+            // still boot, but the missing tools stay visible in the footer and
+            // `/doctor` explains how to repair the file.
+            this.pushRow(represent('boot', {
+                kind: 'error',
+                text: t('onboard.agentPlaneFailed', {
+                    error: errorChain(error),
+                    path: rosterPatchPath(resolveDshHome(), profile),
+                }),
+            }));
+            this.markDirty();
+        }
+    }
+    /**
+     * Add only the profile rows whose tools are missing from this composition.
+     *
+     * A row that is already present in the patch is never written again, even if
+     * its service failed to activate: the planner sees overrides and disables by
+     * id or module name, and `ensureRosterRows` creates a backup first. This is
+     * the first-run/upgrade repair, not an install-hook claim: it changes what
+     * the next boot composes, not what this process has already composed.
+     */
+    async ensureProfileAgentPlane(profile = profileFromArgv()) {
+        const generation = this.settingsGeneration;
+        const tools = this.agentPlaneTools();
+        const missing = generation === 'forms'
+            ? rosterRows(generation).filter(row => row.id === 'tool-ask-user' ? !tools.askUser : !tools.present)
+            : rosterRows(generation).filter(row => row.id === 'agent-presets'
+                ? this.ctx.get('agentPresets') === undefined
+                : row.id === 'code-runtime'
+                    ? !this.hasHostService('codeRuntime')
+                    : true);
+        if (missing.length === 0)
+            return 'present';
+        return ensureRosterRows(resolveDshHome(), profile, missing, generation);
+    }
     /** Re-read the roster fact this process was composed with (cheap, no IO). */
     refreshRosterHealth() {
         // 0.1.7 has no roster to be missing: what a terminal profile owns there is
-        // the agent-plane rows, so the chip reports those instead.
+        // the agent-plane tools, so the chip follows the tools the composition
+        // actually registered. Reading the patch alone would call a broken load
+        // healthy as soon as the row text was written.
         this.rosterMissing = this.settingsGeneration === 'forms'
-            ? !formsRowsDeclared(resolveDshHome(), profileFromArgv())
+            ? !this.agentPlaneReady()
             : this.ctx.get('agentPresets') === undefined;
     }
     /** Which settings protocol this host speaks; decides what "missing" means. */
@@ -10954,6 +11060,14 @@ export class SshTui {
             ? [first, t('mode.formsHost'), t('mode.formsHint', { profile, patch })].join('\n')
             : [first, t('mode.missingServiceHint', { profile, patch })].join('\n');
     }
+    /**
+     * `/mode fix`: write the missing profile rows into the user patch layer.
+     *
+     * The write only takes effect on the next launch — the loader composes the
+     * patch tree once at boot — so the report says so instead of pretending the
+     * running session gained a roster. The helper consults the actual tools, so
+     * a row a bundle already supplies is not mounted a second time.
+     */
     async repairRoster() {
         const profile = profileFromArgv();
         const patch = rosterPatchPath(resolveDshHome(), profile);
@@ -10962,8 +11076,7 @@ export class SshTui {
             // process-wide and owns the agent-plane rows instead of the roster. Both
             // the list and the header come from the same generation `/doctor` uses,
             // or this writes rows the running host cannot resolve.
-            const generation = this.settingsGeneration;
-            const result = await ensureRosterRows(resolveDshHome(), profile, rosterRows(generation), generation);
+            const result = await this.ensureProfileAgentPlane(profile);
             this.refreshRosterHealth();
             this.pushRow(represent('repair-result', {
                 kind: 'system',
@@ -13032,7 +13145,7 @@ export class SshTui {
                     this.setupMessage(state, 'system', t('onboard.baseSaved', { path: displayDshPath('settings.yaml') }));
                 }
                 if (saved) {
-                    this.onboardDone(t('onboard.officialDone', { model }));
+                    await this.onboardDone(t('onboard.officialDone', { model }));
                 }
             }
             else {
@@ -13205,7 +13318,7 @@ export class SshTui {
                     this.onSelectionChanged?.(selection);
                     await this.rememberRoute(selection);
                     await this.syncSubagentToProvider(ownerId, state.models, previousParentProvider !== ownerId);
-                    this.onboardDone(t('onboard.customDone', { id: ownerId, model }));
+                    await this.onboardDone(t('onboard.customDone', { id: ownerId, model }));
                 }
             }
         }
@@ -13249,8 +13362,40 @@ export class SshTui {
      * answer: `command-status` routes to the transcript, exactly like the boot line
      * that asked for the setup in the first place.
      */
-    onboardDone(text) {
+    async onboardDone(text) {
+        const profile = profileFromArgv();
+        let repairNote;
+        try {
+            // The wizard wrote settings and the model selection through the profile
+            // patch. Only after those writes are complete does the agent-plane repair
+            // run, so it cannot be undone by the wizard's own patch update.
+            const repaired = await this.ensureProfileAgentPlane(profile);
+            if (repaired === 'written') {
+                repairNote = t('onboard.agentPlaneAdded', {
+                    path: rosterPatchPath(resolveDshHome(), profile),
+                    profile,
+                });
+            }
+            else if (this.settingsGeneration === 'forms' && !this.agentPlaneReady()) {
+                // The rows are there but this process was composed before them (or a
+                // row failed to activate). Saying "saved" alone would hide that the
+                // tools are still absent from this session.
+                repairNote = t('onboard.agentPlaneRestart', {
+                    path: rosterPatchPath(resolveDshHome(), profile),
+                    profile,
+                });
+            }
+        }
+        catch (error) {
+            repairNote = t('onboard.agentPlaneFailed', {
+                error: errorChain(error),
+                path: rosterPatchPath(resolveDshHome(), profile),
+            });
+        }
         this.pushRow(represent('command-status', { kind: 'system', text }));
+        if (repairNote !== undefined) {
+            this.pushRow(represent('runtime-warning', { kind: 'system', text: repairNote }));
+        }
         this.markDirty();
     }
     /** Store one credential, falling back to a launch-environment override on shadow/absence. */