@getpaseo/cli 0.5.0-beta.4 → 0.5.0-beta.5

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

@@ -1,3 +1,4 @@
+import type { ProviderSnapshotEntry } from "@getpaseo/protocol/agent-types";
 export interface HubStatus {
     state: string;
     daemonId: string | null;
@@ -6,6 +7,9 @@ export interface HubStatus {
     connectedAt: string | null;
     lastError: string | null;
 }
+export interface HubProvidersSnapshotOptions {
+    cwd?: string;
+}
 export interface HubDaemonClient {
     connectHub(url: string, token: string): Promise<{
         status: HubStatus;
@@ -17,6 +21,9 @@ export interface HubDaemonClient {
         status: HubStatus;
         warning?: string;
     }>;
+    getProvidersSnapshot(options?: HubProvidersSnapshotOptions): Promise<{
+        entries: ProviderSnapshotEntry[];
+    }>;
     close(): Promise<void>;
 }
 export interface HubDaemonConnection {

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 HubConfigurationResources, type HubProject, type HubValidationResult } from "./internal/contracts.js";
-export type { CliAuthorization, CliAuthorizationPoll, HubInstallResult, HubConfigurationResources, HubProject, HubValidationResult, } from "./internal/contracts.js";
+import { type CliAuthorization, type CliAuthorizationPoll, type HubInstallResult, type HubConfigurationResources, type HubSetupResources, type HubProject, type HubValidationResult } from "./internal/contracts.js";
+export type { CliAuthorization, CliAuthorizationPoll, HubInstallResult, HubConfigurationResources, HubSetupResources, HubProject, HubValidationResult, } from "./internal/contracts.js";
 interface HubConfigurationInput {
     origin: string;
     apiKey: string;
@@ -12,6 +12,7 @@ export declare class HubHttpClient {
     pollCliAuthorization(origin: string, deviceCode: string, timeoutMilliseconds: number): Promise<CliAuthorizationPoll>;
     listProjects(origin: string, apiKey: string): Promise<HubProject[]>;
     listConfigurationResources(origin: string, apiKey: string): Promise<HubConfigurationResources>;
+    listSetupResources(origin: string, apiKey: string): Promise<HubSetupResources>;
     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, configurationResourcesSchema, enrollmentTokenSchema, installResponseSchema, projectsResponseSchema, validationResponseSchema, } from "./internal/contracts.js";
+import { authorizationPollSchema, authorizationSchema, configurationResourcesSchema, enrollmentTokenSchema, installResponseSchema, projectsResponseSchema, validationResponseSchema, setupResourcesSchema, } from "./internal/contracts.js";
 import { requestHub } from "./internal/transport.js";
 export class HubHttpClient {
     startCliAuthorization(origin) {
@@ -56,6 +56,17 @@ export class HubHttpClient {
             failureMessage: "Hub configuration resource listing failed",
         });
     }
+    listSetupResources(origin, apiKey) {
+        return requestHub({
+            origin,
+            path: "/api/v1/setup-resources",
+            method: "GET",
+            apiKey,
+            successStatus: 200,
+            schema: setupResourcesSchema,
+            failureMessage: "Hub guided setup resource listing failed",
+        });
+    }
     installConfiguration(input) {
         return requestHub({
             origin: input.origin,

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

@@ -62,6 +62,22 @@ export declare const configurationResourcesSchema: z.ZodObject<{
         teamName: z.ZodString;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+export declare const setupResourcesSchema: z.ZodObject<{
+    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<{
+        guildId: z.ZodString;
+        guildName: z.ZodString;
+    }, z.core.$strict>>;
+    slack: z.ZodArray<z.ZodObject<{
+        teamId: z.ZodString;
+        teamName: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export declare const installResponseSchema: z.ZodObject<{
     projectSlug: z.ZodString;
     version: z.ZodNumber;
@@ -80,6 +96,7 @@ 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 HubSetupResources = z.infer<typeof setupResourcesSchema>;
 export type HubInstallResult = z.infer<typeof installResponseSchema>;
 export type HubValidationResult = z.infer<typeof validationResponseSchema>;
 export {};

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

@@ -45,6 +45,20 @@ export const configurationResourcesSchema = z
     slack: z.array(z.object({ slug: z.string().min(1), teamName: z.string().min(1) }).strict()),
 })
     .strict();
+export const setupResourcesSchema = z
+    .object({
+    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({ guildId: z.string().min(1), guildName: z.string().min(1) }).strict()),
+    slack: z.array(z.object({ teamId: 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/index.js

@@ -14,7 +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";
+import { addHubInitCommand, continueHubGuidedSetup } from "./init.js";
 function productionEnvironment() {
     const env = process.env;
     const hub = new HubHttpClient();
@@ -37,6 +37,8 @@ export function createHubCommand(overrides = {}) {
         credentials: environment.credentials,
         flow: environment.login,
         reporter: environment.reporter,
+        isInteractive: environment.isInteractive,
+        continueGuidedSetup: (origin) => continueHubGuidedSetup(origin, environment),
     });
     addHubInitCommand(hub, environment);
     addHubConnectCommand(hub, {

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

@@ -1,6 +1,7 @@
 import type { HubDeployBundle } from "./deploy-bundle.js";
 import type { HubProject } from "./hub-client/index.js";
 import type { HubStatus } from "./daemon-client.js";
+import type { HubStarterAgentRuntime } from "./starter-agent-runtime.js";
 export type HubInitProvider = "github" | "slack" | "discord";
 export type HubInitProjectResolution = {
     kind: "none";
@@ -30,6 +31,7 @@ export interface HubInitOpeningPlan {
 export interface HubInitScaffoldInput {
     cwd: string;
     daemonSlug: string;
+    agent: HubStarterAgentRuntime;
     provider: HubInitProvider;
     providerFilters: Readonly<Record<string, string>>;
 }
@@ -39,6 +41,7 @@ export interface HubInitScaffold {
     workflow: string;
     testAction: string;
 }
+export declare function hubLoginResumeCommand(step: "connect" | "init", origin: string): string;
 export declare function planHubInitOpening(input: {
     loggedIn: boolean;
     paseoDirectoryExists: boolean;

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

@@ -1,5 +1,8 @@
 import path from "node:path";
 import YAML from "yaml";
+export function hubLoginResumeCommand(step, origin) {
+    return step === "connect" ? `paseo hub connect ${origin}` : "paseo hub init";
+}
 export function planHubInitOpening(input) {
     return {
         replaceExisting: input.paseoDirectoryExists,
@@ -47,9 +50,10 @@ export function createHubInitScaffold(input) {
             },
         },
         agents: {
-            codex: {
-                provider: "codex",
-                mode: "full-access",
+            starter: {
+                provider: input.agent.provider,
+                model: input.agent.model,
+                ...(input.agent.mode === undefined ? {} : { mode: input.agent.mode }),
             },
         },
     }, { lineWidth: 0 });
@@ -114,7 +118,7 @@ function workflow(input) {
                 environment: input.environment,
                 max_runtime: "90m",
                 idle_timeout: "10m",
-                agent: "codex",
+                agent: "starter",
                 prompt: [
                     {
                         text: `${replyInstruction}complete this request and call hub.finish_execution when done.\n\n<user-prompt>\n\${{ paseo.prompt }}\n</user-prompt>\n`,

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

@@ -1,10 +1,11 @@
+import { select, text } from "@clack/prompts";
 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 {
+export interface HubGuidedSetupEnvironment {
     env: Readonly<Record<string, string | undefined>>;
     credentials: HubCredentialStore;
     hub: HubHttpClient;
@@ -12,9 +13,23 @@ interface HubInitEnvironment {
     daemon: HubDaemonConnection;
     reporter: HubReporter;
     cwd(): string;
+    isInteractive?(): boolean;
+    prompts?: {
+        confirm(message: string, initialValue: boolean): Promise<boolean>;
+        select(options: Parameters<typeof select<string>>[0]): Promise<string>;
+        text(options: Parameters<typeof text>[0]): Promise<string>;
+        message(value: string): void;
+    };
 }
-export declare function addHubInitCommand(parent: Command, environment: HubInitEnvironment): void;
-export declare function runHubInit(environment: HubInitEnvironment): Promise<void>;
+interface HubGuidedSetupState {
+    origin?: string;
+    daemonId?: string;
+    deploy?: boolean;
+}
+export declare function addHubInitCommand(parent: Command, environment: HubGuidedSetupEnvironment): void;
+export declare function runHubInit(environment: HubGuidedSetupEnvironment): Promise<void>;
+export declare function runHubGuidedSetup(environment: HubGuidedSetupEnvironment, state?: HubGuidedSetupState): Promise<void>;
+export declare function continueHubGuidedSetup(origin: string, environment: HubGuidedSetupEnvironment): Promise<void>;
 export declare function githubRepositoryFromRemote(remote: string): string | undefined;
 export {};
 //# sourceMappingURL=init.d.ts.map

package/dist/commands/hub/init.js

@@ -7,15 +7,17 @@ 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 { createHubInitBundle, createHubInitScaffold, hubLoginResumeCommand, planHubInitOpening, resolveHubInitConnection, resolveHubInitProjects, } from "./init-plan.js";
 import { runHubConnect } from "./connect.js";
 import { runHubDeployBundle } from "./deploy.js";
 import { runHubProjects } from "./projects.js";
 import { normalizeHubOrigin } from "./origin.js";
+import { selectedStarterAgentRuntime, starterAgentProviderSnapshotState, suggestedStarterAgentChoice, } from "./starter-agent-runtime.js";
+import { availableStarterTriggerConnections, } from "./starter-trigger.js";
 const execFileAsync = promisify(execFile);
 const DAEMON_READY_TIMEOUT_MS = 60000;
 const DAEMON_READY_POLL_MS = 250;
+const PROVIDER_READY_TIMEOUT_MS = 60000;
 class HubInitCancelledError extends Error {
 }
 function initErrorMessage(error) {
@@ -43,7 +45,10 @@ export function addHubInitCommand(parent, environment) {
     });
 }
 export async function runHubInit(environment) {
-    requireInteractiveTerminal();
+    await runHubGuidedSetup(environment);
+}
+export async function runHubGuidedSetup(environment, state = {}) {
+    requireInteractiveTerminal(environment);
     intro("Set up Paseo Hub");
     const cwd = environment.cwd();
     const activeLogin = environment.credentials.active();
@@ -52,24 +57,25 @@ export async function runHubInit(environment) {
         paseoDirectoryExists: await pathExists(path.join(cwd, ".paseo")),
     });
     if (opening.replaceExisting &&
-        !(await requiredConfirm("Replace the existing .paseo/ Hub bundle?", false))) {
+        !(await requiredConfirm(environment, "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 origin = state.origin ?? (await ensureLogin(activeLogin?.origin, environment));
+    const daemonId = state.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.");
-    }
+    const resources = await loadSetupResources(origin, environment);
+    const triggerConnections = await resolveStarterTriggerConnections(resources, cwd);
+    reportStarterTriggerConnections(environment, triggerConnections);
+    const trigger = await chooseStarterTriggerConnection(environment, triggerConnections);
+    const daemon = await loadDaemonResource(origin, daemonId, environment);
     log.success(`Connected as ${daemon.slug}`);
-    const provider = await chooseProvider();
-    const providerFilters = await collectProviderFilters(provider, resources, cwd);
+    const agent = await chooseStarterAgentRuntime(environment, cwd);
+    const providerFilters = await collectProviderIdentity(trigger, environment);
     const scaffold = createHubInitScaffold({
         cwd,
         daemonSlug: daemon.slug,
-        provider,
+        agent,
+        provider: trigger.provider,
         providerFilters,
     });
     const bundle = createHubInitBundle(project.slug, scaffold);
@@ -85,7 +91,7 @@ export async function runHubInit(environment) {
     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);
+    const deploy = state.deploy ?? (await requiredConfirm(environment, "Deploy now?", true));
     if (deploy) {
         await withSpinner("Deploying bundle", async () => {
             await runHubDeployBundle({ project: project.slug, hub: origin }, bundle, {
@@ -99,14 +105,41 @@ export async function runHubInit(environment) {
         log.success("Deployed");
     }
     else {
-        log.message(`Skipped deployment. Run: paseo hub deploy -p ${project.slug}`);
+        reportMessage(environment, `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");
 }
+export async function continueHubGuidedSetup(origin, environment) {
+    if (!(await requiredConfirm(environment, "Connect this daemon to this Hub?", true))) {
+        reportMessage(environment, `Skipped daemon connection. Run: ${hubLoginResumeCommand("connect", origin)}; then paseo hub init`);
+        return;
+    }
+    const daemonId = await ensureDaemonConnection(origin, environment, true);
+    if (!(await requiredConfirm(environment, "Initialize and deploy a starter workflow?", true))) {
+        reportMessage(environment, `Skipped starter workflow. Run: ${hubLoginResumeCommand("init", origin)}`);
+        return;
+    }
+    try {
+        await runHubGuidedSetup(environment, { origin, daemonId, deploy: true });
+    }
+    catch (error) {
+        if (error instanceof HubInitCancelledError) {
+            if (environment.prompts === undefined) {
+                log.message(error.message);
+                outro("Connect an app to continue");
+            }
+            else {
+                environment.prompts.message(error.message);
+            }
+            return;
+        }
+        throw error;
+    }
+}
 async function ensureLogin(activeOrigin, environment) {
-    const endpoint = await requiredSelect({
+    const endpoint = await requiredSelect(environment, {
         message: "Hub endpoint",
         initialValue: activeOrigin === undefined || activeOrigin === DEFAULT_HUB_ORIGIN ? "hosted" : "custom",
         options: [
@@ -116,7 +149,7 @@ async function ensureLogin(activeOrigin, environment) {
     });
     const origin = endpoint === "hosted"
         ? DEFAULT_HUB_ORIGIN
-        : await requiredText({
+        : await requiredText(environment, {
             message: "Custom Hub URL",
             initialValue: activeOrigin === undefined || activeOrigin === DEFAULT_HUB_ORIGIN
                 ? environment.env.PASEO_HUB_URL
@@ -136,16 +169,13 @@ async function ensureLogin(activeOrigin, environment) {
         log.success(`Logged in to ${normalizedOrigin}`);
         return normalizedOrigin;
     }
-    await runHubLogin(normalizedOrigin, {}, {
-        env: environment.env,
-        credentials: environment.credentials,
-        flow: environment.login,
-        reporter: environment.reporter,
-    });
+    environment.reporter.progress(`Logging in to ${normalizedOrigin}`);
+    const credential = await environment.login.authorize(normalizedOrigin);
+    environment.credentials.save({ origin: normalizedOrigin, credential });
     log.success(`Logged in to ${normalizedOrigin}`);
     return normalizedOrigin;
 }
-async function ensureDaemonConnection(origin, environment) {
+async function ensureDaemonConnection(origin, environment, confirmed = false) {
     const status = await withHubDaemon(environment.daemon, undefined, async (daemon) => daemon.getHubStatus().then((response) => response.status));
     const connection = resolveHubInitConnection(status, origin);
     if (connection.kind === "connected") {
@@ -157,9 +187,13 @@ async function ensureDaemonConnection(origin, environment) {
     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))) {
+    if (!confirmed &&
+        !(await requiredConfirm(environment, `Connect this daemon to ${origin}?`, true))) {
         throw new HubInitCancelledError("A connected daemon is required to create the bundle.");
     }
+    return connectDaemon(origin, environment);
+}
+async function connectDaemon(origin, environment) {
     await runHubConnect(origin, {}, {
         env: environment.env,
         credentials: environment.credentials,
@@ -205,7 +239,7 @@ async function chooseProject(origin, environment) {
     if (resolution.kind === "selected") {
         return resolution.project;
     }
-    const slug = await requiredSelect({
+    const slug = await requiredSelect(environment, {
         message: "Project",
         options: resolution.projects.map((project) => ({
             value: project.slug,
@@ -219,56 +253,146 @@ async function chooseProject(origin, environment) {
     }
     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 resolveStarterTriggerConnections(resources, cwd) {
+    const remote = await readCommandValue("git", ["remote", "get-url", "origin"], cwd);
+    const repository = remote === undefined ? undefined : githubRepositoryFromRemote(remote);
+    const connections = availableStarterTriggerConnections(resources, repository);
+    if (connections.length === 0) {
+        throw new HubInitCancelledError("No Hub app connection is ready for this workflow.\nConnect GitHub, Slack, or Discord in Hub → Apps, then run `paseo hub init` again.");
+    }
+    return connections;
+}
+function reportStarterTriggerConnections(environment, connections) {
+    const details = `${connections.map(({ label }) => label).join("\n")}\n\nOnly configured connections are shown. To add another, open Hub → Apps, then run \`paseo hub init\` again.`;
+    if (environment.prompts === undefined) {
+        note(details, "Hub app connections ready for this workflow");
+        return;
+    }
+    environment.prompts.message(`Hub app connections ready for this workflow:\n${details}`);
+}
+async function chooseStarterTriggerConnection(environment, connections) {
+    if (connections.length === 1) {
+        const connection = connections[0];
+        reportMessage(environment, `Using ${connection.label}`);
+        return connection;
+    }
+    const id = await requiredSelect(environment, {
+        message: "Trigger connection",
+        options: connections.map((connection) => ({ value: connection.id, label: connection.label })),
     });
+    const connection = connections.find((candidate) => candidate.id === id);
+    if (connection === undefined) {
+        throw new HubCommandError("HUB_PROVIDER_CONNECTION_INVALID", "The selected Hub app connection is no longer available. Run paseo hub init again.");
+    }
+    return connection;
 }
-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"}.`);
+async function chooseStarterAgentRuntime(environment, cwd) {
+    const providers = await waitForStarterAgentProviders(environment, cwd);
+    const provider = await chooseStarterAgentProvider(environment, providers);
+    const model = await chooseStarterAgentModel(environment, provider);
+    const mode = await chooseStarterAgentMode(environment, provider);
+    const runtime = selectedStarterAgentRuntime(provider, model, mode);
+    if (runtime === undefined) {
+        throw new HubCommandError("HUB_AGENT_RUNTIME_SELECTION_INVALID", "The selected starter agent runtime is no longer available. Run paseo hub init again.");
+    }
+    return runtime;
+}
+async function waitForStarterAgentProviders(environment, cwd) {
+    return withSpinner("Discovering agent runtimes", async (reporter) => withHubDaemon(environment.daemon, undefined, async (daemon) => {
+        const deadline = Date.now() + PROVIDER_READY_TIMEOUT_MS;
+        while (true) {
+            const snapshot = await daemon.getProvidersSnapshot({ cwd });
+            const state = starterAgentProviderSnapshotState(snapshot.entries);
+            if (state.kind === "ready")
+                return state.providers;
+            if (state.kind === "unavailable") {
+                throw new HubCommandError("HUB_AGENT_RUNTIME_REQUIRED", "No usable agent runtime is available from this daemon. Configure an enabled provider with a selectable model, then run paseo hub init again.");
+            }
+            if (Date.now() >= deadline) {
+                throw new HubCommandError("HUB_AGENT_RUNTIME_TIMEOUT", "Agent runtime discovery did not finish within 60 seconds. Check the daemon's provider configuration, then run paseo hub init again.");
+            }
+            reporter.progress("Waiting for agent runtime discovery");
+            await delay(DAEMON_READY_POLL_MS);
         }
+    }));
+}
+async function chooseStarterAgentProvider(environment, providers) {
+    const selected = await requiredSelect(environment, {
+        message: "Starter agent provider",
+        options: providers.map((provider) => ({
+            value: provider.id,
+            label: provider.label,
+        })),
+    });
+    const provider = providers.find((candidate) => candidate.id === selected);
+    if (provider === undefined)
+        throw invalidStarterAgentSelection();
+    return provider;
+}
+async function chooseStarterAgentModel(environment, provider) {
+    const suggested = suggestedStarterAgentChoice(provider.models);
+    const selected = await requiredSelect(environment, {
+        message: "Starter agent model",
+        ...(suggested === undefined ? {} : { initialValue: suggested.id }),
+        options: provider.models.map((model) => ({
+            value: model.id,
+            label: model.label,
+            ...(model.suggested ? { hint: "suggested" } : {}),
+        })),
+    });
+    if (!provider.models.some((model) => model.id === selected))
+        throw invalidStarterAgentSelection();
+    return selected;
+}
+async function chooseStarterAgentMode(environment, provider) {
+    if (provider.modes.length === 0)
+        return undefined;
+    const suggested = suggestedStarterAgentChoice(provider.modes);
+    const selected = await requiredSelect(environment, {
+        message: "Starter agent mode",
+        ...(suggested === undefined ? {} : { initialValue: suggested.id }),
+        options: provider.modes.map((mode) => ({
+            value: mode.id,
+            label: mode.label,
+            ...(mode.suggested ? { hint: "suggested" } : {}),
+        })),
+    });
+    if (!provider.modes.some((mode) => mode.id === selected))
+        throw invalidStarterAgentSelection();
+    return selected;
+}
+function invalidStarterAgentSelection() {
+    return new HubCommandError("HUB_AGENT_RUNTIME_SELECTION_INVALID", "The selected starter agent runtime is no longer available. Run paseo hub init again.");
+}
+async function collectProviderIdentity(trigger, environment) {
+    if (trigger.provider === "github") {
+        const login = await readGhValue(["api", "user", "--jq", ".login"]);
         return {
-            user: await requiredText({
+            ...trigger.filters,
+            user: await requiredText(environment, {
                 message: "Your GitHub username (only this user can trigger the bot)",
                 initialValue: login,
             }),
-            repo,
         };
     }
-    if (provider === "slack") {
+    if (trigger.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)",
+            ...trigger.filters,
+            user: await requiredText(environment, {
+                message: "Your Slack member ID (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)",
+        ...trigger.filters,
+        user: await requiredText(environment, {
+            message: "Your Discord user ID (only this user can trigger the bot)",
         }),
     };
 }
-async function loadConfigurationResources(origin, environment) {
+async function loadSetupResources(origin, environment) {
     try {
-        return await withSpinner("Loading Hub connections", () => environment.hub.listConfigurationResources(origin, resolveHubCredential({
+        return await withSpinner("Loading Hub connections", () => environment.hub.listSetupResources(origin, resolveHubCredential({
             options: { origin },
             env: environment.env,
             credentials: environment.credentials,
@@ -277,21 +401,23 @@ async function loadConfigurationResources(origin, environment) {
     }
     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 new HubCommandError("HUB_UPDATE_REQUIRED", "This Hub needs an update before guided setup can use provider IDs. Update 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.`);
+async function loadDaemonResource(origin, daemonId, environment) {
+    const resources = await environment.hub.listConfigurationResources(origin, resolveHubCredential({
+        options: { origin },
+        env: environment.env,
+        credentials: environment.credentials,
+        origin,
+    }));
+    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.");
     }
-    if (connections.length === 1)
-        return connections[0].slug;
-    return requiredSelect({
-        message,
-        options: connections.map(({ slug, label }) => ({ value: slug, label })),
-    });
+    return daemon;
 }
 async function writeScaffold(cwd, scaffold, replaceExisting) {
     const root = path.join(cwd, ".paseo");
@@ -380,8 +506,8 @@ async function withSpinner(message, action) {
         throw error;
     }
 }
-async function requiredText(options) {
-    const answer = await text({
+async function requiredText(environment, options) {
+    const request = {
         ...options,
         validate(value) {
             const input = value ?? "";
@@ -390,26 +516,40 @@ async function requiredText(options) {
                 return customError;
             return input.trim().length === 0 ? "A value is required" : undefined;
         },
-    });
+    };
+    const answer = environment.prompts === undefined
+        ? await text(request)
+        : await environment.prompts.text(request);
     if (isCancel(answer))
         throw new HubInitCancelledError("Hub init cancelled.");
     return answer.trim();
 }
-async function requiredConfirm(message, initialValue) {
-    const answer = await confirm({ message, initialValue });
+async function requiredConfirm(environment, message, initialValue) {
+    const answer = environment.prompts === undefined
+        ? await confirm({ message, initialValue })
+        : await environment.prompts.confirm(message, initialValue);
     if (isCancel(answer))
         throw new HubInitCancelledError("Hub init cancelled.");
     return answer;
 }
-async function requiredSelect(options) {
-    const answer = await select(options);
+async function requiredSelect(environment, options) {
+    const answer = environment.prompts === undefined
+        ? await select(options)
+        : (await environment.prompts.select(options));
     if (isCancel(answer))
         throw new HubInitCancelledError("Hub init cancelled.");
     return answer;
 }
-function requireInteractiveTerminal() {
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+function requireInteractiveTerminal(environment) {
+    if (!(environment.isInteractive?.() ?? (process.stdin.isTTY && process.stdout.isTTY))) {
         throw new HubCommandError("HUB_INIT_INTERACTIVE_REQUIRED", "paseo hub init requires a TTY.");
     }
 }
+function reportMessage(environment, message) {
+    if (environment.prompts === undefined) {
+        log.message(message);
+        return;
+    }
+    environment.prompts.message(message);
+}
 //# sourceMappingURL=init.js.map

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

@@ -12,6 +12,8 @@ interface HubLoginDependencies {
     credentials: HubCredentialStore;
     flow: Pick<CliLoginFlow, "authorize">;
     reporter: HubReporter;
+    isInteractive?(): boolean;
+    continueGuidedSetup?(origin: string): Promise<void>;
 }
 export declare function runHubLogin(originInput: string | undefined, options: {
     json?: boolean;

package/dist/commands/hub/login.js

@@ -19,6 +19,12 @@ export async function runHubLogin(originInput, options, dependencies) {
     reportHubProgress(dependencies.reporter, options, `Logging in to ${origin}`);
     const credential = await dependencies.flow.authorize(origin);
     dependencies.credentials.save({ origin, credential });
+    reportHubProgress(dependencies.reporter, options, "Logged in");
+    if (!options.json &&
+        dependencies.isInteractive?.() &&
+        dependencies.continueGuidedSetup !== undefined) {
+        await dependencies.continueGuidedSetup(origin);
+    }
     return { type: "single", data: { origin, status: "logged_in" }, schema };
 }
 export function addHubLoginCommand(parent, dependencies) {

package/dist/commands/hub/starter-agent-runtime.d.ts

@@ -0,0 +1,37 @@
+import type { ProviderSnapshotEntry } from "@getpaseo/protocol/agent-types";
+export interface HubStarterAgentRuntime {
+    provider: string;
+    model: string;
+    mode?: string;
+}
+export interface HubStarterAgentProvider {
+    id: string;
+    label: string;
+    models: readonly HubStarterAgentModel[];
+    modes: readonly HubStarterAgentMode[];
+}
+export interface HubStarterAgentModel {
+    id: string;
+    label: string;
+    suggested: boolean;
+}
+export interface HubStarterAgentMode {
+    id: string;
+    label: string;
+    suggested: boolean;
+}
+export type HubStarterAgentProviderSnapshotState = {
+    kind: "ready";
+    providers: readonly HubStarterAgentProvider[];
+} | {
+    kind: "loading";
+} | {
+    kind: "unavailable";
+};
+export declare function availableStarterAgentProviders(entries: readonly ProviderSnapshotEntry[]): HubStarterAgentProvider[];
+export declare function starterAgentProviderSnapshotState(entries: readonly ProviderSnapshotEntry[]): HubStarterAgentProviderSnapshotState;
+export declare function suggestedStarterAgentChoice<T extends {
+    suggested: boolean;
+}>(choices: readonly T[]): T | undefined;
+export declare function selectedStarterAgentRuntime(provider: HubStarterAgentProvider, modelId: string, modeId?: string): HubStarterAgentRuntime | undefined;
+//# sourceMappingURL=starter-agent-runtime.d.ts.map

package/dist/commands/hub/starter-agent-runtime.js

@@ -0,0 +1,49 @@
+export function availableStarterAgentProviders(entries) {
+    return entries.flatMap((entry) => {
+        if (entry.status !== "ready" || !entry.enabled)
+            return [];
+        const models = (entry.models ?? [])
+            .filter((model) => model.isSelectable !== false)
+            .map((model) => ({ id: model.id, label: model.label, suggested: model.isDefault === true }));
+        if (models.length === 0)
+            return [];
+        const modes = (entry.modes ?? []).map((mode) => ({
+            id: mode.id,
+            label: mode.label,
+            suggested: mode.id === entry.defaultModeId,
+        }));
+        return [
+            {
+                id: entry.provider,
+                label: entry.label ?? entry.provider,
+                models,
+                modes,
+            },
+        ];
+    });
+}
+export function starterAgentProviderSnapshotState(entries) {
+    const providers = availableStarterAgentProviders(entries);
+    if (providers.length > 0)
+        return { kind: "ready", providers };
+    if (entries.length === 0)
+        return { kind: "loading" };
+    if (entries.some((entry) => entry.enabled && entry.status === "loading")) {
+        return { kind: "loading" };
+    }
+    return { kind: "unavailable" };
+}
+export function suggestedStarterAgentChoice(choices) {
+    return choices.find((choice) => choice.suggested);
+}
+export function selectedStarterAgentRuntime(provider, modelId, modeId) {
+    if (!provider.models.some((model) => model.id === modelId))
+        return undefined;
+    if (provider.modes.length === 0) {
+        return modeId === undefined ? { provider: provider.id, model: modelId } : undefined;
+    }
+    if (modeId === undefined || !provider.modes.some((mode) => mode.id === modeId))
+        return undefined;
+    return { provider: provider.id, model: modelId, mode: modeId };
+}
+//# sourceMappingURL=starter-agent-runtime.js.map

package/dist/commands/hub/starter-trigger.d.ts

@@ -0,0 +1,10 @@
+import type { HubSetupResources } from "./hub-client/index.js";
+import type { HubInitProvider } from "./init-plan.js";
+export interface HubStarterTriggerConnection {
+    id: string;
+    label: string;
+    provider: HubInitProvider;
+    filters: Readonly<Record<string, string>>;
+}
+export declare function availableStarterTriggerConnections(resources: HubSetupResources, githubRepository?: string): HubStarterTriggerConnection[];
+//# sourceMappingURL=starter-trigger.d.ts.map

package/dist/commands/hub/starter-trigger.js

@@ -0,0 +1,28 @@
+export function availableStarterTriggerConnections(resources, githubRepository) {
+    return [
+        ...(githubRepository !== undefined &&
+            resources.github.some(({ repositories }) => repositories.includes(githubRepository))
+            ? [
+                {
+                    id: `github:${githubRepository}`,
+                    label: `GitHub — ${githubRepository}`,
+                    provider: "github",
+                    filters: { repo: githubRepository },
+                },
+            ]
+            : []),
+        ...resources.slack.map(({ teamId, teamName }) => ({
+            id: `slack:${teamId}`,
+            label: `Slack — ${teamName}`,
+            provider: "slack",
+            filters: { workspace: teamId },
+        })),
+        ...resources.discord.map(({ guildId, guildName }) => ({
+            id: `discord:${guildId}`,
+            label: `Discord — ${guildName}`,
+            provider: "discord",
+            filters: { guild: guildId },
+        })),
+    ];
+}
+//# sourceMappingURL=starter-trigger.js.map

package/package.json

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