@getpaseo/cli 0.3.1 → 0.4.0-beta.2

package/dist/commands/chat/schema.d.ts

@@ -1,36 +0,0 @@
-import type { OutputSchema } from "../../output/index.js";
-export interface ChatRoomRow {
-    name: string;
-    id: string;
-    purpose: string;
-    messages: number;
-    lastMessageAt: string;
-}
-export interface ChatMessageRow {
-    id: string;
-    author: string;
-    authorName: string | null;
-    createdAt: string;
-    replyTo: string;
-    mentionAgentIds: string[];
-    mentionLabels: string[];
-    body: string;
-}
-export declare const chatRoomSchema: OutputSchema<ChatRoomRow>;
-export declare const chatMessageSchema: OutputSchema<ChatMessageRow>;
-export declare function toChatRoomRow(room: {
-    id: string;
-    name: string;
-    purpose: string | null;
-    messageCount: number;
-    lastMessageAt: string | null;
-}): ChatRoomRow;
-export declare function toChatMessageRow(message: {
-    id: string;
-    authorAgentId: string;
-    createdAt: string;
-    replyToMessageId: string | null;
-    mentionAgentIds: string[];
-    body: string;
-}): ChatMessageRow;
-//# sourceMappingURL=schema.d.ts.map

package/dist/commands/chat/schema.js

@@ -1,81 +0,0 @@
-export const chatRoomSchema = {
-    idField: "id",
-    columns: [
-        { header: "NAME", field: "name", width: 22 },
-        { header: "ID", field: "id", width: 36 },
-        { header: "PURPOSE", field: "purpose", width: 30 },
-        { header: "MESSAGES", field: "messages", width: 10, align: "right" },
-        { header: "LAST MESSAGE", field: "lastMessageAt", width: 24 },
-    ],
-};
-export const chatMessageSchema = {
-    idField: "id",
-    columns: [
-        { header: "ID", field: "id", width: 36 },
-        { header: "AUTHOR", field: "author", width: 16 },
-        { header: "AUTHOR NAME", field: (row) => row.authorName ?? "-", width: 20 },
-        { header: "CREATED", field: "createdAt", width: 24 },
-        { header: "REPLY TO", field: "replyTo", width: 36 },
-        { header: "MENTIONS", field: (row) => row.mentionLabels.join(", ") || "-", width: 24 },
-        { header: "MESSAGE", field: "body", width: 60 },
-    ],
-    renderHuman: renderChatTranscript,
-};
-function renderChatTranscript(result, _options) {
-    const data = result.type === "list" ? result.data : [result.data];
-    if (data.length === 0) {
-        return "";
-    }
-    return data.map(renderChatMessageBlock).join("\n\n");
-}
-function renderChatMessageBlock(message) {
-    const authorLabel = message.authorName
-        ? `${message.authorName} (${message.author})`
-        : message.author;
-    const lines = [
-        `┌─ ${authorLabel} ── ${formatTimestamp(message.createdAt)} ── [msg ${message.id}]`,
-    ];
-    if (message.replyTo !== "-") {
-        lines.push(`│  reply-to: msg ${message.replyTo}`);
-    }
-    if (message.mentionLabels.length > 0) {
-        lines.push(`│  mentions: ${message.mentionLabels.join(", ")}`);
-    }
-    lines.push("│");
-    const bodyLines = message.body.split(/\r?\n/);
-    for (const line of bodyLines) {
-        lines.push(`│  ${line}`);
-    }
-    lines.push("│");
-    lines.push("└─");
-    return lines.join("\n");
-}
-function formatTimestamp(input) {
-    const date = new Date(input);
-    if (Number.isNaN(date.getTime())) {
-        return input;
-    }
-    return date.toISOString().replace("T", " ").replace(".000Z", "Z");
-}
-export function toChatRoomRow(room) {
-    return {
-        id: room.id,
-        name: room.name,
-        purpose: room.purpose ?? "-",
-        messages: room.messageCount,
-        lastMessageAt: room.lastMessageAt ?? "-",
-    };
-}
-export function toChatMessageRow(message) {
-    return {
-        id: message.id,
-        author: message.authorAgentId,
-        authorName: null,
-        createdAt: message.createdAt,
-        replyTo: message.replyToMessageId ?? "-",
-        mentionAgentIds: message.mentionAgentIds,
-        mentionLabels: message.mentionAgentIds,
-        body: message.body,
-    };
-}
-//# sourceMappingURL=schema.js.map

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

