@yannelli/paseo-linear-plugin 1.1.0-beta.0 → 1.1.0-beta.2

package/client/settings-fields.tsx

@@ -5,6 +5,7 @@ import { type ReactNode, useCallback, useMemo, useState } from "react";
 import { Text, View } from "react-native";
 import { TEMPLATE_VARIABLES } from "../shared/prompts";
 import type { LinearSettings, linearSettings } from "../shared/settings";
+import { MONO } from "./live-issues";
 import type { Theme } from "./ui";
 
 export type ReadySettings = Extract<
@@ -19,10 +20,14 @@ export function MultilineField(props: {
   value: string;
   placeholder?: string;
   minHeight?: number;
+  error?: string | null;
+  /** Markup, not prose: a monospace font and no autocorrect. */
+  code?: boolean;
   onChange(value: string): void;
 }) {
   const { colors } = props.theme;
   const minHeight = props.minHeight ?? 96;
+  const { code } = props;
   const style = useMemo(
     () => ({
       marginTop: 8,
@@ -36,11 +41,12 @@ export function MultilineField(props: {
       fontSize: 13,
       lineHeight: 19,
       textAlignVertical: "top" as const,
+      ...(code ? { fontFamily: MONO, fontSize: 12 } : {}),
     }),
-    [colors, minHeight],
+    [colors, minHeight, code],
   );
   return (
-    <SettingsRow label={props.label} hint={props.hint}>
+    <SettingsRow label={props.label} hint={props.hint} error={props.error}>
       <TextInput
         value={props.value}
         onChangeText={props.onChange}
@@ -48,7 +54,9 @@ export function MultilineField(props: {
         placeholder={props.placeholder}
         placeholderTextColor={colors.foregroundMuted}
         accessibilityLabel={props.label}
-        autoCapitalize="sentences"
+        autoCapitalize={code ? "none" : "sentences"}
+        autoCorrect={!code}
+        spellCheck={!code}
         style={style}
       />
     </SettingsRow>

package/client/settings-icon.tsx

@@ -0,0 +1,228 @@
+import { type PluginSurfaceProps, useSettings } from "@getpaseo/plugin/client";
+import {
+  SettingsAction,
+  SettingsCard,
+  SettingsInput,
+  SettingsRow,
+  SettingsSection,
+  SettingsSelect,
+  SettingsSwitch,
+} from "@getpaseo/plugin/client/ui";
+import { useCallback, useMemo, useState } from "react";
+import { Platform, Text, View } from "react-native";
+import {
+  HEX_COLOR,
+  type IconPaint,
+  type IconSettings,
+  MAX_SVG_LENGTH,
+  parseIconSvg,
+} from "../shared/custom-icon";
+import { linearSettings } from "../shared/settings";
+import { IconGlyph } from "./plugin-icon";
+import { MultilineField, type ReadySettings, SaveBar, SettingsGate, useSettingsDraft } from "./settings-fields";
+import type { Theme } from "./ui";
+import { canPickFiles, pickTextFile } from "./web";
+
+const PAINT_OPTIONS: readonly { label: string; value: IconPaint }[] = [
+  { label: "Original colors", value: "original" },
+  { label: "Theme color, like Paseo's icons", value: "theme" },
+  { label: "Theme accent", value: "accent" },
+  { label: "Linear indigo, the plugin color", value: "linear" },
+  { label: "Custom color", value: "custom" },
+];
+const PREVIEW_SIZES = [14, 16, 22, 28] as const;
+const SVG_FILES = ".svg,image/svg+xml";
+/** Exports often carry comments and metadata, so the file may be larger than the saved SVG. */
+const MAX_FILE_BYTES = MAX_SVG_LENGTH * 4;
+
+export function IconSettingsScreen({ theme }: PluginSurfaceProps) {
+  const settings = useSettings(linearSettings);
+  const render = useCallback(
+    (ready: ReadySettings) => <IconEditor theme={theme} settings={ready} />,
+    [theme],
+  );
+  return (
+    <SettingsGate theme={theme} title="Icon" settings={settings}>
+      {render}
+    </SettingsGate>
+  );
+}
+
+function IconPreview({ theme, icon }: { theme: Theme; icon: IconSettings }) {
+  const { colors } = theme;
+  const styles = useMemo(
+    () => ({
+      row: { flexDirection: "row" as const, flexWrap: "wrap" as const, alignItems: "center" as const, gap: 14, paddingTop: 8 },
+      pill: {
+        flexDirection: "row" as const,
+        alignItems: "center" as const,
+        gap: 6,
+        height: 26,
+        paddingHorizontal: 10,
+        borderRadius: 13,
+        borderWidth: 1,
+        borderColor: colors.border,
+        backgroundColor: colors.surface1,
+      },
+      label: { color: colors.foreground, fontSize: 12 },
+    }),
+    [colors],
+  );
+  return (
+    <View style={styles.row}>
+      {PREVIEW_SIZES.map((size) => (
+        <IconGlyph key={size} icon={icon} size={size} color={colors.foregroundMuted} theme={theme} />
+      ))}
+      <View style={styles.pill}>
+        <IconGlyph icon={icon} size={14} color={colors.foregroundMuted} theme={theme} />
+        <Text style={styles.label}>ENG-123</Text>
+      </View>
+      <View style={styles.pill}>
+        <IconGlyph icon={icon} size={14} color={colors.foreground} theme={theme} />
+        <Text style={styles.label}>Linear</Text>
+      </View>
+    </View>
+  );
+}
+
+function IconEditor({ theme, settings }: { theme: Theme; settings: ReadySettings }) {
+  const { values, dirty, edit, save, discard } = useSettingsDraft(settings);
+  const icon = values.icon;
+  const [markup, setMarkup] = useState(icon.svg);
+  const [markupError, setMarkupError] = useState<string | null>(null);
+  const [colorError, setColorError] = useState<string | null>(null);
+  const [fileName, setFileName] = useState<string | null>(null);
+  const change = useCallback(
+    (patch: Partial<IconSettings>) => edit((current) => ({ ...current, icon: { ...current.icon, ...patch } })),
+    [edit],
+  );
+  // The draft keeps the last SVG that passed the checks, so the preview never breaks.
+  const applyMarkup = useCallback(
+    (text: string) => {
+      setMarkup(text);
+      if (!text.trim()) {
+        setMarkupError(null);
+        change({ svg: "" });
+        return;
+      }
+      const parsed = parseIconSvg(text);
+      setMarkupError("error" in parsed ? parsed.error : null);
+      if ("svg" in parsed) change({ svg: parsed.svg });
+    },
+    [change],
+  );
+  const choose = useCallback(
+    () =>
+      pickTextFile(SVG_FILES, MAX_FILE_BYTES, (file) => {
+        if ("error" in file) {
+          setMarkupError(file.error);
+          return;
+        }
+        setFileName(file.name);
+        applyMarkup(file.text);
+      }),
+    [applyMarkup],
+  );
+  const useBuiltIn = useCallback(() => {
+    setFileName(null);
+    applyMarkup("");
+  }, [applyMarkup]);
+  const changeColor = useCallback(
+    (text: string) => {
+      const color = text.trim();
+      const valid = HEX_COLOR.test(color);
+      setColorError(valid ? null : "Use a hex color, such as #5E6AD2.");
+      if (valid) change({ color });
+    },
+    [change],
+  );
+  const reset = useCallback(() => {
+    discard();
+    setMarkup(settings.values.icon.svg);
+    setMarkupError(null);
+    setColorError(null);
+    setFileName(null);
+  }, [discard, settings.values.icon.svg]);
+  const native = Platform.OS !== "web";
+  const custom = icon.svg !== "";
+
+  return (
+    <View>
+      <SettingsSection title="Plugin icon">
+        <SettingsCard>
+          <SettingsRow
+            label="Preview"
+            hint={
+              native
+                ? "The iOS and Android apps cannot draw plugin SVG images, so they show the built-in icon in the color you choose."
+                : "Composer pills, the Linear sidebar row, and Linear screens use this icon. Paseo menus and panel tabs keep the built-in icon."
+            }
+          >
+            <IconPreview theme={theme} icon={icon} />
+          </SettingsRow>
+          {canPickFiles ? (
+            <SettingsAction
+              label="SVG file"
+              hint={fileName ? `Loaded ${fileName}. Save to use it.` : "Choose an .svg file. The plugin saves a copy in its settings."}
+              actionLabel="Choose file"
+              onPress={choose}
+            />
+          ) : null}
+          <MultilineField
+            theme={theme}
+            label="SVG markup"
+            hint="Paste SVG markup, or edit it here. Scripts, links to other files, and bitmap images are not allowed. Clear it to use the built-in icon."
+            value={markup}
+            placeholder={'<svg viewBox="0 0 24 24">…</svg>'}
+            error={markupError}
+            code
+            onChange={applyMarkup}
+          />
+          <SettingsAction
+            label="Built-in icon"
+            hint="Remove your SVG and use the Linear board icon."
+            actionLabel="Use built-in"
+            disabled={!custom && markup === ""}
+            onPress={useBuiltIn}
+          />
+        </SettingsCard>
+      </SettingsSection>
+      <SettingsSection title="Color and fill">
+        <SettingsCard>
+          <SettingsSelect
+            label="Color"
+            hint="Original colors keep the SVG as drawn, and currentColor follows Paseo. The other choices paint the whole icon one color."
+            value={icon.paint}
+            options={PAINT_OPTIONS}
+            onValueChange={(paint) => change({ paint })}
+          />
+          {icon.paint === "custom" ? (
+            <SettingsInput
+              label="Custom color"
+              hint="A hex color, such as #5E6AD2 or #5E6AD2CC with transparency."
+              initialValue={icon.color}
+              placeholder="#5E6AD2"
+              error={colorError}
+              onChangeText={changeColor}
+            />
+          ) : null}
+          <SettingsSwitch
+            label="Solid"
+            hint={custom ? "Fill shapes that only have an outline, so line icons show as solid shapes." : "Add your SVG to use this. The built-in icon stays as drawn."}
+            value={icon.solid}
+            disabled={!custom}
+            onValueChange={(solid) => change({ solid })}
+          />
+        </SettingsCard>
+      </SettingsSection>
+      <SaveBar
+        theme={theme}
+        dirty={dirty}
+        saving={settings.saving}
+        error={settings.saveError}
+        onSave={() => void save()}
+        onDiscard={reset}
+      />
+    </View>
+  );
+}

package/client/settings-live.tsx

@@ -26,6 +26,7 @@ const VIEW_OPTIONS: readonly { label: string; value: LiveView }[] = [
   { label: "Graph: issue, files, and agents as connected nodes", value: "graph" },
 ];
 const SAME_AGENT = "";
+const MODEL_DEFAULT = "";
 
 export function LiveSettings({ theme }: PluginSurfaceProps) {
   const settings = useSettings(linearSettings);
@@ -62,6 +63,20 @@ function LiveEditor({ theme, settings }: { theme: Theme; settings: ReadySettings
     }
     return options;
   }, [providers.data, live.exploreProvider]);
+  // Efforts of the chosen model, such as Low to Max, with its default first.
+  const effortOptions = useMemo(() => {
+    const [agentId, ...rest] = live.exploreProvider.split("/");
+    const modelId = rest.join("/");
+    const model = providers.data
+      ?.find((agent) => agent.id === agentId)
+      ?.models.find((entry) => entry.id === modelId);
+    if (!model || model.efforts.length === 0) return null;
+    const fallback = model.efforts.find((effort) => effort.id === model.defaultEffortId);
+    return [
+      { label: fallback ? `Model default: ${fallback.label}` : "Model default", value: MODEL_DEFAULT },
+      ...model.efforts.map((effort) => ({ label: effort.label, value: effort.id })),
+    ];
+  }, [providers.data, live.exploreProvider]);
 
   return (
     <View>
@@ -94,8 +109,17 @@ function LiveEditor({ theme, settings }: { theme: Theme; settings: ReadySettings
             hint="It may only read and search the project folder. A faster, cheaper model is usually enough."
             value={live.exploreProvider}
             options={agentOptions}
-            onValueChange={(exploreProvider) => change({ exploreProvider })}
+            onValueChange={(exploreProvider) => change({ exploreProvider, exploreEffort: MODEL_DEFAULT })}
           />
+          {effortOptions ? (
+            <SettingsSelect
+              label="Explore and setup effort"
+              hint="How much the model thinks before it answers. Lower is faster and uses less of your plan."
+              value={effortOptions.some((option) => option.value === live.exploreEffort) ? live.exploreEffort : MODEL_DEFAULT}
+              options={effortOptions}
+              onValueChange={(exploreEffort) => change({ exploreEffort })}
+            />
+          ) : null}
         </SettingsCard>
       </SettingsSection>
       <SettingsSection title="Linear status sync">

package/client/timeline-card.tsx

@@ -4,6 +4,7 @@ import { useCallback, useMemo } from "react";
 import { Pressable, Text, View } from "react-native";
 import type { IssueCard } from "../shared/linear";
 import { ACTION_LABELS } from "../shared/prompts";
+import { PluginIcon } from "./plugin-icon";
 import { usePressableStyle } from "./ui";
 
 export function IssueCardRow({ item, theme }: PluginTimelineItemProps<IssueCard>) {
@@ -44,7 +45,7 @@ export function IssueCardRow({ item, theme }: PluginTimelineItemProps<IssueCard>
       onPress={open}
       style={style}
     >
-      <Icon name="SquareKanban" size={16} color={colors.foregroundMuted} />
+      <PluginIcon size={16} color={colors.foregroundMuted} theme={theme} />
       <View style={styles.body}>
         <Text numberOfLines={1} style={styles.title}>
           <Text style={styles.identifier}>{`${card.identifier}  `}</Text>

package/client/tool-buttons.tsx

@@ -0,0 +1,68 @@
+import { Icon } from "@getpaseo/plugin/client/react-native";
+import { type ReactNode, useMemo } from "react";
+import { ActivityIndicator, Pressable, View } from "react-native";
+import { type Theme, usePressableStyle } from "./ui";
+
+// Small icon buttons for card toolbars: map actions and the graph's camera. A group draws them
+// in one bordered track, like the Map and Graph switch.
+
+export function ToolGroup({ theme, children }: { theme: Theme; children: ReactNode }) {
+  const { colors } = theme;
+  const style = useMemo(
+    () =>
+      ({
+        flexDirection: "row",
+        alignItems: "center",
+        padding: 2,
+        gap: 2,
+        borderRadius: 8,
+        borderWidth: 1,
+        borderColor: colors.border,
+        backgroundColor: colors.surface1,
+      }) as const,
+    [colors],
+  );
+  return <View style={style}>{children}</View>;
+}
+
+export function ToolButton(props: {
+  theme: Theme;
+  icon: string;
+  /** Read by screen readers and shown as the tooltip on web. */
+  label: string;
+  onPress(): void;
+  /** A toggle that is on. */
+  active?: boolean;
+  disabled?: boolean;
+  busy?: boolean;
+}) {
+  const { colors } = props.theme;
+  const styles = useMemo(() => {
+    const idle = {
+      width: 26,
+      height: 24,
+      borderRadius: 6,
+      alignItems: "center",
+      justifyContent: "center",
+      backgroundColor: props.active ? colors.surface2 : "transparent",
+      opacity: props.disabled ? 0.4 : 1,
+    } as const;
+    return { idle, hover: { ...idle, backgroundColor: colors.surface2 } };
+  }, [colors, props.active, props.disabled]);
+  const pressStyle = usePressableStyle(styles.idle, styles.hover);
+  const color = props.active ? colors.foreground : colors.foregroundMuted;
+  return (
+    <Pressable
+      accessibilityRole="button"
+      accessibilityLabel={props.label}
+      accessibilityState={{ selected: props.active === true, disabled: props.disabled === true }}
+      disabled={props.disabled || props.busy}
+      onPress={props.onPress}
+      hitSlop={4}
+      style={pressStyle}
+      {...({ title: props.label } as object)}
+    >
+      {props.busy ? <ActivityIndicator size="small" color={color} /> : <Icon name={props.icon} size={14} color={color} />}
+    </Pressable>
+  );
+}

package/client/ui.tsx

@@ -1,6 +1,6 @@
 import type { PluginSurfaceProps } from "@getpaseo/plugin/client";
 import { Icon } from "@getpaseo/plugin/client/react-native";
-import { type ReactNode, useCallback, useMemo } from "react";
+import { type ComponentType, type ReactNode, useCallback, useMemo } from "react";
 import {
   ActivityIndicator,
   Pressable,
@@ -15,6 +15,15 @@ export { Avatar, LabelPill, PriorityIcon, priorityMeta, StateIcon } from "./glyp
 
 export type Theme = PluginSurfaceProps["theme"];
 
+/** A Lucide icon name, or a component such as the plugin icon. */
+export type Glyph = string | ComponentType<{ size: number; color: string; theme: Theme }>;
+
+export function GlyphIcon(props: { glyph: Glyph; size: number; color: string; theme: Theme }) {
+  const { glyph: Custom, size, color, theme } = props;
+  if (typeof Custom === "string") return <Icon name={Custom} size={size} color={color} />;
+  return <Custom size={size} color={color} theme={theme} />;
+}
+
 type InteractionState = PressableStateCallbackType & { hovered?: boolean };
 
 export function interactive(state: PressableStateCallbackType): boolean {
@@ -43,7 +52,7 @@ function buttonFill(variant: ButtonVariant, colors: Theme["colors"]): string {
 export interface ButtonProps {
   theme: Theme;
   label: string;
-  icon?: string;
+  icon?: Glyph;
   variant?: ButtonVariant;
   size?: keyof typeof HEIGHT;
   disabled?: boolean;
@@ -52,10 +61,10 @@ export interface ButtonProps {
   onPress(): void;
 }
 
-function ButtonGlyph(props: { busy: boolean; icon?: string; size: number; color: string }) {
+function ButtonGlyph(props: { busy: boolean; icon?: Glyph; size: number; color: string; theme: Theme }) {
   if (props.busy) return <ActivityIndicator size="small" color={props.color} />;
   if (!props.icon) return null;
-  return <Icon name={props.icon} size={props.size} color={props.color} />;
+  return <GlyphIcon glyph={props.icon} size={props.size} color={props.color} theme={props.theme} />;
 }
 
 export function Button({
@@ -103,7 +112,7 @@ export function Button({
       onPress={onPress}
       style={pressStyle}
     >
-      <ButtonGlyph busy={busy === true} icon={icon} size={size === "xs" ? 14 : 16} color={ink} />
+      <ButtonGlyph busy={busy === true} icon={icon} size={size === "xs" ? 14 : 16} color={ink} theme={theme} />
       <Text numberOfLines={1} style={styles.label}>
         {label}
       </Text>
@@ -276,7 +285,7 @@ export function OptionRow(props: {
 
 export function EmptyState(props: {
   theme: Theme;
-  icon: string;
+  icon: Glyph;
   title: string;
   detail?: string;
   tone?: "default" | "danger";
@@ -309,7 +318,7 @@ export function EmptyState(props: {
   );
   return (
     <View style={styles.root}>
-      <Icon name={props.icon} size={28} color={colors.foregroundMuted} />
+      <GlyphIcon glyph={props.icon} size={28} color={colors.foregroundMuted} theme={props.theme} />
       <Text style={styles.title}>{props.title}</Text>
       {props.detail ? <Text style={styles.detail}>{props.detail}</Text> : null}
       {props.children}

package/client/web.ts

@@ -0,0 +1,91 @@
+import { Platform } from "react-native";
+
+// The only module that uses the DOM. React wheel listeners are passive, so they cannot keep
+// the page from scrolling while the wheel zooms the graph. Off the web each export does nothing.
+// The file picker is a hidden file input, because plugins cannot use native document pickers.
+
+interface WheelEventLike {
+  deltaY: number;
+  deltaMode: number;
+  clientX: number;
+  clientY: number;
+  preventDefault(): void;
+}
+
+type WheelListener = (event: WheelEventLike) => void;
+
+interface ElementLike {
+  addEventListener(type: "wheel", listener: WheelListener, options: { passive: boolean }): void;
+  removeEventListener(type: "wheel", listener: WheelListener): void;
+  getBoundingClientRect(): { left: number; top: number };
+}
+
+function isElement(node: unknown): node is ElementLike {
+  if (typeof node !== "object" || node === null) return false;
+  const element = node as Partial<ElementLike>;
+  return typeof element.addEventListener === "function" && typeof element.getBoundingClientRect === "function";
+}
+
+const LINE = 16;
+const PAGE = 400;
+
+/** Calls onWheel with the point under the pointer and a zoom factor. Returns the cleanup. */
+export function listenWheel(
+  node: unknown,
+  onWheel: (point: { x: number; y: number }, factor: number) => void,
+): () => void {
+  if (Platform.OS !== "web" || !isElement(node)) return () => {};
+  const listener: WheelListener = (event) => {
+    event.preventDefault();
+    const rect = node.getBoundingClientRect();
+    const pixels = event.deltaY * (event.deltaMode === 1 ? LINE : event.deltaMode === 2 ? PAGE : 1);
+    onWheel({ x: event.clientX - rect.left, y: event.clientY - rect.top }, Math.exp(-pixels * 0.002));
+  };
+  node.addEventListener("wheel", listener, { passive: false });
+  return () => node.removeEventListener("wheel", listener);
+}
+
+interface FileLike {
+  name: string;
+  size: number;
+  text(): Promise<string>;
+}
+
+interface FileInputLike {
+  type: string;
+  accept: string;
+  files: ArrayLike<FileLike> | null;
+  onchange: (() => void) | null;
+  click(): void;
+}
+
+interface DocumentLike {
+  createElement(tag: "input"): FileInputLike;
+}
+
+/** True where pickTextFile can open a file picker. */
+export const canPickFiles = Platform.OS === "web";
+
+export type PickedFile = { name: string; text: string } | { error: string };
+
+/** Opens the browser file picker and calls onPick with the chosen file. Nothing on cancel. */
+export function pickTextFile(accept: string, maxBytes: number, onPick: (file: PickedFile) => void): void {
+  const document = (globalThis as { document?: DocumentLike }).document;
+  if (!canPickFiles || !document) return;
+  const input = document.createElement("input");
+  input.type = "file";
+  input.accept = accept;
+  input.onchange = () => {
+    const file = input.files?.[0];
+    if (!file) return;
+    if (file.size > maxBytes) {
+      onPick({ error: `${file.name} is too large. Use a file under ${Math.round(maxBytes / 1000)} KB.` });
+      return;
+    }
+    file.text().then(
+      (text) => onPick({ name: file.name, text }),
+      () => onPick({ error: `Paseo could not read ${file.name}.` }),
+    );
+  };
+  input.click();
+}

package/index.client.tsx

@@ -4,7 +4,9 @@ import { openPluginScreen, registerScreen } from "./client/compat";
 import { gateAgentPanel } from "./client/access";
 import { LivePanel } from "./client/live-panel";
 import { contributeComposerPills } from "./client/pill";
+import { PluginIcon } from "./client/plugin-icon";
 import { ConnectionSettings } from "./client/settings-connection";
+import { IconSettingsScreen } from "./client/settings-icon";
 import { LiveSettings } from "./client/settings-live";
 import { ProjectSettings } from "./client/settings-projects";
 import { PromptSettings } from "./client/settings-prompts";
@@ -23,6 +25,7 @@ export default function contribute(client: PluginClientContext) {
     id: SCREEN_ID,
     title: "Linear",
     icon: "SquareKanban",
+    RowIcon: PluginIcon,
     Component: LinearScreen,
   });
   client.addWorkspacePanel({
@@ -58,6 +61,12 @@ export default function contribute(client: PluginClientContext) {
     icon: "Radar",
     Component: LiveSettings,
   });
+  client.addSettingsScreen({
+    id: "icon",
+    title: "Icon",
+    icon: "Shapes",
+    Component: IconSettingsScreen,
+  });
   client.addSettingsScreen({
     id: "projects",
     title: "Projects",

package/index.server.ts

@@ -1,5 +1,7 @@
 import path from "node:path";
 import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { registerAgentHooks } from "./server/agent-hooks";
+import { registerAgentTools } from "./server/agent-tools";
 import { createCredentialStore, defaultCredentialPath } from "./server/credentials";
 import { registerHandlers } from "./server/handlers";
 import { registerInit } from "./server/init";
@@ -24,9 +26,11 @@ export default function contribute(server: PluginServerContext) {
   registerLive(server, { access, maps, launches, readSettings });
   registerSync(server, { access, readSettings });
   registerInit(server, { readSettings });
+  registerAgentHooks(server, dataDirectory);
+  const closeTools = registerAgentTools(server, { access, dataDirectory });
   server.handle(accessRpc, async () => {
     const values = await readSettings();
     return values?.access ?? linearSettings.schema.parse({}).access;
   });
-  return () => {};
+  return closeTools;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yannelli/paseo-linear-plugin",
-  "version": "1.1.0-beta.0",
+  "version": "1.1.0-beta.2",
   "description": "Browse and triage Linear issues in Paseo and start agents from them",
   "license": "Apache-2.0",
   "type": "module",

package/server/agent-hooks.ts

@@ -0,0 +1,37 @@
+import { createHash } from "node:crypto";
+import { mkdir, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { agentHooksRpc, claudeHooks, hookPluginName, IDENTIFIER } from "../shared/agent-hooks";
+
+// Writes one Claude Code plugin folder per issue under the plugin's data folder. A launch passes
+// the folder to Claude with --plugin-dir. The name holds a hash of the hooks, so a later launch
+// never changes the hooks of a running agent. Resumed agents keep using it, so it stays.
+
+async function writeAtomic(file: string, text: string) {
+  const temporary = `${file}.${process.pid}.tmp`;
+  await writeFile(temporary, text, { mode: 0o600 });
+  await rename(temporary, file);
+}
+
+export function registerAgentHooks(server: PluginServerContext, dataDirectory: string) {
+  server.handle(agentHooksRpc, async ({ issue, guidance }) => {
+    // The hooks run printf in a POSIX shell, which Windows hosts do not have.
+    if (process.platform === "win32" || !IDENTIFIER.test(issue.identifier)) return { pluginDir: null };
+    const hooks = claudeHooks(issue, guidance);
+    if (!hooks) return { pluginDir: null };
+    const text = `${JSON.stringify(hooks, null, 2)}\n`;
+    const hash = createHash("sha256").update(text).digest("hex").slice(0, 12);
+    const root = path.join(dataDirectory, "claude-hooks", `${issue.identifier.toUpperCase()}-${hash}`);
+    await mkdir(path.join(root, ".claude-plugin"), { recursive: true, mode: 0o700 });
+    await mkdir(path.join(root, "hooks"), { recursive: true, mode: 0o700 });
+    const manifest = {
+      name: hookPluginName(issue.identifier),
+      version: "1.0.0",
+      description: `Linear context for ${issue.identifier} from the Paseo Linear plugin`,
+    };
+    await writeAtomic(path.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+    await writeAtomic(path.join(root, "hooks", "hooks.json"), text);
+    return { pluginDir: root };
+  });
+}