@stigmer/react 3.1.5 → 3.1.7

package/src/mcp-server/__tests__/StdioSandboxNotice.test.tsx

@@ -0,0 +1,71 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+import type { ReactNode } from "react";
+import type { McpServerSpec } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/spec_pb";
+import { DeploymentModeContext } from "../../deployment-mode";
+import { StdioSandboxNotice, isStdioInCloud } from "../StdioSandboxNotice";
+
+type McpServerType = McpServerSpec["serverType"];
+
+const STDIO = { case: "stdio" } as McpServerType;
+const HTTP = { case: "http" } as McpServerType;
+const UNSET = { case: undefined } as McpServerType;
+
+afterEach(cleanup);
+
+describe("isStdioInCloud", () => {
+  it("is true only for stdio transport in cloud mode", () => {
+    expect(isStdioInCloud("cloud", STDIO)).toBe(true);
+  });
+
+  it("is false for stdio transport in local mode", () => {
+    expect(isStdioInCloud("local", STDIO)).toBe(false);
+  });
+
+  it("is false for http transport in cloud mode", () => {
+    expect(isStdioInCloud("cloud", HTTP)).toBe(false);
+  });
+
+  it("is false when the transport oneof is unset", () => {
+    expect(isStdioInCloud("cloud", UNSET)).toBe(false);
+  });
+
+  it("is false when serverType is undefined", () => {
+    expect(isStdioInCloud("cloud", undefined)).toBe(false);
+  });
+});
+
+function withMode(mode: "cloud" | "local", children: ReactNode) {
+  return (
+    <DeploymentModeContext.Provider value={mode}>
+      {children}
+    </DeploymentModeContext.Provider>
+  );
+}
+
+describe("StdioSandboxNotice", () => {
+  it("renders the sandbox-isolation caveat for stdio in cloud", () => {
+    render(withMode("cloud", <StdioSandboxNotice serverType={STDIO} />));
+    expect(screen.getByRole("status")).toBeTruthy();
+    expect(screen.getByText(/isolated cloud sandbox/i)).toBeTruthy();
+  });
+
+  it("does not suggest the CLI (avoids inaccurate guidance)", () => {
+    render(withMode("cloud", <StdioSandboxNotice serverType={STDIO} />));
+    expect(screen.queryByText(/stigmer connect/i)).toBeNull();
+  });
+
+  it("renders nothing for http servers in cloud", () => {
+    const { container } = render(
+      withMode("cloud", <StdioSandboxNotice serverType={HTTP} />),
+    );
+    expect(container.firstChild).toBeNull();
+  });
+
+  it("renders nothing for stdio servers in local mode", () => {
+    const { container } = render(
+      withMode("local", <StdioSandboxNotice serverType={STDIO} />),
+    );
+    expect(container.firstChild).toBeNull();
+  });
+});

package/src/mcp-server/useMcpServerCredentials.ts

