@pellux/goodvibes-tui 1.13.1 → 1.15.0

package/src/input/commands/channel-runtime.ts

@@ -1,14 +1,148 @@
-import type { CommandRegistry } from '../command-registry.ts';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import { requireIntegrationHelpers } from './runtime-services.ts';
+import { runChannelPairing } from './channel-pairing.ts';
+import { describeOperatorRpcError, getOperatorRpc } from './operator-rpc.ts';
+import type { OperatorMethodOutput } from '@pellux/goodvibes-sdk';
+
+type ChannelProfileBinding = OperatorMethodOutput<'channels.profiles.list'>['bindings'][number];
+
+function renderProfileBinding(binding: ChannelProfileBinding): string {
+  const scope = binding.channelId ? `${binding.surfaceKind}:${binding.channelId}` : `${binding.surfaceKind} (surface-wide default)`;
+  const lines = [`  ${scope}`];
+  if (binding.model) lines.push(`    model: ${binding.model}${binding.provider ? ` (${binding.provider})` : ''}`);
+  if (binding.permissionMode) lines.push(`    permission mode: ${binding.permissionMode}`);
+  return lines.join('\n');
+}
+
+const CHANNEL_PROFILES_SUBCOMMANDS = ['list', 'get', 'set', 'delete'] as const;
+
+async function handleChannelProfilesSubcommand(args: string[], ctx: CommandContext): Promise<void> {
+  const sub = args[0] ?? 'list';
+  if (!(CHANNEL_PROFILES_SUBCOMMANDS as readonly string[]).includes(sub)) {
+    ctx.print(
+      'Usage: /channel profiles <subcommand>\n'
+      + '  list                                    — every per-channel profile binding\n'
+      + '  get <surfaceKind> [channelId]           — one binding\n'
+      + '  set <surfaceKind> [channelId] [--model x] [--provider x] [--permission-mode x]  — bind (upsert)\n'
+      + '  delete <surfaceKind> [channelId]        — remove a binding'
+    );
+    return;
+  }
+
+  if (sub === 'list') {
+    const rpc = getOperatorRpc(ctx);
+    if (!rpc.available) {
+      ctx.print(`[channel profiles] ${rpc.reason}`);
+      return;
+    }
+    try {
+      const { bindings } = await rpc.sdk.operator.invoke('channels.profiles.list', {});
+      if (bindings.length === 0) {
+        ctx.print('[channel profiles] no profile bindings configured.');
+        return;
+      }
+      ctx.print(['Channel profile bindings:', ...bindings.map(renderProfileBinding)].join('\n'));
+    } catch (error) {
+      ctx.print(`[channel profiles list] ${describeOperatorRpcError(error)}`);
+    }
+    return;
+  }
+
+  if (sub === 'get') {
+    const surfaceKind = args[1];
+    const channelId = args[2];
+    if (!surfaceKind) {
+      ctx.print('Usage: /channel profiles get <surfaceKind> [channelId]');
+      return;
+    }
+    const rpc = getOperatorRpc(ctx);
+    if (!rpc.available) {
+      ctx.print(`[channel profiles] ${rpc.reason}`);
+      return;
+    }
+    try {
+      const { binding } = await rpc.sdk.operator.invoke('channels.profiles.get', { surfaceKind, ...(channelId ? { channelId } : {}) });
+      ctx.print(renderProfileBinding(binding));
+    } catch (error) {
+      ctx.print(`[channel profiles get] ${describeOperatorRpcError(error)}`);
+    }
+    return;
+  }
+
+  if (sub === 'set') {
+    const rest = args.slice(1);
+    const flagStart = rest.findIndex((token) => token.startsWith('--'));
+    const positional = flagStart === -1 ? rest : rest.slice(0, flagStart);
+    const flagTokens = flagStart === -1 ? [] : rest.slice(flagStart);
+    const surfaceKind = positional[0];
+    const channelId = positional[1];
+    if (!surfaceKind) {
+      ctx.print('Usage: /channel profiles set <surfaceKind> [channelId] [--model x] [--provider x] [--permission-mode plan|normal|accept-edits|auto]');
+      return;
+    }
+    const flags = new Map<string, string>();
+    for (let i = 0; i < flagTokens.length; i++) {
+      const token = flagTokens[i]!;
+      if (!token.startsWith('--')) continue;
+      const name = token.slice(2);
+      const value = flagTokens[i + 1];
+      if (value !== undefined) {
+        flags.set(name, value);
+        i++;
+      }
+    }
+    const rpc = getOperatorRpc(ctx);
+    if (!rpc.available) {
+      ctx.print(`[channel profiles] ${rpc.reason}`);
+      return;
+    }
+    try {
+      const { binding } = await rpc.sdk.operator.invoke('channels.profiles.set', {
+        surfaceKind,
+        ...(channelId ? { channelId } : {}),
+        ...(flags.has('model') ? { model: flags.get('model')! } : {}),
+        ...(flags.has('provider') ? { provider: flags.get('provider')! } : {}),
+        ...(flags.has('permission-mode') ? { permissionMode: flags.get('permission-mode') as 'plan' | 'normal' | 'accept-edits' | 'auto' } : {}),
+      });
+      ctx.print(`[channel profiles set] bound ${binding.id}\n${renderProfileBinding(binding)}`);
+    } catch (error) {
+      ctx.print(`[channel profiles set] ${describeOperatorRpcError(error)}`);
+    }
+    return;
+  }
+
+  if (sub === 'delete') {
+    const surfaceKind = args[1];
+    const channelId = args[2];
+    if (!surfaceKind) {
+      ctx.print('Usage: /channel profiles delete <surfaceKind> [channelId]');
+      return;
+    }
+    const rpc = getOperatorRpc(ctx);
+    if (!rpc.available) {
+      ctx.print(`[channel profiles] ${rpc.reason}`);
+      return;
+    }
+    try {
+      const result = await rpc.sdk.operator.invoke('channels.profiles.delete', { surfaceKind, ...(channelId ? { channelId } : {}) });
+      ctx.print(result.deleted
+        ? `[channel profiles delete] removed binding for ${surfaceKind}${channelId ? `:${channelId}` : ''}.`
+        : `[channel profiles delete] no binding found for ${surfaceKind}${channelId ? `:${channelId}` : ''}.`);
+    } catch (error) {
+      ctx.print(`[channel profiles delete] ${describeOperatorRpcError(error)}`);
+    }
+    return;
+  }
+}
 
 export function registerChannelRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'channel',
