@getpaseo/cli 0.3.0-beta.2 → 0.3.0-beta.3

package/dist/commands/hub/client.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import type { HubDeployPartial } from "./deploy-input.js";
+declare const installResponseSchema: z.ZodObject<{
+    projectSlug: z.ZodString;
+    version: z.ZodNumber;
+    versionId: z.ZodString;
+    active: z.ZodBoolean;
+}, z.core.$strict>;
+export type HubInstallResult = z.infer<typeof installResponseSchema>;
+interface InstallHubConfigurationInput {
+    origin: string;
+    apiKey: string;
+    projectSlug: string;
+    yaml: string;
+    partials?: readonly HubDeployPartial[];
+}
+export declare function installHubConfiguration(input: InstallHubConfigurationInput): Promise<HubInstallResult>;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/commands/hub/client.js

@@ -0,0 +1,114 @@
+import { z } from "zod";
+import { HubDeployError } from "./error.js";
+const installResponseSchema = z
+    .object({
+    projectSlug: z.string().min(1),
+    version: z.number().int().positive(),
+    versionId: z.string().uuid(),
+    active: z.boolean(),
+})
+    .strict();
+const issuePathSchema = z.union([z.string(), z.array(z.union([z.string(), z.number()]))]);
+const fieldIssueSchema = z.object({
+    field: z.string().optional(),
+    path: issuePathSchema.optional(),
+    message: z.string(),
+});
+const problemSchema = z.object({
+    type: z.string().optional(),
+    title: z.string().optional(),
+    status: z.number().int().optional(),
+    detail: z.string().optional(),
+    instance: z.string().optional(),
+    errors: z
+        .union([z.array(fieldIssueSchema), z.record(z.string(), z.array(z.string()))])
+        .optional(),
+    issues: z.array(fieldIssueSchema).optional(),
+});
+export async function installHubConfiguration(input) {
+    let response;
+    try {
+        response = await fetch(`${input.origin}/api/v1/configurations/install`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${input.apiKey}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                projectSlug: input.projectSlug,
+                yaml: input.yaml,
+                ...(input.partials === undefined || input.partials.length === 0
+                    ? {}
+                    : { partials: input.partials }),
+            }),
+        });
+    }
+    catch {
+        throw new HubDeployError("HUB_NETWORK_ERROR", `Could not reach Paseo Hub at ${input.origin}. Check the Hub URL and network connection.`);
+    }
+    if (response.status !== 201) {
+        throw await deploymentFailure(response, input.apiKey);
+    }
+    try {
+        return installResponseSchema.parse(await response.json());
+    }
+    catch {
+        throw new HubDeployError("HUB_INVALID_RESPONSE", "Hub returned a malformed deployment response.");
+    }
+}
+async function deploymentFailure(response, apiKey) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.toLowerCase().includes("application/problem+json")) {
+        return new HubDeployError("HUB_REQUEST_FAILED", `Hub deployment failed with HTTP ${response.status}.`);
+    }
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        return new HubDeployError("HUB_INVALID_RESPONSE", `Hub returned malformed problem details for HTTP ${response.status}.`);
+    }
+    const parsed = problemSchema.safeParse(body);
+    if (!parsed.success ||
+        (parsed.data.status !== undefined && parsed.data.status !== response.status)) {
+        return new HubDeployError("HUB_INVALID_RESPONSE", `Hub returned nonconforming problem details for HTTP ${response.status}.`);
+    }
+    const title = parsed.data.title ?? `Hub deployment failed with HTTP ${response.status}`;
+    const detail = parsed.data.detail;
+    const message = detail === undefined ? title : `${title}: ${detail}`;
+    const details = formatFieldIssues(parsed.data.errors, parsed.data.issues);
+    const code = response.status === 422 ? "HUB_VALIDATION_FAILED" : "HUB_REQUEST_FAILED";
+    return new HubDeployError(code, redactSecret(message, apiKey), details === undefined ? undefined : redactSecret(details, apiKey));
+}
+function formatFieldIssues(errors, issues) {
+    const fieldIssues = Array.isArray(errors) ? errors : issues;
+    if (fieldIssues !== undefined) {
+        const lines = fieldIssues.map((issue) => {
+            const field = issue.field ?? formatIssuePath(issue.path);
+            return field === undefined ? issue.message : `${field}: ${issue.message}`;
+        });
+        return lines.length === 0 ? undefined : lines.join("\n");
+    }
+    if (errors === undefined)
+        return undefined;
+    const lines = Object.entries(errors).flatMap(([field, messages]) => messages.map((message) => `${field}: ${message}`));
+    return lines.length === 0 ? undefined : lines.join("\n");
+}
+function formatIssuePath(path) {
+    if (path === undefined || typeof path === "string")
+        return path;
+    let formatted = "";
+    for (const segment of path) {
+        if (typeof segment === "number") {
+            formatted += `[${segment}]`;
+        }
+        else {
+            formatted += formatted.length === 0 ? segment : `.${segment}`;
+        }
+    }
+    return formatted || undefined;
+}
+function redactSecret(value, secret) {
+    return value.split(secret).join("[redacted]");
+}
+//# sourceMappingURL=client.js.map