@@ -153,6 +153,18 @@ export interface UseMcpServerCredentialsReturn {
    * link (when vendor approval is granted).
    */
   readonly canBringOwnApp: boolean;
+  /**
+   * `true` when a manually-entered static token is a valid way to
+   * authenticate this server. `false` for `oauth_only` servers whose
+   * hosted endpoint rejects static tokens (`spec.auth.oauth_only`), where
+   * OAuth is the sole credential path.
+   *
+   * Connect surfaces use this to decide whether to offer the "enter token
+   * manually" affordance — offering it on an `oauth_only` server would send
+   * the user down a path that cannot succeed. Always `true` for manual-only
+   * and PAT-capable servers.
+   */
+  readonly manualEntrySupported: boolean;
   /**
    * When `true`, the user has opted to bypass OAuth and enter the
    * `target_env_var` token manually. In this state:
@@ -251,6 +263,14 @@ export function useMcpServerCredentials(
   const oauthTargetEnvVar = auth?.targetEnvVar || null;
   const tokenLifetimeHint = auth?.tokenLifetimeHint || null;
 
+  // A static token is a valid credential for every server except those whose
+  // endpoint declares it rejects them (`oauth_only`). This is the single source
+  // of truth the connect surfaces consult before offering manual entry.
+  const manualEntrySupported = !auth?.oauthOnly;
+  // Defensively force manual override off for oauth_only servers so no surface
+  // can enter a dead-end manual-entry state, even if a stale toggle is set.
+  const effectiveManualOverride = manualOverride && manualEntrySupported;
+
   const oauthStatus = mcpServer?.status?.oauthStatus;
   const isVendorApprovalPending =
     authMode === "oauth" &&
@@ -298,15 +318,15 @@ export function useMcpServerCredentials(
   );
 
   const missingVariables = useMemo(() => {
-    if (!oauthTargetEnvVar || manualOverride) return requiredMissing;
+    if (!oauthTargetEnvVar || effectiveManualOverride) return requiredMissing;
     return requiredMissing.filter((v) => v.key !== oauthTargetEnvVar);
-  }, [requiredMissing, oauthTargetEnvVar, manualOverride]);
+  }, [requiredMissing, oauthTargetEnvVar, effectiveManualOverride]);
 
   const isReady =
     !personalEnv.isLoading &&
     !grantStatus.isLoading &&
     missingVariables.length === 0 &&
-    (authMode === "manual" || manualOverride || isOAuthConnected);
+    (authMode === "manual" || effectiveManualOverride || isOAuthConnected);
 
   const saveCredentials = useCallback(
     async (values: Record<string, EnvVarInput>): Promise<void> => {
@@ -335,6 +355,7 @@ export function useMcpServerCredentials(
     effectiveOAuthSource,
     isOrgOAuthApp,
     canBringOwnApp,
+    manualEntrySupported,
     missingVariables,
     isReady,
     isLoading: personalEnv.isLoading || grantStatus.isLoading,
@@ -342,7 +363,7 @@ export function useMcpServerCredentials(
     saveCredentials,
     isSaving: personalEnv.isMutating,
     refetch,
-    manualOverride,
+    manualOverride: effectiveManualOverride,
     setManualOverride,
   };
 }

package/src/session/SessionViewer.tsx

@@ -24,6 +24,7 @@ import { SelectionStore } from "../internal/store/selection-store.js";
 import { useWorkspaceEditors, isVirtualEntryId } from "../internal/store/index.js";
 import { ThreadSelectionContext } from "../execution/ThreadSelectionContext.js";
 import { useSelectedThreadItem } from "../execution/useThreadSelection.js";
+import { isTerminalPhase } from "../execution/execution-phases.js";
 import { MessageThread, type MessageThreadSlots } from "../execution/MessageThread.js";
 import { FileChangeProgressBar } from "../execution/FileChangeProgressBar.js";
 import { FileReviewDock } from "../execution/FileReviewDock.js";
@@ -1126,6 +1127,18 @@ function SessionPanelRegion({
     ],
   );
 
+  // Cloud sessions with a git workspace push approved changes back to a
+  // branch/PR, so the Changes facet is offered from the start with an honest
+  // pre-push state. Deliberately NOT for local sessions: local mode edits the
+  // user's own working tree and never writes back (the runner configures no
+  // push credentials there) — promising a PR would be a lie.
+  const expectsWriteBack =
+    flow.executionTarget === "cloud" &&
+    flow.workspace.entries.some((entry) => entry.type === "git");
+  const displayPhase =
+    flow.displayExecution?.status?.phase ??
+    ExecutionPhase.EXECUTION_PHASE_UNSPECIFIED;
+
   // The session facets (Config / Changes / Artifacts / Usage / Inspect) as
   // injected rail views — the full inspector feature set inside one panel.
   const railViews = useSessionRailViews({
@@ -1138,6 +1151,8 @@ function SessionPanelRegion({
     onOpenPlan,
     onOpenArtifact,
     onActivateArtifact,
+    expectsWriteBack,
+    changesSettled: isTerminalPhase(displayPhase),
   });
 
   // Explorer-footer folder attach (desktop only — needs the native picker).

package/src/session/__tests__/useSessionRailViews.test.tsx

@@ -80,6 +80,18 @@ describe("useSessionRailViews", () => {
     ]);
   });
 
+  it("offers Changes pre-push when a write-back is expected, without a zero badge", () => {
+    const { result } = renderViews({ expectsWriteBack: true });
+    const changes = result.current.find((v) => v.id === "changes");
+    expect(changes, "cloud git sessions get the facet before any push").toBeTruthy();
+    expect(changes?.badge).toBeUndefined();
+  });
+
+  it("hides Changes when no write-back exists and none is expected", () => {
+    const { result } = renderViews({ expectsWriteBack: false });
+    expect(result.current.some((v) => v.id === "changes")).toBe(false);
+  });
+
   it("surfaces Artifacts with a count badge", () => {
     artifactsState.hasArtifacts = true;
     artifactsState.artifactCount = 4;

package/src/session/facets/ChangesTab.tsx

@@ -6,20 +6,42 @@ import { WriteBackCard } from "../../execution/WriteBackCard.js";
 
 export interface ChangesTabProps {
   readonly executions: readonly AgentExecution[];
+  /**
+   * Whether this session is expected to push its approved changes back to a
+   * git remote — a CLOUD session with at least one git workspace entry (local
+   * sessions edit the user's own working tree and never write back). Enables
+   * the pre-write-back states below, so the facet answers "where does my work
+   * go?" before any push exists. Defaults to `false`: a bare `ChangesTab`
+   * stays the pure write-back list it always was.
+   */
+  readonly expectsWriteBack?: boolean;
+  /**
+   * Whether the session's latest execution is settled (terminal). Selects
+   * between the pre-write-back states: a live turn shows the "will be pushed
+   * here" promise, a settled one shows the honest "nothing pushed yet".
+   * Only consulted when {@link expectsWriteBack} is set and no write-back
+   * exists yet.
+   */
+  readonly isSettled?: boolean;
 }
 
 /**
- * Changes facet for the session panel — the session's git write-backs
- * (branch/commit/PR), one `WriteBackCard` per entry.
+ * Changes facet for the session panel — the definitive "where did my work go"
+ * surface: the session's git write-backs (branch/commit/PR), one
+ * `WriteBackCard` per entry, with honest pre-push states for cloud git
+ * sessions whose write-back hasn't happened yet.
  *
  * Local file changes deliberately do NOT render here: they live in the
  * transcript, where each stamped edit row shows its diff in place and the
  * per-turn decision bar carries the review controls and file list
- * (`FileReviewCard`). Duplicating them in a side panel gave the same change a
- * third rendering with no added authority. The facet therefore only surfaces
- * once a write-back exists (see `useSessionRailViews`).
+ * (`FileReviewCard`). This facet is exclusively the git OUTCOME surface —
+ * what was reviewed there lands here as a branch and pull request.
  */
