skydive-cli 0.2.0 → 0.3.0-beta.773

package/dist/js/chat/tui/chunks/grammars/assets/yaml.highlights.scm

@@ -0,0 +1,79 @@
+(boolean_scalar) @boolean
+
+(null_scalar) @constant.builtin
+
+[
+  (double_quote_scalar)
+  (single_quote_scalar)
+  (block_scalar)
+  (string_scalar)
+] @string
+
+[
+  (integer_scalar)
+  (float_scalar)
+] @number
+
+(comment) @comment
+
+[
+  (anchor_name)
+  (alias_name)
+] @label
+
+(tag) @type
+
+[
+  (yaml_directive)
+  (tag_directive)
+  (reserved_directive)
+] @attribute
+
+(block_mapping_pair
+  key: (flow_node
+    [
+      (double_quote_scalar)
+      (single_quote_scalar)
+    ] @property))
+
+(block_mapping_pair
+  key: (flow_node
+    (plain_scalar
+      (string_scalar) @property)))
+
+(flow_mapping
+  (_
+    key: (flow_node
+      [
+        (double_quote_scalar)
+        (single_quote_scalar)
+      ] @property)))
+
+(flow_mapping
+  (_
+    key: (flow_node
+      (plain_scalar
+        (string_scalar) @property))))
+
+[
+  ","
+  "-"
+  ":"
+  ">"
+  "?"
+  "|"
+] @punctuation.delimiter
+
+[
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+[
+  "*"
+  "&"
+  "---"
+  "..."
+] @punctuation.special

package/dist/js/chat/tui/chunks/grammars/grammars.ts

@@ -0,0 +1,146 @@
+/**
+ * Extra tree-sitter grammars for the chat TUI, on top of OpenTUI's five
+ * bundled ones (javascript, typescript, markdown, zig). Without these, every
+ * fenced code block and every diff/file-review pane in a non-js/ts language
+ * renders unhighlighted.
+ *
+ * Each entry pairs a prebuilt `.wasm` parser with its co-versioned
+ * `highlights.scm` query. `scripts/fetch-grammars.ts` vendors both from the
+ * same npm package into ./assets and records the versions in manifest.json —
+ * grammar and query MUST match or `Query` compilation throws at runtime.
+ *
+ * ── Why the `with { type: 'file' }` imports ──────────────────────────────
+ * The chat TUI always runs under Bun (the `chat` command re-execs itself
+ * under Bun before it touches OpenTUI). Under Bun these imports resolve to a
+ * real filesystem path in dev, and `bun build --compile` embeds each asset
+ * into the binary's virtual filesystem and rewrites the path to `/$bunfs`.
+ * OpenTUI loads its own bundled grammars exactly this way.
+ *
+ * Rolldown (tsdown, the npm build) CANNOT parse `.wasm`/`.scm` as modules, so
+ * this file is externalized in tsdown.config.mts and copied verbatim into
+ * dist/js/chat/tui/chunks/grammars/ alongside its assets; the bundled
+ * bin.mjs reaches it through a dynamic import that Bun resolves at runtime.
+ * Keep every asset reference a static `with { type: 'file' }` import so the
+ * compiled binary discovers and embeds them — a runtime `Bun.file(path)` on
+ * a computed path would not be embedded.
+ */
+import type { FiletypeParserOptions } from '@opentui/core';
+
+import python_wasm from './assets/python.wasm' with { type: 'file' };
+import python_scm from './assets/python.highlights.scm' with { type: 'file' };
+import bash_wasm from './assets/bash.wasm' with { type: 'file' };
+import bash_scm from './assets/bash.highlights.scm' with { type: 'file' };
+import go_wasm from './assets/go.wasm' with { type: 'file' };
+import go_scm from './assets/go.highlights.scm' with { type: 'file' };
+import rust_wasm from './assets/rust.wasm' with { type: 'file' };
+import rust_scm from './assets/rust.highlights.scm' with { type: 'file' };
+import c_wasm from './assets/c.wasm' with { type: 'file' };
+import c_scm from './assets/c.highlights.scm' with { type: 'file' };
+import cpp_wasm from './assets/cpp.wasm' with { type: 'file' };
+import cpp_scm from './assets/cpp.highlights.scm' with { type: 'file' };
+import java_wasm from './assets/java.wasm' with { type: 'file' };
+import java_scm from './assets/java.highlights.scm' with { type: 'file' };
+import ruby_wasm from './assets/ruby.wasm' with { type: 'file' };
+import ruby_scm from './assets/ruby.highlights.scm' with { type: 'file' };
+import css_wasm from './assets/css.wasm' with { type: 'file' };
+import css_scm from './assets/css.highlights.scm' with { type: 'file' };
+import html_wasm from './assets/html.wasm' with { type: 'file' };
+import html_scm from './assets/html.highlights.scm' with { type: 'file' };
+import json_wasm from './assets/json.wasm' with { type: 'file' };
+import json_scm from './assets/json.highlights.scm' with { type: 'file' };
+import yaml_wasm from './assets/yaml.wasm' with { type: 'file' };
+import yaml_scm from './assets/yaml.highlights.scm' with { type: 'file' };
+import toml_wasm from './assets/toml.wasm' with { type: 'file' };
+import toml_scm from './assets/toml.highlights.scm' with { type: 'file' };
+import lua_wasm from './assets/lua.wasm' with { type: 'file' };
+import lua_scm from './assets/lua.highlights.scm' with { type: 'file' };
+
+/**
+ * `aliases` are the alternate names a code fence or file extension may use
+ * for the language (```sh → bash, ```py → python). OpenTUI's markdown
+ * injection resolver looks up a fence's info-string against each parser's
+ * registered aliases, so listing them here is what makes ```sh highlight.
+ * The canonical `filetype` need not be repeated in its own alias list.
+ */
+export const EXTRA_GRAMMARS: FiletypeParserOptions[] = [
+  {
+    filetype: 'python',
+    aliases: ['py', 'python3'],
+    wasm: python_wasm,
+    queries: { highlights: [python_scm] },
+  },
+  {
+    filetype: 'bash',
+    aliases: ['sh', 'shell', 'zsh', 'shellscript'],
+    wasm: bash_wasm,
+    queries: { highlights: [bash_scm] },
+  },
+  {
+    filetype: 'go',
+    aliases: ['golang'],
+    wasm: go_wasm,
+    queries: { highlights: [go_scm] },
+  },
+  {
+    filetype: 'rust',
+    aliases: ['rs'],
+    wasm: rust_wasm,
+    queries: { highlights: [rust_scm] },
+  },
+  {
+    filetype: 'c',
+    aliases: ['h'],
+    wasm: c_wasm,
+    queries: { highlights: [c_scm] },
+  },
+  {
+    filetype: 'cpp',
+    aliases: ['c++', 'cc', 'cxx', 'hpp', 'hxx', 'hh'],
+    wasm: cpp_wasm,
+    queries: { highlights: [cpp_scm] },
+  },
+  {
+    filetype: 'java',
+    wasm: java_wasm,
+    queries: { highlights: [java_scm] },
+  },
+  {
+    filetype: 'ruby',
+    aliases: ['rb'],
+    wasm: ruby_wasm,
+    queries: { highlights: [ruby_scm] },
+  },
+  {
+    filetype: 'css',
+    wasm: css_wasm,
+    queries: { highlights: [css_scm] },
+  },
+  {
+    filetype: 'html',
+    aliases: ['htm'],
+    wasm: html_wasm,
+    queries: { highlights: [html_scm] },
+  },
+  {
+    filetype: 'json',
+    aliases: ['jsonc'],
+    wasm: json_wasm,
+    queries: { highlights: [json_scm] },
+  },
+  {
+    filetype: 'yaml',
+    aliases: ['yml'],
+    wasm: yaml_wasm,
+    queries: { highlights: [yaml_scm] },
+  },
+  {
+    filetype: 'toml',
+    wasm: toml_wasm,
+    queries: { highlights: [toml_scm] },
+  },
+  {
+    filetype: 'lua',
+    wasm: lua_wasm,
+    queries: { highlights: [lua_scm] },
+  },
+];

package/dist/js/{client-B3ZhhF7e.mjs → client-Dc7GZ3PG.mjs}

@@ -1,10 +1,66 @@
 #!/usr/bin/env node
-import { t as errorMessage } from "./util-CeisaZVY.mjs";
-import { c as machineIdentity, i as mintPortalDeviceToken, l as portalWsUrl, n as findThisDevice, r as grantPortalAccess, s as buildEnv, t as fetchPortalDevices } from "./api-CDTKq_5Q.mjs";
+import { a as errorMessage, t as HttpError } from "./rest-BlN_uWmL.mjs";
+import os from "node:os";
 import { z } from "zod";
 import { spawn } from "node:child_process";
 import { WebSocket } from "ws";
 
+//#region src/chat/portal/machine.ts
+/**
+* Identity this machine registers under when the CLI shares it via the portal.
+*
+* The `-cli` suffix / `(CLI)` label keep a CLI-shared machine a DISTINCT portal
+* device from the same host's Skydive Desktop app. `portal_device` is unique on
+* (org, user, machineName), and directives route to whichever socket holds the
+* device — if the CLI and desktop registered the same name they'd share a
+* device row and both execute every directive. Distinct names also make the
+* grant UI unambiguous about which surface is being authorized.
+*/
+function machineIdentity() {
+	const host = (os.hostname() || "machine").trim().replace(/\.local$/i, "") || "machine";
+	return {
+		machineName: `${host}-cli`,
+		friendlyName: `${host} (CLI)`
+	};
+}
+const INHERITED_ENV = [
+	"HOME",
+	"USER",
+	"LOGNAME",
+	"SHELL",
+	"LANG",
+	"LC_ALL",
+	"TMPDIR",
+	"TERM",
+	"PATH"
+];
+function buildEnv(extra) {
+	const env = {};
+	for (const key of INHERITED_ENV) {
+		const value = process.env[key];
+		if (value !== void 0) env[key] = value;
+	}
+	if (extra) for (const [key, value] of Object.entries(extra)) env[key] = value;
+	return env;
+}
+/**
+* Build the desktop-portal WebSocket URL from the chat origin. Mirrors the Rust
+* desktop client: http→ws, https→wss, scheme-less defaults to wss, and the
+* machine/label ride as query pairs (percent-encoded by URL).
+*/
+function portalWsUrl(appUrl, machine, label) {
+	const base = appUrl.replace(/\/+$/, "");
+	let wsBase;
+	if (base.startsWith("https://")) wsBase = `wss://${base.slice(8)}`;
+	else if (base.startsWith("http://")) wsBase = `ws://${base.slice(7)}`;
+	else wsBase = `wss://${base}`;
+	const url = new URL(`${wsBase}/api/v1/portal/desktop`);
+	url.searchParams.set("machine", machine);
+	url.searchParams.set("label", label);
+	return url.toString();
+}
+
+//#endregion
 //#region ../portal-protocol/src/index.ts
 const MAX_WS_FRAME_BYTES = 16 * 1024 * 1024;
 const T_DATA = 1;
@@ -31,7 +87,8 @@ const ctrlMessageSchema = z.discriminatedUnion("t", [
 	z.object({
 		t: z.literal("open"),
 		argv: z.array(z.string()),
-		env: z.record(z.string()).nullable()
+		env: z.record(z.string()).nullable(),
+		conversationId: z.string().nullable().optional()
 	}),
 	z.object({ t: z.literal("stdin_eof") }),
 	z.object({ t: z.literal("pause") }),
@@ -103,7 +160,7 @@ var JobManager = class {
 	handleCtrl(id, msg) {
 		switch (msg.t) {
 			case "open":
-				this.startJob(id, msg.argv, msg.env);
+				this.startJob(id, msg.argv, msg.env, msg.conversationId ?? null);
 				return;
 			case "stdin_eof":
 				this.jobs.get(id)?.child.stdin.end();
@@ -133,7 +190,7 @@ var JobManager = class {
 			job.child.stderr.resume();
 		}
 	}
-	startJob(id, argv, env) {
+	startJob(id, argv, env, conversationId) {
 		const [program, ...args] = argv;
 		if (!program) {
 			this.opts.send(encodeCtrl(id, {
@@ -145,7 +202,7 @@ var JobManager = class {
 		let child;
 		try {
 			child = spawn(program, args, {
-				cwd: this.opts.cwd,
+				cwd: this.opts.resolveCwd(conversationId),
 				env: buildEnv(env),
 				stdio: [
 					"pipe",
@@ -194,6 +251,89 @@ var JobManager = class {
 	}
 };
 
+//#endregion
+//#region src/chat/portal/api.ts
+/**
+* The portal's session-authed REST surface, shared by `PortalClient` (the
+* TUI/`portal open` connection) and the `skydive portal` management
+* commands, so the endpoint contracts and response schemas live in exactly
+* one place.
+*/
+const deviceSchema = z.object({
+	id: z.string(),
+	machineName: z.string(),
+	friendlyName: z.string(),
+	connected: z.boolean(),
+	lastSeen: z.string().nullable(),
+	grantedAgentIds: z.array(z.string())
+});
+const devicesResponseSchema = z.object({
+	devices: z.array(deviceSchema),
+	agents: z.array(z.object({
+		id: z.string(),
+		name: z.string()
+	}))
+});
+const deviceTokenSchema = z.object({ token: z.string().min(1) });
+async function portalFetch(auth, path, init) {
+	const res = await fetch(`${auth.appUrl}${path}`, {
+		method: init.method,
+		headers: {
+			authorization: `Bearer ${auth.sessionToken}`,
+			accept: "application/json",
+			...init.body ? { "content-type": "application/json" } : {}
+		},
+		...init.body ? { body: init.body } : {}
+	});
+	if (!res.ok) {
+		const body = await res.text().catch(() => "");
+		throw new HttpError(res.status, body);
+	}
+	return res.json();
+}
+async function fetchPortalDevices(auth) {
+	const json = await portalFetch(auth, "/api/v1/portal/devices", { method: "GET" });
+	return devicesResponseSchema.parse(json);
+}
+const registerResponseSchema = z.object({ device: z.object({ id: z.string() }) });
+/**
+* Register this machine's device row without connecting. Connecting registers
+* as a side effect; this covers granting an agent on a machine that has never
+* shared yet (the grant references the device row).
+*/
+async function registerPortalDevice(auth, { machineName, friendlyName }) {
+	const json = await portalFetch(auth, "/api/v1/portal/devices", {
+		method: "POST",
+		body: JSON.stringify({
+			machineName,
+			friendlyName
+		})
+	});
+	return registerResponseSchema.parse(json).device;
+}
+/** Short-lived token the machine presents when dialing the portal WebSocket. */
+async function mintPortalDeviceToken(auth) {
+	const json = await portalFetch(auth, "/api/v1/portal/device-token", { method: "POST" });
+	return deviceTokenSchema.parse(json).token;
+}
+async function grantPortalAccess(auth, { deviceId, agentId }) {
+	await portalFetch(auth, `/api/v1/portal/devices/${encodeURIComponent(deviceId)}/grants`, {
+		method: "POST",
+		body: JSON.stringify({ agentId })
+	});
+}
+async function revokePortalAccess(auth, { deviceId, agentId }) {
+	await portalFetch(auth, `/api/v1/portal/devices/${encodeURIComponent(deviceId)}/grants/${encodeURIComponent(agentId)}`, { method: "DELETE" });
+}
+/**
+* The device row for a given machine identity. Matching is by `machineName`
+* equality — the stable per-surface handle (`<host>-cli` vs the desktop's
+* `<host>`), not the display label.
+*/
+function findThisDevice(devices, machineName) {
+	return devices.find((device) => device.machineName === machineName) ?? null;
+}
+
 //#endregion
 //#region src/chat/portal/client.ts
 const INITIAL_BACKOFF_MS = 500;
@@ -309,7 +449,7 @@ var PortalClient = class {
 			});
 			this.ws = ws;
 			const jobs = new JobManager({
-				cwd: this.opts.cwd,
+				resolveCwd: this.opts.resolveCwd,
 				send: (frame) => {
 					if (ws.readyState === WebSocket.OPEN) ws.send(frame);
 				}
@@ -363,4 +503,4 @@ function sleep(ms) {
 }
 
 //#endregion
-export { PortalClient as t };
+export { registerPortalDevice as a, grantPortalAccess as i, fetchPortalDevices as n, revokePortalAccess as o, findThisDevice as r, machineIdentity as s, PortalClient as t };

package/dist/js/client-DuwxEDG4.mjs

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

package/dist/js/daemon-Ch_MSDmQ.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import "./rest-BlN_uWmL.mjs";
+import "./client-Dc7GZ3PG.mjs";
+import { a as runPortalDaemon, i as queryDaemonStatus, n as ensureDaemonRunning, o as stopDaemon, r as isDaemonListening, t as PortalDaemon } from "./daemon-Co4CtpXZ.mjs";
+
+export { runPortalDaemon };