package/dist/commands/hub/deploy-input.d.ts

@@ -0,0 +1,17 @@
+export interface HubDeployPartial {
+    path: string;
+    content: string;
+}
+export interface HubDeployInput {
+    projectSlug: string;
+    yaml: string;
+    partials?: readonly HubDeployPartial[];
+}
+interface ResolveHubDeployInput {
+    cwd: string;
+    file?: string;
+    project?: string;
+}
+export declare function resolveHubDeployInput(input: ResolveHubDeployInput): Promise<HubDeployInput>;
+export {};
+//# sourceMappingURL=deploy-input.d.ts.map

package/dist/commands/hub/deploy-input.js

@@ -0,0 +1,264 @@
+import { lstat, readFile } from "node:fs/promises";
+import path from "node:path";
+import YAML from "yaml";
+import { HubDeployError } from "./error.js";
+const DEFAULT_CONFIGURATION_PATH = ".paseo/hub.yml";
+const PROMPT_PARTIAL_ROOT = ".paseo/partials";
+const PROMPT_PARTIAL_ROOT_PREFIX = `${PROMPT_PARTIAL_ROOT}/`;
+const PROJECT_SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+const MAX_CONFIGURATION_LENGTH = 1000000;
+const MAX_PROMPT_PARTIAL_COUNT = 100;
+const MAX_PROMPT_PARTIAL_PATH_LENGTH = 512;
+const MAX_PROMPT_PARTIAL_CONTENT_BYTES = 1000000;
+const MAX_PROMPT_PARTIAL_BUNDLE_BYTES = 5000000;
+export async function resolveHubDeployInput(input) {
+    const file = input.file ?? DEFAULT_CONFIGURATION_PATH;
+    const projectRoot = path.resolve(input.cwd);
+    const configurationPath = resolveConfigurationPath(projectRoot, file);
+    const yaml = await readConfiguration(projectRoot, configurationPath, file);
+    const configuration = parseConfiguration(yaml);
+    const projectSlug = input.project ?? projectFromConfiguration(configuration);
+    if (projectSlug === undefined) {
+        throw new HubDeployError("HUB_PROJECT_REQUIRED", "Project is required. Pass --project <slug> or add top-level project to the YAML.");
+    }
+    if (!PROJECT_SLUG_PATTERN.test(projectSlug)) {
+        throw new HubDeployError("HUB_INVALID_PROJECT", "Project must be a bare slug such as my-project.");
+    }
+    const partials = await resolvePromptPartials(projectRoot, configuration);
+    return {
+        projectSlug,
+        yaml,
+        ...(partials.length === 0 ? {} : { partials }),
+    };
+}
+function resolveConfigurationPath(cwd, file) {
+    if (file.length === 0 || file.includes("\0")) {
+        throw invalidConfigurationPath();
+    }
+    const segments = file.replaceAll("\\", "/").split("/");
+    if (segments.some((segment) => segment === "..")) {
+        throw invalidConfigurationPath();
+    }
+    const resolved = path.resolve(cwd, file);
+    const relative = path.relative(cwd, resolved);
+    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw invalidConfigurationPath();
+    }
+    return resolved;
+}
+async function readConfiguration(projectRoot, configurationPath, displayPath) {
+    const unsafePath = () => new HubDeployError("HUB_CONFIGURATION_UNSAFE_PATH", `Hub configuration at ${displayPath} must not use a symlink.`);
+    await rejectSymlinkComponents(projectRoot, configurationPath, unsafePath);
+    let stats;
+    try {
+        stats = await lstat(configurationPath);
+    }
+    catch (error) {
+        throw configurationReadError(displayPath, error);
+    }
+    if (stats.isSymbolicLink()) {
+        throw unsafePath();
+    }
+    if (!stats.isFile()) {
+        throw new HubDeployError("HUB_CONFIGURATION_NOT_FILE", `Hub configuration at ${displayPath} must be a regular file.`);
+    }
+    if (!hasReadPermission(stats.mode)) {
+        throw new HubDeployError("HUB_CONFIGURATION_UNREADABLE", `Could not read Hub configuration at ${displayPath}. Check file permissions.`);
+    }
+    let bytes;
+    try {
+        bytes = await readFile(configurationPath);
+    }
+    catch (error) {
+        throw configurationReadError(displayPath, error);
+    }
+    const yaml = bytes.toString("utf8");
+    if (yaml.length > MAX_CONFIGURATION_LENGTH) {
+        throw new HubDeployError("HUB_CONFIGURATION_TOO_LARGE", `Hub configuration at ${displayPath} exceeds the ${MAX_CONFIGURATION_LENGTH}-character limit.`);
+    }
+    return yaml;
+}
+function parseConfiguration(yaml) {
+    let configuration;
+    try {
+        configuration = YAML.parse(yaml);
+    }
+    catch {
+        throw new HubDeployError("HUB_INVALID_CONFIGURATION", "Hub configuration is not valid YAML.");
+    }
+    if (!isRecord(configuration)) {
+        throw new HubDeployError("HUB_INVALID_CONFIGURATION", "Hub configuration must be a YAML mapping.");
+    }
+    return configuration;
+}
+function projectFromConfiguration(configuration) {
+    const project = configuration["project"];
+    if (project === undefined)
+        return undefined;
+    if (typeof project !== "string") {
+        throw new HubDeployError("HUB_INVALID_PROJECT", "Top-level project must be a bare project slug.");
+    }
+    return project;
+}
+async function resolvePromptPartials(projectRoot, configuration) {
+    const references = collectPromptPartialReferences(configuration);
+    if (references.length > MAX_PROMPT_PARTIAL_COUNT) {
+        throw new HubDeployError("HUB_PARTIAL_LIMIT_EXCEEDED", `Hub configuration references ${references.length} partials; the limit is ${MAX_PROMPT_PARTIAL_COUNT}.`);
+    }
+    const partials = [];
+    let bundleBytes = 0;
+    for (const reference of references) {
+        const partialPath = path.resolve(projectRoot, PROMPT_PARTIAL_ROOT, ...reference.path.split("/"));
+        const content = await readPartial(projectRoot, partialPath, reference.path);
+        const contentBytes = Buffer.byteLength(content, "utf8");
+        if (contentBytes > MAX_PROMPT_PARTIAL_CONTENT_BYTES) {
+            throw new HubDeployError("HUB_PARTIAL_TOO_LARGE", `Referenced Hub partial ${reference.path} exceeds the ${MAX_PROMPT_PARTIAL_CONTENT_BYTES}-byte limit.`);
+        }
+        bundleBytes += contentBytes;
+        if (bundleBytes > MAX_PROMPT_PARTIAL_BUNDLE_BYTES) {
+            throw new HubDeployError("HUB_PARTIAL_BUNDLE_TOO_LARGE", `Referenced Hub partials exceed the ${MAX_PROMPT_PARTIAL_BUNDLE_BYTES}-byte combined limit.`);
+        }
+        partials.push({ path: reference.path, content });
+    }
+    return partials;
+}
+function collectPromptPartialReferences(configuration) {
+    const references = [];
+    const seen = new Set();
+    const triggers = configuration["triggers"];
+    if (!Array.isArray(triggers))
+        return references;
+    for (const trigger of triggers) {
+        if (!isRecord(trigger) || !Array.isArray(trigger["steps"]))
+            continue;
+        for (const step of trigger["steps"]) {
+            if (!isRecord(step) || !Array.isArray(step["prompt"]))
+                continue;
+            for (const block of step["prompt"]) {
+                if (!isRecord(block) || !Object.hasOwn(block, "include"))
+                    continue;
+                const include = block["include"];
+                if (typeof include !== "string") {
+                    throw new HubDeployError("HUB_PARTIAL_PATH_INVALID", "Hub partial include path must be a string.");
+                }
+                const normalizedPath = normalizePromptPartialPath(include);
+                if (seen.has(normalizedPath)) {
+                    throw new HubDeployError("HUB_PARTIAL_DUPLICATE", `Hub partial ${normalizedPath} is referenced more than once. Remove the duplicate include.`);
+                }
+                seen.add(normalizedPath);
+                references.push({ path: normalizedPath });
+            }
+        }
+    }
+    return references;
+}
+function normalizePromptPartialPath(value) {
+    const decoded = decodePromptPartialPath(value);
+    if (decoded.length === 0)
+        throw invalidPromptPartialPath(value);
+    if (/^(?:[a-zA-Z]:[\\/]|[\\/]{1,2})/u.test(decoded)) {
+        throw invalidPromptPartialPath(value);
+    }
+    const segments = decoded.replaceAll("\\", "/").split("/");
+    if (segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+        throw invalidPromptPartialPath(value);
+    }
+    const canonical = `${PROMPT_PARTIAL_ROOT}/${segments.join("/")}`;
+    if (!canonical.startsWith(PROMPT_PARTIAL_ROOT_PREFIX)) {
+        throw invalidPromptPartialPath(value);
+    }
+    if (canonical.length > MAX_PROMPT_PARTIAL_PATH_LENGTH) {
+        throw new HubDeployError("HUB_PARTIAL_PATH_TOO_LONG", `Hub partial path ${value} exceeds the ${MAX_PROMPT_PARTIAL_PATH_LENGTH}-character limit.`);
+    }
+    return canonical.slice(PROMPT_PARTIAL_ROOT_PREFIX.length);
+}
+function decodePromptPartialPath(value) {
+    let decoded = value;
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+        let next;
+        try {
+            next = decodeURIComponent(decoded);
+        }
+        catch {
+            throw invalidPromptPartialPath(value);
+        }
+        if (next === decoded)
+            break;
+        decoded = next;
+    }
+    if (decoded.includes("\0") || /%[0-9a-f]{2}/iu.test(decoded)) {
+        throw invalidPromptPartialPath(value);
+    }
+    return decoded;
+}
+async function readPartial(projectRoot, partialPath, displayPath) {
+    await rejectSymlinkComponents(projectRoot, partialPath, () => new HubDeployError("HUB_PARTIAL_UNSAFE_PATH", `Referenced Hub partial ${displayPath} must not use a symlink.`));
+    let stats;
+    try {
+        stats = await lstat(partialPath);
+    }
+    catch (error) {
+        if (errorCode(error) === "ENOENT") {
+            throw new HubDeployError("HUB_PARTIAL_MISSING", `Referenced Hub partial ${displayPath} does not exist.`);
+        }
+        throw new HubDeployError("HUB_PARTIAL_UNREADABLE", `Could not read referenced Hub partial ${displayPath}. Check the file and permissions.`);
+    }
+    if (stats.isSymbolicLink()) {
+        throw new HubDeployError("HUB_PARTIAL_UNSAFE_PATH", `Referenced Hub partial ${displayPath} must not be a symlink.`);
+    }
+    if (!stats.isFile()) {
+        throw new HubDeployError("HUB_PARTIAL_NOT_FILE", `Referenced Hub partial ${displayPath} must be a regular file.`);
+    }
+    if (!hasReadPermission(stats.mode)) {
+        throw new HubDeployError("HUB_PARTIAL_UNREADABLE", `Could not read referenced Hub partial ${displayPath}. Check the file and permissions.`);
+    }
+    try {
+        return (await readFile(partialPath)).toString("utf8");
+    }
+    catch {
+        throw new HubDeployError("HUB_PARTIAL_UNREADABLE", `Could not read referenced Hub partial ${displayPath}. Check the file and permissions.`);
+    }
+}
+async function rejectSymlinkComponents(root, target, error) {
+    const relative = path.relative(root, target);
+    let current = root;
+    for (const segment of relative.split(path.sep).filter(Boolean)) {
+        current = path.join(current, segment);
+        try {
+            if ((await lstat(current)).isSymbolicLink())
+                throw error();
+        }
+        catch (failure) {
+            if (failure instanceof HubDeployError)
+                throw failure;
+            if (errorCode(failure) === "ENOENT")
+                return;
+            throw error();
+        }
+    }
+}
+function configurationReadError(displayPath, error) {
+    if (errorCode(error) === "ENOENT") {
+        return new HubDeployError("HUB_CONFIGURATION_UNREADABLE", `Could not read Hub configuration at ${displayPath}. Pass an existing YAML file.`);
+    }
+    return new HubDeployError("HUB_CONFIGURATION_UNREADABLE", `Could not read Hub configuration at ${displayPath}. Check the file and permissions.`);
+}
+function invalidConfigurationPath() {
+    return new HubDeployError("HUB_CONFIGURATION_PATH_INVALID", "Hub configuration path must stay within the current project root; parent-directory paths are not allowed.");
+}
+function invalidPromptPartialPath(value) {
+    return new HubDeployError("HUB_PARTIAL_PATH_INVALID", `Hub partial path must be a safe relative path under .paseo/partials/: ${value}`);
+}
+function hasReadPermission(mode) {
+    return (mode & 0o444) !== 0;
+}
+function errorCode(error) {
+    if (typeof error !== "object" || error === null)
+        return undefined;
+    const code = Reflect.get(error, "code");
+    return typeof code === "string" ? code : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=deploy-input.js.map

package/dist/commands/hub/deploy.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from "commander";
+import { type SingleResult } from "../../output/index.js";
+import { type HubInstallResult } from "./client.js";
+export interface HubDeployOptions {
+    file?: string;
+    project?: string;
+    hub?: string;
+    apiKey?: string;
+}
+interface HubDeployEnvironment {
+    cwd: string;
+    env: Readonly<Record<string, string | undefined>>;
+}
+export declare function runHubDeploy(options: HubDeployOptions, environment?: HubDeployEnvironment): Promise<SingleResult<HubInstallResult>>;
+export declare function addHubDeployCommand(hub: Command): void;
+export {};
+//# sourceMappingURL=deploy.d.ts.map

package/dist/commands/hub/deploy.js

@@ -0,0 +1,71 @@
+import { withOutput } from "../../output/index.js";
+import { addJsonOption } from "../../utils/command-options.js";
+import { installHubConfiguration } from "./client.js";
+import { resolveHubDeployInput } from "./deploy-input.js";
+import { HubDeployError } from "./error.js";
+const resultSchema = {
+    idField: "versionId",
+    columns: [
+        { header: "PROJECT", field: "projectSlug" },
+        { header: "VERSION", field: "version" },
+        { header: "VERSION ID", field: "versionId" },
+        { header: "ACTIVE", field: "active" },
+    ],
+};
+export async function runHubDeploy(options, environment = { cwd: process.cwd(), env: process.env }) {
+    const origin = options.hub ?? environment.env.PASEO_HUB_URL;
+    const apiKey = options.apiKey ?? environment.env.PASEO_HUB_API_KEY;
+    if (!origin) {
+        throw new HubDeployError("HUB_ORIGIN_REQUIRED", "Hub origin is required. Pass --hub <origin> or set PASEO_HUB_URL.");
+    }
+    if (!apiKey) {
+        throw new HubDeployError("HUB_API_KEY_REQUIRED", "Hub API key is required. Pass --api-key <secret> or set PASEO_HUB_API_KEY.");
+    }
+    const normalizedOrigin = parseHubOrigin(origin);
+    const deployInput = await resolveHubDeployInput({
+        cwd: environment.cwd,
+        ...(options.file === undefined ? {} : { file: options.file }),
+        ...(options.project === undefined ? {} : { project: options.project }),
+    });
+    const deployed = await installHubConfiguration({
+        origin: normalizedOrigin,
+        apiKey,
+        ...deployInput,
+    });
+    return { type: "single", data: deployed, schema: resultSchema };
+}
+export function addHubDeployCommand(hub) {
+    addJsonOption(hub
+        .command("deploy")
+        .description("Install and activate a Hub configuration")
+        .argument("[file]", "Hub configuration YAML", ".paseo/hub.yml")
+        .option("-p, --project <slug>", "Target project slug")
+        .option("--hub <origin>", "Paseo Hub origin")
+        .option("--api-key <secret>", "Organization API key")).action(withOutput(async (...args) => {
+        const file = args[0];
+        const options = args.at(-2);
+        return runHubDeploy({ ...options, file });
+    }));
+}
+function parseHubOrigin(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw invalidHubOrigin();
+    }
+    if (!["http:", "https:"].includes(url.protocol) ||
+        url.username ||
+        url.password ||
+        url.pathname !== "/" ||
+        url.search ||
+        url.hash) {
+        throw invalidHubOrigin();
+    }
+    return url.origin;
+}
+function invalidHubOrigin() {
+    return new HubDeployError("HUB_INVALID_ORIGIN", "Hub URL must be an HTTP or HTTPS origin without credentials, path, query, or hash.");
+}
+//# sourceMappingURL=deploy.js.map

