@getpaseo/cli 0.7.0-beta.1 → 0.7.0-beta.2

package/dist/commands/agent/ls.js

@@ -80,13 +80,16 @@ function toListItem(agent) {
 }
 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: [
-            "Start a local daemon with: paseo daemon start",
-            "To use another daemon, pass --host <host:port> or set PASEO_HOST.",
-        ].join("\n"),
+        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) {

package/dist/commands/plugin/scaffold.js

@@ -55,6 +55,46 @@ 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";
@@ -154,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> }
@@ -240,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> }
@@ -257,6 +321,7 @@ 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;

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.7.0-beta.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.7.0-beta.1",
-    "@getpaseo/protocol": "0.7.0-beta.1",
-    "@getpaseo/server": "0.7.0-beta.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",