@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/terminal/agent-hooks/codex/codex.d.ts

@@ -0,0 +1,4 @@
+import type { AgentHookProvider } from "../agent-hook-installer.js";
+import { type CodexHooksFile } from "./codex-settings.js";
+export declare const codexAgentHookProvider: AgentHookProvider<CodexHooksFile>;
+//# sourceMappingURL=codex.d.ts.map

package/dist/server/terminal/agent-hooks/codex/codex.js

@@ -0,0 +1,30 @@
+import { codexHooksFormat } from "./codex-settings.js";
+const CODEX_EVENT_STATES = {
+    UserPromptSubmit: "running",
+    PreToolUse: "running",
+    PostToolUse: "running",
+    PermissionRequest: "needs-input",
+    Stop: "idle",
+};
+export const codexAgentHookProvider = {
+    id: "codex",
+    events: [
+        { event: "UserPromptSubmit" },
+        { event: "PreToolUse" },
+        { event: "PostToolUse" },
+        { event: "PermissionRequest" },
+        { event: "Stop" },
+    ],
+    install: {
+        kind: "config-file",
+        configDir: ".codex",
+        configFile: "hooks.json",
+        configDirEnvOverride: "CODEX_HOME",
+        hookMarker: "hooks codex",
+        format: codexHooksFormat,
+    },
+    async resolveActivity({ event }) {
+        return CODEX_EVENT_STATES[event] ?? null;
+    },
+};
+//# sourceMappingURL=codex.js.map

package/dist/server/terminal/agent-hooks/opencode/opencode-plugin.d.ts

@@ -0,0 +1,4 @@
+import type { AgentHookPluginFileInstallStrategy } from "../agent-hook-installer.js";
+export declare const OPENCODE_PLUGIN_SOURCE: string;
+export declare function createOpenCodePluginInstallStrategy(): AgentHookPluginFileInstallStrategy;
+//# sourceMappingURL=opencode-plugin.d.ts.map

package/dist/server/terminal/agent-hooks/opencode/opencode-plugin.js

@@ -0,0 +1,46 @@
+export const OPENCODE_PLUGIN_SOURCE = [
+    "const STATUS_EVENTS = {",
+    '  busy: "session.status.busy",',
+    '  retry: "session.status.retry",',
+    '  idle: "session.status.idle",',
+    "};",
+    "",
+    "function paseoEventFor(event) {",
+    '  if (event?.type === "permission.asked") return "permission.asked";',
+    '  if (event?.type === "permission.replied") return "permission.replied";',
+    '  if (event?.type !== "session.status") return null;',
+    "  return STATUS_EVENTS[event?.properties?.status?.type] ?? null;",
+    "}",
+    "",
+    "function runPaseoHook(event) {",
+    "  if (!process.env.PASEO_TERMINAL_ID) return;",
+    "  try {",
+    '    const child = Bun.spawn(["paseo", "hooks", "opencode", event], {',
+    '      stdin: "ignore",',
+    '      stdout: "ignore",',
+    '      stderr: "ignore",',
+    "    });",
+    "    void child.exited.catch(() => {});",
+    "  } catch {}",
+    "}",
+    "",
+    "export default async () => ({",
+    "  event: async ({ event }) => {",
+    "    const paseoEvent = paseoEventFor(event);",
+    "    if (paseoEvent) runPaseoHook(paseoEvent);",
+    "  },",
+    "});",
+    "",
+].join("\n");
+export function createOpenCodePluginInstallStrategy() {
+    return {
+        kind: "plugin-file",
+        configDir: "opencode",
+        configDirBase: "xdg-config",
+        configFile: "plugins/paseo-terminal-activity.js",
+        configDirEnvOverride: "OPENCODE_CONFIG_DIR",
+        hookMarker: "paseo hooks opencode",
+        source: OPENCODE_PLUGIN_SOURCE,
+    };
+}
+//# sourceMappingURL=opencode-plugin.js.map

package/dist/server/terminal/agent-hooks/opencode/opencode.d.ts

