@omercnet/paseo-agent-crew 0.3.0-next.133.1 → 0.3.0-next.137.1

package/README.md

@@ -20,6 +20,16 @@ that no private organization names remained in the rendered page.
 
 ![Agent Crew nudge confirmation](https://raw.githubusercontent.com/omercnet/paseo-plugins/main/agent-crew/docs/images/agent-crew-action.png)
 
+## Auto open
+
+When enabled in the plugin settings screen, Agent Crew opens the Explorer tab once for each new workspace observed on that host.
+
+- Default: off.
+- Existing workspaces are not opened when the setting is enabled.
+- Disabling stops queued and future opens. Re-enabling resumes observation for workspaces created or updated afterward.
+- Workspace claims are remembered on the daemon so reconnects and reloads do not reopen a workspace.
+- A failed claim batch is retried once after two seconds, then dropped with a logged error.
+
 ## What it shows
 
 - Every non-archived managed agent in the current workspace, organized into orchestration trees.

package/client/auto-open.ts

@@ -0,0 +1,211 @@
+import type { PluginClientContext } from "@getpaseo/plugin/client";
+import { claimOpenedWorkspaces, MAX_AUTO_OPEN_CLAIM_BATCH } from "../shared/auto-open";
+import {
+  agentCrewSettingsRpc,
+  agentCrewSettingsSchema,
+  DEFAULT_AUTO_OPEN_EXPLORER,
+} from "../shared/settings";
+
+const FLUSH_DELAY_MS = 400;
+const RETRY_DELAY_MS = 2000;
+const PAGE_LIMIT = 200;
+const SETTINGS_POLL_MS = 15_000;
+
+type ClaimJob = {
+  workspaceIds: string[];
+  retried: boolean;
+};
+
+type AutoOpenManager = {
+  setEnabled(enabled: boolean): void;
+  dispose(): void;
+};
+
+async function listWorkspaceIds(paseo: PluginClientContext["paseo"]): Promise<Set<string>> {
+  const workspaceIds = new Set<string>();
+  const seenCursors = new Set<string>();
+  let cursor: string | undefined;
+  while (true) {
+    const result = await paseo.workspaces.list({
+      page: { limit: PAGE_LIMIT, ...(cursor ? { cursor } : {}) },
+    });
+    for (const workspace of result.entries) workspaceIds.add(workspace.id);
+    if (!result.pageInfo.hasMore) return workspaceIds;
+    const nextCursor = result.pageInfo.nextCursor ?? undefined;
+    if (!nextCursor || seenCursors.has(nextCursor)) return workspaceIds;
+    seenCursors.add(nextCursor);
+    cursor = nextCursor;
+  }
+}
+
+function startAutoOpen(client: PluginClientContext): () => void {
+  const pending = new Set<string>();
+  const buffered = new Set<string>();
+  const jobs: ClaimJob[] = [];
+  let known: Set<string> | undefined;
+  let flushTimer: NodeJS.Timeout | undefined;
+  let removeObserver: (() => void) | undefined;
+  let releaseSubscription: (() => Promise<void>) | undefined;
+  let pumping = false;
+  let closed = false;
+
+  function schedule(delayMs: number) {
+    if (closed || pumping || flushTimer) return;
+    flushTimer = setTimeout(() => {
+      flushTimer = undefined;
+      void pump();
+    }, delayMs);
+  }
+
+  function enqueue(workspaceId: string) {
+    if (closed) return;
+    pending.add(workspaceId);
+    schedule(FLUSH_DELAY_MS);
+  }
+
+  function observe(workspaceId: string) {
+    if (!known) {
+      buffered.add(workspaceId);
+      return;
+    }
+    if (known.has(workspaceId)) return;
+    known.add(workspaceId);
+    enqueue(workspaceId);
+  }
+
+  function drainPending() {
+    const workspaceIds = [...pending];
+    pending.clear();
+    for (let index = 0; index < workspaceIds.length; index += MAX_AUTO_OPEN_CLAIM_BATCH) {
+      jobs.push({
+        workspaceIds: workspaceIds.slice(index, index + MAX_AUTO_OPEN_CLAIM_BATCH),
+        retried: false,
+      });
+    }
+  }
+
+  async function pump() {
+    if (closed || pumping) return;
+    pumping = true;
+    drainPending();
+    while (!closed && jobs.length > 0) {
+      const job = jobs.shift();
+      if (!job) break;
+      try {
+        const { claimed } = await client.rpc(claimOpenedWorkspaces, {
+          workspaceIds: job.workspaceIds,
+        });
+        for (const workspaceId of claimed) {
+          try {
+            client.openPanel("crew", { workspaceId, location: "explorer" });
+          } catch (error) {
+            console.error(
+              `Agent Crew auto-open could not open the panel for workspace ${workspaceId}`,
+              error,
+            );
+          }
+        }
+      } catch (error) {
+        console.error("Agent Crew auto-open claim failed", error);
+        if (!job.retried) {
+          jobs.unshift({ ...job, retried: true });
+          pumping = false;
+          schedule(RETRY_DELAY_MS);
+          return;
+        }
+      }
+    }
+    pumping = false;
+    if (!closed && pending.size > 0) schedule(FLUSH_DELAY_MS);
+  }
+
+  void client.paseo.workspaces
+    .list({ subscribe: {} })
+    .then(({ subscription }) => {
+      if (closed) return subscription.release();
+      releaseSubscription = () => subscription.release();
+      removeObserver = subscription.subscribe({
+        snapshot() {},
+        update(message) {
+          if (message.type !== "workspace_update" || message.payload.kind !== "upsert") return;
+          observe(message.payload.workspace.id);
+        },
+      });
+      return listWorkspaceIds(client.paseo).then((workspaceIds) => {
+        if (closed) return;
+        known = workspaceIds;
+        for (const workspaceId of buffered) observe(workspaceId);
+        buffered.clear();
+      });
+    })
+    .catch((error: unknown) => {
+      if (!closed) console.error("Agent Crew auto-open observation failed", error);
+    });
+
+  return () => {
+    closed = true;
+    pending.clear();
+    buffered.clear();
+    jobs.length = 0;
+    clearTimeout(flushTimer);
+    removeObserver?.();
+    void releaseSubscription?.();
+    releaseSubscription = undefined;
+  };
+}
+
+export function createAutoOpenManager(client: PluginClientContext): AutoOpenManager {
+  let enabled = DEFAULT_AUTO_OPEN_EXPLORER;
+  let activeCleanup: (() => void) | undefined;
+  let disposed = false;
+  let refreshRunning = false;
+  let generation = 0;
+  const pollTimer = setInterval(() => {
+    void refreshEnabled();
+  }, SETTINGS_POLL_MS);
+
+  function syncEnabled(nextEnabled: boolean) {
+    if (disposed || nextEnabled === enabled) return;
+    enabled = nextEnabled;
+    activeCleanup?.();
+    activeCleanup = enabled ? startAutoOpen(client) : undefined;
+  }
+
+  async function refreshEnabled() {
+    if (disposed || refreshRunning) return;
+    refreshRunning = true;
+    const requestGeneration = generation;
+    try {
+      const result = await client.rpc(agentCrewSettingsRpc.read, {});
+      if (disposed || requestGeneration !== generation) return;
+      if (result.status !== "ready") {
+        syncEnabled(DEFAULT_AUTO_OPEN_EXPLORER);
+        return;
+      }
+      const parsed = agentCrewSettingsSchema.safeParse(result.values);
+      syncEnabled(parsed.success ? parsed.data.autoOpenExplorer : DEFAULT_AUTO_OPEN_EXPLORER);
+    } catch (error) {
+      if (disposed || requestGeneration !== generation) return;
+      console.error("Agent Crew auto-open settings read failed", error);
+      syncEnabled(DEFAULT_AUTO_OPEN_EXPLORER);
+    } finally {
+      refreshRunning = false;
+    }
+  }
+
+  void refreshEnabled();
+
+  return {
+    setEnabled(nextEnabled) {
+      generation += 1;
+      syncEnabled(nextEnabled);
+    },
+    dispose() {
+      disposed = true;
+      generation += 1;
+      clearInterval(pollTimer);
+      activeCleanup?.();
+      activeCleanup = undefined;
+    },
+  };
+}

package/client/settings-screen.tsx

@@ -0,0 +1,78 @@
+import { type PluginSurfaceProps, useSettings } from "@getpaseo/plugin/client";
+import {
+  SettingsAction,
+  SettingsCard,
+  SettingsSection,
+  SettingsSwitch,
+} from "@getpaseo/plugin/client/ui";
+import { useMemo } from "react";
+import { Text } from "react-native";
+import { agentCrewSettings } from "../shared/settings";
+
+export interface AgentCrewSettingsScreenProps extends PluginSurfaceProps {
+  onAutoOpenChange(enabled: boolean): void;
+}
+
+export function AgentCrewSettingsScreen({ onAutoOpenChange, theme }: AgentCrewSettingsScreenProps) {
+  const settings = useSettings(agentCrewSettings);
+  const styles = useMemo(
+    () => ({
+      text: { color: theme.colors.foreground },
+      error: { color: theme.colors.statusDanger },
+    }),
+    [theme],
+  );
+
+  if (settings.status === "loading") return <Text style={styles.text}>Loading settings…</Text>;
+  if (settings.status !== "ready") {
+    return (
+      <SettingsSection title="Agent Crew settings">
+        <Text accessibilityRole="alert" style={styles.error}>
+          {settings.error}
+        </Text>
+        <SettingsCard>
+          <SettingsAction
+            label="Read settings again"
+            actionLabel="Reload"
+            onPress={settings.reload}
+          />
+          {settings.status === "invalid" ? (
+            <SettingsAction
+              label="Replace invalid data with defaults"
+              actionLabel="Reset"
+              disabled={settings.saving}
+              onPress={async () => {
+                if (await settings.reset()) onAutoOpenChange(false);
+              }}
+            />
+          ) : null}
+        </SettingsCard>
+      </SettingsSection>
+    );
+  }
+
+  return (
+    <SettingsSection title="Explorer">
+      <SettingsCard>
+        <SettingsSwitch
+          label="Open Agent Crew automatically"
+          hint="Open the Explorer panel once for each new workspace observed while enabled"
+          value={settings.values.autoOpenExplorer}
+          disabled={settings.saving}
+          onValueChange={async (autoOpenExplorer) => {
+            const saved = await settings.save(
+              { ...settings.values, autoOpenExplorer },
+              settings.revision,
+            );
+            if (saved) onAutoOpenChange(autoOpenExplorer);
+          }}
+        />
+      </SettingsCard>
+      {settings.saveError ? (
+        <Text accessibilityRole="alert" style={styles.error}>
+          {settings.saveError}
+        </Text>
+      ) : null}
+    </SettingsSection>
+  );
+}

package/index.client.tsx

@@ -1,8 +1,23 @@
-import type { PluginClientContext } from "@getpaseo/plugin/client";
+import type { PluginClientContext, PluginSurfaceProps } from "@getpaseo/plugin/client";
+import { createAutoOpenManager } from "./client/auto-open";
 import { AgentCrew } from "./client/main";
+import { AgentCrewSettingsScreen } from "./client/settings-screen";
+import { agentCrewSettings } from "./shared/settings";
 
 export default function contribute(client: PluginClientContext) {
-  client.addWorkspacePanel({
+  const autoOpen = createAutoOpenManager(client);
+
+  function SettingsSurface(props: PluginSurfaceProps) {
+    return <AgentCrewSettingsScreen {...props} onAutoOpenChange={autoOpen.setEnabled} />;
+  }
+
+  const removeSettings = client.addSettingsScreen({
+    id: agentCrewSettings.id,
+    title: "Agent Crew settings",
+    icon: "Settings",
+    Component: SettingsSurface,
+  });
+  const removeWorkspacePanel = client.addWorkspacePanel({
     id: "crew",
     title: "Agent Crew",
     icon: "Network",
@@ -10,7 +25,7 @@ export default function contribute(client: PluginClientContext) {
     locations: ["explorer"],
     Component: AgentCrew,
   });
-  client.addCommandCenterItem({
+  const removeOpenCrew = client.addCommandCenterItem({
     id: "open-crew",
     title: "Open Agent Crew",
     icon: "Network",
@@ -20,5 +35,11 @@ export default function contribute(client: PluginClientContext) {
       openPanel("crew", { location: "explorer" });
     },
   });
-  return () => {};
+
+  return () => {
+    removeOpenCrew();
+    removeWorkspacePanel();
+    removeSettings();
+    autoOpen.dispose();
+  };
 }

package/index.server.ts

@@ -0,0 +1,10 @@
+import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { createAutoOpenClaimHandler } from "./server/auto-open";
+import { claimOpenedWorkspaces } from "./shared/auto-open";
+import { agentCrewSettings } from "./shared/settings";
+
+export default function contribute(server: PluginServerContext) {
+  server.registerSettings(agentCrewSettings);
+  server.handle(claimOpenedWorkspaces, createAutoOpenClaimHandler());
+  return () => {};
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-agent-crew",
-  "version": "0.3.0-next.133.1",
+  "version": "0.3.0-next.137.1",
   "type": "module",
   "description": "A Paseo Explorer panel for visualizing and controlling every managed agent crew in a workspace.",
   "license": "MIT",
@@ -32,7 +32,10 @@
     "LICENSE",
     "README.md",
     "client",
+    "shared",
+    "server",
     "index.client.tsx",
+    "index.server.ts",
     "paseo-plugin.json"
   ],
   "scripts": {

package/server/auto-open.ts

@@ -0,0 +1,86 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import type { RpcInput } from "@getpaseo/plugin";
+import { type claimOpenedWorkspaces, claimUnclaimedWorkspaces } from "../shared/auto-open";
+
+export interface AutoOpenStore {
+  load(): Promise<ReadonlySet<string>>;
+  persist(next: ReadonlySet<string>): Promise<void>;
+}
+
+export function autoOpenDataFilePath(): string {
+  const home = process.env.PASEO_HOME ?? join(homedir(), ".paseo");
+  return join(home, "plugin-data", "agent-crew", "auto-open.json");
+}
+
+function parseWorkspaceIds(raw: string): Set<string> {
+  const parsed: unknown = JSON.parse(raw);
+  if (!Array.isArray(parsed)) {
+    throw new Error("auto-open store must contain an array of workspace IDs");
+  }
+  const values = new Set<string>();
+  for (const value of parsed) {
+    if (typeof value !== "string" || value.length === 0) {
+      throw new Error("auto-open store must contain only non-empty string workspace IDs");
+    }
+    values.add(value);
+  }
+  return values;
+}
+
+export function createFileAutoOpenStore(filePath: string = autoOpenDataFilePath()): AutoOpenStore {
+  return {
+    async load() {
+      let raw: string;
+      try {
+        raw = await readFile(filePath, "utf8");
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === "ENOENT") return new Set();
+        throw error;
+      }
+      try {
+        return parseWorkspaceIds(raw);
+      } catch (error) {
+        console.error("Agent Crew auto-open store load failed", { filePath, error });
+        throw error;
+      }
+    },
+    async persist(next) {
+      await mkdir(dirname(filePath), { recursive: true });
+      const temporary = `${filePath}.${process.pid}.tmp`;
+      await writeFile(temporary, `${JSON.stringify([...next], null, 2)}\n`, "utf8");
+      await rename(temporary, filePath);
+    },
+  };
+}
+
+export function createMemoryAutoOpenStore(initial: Iterable<string> = []): AutoOpenStore {
+  let values = new Set(initial);
+  return {
+    async load() {
+      return new Set(values);
+    },
+    async persist(next) {
+      values = new Set(next);
+    },
+  };
+}
+
+export function createAutoOpenClaimHandler(store: AutoOpenStore = createFileAutoOpenStore()) {
+  let chain: Promise<unknown> = Promise.resolve();
+  return async function handleClaim({ workspaceIds }: RpcInput<typeof claimOpenedWorkspaces>) {
+    const run = async () => {
+      const opened = await store.load();
+      const claimed = claimUnclaimedWorkspaces(opened, workspaceIds);
+      if (claimed.length === 0) return { claimed };
+      const next = new Set(opened);
+      for (const workspaceId of claimed) next.add(workspaceId);
+      await store.persist(next);
+      return { claimed };
+    };
+    const result = chain.then(run, run);
+    chain = result.catch(() => {});
+    return result;
+  };
+}

package/shared/auto-open.ts

@@ -0,0 +1,24 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+export const MAX_AUTO_OPEN_CLAIM_BATCH = 1000;
+
+export const claimOpenedWorkspaces = defineRpc({
+  name: "agent-crew.auto-open.claim",
+  input: z.object({
+    workspaceIds: z.array(z.string().min(1)).min(1).max(MAX_AUTO_OPEN_CLAIM_BATCH),
+  }),
+  output: z.object({ claimed: z.array(z.string()) }),
+});
+
+export function claimUnclaimedWorkspaces(
+  opened: ReadonlySet<string>,
+  candidates: readonly string[],
+): string[] {
+  const claimed: string[] = [];
+  for (const workspaceId of candidates) {
+    if (opened.has(workspaceId) || claimed.includes(workspaceId)) continue;
+    claimed.push(workspaceId);
+  }
+  return claimed;
+}

package/shared/settings.ts

@@ -0,0 +1,17 @@
+import { defineSettings, settingsRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+export const DEFAULT_AUTO_OPEN_EXPLORER = false;
+
+export const agentCrewSettingsSchema = z.object({
+  autoOpenExplorer: z.boolean().default(DEFAULT_AUTO_OPEN_EXPLORER),
+});
+
+export const agentCrewSettings = defineSettings({
+  id: "agent-crew-preferences",
+  scope: "host",
+  version: 1,
+  schema: agentCrewSettingsSchema,
+});
+
+export const agentCrewSettingsRpc = settingsRpc(agentCrewSettings.id);