@@ -1,19 +0,0 @@
-import { connectToDaemon } from "../../utils/client.js";
-import type { CommandError, CommandOptions } from "../../output/index.js";
-import type { ChatMessageRow } from "./schema.js";
-export interface ChatCommandOptions extends CommandOptions {
-    host?: string;
-}
-export declare function connectChatClient(host?: string): Promise<{
-    client: import("@getpaseo/client/internal/daemon-client").DaemonClient;
-    daemonHost: string;
-}>;
-export declare function attachAgentNamesToMessages(client: Awaited<ReturnType<typeof connectToDaemon>>, messages: ChatMessageRow[], options?: {
-    timeout?: number;
-    bestEffort?: boolean;
-}): Promise<ChatMessageRow[]>;
-export declare function toChatCommandError(code: string, action: string, err: unknown): CommandError;
-export declare function parseSinceValue(input?: string): string | undefined;
-export declare function parseTimeoutMs(input?: string): number | undefined;
-export declare function resolveChatAuthorAgentId(): string;
-//# sourceMappingURL=shared.d.ts.map

package/dist/commands/chat/shared.js

@@ -1,118 +0,0 @@
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-import { parseDuration } from "../../utils/duration.js";
-export async function connectChatClient(host) {
-    const daemonHost = getDaemonHost({ host });
-    try {
-        const client = await connectToDaemon({ host });
-        return { client, daemonHost };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const error = {
-            code: "DAEMON_NOT_RUNNING",
-            message: `Cannot connect to daemon at ${daemonHost}: ${message}`,
-            details: "Start the daemon with: paseo daemon start",
-        };
-        throw error;
-    }
-}
-export async function attachAgentNamesToMessages(client, messages, options = {}) {
-    const agentIds = new Set();
-    for (const message of messages) {
-        agentIds.add(message.author);
-        for (const mentionId of message.mentionAgentIds) {
-            agentIds.add(mentionId);
-        }
-    }
-    if (agentIds.size === 0) {
-        return messages;
-    }
-    let payload;
-    try {
-        payload = await client.fetchAgents({
-            filter: { includeArchived: true },
-            ...(typeof options.timeout === "number" ? { timeout: options.timeout } : {}),
-        });
-    }
-    catch (error) {
-        if (options.bestEffort) {
-            return messages;
-        }
-        throw error;
-    }
-    const agentNames = new Map();
-    for (const entry of payload.entries) {
-        const title = entry.agent.title?.trim();
-        if (title) {
-            agentNames.set(entry.agent.id, title);
-        }
-    }
-    return messages.map((message) => ({
-        ...message,
-        authorName: agentNames.get(message.author) ?? null,
-        mentionLabels: message.mentionAgentIds.map((agentId) => {
-            const name = agentNames.get(agentId);
-            return name ? `${name} (${agentId})` : agentId;
-        }),
-    }));
-}
-export function toChatCommandError(code, action, err) {
-    if (err && typeof err === "object" && "code" in err && "message" in err) {
-        return err;
-    }
-    const message = err instanceof Error ? err.message : String(err);
-    const rpcCode = typeof err === "object" && err !== null && "code" in err && typeof err.code === "string"
-        ? err.code
-        : undefined;
-    return {
-        code: rpcCode ?? code,
-        message: `Failed to ${action}: ${message}`,
-    };
-}
-export function parseSinceValue(input) {
-    if (!input) {
-        return undefined;
-    }
-    try {
-        const durationMs = parseDuration(input);
-        return new Date(Date.now() - durationMs).toISOString();
-    }
-    catch {
-        const timestamp = new Date(input);
-        if (Number.isNaN(timestamp.getTime())) {
-            const error = {
-                code: "INVALID_SINCE",
-                message: "Invalid --since value",
-                details: "Use a duration like 10m or an ISO timestamp.",
-            };
-            throw error;
-        }
-        return timestamp.toISOString();
-    }
-}
-export function parseTimeoutMs(input) {
-    if (!input) {
-        return undefined;
-    }
-    try {
-        const timeoutMs = parseDuration(input);
-        if (timeoutMs <= 0) {
-            throw new Error("Timeout must be positive");
-        }
-        return timeoutMs;
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const error = {
-            code: "INVALID_TIMEOUT",
-            message: "Invalid timeout value",
-            details: message,
-        };
-        throw error;
-    }
-}
-export function resolveChatAuthorAgentId() {
-    const agentId = process.env.PASEO_AGENT_ID?.trim();
-    return agentId && agentId.length > 0 ? agentId : "manual";
-}
-//# sourceMappingURL=shared.js.map

package/dist/commands/chat/wait.d.ts

