skydive-cli 0.2.0-beta.630 → 0.2.0-beta.684

package/README.md

@@ -131,10 +131,45 @@ skydive portal open             # open the portal to this machine, headless
 skydive portal grant --agent <id|name>
 skydive portal revoke --agent <id|name>
 skydive portal status
+
+skydive completion install      # set up TAB completion for your shell
 ```
 
 Global flags: `--json`, `--quiet`, `--api-url <url>`.
 
+## Shell completions
+
+bash, zsh, and fish. One command sets them up for the shell you're in:
+
+```sh
+skydive completion install
+```
+
+It writes to `~/.bashrc` (or `~/.bash_profile` on macOS), `~/.zshrc`, or
+`~/.config/fish/completions/skydive.fish`, respecting `ZDOTDIR` and
+`XDG_CONFIG_HOME`, and picking whichever bash startup file you already have.
+Open a new shell to pick them up. Re-running it — after an upgrade, say —
+refreshes the block it wrote instead of appending a second copy, and leaves
+the rest of the file alone. Pass a shell explicitly to set up one you're not
+currently in: `skydive completion install fish`.
+
+To see the script instead of installing it, or to source it from somewhere of
+your own choosing:
+
+```sh
+skydive completion zsh            # print it
+eval "$(skydive completion bash)" # this shell only
+```
+
+The script doesn't contain the command list — it asks the CLI for candidates
+on each TAB, so completions never drift from the installed version. That
+covers commands, subcommands, flags, and the values of flags with a fixed set
+(`skydive agents list --scope <TAB>` → `mine org`). One TAB costs one short
+CLI invocation (~150 ms).
+
+zsh and fish show each command's description alongside it; bash lists names
+only.
+
 ## `skydive import`
 
 Migrating from Claude Code, Cursor, or OpenCode? `skydive import` opens a

package/dist/js/bin.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { C as setActiveWorkspace, S as listWorkspaces, T as version, _ as themes, b as getActiveWorkspaceId, o as brandHelpArt, t as installCrashHandler, w as name, x as getSessionIdentity, y as ensureActiveOrganization } from "./install-ZNL9Ss_c.mjs";
+import { C as setActiveWorkspace, S as listWorkspaces, T as version, _ as themes, b as getActiveWorkspaceId, o as brandHelpArt, t as installCrashHandler, w as name, x as getSessionIdentity, y as ensureActiveOrganization } from "./install-DgwIUN1J.mjs";
 import { A as resolveAppUrl, C as getPromptHistoryPath, D as getStoredApiKeyId, E as getShareMachineDefault, F as saveConfig, I as saveSession, M as resolveManagementAuth, N as resolveSession, O as getStoredApiKeyWorkspaceName, R as setLastSeenVersion, S as getLastSeenVersion, _ as API_KEY_PREFIX, b as deleteConfig, g as API_KEY_FAMILY_PREFIX, h as API_KEYS_URL, i as resolveAgent, j as resolveConfig, k as getUpdateCheckDisabled, v as DEFAULT_API_URL, x as getConfigPath } from "./print-BUbxOvnm.mjs";
 import { n as printError, r as printTable, t as output } from "./output-DYzzdXYV.mjs";
 import { n as createRestClient } from "./rest-CCyln7vx.mjs";
@@ -8,14 +8,14 @@ import { c as PORTAL_DAEMON_FLAG, i as queryDaemonStatus, l as daemonPaths, n as
 import { t as SandboxStream } from "./client-DfcJFEbh.mjs";
 import { hideBin } from "yargs/helpers";
 import yargs from "yargs";
-import { hostname } from "node:os";
+import os, { hostname } from "node:os";
 import path from "node:path";
 import { err, ok } from "neverthrow";
 import { z } from "zod";
 import open from "open";
+import fs from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import fs from "node:fs";
 import zlib from "node:zlib";
 import fsp from "node:fs/promises";
 import semver from "semver";
@@ -713,6 +713,308 @@ const authCommand = {
 	handler: () => {}
 };
 
+//#endregion
+//#region src/commands/completion.ts
+/**
+* The argv sentinel yargs answers with completion candidates for a partially
+* typed command line. The scripts below are the only callers; `bin.ts` also
+* matches on it to keep notices off the user's prompt (see isCompletionProbe).
+*/
+const COMPLETION_PROBE_FLAG = "--get-yargs-completions";
+const SUPPORTED_SHELLS = [
+	"bash",
+	"zsh",
+	"fish"
+];
+/**
+* True when this invocation is a shell asking for completion candidates
+* rather than a user running a command. Such a run must print candidates and
+* nothing else: stderr is still a TTY inside a completion function, so an
+* update notice would be drawn onto the prompt line, and the what's-new
+* notice is one-shot — a TAB press would consume it unread.
+*/
+function isCompletionProbe(argv) {
+	return argv.includes(COMPLETION_PROBE_FLAG);
+}
+/**
+* Blank the word the cursor is still on before yargs sees a probe.
+*
+* yargs' completion walk treats *every* token in the probe as a finished
+* command, the word under the cursor included: it scans the args for one that
+* names a command, descends into that command's builder, and answers from
+* there. So a fully typed command name answers with nothing —
+* `skydive conv<TAB>` descends into the `conv` alias of `conversations` and
+* emits an empty list, which leaves an alias that can never be expanded and a
+* `skydive agents<TAB>` that won't even add its trailing space. In bash it is
+* worse than a no-op: `complete -o default` reads the empty list as "no
+* candidates" and offers local *filenames* instead.
+*
+* The three scripts all send the partial word as the last token — that is
+* yargs' wire format, not something we chose — so drop it here and let the
+* shell filter the full candidate list by prefix. That is already what happens
+* for any partial that doesn't happen to name a command (`skydive conve<TAB>`
+* gets all 13 commands back today and bash/zsh/fish narrow them), so this only
+* removes the special case, it doesn't change the contract.
+*
+* Two tokens are left alone:
+* - one starting with `-`, because yargs uses exactly that to decide between
+*   offering options and offering subcommands, and
+* - the command name itself, so a probe never degrades to an empty script name.
+*/
+function normalizeProbeArgv(argv) {
+	const flag = argv.indexOf(COMPLETION_PROBE_FLAG);
+	if (flag === -1 || argv.length - flag < 3) return argv;
+	const last = argv[argv.length - 1] ?? "";
+	if (last === "" || last.startsWith("-")) return argv;
+	return [...argv.slice(0, -1), ""];
+}
+const blockStart = (name) => `###-begin-${name}-completions-###`;
+const blockEnd = (name) => `###-end-${name}-completions-###`;
+/**
+* Emit a completion script that asks the CLI itself for candidates on every
+* TAB, rather than baking today's command tree into the script. bash and zsh
+* are adapted from yargs' own templates
+* (node_modules/yargs/build/lib/completion-templates.js); fish is
+* hand-written, as yargs ships no fish template. Differences from yargs:
+*
+* - The shell is an explicit argument, not inferred from `$SHELL` at generate
+*   time, so `skydive completion zsh` is meaningful from any shell.
+* - The script calls `skydive` off PATH instead of the absolute path of the
+*   generating process, which would go stale on every version bump under a
+*   version manager.
+* - The probe's wire format is pinned. yargs picks it from `SHELL`/`ZSH_NAME`
+*   — plain lines normally, `value:description` when either says "zsh" — so
+*   a bash user whose login shell is zsh would otherwise get descriptions
+*   stuffed into COMPREPLY. bash asks for plain lines; zsh and fish ask for
+*   the descriptive format and render the descriptions.
+*/
+function renderCompletionScript(shell, commandName = "skydive") {
+	if (shell === "zsh") return zshScript(commandName);
+	if (shell === "fish") return fishScript(commandName);
+	return bashScript(commandName);
+}
+function bashScript(name) {
+	const fn = `_${name}_completions`;
+	return `${blockStart(name)}
+#
+# ${name} command completion script, generated by \`${name} completion bash\`.
+# Installed by \`${name} completion install bash\`; edits inside this block
+# are overwritten on the next install.
+#
+${fn}()
+{
+  local cur_word args candidates
+
+  cur_word="\${COMP_WORDS[COMP_CWORD]}"
+  args=("\${COMP_WORDS[@]}")
+
+  candidates=$(SHELL=bash ZSH_NAME= ${name} ${COMPLETION_PROBE_FLAG} "\${args[@]}" 2>/dev/null)
+
+  COMPREPLY=( $(compgen -W "\${candidates}" -- "\${cur_word}") )
+
+  return 0
+}
+complete -o bashdefault -o default -F ${fn} ${name}
+${blockEnd(name)}
+`;
+}
+function zshScript(name) {
+	const fn = `_${name}_completions`;
+	return `${blockStart(name)}
+#
+# ${name} command completion script, generated by \`${name} completion zsh\`.
+# Installed by \`${name} completion install zsh\`; edits inside this block
+# are overwritten on the next install.
+#
+${fn}()
+{
+  local reply
+  local si=$IFS
+  IFS=$'\\n' reply=($(COMP_CWORD="$((CURRENT-1))" COMP_LINE="$BUFFER" COMP_POINT="$CURSOR" SHELL=zsh ${name} ${COMPLETION_PROBE_FLAG} "\${words[@]}" 2>/dev/null))
+  IFS=$si
+  _describe 'values' reply
+}
+# compdef only exists once compinit has run. Sourcing this block from a .zshrc
+# that never calls compinit (or calls it later) would otherwise fail with
+# "command not found: compdef".
+#
+# -i is load-bearing: a bare compinit that finds an insecure directory on fpath
+# stops to ask "Ignore insecure directories and continue?", and where it cannot
+# open the terminal it prints "compinit: initialization aborted" and defines no
+# compdef at all -- so the line below fails and the user gets no completions.
+# An insecure fpath entry is ordinary, not exotic: Homebrew's
+# share/zsh/site-functions is writable by the installing user. -i skips those
+# directories and carries on, which beats prompting from someone's shell
+# startup.
+if ! type compdef >/dev/null 2>&1; then
+  autoload -Uz compinit && compinit -i
+fi
+compdef ${fn} ${name}
+${blockEnd(name)}
+`;
+}
+function fishScript(name) {
+	const fn = `__${name}_completions`;
+	return `${blockStart(name)}
+#
+# ${name} command completion script, generated by \`${name} completion fish\`.
+# Installed by \`${name} completion install fish\`; edits are overwritten on
+# the next install.
+#
+function ${fn}
+    set -l tokens (commandline --current-process --tokenize --cut-at-cursor)
+    set -l current (commandline --current-token --cut-at-cursor)
+
+    for line in (ZSH_NAME=zsh ${name} ${COMPLETION_PROBE_FLAG} $tokens "$current" 2>/dev/null)
+        set -l masked (string replace --all -- '\\:' \\x01 $line)
+        set -l parts (string split --max 1 -- ':' $masked)
+        set -l value (string replace --all -- \\x01 ':' $parts[1])
+
+        # Filter by the partial token ourselves. fish 3.3 and older (Ubuntu
+        # 22.04 LTS ships 3.3.1) skip their own matching for any candidate that
+        # carries a description, so \`${name} ag<TAB>\` there offers every
+        # command instead of the one that matches -- and a description is the
+        # whole reason this script asks for the descriptive wire format. Newer
+        # fish filters, so this is a no-op on it. Compared by length rather
+        # than \`string match\` so a token holding a glob character stays
+        # literal. Prefix matching is also what bash's \`compgen -W\` and zsh's
+        # \`_describe\` do, so the three shells now agree.
+        if test (string sub --length (string length -- "$current") -- "$value") != "$current"
+            continue
+        end
+
+        if set -q parts[2]
+            printf '%s\\t%s\\n' $value (string replace --all -- \\x01 ':' $parts[2])
+        else
+            printf '%s\\n' $value
+        end
+    end
+end
+
+# -f: only our candidates, no filename fallback. -k: keep the CLI's own order
+# instead of fish's alphabetical sort.
+complete -c ${name} -f -k -a '(${fn})'
+${blockEnd(name)}
+`;
+}
+const defaultInstallEnv = () => ({
+	home: os.homedir(),
+	platform: process.platform,
+	env: process.env,
+	exists: fs.existsSync
+});
+/**
+* The shell to install for when the user didn't name one. `$SHELL` is the
+* only signal available: a completion 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;
+}
+function completionTarget(shell, deps = defaultInstallEnv()) {
+	const { home, platform, env, exists } = deps;
+	if (shell === "fish") {
+		const configHome = env["XDG_CONFIG_HOME"] || path.join(home, ".config");
+		return {
+			path: path.join(configHome, "fish", "completions", "skydive.fish"),
+			mode: "file"
+		};
+	}
+	if (shell === "zsh") {
+		const zdotdir = env["ZDOTDIR"] || home;
+		return {
+			path: path.join(zdotdir, ".zshrc"),
+			mode: "block"
+		};
+	}
+	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 {
+		path: alternate,
+		mode: "block"
+	};
+	return {
+		path: preferred,
+		mode: "block"
+	};
+}
+/**
+* The startup file's contents with our block added or refreshed. Idempotent:
+* a second install rewrites the block in place rather than appending a
+* duplicate, which is also how an upgraded CLI ships a newer script.
+*/
+function spliceCompletionBlock(existing, script, commandName = "skydive") {
+	const start = existing.indexOf(blockStart(commandName));
+	const endMarker = blockEnd(commandName);
+	const end = existing.indexOf(endMarker);
+	if (start !== -1 && end > start) {
+		const before = existing.slice(0, start);
+		const after = existing.slice(end + endMarker.length).replace(/^\n/, "");
+		return `${before}${script.trimEnd()}\n${after}`;
+	}
+	return `${existing}${existing === "" || existing.endsWith("\n\n") ? "" : "\n"}\n${script}`;
+}
+function installCompletionScript(shell, deps = defaultInstallEnv()) {
+	const target = completionTarget(shell, deps);
+	const script = renderCompletionScript(shell);
+	const existing = deps.exists(target.path) ? fs.readFileSync(target.path, "utf8") : "";
+	const contents = target.mode === "file" ? script : spliceCompletionBlock(existing, script);
+	fs.mkdirSync(path.dirname(target.path), { recursive: true });
+	fs.writeFileSync(target.path, contents, "utf8");
+	return {
+		shell,
+		path: target.path,
+		updated: existing.includes(blockStart("skydive"))
+	};
+}
+/** What the user has to do before completions work in the shell they're in. */
+function activationHint(result) {
+	return result.shell === "fish" ? "Open a new fish shell to pick them up (fish autoloads completions)." : `Open a new shell, or run: source ${result.path}`;
+}
+const installCommand$1 = {
+	command: "install [shell]",
+	describe: "Install completions into your shell's startup file",
+	builder: (y) => y.positional("shell", {
+		type: "string",
+		describe: "Shell to install for (default: $SHELL)"
+	}).example("skydive completion install", "Install for the current shell").example("skydive completion install fish", "Install for a named shell"),
+	handler: async (argv) => {
+		const shell = argv.shell ? SUPPORTED_SHELLS.find((candidate) => candidate === argv.shell) : detectShell();
+		if (!shell) throw new Error(argv.shell ? `No completions for ${argv.shell}. Supported: ${SUPPORTED_SHELLS.join(", ")}.` : `Could not tell which shell to install for from $SHELL. Name one: ${SUPPORTED_SHELLS.join(", ")}.`);
+		let result;
+		try {
+			result = installCompletionScript(shell);
+		} catch (error) {
+			throw new Error(`Could not write ${shell} completions: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+		}
+		if (argv.json) {
+			output(argv, result);
+			return;
+		}
+		console.log(`${result.updated ? "Updated" : "Installed"} ${result.shell} completions in ${result.path}`);
+		if (!argv.quiet) console.log(activationHint(result));
+	}
+};
+const completionCommand = {
+	command: "completion [shell]",
+	describe: "Print the shell completion script for bash, zsh, or fish",
+	builder: (y) => y.positional("shell", {
+		type: "string",
+		choices: SUPPORTED_SHELLS,
+		describe: "Shell to generate completions for"
+	}).command(installCommand$1).example("skydive completion install", "Set up completions for your shell").example("eval \"$(skydive completion zsh)\"", "Enable completions for this shell only"),
+	handler: async (argv) => {
+		if (!argv.shell) throw new Error(`Specify a shell (${SUPPORTED_SHELLS.join(", ")}), or run \`skydive completion install\` to set up $SHELL.`);
+		process.stdout.write(renderCompletionScript(argv.shell));
+	}
+};
+
 //#endregion
 //#region src/commands/session.ts
 /**
@@ -1198,7 +1500,7 @@ const importCommand = {
 				process.exit(1);
 			}
 		}
-		const { runChat } = await import("./boot-DpgN_3SH.mjs");
+		const { runChat } = await import("./boot-Buk9Rq0h.mjs");
 		await runChat({
 			appUrl,
 			sessionToken: session.value.sessionToken,
@@ -1514,7 +1816,7 @@ const chatCommand = {
 			printError(`Unknown theme "${themeId}". Valid themes: ${themes.map((t) => t.id).join(", ")}`);
 			process.exit(1);
 		}
-		const { runChat } = await import("./boot-DpgN_3SH.mjs");
+		const { runChat } = await import("./boot-Buk9Rq0h.mjs");
 		await runChat({
 			appUrl,
 			sessionToken: session.value.sessionToken,
@@ -1822,7 +2124,7 @@ const switchCommand = {
 				printError("The workspace picker needs the Bun runtime and it could not be set up automatically. Pass a workspace slug instead, or install Bun and retry.");
 				process.exit(1);
 			}
-			const { runWorkspacePicker } = await import("./boot-DpgN_3SH.mjs");
+			const { runWorkspacePicker } = await import("./boot-Buk9Rq0h.mjs");
 			await runWorkspacePicker(session);
 			return;
 		}
@@ -2882,7 +3184,7 @@ const updateCommand = {
 //#endregion
 //#region src/cli.ts
 function createCli(argv) {
-	return yargs(argv).scriptName("skydive").usage("$0 <command> [options]").parserConfiguration({ "populate--": true }).example("skydive auth login", "Store your API key").example("skydive chat", "Open the interactive chat TUI (prod)").example("skydive chat --api-url http://localhost:4500", "Chat against a local dev API").example("skydive agents list", "List your agents").example("skydive keys create \"my-key\"", "Create an API key").example("skydive secrets set OPENAI_API_KEY --agent-id <id>", "Set a secret (value from stdin)").example("skydive workspace list", "List workspaces on your account").example("skydive workspace switch acme-team", "Switch the workspace all `skydive` commands act on").example("skydive portal open --agent grace", "Open the portal to this machine for an agent, headless (no TUI)").option("json", {
+	return yargs(argv).scriptName("skydive").usage("$0 <command> [options]").parserConfiguration({ "populate--": true }).example("skydive auth login", "Store your API key").example("skydive chat", "Open the interactive chat TUI (prod)").example("skydive chat --api-url http://localhost:4500", "Chat against a local dev API").example("skydive agents list", "List your agents").example("skydive completion install", "Set up TAB completion for your shell").example("skydive keys create \"my-key\"", "Create an API key").example("skydive secrets set OPENAI_API_KEY --agent-id <id>", "Set a secret (value from stdin)").example("skydive workspace list", "List workspaces on your account").example("skydive workspace switch acme-team", "Switch the workspace all `skydive` commands act on").example("skydive portal open --agent grace", "Open the portal to this machine for an agent, headless (no TUI)").option("json", {
 		type: "boolean",
 		default: false,
 		global: true,
@@ -2896,7 +3198,7 @@ function createCli(argv) {
 		type: "string",
 		global: true,
 		describe: "Override API base URL"
-	}).command(authCommand).command(chatCommand).command(messagesCommand).command(conversationsCommand).command(agentsCommand).command(importCommand).command(keysCommand).command(secretsCommand).command(workspaceCommand).command(portalCommand).command(sandboxCommand).command(updateCommand).demandCommand(1, "Specify a command. Run --help for usage.").strict().wrap(null).version(version).alias("v", "version").alias("h", "help").help().fail((msg, err) => {
+	}).command(authCommand).command(chatCommand).command(messagesCommand).command(conversationsCommand).command(agentsCommand).command(importCommand).command(keysCommand).command(secretsCommand).command(workspaceCommand).command(portalCommand).command(sandboxCommand).command(updateCommand).command(completionCommand).demandCommand(1, "Specify a command. Run --help for usage.").strict().wrap(null).version(version).alias("v", "version").alias("h", "help").help().fail((msg, err) => {
 		printError(err ? err instanceof Error ? err.message : String(err) : msg ?? "Unknown error");
 		process.exit(1);
 	});
@@ -3255,11 +3557,14 @@ if (process.argv.includes(PORTAL_DAEMON_FLAG)) {
 	runPortalDaemon(process.argv);
 } else runCli();
 function runCli() {
-	maybePrintWhatsNew();
-	setupUpdateCheck(hideBin(process.argv));
-	const resolved = resolveArgv(hideBin(process.argv));
+	const completionProbe = isCompletionProbe(process.argv);
+	if (!completionProbe) {
+		maybePrintWhatsNew();
+		setupUpdateCheck(hideBin(process.argv));
+	}
+	const resolved = resolveArgv(normalizeProbeArgv(hideBin(process.argv)));
 	const raw = hideBin(process.argv);
-	if ((raw.includes("--help") || raw.includes("-h")) && !raw.some((a) => !a.startsWith("-")) && !raw.includes("--json") && !raw.includes("--quiet")) process.stdout.write(brandHelpArt());
+	if (!completionProbe && (raw.includes("--help") || raw.includes("-h")) && !raw.some((a) => !a.startsWith("-")) && !raw.includes("--json") && !raw.includes("--quiet")) process.stdout.write(brandHelpArt());
 	createCli(resolved).parse();
 }
 

package/dist/js/{boot-DpgN_3SH.mjs → boot-Buk9Rq0h.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { C as setActiveWorkspace, S as listWorkspaces, a as WORDMARK, b as getActiveWorkspaceId, c as applyTheme, d as noColorRequested, f as theme, g as themeVersion, h as themeModeFromColorFgBg, i as MARK_CELLS, l as findTheme, m as themeMode, n as buildCrashReport, p as themeForMode, r as writeCrashReport, s as DEFAULT_THEME_ID, t as installCrashHandler, u as monoTheme, v as themesForMode } from "./install-ZNL9Ss_c.mjs";
+import { C as setActiveWorkspace, S as listWorkspaces, a as WORDMARK, b as getActiveWorkspaceId, c as applyTheme, d as noColorRequested, f as theme, g as themeVersion, h as themeModeFromColorFgBg, i as MARK_CELLS, l as findTheme, m as themeMode, n as buildCrashReport, p as themeForMode, r as writeCrashReport, s as DEFAULT_THEME_ID, t as installCrashHandler, u as monoTheme, v as themesForMode } from "./install-DgwIUN1J.mjs";
 import { L as saveTheme, P as resolveWebUrl, T as getSavedTheme, c as cardActionErrorMessage, d as reconcileMaskedInput, f as resolveConnectUrl, i as resolveAgent, l as parseExternalOauthConnectParams, m as specKeyFor, p as parseConnectCard, s as MASK_CHAR, u as parseOauthConnectParams, v as DEFAULT_API_URL, w as getReviewStateDir, x as getConfigPath, y as DEFAULT_APP_URL } from "./print-BUbxOvnm.mjs";
 import { a as errorMessage, i as sendErrorMessage, n as createRestClient, o as isRecord, r as errorDetail, t as HttpError } from "./rest-CCyln7vx.mjs";
 import { t as PortalClient } from "./client-O5KfzIaB.mjs";
@@ -11,9 +11,9 @@ import { homedir, platform, release, tmpdir } from "node:os";
 import path, { basename, extname, isAbsolute, join, win32 } from "node:path";
 import { z } from "zod";
 import open from "open";
+import { constants } from "node:fs";
 import { execFile, spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
-import { constants } from "node:fs";
 import { connect, createConnection } from "node:net";
 import { access, appendFile, mkdir, mkdtemp, readFile, readdir, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { MarkdownRenderable, RenderableEvents, StyledText, SyntaxStyle, createCliRenderer, decodePasteBytes, detectLinks, fg, link } from "@opentui/core";

package/dist/js/{install-ZNL9Ss_c.mjs → install-DgwIUN1J.mjs}

@@ -8,7 +8,7 @@ import fs from "node:fs";
 
 //#region package.json
 var name = "skydive-cli";
-var version$1 = "0.2.0-beta.630";
+var version$1 = "0.2.0-beta.684";
 
 //#endregion
 //#region src/auth/organization.ts

package/package.json

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