@@ -0,0 +1,3 @@
+import type { AgentHookProvider } from "../agent-hook-installer.js";
+export declare const opencodeAgentHookProvider: AgentHookProvider;
+//# sourceMappingURL=opencode.d.ts.map

package/dist/server/terminal/agent-hooks/opencode/opencode.js

@@ -0,0 +1,23 @@
+import { createOpenCodePluginInstallStrategy } from "./opencode-plugin.js";
+const OPENCODE_EVENT_STATES = {
+    "session.status.busy": "running",
+    "session.status.retry": "running",
+    "session.status.idle": "idle",
+    "permission.asked": "needs-input",
+    "permission.replied": "running",
+};
+export const opencodeAgentHookProvider = {
+    id: "opencode",
+    events: [
+        { event: "session.status.busy" },
+        { event: "session.status.retry" },
+        { event: "session.status.idle" },
+        { event: "permission.asked" },
+        { event: "permission.replied" },
+    ],
+    install: createOpenCodePluginInstallStrategy(),
+    async resolveActivity({ event }) {
+        return OPENCODE_EVENT_STATES[event] ?? null;
+    },
+};
+//# sourceMappingURL=opencode.js.map

package/dist/server/terminal/agent-hooks/provider-registry.d.ts

@@ -0,0 +1,24 @@
+import { type AgentHookActivityInput, type AgentHookActivityState, type AgentHookInstallLogger, type AgentHookInstallOptions, type AgentHookInstallResult, type AgentHookProvider } from "./agent-hook-installer.js";
+import { claudeAgentHookProvider } from "./claude/claude.js";
+import { codexAgentHookProvider } from "./codex/codex.js";
+import { opencodeAgentHookProvider } from "./opencode/opencode.js";
+export type { AgentHookActivityInput, AgentHookActivityState, AgentHookProvider, } from "./agent-hook-installer.js";
+export declare const AGENT_HOOK_PROVIDERS: {
+    [claudeAgentHookProvider.id]: AgentHookProvider<import("./claude/claude-settings.js").ClaudeSettings>;
+    [codexAgentHookProvider.id]: AgentHookProvider<import("./codex/codex-settings.js").CodexHooksFile>;
+    [opencodeAgentHookProvider.id]: AgentHookProvider<unknown>;
+};
+export type AgentHookProviderId = keyof typeof AGENT_HOOK_PROVIDERS;
+export interface AgentHookActivityRequest {
+    provider: string;
+    event: string;
+    input: AgentHookActivityInput;
+}
+export interface RegisteredAgentHookInstallOptions extends AgentHookInstallOptions {
+    logger?: AgentHookInstallLogger;
+}
+export declare function installRegisteredAgentHooks(options?: RegisteredAgentHookInstallOptions): AgentHookInstallResult[];
+export declare function uninstallRegisteredAgentHooks(options?: AgentHookInstallOptions): void;
+export declare function registeredAgentHooksAreInstalled(options?: AgentHookInstallOptions): boolean;
+export declare function resolveHookActivity(request: AgentHookActivityRequest): Promise<AgentHookActivityState | null>;
+//# sourceMappingURL=provider-registry.d.ts.map

package/dist/server/terminal/agent-hooks/provider-registry.js