@@ -1,9 +0,0 @@
-import type { Command } from "commander";
-import type { ListResult } from "../../output/index.js";
-import { type ChatCommandOptions } from "./shared.js";
-import { type ChatMessageRow } from "./schema.js";
-export interface ChatWaitOptions extends ChatCommandOptions {
-    timeout?: string;
-}
-export declare function runWaitCommand(room: string, options: ChatWaitOptions, _command: Command): Promise<ListResult<ChatMessageRow>>;
-//# sourceMappingURL=wait.d.ts.map

package/dist/commands/chat/wait.js

@@ -1,45 +0,0 @@
-import { attachAgentNamesToMessages, connectChatClient, parseTimeoutMs, toChatCommandError, } from "./shared.js";
-import { chatMessageSchema, toChatMessageRow } from "./schema.js";
-const CHAT_WAIT_PREFLIGHT_TIMEOUT_MS = 2000;
-export async function runWaitCommand(room, options, _command) {
-    const timeoutMs = parseTimeoutMs(options.timeout);
-    const { client } = await connectChatClient(options.host);
-    const deadline = typeof timeoutMs === "number" ? Date.now() + timeoutMs : null;
-    const hasExplicitTimeout = deadline !== null;
-    const remainingTimeoutMs = () => deadline === null ? undefined : Math.max(1, deadline - Date.now());
-    try {
-        const latest = await client.readChatMessages({
-            room,
-            limit: 1,
-            ...(hasExplicitTimeout
-                ? {
-                    timeout: Math.min(remainingTimeoutMs() ?? 1, CHAT_WAIT_PREFLIGHT_TIMEOUT_MS),
-                }
-                : {}),
-        });
-        const afterMessageId = latest.messages[0]?.id;
-        const payload = await client.waitForChatMessages({
-            room,
-            afterMessageId,
-            timeoutMs: remainingTimeoutMs() ?? timeoutMs,
-        });
-        const messages = await attachAgentNamesToMessages(client, payload.messages.map(toChatMessageRow), hasExplicitTimeout
-            ? {
-                timeout: remainingTimeoutMs(),
-                bestEffort: true,
-            }
-            : {});
-        return {
-            type: "list",
-            data: messages,
-            schema: chatMessageSchema,
-        };
-    }
-    catch (err) {
-        throw toChatCommandError("CHAT_WAIT_FAILED", "wait for chat messages", err);
-    }
-    finally {
-        await client.close().catch(() => { });
-    }
-}
-//# sourceMappingURL=wait.js.map

package/dist/commands/hub/client.js

