@getpaseo/cli 0.4.0-beta.2 → 0.4.0

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

@@ -2,6 +2,7 @@ import type { Command } from "commander";
 import { type SingleResult } from "../../output/index.js";
 import { HubHttpClient, type HubInstallResult, type HubValidationResult } from "./hub-client/index.js";
 import { type HubCredentialStore } from "./credentials.js";
+import { type HubDeployBundle } from "./deploy-bundle.js";
 import { type HubReporter } from "./reporter.js";
 export interface HubDeployOptions {
     project?: string;
@@ -10,7 +11,7 @@ export interface HubDeployOptions {
     dryRun?: boolean;
     json?: boolean;
 }
-interface HubDeployEnvironment {
+export interface HubDeployEnvironment {
     cwd: string;
     env: Readonly<Record<string, string | undefined>>;
     credentials?: HubCredentialStore;
@@ -33,6 +34,7 @@ interface HubDryRunResult extends HubValidationResult {
     workflows: number;
 }
 export declare function runHubDeploy(options: HubDeployOptions, environment?: HubDeployEnvironment): Promise<SingleResult<HubDeployResult> | SingleResult<HubDryRunResult>>;
+export declare function runHubDeployBundle(options: HubDeployOptions, deployInput: HubDeployBundle, environment: HubDeployEnvironment): Promise<SingleResult<HubDeployResult> | SingleResult<HubDryRunResult>>;
 export declare function addHubDeployCommand(hub: Command, dependencies: HubDeployCommandDependencies): void;
 export {};
 //# sourceMappingURL=deploy.d.ts.map

package/dist/commands/hub/deploy.js

@@ -32,6 +32,13 @@ export async function runHubDeploy(options, environment = {
     credentials: new PrivateHubCredentialStore(),
     hub: new HubHttpClient(),
 }) {
+    const deployInput = await discoverHubBundle({
+        cwd: environment.cwd,
+        ...(options.project === undefined ? {} : { project: options.project }),
+    });
+    return runHubDeployBundle(options, deployInput, environment);
+}
+export async function runHubDeployBundle(options, deployInput, environment) {
     const credentials = environment.credentials ?? new PrivateHubCredentialStore(environment.env);
     const resolution = {
         options: { origin: options.hub, apiKey: options.apiKey },
@@ -39,10 +46,6 @@ export async function runHubDeploy(options, environment = {
         credentials,
     };
     const origin = resolveHubOrigin(resolution);
-    const deployInput = await discoverHubBundle({
-        cwd: environment.cwd,
-        ...(options.project === undefined ? {} : { project: options.project }),
-    });
     const action = options.dryRun === true ? "Validating" : "Deploying";
     reportHubProgress(environment.reporter ?? processHubReporter, options, `${action} ${deployInput.projectSlug} ${options.dryRun === true ? "against" : "to"} ${origin}`);
     const credential = resolveHubCredential({ ...resolution, origin });

package/dist/commands/hub/disconnect.js

@@ -10,13 +10,13 @@ export function runHubDisconnect(options, dependencies) {
             reportHubProgress(dependencies.reporter, options, `Disconnecting this daemon from ${current.hubOrigin}`);
         }
         const response = await client.disconnectHub(options.force ?? false);
-        return hubStatusResult(response.status, response.warning, current.hubOrigin);
+        return hubStatusResult(response.status, response.warning);
     });
 }
 export function addHubDisconnectCommand(parent, dependencies) {
     addJsonAndDaemonHostOptions(parent
         .command("disconnect")
-        .option("--force", "Remove local authority even if the Hub is offline")).action(withOutput(async (...args) => {
+        .option("--force", "Remove local authority without notifying the Hub")).action(withOutput(async (...args) => {
         const options = args.at(-2);
         return runHubDisconnect(options, dependencies);
     }));

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

@@ -1,6 +1,6 @@
 import type { HubBundleFile } from "../deploy-bundle.js";
-import { type CliAuthorization, type CliAuthorizationPoll, type HubInstallResult, type HubProject, type HubValidationResult } from "./internal/contracts.js";
-export type { CliAuthorization, CliAuthorizationPoll, HubInstallResult, HubProject, HubValidationResult, } from "./internal/contracts.js";
+import { type CliAuthorization, type CliAuthorizationPoll, type HubInstallResult, type HubConfigurationResources, type HubProject, type HubValidationResult } from "./internal/contracts.js";
+export type { CliAuthorization, CliAuthorizationPoll, HubInstallResult, HubConfigurationResources, HubProject, HubValidationResult, } from "./internal/contracts.js";
 interface HubConfigurationInput {
     origin: string;
     apiKey: string;
@@ -11,6 +11,7 @@ export declare class HubHttpClient {
     startCliAuthorization(origin: string): Promise<CliAuthorization>;
     pollCliAuthorization(origin: string, deviceCode: string, timeoutMilliseconds: number): Promise<CliAuthorizationPoll>;
     listProjects(origin: string, apiKey: string): Promise<HubProject[]>;
+    listConfigurationResources(origin: string, apiKey: string): Promise<HubConfigurationResources>;
     installConfiguration(input: HubConfigurationInput): Promise<HubInstallResult>;
     validateConfiguration(input: HubConfigurationInput): Promise<HubValidationResult>;
     issueEnrollmentToken(origin: string, apiKey: string): Promise<string>;

package/dist/commands/hub/hub-client/index.js

@@ -1,5 +1,5 @@
 import { HubCommandError } from "../error.js";
-import { authorizationPollSchema, authorizationSchema, enrollmentTokenSchema, installResponseSchema, projectsResponseSchema, validationResponseSchema, } from "./internal/contracts.js";
+import { authorizationPollSchema, authorizationSchema, configurationResourcesSchema, enrollmentTokenSchema, installResponseSchema, projectsResponseSchema, validationResponseSchema, } from "./internal/contracts.js";
 import { requestHub } from "./internal/transport.js";
 export class HubHttpClient {
     startCliAuthorization(origin) {
@@ -45,6 +45,17 @@ export class HubHttpClient {
         });
         return response.projects;
     }
+    listConfigurationResources(origin, apiKey) {
+        return requestHub({
+            origin,
+            path: "/api/v1/configuration-resources",
+            method: "GET",
+            apiKey,
+            successStatus: 200,
+            schema: configurationResourcesSchema,
+            failureMessage: "Hub configuration resource listing failed",
+        });
+    }
     installConfiguration(input) {
         return requestHub({
             origin: input.origin,

package/dist/commands/hub/hub-client/internal/contracts.d.ts

@@ -42,6 +42,26 @@ export declare const projectsResponseSchema: z.ZodObject<{
         name: z.ZodString;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+export declare const configurationResourcesSchema: z.ZodObject<{
+    daemons: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        slug: z.ZodString;
+    }, z.core.$strict>>;
+    github: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        accountLogin: z.ZodString;
+        accountType: z.ZodString;
+        repositories: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    discord: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        guildName: z.ZodString;
+    }, z.core.$strict>>;
+    slack: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        teamName: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export declare const installResponseSchema: z.ZodObject<{
     projectSlug: z.ZodString;
     version: z.ZodNumber;
@@ -59,6 +79,7 @@ export declare const enrollmentTokenSchema: z.ZodObject<{
 export type CliAuthorization = z.infer<typeof authorizationSchema>;
 export type CliAuthorizationPoll = z.infer<typeof authorizationPollSchema>;
 export type HubProject = z.infer<typeof projectSchema>;
+export type HubConfigurationResources = z.infer<typeof configurationResourcesSchema>;
 export type HubInstallResult = z.infer<typeof installResponseSchema>;
 export type HubValidationResult = z.infer<typeof validationResponseSchema>;
 export {};

package/dist/commands/hub/hub-client/internal/contracts.js

@@ -30,6 +30,21 @@ const projectSchema = z
     .object({ id: z.string().uuid(), slug: z.string().min(1), name: z.string().min(1) })
     .strict();
 export const projectsResponseSchema = z.object({ projects: z.array(projectSchema) }).strict();
+export const configurationResourcesSchema = z
+    .object({
+    daemons: z.array(z.object({ id: z.string().uuid(), slug: z.string().min(1) }).strict()),
+    github: z.array(z
+        .object({
+        slug: z.string().min(1),
+        accountLogin: z.string().min(1),
+        accountType: z.string().min(1),
+        repositories: z.array(z.string().min(1)),
+    })
+        .strict()),
+    discord: z.array(z.object({ slug: z.string().min(1), guildName: z.string().min(1) }).strict()),
+    slack: z.array(z.object({ slug: z.string().min(1), teamName: z.string().min(1) }).strict()),
+})
+    .strict();
 export const installResponseSchema = z
     .object({
     projectSlug: z.string().min(1),

package/dist/commands/hub/hub-client/internal/problem.js

@@ -35,9 +35,15 @@ export async function hubRequestFailure(response, failureMessage, apiKey) {
         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";
+    const message = details !== undefined || parsed.data.detail === undefined
+        ? title
+        : `${title}: ${parsed.data.detail}`;
+    let code = "HUB_REQUEST_FAILED";
+    if (response.status === 422)
+        code = "HUB_VALIDATION_FAILED";
+    if (response.status === 404)
+        code = "HUB_NOT_FOUND";
     return new HubCommandError(code, redactSecret(message, apiKey), details === undefined ? undefined : redactSecret(details, apiKey));
 }
 function formatFieldIssues(errors, issues) {
@@ -57,6 +63,13 @@ function formatFieldIssues(errors, issues) {
 function formatIssuePath(path) {
     if (path === undefined || typeof path === "string")
         return path;
+    const [file, ...fieldPath] = path;
+    if (typeof file === "string" && file.startsWith(".paseo/") && fieldPath.length > 0) {
+        return `${file}: ${formatPathSegments(fieldPath)}`;
+    }
+    return formatPathSegments(path) || undefined;
+}
+function formatPathSegments(path) {
     let formatted = "";
     for (const segment of path) {
         if (typeof segment === "number")
@@ -64,7 +77,7 @@ function formatIssuePath(path) {
         else
             formatted += formatted.length === 0 ? segment : `.${segment}`;
     }
-    return formatted || undefined;
+    return formatted;
 }
 function redactSecret(value, secret) {
     return secret === undefined ? value : value.split(secret).join("[redacted]");

package/dist/commands/hub/index.js

@@ -14,6 +14,7 @@ import { addHubProjectsCommand } from "./projects.js";
 import { processHubReporter } from "./reporter.js";
 import { hubStatusResult } from "./status-output.js";
 import { addHubResolutionHelp } from "./help.js";
+import { addHubInitCommand } from "./init.js";
 function productionEnvironment() {
     const env = process.env;
     const hub = new HubHttpClient();
@@ -37,6 +38,7 @@ export function createHubCommand(overrides = {}) {
         flow: environment.login,
         reporter: environment.reporter,
     });
+    addHubInitCommand(hub, environment);
     addHubConnectCommand(hub, {
         env: environment.env,
         credentials: environment.credentials,

package/dist/commands/hub/init-plan.d.ts

@@ -0,0 +1,50 @@
+import type { HubDeployBundle } from "./deploy-bundle.js";
+import type { HubProject } from "./hub-client/index.js";
+import type { HubStatus } from "./daemon-client.js";
+export type HubInitProvider = "github" | "slack" | "discord";
+export type HubInitProjectResolution = {
+    kind: "none";
+} | {
+    kind: "selected";
+    project: HubProject;
+} | {
+    kind: "choose";
+    projects: readonly HubProject[];
+};
+export type HubInitConnectionResolution = {
+    kind: "connected";
+    daemonId: string;
+} | {
+    kind: "pending";
+    state: "connecting" | "reconnecting";
+} | {
+    kind: "connect";
+} | {
+    kind: "conflict";
+    origin: string;
+};
+export interface HubInitOpeningPlan {
+    replaceExisting: boolean;
+    steps: readonly ("login" | "connect" | "project" | "scaffold")[];
+}
+export interface HubInitScaffoldInput {
+    cwd: string;
+    daemonSlug: string;
+    provider: HubInitProvider;
+    providerFilters: Readonly<Record<string, string>>;
+}
+export interface HubInitScaffold {
+    hub: string;
+    workflowPath: string;
+    workflow: string;
+    testAction: string;
+}
+export declare function planHubInitOpening(input: {
+    loggedIn: boolean;
+    paseoDirectoryExists: boolean;
+}): HubInitOpeningPlan;
+export declare function createHubInitBundle(projectSlug: string, scaffold: HubInitScaffold): HubDeployBundle;
+export declare function resolveHubInitProjects(projects: readonly HubProject[]): HubInitProjectResolution;
+export declare function resolveHubInitConnection(status: HubStatus, origin: string): HubInitConnectionResolution;
+export declare function createHubInitScaffold(input: HubInitScaffoldInput): HubInitScaffold;
+//# sourceMappingURL=init-plan.d.ts.map

package/dist/commands/hub/init-plan.js

@@ -0,0 +1,136 @@
+import path from "node:path";
+import YAML from "yaml";
+export function planHubInitOpening(input) {
+    return {
+        replaceExisting: input.paseoDirectoryExists,
+        steps: [...(input.loggedIn ? [] : ["login"]), "connect", "project", "scaffold"],
+    };
+}
+export function createHubInitBundle(projectSlug, scaffold) {
+    return {
+        projectSlug,
+        workflowCount: 1,
+        files: [
+            { path: ".paseo/hub.yml", content: scaffold.hub },
+            { path: scaffold.workflowPath, content: scaffold.workflow },
+        ],
+    };
+}
+export function resolveHubInitProjects(projects) {
+    if (projects.length === 0)
+        return { kind: "none" };
+    if (projects.length === 1)
+        return { kind: "selected", project: projects[0] };
+    return { kind: "choose", projects };
+}
+export function resolveHubInitConnection(status, origin) {
+    if (status.state === "connected" && status.hubOrigin === origin && status.daemonId !== null) {
+        return { kind: "connected", daemonId: status.daemonId };
+    }
+    if ((status.state === "connecting" || status.state === "reconnecting") &&
+        status.hubOrigin === origin) {
+        return { kind: "pending", state: status.state };
+    }
+    if (status.hubOrigin !== null && status.state !== "not_connected" && status.state !== "revoked") {
+        return { kind: "conflict", origin: status.hubOrigin };
+    }
+    return { kind: "connect" };
+}
+export function createHubInitScaffold(input) {
+    const environmentName = input.daemonSlug;
+    const hub = YAML.stringify({
+        environments: {
+            [environmentName]: {
+                kind: "daemon",
+                daemon: input.daemonSlug,
+                cwd: path.resolve(input.cwd),
+            },
+        },
+        agents: {
+            codex: {
+                provider: "codex",
+                mode: "full-access",
+            },
+        },
+    }, { lineWidth: 0 });
+    const provider = providerScaffold(input.provider, input.providerFilters, environmentName);
+    return {
+        hub,
+        workflowPath: `.paseo/workflows/${input.provider}-help.yml`,
+        workflow: YAML.stringify(provider.workflow, { lineWidth: 0 }),
+        testAction: provider.testAction,
+    };
+}
+function providerScaffold(provider, filters, environment) {
+    if (provider === "github") {
+        const repo = requireFilter(filters, "repo");
+        const user = requireFilter(filters, "user");
+        return {
+            workflow: workflow({
+                name: "github-help",
+                on: "github.issue_comment",
+                filters: { repo, contains: "@paseo", from_users: [user] },
+                environment,
+            }),
+            testAction: `Comment \`@paseo have a look\` on ${repo}.`,
+        };
+    }
+    const user = requireFilter(filters, "user");
+    if (provider === "slack") {
+        const workspace = requireFilter(filters, "workspace");
+        return {
+            workflow: workflow({
+                name: "slack-help",
+                on: "slack.mention",
+                filters: { workspace, from_users: [user] },
+                environment,
+                reply: "slack.reply",
+            }),
+            testAction: "Mention `@Paseo have a look` in Slack.",
+        };
+    }
+    const guild = requireFilter(filters, "guild");
+    return {
+        workflow: workflow({
+            name: "discord-help",
+            on: "discord.mention",
+            filters: { guild, from_users: [user] },
+            environment,
+            reply: "discord.reply",
+        }),
+        testAction: "Mention `@Paseo have a look` in Discord.",
+    };
+}
+function workflow(input) {
+    const replyInstruction = input.reply === undefined ? "" : "Answer with hub.reply, then ";
+    return {
+        name: input.name,
+        on: input.on,
+        max_runtime: "2h",
+        filters: input.filters,
+        steps: [
+            {
+                id: "work",
+                environment: input.environment,
+                max_runtime: "90m",
+                idle_timeout: "10m",
+                agent: "codex",
+                prompt: [
+                    {
+                        text: `${replyInstruction}complete this request and call hub.finish_execution when done.\n\n<user-prompt>\n\${{ paseo.prompt }}\n</user-prompt>\n`,
+                    },
+                ],
+                ...(input.reply === undefined
+                    ? {}
+                    : { allow_outputs: [{ type: input.reply, max: 1, required: true }] }),
+            },
+        ],
+    };
+}
+function requireFilter(filters, name) {
+    const value = filters[name]?.trim();
+    if (!value)
+        throw new Error(`${name} is required for this provider`);
+    return value;
+}
+//# sourceMappingURL=init-plan.js.map

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

@@ -0,0 +1,20 @@
+import type { Command } from "commander";
+import type { HubCredentialStore } from "./credentials.js";
+import type { HubDaemonConnection } from "./daemon-client.js";
+import type { HubHttpClient } from "./hub-client/index.js";
+import type { CliLoginFlow } from "./login-flow.js";
+import type { HubReporter } from "./reporter.js";
+interface HubInitEnvironment {
+    env: Readonly<Record<string, string | undefined>>;
+    credentials: HubCredentialStore;
+    hub: HubHttpClient;
+    login: Pick<CliLoginFlow, "authorize">;
+    daemon: HubDaemonConnection;
+    reporter: HubReporter;
+    cwd(): string;
+}
+export declare function addHubInitCommand(parent: Command, environment: HubInitEnvironment): void;
+export declare function runHubInit(environment: HubInitEnvironment): Promise<void>;
+export declare function githubRepositoryFromRemote(remote: string): string | undefined;
+export {};
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/hub/init.js

@@ -0,0 +1,415 @@
+import { cancel, confirm, intro, isCancel, log, note, outro, select, spinner, text, } from "@clack/prompts";
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { DEFAULT_HUB_ORIGIN, resolveHubCredential } from "./authority.js";
+import { withHubDaemon } from "./daemon-client.js";
+import { HubCommandError } from "./error.js";
+import { createHubInitBundle, createHubInitScaffold, planHubInitOpening, resolveHubInitConnection, resolveHubInitProjects, } from "./init-plan.js";
+import { runHubLogin } from "./login.js";
+import { runHubConnect } from "./connect.js";
+import { runHubDeployBundle } from "./deploy.js";
+import { runHubProjects } from "./projects.js";
+import { normalizeHubOrigin } from "./origin.js";
+const execFileAsync = promisify(execFile);
+const DAEMON_READY_TIMEOUT_MS = 60000;
+const DAEMON_READY_POLL_MS = 250;
+class HubInitCancelledError extends Error {
+}
+function initErrorMessage(error) {
+    if (error instanceof HubCommandError && error.details) {
+        return `${error.message}\n${error.details}`;
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+export function addHubInitCommand(parent, environment) {
+    parent
+        .command("init")
+        .description("Create and optionally deploy a safe starter Hub bundle")
+        .action(async () => {
+        try {
+            await runHubInit(environment);
+        }
+        catch (error) {
+            if (error instanceof HubInitCancelledError) {
+                cancel(error.message);
+                return;
+            }
+            cancel(initErrorMessage(error));
+            process.exitCode = 1;
+        }
+    });
+}
+export async function runHubInit(environment) {
+    requireInteractiveTerminal();
+    intro("Set up Paseo Hub");
+    const cwd = environment.cwd();
+    const activeLogin = environment.credentials.active();
+    const opening = planHubInitOpening({
+        loggedIn: activeLogin !== null,
+        paseoDirectoryExists: await pathExists(path.join(cwd, ".paseo")),
+    });
+    if (opening.replaceExisting &&
+        !(await requiredConfirm("Replace the existing .paseo/ Hub bundle?", false))) {
+        throw new HubInitCancelledError("Existing .paseo/ bundle left unchanged.");
+    }
+    const origin = await ensureLogin(activeLogin?.origin, environment);
+    const daemonId = await ensureDaemonConnection(origin, environment);
+    const project = await chooseProject(origin, environment);
+    const resources = await loadConfigurationResources(origin, environment);
+    const daemon = resources.daemons.find(({ id }) => id === daemonId);
+    if (daemon === undefined) {
+        throw new HubCommandError("HUB_DAEMON_RESOURCE_MISSING", "The connected daemon is not available in this Hub organization. Reconnect it and try again.");
+    }
+    log.success(`Connected as ${daemon.slug}`);
+    const provider = await chooseProvider();
+    const providerFilters = await collectProviderFilters(provider, resources, cwd);
+    const scaffold = createHubInitScaffold({
+        cwd,
+        daemonSlug: daemon.slug,
+        provider,
+        providerFilters,
+    });
+    const bundle = createHubInitBundle(project.slug, scaffold);
+    await withSpinner("Validating bundle", async () => {
+        await runHubDeployBundle({ project: project.slug, hub: origin, dryRun: true }, bundle, {
+            cwd,
+            env: environment.env,
+            credentials: environment.credentials,
+            hub: environment.hub,
+            reporter: { progress() { } },
+        });
+    });
+    log.success("Dry run passed");
+    await writeScaffold(cwd, scaffold, opening.replaceExisting);
+    log.success(`Created .paseo/hub.yml and ${scaffold.workflowPath}`);
+    const deploy = await requiredConfirm("Deploy now?", true);
+    if (deploy) {
+        await withSpinner("Deploying bundle", async () => {
+            await runHubDeployBundle({ project: project.slug, hub: origin }, bundle, {
+                cwd,
+                env: environment.env,
+                credentials: environment.credentials,
+                hub: environment.hub,
+                reporter: { progress() { } },
+            });
+        });
+        log.success("Deployed");
+    }
+    else {
+        log.message(`Skipped deployment. Run: paseo hub deploy -p ${project.slug}`);
+    }
+    const activityUrl = new URL(`/projects/${project.slug}/activity`, origin).toString();
+    note(`${scaffold.testAction}\nWatch it at ${activityUrl}`, "Test your workflow");
+    outro(deploy ? "Hub is ready" : "Hub bundle is ready");
+}
+async function ensureLogin(activeOrigin, environment) {
+    const endpoint = await requiredSelect({
+        message: "Hub endpoint",
+        initialValue: activeOrigin === undefined || activeOrigin === DEFAULT_HUB_ORIGIN ? "hosted" : "custom",
+        options: [
+            { value: "hosted", label: "hub.paseo.sh" },
+            { value: "custom", label: "Custom endpoint…" },
+        ],
+    });
+    const origin = endpoint === "hosted"
+        ? DEFAULT_HUB_ORIGIN
+        : await requiredText({
+            message: "Custom Hub URL",
+            initialValue: activeOrigin === undefined || activeOrigin === DEFAULT_HUB_ORIGIN
+                ? environment.env.PASEO_HUB_URL
+                : activeOrigin,
+            validate(value) {
+                try {
+                    normalizeHubOrigin(value ?? "");
+                }
+                catch {
+                    return "Enter a valid Hub URL";
+                }
+                return undefined;
+            },
+        });
+    const normalizedOrigin = normalizeHubOrigin(origin);
+    if (environment.credentials.get(normalizedOrigin) !== null) {
+        log.success(`Logged in to ${normalizedOrigin}`);
+        return normalizedOrigin;
+    }
+    await runHubLogin(normalizedOrigin, {}, {
+        env: environment.env,
+        credentials: environment.credentials,
+        flow: environment.login,
+        reporter: environment.reporter,
+    });
+    log.success(`Logged in to ${normalizedOrigin}`);
+    return normalizedOrigin;
+}
+async function ensureDaemonConnection(origin, environment) {
+    const status = await withHubDaemon(environment.daemon, undefined, async (daemon) => daemon.getHubStatus().then((response) => response.status));
+    const connection = resolveHubInitConnection(status, origin);
+    if (connection.kind === "connected") {
+        return connection.daemonId;
+    }
+    if (connection.kind === "pending") {
+        return waitForDaemonReady(origin, environment.daemon);
+    }
+    if (connection.kind === "conflict") {
+        throw new HubCommandError("HUB_DAEMON_ALREADY_CONNECTED", `This daemon is connected to ${connection.origin}. Disconnect it before running Hub init for ${origin}.`);
+    }
+    if (!(await requiredConfirm(`Connect this daemon to ${origin}?`, true))) {
+        throw new HubInitCancelledError("A connected daemon is required to create the bundle.");
+    }
+    await runHubConnect(origin, {}, {
+        env: environment.env,
+        credentials: environment.credentials,
+        hub: environment.hub,
+        daemon: environment.daemon,
+        reporter: environment.reporter,
+    });
+    return waitForDaemonReady(origin, environment.daemon);
+}
+async function waitForDaemonReady(origin, connection) {
+    return withSpinner("Waiting for the daemon to connect", async (reporter) => withHubDaemon(connection, undefined, async (daemon) => {
+        const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
+        while (true) {
+            const status = (await daemon.getHubStatus()).status;
+            const resolution = resolveHubInitConnection(status, origin);
+            if (resolution.kind === "connected")
+                return resolution.daemonId;
+            if (resolution.kind === "conflict") {
+                throw new HubCommandError("HUB_DAEMON_ALREADY_CONNECTED", `This daemon connected to ${resolution.origin} while Hub init was waiting for ${origin}.`);
+            }
+            if (resolution.kind === "connect") {
+                throw new HubCommandError("HUB_DAEMON_CONNECTION_LOST", "The daemon lost its Hub relationship while Hub init was waiting for it.");
+            }
+            if (Date.now() >= deadline) {
+                throw new HubCommandError("HUB_DAEMON_CONNECTION_TIMEOUT", "The daemon did not connect within 60 seconds. Check `paseo hub status`, then run Hub init again.");
+            }
+            reporter.progress(`Daemon is ${resolution.state}`);
+            await delay(DAEMON_READY_POLL_MS);
+        }
+    }));
+}
+async function chooseProject(origin, environment) {
+    const result = await runHubProjects({ hub: origin }, {
+        env: environment.env,
+        credentials: environment.credentials,
+        hub: environment.hub,
+        reporter: { progress() { } },
+    });
+    const resolution = resolveHubInitProjects(result.data.projects);
+    if (resolution.kind === "none") {
+        throw new HubInitCancelledError(`No Hub projects exist yet. Create one at ${new URL("/projects/new", origin).toString()}, then run paseo hub init again.`);
+    }
+    if (resolution.kind === "selected") {
+        return resolution.project;
+    }
+    const slug = await requiredSelect({
+        message: "Project",
+        options: resolution.projects.map((project) => ({
+            value: project.slug,
+            label: project.name,
+            hint: project.slug,
+        })),
+    });
+    const project = resolution.projects.find((candidate) => candidate.slug === slug);
+    if (project === undefined) {
+        throw new HubCommandError("HUB_PROJECT_SELECTION_INVALID", "The selected Hub project is unavailable.");
+    }
+    return project;
+}
+async function chooseProvider() {
+    return requiredSelect({
+        message: "Trigger provider",
+        options: [
+            { value: "github", label: "GitHub", hint: "issue or pull request comment" },
+            { value: "slack", label: "Slack", hint: "channel mention" },
+            { value: "discord", label: "Discord", hint: "channel mention" },
+        ],
+    });
+}
+async function collectProviderFilters(provider, resources, cwd) {
+    if (provider === "github") {
+        const [login, originRemote] = await Promise.all([
+            readGhValue(["api", "user", "--jq", ".login"]),
+            readCommandValue("git", ["remote", "get-url", "origin"], cwd),
+        ]);
+        const repo = originRemote === undefined ? undefined : githubRepositoryFromRemote(originRemote);
+        if (repo === undefined) {
+            throw new HubCommandError("HUB_GITHUB_REPOSITORY_UNDETECTED", "Could not detect a GitHub repository from the origin remote.");
+        }
+        if (!resources.github.some(({ repositories }) => repositories.includes(repo))) {
+            const connected = resources.github.flatMap(({ repositories }) => repositories);
+            throw new HubCommandError("HUB_GITHUB_REPOSITORY_NOT_CONNECTED", `${repo} is not connected to this Hub organization. Connected repositories: ${connected.join(", ") || "none"}.`);
+        }
+        return {
+            user: await requiredText({
+                message: "Your GitHub username (only this user can trigger the bot)",
+                initialValue: login,
+            }),
+            repo,
+        };
+    }
+    if (provider === "slack") {
+        return {
+            workspace: await chooseConnection("Slack workspace", resources.slack.map(({ slug, teamName }) => ({ slug, label: teamName }))),
+            user: await requiredText({
+                message: "Your Slack username (only this user can trigger the bot)",
+            }),
+        };
+    }
+    return {
+        guild: await chooseConnection("Discord server", resources.discord.map(({ slug, guildName }) => ({ slug, label: guildName }))),
+        user: await requiredText({
+            message: "Your Discord username (only this user can trigger the bot)",
+        }),
+    };
+}
+async function loadConfigurationResources(origin, environment) {
+    try {
+        return await withSpinner("Loading Hub connections", () => environment.hub.listConfigurationResources(origin, resolveHubCredential({
+            options: { origin },
+            env: environment.env,
+            credentials: environment.credentials,
+            origin,
+        })));
+    }
+    catch (error) {
+        if (error instanceof HubCommandError && error.code === "HUB_NOT_FOUND") {
+            throw new HubCommandError("HUB_UPDATE_REQUIRED", "This Hub does not support guided setup. Update the Hub and try again.");
+        }
+        throw error;
+    }
+}
+async function chooseConnection(message, connections) {
+    if (connections.length === 0) {
+        throw new HubCommandError("HUB_PROVIDER_CONNECTION_REQUIRED", `No ${message.toLowerCase()} is connected in this Hub organization. Connect one and try again.`);
+    }
+    if (connections.length === 1)
+        return connections[0].slug;
+    return requiredSelect({
+        message,
+        options: connections.map(({ slug, label }) => ({ value: slug, label })),
+    });
+}
+async function writeScaffold(cwd, scaffold, replaceExisting) {
+    const root = path.join(cwd, ".paseo");
+    const staging = path.join(cwd, `.paseo-init-${randomUUID()}`);
+    const backup = path.join(cwd, `.paseo-backup-${randomUUID()}`);
+    let movedExisting = false;
+    try {
+        await mkdir(path.join(staging, "workflows"), { recursive: true });
+        await writeFile(path.join(staging, "hub.yml"), scaffold.hub, { flag: "wx" });
+        await writeFile(path.join(staging, "workflows", path.basename(scaffold.workflowPath)), scaffold.workflow, {
+            flag: "wx",
+        });
+        if (replaceExisting) {
+            await rename(root, backup);
+            movedExisting = true;
+        }
+        await rename(staging, root);
+        if (movedExisting)
+            await rm(backup, { recursive: true, force: true });
+    }
+    catch (error) {
+        await rm(staging, { recursive: true, force: true });
+        if (movedExisting) {
+            await rename(backup, root).catch(() => undefined);
+        }
+        throw error;
+    }
+}
+async function pathExists(target) {
+    try {
+        await lstat(target);
+        return true;
+    }
+    catch (error) {
+        if (errorCode(error) === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+function errorCode(error) {
+    return error instanceof Error && "code" in error && typeof error.code === "string"
+        ? error.code
+        : undefined;
+}
+function delay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function readGhValue(args) {
+    return readCommandValue("gh", args);
+}
+async function readCommandValue(command, args, cwd) {
+    try {
+        const { stdout } = await execFileAsync(command, [...args], { encoding: "utf8", cwd });
+        return stdout.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function githubRepositoryFromRemote(remote) {
+    const trimmed = remote.trim().replace(/\.git$/u, "");
+    const ssh = /^(?:ssh:\/\/)?git@github\.com[:/]([^/]+\/[^/]+)$/u.exec(trimmed);
+    if (ssh?.[1] !== undefined)
+        return ssh[1];
+    try {
+        const url = new URL(trimmed);
+        if (url.hostname !== "github.com")
+            return undefined;
+        const repository = url.pathname.replace(/^\//u, "");
+        return /^[^/]+\/[^/]+$/u.test(repository) ? repository : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function withSpinner(message, action) {
+    const progress = spinner();
+    progress.start(message);
+    try {
+        const result = await action({ progress: (nextMessage) => progress.message(nextMessage) });
+        progress.stop(message);
+        return result;
+    }
+    catch (error) {
+        progress.error(message);
+        throw error;
+    }
+}
+async function requiredText(options) {
+    const answer = await text({
+        ...options,
+        validate(value) {
+            const input = value ?? "";
+            const customError = options.validate?.(input);
+            if (customError !== undefined)
+                return customError;
+            return input.trim().length === 0 ? "A value is required" : undefined;
+        },
+    });
+    if (isCancel(answer))
+        throw new HubInitCancelledError("Hub init cancelled.");
+    return answer.trim();
+}
+async function requiredConfirm(message, initialValue) {
+    const answer = await confirm({ message, initialValue });
+    if (isCancel(answer))
+        throw new HubInitCancelledError("Hub init cancelled.");
+    return answer;
+}
+async function requiredSelect(options) {
+    const answer = await select(options);
+    if (isCancel(answer))
+        throw new HubInitCancelledError("Hub init cancelled.");
+    return answer;
+}
+function requireInteractiveTerminal() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new HubCommandError("HUB_INIT_INTERACTIVE_REQUIRED", "paseo hub init requires a TTY.");
+    }
+}
+//# sourceMappingURL=init.js.map

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

@@ -7,6 +7,7 @@ interface HubLogoutResult {
     origin: string | null;
     status: "logged_out" | "not_logged_in";
     daemonDisconnected: boolean;
+    warning?: string;
 }
 interface HubLogoutOptions {
     disconnectDaemon?: boolean;

package/dist/commands/hub/logout.js

@@ -9,6 +9,7 @@ const schema = {
         { header: "HUB", field: "origin" },
         { header: "STATUS", field: "status" },
         { header: "DAEMON DISCONNECTED", field: "daemonDisconnected" },
+        { header: "WARNING", field: "warning" },
     ],
 };
 export async function runHubLogout(options, dependencies) {
@@ -33,18 +34,23 @@ export async function runHubLogout(options, dependencies) {
         return logoutResult({ origin: active.origin, status: "logged_out", daemonDisconnected: false });
     }
     reportHubProgress(dependencies.reporter, options, `Disconnecting this daemon from ${active.origin}`);
-    await withHubDaemon(dependencies.daemon, options.host, async (daemon) => {
-        await daemon.disconnectHub(options.force ?? false);
+    const disconnect = await withHubDaemon(dependencies.daemon, options.host, async (daemon) => {
+        return daemon.disconnectHub(options.force ?? false);
     });
     dependencies.credentials.logoutActive();
-    return logoutResult({ origin: active.origin, status: "logged_out", daemonDisconnected: true });
+    return logoutResult({
+        origin: active.origin,
+        status: "logged_out",
+        daemonDisconnected: disconnect.status.state === "not_connected",
+        ...(disconnect.warning ? { warning: disconnect.warning } : {}),
+    });
 }
 export function addHubLogoutCommand(parent, dependencies) {
     addJsonAndDaemonHostOptions(parent
         .command("logout")
         .description("Remove the active stored Hub CLI login")
         .option("--disconnect-daemon", "Also disconnect a daemon related to the same Hub")
-        .option("--force", "Remove daemon authority even if Hub is offline")).action(withOutput(async (...args) => {
+        .option("--force", "Remove daemon authority without notifying the Hub")).action(withOutput(async (...args) => {
         const options = args.at(-2);
         return runHubLogout(options, dependencies);
     }));

package/package.json

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