@getpaseo/cli 0.3.0 → 0.4.0-beta.1

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.d.ts

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

@@ -1,114 +0,0 @@
-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/cloud-device-authorization.d.ts

@@ -1,45 +0,0 @@
-import { z } from "zod";
-declare const authorizationSchema: z.ZodObject<{
-    deviceCode: z.ZodString;
-    userCode: z.ZodString;
-    verificationUri: z.ZodURL;
-    verificationUriComplete: z.ZodURL;
-    expiresAt: z.ZodString;
-    interval: z.ZodNumber;
-}, z.core.$strip>;
-declare const pollSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    status: z.ZodLiteral<"pending">;
-    interval: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"slow_down">;
-    interval: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"approved">;
-    interval: z.ZodNumber;
-    enrollmentToken: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"denied">;
-    interval: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"expired">;
-    interval: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"enrolled">;
-    interval: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"retry_later">;
-}, z.core.$strip>], "status">;
-export type DeviceAuthorization = z.infer<typeof authorizationSchema>;
-export type DeviceAuthorizationPoll = z.infer<typeof pollSchema>;
-export interface CloudDeviceAuthorization {
-    start(hubUrl: string, displayName: string): Promise<DeviceAuthorization>;
-    poll(hubUrl: string, deviceCode: string, timeoutMilliseconds: number): Promise<DeviceAuthorizationPoll>;
-}
-export declare class CloudDeviceAuthorizationClient implements CloudDeviceAuthorization {
-    private readonly startTimeoutMilliseconds;
-    constructor(startTimeoutMilliseconds?: number);
-    start(hubUrl: string, displayName: string): Promise<DeviceAuthorization>;
-    poll(hubUrl: string, deviceCode: string, timeoutMilliseconds: number): Promise<DeviceAuthorizationPoll>;
-}
-export {};
-//# sourceMappingURL=cloud-device-authorization.d.ts.map

package/dist/commands/hub/cloud-device-authorization.js

@@ -1,92 +0,0 @@
-import { z } from "zod";
-const START_TIMEOUT_MS = 15000;
-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(5),
-});
-const pollSchema = z.discriminatedUnion("status", [
-    z.object({ status: z.literal("pending"), interval: z.number().int().min(5) }),
-    z.object({ status: z.literal("slow_down"), interval: z.number().int().min(5) }),
-    z.object({
-        status: z.literal("approved"),
-        interval: z.number().int().min(5),
-        enrollmentToken: z.string().min(32),
-    }),
-    z.object({ status: z.literal("denied"), interval: z.number().int().min(5) }),
-    z.object({ status: z.literal("expired"), interval: z.number().int().min(5) }),
-    z.object({ status: z.literal("enrolled"), interval: z.number().int().min(5) }),
-    z.object({ status: z.literal("retry_later") }),
-]);
-export class CloudDeviceAuthorizationClient {
-    constructor(startTimeoutMilliseconds = START_TIMEOUT_MS) {
-        this.startTimeoutMilliseconds = startTimeoutMilliseconds;
-    }
-    async start(hubUrl, displayName) {
-        const signal = AbortSignal.timeout(this.startTimeoutMilliseconds);
-        try {
-            const response = await fetch(endpoint(hubUrl, "/api/device-authorizations/"), {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify({ displayName }),
-                signal,
-            });
-            if (!response.ok)
-                throw new Error(`Cloud registration failed (${response.status})`);
-            return authorizationSchema.parse(await response.json());
-        }
-        catch (error) {
-            if (signal.aborted) {
-                throw new Error("Cloud registration start timed out", { cause: error });
-            }
-            throw error;
-        }
-    }
-    async poll(hubUrl, deviceCode, timeoutMilliseconds) {
-        const signal = AbortSignal.timeout(timeoutMilliseconds);
-        let response;
-        try {
-            response = await fetch(endpoint(hubUrl, "/api/device-authorizations/poll"), {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify({ deviceCode }),
-                signal,
-            });
-        }
-        catch {
-            return { status: "retry_later" };
-        }
-        if ([408, 425, 429].includes(response.status) || response.status >= 500) {
-            return { status: "retry_later" };
-        }
-        if (!response.ok)
-            throw new Error(`Cloud registration poll failed (${response.status})`);
-        let body;
-        try {
-            body = await response.json();
-        }
-        catch (error) {
-            if (signal.aborted || error instanceof TypeError)
-                return { status: "retry_later" };
-            throw error;
-        }
-        return pollSchema.parse(body);
-    }
-}
-function endpoint(hubUrl, pathname) {
-    const url = new URL(hubUrl);
-    if (!["http:", "https:"].includes(url.protocol) ||
-        url.username ||
-        url.password ||
-        url.search ||
-        url.hash) {
-        throw new Error("Hub URL must be an HTTP or HTTPS origin without credentials or a query");
-    }
-    url.pathname = `${url.pathname.replace(/\/$/u, "")}${pathname}`;
-    return url.toString();
-}
-//# sourceMappingURL=cloud-device-authorization.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