@@ -0,0 +1,36 @@
+import { agentHooksAreInstalled, installAgentHooks, uninstallAgentHooks, } from "./agent-hook-installer.js";
+import { claudeAgentHookProvider } from "./claude/claude.js";
+import { codexAgentHookProvider } from "./codex/codex.js";
+import { opencodeAgentHookProvider } from "./opencode/opencode.js";
+export const AGENT_HOOK_PROVIDERS = {
+    [claudeAgentHookProvider.id]: claudeAgentHookProvider,
+    [codexAgentHookProvider.id]: codexAgentHookProvider,
+    [opencodeAgentHookProvider.id]: opencodeAgentHookProvider,
+};
+export function installRegisteredAgentHooks(options = {}) {
+    const results = [];
+    for (const provider of Object.values(AGENT_HOOK_PROVIDERS)) {
+        try {
+            results.push(installAgentHooks(provider, options));
+        }
+        catch (error) {
+            options.logger?.warn({ err: error, provider: provider.id }, "Failed to install terminal activity hook provider");
+        }
+    }
+    return results;
+}
+export function uninstallRegisteredAgentHooks(options = {}) {
+    for (const provider of Object.values(AGENT_HOOK_PROVIDERS)) {
+        uninstallAgentHooks(provider, options);
+    }
+}
+export function registeredAgentHooksAreInstalled(options = {}) {
+    return Object.values(AGENT_HOOK_PROVIDERS).every((provider) => agentHooksAreInstalled(provider, options));
+}
+export async function resolveHookActivity(request) {
+    const provider = AGENT_HOOK_PROVIDERS[request.provider.toLowerCase()];
+    if (!provider)
+        return null;
+    return provider.resolveActivity({ event: request.event, input: request.input });
+}
+//# sourceMappingURL=provider-registry.js.map

package/dist/server/terminal/agent-hooks/terminal-agent-hook-setting.d.ts

@@ -0,0 +1,10 @@
+import type { AgentHookInstallLogger, AgentHookInstallOptions } from "./agent-hook-installer.js";
+import type { DaemonConfigStore } from "../../server/daemon-config-store.js";
+interface ApplyTerminalAgentHookSettingOptions {
+    store: DaemonConfigStore;
+    logger?: AgentHookInstallLogger;
+    install?: AgentHookInstallOptions;
+}
+export declare function applyTerminalAgentHookSetting(options: ApplyTerminalAgentHookSettingOptions): () => void;
+export {};
+//# sourceMappingURL=terminal-agent-hook-setting.d.ts.map

package/dist/server/terminal/agent-hooks/terminal-agent-hook-setting.js

@@ -0,0 +1,26 @@
+import { installRegisteredAgentHooks, uninstallRegisteredAgentHooks, } from "./provider-registry.js";
+// Installing agent hooks edits the user's real agent config files, so it only
+// happens when `enableTerminalAgentHooks` is on. At boot we install when enabled
+// and otherwise leave the configs untouched; toggling the setting live installs
+// on enable and removes our marker-matched hooks on disable so opting out cleans
+// up after itself. Returns an unsubscribe for the field-change listener.
+export function applyTerminalAgentHookSetting(options) {
+    const { store, logger, install } = options;
+    const installOptions = { ...install, logger };
+    if (store.get().enableTerminalAgentHooks) {
+        installRegisteredAgentHooks(installOptions);
+    }
+    return store.onFieldChange("enableTerminalAgentHooks", (value) => {
+        if (value === true) {
+            installRegisteredAgentHooks(installOptions);
+            return;
+        }
+        try {
+            uninstallRegisteredAgentHooks(install);
+        }
+        catch (error) {
+            logger?.warn({ err: error }, "Failed to remove terminal activity hooks");
+        }
+    });
+}
+//# sourceMappingURL=terminal-agent-hook-setting.js.map

package/dist/server/terminal/shell-integration/zsh/.zshenv

@@ -0,0 +1,17 @@
+typeset -g PASEO_SHELL_INTEGRATION_DIR="${${(%):-%N}:A:h}"
+
+if [[ -n "${PASEO_ZSH_ZDOTDIR-}" ]]; then
+  export ZDOTDIR="${PASEO_ZSH_ZDOTDIR}"
+else
+  unset ZDOTDIR
+fi
+
+if [[ -n "${ZDOTDIR-}" ]]; then
+  if [[ -f "${ZDOTDIR}/.zshenv" ]]; then
+    source "${ZDOTDIR}/.zshenv"
+  fi
+elif [[ -f "${HOME}/.zshenv" ]]; then
+  source "${HOME}/.zshenv"
+fi
+
+source "${PASEO_SHELL_INTEGRATION_DIR}/paseo-integration.zsh"

package/dist/server/terminal/shell-integration/zsh/paseo-integration.zsh

