@stigmer/react 3.1.7 → 3.1.9

package/src/environment/EnvironmentPicker.tsx

@@ -16,6 +16,21 @@ export interface EnvironmentPickerProps {
   readonly onChange: (refs: ResourceRef[]) => void;
   /** Disable all interactions. */
   readonly disabled?: boolean;
+  /**
+   * Restrict which environments are offered in the dropdown. Already
+   * selected references remain listed (and removable) even when they no
+   * longer pass the filter — hiding them would strand the binding.
+   * When omitted, every environment in the org is offered (the default
+   * behavior of every existing caller).
+   *
+   * @example Only org-shared environments (guest-usable credentials):
+   * ```tsx
+   * filterEnvironment={(env) =>
+   *   env.metadata?.visibility === ApiResourceVisibility.visibility_org
+   * }
+   * ```
+   */
+  readonly filterEnvironment?: (environment: Environment) => boolean;
   /** Additional CSS class names for the root container. */
   readonly className?: string;
 }
@@ -44,6 +59,7 @@ export function EnvironmentPicker({
   value,
   onChange,
   disabled = false,
+  filterEnvironment,
   className,
 }: EnvironmentPickerProps) {
   const { environments, isLoading } = useEnvironmentList(org);
@@ -55,8 +71,13 @@ export function EnvironmentPicker({
   );
 
   const availableEnvironments = useMemo(
-    () => environments.filter((env) => !selectedSlugs.has(env.metadata?.slug ?? "")),
-    [environments, selectedSlugs],
+    () =>
+      environments.filter(
+        (env) =>
+          !selectedSlugs.has(env.metadata?.slug ?? "") &&
+          (filterEnvironment?.(env) ?? true),
+      ),
+    [environments, selectedSlugs, filterEnvironment],
   );
 
   const handleAdd = useCallback(

package/src/environment/EnvironmentVariableEditor.tsx

@@ -12,6 +12,7 @@ import { getUserMessage, type EnvVarInput } from "@stigmer/sdk";
 import type { Environment } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/api_pb";
 import { useStigmer } from "../hooks.js";
 import { toError } from "../internal/toError.js";
+import { PermissionGate } from "../iam-policy/PermissionGate.js";
 import { useUpdateEnvironmentVariables } from "./useUpdateEnvironmentVariables.js";
 import { useRemoveEnvironmentVariables } from "./useRemoveEnvironmentVariables.js";
 import { useRevealSecretValue } from "./useRevealSecretValue.js";
@@ -438,24 +439,33 @@ function VariableRow({
           !readOnly && (
             <div className="flex shrink-0 items-center gap-0.5 opacity-0 transition-opacity group-hover:opacity-100 group-focus-within:opacity-100">
               {variable.isSecret && (
-                <ActionButton
-                  onClick={toggleReveal}
-                  disabled={isRevealing}
-                  label={
-                    revealedValue !== null
-                      ? `Hide ${variable.key}`
-                      : `Reveal ${variable.key}`
-                  }
-                  variant="muted"
+                /* Secret reveal is creator-only (can_read_secrets) at every
+                   visibility level — org sharing never widens it. Hide the
+                   affordance for everyone else instead of offering a button
+                   that is guaranteed to fail (error prevention). */
+                <PermissionGate
+                  resource={{ kind: "environment", id: environmentId }}
+                  relation="can_read_secrets"
                 >
-                  {isRevealing ? (
-                    <SpinnerIcon />
-                  ) : revealedValue !== null ? (
-                    <EyeOffIcon />
-                  ) : (
-                    <EyeIcon />
-                  )}
-                </ActionButton>
+                  <ActionButton
+                    onClick={toggleReveal}
+                    disabled={isRevealing}
+                    label={
+                      revealedValue !== null
+                        ? `Hide ${variable.key}`
+                        : `Reveal ${variable.key}`
+                    }
+                    variant="muted"
+                  >
+                    {isRevealing ? (
+                      <SpinnerIcon />
+                    ) : revealedValue !== null ? (
+                      <EyeOffIcon />
+                    ) : (
+                      <EyeIcon />
+                    )}
+                  </ActionButton>
+                </PermissionGate>
               )}
               <ActionButton
                 onClick={startEdit}

package/src/environment/__tests__/shareRestriction.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { create } from "@bufbuild/protobuf";
+import { EnvironmentSchema } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/api_pb";
+import { isShareRestrictedEnvironment } from "../shareRestriction";
+
+function env(labels: Record<string, string>) {
+  return create(EnvironmentSchema, {
+    metadata: { id: "env_1", org: "acme", labels },
+  });
+}
+
+describe("isShareRestrictedEnvironment", () => {
+  it("restricts personal environments", () => {
+    expect(
+      isShareRestrictedEnvironment(env({ "stigmer.ai/personal": "true" })),
+    ).toBe(true);
+  });
+
+  it("restricts OAuth-managed environments", () => {
+    expect(
+      isShareRestrictedEnvironment(env({ "stigmer.ai/managed": "true" })),
+    ).toBe(true);
+  });
+
+  it("does not restrict ordinary environments", () => {
+    expect(isShareRestrictedEnvironment(env({}))).toBe(false);
+    expect(isShareRestrictedEnvironment(env({ team: "payments" }))).toBe(false);
+  });
+
+  it("only the literal 'true' value restricts", () => {
+    expect(
+      isShareRestrictedEnvironment(env({ "stigmer.ai/personal": "false" })),
+    ).toBe(false);
+  });
+});

package/src/environment/index.ts

@@ -50,3 +50,8 @@ export {
 } from "./systemEnvVars.js";
 export { EnvironmentPicker } from "./EnvironmentPicker.js";
 export type { EnvironmentPickerProps } from "./EnvironmentPicker.js";
+export {
+  PERSONAL_ENV_LABEL,
+  MANAGED_ENV_LABEL,
+  isShareRestrictedEnvironment,
+} from "./shareRestriction.js";

package/src/environment/shareRestriction.ts

@@ -0,0 +1,22 @@
+import type { Environment } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/api_pb";
+
+/** Label marking a user's personal credential-fallback environment. */
+export const PERSONAL_ENV_LABEL = "stigmer.ai/personal";
+
+/** Label marking a system-managed environment holding per-user OAuth tokens. */
+export const MANAGED_ENV_LABEL = "stigmer.ai/managed";
+
+/**
+ * Whether an environment is share-restricted — personal and OAuth-managed
+ * environments must never carry org visibility, so surfaces hide the
+ * sharing control for them entirely (error prevention: the backend
+ * rejects the transition with FAILED_PRECONDITION in both editions).
+ */
+export function isShareRestrictedEnvironment(
+  environment: Environment,
+): boolean {
+  const labels = environment.metadata?.labels ?? {};
+  return (
+    labels[PERSONAL_ENV_LABEL] === "true" || labels[MANAGED_ENV_LABEL] === "true"
+  );
+}

package/src/execution/ToolCallItem.tsx

@@ -454,7 +454,7 @@ const REVIEW_BADGE: Record<FileReviewRowState, ApprovalBadgeInfo> = {
 // Status mapping
 // ---------------------------------------------------------------------------
 
-type ItemStatus = "running" | "waiting" | "failed" | "completed" | "pending";
+type ItemStatus = "running" | "waiting" | "failed" | "completed" | "pending" | "interrupted";
 
 function mapToolCallStatus(toolCall: ToolCall): ItemStatus {
   switch (toolCall.status) {
@@ -474,6 +474,12 @@ function mapToolCallStatus(toolCall: ToolCall): ItemStatus {
     case ToolCallStatus.TOOL_CALL_COMPLETED:
     case ToolCallStatus.TOOL_CALL_SKIPPED:
       return "completed";
+    // Platform-settled when the execution terminalized mid-call (issue #207).
+    // A settled, neutral state: not a spinner (nothing is running), not a
+    // failure (the tool never errored), not a grey pending dot (it will never
+    // start).
+    case ToolCallStatus.TOOL_CALL_INTERRUPTED:
+      return "interrupted";
     default:
       return "pending";
   }
@@ -485,6 +491,7 @@ const STATUS_COLOR: Record<ItemStatus, string> = {
   failed: "text-destructive",
   completed: "text-success",
   pending: "text-muted-foreground",
+  interrupted: "text-muted-foreground",
 };
 
 // ---------------------------------------------------------------------------
@@ -626,6 +633,7 @@ const STATUS_ICON: Record<ItemStatus, () => React.JSX.Element> = {
   failed: XCircleIcon,
   completed: CheckCircleIcon,
   pending: DotIcon,
+  interrupted: SlashCircleIcon,
 };
 
 function SpinnerIcon() {
@@ -671,6 +679,16 @@ function DotIcon() {
   );
 }
 
+/** Slashed circle for an interrupted call — settled, neutral, visibly "cut short". */
+function SlashCircleIcon() {
+  return (
+    <svg width="10" height="10" viewBox="0 0 12 12" fill="none" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round">
+      <circle cx="6" cy="6" r="4.5" />
+      <path d="M2.8 9.2L9.2 2.8" />
+    </svg>
+  );
+}
+
 function InspectIcon() {
   return (
     <svg width="12" height="12" viewBox="0 0 12 12" fill="none" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">

package/src/execution/ToolRunGroup.tsx

@@ -202,6 +202,10 @@ function deriveAggregateStatus(toolCalls: readonly ToolCall[]): AggregateStatus
         break;
       case ToolCallStatus.TOOL_CALL_COMPLETED:
       case ToolCallStatus.TOOL_CALL_SKIPPED:
+      // INTERRUPTED is terminal (platform-settled when the execution
+      // terminalized mid-call, issue #207): the chip must settle, not pin to
+      // "pending" forever.
+      case ToolCallStatus.TOOL_CALL_INTERRUPTED:
         break;
       default:
         allTerminal = false;