-    aliases: [],
-    description: 'Inspect channel routes, delivery strategies, and ingress policies',
-    usage: '[status|routes|delivery|policy] [--json]',
-    argsHint: 'status | routes | delivery | policy',
-    handler(args, ctx) {
+    aliases: ['channels'],
+    description: 'Pair channels and inspect routes, delivery strategies, ingress policies, and per-channel profile bindings',
+    usage: '[pair [surface]|status|routes|delivery|policy|profiles [list|get|set|delete]] [--json]',
+    argsHint: 'pair | status | routes | delivery | policy | profiles',
+    async handler(args, ctx) {
       const sub = args[0];
       const asJson = args.includes('--json');
 
@@ -17,6 +151,16 @@ export function registerChannelRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
+      if (sub === 'pair') {
+        await runChannelPairing(args.slice(1), ctx);
+        return;
+      }
+
+      if (sub === 'profiles') {
+        await handleChannelProfilesSubcommand(args.slice(1), ctx);
+        return;
+      }
+
       const helpers = requireIntegrationHelpers(ctx);
 
       if (sub === 'status') {
@@ -126,10 +270,12 @@ export function registerChannelRuntimeCommands(registry: CommandRegistry): void
       ctx.print(
         'Usage: /channel <subcommand>\n'
         + '  (no args)  — open the Routes panel\n'
+        + '  pair [surface] — guided channel pairing: list adapters, enter declared credentials, verify\n'
         + '  status     — channel overview: routes, sessions, tasks, pending approvals\n'
         + '  routes     — active route binding snapshot\n'
         + '  delivery   — outbound delivery snapshot\n'
         + '  policy     — configured channel surfaces and ingress policy location\n'
+        + '  profiles [list|get|set|delete]  — per-channel model/permission profile bindings\n'
         + '\n'
         + 'Options:\n'
         + '  --json  Output raw JSON for scripting'

package/src/input/commands/checkin-runtime.ts

@@ -0,0 +1,89 @@
+/**
+ * checkin-runtime.ts
+ *
+ * `/checkin` — the proactive check-in surface: config (enabled/cadence/
+ * delivery channel/quiet hours) and its receipt trail, over the operator
+ * wire (see operator-rpc.ts for why this goes over HTTP rather than the
+ * in-process OperatorClient facade). Off by default; every run — scheduled
+ * or manual — leaves a receipt (`checkin.receipts.list`) recording whether it
+ * stayed quiet, delivered a message, or was skipped, so the config surface
+ * in /config's Automation group is never the only place this feature's
+ * behavior is visible.
+ */
+import type { CommandRegistry } from '../command-registry.ts';
+import { describeOperatorRpcError, getOperatorRpc } from './operator-rpc.ts';
+import type { OperatorMethodOutput } from '@pellux/goodvibes-sdk';
+
+type CheckinConfig = OperatorMethodOutput<'checkin.config.get'>['config'];
+type CheckinReceipt = OperatorMethodOutput<'checkin.receipts.list'>['receipts'][number];
+
+export function renderConfig(config: CheckinConfig): string {
+  return [
+    'Check-in config:',
+    `  enabled:         ${config.enabled ? 'yes' : 'no'}`,
+    `  cadence (cron):  ${config.cadence || '(not set)'}`,
+    `  delivery channel: ${config.deliveryChannel || '(not set)'}`,
+    `  quiet hours:     ${config.quietHours || '(none)'}`,
+  ].join('\n');
+}
+
+export function renderReceipt(receipt: CheckinReceipt): string {
+  const parts = [`  ${new Date(receipt.ranAt).toISOString()}  [${receipt.trigger}]  ${receipt.outcome}`];
+  parts.push(`    ${receipt.briefingSummary}`);
+  if (receipt.decisionReason) parts.push(`    reason: ${receipt.decisionReason}`);
+  if (receipt.deliveredMessage) parts.push(`    delivered: ${receipt.deliveredMessage}`);
+  if (receipt.deliveryChannel) parts.push(`    channel: ${receipt.deliveryChannel}`);
+  if (receipt.error) parts.push(`    error: ${receipt.error}`);
+  return parts.join('\n');
+}
+
+export function registerCheckinRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'checkin',
+    description: 'Proactive check-in: view config + recent receipts, or trigger one now',
+    usage: '[run]',
+    argsHint: '[run]',
+    async handler(args, ctx) {
+      const rpc = getOperatorRpc(ctx);
+      if (!rpc.available) {
+        ctx.print(`[checkin] ${rpc.reason}`);
+        return;
+      }
+
+      if (args[0] === 'run') {
+        try {
+          const result = await rpc.sdk.operator.invoke('checkin.run', {});
+          const lines = [`[checkin run] outcome: ${result.outcome}`, `  ${result.summary}`];
+          if (result.deliveryId) lines.push(`  delivery id: ${result.deliveryId}`);
+          ctx.print(lines.join('\n'));
+        } catch (error) {
+          ctx.print(`[checkin run] ${describeOperatorRpcError(error)}`);
+        }
+        return;
+      }
+
+      if (args.length > 0) {
+        ctx.print('Usage: /checkin [run]');
+        return;
+      }
+
+      try {
+        const [{ config }, { receipts }] = await Promise.all([
+          rpc.sdk.operator.invoke('checkin.config.get', {}),
+          rpc.sdk.operator.invoke('checkin.receipts.list', { limit: 10 }),
+        ]);
+        const lines = [renderConfig(config), ''];
+        if (receipts.length === 0) {
+          lines.push('No check-in receipts yet.');
+        } else {
+          lines.push('Recent receipts:');
+          lines.push(...receipts.map(renderReceipt));
+        }
+        lines.push('', '  /checkin run — trigger one now');
+        ctx.print(lines.join('\n'));
+      } catch (error) {
+        ctx.print(`[checkin] ${describeOperatorRpcError(error)}`);
+      }
+    },
+  });
+}

package/src/input/commands/checkpoint-runtime.ts

@@ -1,26 +1,19 @@
 // ---------------------------------------------------------------------------
-// checkpoint-runtime.ts — /checkpoints, /checkpoint, /rewind
+// checkpoint-runtime.ts — /checkpoints, /checkpoint
 //
 // UX over WorkspaceCheckpointManager (@pellux/goodvibes-sdk/platform/workspace),
-// the whole-workspace, git-backed rewind engine wired onto RuntimeServices as
+// the whole-workspace, git-backed snapshot engine wired onto RuntimeServices as
 // `workspaceCheckpointManager` (src/runtime/services.ts) and threaded through
 // CommandContext.workspace exactly like FileUndoManager already is.
 //
-// Architecture note (why the confirm step lives in DiffPanel, not here):
-// SlashCommand.handler(args, ctx) is a single-shot call — there is no "await
-// next keypress" primitive in the command layer. So `/rewind <id>` can only
-// resolve the target, load the preview, open+focus the diff panel, and arm
-// its confirm overlay (DiffPanel.confirmOverlay, a PanelConfirmOverlay —
-// see panel-confirm-overlay.ts); the actual y/n/Enter/Esc handling happens
-// in DiffPanel.handleInput() via the project's canonical ConfirmState<T>
-// contract (confirm-state.ts), which every other destructive-action confirm
-// in this codebase already uses (see git-panel.ts).
+// Restoring a checkpoint is now done through the unified, message-anchored
+// /rewind (rewind-runtime.ts), which rewinds files AND/OR conversation to a
+// completed turn — reusing this same checkpoint store for the files half.
 // ---------------------------------------------------------------------------
 
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
-import type { WorkspaceCheckpoint, WorkspaceCheckpointManager } from '@pellux/goodvibes-sdk/platform/workspace';
+import type { WorkspaceCheckpoint } from '@pellux/goodvibes-sdk/platform/workspace';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
-import { requirePanelManager } from './runtime-services.ts';
 
 // ---------------------------------------------------------------------------
 // Formatting helpers
@@ -50,62 +43,6 @@ function formatBytes(bytes: number): string {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 
-function plural(n: number, word: string): string {
-  return `${n} ${word}${n === 1 ? '' : 's'}`;
-}
-
-// ---------------------------------------------------------------------------
-// Checkpoint resolution — shared by /rewind
-// ---------------------------------------------------------------------------
-
-type ResolveResult =
-  | { checkpoint: WorkspaceCheckpoint }
-  | { error: string };
-
-/**
- * Resolve a user-supplied checkpoint reference ('last' or an id / id prefix,
- * as shown by /checkpoints) against the live checkpoint list. Resolution
- * happens entirely against list() results — never against
- * WorkspaceCheckpointManager's own requireCheckpoint() — so an unknown ref is
- * caught here, before anything touches the diff panel or arms a confirm.
- *
- * mgr.list() is guarded here (not left to the caller) so every caller gets a
- * plain ResolveResult and can never be handed a rejected promise: if the
- * manager's list() call fails (including a cached init() failure — see
- * services.ts — which makes every WorkspaceCheckpointManager method reject
- * forever), that surfaces as an honest `{ error }` instead of an unhandled
- * rejection.
- */
-async function resolveCheckpointTarget(
-  mgr: WorkspaceCheckpointManager,
-  ref: string,
-): Promise<ResolveResult> {
-  let all: WorkspaceCheckpoint[];
-  try {
-    all = await mgr.list();
-  } catch (err) {
-    return { error: `Failed to list checkpoints: ${summarizeError(err)}` };
-  }
-  if (ref === 'last') {
-    const checkpoint = all[0];
-    if (!checkpoint) {
-      return { error: 'No checkpoints to rewind to. Use /checkpoint <label> to create one.' };
-    }
-    return { checkpoint };
-  }
-  const exact = all.find((c) => c.id === ref);
-  if (exact) return { checkpoint: exact };
-
-  const prefixMatches = all.filter((c) => c.id.startsWith(ref) || shortId(c.id).startsWith(ref));
-  if (prefixMatches.length === 1) return { checkpoint: prefixMatches[0]! };
-  if (prefixMatches.length > 1) {
-    return {
-      error: `Checkpoint id "${ref}" is ambiguous — matches ${prefixMatches.length} checkpoints. Use a longer prefix or run /checkpoints for full ids.`,
-    };
-  }
-  return { error: `Unknown checkpoint id: "${ref}". Run /checkpoints to see available checkpoints.` };
-}
-
 // ---------------------------------------------------------------------------
 // Commands
 // ---------------------------------------------------------------------------
@@ -140,7 +77,7 @@ export function registerCheckpointRuntimeCommands(registry: CommandRegistry): vo
       // them would cost one diff spawn per checkpoint (O(checkpoints)), which
       // stops being cheap once there are more than a handful. /rewind <id>
       // loads exactly one diff, so the exact file list is available there.
-      ctx.print('Use /rewind <id|last> to preview the exact file changes and restore a checkpoint.');
+      ctx.print('Use /rewind to preview and restore a completed turn (files and/or conversation) — it reuses these checkpoints for the files half.');
     },
   });
 
