wave-code 0.13.6 → 0.14.1

package/src/hooks/usePluginManager.ts

@@ -11,7 +11,9 @@ import {
   PluginManagerContextType,
 } from "../components/PluginManagerTypes.js";
 
-export function usePluginManager(): PluginManagerContextType {
+export function usePluginManager(options?: {
+  onPluginInstalled?: () => void;
+}): PluginManagerContextType {
   const [state, setState] = useState<PluginManagerState>({
     currentView: "DISCOVER",
     selectedId: null,
@@ -141,16 +143,20 @@ export function usePluginManager(): PluginManagerContextType {
   }, []);
 
   const addMarketplace = useCallback(
-    async (source: string) => {
+    async (source: string, scope: "user" | "project" | "local" = "user") => {
       clearPluginFeedback();
       setState((prev: PluginManagerState) => ({
         ...prev,
         isLoading: true,
       }));
       try {
-        await pluginCore.addMarketplace(source);
+        await pluginCore.addMarketplace(source, scope);
         await refresh();
-        setSuccessMessage(`Marketplace added successfully`);
+        setSuccessMessage(`Marketplace added successfully (${scope} scope)`);
+        setState((prev: PluginManagerState) => ({
+          ...prev,
+          currentView: "MARKETPLACES",
+        }));
       } catch (error) {
         setState((prev: PluginManagerState) => ({
           ...prev,
@@ -163,16 +169,20 @@ export function usePluginManager(): PluginManagerContextType {
   );
 
   const removeMarketplace = useCallback(
-    async (name: string) => {
+    async (name: string, scope?: "user" | "project" | "local") => {
       clearPluginFeedback();
       setState((prev: PluginManagerState) => ({
         ...prev,
         isLoading: true,
       }));
       try {
-        await pluginCore.removeMarketplace(name);
+        await pluginCore.removeMarketplace(name, scope);
         await refresh();
         setSuccessMessage(`Marketplace '${name}' removed successfully`);
+        setState((prev: PluginManagerState) => ({
+          ...prev,
+          currentView: "MARKETPLACES",
+        }));
       } catch (error) {
         setState((prev: PluginManagerState) => ({
           ...prev,
@@ -222,6 +232,7 @@ export function usePluginManager(): PluginManagerContextType {
         await pluginCore.installPlugin(pluginId, scope);
         await refresh();
         setSuccessMessage(`Plugin '${name}' installed successfully`);
+        options?.onPluginInstalled?.();
       } catch (error) {
         setState((prev: PluginManagerState) => ({
           ...prev,
@@ -230,7 +241,7 @@ export function usePluginManager(): PluginManagerContextType {
         }));
       }
     },
-    [pluginCore, refresh, clearPluginFeedback, setSuccessMessage],
+    [pluginCore, refresh, clearPluginFeedback, setSuccessMessage, options],
   );
 
   const uninstallPlugin = useCallback(

package/src/managers/inputHandlers.ts

@@ -297,14 +297,12 @@ export const handlePasteInput = (
     inputString.includes("\r");
 
   if (isPasteOperation) {
-    if (!state.isPasting) {
-      dispatch({
-        type: "START_PASTE",
-        payload: { buffer: inputString, cursorPosition: state.cursorPosition },
-      });
-    } else {
-      dispatch({ type: "APPEND_PASTE_BUFFER", payload: inputString });
-    }
+    // Dispatch a single action type; the reducer determines start vs append
+    // by checking pasteBuffer, avoiding stale state issues
+    dispatch({
+      type: "APPEND_PASTE_CHUNK",
+      payload: { chunk: inputString, cursorPosition: state.cursorPosition },
+    });
   } else {
     let char = inputString;
     if (char === "！" && state.cursorPosition === 0) {

package/src/managers/inputReducer.ts

@@ -173,6 +173,10 @@ export type InputAction =
   | { type: "CLEAR_INPUT" }
   | { type: "START_PASTE"; payload: { buffer: string; cursorPosition: number } }
   | { type: "APPEND_PASTE_BUFFER"; payload: string }
+  | {
+      type: "APPEND_PASTE_CHUNK";
+      payload: { chunk: string; cursorPosition: number };
+    }
   | { type: "END_PASTE" }
   | {
       type: "ADD_IMAGE_AND_INSERT_PLACEHOLDER";
@@ -407,6 +411,21 @@ export function inputReducer(
         cursorPosition: 0,
         historyIndex: -1,
       };
+    case "APPEND_PASTE_CHUNK": {
+      // The reducer determines if this is a new paste or a continuation
+      // by checking if pasteBuffer is already set. This avoids the
+      // handler needing to track isPasting state, which can be stale
+      // when multiple dispatches fire before React state updates.
+      const isNewPaste = !state.pasteBuffer;
+      return {
+        ...state,
+        isPasting: true,
+        pasteBuffer: state.pasteBuffer + action.payload.chunk,
+        initialPasteCursorPosition: isNewPaste
+          ? action.payload.cursorPosition
+          : state.initialPasteCursorPosition,
+      };
+    }
     case "START_PASTE":
       return {
         ...state,

package/src/reducers/backgroundTaskManagerReducer.ts

@@ -0,0 +1,60 @@
+export interface Task {
+  id: string;
+  type: string;
+  description?: string;
+  status: "running" | "completed" | "failed" | "killed";
+  startTime: number;
+  exitCode?: number;
+  runtime?: number;
+  outputPath?: string;
+}
+
+export interface DetailOutput {
+  stdout: string;
+  stderr: string;
+  status: string;
+  outputPath?: string;
+}
+
+export interface BackgroundTaskManagerState {
+  tasks: Task[];
+  selectedIndex: number;
+  viewMode: "list" | "detail";
+  detailTaskId: string | null;
+  detailOutput: DetailOutput | null;
+}
+
+export type BackgroundTaskManagerAction =
+  | { type: "SET_TASKS"; tasks: Task[] }
+  | { type: "SELECT_INDEX"; index: number }
+  | { type: "SET_VIEW_MODE"; mode: "list" | "detail" }
+  | { type: "SET_DETAIL_TASK_ID"; id: string | null }
+  | { type: "SET_DETAIL_OUTPUT"; output: DetailOutput | null }
+  | { type: "RESET_DETAIL" };
+
+export function backgroundTaskManagerReducer(
+  state: BackgroundTaskManagerState,
+  action: BackgroundTaskManagerAction,
+): BackgroundTaskManagerState {
+  switch (action.type) {
+    case "SET_TASKS":
+      return { ...state, tasks: action.tasks };
+    case "SELECT_INDEX":
+      return { ...state, selectedIndex: action.index };
+    case "SET_VIEW_MODE":
+      return { ...state, viewMode: action.mode };
+    case "SET_DETAIL_TASK_ID":
+      return { ...state, detailTaskId: action.id };
+    case "SET_DETAIL_OUTPUT":
+      return { ...state, detailOutput: action.output };
+    case "RESET_DETAIL":
+      return {
+        ...state,
+        viewMode: "list",
+        detailTaskId: null,
+        detailOutput: null,
+      };
+    default:
+      return state;
+  }
+}

package/src/reducers/confirmationReducer.ts

@@ -0,0 +1,74 @@
+import type { PermissionDecision } from "wave-agent-sdk";
+
+export interface ConfirmationState {
+  selectedOption: "clear" | "auto" | "allow" | "alternative";
+  alternativeText: string;
+  alternativeCursorPosition: number;
+  hasUserInput: boolean;
+  decision: PermissionDecision | null;
+}
+
+export type ConfirmationAction =
+  | { type: "SELECT_OPTION"; option: ConfirmationState["selectedOption"] }
+  | { type: "INSERT_TEXT"; text: string }
+  | { type: "BACKSPACE" }
+  | { type: "MOVE_CURSOR_LEFT" }
+  | { type: "MOVE_CURSOR_RIGHT" }
+  | { type: "CONFIRM"; decision: PermissionDecision };
+
+export function confirmationReducer(
+  state: ConfirmationState,
+  action: ConfirmationAction,
+): ConfirmationState {
+  switch (action.type) {
+    case "SELECT_OPTION":
+      return { ...state, selectedOption: action.option };
+    case "INSERT_TEXT": {
+      const nextText =
+        state.alternativeText.slice(0, state.alternativeCursorPosition) +
+        action.text +
+        state.alternativeText.slice(state.alternativeCursorPosition);
+      return {
+        ...state,
+        selectedOption: "alternative",
+        alternativeText: nextText,
+        alternativeCursorPosition:
+          state.alternativeCursorPosition + action.text.length,
+        hasUserInput: true,
+      };
+    }
+    case "BACKSPACE": {
+      if (state.alternativeCursorPosition <= 0) return state;
+      const nextText =
+        state.alternativeText.slice(0, state.alternativeCursorPosition - 1) +
+        state.alternativeText.slice(state.alternativeCursorPosition);
+      return {
+        ...state,
+        selectedOption: "alternative",
+        alternativeText: nextText,
+        alternativeCursorPosition: state.alternativeCursorPosition - 1,
+        hasUserInput: nextText.length > 0,
+      };
+    }
+    case "MOVE_CURSOR_LEFT":
+      return {
+        ...state,
+        alternativeCursorPosition: Math.max(
+          0,
+          state.alternativeCursorPosition - 1,
+        ),
+      };
+    case "MOVE_CURSOR_RIGHT":
+      return {
+        ...state,
+        alternativeCursorPosition: Math.min(
+          state.alternativeText.length,
+          state.alternativeCursorPosition + 1,
+        ),
+      };
+    case "CONFIRM":
+      return { ...state, decision: action.decision };
+    default:
+      return state;
+  }
+}

package/src/reducers/marketplaceAddFormReducer.ts

@@ -0,0 +1,35 @@
+export interface MarketplaceAddFormState {
+  source: string;
+  scopeIndex: number;
+  step: "source" | "scope";
+}
+
+export type MarketplaceAddFormAction =
+  | { type: "SET_SOURCE"; source: string }
+  | { type: "SET_SCOPE_INDEX"; index: number }
+  | { type: "SET_STEP"; step: "source" | "scope" }
+  | { type: "INSERT_CHAR"; text: string }
+  | { type: "DELETE_CHAR" }
+  | { type: "BACK_TO_SOURCE" };
+
+export function marketplaceAddFormReducer(
+  state: MarketplaceAddFormState,
+  action: MarketplaceAddFormAction,
+): MarketplaceAddFormState {
+  switch (action.type) {
+    case "SET_SOURCE":
+      return { ...state, source: action.source };
+    case "SET_SCOPE_INDEX":
+      return { ...state, scopeIndex: action.index };
+    case "SET_STEP":
+      return { ...state, step: action.step };
+    case "INSERT_CHAR":
+      return { ...state, source: state.source + action.text };
+    case "DELETE_CHAR":
+      return { ...state, source: state.source.slice(0, -1) };
+    case "BACK_TO_SOURCE":
+      return { ...state, step: "source" };
+    default:
+      return state;
+  }
+}

package/src/reducers/mcpManagerReducer.ts

@@ -0,0 +1,31 @@
+export interface McpManagerState {
+  selectedIndex: number;
+  viewMode: "list" | "detail";
+}
+
+export type McpManagerAction =
+  | { type: "MOVE_UP"; serverCount: number }
+  | { type: "MOVE_DOWN"; serverCount: number }
+  | { type: "SET_VIEW_MODE"; viewMode: "list" | "detail" };
+
+export function mcpManagerReducer(
+  state: McpManagerState,
+  action: McpManagerAction,
+): McpManagerState {
+  switch (action.type) {
+    case "MOVE_UP":
+      return { ...state, selectedIndex: Math.max(0, state.selectedIndex - 1) };
+    case "MOVE_DOWN":
+      return {
+        ...state,
+        selectedIndex: Math.min(
+          action.serverCount - 1,
+          state.selectedIndex + 1,
+        ),
+      };
+    case "SET_VIEW_MODE":
+      return { ...state, viewMode: action.viewMode };
+    default:
+      return state;
+  }
+}

package/src/reducers/pluginDetailReducer.ts

@@ -0,0 +1,58 @@
+export interface PluginDetailState {
+  selectedScopeIndex: number;
+  selectedActionIndex: number;
+}
+
+export type PluginDetailAction =
+  | { type: "SELECT_SCOPE_INDEX"; index: number }
+  | { type: "SELECT_ACTION_INDEX"; index: number }
+  | { type: "MOVE_SCOPE_UP"; maxIndex: number }
+  | { type: "MOVE_SCOPE_DOWN"; maxIndex: number }
+  | { type: "MOVE_ACTION_UP"; maxIndex: number }
+  | { type: "MOVE_ACTION_DOWN"; maxIndex: number };
+
+export function pluginDetailReducer(
+  state: PluginDetailState,
+  action: PluginDetailAction,
+): PluginDetailState {
+  switch (action.type) {
+    case "SELECT_SCOPE_INDEX":
+      return { ...state, selectedScopeIndex: action.index };
+    case "SELECT_ACTION_INDEX":
+      return { ...state, selectedActionIndex: action.index };
+    case "MOVE_SCOPE_UP":
+      return {
+        ...state,
+        selectedScopeIndex:
+          state.selectedScopeIndex > 0
+            ? state.selectedScopeIndex - 1
+            : action.maxIndex,
+      };
+    case "MOVE_SCOPE_DOWN":
+      return {
+        ...state,
+        selectedScopeIndex:
+          state.selectedScopeIndex < action.maxIndex
+            ? state.selectedScopeIndex + 1
+            : 0,
+      };
+    case "MOVE_ACTION_UP":
+      return {
+        ...state,
+        selectedActionIndex:
+          state.selectedActionIndex > 0
+            ? state.selectedActionIndex - 1
+            : action.maxIndex,
+      };
+    case "MOVE_ACTION_DOWN":
+      return {
+        ...state,
+        selectedActionIndex:
+          state.selectedActionIndex < action.maxIndex
+            ? state.selectedActionIndex + 1
+            : 0,
+      };
+    default:
+      return state;
+  }
+}

package/src/reducers/questionReducer.ts

@@ -0,0 +1,251 @@
+import type { PermissionDecision } from "wave-agent-sdk";
+
+export interface QuestionSavedState {
+  selectedOptionIndex: number;
+  selectedOptionIndices: Set<number>;
+  otherText: string;
+  otherCursorPosition: number;
+}
+
+export interface QuestionState {
+  currentQuestionIndex: number;
+  selectedOptionIndex: number;
+  selectedOptionIndices: Set<number>;
+  userAnswers: Record<string, string>;
+  otherText: string;
+  otherCursorPosition: number;
+  savedStates: Record<number, QuestionSavedState>;
+  decision: PermissionDecision | null;
+}
+
+export type QuestionAction =
+  | { type: "SELECT_OPTION"; index: number }
+  | { type: "MOVE_OPTION_UP"; maxIndex: number }
+  | { type: "MOVE_OPTION_DOWN"; maxIndex: number }
+  | {
+      type: "TOGGLE_MULTI_SELECT";
+      optionsLength: number;
+    }
+  | { type: "CYCLE_QUESTION"; shift: boolean; questionCount: number }
+  | { type: "INSERT_OTHER"; text: string; optionsLength: number }
+  | { type: "DELETE_OTHER"; optionsLength: number }
+  | { type: "MOVE_OTHER_LEFT"; optionsLength: number }
+  | { type: "MOVE_OTHER_RIGHT"; optionsLength: number }
+  | {
+      type: "CONFIRM_ANSWER";
+      currentQuestion: {
+        question: string;
+        options: Array<{ label: string }>;
+        multiSelect?: boolean;
+      };
+      options: Array<{ label: string }>;
+      isMultiSelect: boolean;
+      questions: Array<{
+        question: string;
+        options: Array<{ label: string }>;
+        multiSelect?: boolean;
+      }>;
+    };
+
+function buildAnswerFromSavedState(
+  q: {
+    question: string;
+    options: Array<{ label: string }>;
+    multiSelect?: boolean;
+  },
+  s: QuestionSavedState,
+): string {
+  const opts = [...q.options, { label: "Other" }];
+  let a = "";
+  if (q.multiSelect) {
+    const selectedLabels = Array.from(s.selectedOptionIndices)
+      .filter((i) => i < q.options.length)
+      .map((i) => q.options[i].label);
+    const isOtherChecked = s.selectedOptionIndices.has(opts.length - 1);
+    if (isOtherChecked && s.otherText.trim()) {
+      selectedLabels.push(s.otherText.trim());
+    }
+    a = selectedLabels.join(", ");
+  } else {
+    if (s.selectedOptionIndex === opts.length - 1) {
+      a = s.otherText.trim();
+    } else {
+      a = opts[s.selectedOptionIndex].label;
+    }
+  }
+  return a;
+}
+
+export function questionReducer(
+  state: QuestionState,
+  action: QuestionAction,
+): QuestionState {
+  switch (action.type) {
+    case "SELECT_OPTION":
+      return { ...state, selectedOptionIndex: action.index };
+    case "MOVE_OPTION_UP":
+      return {
+        ...state,
+        selectedOptionIndex: Math.max(0, state.selectedOptionIndex - 1),
+      };
+    case "MOVE_OPTION_DOWN":
+      return {
+        ...state,
+        selectedOptionIndex: Math.min(
+          action.maxIndex,
+          state.selectedOptionIndex + 1,
+        ),
+      };
+    case "TOGGLE_MULTI_SELECT": {
+      const nextIndices = new Set(state.selectedOptionIndices);
+      if (nextIndices.has(state.selectedOptionIndex))
+        nextIndices.delete(state.selectedOptionIndex);
+      else nextIndices.add(state.selectedOptionIndex);
+      return { ...state, selectedOptionIndices: nextIndices };
+    }
+    case "CYCLE_QUESTION": {
+      const direction = action.shift ? -1 : 1;
+      let nextIndex = state.currentQuestionIndex + direction;
+      if (nextIndex < 0) nextIndex = action.questionCount - 1;
+      if (nextIndex >= action.questionCount) nextIndex = 0;
+      if (nextIndex === state.currentQuestionIndex) return state;
+      const savedStates = {
+        ...state.savedStates,
+        [state.currentQuestionIndex]: {
+          selectedOptionIndex: state.selectedOptionIndex,
+          selectedOptionIndices: state.selectedOptionIndices,
+          otherText: state.otherText,
+          otherCursorPosition: state.otherCursorPosition,
+        },
+      };
+      const nextState = savedStates[nextIndex] || {
+        selectedOptionIndex: 0,
+        selectedOptionIndices: new Set<number>(),
+        otherText: "",
+        otherCursorPosition: 0,
+      };
+      return {
+        ...state,
+        currentQuestionIndex: nextIndex,
+        ...nextState,
+        savedStates,
+      };
+    }
+    case "INSERT_OTHER": {
+      if (state.selectedOptionIndex !== action.optionsLength - 1) return state;
+      const newText =
+        state.otherText.slice(0, state.otherCursorPosition) +
+        action.text +
+        state.otherText.slice(state.otherCursorPosition);
+      return {
+        ...state,
+        otherText: newText,
+        otherCursorPosition: state.otherCursorPosition + action.text.length,
+      };
+    }
+    case "DELETE_OTHER":
+      if (state.selectedOptionIndex !== action.optionsLength - 1) return state;
+      if (state.otherCursorPosition > 0) {
+        return {
+          ...state,
+          otherText:
+            state.otherText.slice(0, state.otherCursorPosition - 1) +
+            state.otherText.slice(state.otherCursorPosition),
+          otherCursorPosition: state.otherCursorPosition - 1,
+        };
+      }
+      return state;
+    case "MOVE_OTHER_LEFT":
+      if (state.selectedOptionIndex !== action.optionsLength - 1) return state;
+      return {
+        ...state,
+        otherCursorPosition: Math.max(0, state.otherCursorPosition - 1),
+      };
+    case "MOVE_OTHER_RIGHT":
+      if (state.selectedOptionIndex !== action.optionsLength - 1) return state;
+      return {
+        ...state,
+        otherCursorPosition: Math.min(
+          state.otherText.length,
+          state.otherCursorPosition + 1,
+        ),
+      };
+    case "CONFIRM_ANSWER": {
+      const { currentQuestion: cq, options, isMultiSelect, questions } = action;
+      const isOtherFocused = state.selectedOptionIndex === options.length - 1;
+      let answer = "";
+      if (isMultiSelect) {
+        const selectedLabels = Array.from(state.selectedOptionIndices)
+          .filter((i) => i < cq.options.length)
+          .map((i) => cq.options[i].label);
+        const isOtherChecked = state.selectedOptionIndices.has(
+          options.length - 1,
+        );
+        if (isOtherChecked && state.otherText.trim()) {
+          selectedLabels.push(state.otherText.trim());
+        }
+        answer = selectedLabels.join(", ");
+      } else {
+        if (isOtherFocused) {
+          answer = state.otherText.trim();
+        } else {
+          answer = options[state.selectedOptionIndex].label;
+        }
+      }
+      if (!answer) return state;
+
+      const newAnswers = {
+        ...state.userAnswers,
+        [cq.question]: answer,
+      };
+
+      if (state.currentQuestionIndex < questions.length - 1) {
+        const nextIndex = state.currentQuestionIndex + 1;
+        const savedStates = {
+          ...state.savedStates,
+          [state.currentQuestionIndex]: {
+            selectedOptionIndex: state.selectedOptionIndex,
+            selectedOptionIndices: state.selectedOptionIndices,
+            otherText: state.otherText,
+            otherCursorPosition: state.otherCursorPosition,
+          },
+        };
+        const nextState = savedStates[nextIndex] || {
+          selectedOptionIndex: 0,
+          selectedOptionIndices: new Set<number>(),
+          otherText: "",
+          otherCursorPosition: 0,
+        };
+        return {
+          ...state,
+          currentQuestionIndex: nextIndex,
+          ...nextState,
+          userAnswers: newAnswers,
+          savedStates,
+        };
+      } else {
+        const finalAnswers = { ...newAnswers };
+        for (const [idxStr, s] of Object.entries(state.savedStates)) {
+          const idx = parseInt(idxStr);
+          const q = questions[idx];
+          if (q && !finalAnswers[q.question]) {
+            const a = buildAnswerFromSavedState(q, s);
+            if (a) finalAnswers[q.question] = a;
+          }
+        }
+        const allAnswered = questions.every((q) => finalAnswers[q.question]);
+        if (!allAnswered) return state;
+        return {
+          ...state,
+          userAnswers: finalAnswers,
+          decision: {
+            behavior: "allow",
+            message: JSON.stringify(finalAnswers),
+          },
+        };
+      }
+    }
+    default:
+      return state;
+  }
+}