@getpaseo/cli 0.6.1 → 0.7.0-beta.2

package/dist/commands/agent/ls.js

@@ -78,6 +78,20 @@ function toListItem(agent) {
         created: relativeTime(agent.createdAt),
     };
 }
+function daemonConnectionFailure(host, cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    const isSsh = host.trim().startsWith("ssh://");
+    return {
+        code: "DAEMON_NOT_RUNNING",
+        message: `Cannot reach the daemon at ${host}: ${reason}`,
+        details: isSsh
+            ? "Start the Paseo daemon on the SSH host; SSH transport does not install or start it."
+            : [
+                "Start a local daemon with: paseo daemon start",
+                "To use another daemon, pass --host <host:port> or set PASEO_HOST.",
+            ].join("\n"),
+    };
+}
 function parseLabelFilters(labels) {
     const labelFilters = {};
     for (const labelStr of labels ?? []) {
@@ -126,13 +140,7 @@ export async function runLsCommand(options, _command) {
         client = await connectToDaemon({ host: options.host });
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const error = {
-            code: "DAEMON_NOT_RUNNING",
-            message: `Cannot connect to daemon at ${host}: ${message}`,
-            details: "Start the daemon with: paseo daemon start\nFor a remote daemon, pass --host <host:port> or set PASEO_HOST.",
-        };
-        throw error;
+        throw daemonConnectionFailure(host, err);
     }
     try {
         const normalizedThinkingOptionId = options.thinking?.trim();

package/dist/commands/plugin/index.d.ts

@@ -5,6 +5,9 @@ import { type PluginScaffold } from "./scaffold.js";
 interface PluginOptions extends CommandOptions {
     host?: string;
     id?: string;
+    ref?: string;
+    path?: string;
+    all?: boolean;
 }
 export declare function runPluginInitCommand(directory: string, options: PluginOptions, _command: Command): Promise<SingleResult<PluginScaffold>>;
 export declare function runPluginListCommand(options: PluginOptions, _command: Command): Promise<ListResult<PluginListItem>>;

package/dist/commands/plugin/index.js

@@ -1,8 +1,9 @@
 import { Command } from "commander";
+import path from "node:path";
 import { withOutput } from "../../output/index.js";
 import { addJsonAndDaemonHostOptions, addJsonOption } from "../../utils/command-options.js";
 import { scaffoldPluginDirectory } from "./scaffold.js";
-import { withPluginLogsClient, withPluginManagementClient } from "./shared.js";
+import { withPluginLogsClient, withPluginManagementClient, withPluginSourceClient, } from "./shared.js";
 const pluginSchema = {
     idField: "id",
     columns: [
@@ -28,6 +29,30 @@ const pluginLogsSchema = {
         { header: "MESSAGE", field: "message", width: 80 },
     ],
 };
+function shortCommit(commit) {
+    return commit?.slice(0, 12) ?? "-";
+}
+const pluginStatusSchema = {
+    idField: "id",
+    columns: [
+        { header: "PLUGIN", field: "id", width: 20 },
+        { header: "SOURCE", field: "source", width: 10 },
+        { header: "CURRENT", field: (plugin) => shortCommit(plugin.currentCommit), width: 14 },
+        { header: "LATEST", field: (plugin) => shortCommit(plugin.latestCommit), width: 14 },
+        { header: "COMMITS", field: (plugin) => String(plugin.commitsBehind ?? 0), width: 8 },
+        { header: "REF", field: (plugin) => plugin.ref ?? "-", width: 24 },
+    ],
+};
+const pluginUpdateSchema = {
+    idField: "id",
+    columns: [
+        { header: "PLUGIN", field: "id", width: 20 },
+        { header: "PREVIOUS", field: (plugin) => shortCommit(plugin.previousCommit), width: 14 },
+        { header: "CURRENT", field: (plugin) => shortCommit(plugin.currentCommit), width: 14 },
+        { header: "COMMITS", field: (plugin) => String(plugin.commits), width: 8 },
+        { header: "UPDATED", field: (plugin) => (plugin.updated ? "yes" : "no"), width: 8 },
+    ],
+};
 export async function runPluginInitCommand(directory, options, _command) {
     return {
         type: "single",
@@ -43,10 +68,36 @@ export async function runPluginLogsCommand(pluginId, options, _command) {
     const data = await withPluginLogsClient(options.host, (client) => client.getPluginLogs(pluginId));
     return { type: "list", data, schema: pluginLogsSchema };
 }
-async function install(directory, options, _command) {
-    const data = await withPluginManagementClient(options.host, (client) => client.installDirectoryPlugin(directory, options.id));
+async function install(source, options, _command) {
+    const isExplicitPath = path.isAbsolute(source) ||
+        source === "." ||
+        source === ".." ||
+        source.startsWith("./") ||
+        source.startsWith("../") ||
+        source.startsWith(".\\") ||
+        source.startsWith("..\\");
+    const canUseLegacyDirectoryInstall = isExplicitPath && !options.ref && !options.path;
+    const data = canUseLegacyDirectoryInstall
+        ? await withPluginManagementClient(options.host, (client) => client.installDirectoryPlugin(source, options.id))
+        : await withPluginSourceClient(options.host, (client) => client.installPluginSource({
+            source,
+            ...(options.id ? { id: options.id } : {}),
+            ...(options.ref ? { ref: options.ref } : {}),
+            ...(options.path ? { pluginPath: options.path } : {}),
+        }));
     return { type: "single", data, schema: pluginSchema };
 }
+async function status(pluginId, options, _command) {
+    const data = await withPluginSourceClient(options.host, (client) => client.getPluginSourceStatus(pluginId));
+    return { type: "list", data, schema: pluginStatusSchema };
+}
+async function update(pluginId, options, _command) {
+    if ((pluginId === undefined) === (options.all !== true)) {
+        throw new Error("Choose one plugin ID or pass --all");
+    }
+    const data = await withPluginSourceClient(options.host, (client) => client.updatePluginSources(pluginId));
+    return { type: "list", data, schema: pluginUpdateSchema };
+}
 async function act(action, pluginId, options) {
     const data = await withPluginManagementClient(options.host, (client) => client[`${action}Plugin`](pluginId));
     return { type: "single", data, schema: pluginSchema };
@@ -62,7 +113,7 @@ async function remove(pluginId, options, _command) {
     return { type: "single", data, schema: pluginSchema };
 }
 export function createPluginCommand() {
-    const plugin = new Command("plugin").description("Manage trusted local plugins");
+    const plugin = new Command("plugin").description("Manage trusted plugins");
     addJsonOption(plugin
         .command("init")
         .description("Create a typecheckable local plugin")
@@ -72,11 +123,20 @@ export function createPluginCommand() {
     addJsonAndDaemonHostOptions(plugin.command("logs").description("Show recent plugin output").argument("<id>")).action(withOutput(runPluginLogsCommand));
     addJsonAndDaemonHostOptions(plugin
         .command("install")
-        .description("Install a local plugin directory")
-        .argument("<directory>", "Host filesystem directory")
-        .option("--id <id>", "Runtime plugin ID (defaults to paseo-plugin.json id)")).action(withOutput(install));
+        .alias("add")
+        .description("Install a plugin from a directory or Git repository")
+        .argument("<source>", "Host directory, owner/repo shorthand, or Git URL")
+        .option("--id <id>", "Runtime plugin ID (defaults to paseo-plugin.json id)")
+        .option("--ref <ref>", "Git branch, tag, or commit")
+        .option("--path <path>", "Plugin directory within the repository")).action(withOutput(install));
+    addJsonAndDaemonHostOptions(plugin.command("status").description("Check plugin source updates").argument("[id]")).action(withOutput(status));
+    addJsonAndDaemonHostOptions(plugin
+        .command("update")
+        .description("Update a Git-managed plugin")
+        .argument("[id]")
+        .option("--all", "Update every Git-managed plugin")).action(withOutput(update));
     for (const action of ["reload", "enable", "disable"]) {
-        addJsonAndDaemonHostOptions(plugin.command(action).description(`${action} a local plugin`).argument("<id>")).action(withOutput((id, options, _command) => act(action, id, options)));
+        addJsonAndDaemonHostOptions(plugin.command(action).description(`${action} a plugin`).argument("<id>")).action(withOutput((id, options, _command) => act(action, id, options)));
     }
     addJsonAndDaemonHostOptions(plugin.command("remove").description("Remove plugin configuration").argument("<id>")).action(withOutput(remove));
     return plugin;

package/dist/commands/plugin/scaffold.js

@@ -55,9 +55,50 @@ const SDK_DECLARATIONS = `declare module "@getpaseo/plugin/server" {
   export const PluginAttachmentSearchPayloadSchema: import("zod").ZodType<PluginAttachmentSearchPayload>;
 }
 
+declare module "@getpaseo/plugin/react-native" {
+  import type { ComponentType, FunctionComponent, ReactNode } from "react";
+
+  export interface PluginIconProps {
+    name: string;
+    size?: number;
+    color?: string;
+  }
+
+  export interface ModalProps {
+    title: string;
+    icon?: ReactNode;
+    open: boolean;
+    onOpenChange(open: boolean): void;
+    children: ReactNode;
+  }
+
+  export interface ModalContentProps {
+    children: ReactNode;
+  }
+
+  export interface ModalComponent extends FunctionComponent<ModalProps> {
+    Content: ComponentType<ModalContentProps>;
+  }
+
+  export type ToastVariant = "default" | "info" | "success" | "warning" | "error";
+  export interface ToastOptions {
+    variant?: ToastVariant;
+    durationMs?: number;
+  }
+  export interface ToastApi {
+    show(message: string, options?: ToastOptions): void;
+    error(message: string): void;
+  }
+
+  export const Icon: ComponentType<PluginIconProps>;
+  export const Modal: ModalComponent;
+  export function useToast(): ToastApi;
+}
+
 declare module "@getpaseo/plugin" {
   import type { ComponentType } from "react";
   import type { PaseoApi } from "@getpaseo/client";
+  import type { AgentTimelineItem } from "@getpaseo/protocol/agent-types";
   import type { ZodType, input as ZodInput, output as ZodOutput } from "zod";
   import type {
     PluginAttachmentSourceContribution,
@@ -80,10 +121,15 @@ declare module "@getpaseo/plugin" {
   export interface PluginTheme {
     readonly colors: {
       readonly surface0: string;
+      readonly surface1: string;
+      readonly surface2: string;
+      readonly border: string;
       readonly foreground: string;
       readonly foregroundMuted: string;
       readonly accent: string;
       readonly accentForeground: string;
+      readonly statusSuccess: string;
+      readonly statusWarning: string;
       readonly statusDanger: string;
     };
   }
@@ -96,6 +142,12 @@ declare module "@getpaseo/plugin" {
 
   export interface PluginSurfaceProps extends PluginHostProps {}
 
+  export interface PluginIconProps {
+    name: string;
+    size?: number;
+    color?: string;
+  }
+
   export interface PluginWorkspaceSnapshot {
     readonly id: string;
     readonly projectId: string;
@@ -142,8 +194,26 @@ declare module "@getpaseo/plugin" {
     agentId: string;
   }
 
+  export interface PluginComposerPillProps extends PluginHostProps {
+    workspaceId: string;
+    agentId: string;
+  }
+
+  export interface PluginComposerPillContribution {
+    id: string;
+    title: string;
+    workspaceId: string;
+    agentId: string;
+    Component: ComponentType<PluginComposerPillProps>;
+    onPress(): void | Promise<void>;
+  }
+
   export type PluginPanelLocation = "workspace" | "explorer";
   export interface PluginOpenPanelOptions { location?: PluginPanelLocation; }
+  export interface PluginClientOpenPanelOptions extends PluginOpenPanelOptions {
+    workspaceId: string;
+    agentId?: string;
+  }
 
   export type PluginWorkspacePanelContribution =
     | { id: string; title: string; icon: string; locations?: readonly PluginPanelLocation[]; context: "workspace"; Component: ComponentType<PluginWorkspacePanelProps> }
@@ -179,6 +249,29 @@ declare module "@getpaseo/plugin" {
     Component: ComponentType<PluginSurfaceProps>;
   }
 
+  export type PluginTimelineData = null | boolean | number | string | PluginTimelineData[] | { [key: string]: PluginTimelineData };
+  export interface PluginTimelineItem { type: "plugin"; kind: string; version: number; data: PluginTimelineData; }
+  export interface PluginTimelineTransformResult { items: PluginTimelineItem[]; }
+  export type PluginTimelineTransformerContribution<ItemType extends AgentTimelineItem["type"] = AgentTimelineItem["type"]> =
+    ItemType extends AgentTimelineItem["type"]
+      ? {
+          id: string;
+          query: { itemType: ItemType };
+          transform(input: { item: Extract<AgentTimelineItem, { type: ItemType }> }): PluginTimelineTransformResult | undefined;
+        }
+      : never;
+  export interface PluginTimelineItemProps<Data = unknown> extends PluginHostProps {
+    agentId: string;
+    item: { type: "plugin"; kind: string; version: number; data: Data };
+    timestamp: Date;
+  }
+  export interface PluginTimelineRendererContribution<Schema extends ZodType = ZodType> {
+    kind: string;
+    version: number;
+    schema: Schema;
+    Component: ComponentType<PluginTimelineItemProps<ZodOutput<Schema>>>;
+  }
+
   export interface PluginCommandCapabilities {
     paseo: PaseoApi;
     rpc<InputSchema extends ZodType, OutputSchema extends ZodType>(
@@ -205,6 +298,12 @@ declare module "@getpaseo/plugin" {
     openPanel(id: string, options?: PluginOpenPanelOptions): void;
   }
 
+  export interface PluginClientContext extends PluginCommandCapabilities {
+    addComposerPill(contribution: PluginComposerPillContribution): PluginCleanup;
+    openPanel(id: string, options: PluginClientOpenPanelOptions): void;
+  }
+  export type PluginClientContribution = (client: PluginClientContext) => PluginCleanup;
+
   export type PluginCommandCenterItemContribution =
     | { id: string; title: string; icon: string; keywords?: readonly string[]; context: "global"; onSelect(context: PluginGlobalCommandContext): void | Promise<void> }
     | { id: string; title: string; icon: string; keywords?: readonly string[]; context: "workspace"; onSelect(context: PluginWorkspaceCommandContext): void | Promise<void> }
@@ -222,13 +321,18 @@ declare module "@getpaseo/plugin" {
     addSidebarItem(contribution: PluginSidebarContribution): void;
     addWorkspacePanel(contribution: PluginWorkspacePanelContribution): void;
     addCommandCenterItem(contribution: PluginCommandCenterItemContribution): void;
+    addClientSide(contribution: PluginClientContribution): void;
     addAttachmentSource(contribution: PluginAttachmentSourceContribution): void;
     addTheme(contribution: PluginThemeContribution): void;
+    addTimelineTransformer<ItemType extends AgentTimelineItem["type"]>(contribution: PluginTimelineTransformerContribution<ItemType>): void;
+    addTimelineRenderer<Schema extends ZodType>(contribution: PluginTimelineRendererContribution<Schema>): void;
   }
 
   export type PluginCleanup = () => void | Promise<void>;
   export type PluginContribution = (plugin: PluginContext) => PluginCleanup;
 
+  export const Icon: ComponentType<PluginIconProps>;
+
   export function useRpc<InputSchema extends ZodType, OutputSchema extends ZodType>(
     contract: PluginRpcContract<InputSchema, OutputSchema>,
   ): (input: ZodInput<InputSchema>) => Promise<ZodOutput<OutputSchema>>;
@@ -307,6 +411,7 @@ export async function scaffoldPluginDirectory(targetDirectory, requestedId) {
         scripts: { typecheck: "tsc --noEmit" },
         devDependencies: {
             "@getpaseo/client": "^0.4.0",
+            "@getpaseo/protocol": "^0.6.1",
             "@tanstack/react-query": "^5.90.11",
             "@types/react": "~19.2.0",
             react: "19.1.0",

package/dist/commands/plugin/shared.d.ts

@@ -1,4 +1,5 @@
 import type { DaemonClient } from "@getpaseo/client/internal/daemon-client";
 export declare function withPluginManagementClient<T>(host: string | undefined, run: (client: DaemonClient) => Promise<T>): Promise<T>;
 export declare function withPluginLogsClient<T>(host: string | undefined, run: (client: DaemonClient) => Promise<T>): Promise<T>;
+export declare function withPluginSourceClient<T>(host: string | undefined, run: (client: DaemonClient) => Promise<T>): Promise<T>;
 //# sourceMappingURL=shared.d.ts.map

package/dist/commands/plugin/shared.js

@@ -23,4 +23,8 @@ export async function withPluginLogsClient(host, run) {
     // COMPAT(pluginLogs): added in v0.4.0, remove gate after 2027-08-16.
     return withPluginClient(host, "pluginLogs", "Update the host to view plugin logs.", run);
 }
+export async function withPluginSourceClient(host, run) {
+    // COMPAT(pluginGitManagement): added in v0.7.0, remove gate after 2027-08-26.
+    return withPluginClient(host, "pluginGitManagement", "Update the host to install and update Git plugins.", run);
+}
 //# sourceMappingURL=shared.js.map

package/dist/ssh/ssh-tunnel.d.ts

@@ -0,0 +1,9 @@
+import { type SshTransportTarget } from "@getpaseo/protocol/ssh-transport";
+export interface SshTunnel {
+    endpoint: string;
+    close(): void;
+    failureDetail(): string | null;
+}
+export declare function resolveSshFailureDetail(failure: string | null, stderr: string): string | null;
+export declare function createSshTunnel(target: SshTransportTarget): Promise<SshTunnel>;
+//# sourceMappingURL=ssh-tunnel.d.ts.map

package/dist/ssh/ssh-tunnel.js

@@ -0,0 +1,79 @@
+import { spawn } from "node:child_process";
+import { createServer } from "node:net";
+import { buildSshTunnelArgs } from "@getpaseo/protocol/ssh-transport";
+const SSH_STDERR_LIMIT = 8192;
+function formatSshFailure(stderr, code, signal) {
+    const detail = stderr.trim();
+    if (detail)
+        return detail;
+    if (signal)
+        return `ssh exited with signal ${signal}`;
+    return `ssh exited with code ${code ?? "unknown"}`;
+}
+export function resolveSshFailureDetail(failure, stderr) {
+    return failure ?? (stderr.trim() || null);
+}
+export function createSshTunnel(target) {
+    let server = null;
+    let socket = null;
+    let child = null;
+    let stderr = "";
+    let failure = null;
+    function close() {
+        server?.close();
+        server = null;
+        socket?.destroy();
+        socket = null;
+        if (child && !child.killed)
+            child.kill();
+        child = null;
+    }
+    return new Promise((resolve, reject) => {
+        server = createServer((acceptedSocket) => {
+            socket = acceptedSocket;
+            server?.close();
+            server = null;
+            child = spawn("ssh", buildSshTunnelArgs(target), {
+                stdio: ["pipe", "pipe", "pipe"],
+                windowsHide: true,
+            });
+            child.stderr.on("data", (chunk) => {
+                stderr = `${stderr}${chunk.toString()}`.slice(-SSH_STDERR_LIMIT);
+            });
+            child.on("error", (error) => {
+                failure = error.message;
+                acceptedSocket.destroy(error);
+            });
+            child.on("exit", (code, signal) => {
+                if (code !== 0 || signal)
+                    failure = formatSshFailure(stderr, code, signal);
+                acceptedSocket.destroy(failure ? new Error(failure) : undefined);
+            });
+            acceptedSocket.on("error", () => undefined);
+            acceptedSocket.on("close", () => {
+                if (child && !child.killed)
+                    child.kill();
+            });
+            acceptedSocket.pipe(child.stdin);
+            child.stdout.pipe(acceptedSocket);
+        });
+        server.once("error", (error) => {
+            close();
+            reject(error);
+        });
+        server.listen(0, "127.0.0.1", () => {
+            const address = server?.address();
+            if (!address || typeof address === "string") {
+                close();
+                reject(new Error("Failed to allocate the SSH tunnel port"));
+                return;
+            }
+            resolve({
+                endpoint: `127.0.0.1:${address.port}`,
+                close,
+                failureDetail: () => resolveSshFailureDetail(failure, stderr),
+            });
+        });
+    });
+}
+//# sourceMappingURL=ssh-tunnel.js.map

package/dist/utils/client.js

@@ -2,11 +2,13 @@ import { existsSync, readFileSync } from "node:fs";
 import { loadConfig, resolvePaseoHome } from "@getpaseo/server";
 import { buildDaemonWebSocketUrl, buildRelayWebSocketUrl, normalizeHostPort, parseConnectionUri, shouldUseTlsForDefaultHostedRelay, } from "@getpaseo/protocol/daemon-endpoints";
 import { parseConnectionOfferFromUrl, } from "@getpaseo/protocol/connection-offer";
+import { parseSshTransportUri } from "@getpaseo/protocol/ssh-transport";
 import { DaemonClient } from "@getpaseo/client/internal/daemon-client";
 import path from "node:path";
 import { WebSocket } from "ws";
 import { getOrCreateCliClientId } from "./client-id.js";
 import { resolveCliVersion } from "../version.js";
+import { createSshTunnel } from "../ssh/ssh-tunnel.js";
 const DEFAULT_HOST = "localhost:6767";
 const DEFAULT_TIMEOUT = 15000;
 const PID_FILENAME = "paseo.pid";
@@ -22,7 +24,9 @@ export function buildDaemonConnectionCommandError(options) {
     return {
         code: "DAEMON_NOT_RUNNING",
         message: `Cannot connect to daemon at ${host}: ${message}`,
-        details: "Start the daemon with: paseo daemon start",
+        details: host.trim().startsWith("ssh://")
+            ? "Start the Paseo daemon on the SSH host; SSH transport does not install or start it."
+            : "Start the daemon with: paseo daemon start",
     };
 }
 export function normalizeDaemonHost(raw) {
@@ -266,6 +270,19 @@ export async function connectToDaemon(options) {
     const clientId = await getOrCreateCliClientId();
     const nodeWebSocketFactory = createNodeWebSocketFactory();
     const explicitHost = options?.host ?? process.env.PASEO_HOST;
+    if (explicitHost?.trim().startsWith("ssh://")) {
+        const target = parseSshTransportUri(explicitHost.trim());
+        const tunnel = await createSshTunnel(target);
+        const password = resolveDaemonPassword(explicitHost);
+        const result = await tryConnectHost(tunnel.endpoint, password, clientId, timeout, nodeWebSocketFactory);
+        if ("client" in result)
+            return result.client;
+        const failure = tunnel.failureDetail();
+        tunnel.close();
+        if (failure)
+            throw new Error(`SSH connection failed: ${failure}`, { cause: result.error });
+        throw result.error;
+    }
     const offer = parseHostOfferOrNull(explicitHost);
     if (offer) {
         return connectViaRelayOffer(offer, clientId, timeout, nodeWebSocketFactory);

package/dist/utils/command-options.js

@@ -1,5 +1,5 @@
 const JSON_OPTION_DESCRIPTION = "Output in JSON format";
-const DAEMON_HOST_OPTION_DESCRIPTION = "Daemon host target: host:port or tcp://host:port?ssl=true&password=secret (default: local socket/pipe, then localhost:6767)";
+const DAEMON_HOST_OPTION_DESCRIPTION = "Daemon host target: host:port, tcp://host:port, or ssh://user@host (default: local socket/pipe, then localhost:6767)";
 export function collectMultiple(value, previous) {
     return previous.concat([value]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/cli",
-  "version": "0.6.1",
+  "version": "0.7.0-beta.2",
   "description": "Paseo CLI - control your AI coding agents from the command line",
   "bin": {
     "paseo": "bin/paseo"
@@ -28,9 +28,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@getpaseo/client": "0.6.1",
-    "@getpaseo/protocol": "0.6.1",
-    "@getpaseo/server": "0.6.1",
+    "@getpaseo/client": "0.7.0-beta.2",
+    "@getpaseo/protocol": "0.7.0-beta.2",
+    "@getpaseo/server": "0.7.0-beta.2",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",