-export function ChangesTab({ executions }: ChangesTabProps) {
+export function ChangesTab({
+  executions,
+  expectsWriteBack = false,
+  isSettled = false,
+}: ChangesTabProps) {
   const { writeBacks, hasWriteBacks } = useSessionWriteBacks(executions);
 
   if (hasWriteBacks) {
@@ -34,6 +56,21 @@ export function ChangesTab({ executions }: ChangesTabProps) {
     );
   }
 
+  if (expectsWriteBack) {
+    return (
+      <div className="flex flex-col items-center justify-center px-4 py-8 text-center">
+        <p className="text-xs text-muted-foreground">
+          {isSettled
+            ? "No changes have been pushed yet. When the agent changes files " +
+              "and you approve them, they are pushed to a branch and pull " +
+              "request here."
+            : "Changes stay in the session workspace while you review them. " +
+              "Approved changes are pushed to a branch and pull request here."}
+        </p>
+      </div>
+    );
+  }
+
   return (
     <div className="flex flex-col items-center justify-center px-4 py-8 text-center">
       <p className="text-xs text-muted-foreground">

package/src/session/facets/__tests__/ChangesTab.test.tsx

@@ -35,4 +35,27 @@ describe("ChangesTab", () => {
     expect(screen.getByText(/no changes yet/i)).toBeTruthy();
     expect(screen.getByText(/pull requests/i)).toBeTruthy();
   });
+
+  // Pre-push states for a session expected to write back (cloud + git):
+  // live turns promise where approved work will land; a settled execution
+  // reports honestly that nothing was pushed.
+  it("renders the in-review promise while a write-back is expected and the session is live", () => {
+    render(<ChangesTab executions={[]} expectsWriteBack isSettled={false} />);
+    expect(screen.getByText(/stay in the session workspace/i)).toBeTruthy();
+    expect(screen.getByText(/pushed to a branch and pull request here/i)).toBeTruthy();
+  });
+
+  it("renders the nothing-pushed state when expected but the execution settled without a push", () => {
+    render(<ChangesTab executions={[]} expectsWriteBack isSettled />);
+    expect(screen.getByText(/no changes have been pushed yet/i)).toBeTruthy();
+  });
+
+  it("write-backs take precedence over the pre-push states", () => {
+    writeBacksReturn.writeBacks = [{ writeBack: { workspaceEntryName: "w1" } }];
+    writeBacksReturn.hasWriteBacks = true;
+
+    render(<ChangesTab executions={[]} expectsWriteBack />);
+    expect(screen.getByTestId("write-back-card")).toBeTruthy();
+    expect(screen.queryByText(/no changes/i)).toBeNull();
+  });
 });

package/src/session/useSessionRailViews.tsx

@@ -54,6 +54,21 @@ export interface UseSessionRailViewsOptions {
    * @default true
    */
   readonly includeExecutionFacets?: boolean;
+  /**
+   * Whether the session is expected to push approved changes to a git remote
+   * (a cloud session with git workspace entries). When `true` the Changes
+   * facet is offered from the start — with an honest pre-push state — instead
+   * of only materializing once a write-back exists, so "where does my work
+   * go?" always has an answer. See {@link ChangesTabProps.expectsWriteBack}.
+   * @default false
+   */
+  readonly expectsWriteBack?: boolean;
+  /**
+   * Whether the session's latest execution is settled (terminal) — forwarded
+   * to the Changes facet's pre-push states. See {@link ChangesTabProps.isSettled}.
+   * @default false
+   */
+  readonly changesSettled?: boolean;
 }
 
 /**
@@ -77,6 +92,8 @@ export function useSessionRailViews({
   onOpenArtifact,
   onActivateArtifact,
   includeExecutionFacets = true,
+  expectsWriteBack = false,
+  changesSettled = false,
 }: UseSessionRailViewsOptions): readonly SurfaceRailView[] {
   const { hasWriteBacks, writeBackCount } = useSessionWriteBacks(allExecutions);
   const { hasArtifacts, artifactCount } = useSessionArtifacts(allExecutions);
@@ -94,13 +111,22 @@ export function useSessionRailViews({
     }
 
     if (includeExecutionFacets) {
-      if (hasWriteBacks) {
+      // Offered when a write-back exists OR the session is expected to
+      // produce one — the facet then carries an honest pre-push state
+      // instead of being invisible until the first push.
+      if (hasWriteBacks || expectsWriteBack) {
         views.push({
           id: "changes",
           label: "Changes",
           icon: <ChangesIcon />,
-          badge: writeBackCount,
-          content: <ChangesTab executions={allExecutions} />,
+          badge: writeBackCount > 0 ? writeBackCount : undefined,
+          content: (
+            <ChangesTab
+              executions={allExecutions}
+              expectsWriteBack={expectsWriteBack}
+              isSettled={changesSettled}
+            />
+          ),
         });
       }
 
@@ -145,6 +171,8 @@ export function useSessionRailViews({
   }, [
     sessionConfig,
     includeExecutionFacets,
+    expectsWriteBack,
+    changesSettled,
     hasWriteBacks,
     writeBackCount,
     hasArtifacts,

package/src/workflow/picker/__tests__/recents.test.ts

@@ -81,10 +81,10 @@ describe("TaskKindRecentsStore", () => {
 
   it("filters out invalid entries from localStorage", () => {
     const data = [
-      { kind: "valid_kind", timestamp: Date.now() },
-      { kind: 123, timestamp: Date.now() }, // invalid: kind is not string
-      { timestamp: Date.now() }, // invalid: missing kind
-      { kind: "another_valid", timestamp: Date.now() },
+      { kind: "valid_kind", timestamp: 2 },
+      { kind: 123, timestamp: 3 }, // invalid: kind is not string
+      { timestamp: 4 }, // invalid: missing kind
+      { kind: "another_valid", timestamp: 1 },
     ];
     globalThis.localStorage.setItem(TEST_KEY, JSON.stringify(data));