@@ -0,0 +1,32 @@
+if [[ -n "${_PASEO_ZSH_INTEGRATION_LOADED-}" ]]; then
+  return
+fi
+typeset -g _PASEO_ZSH_INTEGRATION_LOADED=1
+
+autoload -Uz add-zsh-hook
+
+typeset -g _PASEO_ZSH_COMMAND_ACTIVE=0
+
+function _paseo_osc633() {
+  printf '\e]633;%s\a' "$1"
+}
+
+function _paseo_precmd() {
+  local command_status=$?
+  if [[ "$_PASEO_ZSH_COMMAND_ACTIVE" == "1" ]]; then
+    _paseo_osc633 "D;${command_status}"
+    _PASEO_ZSH_COMMAND_ACTIVE=0
+  fi
+  printf '\e]2;%s\a' "${PWD/#$HOME/~}"
+  _paseo_osc633 "A"
+}
+
+function _paseo_preexec() {
+  _PASEO_ZSH_COMMAND_ACTIVE=1
+  _paseo_osc633 "B"
+  _paseo_osc633 "C"
+  printf '\e]2;%s\a' "$1"
+}
+
+add-zsh-hook precmd _paseo_precmd
+add-zsh-hook preexec _paseo_preexec

package/dist/server/terminal/terminal-capture.d.ts

@@ -0,0 +1,12 @@
+import type { TerminalSession } from "./terminal.js";
+export interface CaptureTerminalLinesOptions {
+    start?: number;
+    end?: number;
+    stripAnsi?: boolean;
+}
+export interface CaptureTerminalLinesResult {
+    lines: string[];
+    totalLines: number;
+}
+export declare function captureTerminalLines(terminal: TerminalSession, options?: CaptureTerminalLinesOptions): CaptureTerminalLinesResult;
+//# sourceMappingURL=terminal-capture.d.ts.map

package/dist/server/terminal/terminal-capture.js

@@ -0,0 +1,43 @@
+import stripAnsi from "strip-ansi";
+function cellsToPlainText(cells, options) {
+    const text = cells
+        .map((cell) => cell.char)
+        .join("")
+        .trimEnd();
+    return options.stripAnsi ? stripAnsi(text) : text;
+}
+function resolveCaptureLineIndex(lineNumber, totalLines, fallback) {
+    if (totalLines === 0) {
+        return fallback === "start" ? 0 : -1;
+    }
+    const defaultIndex = fallback === "start" ? 0 : totalLines - 1;
+    if (typeof lineNumber !== "number") {
+        return defaultIndex;
+    }
+    const resolvedIndex = lineNumber < 0 ? totalLines + lineNumber : lineNumber;
+    if (resolvedIndex < 0) {
+        return 0;
+    }
+    if (resolvedIndex >= totalLines) {
+        return totalLines - 1;
+    }
+    return resolvedIndex;
+}
+export function captureTerminalLines(terminal, options = {}) {
+    const state = terminal.getState();
+    const allLines = [...state.scrollback, ...state.grid].map((cells) => cellsToPlainText(cells, { stripAnsi: options.stripAnsi ?? true }));
+    const totalLines = allLines.length;
+    const startIndex = resolveCaptureLineIndex(options.start, totalLines, "start");
+    const endIndex = resolveCaptureLineIndex(options.end, totalLines, "end");
+    if (totalLines === 0 || startIndex > endIndex) {
+        return {
+            lines: [],
+            totalLines,
+        };
+    }
+    return {
+        lines: allLines.slice(startIndex, endIndex + 1),
+        totalLines,
+    };
+}
+//# sourceMappingURL=terminal-capture.js.map

package/dist/server/terminal/terminal-manager-factory.d.ts

@@ -0,0 +1,6 @@
+import type { TerminalManager } from "./terminal-manager.js";
+export interface ConfiguredTerminalManagerOptions {
+    getTerminalActivityUrl?: () => string | null;
+}
+export declare function createConfiguredTerminalManager(options?: ConfiguredTerminalManagerOptions): TerminalManager;
+//# sourceMappingURL=terminal-manager-factory.d.ts.map

