@treeport/treeport 0.6.1 → 0.8.3

package/dist/{shell-integration-Be_c91lw.js → shell-integration-CPmrVa3B.js}

@@ -11,19 +11,18 @@ const ZSH_DELEGATE = (file) => `if [[ -r "$TREEPORT_USER_ZDOTDIR/${file}" ]]; th
 fi
 `;
 const ZSH_INTEGRATION = `${ZSH_DELEGATE(".zshrc")}
-if [[ -n "$TMUX_PANE" && -n "$TREEPORT_TMUX_EXECUTABLE" ]]; then
-  _treeport_tmux_executable=$TREEPORT_TMUX_EXECUTABLE
-  unset TREEPORT_TMUX_EXECUTABLE
+if [[ -n "$TREEPORT_SHELL_INTEGRATION" ]]; then
+  unset TREEPORT_SHELL_INTEGRATION
   autoload -Uz add-zsh-hook 2>/dev/null
   _treeport_command_title_preexec() {
     emulate -L zsh
     local title=\${1//[[:cntrl:]]/}
     title=\${title[1,256]}
-    "$_treeport_tmux_executable" set-option -p -t "$TMUX_PANE" -- @treeport-command "$title" >/dev/null 2>&1
+    printf '\\033]777;command;%s\\033\\\\' "$title"
   }
   _treeport_command_title_precmd() {
     emulate -L zsh
-    "$_treeport_tmux_executable" set-option -p -u -t "$TMUX_PANE" @treeport-command >/dev/null 2>&1
+    printf '\\033]777;command;\\033\\\\'
   }
   add-zsh-hook -d preexec _treeport_command_title_preexec 2>/dev/null
   add-zsh-hook -d precmd _treeport_command_title_precmd 2>/dev/null
@@ -36,21 +35,8 @@ unset TREEPORT_USER_ZDOTDIR
 `;
 const BASH_INTEGRATION = `[[ $- == *i* ]] || return
 
-_treeport_bash_injected_prompt='source "\${TREEPORT_BASH_INTEGRATION_FILE}"'
-_treeport_bash_remaining_prompt=\${PROMPT_COMMAND//"$_treeport_bash_injected_prompt"/}
-_treeport_bash_remaining_prompt=\${_treeport_bash_remaining_prompt#;}
-_treeport_bash_remaining_prompt=\${_treeport_bash_remaining_prompt%;}
-if [[ -n "\${TREEPORT_BASH_PROMPT_COMMAND_SET-}" ]]; then
-  PROMPT_COMMAND=$TREEPORT_BASH_PROMPT_COMMAND
-  [[ -n "$_treeport_bash_remaining_prompt" ]] && PROMPT_COMMAND="\${PROMPT_COMMAND:+$PROMPT_COMMAND;}$_treeport_bash_remaining_prompt"
-else
-  PROMPT_COMMAND=$_treeport_bash_remaining_prompt
-fi
-unset TREEPORT_BASH_INTEGRATION_FILE TREEPORT_BASH_PROMPT_COMMAND TREEPORT_BASH_PROMPT_COMMAND_SET
-unset _treeport_bash_injected_prompt _treeport_bash_remaining_prompt
+unset TREEPORT_SHELL_INTEGRATION
 
-_treeport_tmux_executable=$TREEPORT_TMUX_EXECUTABLE
-unset TREEPORT_TMUX_EXECUTABLE
 _treeport_command_title_preexec() {
   local fallback=\${1-} line title
   line=$(HISTTIMEFORMAT= builtin history 1)
@@ -60,13 +46,10 @@ _treeport_command_title_preexec() {
   [[ -n "$title" ]] || title=$fallback
   title=$(LC_ALL=C printf '%s' "$title" | tr -d '\\000-\\037\\177')
   title="\${title:0:256}"
-  [[ -n "$TMUX_PANE" && -n "$_treeport_tmux_executable" ]] || return
-  "$_treeport_tmux_executable" set-option -p -t "$TMUX_PANE" -- @treeport-command "$title" >/dev/null 2>&1
+  printf '\\033]777;command;%s\\033\\\\' "$title"
 }
 _treeport_command_title_prompt() {
-  if [[ -n "$TMUX_PANE" && -n "$_treeport_tmux_executable" ]]; then
-    "$_treeport_tmux_executable" set-option -p -u -t "$TMUX_PANE" @treeport-command >/dev/null 2>&1
-  fi
+  printf '\\033]777;command;\\033\\\\'
   [[ -n "\${_treeport_uses_debug_trap-}" ]] && _treeport_command_ready=1
 }
 
@@ -94,6 +77,26 @@ if [[ -n "\${_treeport_uses_debug_trap-}" ]]; then
   _treeport_command_ready=1
 fi
 `;