@@ -1,234 +0,0 @@
-import { z } from "zod";
-import { HubCommandError } from "./error.js";
-const activationUrlSchema = z.url({ protocol: /^https?$/u });
-const authorizationSchema = z
-    .object({
-    deviceCode: z.string().min(32),
-    userCode: z.string().min(1),
-    verificationUri: activationUrlSchema,
-    verificationUriComplete: activationUrlSchema,
-    expiresAt: z.string().datetime(),
-    interval: z.number().int().min(1),
-})
-    .strict();
-const authorizationPollSchema = z.discriminatedUnion("status", [
-    z.object({ status: z.literal("pending"), interval: z.number().int().min(1) }).strict(),
-    z.object({ status: z.literal("slow_down"), interval: z.number().int().min(1) }).strict(),
-    z
-        .object({
-        status: z.literal("authorized"),
-        interval: z.number().int().min(1),
-        credential: z.string().min(32),
-        organizationId: z.string().min(1),
-    })
-        .strict(),
-    z.object({ status: z.literal("denied"), interval: z.number().int().min(1) }).strict(),
-    z.object({ status: z.literal("expired"), interval: z.number().int().min(1) }).strict(),
-    z.object({ status: z.literal("disclosed"), interval: z.number().int().min(1) }).strict(),
-    z.object({ status: z.literal("retry_later") }).strict(),
-]);
-const projectSchema = z
-    .object({ id: z.string().uuid(), slug: z.string().min(1), name: z.string().min(1) })
-    .strict();
-const projectsResponseSchema = z.object({ projects: z.array(projectSchema) }).strict();
-const installResponseSchema = z
-    .object({
-    projectSlug: z.string().min(1),
-    version: z.number().int().positive(),
-    versionId: z.string().uuid(),
-    active: z.literal(true),
-})
-    .strict();
-const validationResponseSchema = z
-    .object({ projectSlug: z.string().min(1), valid: z.literal(true) })
-    .strict();
-const enrollmentTokenSchema = z
-    .object({ token: z.string().min(32), expiresAt: z.string().datetime() })
-    .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 class HubHttpClient {
-    async startCliAuthorization(origin) {
-        return this.request({
-            origin,
-            path: "/api/v1/cli-authorizations",
-            method: "POST",
-            body: {},
-            successStatus: 201,
-            schema: authorizationSchema,
-            failureMessage: "Hub CLI login could not be started",
-        });
-    }
-    async pollCliAuthorization(origin, deviceCode, timeoutMilliseconds) {
-        try {
-            return await this.request({
-                origin,
-                path: "/api/v1/cli-authorizations/poll",
-                method: "POST",
-                body: { deviceCode },
-                successStatus: 200,
-                schema: authorizationPollSchema,
-                timeoutMilliseconds,
-                failureMessage: "Hub CLI login polling failed",
-            });
-        }
-        catch (error) {
-            if (error instanceof HubCommandError && error.code === "HUB_NETWORK_ERROR") {
-                return { status: "retry_later" };
-            }
-            throw error;
-        }
-    }
-    async listProjects(origin, apiKey) {
-        const response = await this.request({
-            origin,
-            path: "/api/v1/projects",
-            method: "GET",
-            apiKey,
-            successStatus: 200,
-            schema: projectsResponseSchema,
-            failureMessage: "Hub project listing failed",
-        });
-        return response.projects;
-    }
-    installConfiguration(input) {
-        return this.request({
-            origin: input.origin,
-            path: "/api/v1/configurations/install",
-            method: "POST",
-            apiKey: input.apiKey,
-            body: configurationBody(input),
-            successStatus: 201,
-            schema: installResponseSchema,
-            failureMessage: "Hub deployment failed",
-        });
-    }
-    validateConfiguration(input) {
-        return this.request({
-            origin: input.origin,
-            path: "/api/v1/configurations/validate",
-            method: "POST",
-            apiKey: input.apiKey,
-            body: configurationBody(input),
-            successStatus: 200,
-            schema: validationResponseSchema,
-            failureMessage: "Hub configuration validation failed",
-        });
-    }
-    async issueEnrollmentToken(origin, apiKey) {
-        const response = await this.request({
-            origin,
-            path: "/api/v1/daemons/enrollment-tokens",
-            method: "POST",
-            apiKey,
-            successStatus: 201,
-            schema: enrollmentTokenSchema,
-            failureMessage: "Hub daemon enrollment authorization failed",
-        });
-        return response.token;
-    }
-    async request(input) {
-        const signal = AbortSignal.timeout(input.timeoutMilliseconds ?? 15000);
-        let response;
-        try {
-            response = await fetch(`${input.origin}${input.path}`, {
-                method: input.method,
-                headers: {
-                    ...(input.apiKey === undefined ? {} : { authorization: `Bearer ${input.apiKey}` }),
-                    ...(input.body === undefined ? {} : { "content-type": "application/json" }),
-                },
-                ...(input.body === undefined ? {} : { body: JSON.stringify(input.body) }),
-                signal,
-            });
-        }
-        catch {
-            throw new HubCommandError("HUB_NETWORK_ERROR", `Could not reach Paseo Hub at ${input.origin}. Check the Hub URL and network connection.`);
-        }
-        if (response.status !== input.successStatus) {
-            throw await requestFailure(response, input.failureMessage, input.apiKey);
-        }
-        try {
-            return input.schema.parse(await response.json());
-        }
-        catch {
-            throw new HubCommandError("HUB_INVALID_RESPONSE", "Hub returned a malformed response.");
-        }
-    }
-}
-function configurationBody(input) {
-    return {
-        projectSlug: input.projectSlug,
-        yaml: input.yaml,
-        ...(input.partials === undefined || input.partials.length === 0
-            ? {}
-            : { partials: input.partials }),
-    };
-}
-async function requestFailure(response, failureMessage, apiKey) {
-    const contentType = response.headers.get("content-type") ?? "";
-    if (!contentType.toLowerCase().includes("application/problem+json")) {
-        return new HubCommandError("HUB_REQUEST_FAILED", `${failureMessage} with HTTP ${response.status}.`);
-    }
-    let body;
-    try {
-        body = await response.json();
-    }
-    catch {
-        return new HubCommandError("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 HubCommandError("HUB_INVALID_RESPONSE", `Hub returned nonconforming problem details for HTTP ${response.status}.`);
-    }
-    const title = parsed.data.title ?? `${failureMessage} with HTTP ${response.status}`;
-    const message = parsed.data.detail === undefined ? title : `${title}: ${parsed.data.detail}`;
-    const details = formatFieldIssues(parsed.data.errors, parsed.data.issues);
-    const code = response.status === 422 ? "HUB_VALIDATION_FAILED" : "HUB_REQUEST_FAILED";
-    return new HubCommandError(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 secret === undefined ? value : value.split(secret).join("[redacted]");
-}
-//# sourceMappingURL=client.js.map

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

@@ -1,17 +0,0 @@
-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