@@ -168,113 +105,4 @@ export function registerCheckpointRuntimeCommands(registry: CommandRegistry): vo
       }
     },
   });
-
-  registry.register({
-    name: 'rewind',
-    description: 'Preview and restore a workspace checkpoint (files only — conversation history is unchanged)',
-    usage: '<id|last>',
-    argsHint: '<id|last>',
-    handler: async (args, ctx: CommandContext) => {
-      const mgr = ctx.workspace.workspaceCheckpointManager;
-      if (!mgr) {
-        ctx.print('Checkpoints are not available in this session.');
-        return;
-      }
-      const ref = args[0];
-      if (!ref) {
-        ctx.print('Usage: /rewind <id|last>. Run /checkpoints to see available checkpoints.');
-        return;
-      }
-
-      const resolved = await resolveCheckpointTarget(mgr, ref);
-      if ('error' in resolved) {
-        ctx.print(resolved.error);
-        return;
-      }
-      const { checkpoint } = resolved;
-
-      let diff: Awaited<ReturnType<WorkspaceCheckpointManager['diff']>>;
-      try {
-        diff = await mgr.diff(checkpoint.id);
-      } catch (err) {
-        ctx.print(`Could not load checkpoint preview: ${summarizeError(err)}`);
-        return;
-      }
-
-      const { DiffPanel } = await import('../../panels/diff-panel.ts');
-      const pm = requirePanelManager(ctx);
-      let panel = pm.getAllOpen().find((p) => p.id === 'diff');
-      if (!panel) {
-        try {
-          panel = pm.open('diff');
-        } catch {
-          ctx.print('Could not open diff panel.');
-          return;
-        }
-      }
-      pm.activateById('diff');
-      if (!pm.isVisible()) pm.show();
-      // Must focus the panel — otherwise the user is left typing at the
-      // prompt while the panel silently shows a pending confirm they never
-      // see (the single most likely UX bug in this feature).
-      ctx.focusPanels?.();
-
-      const diffPanel = panel as InstanceType<typeof DiffPanel>;
-      if (diff.unifiedDiff.trim()) {
-        diffPanel.loadRawDiff(diff.unifiedDiff);
-      } else {
-        diffPanel.showDiff('(no changes)', '@@ -0,0 +0,0 @@\n Working tree already matches this checkpoint.');
-      }
-
-      diffPanel.confirmOverlay.arm({
-        id: checkpoint.id,
-        // renderConfirmLines (panels/confirm-state.ts) builds the on-screen
-        // prompt as `${verb} "${label}"?` itself — it supplies both the verb
-        // and the surrounding quotes. A label that already contained "Restore
-        // "..."" duplicated both, rendering as `Restore "Restore
-        // "baseline-pin"…`. label here must be just the descriptive subject,
-        // with no verb and no quotes of its own (same convention GitPanel
-        // already follows for its own confirms — see git-panel.ts:352,370).
-        label: `${checkpoint.label} (${plural(diff.files.length, 'file')} differ) — files only, conversation history is unchanged`,
-        verb: 'Restore',
-        onConfirm: async () => {
-          try {
-            const result = await mgr.restore(checkpoint.id, { safetyCheckpoint: true });
-            ctx.print(
-              `Rewind complete: restored ${plural(result.restoredFiles.length, 'file')}, removed ${plural(result.removedFiles.length, 'file')}. ` +
-              `Safety checkpoint: ${result.safetyCheckpointId ? shortId(result.safetyCheckpointId) : '(none — working tree already matched)'}.`,
-            );
-            // Conversation is NOT rewound: addSystemMessage (not ctx.print)
-            // persists this note into real turn/session history so it is
-            // indexed by getTranscriptEventIndex() and session save/load,
-            // while staying a distinct message kind from user/assistant turns.
-            ctx.session.conversationManager.addSystemMessage(
-              `[Rewind] Restored checkpoint "${checkpoint.label}" (${plural(result.restoredFiles.length, 'file')} restored, ${plural(result.removedFiles.length, 'file')} removed). ` +
-              'Files were rewound — conversation history is unchanged. Use /undo to remove turns separately.',
-            );
-            // Auto-close the preview: once the restore has actually happened,
-            // the diff panel showing the (now-stale) pre-restore preview has
-            // nothing left to confirm and no obvious way to dismiss it
-            // otherwise (same pm.close(id) + focusPrompt() pattern as
-            // /panel close — see operator-panel-runtime.ts).
-            pm.close('diff');
-            ctx.focusPrompt?.();
-            ctx.renderRequest();
-          } catch (err) {
-            ctx.print(`Rewind failed: ${summarizeError(err)}`);
-          }
-        },
-        onCancel: () => {
-          ctx.print('Rewind cancelled — no files changed.');
-          // Same auto-close as the confirm path above — a denied restore also
-          // leaves nothing actionable in the preview panel.
-          pm.close('diff');
-          ctx.focusPrompt?.();
-          ctx.renderRequest();
-        },
-      });
-      ctx.print(`Previewing checkpoint ${shortId(checkpoint.id)} "${checkpoint.label}". Confirm in the diff panel: Enter/y to restore, n/Esc to cancel.`);
-      ctx.renderRequest();
-    },
-  });
 }