+const BASH_PROFILE_DELEGATE = `_treeport_integration_home=$HOME
+HOME=$TREEPORT_USER_HOME
+unset TREEPORT_USER_HOME
+if [[ -r "$HOME/.bash_profile" ]]; then
+  source "$HOME/.bash_profile"
+elif [[ -r "$HOME/.bash_login" ]]; then
+  source "$HOME/.bash_login"
+elif [[ -r "$HOME/.profile" ]]; then
+  source "$HOME/.profile"
+fi
+source "$_treeport_integration_home/../treeport.bash"
+unset _treeport_integration_home
+`;
+const BASH_RC_DELEGATE = `_treeport_integration_home=$HOME
+HOME=$TREEPORT_USER_HOME
+unset TREEPORT_USER_HOME
+[[ -r "$HOME/.bashrc" ]] && source "$HOME/.bashrc"
+source "$_treeport_integration_home/../treeport.bash"
+unset _treeport_integration_home
+`;
 const FISH_INTEGRATION = `if set -q TREEPORT_FISH_XDG_DATA_DIR
   if set -q TREEPORT_FISH_XDG_DATA_DIRS_SET
     set -l treeport_xdg_dirs
@@ -108,32 +111,28 @@ const FISH_INTEGRATION = `if set -q TREEPORT_FISH_XDG_DATA_DIR
   end
   set -e TREEPORT_FISH_XDG_DATA_DIR TREEPORT_FISH_XDG_DATA_DIRS_SET
 end
-set -g _treeport_tmux_executable "$TREEPORT_TMUX_EXECUTABLE"
-set -e TREEPORT_TMUX_EXECUTABLE
+set -e TREEPORT_SHELL_INTEGRATION
 
 function _treeport_command_title_preexec --on-event fish_preexec
   set -l title (string replace -ar '[[:cntrl:]]' '' -- "$argv[1]" | string sub -l 256)
-  if test -n "$TMUX_PANE"; and test -n "$_treeport_tmux_executable"
-    command "$_treeport_tmux_executable" set-option -p -t "$TMUX_PANE" -- @treeport-command "$title" >/dev/null 2>&1
-  end
+  printf '\\e]777;command;%s\\e\\\\' "$title"
 end
 
 function _treeport_command_title_prompt --on-event fish_prompt