package/dist/server/terminal/terminal-manager-factory.js

@@ -0,0 +1,5 @@
+import { createWorkerTerminalManager } from "./worker-terminal-manager.js";
+export function createConfiguredTerminalManager(options = {}) {
+    return createWorkerTerminalManager(options);
+}
+//# sourceMappingURL=terminal-manager-factory.js.map

package/dist/server/terminal/terminal-manager.d.ts

@@ -0,0 +1,78 @@
+import { type TerminalSession, type TerminalStateSnapshot, type TerminalStateSnapshotOptions } from "./terminal.js";
+import { type CaptureTerminalLinesResult } from "./terminal-capture.js";
+import type { TerminalActivity, TerminalActivityState } from "@hyperdrive.bot/paseo-protocol/terminal-activity";
+export interface TerminalListItem {
+    id: string;
+    name: string;
+    cwd: string;
+    workspaceId: string;
+    title?: string;
+    activity: TerminalActivity | null;
+}
+export interface TerminalsChangedEvent {
+    cwd: string;
+    terminals: TerminalListItem[];
+}
+export type TerminalsChangedListener = (input: TerminalsChangedEvent) => void;
+export interface TerminalActivityTransitionEvent {
+    terminalId: string;
+    name: string;
+    cwd: string;
+    workspaceId: string;
+    activity: TerminalActivity | null;
+    previous: TerminalActivity | null;
+}
+export type TerminalActivityListener = (event: TerminalActivityTransitionEvent) => void;
+export interface TerminalWorkspaceContributionChangedEvent {
+    terminalId: string;
+    cwd: string;
+    workspaceId: string;
+}
+export type TerminalWorkspaceContributionChangedListener = (event: TerminalWorkspaceContributionChangedEvent) => void;
+export interface TerminalManager {
+    getTerminals(cwd: string, options?: {
+        workspaceId?: string;
+    }): Promise<TerminalSession[]>;
+    createTerminal(options: {
+        id?: string;
+        cwd: string;
+        workspaceId: string;
+        name?: string;
+        title?: string;
+        env?: Record<string, string>;
+        command?: string;
+        args?: string[];
+        activityToken?: string;
+        activityUrl?: string | null;
+    }): Promise<TerminalSession>;
+    registerCwdEnv(options: {
+        cwd: string;
+        env: Record<string, string>;
+    }): void;
+    validateTerminalActivityToken(terminalId: string, token: string): "valid" | "unknown" | "invalid";
+    getTerminal(id: string): TerminalSession | undefined;
+    getTerminalState(id: string, options?: TerminalStateSnapshotOptions): Promise<TerminalStateSnapshot | null>;
+    setTerminalTitle(id: string, title: string): boolean;
+    setTerminalActivity(id: string, state: TerminalActivityState): Promise<boolean>;
+    clearTerminalAttention(id: string): Promise<boolean>;
+    killTerminal(id: string): void;
+    killTerminalAndWait(id: string, options?: {
+        gracefulTimeoutMs?: number;
+        forceTimeoutMs?: number;
+    }): Promise<void>;
+    captureTerminal(id: string, options?: {
+        start?: number;
+        end?: number;
+        stripAnsi?: boolean;
+    }): Promise<CaptureTerminalLinesResult>;
+    listDirectories(): string[];
+    killAll(): void;
+    subscribeTerminalsChanged(listener: TerminalsChangedListener): () => void;
+    subscribeTerminalActivity(listener: TerminalActivityListener): () => void;
+    subscribeTerminalWorkspaceContributionChanged(listener: TerminalWorkspaceContributionChangedListener): () => void;
+}
+export interface TerminalManagerOptions {
+    getTerminalActivityUrl?: () => string | null;
+}
+export declare function createTerminalManager(managerOptions?: TerminalManagerOptions): TerminalManager;
+//# sourceMappingURL=terminal-manager.d.ts.map