package/dist/commands/hub/error.d.ts

@@ -0,0 +1,6 @@
+export declare class HubDeployError extends Error {
+    readonly code: string;
+    readonly details?: string | undefined;
+    constructor(code: string, message: string, details?: string | undefined);
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/commands/hub/error.js

@@ -0,0 +1,9 @@
+export class HubDeployError extends Error {
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "HubDeployError";
+    }
+}
+//# sourceMappingURL=error.js.map

package/dist/commands/hub/index.js

@@ -4,6 +4,7 @@ import { withOutput } from "../../output/index.js";
 import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
 import { connectToDaemon } from "../../utils/client.js";
 import { createDeviceAuthorizationWorkflow } from "./device-authorization.js";
+import { addHubDeployCommand } from "./deploy.js";
 const productionEnvironment = {
     connect: (host) => connectToDaemon({ host }),
     authorize: (url, displayName) => createDeviceAuthorizationWorkflow().authorize(url, displayName),
@@ -48,7 +49,7 @@ async function withClient(environment, host, action) {
     }
 }
 export function createHubCommand(environment = productionEnvironment) {
-    const hub = new Command("hub").description("Manage this daemon's Paseo Hub relationship");
+    const hub = new Command("hub").description("Manage Paseo Hub");
     addJsonAndDaemonHostOptions(hub.command("connect").argument("<url>").option("--token <token>")).action(withOutput(async (...args) => {
         const url = args[0];
         const options = args.at(-2);
@@ -77,6 +78,7 @@ export function createHubCommand(environment = productionEnvironment) {
             return result(response.status, response.warning);
         });
     }));
+    addHubDeployCommand(hub);
     return hub;
 }
 function suggestedDisplayName(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/cli",
-  "version": "0.3.0-beta.2",
+  "version": "0.3.0-beta.3",
   "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.3.0-beta.2",
-    "@getpaseo/protocol": "0.3.0-beta.2",
-    "@getpaseo/server": "0.3.0-beta.2",
+    "@getpaseo/client": "0.3.0-beta.3",
+    "@getpaseo/protocol": "0.3.0-beta.3",
+    "@getpaseo/server": "0.3.0-beta.3",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",