skydive-cli 0.1.0

package/dist/js/print-BHbFMxQv.mjs

@@ -0,0 +1,442 @@
+#!/usr/bin/env node
+import { z } from "zod";
+import { createParser } from "eventsource-parser";
+
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region src/chat/api/rest.ts
+var HttpError = class extends Error {
+	constructor(status, body) {
+		super(`HTTP ${status}: ${body.slice(0, 200)}`);
+		this.status = status;
+		this.body = body;
+		this.name = "HttpError";
+	}
+};
+const MAX_STREAM_RECONNECTS = 5;
+function createRestClient({ appUrl, sessionToken }) {
+	const baseHeaders = {
+		authorization: `Bearer ${sessionToken}`,
+		accept: "application/json"
+	};
+	async function get(path, schema) {
+		const res = await fetch(`${appUrl}${path}`, { headers: baseHeaders });
+		if (!res.ok) throw new HttpError(res.status, await res.text().catch(() => ""));
+		return schema.parse(await res.json());
+	}
+	async function post(path, body, schema, method = "POST") {
+		const res = await fetch(`${appUrl}${path}`, {
+			method,
+			headers: {
+				...baseHeaders,
+				"content-type": "application/json"
+			},
+			body: JSON.stringify(body)
+		});
+		if (!res.ok) throw new HttpError(res.status, await res.text().catch(() => ""));
+		return schema.parse(await res.json());
+	}
+	async function del(path) {
+		const res = await fetch(`${appUrl}${path}`, {
+			method: "DELETE",
+			headers: baseHeaders
+		});
+		if (!res.ok) throw new HttpError(res.status, await res.text().catch(() => ""));
+	}
+	return {
+		listAgents: async ({ scope, onPage }) => {
+			const all = [];
+			let cursor;
+			const maxAgents = 2e3;
+			do {
+				const params = new URLSearchParams({
+					limit: "100",
+					scope,
+					sort: "mine_first_usage",
+					includeStats: "false"
+				});
+				if (cursor) params.set("cursor", cursor);
+				const page = await get(`/api/v1/agents?${params.toString()}`, listAgentsResponseSchema);
+				all.push(...page.agents);
+				cursor = page.nextCursor ?? void 0;
+				onPage?.([...all]);
+			} while (cursor && all.length < maxAgents);
+			return all;
+		},
+		createAgent: async ({ name }) => {
+			const { agent } = await post("/api/v1/agents", { name }, createAgentResponseSchema);
+			return agent;
+		},
+		getConversation: async ({ conversationId }) => {
+			const { conversation } = await get(`/api/v1/conversations/${encodeURIComponent(conversationId)}`, getConversationResponseSchema);
+			return conversation;
+		},
+		listModels: async () => {
+			const { models } = await get("/api/v1/models", listModelsResponseSchema);
+			return models;
+		},
+		updateAgentModel: async ({ agentId, model }) => {
+			const { agent } = await post(`/api/v1/agents/${encodeURIComponent(agentId)}`, { model }, updateAgentResponseSchema, "PATCH");
+			return { model: agent.model ?? null };
+		},
+		listConversations: async ({ agentId, limit }) => {
+			const params = new URLSearchParams({
+				agentId,
+				includeTotal: "false"
+			});
+			if (limit) params.set("limit", String(limit));
+			const { conversations } = await get(`/api/v1/conversations?${params.toString()}`, listConversationsResponseSchema);
+			return conversations;
+		},
+		listMessages: async ({ conversationId }) => {
+			const { messages } = await get(`/api/v1/conversations/${encodeURIComponent(conversationId)}/messages`, listMessagesResponseSchema);
+			return messages;
+		},
+		uploadAttachment: async ({ agentId, fileName, mediaType, data }) => {
+			const size = data.byteLength;
+			const presign = await post("/api/v1/attachments/presign", {
+				agentId,
+				fileName,
+				mediaType,
+				size
+			}, presignResponseSchema);
+			const putRes = await fetch(presign.uploadUrl, {
+				method: "PUT",
+				headers: { "content-type": mediaType },
+				body: new Uint8Array(data)
+			});
+			if (!putRes.ok) throw new HttpError(putRes.status, await putRes.text().catch(() => ""));
+			const finalized = await post(`/api/v1/attachments/${encodeURIComponent(presign.id)}/finalize`, {
+				agentId,
+				fileName: presign.fileName,
+				mediaType: presign.mediaType,
+				size
+			}, finalizeResponseSchema);
+			return {
+				id: presign.id,
+				fileName: finalized.fileName,
+				mediaType: finalized.mediaType,
+				sizeBytes: finalized.sizeBytes ?? size
+			};
+		},
+		deleteConversation: async ({ conversationId }) => {
+			await del(`/api/v1/conversations/${encodeURIComponent(conversationId)}`);
+		},
+		sendMessage: async (input) => post("/api/v1/chat/send", input, sendResultSchema),
+		activeRun: async ({ conversationId }) => {
+			const { run } = await get(`/api/v1/chat/active-run?${new URLSearchParams({ conversationId }).toString()}`, activeRunResponseSchema);
+			return run;
+		},
+		cancelRun: async ({ runId }) => {
+			await post(`/api/v1/chat/runs/${encodeURIComponent(runId)}/cancel`, {}, z.object({ ok: z.boolean() }));
+		},
+		cancelSteer: async ({ directiveId }) => {
+			await post(`/api/v1/chat/steer/${encodeURIComponent(directiveId)}/cancel`, {}, z.object({ ok: z.boolean() }));
+		},
+		oauthConnect: async (input) => {
+			const { connectLink } = await post("/api/v1/oauth/connect", input, oauthConnectResponseSchema);
+			return { connectLink };
+		},
+		externalOauthConnect: async (input) => {
+			const { authorizationUrl } = await post("/api/v1/external-oauth/connect", input, externalOauthConnectResponseSchema);
+			return { authorizationUrl: authorizationUrl ?? null };
+		},
+		fulfillCredential: async ({ url, body }) => {
+			const target = new URL(url, appUrl).toString();
+			const res = await fetch(target, {
+				method: "POST",
+				headers: {
+					...baseHeaders,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify(body)
+			});
+			if (!res.ok) throw new HttpError(res.status, await res.text().catch(() => ""));
+		},
+		streamRun: async ({ runId, signal, onEvent }) => {
+			let lastEventId = null;
+			let finished = false;
+			let reconnects = 0;
+			for (;;) {
+				if (signal.aborted) return;
+				try {
+					const headers = {
+						authorization: `Bearer ${sessionToken}`,
+						accept: "text/event-stream"
+					};
+					if (lastEventId) headers["last-event-id"] = lastEventId;
+					const res = await fetch(`${appUrl}/api/v1/chat/runs/${encodeURIComponent(runId)}/stream`, {
+						headers,
+						signal
+					});
+					if (!res.ok || !res.body) throw new HttpError(res.status, await res.text().catch(() => ""));
+					reconnects = 0;
+					const parser = createParser({ onEvent: (message) => {
+						if (message.id) lastEventId = message.id;
+						if (message.event === "error") {
+							const { error } = streamErrorSchema.parse(JSON.parse(message.data));
+							throw new Error(error);
+						}
+						const event = runStreamEventSchema.parse(JSON.parse(message.data));
+						if (event.kind === "finished") finished = true;
+						onEvent(event.kind === "finished" ? {
+							...event,
+							error: event.error ?? null
+						} : event);
+					} });
+					const decoder = new TextDecoder();
+					const reader = res.body.getReader();
+					try {
+						for (;;) {
+							const { done, value } = await reader.read();
+							if (done) break;
+							parser.feed(decoder.decode(value, { stream: true }));
+							if (finished) return;
+						}
+					} finally {
+						try {
+							await reader.cancel();
+						} catch (_error) {}
+					}
+				} catch (err) {
+					if (signal.aborted) return;
+					if (err instanceof HttpError && err.status >= 400 && err.status < 500) throw err;
+					reconnects += 1;
+					if (reconnects > MAX_STREAM_RECONNECTS) throw err;
+					await sleep(Math.min(500 * 2 ** reconnects, 5e3));
+					continue;
+				}
+				if (finished) return;
+				reconnects += 1;
+				if (reconnects > MAX_STREAM_RECONNECTS) throw new Error("run stream ended unexpectedly");
+				await sleep(Math.min(500 * 2 ** reconnects, 5e3));
+			}
+		}
+	};
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const agentSummarySchema = z.object({
+	id: z.string().uuid(),
+	name: z.string(),
+	slug: z.string().nullable().optional(),
+	title: z.string().nullable().optional(),
+	description: z.string().nullable().optional(),
+	createdAt: z.string(),
+	creatorName: z.string().nullable().optional(),
+	model: z.string().nullable().optional(),
+	modelLocked: z.boolean().optional()
+});
+const platformModelSchema = z.object({
+	id: z.string(),
+	displayName: z.string(),
+	providerDisplay: z.string().optional(),
+	reasoning: z.boolean().optional(),
+	compliant: z.boolean().optional()
+}).passthrough();
+const listModelsResponseSchema = z.object({ models: z.array(platformModelSchema) });
+const updateAgentResponseSchema = z.object({ agent: z.object({ model: z.string().nullable().optional() }).passthrough() });
+const listAgentsResponseSchema = z.object({
+	agents: z.array(agentSummarySchema),
+	nextCursor: z.string().nullable().optional(),
+	totalCount: z.number().nullable().optional()
+});
+const createAgentResponseSchema = z.object({ agent: agentSummarySchema });
+const conversationSummarySchema = z.object({
+	id: z.string().uuid(),
+	title: z.string().nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	preview: z.string().nullable(),
+	channel: z.string().nullable(),
+	channelLabel: z.string().nullable(),
+	agent: z.object({
+		id: z.string().uuid(),
+		name: z.string(),
+		slug: z.string().nullable().optional(),
+		title: z.string().nullable().optional()
+	})
+});
+const conversationTitleSchema = z.object({
+	id: z.string().uuid(),
+	title: z.string().nullable()
+});
+const getConversationResponseSchema = z.object({ conversation: conversationTitleSchema });
+const listConversationsResponseSchema = z.object({
+	conversations: z.array(conversationSummarySchema),
+	nextCursor: z.string().nullable().optional(),
+	totalCount: z.number().optional()
+});
+const uiMessagePartSchema = z.union([
+	z.object({
+		type: z.literal("text"),
+		text: z.string()
+	}),
+	z.object({
+		type: z.literal("reasoning"),
+		text: z.string().optional()
+	}),
+	z.object({
+		type: z.literal("dynamic-tool"),
+		toolCallId: z.string(),
+		toolName: z.string(),
+		input: z.unknown().optional(),
+		output: z.unknown().optional(),
+		state: z.string().optional(),
+		errorText: z.string().optional()
+	}),
+	z.object({ type: z.string() }).passthrough()
+]);
+const uiMessageSchema = z.object({
+	id: z.string(),
+	role: z.string(),
+	parts: z.array(uiMessagePartSchema)
+});
+const listMessagesResponseSchema = z.object({ messages: z.array(uiMessageSchema) });
+const sendResultSchema = z.object({
+	runId: z.string(),
+	conversationId: z.string().uuid(),
+	isNewConversation: z.boolean(),
+	steered: z.boolean().optional(),
+	directive: z.object({ id: z.string() }).passthrough().optional()
+});
+const presignResponseSchema = z.object({
+	id: z.string(),
+	uploadUrl: z.string(),
+	fileName: z.string(),
+	mediaType: z.string()
+});
+const finalizeResponseSchema = z.object({
+	fileName: z.string(),
+	mediaType: z.string(),
+	sizeBytes: z.number().nullable().optional()
+});
+const activeRunResponseSchema = z.object({ run: z.object({ runId: z.string() }).nullable() });
+const oauthConnectResponseSchema = z.object({ connectLink: z.string() }).passthrough();
+const externalOauthConnectResponseSchema = z.object({ authorizationUrl: z.string().optional() }).passthrough();
+const runStreamEventSchema = z.union([z.object({
+	kind: z.literal("chunk"),
+	chunk: z.record(z.unknown())
+}), z.object({
+	kind: z.literal("finished"),
+	status: z.string(),
+	error: z.string().nullish()
+})]);
+const streamErrorSchema = z.object({ error: z.string() });
+
+//#endregion
+//#region src/chat/print.ts
+var print_exports = /* @__PURE__ */ __exportAll({
+	readStdin: () => readStdin,
+	resolveAgent: () => resolveAgent,
+	runPrint: () => runPrint
+});
+/**
+* Non-interactive chat, à la `claude -p`. Sends a single prompt to an
+* agent, streams the run, and prints the assistant's reply to stdout
+* before exiting. No OpenTUI, no Bun requirement — this rides the same
+* Node-friendly REST client the TUI uses, so it runs anywhere the
+* management commands do (CI, pipes, scripts).
+*
+* Resolution rules kept deliberately strict because there's no human to
+* disambiguate: an `--agent` selector must match exactly one agent, and
+* when it's omitted we only auto-pick if the account has exactly one.
+*/
+async function runPrint({ appUrl, sessionToken, prompt, agentSelector, conversationId, json }) {
+	const client = createRestClient({
+		appUrl,
+		sessionToken
+	});
+	const agent = resolveAgent(await client.listAgents({
+		scope: "org",
+		onPage: null
+	}), agentSelector);
+	const send = await client.sendMessage({
+		agentId: agent.id,
+		conversationId,
+		content: prompt,
+		attachmentIds: []
+	});
+	let text = "";
+	const controller = new AbortController();
+	let streamError = null;
+	await client.streamRun({
+		runId: send.runId,
+		signal: controller.signal,
+		onEvent: (event) => {
+			if (event.kind === "finished") {
+				if (event.error) streamError = event.error;
+				return;
+			}
+			const chunk = event.chunk;
+			if (chunk["type"] === "text-delta") {
+				const delta = typeof chunk["delta"] === "string" ? chunk["delta"] : typeof chunk["text"] === "string" ? chunk["text"] : "";
+				if (delta) {
+					text += delta;
+					if (!json) process.stdout.write(delta);
+				}
+			} else if (chunk["type"] === "error") streamError = typeof chunk["errorText"] === "string" ? chunk["errorText"] : "unknown error";
+		}
+	});
+	if (streamError) throw new Error(streamError);
+	if (!json && text && !text.endsWith("\n")) process.stdout.write("\n");
+	return {
+		agentId: agent.id,
+		agentName: agent.name,
+		conversationId: send.conversationId,
+		isNewConversation: send.isNewConversation,
+		runId: send.runId,
+		text
+	};
+}
+/**
+* Pick the target agent. With no selector, auto-pick only when the
+* account has exactly one agent; otherwise the user must name one (there's
+* no picker in non-interactive mode). A selector matches by id first, then
+* a unique case-insensitive slug/name; ambiguous or missing matches throw
+* with the candidate list so the caller knows what to pass.
+*/
+function resolveAgent(agents, selector) {
+	if (!selector) {
+		const [only, ...rest] = agents;
+		if (!only) throw new Error("No agents on this account.");
+		if (rest.length === 0) return only;
+		throw new Error(`Multiple agents on this account — pass --agent <id|slug|name>. Candidates:\n${formatCandidates(agents)}`);
+	}
+	const byId = agents.find((a) => a.id === selector);
+	if (byId) return byId;
+	const needle = selector.toLowerCase();
+	const matches = agents.filter((a) => a.slug && a.slug.toLowerCase() === needle || a.name.toLowerCase() === needle);
+	const [firstMatch, ...restMatches] = matches;
+	if (firstMatch && restMatches.length === 0) return firstMatch;
+	if (restMatches.length > 0) throw new Error(`Multiple agents match "${selector}" — pass the id instead. Candidates:\n${formatCandidates(matches)}`);
+	throw new Error(`No agent matches "${selector}". Candidates:\n${formatCandidates(agents)}`);
+}
+function formatCandidates(agents) {
+	return agents.slice(0, 25).map((a) => `  ${a.id}  ${a.slug ?? a.name}`).join("\n");
+}
+/** Read all of stdin as UTF-8. Used when `-p` is passed with no value. */
+async function readStdin() {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	return Buffer.concat(chunks).toString("utf8");
+}
+
+//#endregion
+export { createRestClient as i, resolveAgent as n, HttpError as r, print_exports as t };

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "skydive-cli",
+  "version": "0.1.0",
+  "description": "Skydive CLI — manage AI agents from the command line",
+  "homepage": "https://skydive.com",
+  "license": "MIT",
+  "bin": {
+    "skydive": "./dist/js/bin.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    "./bin": "./dist/js/bin.mjs"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "build": "tsdown --no-dts --out-dir dist/js",
+    "test:unit": "vitest run --passWithNoTests",
+    "test:ci": "vitest run --coverage --coverage.reporter=lcovonly --reporter=default --reporter=github-actions --minWorkers=1 --maxWorkers=2 --passWithNoTests",
+    "typecheck": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "@opentui/react": "0.4.3",
+    "conf": "^13.0.1",
+    "diff": "9.0.0",
+    "eventsource-parser": "^3.0.8",
+    "neverthrow": "^8.2.0",
+    "open": "^10.1.0",
+    "react": "^19.0.0",
+    "react-devtools-core": "^7.0.1",
+    "web-tree-sitter": "0.25.10",
+    "ws": "^8.18.0",
+    "yargs": "^17.7.2",
+    "zod": "^3.24.1",
+    "zustand": "^5.0.2"
+  },
+  "devDependencies": {
+    "@createinc/anyone-portal-protocol": "workspace:*",
+    "@createinc/tsconfig": "workspace:*",
+    "@types/node": "^24.0.0",
+    "@types/react": "^19.0.0",
+    "@types/yargs": "^17.0.33",
+    "@typescript/native-preview": "^7.0.0-dev.20260113.1",
+    "@vitest/coverage-v8": "^2.1.8",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3",
+    "vitest": "^2.1.8"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}