skydive-cli 0.5.0-beta.3 → 0.5.0-beta.30

package/dist/js/{profiler-DtuXkIkR.mjs → profiler-BoO7ldO0.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { S as getConfigPath } from "./print-CbayCa87.mjs";
+import { C as getConfigPath } from "./print-DYiQC5IW.mjs";
 import os from "node:os";
 import path from "node:path";
 import { err, ok } from "neverthrow";
@@ -8,7 +8,7 @@ import fs from "node:fs";
 
 //#region package.json
 var name = "skydive-cli";
-var version$1 = "0.5.0-beta.3";
+var version$1 = "0.5.0-beta.30";
 
 //#endregion
 //#region src/auth/organization.ts
@@ -32,6 +32,32 @@ async function listWorkspaces({ appUrl, sessionToken }) {
 	}
 }
 /**
+* Match a workspace selector against a roster the way `workspace switch` does:
+* exact id first, then case-insensitive slug, then case-insensitive name.
+* Returns null when nothing matches. Pure — the caller owns fetching and error
+* messaging.
+*/
+function matchWorkspace(workspaces, selector) {
+	const needle = selector.trim().toLowerCase();
+	return workspaces.find((w) => w.id === selector) ?? workspaces.find((w) => w.slug.toLowerCase() === needle) ?? workspaces.find((w) => w.name.toLowerCase() === needle) ?? null;
+}
+/**
+* Resolve a workspace selector (slug, name, or id) to its id by listing the
+* account's workspaces and matching. Used by any command that takes a
+* `--workspace` flag to scope requests without persisting an active-workspace
+* switch.
+*/
+async function resolveWorkspaceId({ appUrl, sessionToken, selector }) {
+	const workspaces = await listWorkspaces({
+		appUrl,
+		sessionToken
+	});
+	if (workspaces.isErr()) return err(workspaces.error);
+	const match = matchWorkspace(workspaces.value, selector);
+	if (!match) return err({ message: `No workspace matches "${selector}". Run \`skydive workspace list\` to see available workspaces.` });
+	return ok(match);
+}
+/**
 * Resolve who the current chat session belongs to: the signed-in user's
 * email/name and the active workspace. Used by `auth status` so a user running
 * multiple accounts can answer "am I logged into the right one?" without
@@ -125,6 +151,223 @@ async function ensureActiveOrganization({ appUrl, sessionToken }) {
 	});
 }
 
+//#endregion
+//#region src/shell/shell-env.ts
+/**
+* Shared, dependency-light shell primitives used by anything that edits the
+* user's shell startup files — `completion install` and `agents alias`. Kept
+* free of yargs and the CLI's output layer so the TUI can import it without
+* dragging command machinery into its bundle or creating a TUI -> commands
+* import cycle.
+*/
+const SUPPORTED_SHELLS = [
+	"bash",
+	"zsh",
+	"fish"
+];
+const defaultInstallEnv = () => ({
+	home: os.homedir(),
+	platform: process.platform,
+	env: process.env,
+	exists: fs.existsSync
+});
+/**
+* The shell to act on when the user didn't name one. `$SHELL` is the only
+* signal available: an install runs as a child process, so the invoking
+* shell's own variables (`$ZSH_VERSION`, `$FISH_VERSION`) aren't visible here.
+*/
+function detectShell(env = process.env) {
+	const shell = env["SHELL"];
+	if (!shell) return null;
+	const name = path.basename(shell);
+	return SUPPORTED_SHELLS.find((candidate) => name === candidate) ?? null;
+}
+
+//#endregion
+//#region src/commands/agent-alias.ts
+/**
+* Shell aliases that point a friendly command name at a specific agent's chat.
+*
+* When someone creates an agent named "Ripple", they almost always want to
+* reach it again by typing `ripple`, not `skydive chat --agent <uuid>`. This
+* module writes a managed alias block into the user's shell startup file so
+* `ripple` opens that agent. It reuses the same shell detection and startup-file
+* machinery as `completion install` (imported from ./completion), so the two
+* features agree on which file to touch and how to detect the shell.
+*
+* The alias always targets the agent **id**, never its name: names are not
+* unique and can be renamed, so an id keeps `ripple` pointed at the same agent
+* even if a second "Ripple" is created later or this one is renamed.
+*/
+/**
+* Turn a display name into a shell-safe alias token: lowercase, non-alnum runs
+* collapsed to a single hyphen, leading/trailing hyphens trimmed. "Ripple" ->
+* "ripple", "My Agent" -> "my-agent", "Ripple 2.0" -> "ripple-2-0".
+*
+* A leading digit is prefixed with `a-` because bash rejects an alias name that
+* starts with a digit (`alias 2fast=...` is a syntax error). An empty result
+* (a name that was all punctuation) falls back to "agent" so callers always get
+* a usable token to offer or dedupe from.
+*/
+function slugifyAliasName(name) {
+	const slug = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+	if (!slug) return "agent";
+	return /^[0-9]/.test(slug) ? `a-${slug}` : slug;
+}
+/**
+* The alias token to actually install, given a preferred token and the set of
+* names already taken (existing aliases, and — the caller's choice — commands
+* on PATH). Prefers the clean token; on a collision appends the lowest integer
+* that frees it: `ripple` -> `ripple2` -> `ripple3`. Matching is
+* case-insensitive because shells treat `Ripple` and `ripple` as distinct
+* aliases but a user typing one means the other.
+*/
+function dedupeAliasName(preferred, taken) {
+	const takenLower = new Set(Array.from(taken, (t) => t.trim().toLowerCase()).filter(Boolean));
+	if (!takenLower.has(preferred.toLowerCase())) return preferred;
+	for (let n = 2;; n += 1) {
+		const candidate = `${preferred}${n}`;
+		if (!takenLower.has(candidate.toLowerCase())) return candidate;
+	}
+}
+/** The startup file an alias block belongs in, per shell. */
+function aliasTarget(shell, deps = defaultInstallEnv()) {
+	const { home, platform, env, exists } = deps;
+	if (shell === "fish") {
+		const configHome = env["XDG_CONFIG_HOME"] || path.join(home, ".config");
+		return path.join(configHome, "fish", "config.fish");
+	}
+	if (shell === "zsh") {
+		const zdotdir = env["ZDOTDIR"] || home;
+		return path.join(zdotdir, ".zshrc");
+	}
+	const rc = path.join(home, ".bashrc");
+	const profile = path.join(home, ".bash_profile");
+	const preferred = platform === "darwin" ? profile : rc;
+	const alternate = platform === "darwin" ? rc : profile;
+	if (!exists(preferred) && exists(alternate)) return alternate;
+	return preferred;
+}
+const BLOCK_START = "###-begin-skydive-agent-aliases-###";
+const BLOCK_END = "###-end-skydive-agent-aliases-###";
+const aliasLine = (entry) => {
+	const ws = entry.workspaceId ? ` --workspace ${entry.workspaceId}` : "";
+	return `alias ${entry.alias}='skydive chat --agent ${entry.agentId}${ws} --new' # skydive-agent:${entry.agentId}`;
+};
+/**
+* Parse the alias entries already inside the managed block. Used to merge a new
+* alias with existing ones and to answer "is this token taken?". Tolerant of
+* hand-edits: only well-formed lines carrying our trailing marker are read
+* back; anything else in the block is preserved verbatim on rewrite.
+*/
+function parseAliasBlock(existing) {
+	const start = existing.indexOf(BLOCK_START);
+	const end = existing.indexOf(BLOCK_END);
+	if (start === -1 || end <= start) return [];
+	const body = existing.slice(start + 35, end);
+	const entries = [];
+	for (const line of body.split("\n")) {
+		const match = line.match(/^alias\s+([^=]+)=.*# skydive-agent:([0-9a-f-]+)\s*$/i);
+		if (match?.[1] && match[2]) {
+			const wsMatch = line.match(/--workspace\s+(\S+)/);
+			entries.push({
+				alias: match[1].trim(),
+				agentId: match[2],
+				workspaceId: wsMatch?.[1]
+			});
+		}
+	}
+	return entries;
+}
+/**
+* Merge `entry` into the managed alias block of `existing`, returning the new
+* file contents. Idempotent: re-installing the same alias for the same agent is
+* a no-op edit; a new agent id adds a line; an existing agent id has its alias
+* token refreshed. The block is created if absent.
+*/
+function spliceAliasBlock(existing, entry) {
+	const current = parseAliasBlock(existing).filter((e) => e.agentId !== entry.agentId);
+	current.push(entry);
+	current.sort((a, b) => a.alias.localeCompare(b.alias));
+	const block = [
+		BLOCK_START,
+		"# skydive agent aliases, managed by `skydive agents alias`. Edits between",
+		"# these markers are overwritten when an alias is added or refreshed.",
+		...current.map(aliasLine),
+		BLOCK_END
+	].join("\n");
+	const start = existing.indexOf(BLOCK_START);
+	const endMarker = BLOCK_END;
+	const end = existing.indexOf(endMarker);
+	if (start !== -1 && end > start) return `${existing.slice(0, start)}${block}\n${existing.slice(end + 33).replace(/^\n/, "")}`;
+	return `${existing}${existing === "" || existing.endsWith("\n\n") ? "" : "\n"}\n${block}\n`;
+}
+/**
+* Write (or refresh) an agent alias in the user's shell startup file. Returns
+* the resolved shell, file, and the alias token actually used. Does not dedupe
+* on its own — pass a token already reconciled with `takenAliasNames` so the
+* caller controls the suggestion UX.
+*/
+function installAgentAlias(input, deps = defaultInstallEnv()) {
+	const target = aliasTarget(input.shell, deps);
+	const existing = deps.exists(target) ? fs.readFileSync(target, "utf8") : "";
+	const contents = spliceAliasBlock(existing, {
+		alias: input.alias,
+		agentId: input.agentId,
+		workspaceId: input.workspaceId
+	});
+	fs.mkdirSync(path.dirname(target), { recursive: true });
+	fs.writeFileSync(target, contents, "utf8");
+	return {
+		shell: input.shell,
+		path: target,
+		alias: input.alias,
+		agentId: input.agentId,
+		updated: existing.includes(BLOCK_START)
+	};
+}
+/**
+* Alias tokens already defined in our managed block of the given shell's
+* startup file. The dedupe source: a fresh install shouldn't collide with an
+* alias we wrote for another agent. (We don't try to read the user's own
+* hand-written aliases or PATH — a shell child process can't see the parent's
+* live alias table, and probing PATH is noisy; the dedupe covers our own
+* blocks, which is where real collisions come from in practice.)
+*/
+function takenAliasNames(shell, deps = defaultInstallEnv()) {
+	const target = aliasTarget(shell, deps);
+	if (!deps.exists(target)) return [];
+	return parseAliasBlock(fs.readFileSync(target, "utf8")).map((e) => e.alias);
+}
+/** What the user must do before the alias works in the shell they're in. */
+function aliasActivationHint(result) {
+	return result.shell === "fish" ? "Open a new fish shell to use it." : `Open a new shell, or run: source ${result.path}`;
+}
+
+//#endregion
+//#region src/chat/import-seed.ts
+/** Map `process.platform` to the OS family used by the seed prompts. Every
+* non-`win32` platform Node runs on (darwin, linux, the BSDs) is POSIX. */
+function machineOsFromPlatform(platform) {
+	return platform === "win32" ? "windows" : "posix";
+}
+/** One clause describing the machine's shell/paths so the agent's discovery
+* sweep uses the right conventions instead of guessing. */
+function osHint(os) {
+	return os === "windows" ? "This machine is Windows, so use PowerShell and Windows paths (%USERPROFILE%, backslashes)." : "This machine is POSIX (macOS/Linux), so use a POSIX shell and paths (~, forward slashes).";
+}
+/**
+* The first message of an explicit `skydive import` conversation, sent as the
+* user. Frames the migration and points the agent at its import-config skill.
+*/
+function buildImportSeedPrompt(projectDir, os) {
+	return [
+		"I'm migrating from another coding agent. Import my setup from this machine.",
+		"",
+		`Use your import-config skill. I ran this from \`${projectDir}\`, so start there and in my home directory. ${osHint(os)} Don't assume one tool — do the discovery sweep so you catch whatever I actually use (Claude Code, Cursor, Codex, Gemini CLI, Copilot, Windsurf, Cline, OpenCode, Aider, and any nested AGENTS.md). Show me the plan first: everything you found, what you'll bring over, where it lands in you, and anything you're leaving out (credentials especially). Then wait for my OK before committing anything.`
+	].join("\n");
+}
+
 //#endregion
 //#region src/chat/tui/theme.ts
 const tokyonight = {
@@ -907,6 +1150,17 @@ const WORDMARK = [
 	"███████║██║  ██╗   ██║   ██████╔╝██║ ╚████╔╝ ███████╗",
 	"╚══════╝╚═╝  ╚═╝   ╚═╝   ╚═════╝ ╚═╝  ╚═══╝  ╚══════╝"
 ];
+/** Columns between the pinwheel and the wordmark. */
+const SPLASH_GAP = 3;
+/** Columns the full mark + wordmark occupies (no chrome). */
+const SPLASH_WIDTH = MARK_WIDTH + SPLASH_GAP + WORDMARK.reduce((max, line) => Math.max(max, line.length), 0);
+/** Extra columns around the splash: `skydive --help` indents by 2, the TUI
+*  app pads 1 on each side. Same number, so one threshold covers both. */
+const SPLASH_CHROME = 2;
+/** Whether the full splash fits on one line of `columns` without wrapping. */
+function splashFitsWidth(columns) {
+	return columns >= SPLASH_WIDTH + SPLASH_CHROME;
+}
 const RESET = "\x1B[0m";
 function hexToRgb(hex) {
 	const n = Number.parseInt(hex.slice(1), 16);
@@ -933,7 +1187,7 @@ function markLinesAnsi() {
 function brandHelpArt(stream = process.stdout) {
 	if (!stream.isTTY) return "";
 	const truecolor = (typeof stream.getColorDepth === "function" ? stream.getColorDepth() : 1) >= 24;
-	if ((stream.columns ?? 80) < 66) return truecolor ? `\n  ${sgr("✦", BRAND_ACCENT)} Skydive\n` : "\n  ✦ Skydive\n";
+	if (!splashFitsWidth(stream.columns ?? 80)) return truecolor ? `\n  ${sgr("✦", BRAND_ACCENT)} Skydive\n` : "\n  ✦ Skydive\n";
 	if (!truecolor) return `\n${WORDMARK.map((l) => `  ${l}`).join("\n")}\n`;
 	const mark = markLinesAnsi();
 	const word = [...WORDMARK];
@@ -1264,4 +1518,4 @@ function maybeStartProfiling(argv, cliVersion) {
 }
 
 //#endregion
-export { ensureActiveOrganization as C, setActiveWorkspace as D, listWorkspaces as E, name as O, themesForMode as S, getSessionIdentity as T, themeForMode as _, installCrashHandler as a, themeVersion as b, MARK_CELLS as c, DEFAULT_THEME_ID as d, applyTheme as f, theme as g, noColorRequested as h, writeArtifact as i, version$1 as k, WORDMARK as l, monoTheme as m, profilingEnabled as n, buildCrashReport as o, findTheme as p, record as r, writeCrashReport as s, maybeStartProfiling as t, brandHelpArt as u, themeMode as v, getActiveWorkspaceId as w, themes as x, themeModeFromColorFgBg as y };
+export { takenAliasNames as A, name as B, themesForMode as C, dedupeAliasName as D, aliasActivationHint as E, getActiveWorkspaceId as F, getSessionIdentity as I, listWorkspaces as L, defaultInstallEnv as M, detectShell as N, installAgentAlias as O, ensureActiveOrganization as P, resolveWorkspaceId as R, themes as S, machineOsFromPlatform as T, version$1 as V, theme as _, installCrashHandler as a, themeModeFromColorFgBg as b, MARK_CELLS as c, splashFitsWidth as d, DEFAULT_THEME_ID as f, noColorRequested as g, monoTheme as h, writeArtifact as i, SUPPORTED_SHELLS as j, slugifyAliasName as k, WORDMARK as l, findTheme as m, profilingEnabled as n, buildCrashReport as o, applyTheme as p, record as r, writeCrashReport as s, maybeStartProfiling as t, brandHelpArt as u, themeForMode as v, buildImportSeedPrompt as w, themeVersion as x, themeMode as y, setActiveWorkspace as z };

package/dist/js/{raw-pty-B6mAroiI.mjs → raw-pty-DY4KelZW.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as SandboxStream } from "./client-Cn2af31H.mjs";
+import { t as SandboxStream } from "./client-c4c5MmgN.mjs";
 
 //#region src/chat/sandbox/raw-pty.ts
 /**

package/dist/js/raw-pty-DmdUf4_w.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import "./client-c4c5MmgN.mjs";
+import { t as runRawPtyPassthrough } from "./raw-pty-DY4KelZW.mjs";
+
+export { runRawPtyPassthrough };

package/dist/js/{rest-DADJh0bi.mjs → rest-DSpGS5XU.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { t as HttpError } from "./http-error-DzyrsLAZ.mjs";
-import { n as errorDetail, r as sendErrorMessage, t as createRestClient } from "./rest-BY2nADw5.mjs";
+import { n as errorDetail, r as sendErrorMessage, t as createRestClient } from "./rest-xXfqT4SX.mjs";
 import "./billing-blocked-2wju4gC_.mjs";
 
 export { createRestClient };

package/dist/js/{rest-BY2nADw5.mjs → rest-xXfqT4SX.mjs}

@@ -193,13 +193,14 @@ function createRestClient({ appUrl, sessionToken, workspaceId }) {
 		}
 	};
 	return {
-		listAgents: async ({ scope, onPage }) => {
+		listAgents: async ({ scope, onPage, limit }) => {
 			const all = [];
 			let cursor;
-			const maxAgents = 2e3;
+			const maxAgents = limit ?? 2e3;
+			const pageSize = Math.min(100, maxAgents);
 			do {
 				const params = new URLSearchParams({
-					limit: "100",
+					limit: String(pageSize),
 					scope,
 					sort: "mine_first_usage",
 					includeStats: "false"
@@ -213,16 +214,23 @@ function createRestClient({ appUrl, sessionToken, workspaceId }) {
 			return all;
 		},
 		createAgent: async ({ name }) => {
-			const { agent } = await post("/api/v1/agents", { name }, createAgentResponseSchema);
+			const { agent } = await post("/api/v1/agents", name == null ? {} : { name }, createAgentResponseSchema);
 			return agent;
 		},
-		getAgent: async ({ agentId }) => {
-			const { agent } = await get(`/api/v1/agents/${encodeURIComponent(agentId)}`, getAgentResponseSchema);
+		createOnboardingConversation: async ({ agentId, projectDir, os }) => {
+			const result = await post(`/api/v1/agents/${encodeURIComponent(agentId)}/onboarding-conversation`, {
+				projectDir,
+				os
+			}, onboardingConversationResponseSchema);
 			return {
-				id: agent.id,
-				name: agent.name
+				conversationId: result.conversationId,
+				runId: result.runId
 			};
 		},
+		getAgent: async ({ agentId }) => {
+			const { agent } = await get(`/api/v1/agents/${encodeURIComponent(agentId)}`, getAgentResponseSchema);
+			return agent;
+		},
 		suggestAgentIdentity: async () => {
 			const { suggestion } = await get("/api/v1/agents/suggest", suggestAgentResponseSchema);
 			return suggestion;
@@ -331,6 +339,9 @@ function createRestClient({ appUrl, sessionToken, workspaceId }) {
 		setConversationArchived: async ({ conversationId, archived }) => {
 			await post(`/api/v1/conversations/${encodeURIComponent(conversationId)}/archive`, { archived }, z.object({ archived: z.boolean() }));
 		},
+		markConversationRead: async ({ conversationId }) => {
+			await post(`/api/v1/conversations/${encodeURIComponent(conversationId)}/read`, {}, z.object({ read: z.boolean() }));
+		},
 		renameConversation: async ({ conversationId, title }) => {
 			await post(`/api/v1/conversations/${encodeURIComponent(conversationId)}`, { title }, z.object({ conversation: z.object({ id: z.string() }) }), "PATCH");
 		},
@@ -352,6 +363,7 @@ function createRestClient({ appUrl, sessionToken, workspaceId }) {
 			const { authorizationUrl } = await post("/api/v1/external-oauth/connect", input, externalOauthConnectResponseSchema);
 			return { authorizationUrl: authorizationUrl ?? null };
 		},
+		decideComputeRequest: async ({ requestId, decision }) => post(`/api/v1/compute-requests/${encodeURIComponent(requestId)}/decision`, { decision }, computeDecisionResponseSchema),
 		fulfillCredential: async ({ url, body }) => {
 			const target = new URL(url, appUrl).toString();
 			const res = await fetch(target, {
@@ -453,10 +465,11 @@ const listAgentsResponseSchema = z.object({
 	totalCount: z.number().nullable().optional()
 });
 const createAgentResponseSchema = z.object({ agent: agentSummarySchema });
-const getAgentResponseSchema = z.object({ agent: z.object({
-	id: z.string(),
-	name: z.string()
-}).passthrough() });
+const onboardingConversationResponseSchema = z.object({
+	conversationId: z.string(),
+	runId: z.string().nullable()
+});
+const getAgentResponseSchema = z.object({ agent: agentSummarySchema });
 const agentSuggestionSchema = z.object({ name: z.string() });
 const suggestAgentResponseSchema = z.object({ suggestion: agentSuggestionSchema.nullable() });
 const conversationAgentSchema = z.object({
@@ -474,6 +487,7 @@ const conversationSummarySchema = z.object({
 	channel: z.string().nullable(),
 	channelLabel: z.string().nullable(),
 	viewerArchivedAt: z.string().nullable().optional(),
+	unread: z.boolean().optional(),
 	agent: conversationAgentSchema,
 	agents: z.array(conversationAgentSchema).optional()
 });
@@ -569,6 +583,7 @@ const finalizeResponseSchema = z.object({
 });
 const oauthConnectResponseSchema = z.object({ connectLink: z.string() }).passthrough();
 const externalOauthConnectResponseSchema = z.object({ authorizationUrl: z.string().optional() }).passthrough();
+const computeDecisionResponseSchema = z.object({ status: z.string() }).passthrough();
 const runStreamEventSchema = z.union([z.object({
 	kind: z.literal("chunk"),
 	chunk: z.record(z.unknown())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skydive-cli",
-  "version": "0.5.0-beta.3",
+  "version": "0.5.0-beta.30",
   "description": "Skydive CLI — cloud agents from the command line",
   "homepage": "https://skydive.com",
   "license": "MIT",

package/dist/js/client-CKBQ8pft.mjs

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import { t as PortalClient } from "./client-Dd5sMXPv.mjs";
-
-export { PortalClient };

package/dist/js/daemon-client-srAit8Fz.mjs

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-import "./client-Dd5sMXPv.mjs";
-import "./daemon-Bq93vOIk.mjs";
-import { t as PortalDaemonClient } from "./daemon-client-Bewt98dE.mjs";
-
-export { PortalDaemonClient };

package/dist/js/raw-pty-3EkG-jjH.mjs

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-import "./client-Cn2af31H.mjs";
-import { t as runRawPtyPassthrough } from "./raw-pty-B6mAroiI.mjs";
-
-export { runRawPtyPassthrough };