-  if test -n "$TMUX_PANE"; and test -n "$_treeport_tmux_executable"
-    command "$_treeport_tmux_executable" set-option -p -u -t "$TMUX_PANE" @treeport-command >/dev/null 2>&1
-  end
+  printf '\\e]777;command;\\e\\\\'
 end
 `;
 async function prepareShellIntegration(root) {
 	const zshDir = path.join(root, "zsh");
 	const bashDir = path.join(root, "bash");
+	const bashHome = path.join(bashDir, "home");
 	const fishDir = path.join(root, "fish", "fish", "vendor_conf.d");
 	await Promise.all([
 		fs.mkdir(zshDir, {
 			recursive: true,
 			mode: 448
 		}),
-		fs.mkdir(bashDir, {
+		fs.mkdir(bashHome, {
 			recursive: true,
 			mode: 448
 		}),
@@ -151,12 +150,14 @@ async function prepareShellIntegration(root) {
 		].map((file) => fs.writeFile(path.join(zshDir, file), ZSH_DELEGATE(file), { mode: 384 })),
 		fs.writeFile(path.join(zshDir, ".zshrc"), ZSH_INTEGRATION, { mode: 384 }),
 		fs.writeFile(path.join(bashDir, "treeport.bash"), BASH_INTEGRATION, { mode: 384 }),
+		fs.writeFile(path.join(bashHome, ".bash_profile"), BASH_PROFILE_DELEGATE, { mode: 384 }),
+		fs.writeFile(path.join(bashHome, ".bashrc"), BASH_RC_DELEGATE, { mode: 384 }),
 		fs.writeFile(path.join(fishDir, "treeport.fish"), FISH_INTEGRATION, { mode: 384 })
 	]);
 }
-function integrateShellLaunch(argv, env, root, tmuxExecutable) {
+function integrateShellLaunch(argv, env, root, enabled) {
 	const shell = path.basename(argv[0] ?? "").replace(/^-/, "");
-	if (!root || !tmuxExecutable || ![
+	if (!root || !enabled || ![
 		"zsh",
 		"bash",
 		"fish"
@@ -188,7 +189,7 @@ function integrateShellLaunch(argv, env, root, tmuxExecutable) {
 	}
 	const integratedEnv = {
 		...env,
-		TREEPORT_TMUX_EXECUTABLE: tmuxExecutable
+		TREEPORT_SHELL_INTEGRATION: "1"
 	};
 	if (shell === "zsh") {
 		const integrationZdotDir = path.join(root, "zsh");
@@ -239,19 +240,18 @@ function integrateShellLaunch(argv, env, root, tmuxExecutable) {
 			env
 		};
 	}
-	const integrationFile = path.join(root, "bash", "treeport.bash");
-	const bashEnvironment = {
-		...integratedEnv,
-		TREEPORT_BASH_INTEGRATION_FILE: integrationFile,
-		PROMPT_COMMAND: "source \"${TREEPORT_BASH_INTEGRATION_FILE}\""
+	const userHome = env.HOME?.trim();
+	if (!userHome) return {
+		argv,
+		env
 	};
-	if (env.PROMPT_COMMAND !== void 0) {
-		bashEnvironment.TREEPORT_BASH_PROMPT_COMMAND_SET = "1";
-		bashEnvironment.TREEPORT_BASH_PROMPT_COMMAND = env.PROMPT_COMMAND;
-	}
 	return {
 		argv,
-		env: bashEnvironment
+		env: {
+			...integratedEnv,
+			HOME: path.join(root, "bash", "home"),
+			TREEPORT_USER_HOME: userHome
+		}
 	};
 }
 //#endregion

package/dist/terminal-host-protocol-DZkQRAUF.js

@@ -0,0 +1,378 @@
+import path from "node:path";
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+import fsSync from "node:fs";
+import { z } from "zod";
+import * as Exit from "effect/Exit";
+import * as Cause from "effect/Cause";
+import * as Option from "effect/Option";
+import * as Tracer from "effect/Tracer";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+import { NodeSdk } from "@effect/opentelemetry";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+//#region src/server/tracing.ts
+const SAFE_ATTRIBUTE_NAMES = /* @__PURE__ */ new Set([
+	"http.request.method",
+	"http.response.status_code",
+	"network.protocol",
+	"url.path",
+	"treeport.channel",
+	"treeport.client.id",
+	"treeport.connection.id",
+	"treeport.mutation.coordinator",
+	"treeport.mutation.queue_wait_ms",
+	"treeport.mutation.queued_ahead",
+	"treeport.panel.id",
+	"treeport.request.id",
+	"treeport.terminal.id",
+	"treeport.terminal.launch_kind",
+	"treeport.terminal.pending_output_bytes",
+	"treeport.terminal.snapshot_bytes",
+	"treeport.terminal_host.method",
+	"treeport.terminal_host.queue_wait_ms",
+	"treeport.worktree.id"
+]);
+function tracingDestination(environment = process.env) {
+	if (environment.TREEPORT_TRACE !== "jsonl") return null;
+	const configuredPath = environment.TREEPORT_TRACE_FILE?.trim();
+	if (configuredPath && !path.isAbsolute(configuredPath)) throw new Error("TREEPORT_TRACE_FILE must be an absolute path");
+	return { filePath: configuredPath || null };
+}
+function safeAttributes(attributes) {
+	const result = {};
+	for (const [name, value] of Object.entries(attributes)) {
+		if (!SAFE_ATTRIBUTE_NAMES.has(name)) continue;
+		if (typeof value === "string") result[name] = value.slice(0, 512);
+		else if (typeof value === "number" || typeof value === "boolean") result[name] = value;
+	}
+	return result;
+}
+function hrTimeMilliseconds(value) {
+	return value[0] * 1e3 + value[1] / 1e6;
+}
+var JsonLinesSpanExporter = class {
+	serviceName;
+	descriptor;
+	closed = false;
+	constructor(serviceName, destination) {
+		this.serviceName = serviceName;
+		if (destination.filePath) {
+			fsSync.mkdirSync(path.dirname(destination.filePath), {
+				recursive: true,
+				mode: 448
+			});
+			this.descriptor = fsSync.openSync(destination.filePath, "a", 384);
+			fsSync.chmodSync(destination.filePath, 384);
+		} else this.descriptor = null;
+	}
+	export(spans, resultCallback) {
+		if (this.closed) {
+			resultCallback({ code: 1 });
+			return;
+		}
+		try {
+			for (const span of spans) {
+				const context = span.spanContext();
+				const record = {
+					type: "treeport.trace.span",
+					timestamp: new Date(hrTimeMilliseconds(span.startTime)).toISOString(),
+					service: this.serviceName,
+					traceId: context.traceId,
+					spanId: context.spanId,
+					parentSpanId: span.parentSpanContext?.spanId ?? null,
+					name: span.name,
+					kind: span.kind,
+					durationMs: Number(hrTimeMilliseconds(span.duration).toFixed(3)),
+					status: span.status.code,
+					attributes: safeAttributes(span.attributes)
+				};
+				const line = `${JSON.stringify(record)}\n`;
+				if (this.descriptor === null) process.stderr.write(line);
+				else fsSync.writeSync(this.descriptor, line);
+			}
+			resultCallback({ code: 0 });
+		} catch (error) {
+			resultCallback({
+				code: 1,
+				error: error instanceof Error ? error : new Error(String(error))
+			});
+		}
+	}
+	async forceFlush() {
+		if (this.descriptor !== null && !this.closed) fsSync.fsyncSync(this.descriptor);
+	}
+	async shutdown() {
+		if (this.closed) return;
+		await this.forceFlush();
+		this.closed = true;
+		if (this.descriptor !== null) fsSync.closeSync(this.descriptor);
+	}
+};
+function makeTracingLayer(options) {
+	if (!options.destination) return Layer.empty;
+	const exporter = new JsonLinesSpanExporter(options.serviceName, options.destination);
+	return NodeSdk.layer(() => ({
+		resource: {
+			serviceName: options.serviceName,
+			serviceVersion: options.serviceVersion
+		},
+		spanProcessor: new BatchSpanProcessor(exporter, {
+			maxQueueSize: 2048,
+			maxExportBatchSize: 256,
+			scheduledDelayMillis: 250
+		}),
+		shutdownTimeout: "5 seconds"
+	}));
+}
+function tracingLayerFromEnvironment(serviceName, serviceVersion, environment = process.env) {
+	return makeTracingLayer({
+		serviceName,
+		serviceVersion,
+		destination: tracingDestination(environment)
+	});
+}
+function tracingEnabled(environment = process.env) {
+	return tracingDestination(environment) !== null;
+}
+const currentTraceContext = tracingEnabled() ? Effect.option(Effect.currentSpan).pipe(Effect.map(Option.match({
+	onNone: () => null,
+	onSome: (span) => ({
+		traceId: span.traceId,
+		spanId: span.spanId,
+		sampled: span.sampled
+	})
+}))) : Effect.succeed(null);
+function makeHostTraceRuntime(serviceVersion) {
+	if (!tracingEnabled()) return null;
+	const runtime = ManagedRuntime.make(tracingLayerFromEnvironment("treeport-terminal-host", serviceVersion));
+	return {
+		async run(name, parent, attributes, evaluate) {
+			const exit = await runtime.runPromiseExit(Effect.tryPromise({
+				try: evaluate,
+				catch: (cause) => cause
+			}).pipe(Effect.withSpan(name, {
+				parent: Tracer.externalSpan({
+					traceId: parent.traceId,
+					spanId: parent.spanId,
+					sampled: parent.sampled
+				}),
+				attributes
+			})));
+			if (Exit.isSuccess(exit)) return exit.value;
+			const failure = Cause.failureOption(exit.cause);
+			if (Option.isSome(failure)) throw failure.value;
+			throw Cause.squash(exit.cause);
+		},
+		dispose() {
+			return runtime.dispose();
+		}
+	};
+}
+//#endregion
+//#region src/server/terminal-host-protocol.ts
+const TERMINAL_HOST_MAX_FRAME_BYTES = 64 * 1024 * 1024;
+const terminalHostRecordSchema = z.object({
+	protocolVersion: z.number().int().positive(),
+	hostId: z.string().min(1),
+	hostKey: z.string().min(1),
+	pid: z.number().int().positive(),
+	socketPath: z.string().min(1),
+	startedAt: z.string().min(1)
+}).strict();
+const terminalSizeSchema = z.object({
+	cols: z.number().int().positive(),
+	rows: z.number().int().positive()
+}).strict();
+const terminalIdSchema = z.object({ terminalId: z.string().min(1) }).strict();
+const worktreeIdSchema = z.object({ worktreeId: z.string().min(1) }).strict();
+const setupTaskSchema = z.object({
+	label: z.string(),
+	argv: z.array(z.string()),
+	cwd: z.string(),
+	env: z.record(z.string(), z.string()),
+	timeoutMs: z.number().positive()
+}).strict();
+const createSchema = z.object({
+	terminalId: z.string().min(1),
+	worktreeId: z.string().min(1),
+	name: z.string(),
+	createdAt: z.string(),
+	cwd: z.string(),
+	argv: z.array(z.string()),
+	initialTitle: z.string().optional(),
+	shellCommand: z.string().nullable(),
+	interactiveShell: z.boolean(),
+	fallbackArgv: z.array(z.string()).optional(),
+	closeOnSuccess: z.boolean().optional(),
+	initialSize: terminalSizeSchema.optional(),
+	env: z.record(z.string(), z.string()),
+	setupTasks: z.array(setupTaskSchema).optional(),
+	setupError: z.string().optional()
+}).strict();
+const terminalHostInputSchemas = {
+	handshake: z.object({
+		token: z.string(),
+		hostKey: z.string(),
+		protocolVersion: z.number().int()
+	}).strict(),
+	create: createSchema,
+	inventory: worktreeIdSchema,
+	state: terminalIdSchema,
+	attach: terminalIdSchema,
+	unsubscribeOutput: terminalIdSchema,
+	subscribeRuntime: terminalIdSchema,
+	unsubscribeRuntime: terminalIdSchema,
+	runtimeState: terminalIdSchema,
+	write: z.object({
+		terminalId: z.string(),
+		data: z.string(),
+		encoding: z.enum(["utf8", "base64"]),
+		authority: z.object({
+			attachmentId: z.string(),
+			generation: z.number().int().positive()
+		}).strict()
+	}).strict(),
+	prepareQueryAuthority: terminalIdSchema,
+	activateQueryAuthority: terminalIdSchema.extend({
+		transitionId: z.string(),
+		attachmentId: z.string(),
+		generation: z.number().int().positive()
+	}).strict(),
+	hostQueryAuthority: terminalIdSchema,
+	resize: terminalIdSchema.extend({
+		cols: z.number().int().positive(),
+		rows: z.number().int().positive()
+	}).strict(),
+	capture: terminalIdSchema.extend({ lines: z.number().int().positive() }).strict(),
+	rename: terminalIdSchema.extend({
+		name: z.string(),
+		updatedAt: z.string()
+	}).strict(),
+	processes: worktreeIdSchema,
+	titleState: terminalIdSchema,
+	signal: terminalIdSchema.extend({ signal: z.enum([
+		"SIGINT",
+		"SIGTERM",
+		"SIGKILL",
+		"SIGHUP"
+	]) }).strict(),
+	kill: terminalIdSchema,
+	killWorktree: worktreeIdSchema,
+	shutdown: z.object({ ifEmpty: z.literal(true) }).strict()
+};
+const TERMINAL_HOST_REQUEST_METHODS = [
+	"handshake",
+	"create",
+	"inventory",
+	"state",
+	"attach",
+	"unsubscribeOutput",
+	"subscribeRuntime",
+	"unsubscribeRuntime",
+	"runtimeState",
+	"write",
+	"prepareQueryAuthority",
+	"activateQueryAuthority",
+	"hostQueryAuthority",
+	"resize",
+	"capture",
+	"rename",
+	"processes",
+	"titleState",
+	"signal",
+	"kill",
+	"killWorktree",
+	"shutdown"
+];
+const runtimeEventSchema = z.object({
+	title: z.string().optional(),
+	progress: z.strictObject({
+		state: z.enum([
+			"normal",
+			"error",
+			"indeterminate",
+			"paused"
+		]),
+		value: z.number().int().min(0).max(100).nullable()
+	}).nullable().optional(),
+	bell: z.object({
+		sequence: z.number().int().positive(),
+		at: z.string().datetime()
+	}).strict().optional(),
+	exitCode: z.number().int().nullable().optional(),
+	titleState: z.object({
+		terminalTitle: z.string().nullable(),
+		currentCommand: z.string().nullable(),
+		commandLine: z.string().nullable()
+	}).strict().optional()
+}).strict();
+const terminalHostFrameSchema = z.union([
+	z.object({
+		protocolVersion: z.number().int(),
+		type: z.literal("request"),
+		id: z.string(),
+		method: z.enum(TERMINAL_HOST_REQUEST_METHODS),
+		input: z.record(z.string(), z.unknown()),
+		trace: z.object({
+			traceId: z.string().regex(/^[0-9a-f]{32}$/),
+			spanId: z.string().regex(/^[0-9a-f]{16}$/),
+			sampled: z.boolean()
+		}).strict().optional()
+	}).strict(),
+	z.object({
+		protocolVersion: z.number().int(),
+		type: z.literal("response"),
+		id: z.string(),
+		result: z.any().optional(),
+		error: z.object({
+			code: z.string(),
+			message: z.string(),
+			hostProtocolVersion: z.number().int().optional(),
+			liveSessionCount: z.number().int().nonnegative().optional()
+		}).strict().nullable()
+	}).strict(),
+	z.object({
+		protocolVersion: z.number().int(),
+		type: z.literal("event"),
+		event: z.literal("output"),
+		data: z.object({
+			terminalId: z.string(),
+			output: z.string(),
+			sequence: z.number().int().positive()
+		}).strict()
+	}).strict(),
+	z.object({
+		protocolVersion: z.number().int(),
+		type: z.literal("event"),
+		event: z.literal("runtime"),
+		data: z.object({
+			terminalId: z.string(),
+			value: runtimeEventSchema
+		}).strict()
+	}).strict()
+]);
+function encodeTerminalHostFrame(frame) {
+	const payload = Buffer.from(JSON.stringify(frame), "utf8");
+	if (payload.byteLength > TERMINAL_HOST_MAX_FRAME_BYTES) throw new Error("Terminal host frame exceeds the byte limit");
+	const header = Buffer.allocUnsafe(4);
+	header.writeUInt32BE(payload.byteLength);
+	return Buffer.concat([header, payload]);
+}
+var TerminalHostFrameDecoder = class {
+	buffer = Buffer.alloc(0);
+	push(chunk) {
+		this.buffer = this.buffer.byteLength ? Buffer.concat([this.buffer, chunk]) : chunk;
+		const frames = [];
+		while (this.buffer.byteLength >= 4) {
+			const length = this.buffer.readUInt32BE(0);
+			if (length <= 0 || length > TERMINAL_HOST_MAX_FRAME_BYTES) throw new Error("Invalid terminal host frame length");
+			if (this.buffer.byteLength < length + 4) break;
+			const payload = this.buffer.subarray(4, length + 4);
+			this.buffer = this.buffer.subarray(length + 4);
+			frames.push(terminalHostFrameSchema.parse(JSON.parse(payload.toString("utf8"))));
+		}
+		return frames;
+	}
+};
+//#endregion
+export { currentTraceContext as a, terminalHostRecordSchema as i, encodeTerminalHostFrame as n, makeHostTraceRuntime as o, terminalHostInputSchemas as r, tracingLayerFromEnvironment as s, TerminalHostFrameDecoder as t };