@treeport/treeport 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Noice Tech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,12 @@
+# Treeport
+
+Treeport is a worktree-first terminal driver for persistent development workspaces.
+
+```sh
+npm install --global @treeport/treeport
+treeport up
+```
+
+Treeport supports macOS and Linux and requires Node.js 24 or newer, Git, and tmux 3.2 or newer.
+
+Documentation: <https://treeport.app>

package/bin/treeport.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/node/cli/index.js'

package/dist/dist-CUkImh2W.js

@@ -0,0 +1,254 @@
+import { z } from "zod";
+//#region ../../packages/shared/dist/terminal-protocol.js
+const SOCKET_IO_PATH = "/api/socket.io/";
+const TERMINAL_CONTROLLER_GRACE_MS = 1e4;
+const TERMINAL_OUTPUT_HIGH_WATERMARK = 256 * 1024;
+const TERMINAL_OUTPUT_LOW_WATERMARK = 64 * 1024;
+const TERMINAL_OUTPUT_STALL_TIMEOUT_MS = 3e4;
+const TERMINAL_MAX_CLIENT_MESSAGE_BYTES = 128 * 1024;
+const TERMINAL_MAX_INPUT_BYTES = 64 * 1024;
+const terminalId = z.string().min(1).max(128);
+const clientId = z.string().min(1).max(128);
+const streamId = z.string().min(1).max(128);
+const generation = z.number().int().nonnegative();
+const dimensions = {
+	cols: z.number().int().min(2).max(1e3),
+	rows: z.number().int().min(2).max(500)
+};
+const terminalSizeSchema = z.strictObject(dimensions);
+const terminalProgressSchema = z.strictObject({
+	state: z.enum([
+		"normal",
+		"error",
+		"indeterminate",
+		"paused"
+	]),
+	value: z.number().int().min(0).max(100).nullable()
+});
+const terminalRuntimeMetadataSchema = z.strictObject({
+	terminalId: z.string().min(1),
+	title: z.string().max(256).nullable(),
+	hasForegroundProcess: z.boolean().nullable().optional(),
+	progress: terminalProgressSchema.nullable(),
+	progressStartedAt: z.string().datetime().nullable().default(null),
+	progressClearedAt: z.string().datetime().nullable().default(null),
+	bell: z.strictObject({
+		sequence: z.number().int().positive(),
+		at: z.string().datetime(),
+		unread: z.boolean()
+	}).nullable().default(null)
+});
+const terminalBellAcknowledgementSchema = z.strictObject({ sequence: z.number().int().positive() });
+function parseTerminalRuntimeMetadata(value) {
+	const parsed = terminalRuntimeMetadataSchema.safeParse(value);
+	return parsed.success ? parsed.data : null;
+}
+function parseTerminalProgress(data) {
+	const [command, rawState, rawValue, ...extra] = data.split(";");
+	if (command !== "4" || extra.length > 0 || !/^[0-4]$/.test(rawState ?? "")) return;
+	const state = Number(rawState);
+	if (state === 0) return null;
+	if (rawValue !== void 0 && rawValue !== "" && !/^\d{1,3}$/.test(rawValue)) return;
+	const value = rawValue === void 0 || rawValue === "" ? null : Number(rawValue);
+	if (value !== null && value > 100) return;
+	return {
+		state: [
+			void 0,
+			"normal",
+			"error",
+			"indeterminate",
+			"paused"
+		][state],
+		value
+	};
+}
+const terminalAuthSchema = z.strictObject({
+	terminalId,
+	clientId,
+	...dimensions
+});
+const terminalInputSchema = z.strictObject({
+	generation,
+	data: z.string().max(TERMINAL_MAX_INPUT_BYTES)
+});
+const terminalBinarySchema = z.strictObject({
+	generation,
+	data: z.string().max(TERMINAL_MAX_INPUT_BYTES)
+});
+const terminalResizeSchema = z.strictObject({
+	generation,
+	...dimensions
+});
+const terminalTakeControlSchema = z.strictObject({
+	generation,
+	...dimensions
+});
+const terminalLegacyTakeControlSchema = z.strictObject({ generation });
+const terminalOutputAckSchema = z.strictObject({
+	streamId,
+	sequence: z.number().int().nonnegative()
+});
+const terminalReadyBase = {
+	connectionId: z.string().min(1).max(128),
+	streamId,
+	generation,
+	controller: z.boolean(),
+	reset: z.literal("full")
+};
+const terminalLegacyReadySchema = z.strictObject(terminalReadyBase);
+const terminalReadyV2Schema = z.strictObject({
+	...terminalReadyBase,
+	...dimensions,
+	revision: z.number().int().positive()
+});
+z.union([terminalLegacyReadySchema, terminalReadyV2Schema]);
+z.strictObject({
+	...dimensions,
+	revision: z.number().int().positive()
+});
+z.strictObject({
+	streamId,
+	sequence: z.number().int().positive(),
+	data: z.string()
+});
+z.strictObject({ title: z.string().max(256) });
+z.strictObject({ progress: terminalProgressSchema.nullable() });
+z.strictObject({
+	generation,
+	controller: z.boolean()
+});
+z.strictObject({ exitCode: z.number().int().nullable() });
+z.strictObject({
+	code: z.string().min(1).max(80),
+	message: z.string().min(1).max(1e3),
+	retryable: z.boolean()
+});
+function parseTerminalAuth(value) {
+	const parsed = terminalAuthSchema.safeParse(value);
+	return parsed.success ? parsed.data : null;
+}
+//#endregion
+//#region ../../packages/shared/dist/socket-protocol.js
+const productEventTypeSchema = z.enum([
+	"project.created",
+	"project.updated",
+	"project.removed",
+	"worktree.created",
+	"worktree.updated",
+	"worktree.removed",
+	"terminal.created",
+	"terminal.updated",
+	"terminal.removed",
+	"terminal.metadata",
+	"terminal.controller_changed",
+	"remove.started",
+	"remove.completed",
+	"remove.failed"
+]);
+const productEventSchema = z.strictObject({
+	id: z.string().min(1).max(128),
+	type: productEventTypeSchema,
+	at: z.string().datetime(),
+	data: z.record(z.string(), z.unknown())
+});
+const eventsSnapshotSchema = z.strictObject({
+	at: z.string().datetime(),
+	terminalMetadata: z.array(terminalRuntimeMetadataSchema)
+});
+function parseEventsSnapshot(value) {
+	const parsed = eventsSnapshotSchema.safeParse(value);
+	return parsed.success ? parsed.data : null;
+}
+function parseProductEvent(value) {
+	const parsed = productEventSchema.safeParse(value);
+	return parsed.success ? parsed.data : null;
+}
+//#endregion
+//#region ../../packages/shared/dist/index.js
+const TERMINAL_MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
+const TERMINAL_EXECUTABLE_MAX_LENGTH = 4096;
+const TERMINAL_ARGUMENT_MAX_LENGTH = 4096;
+const TERMINAL_CAPTURE_MAX_LINES = 5e3;
+const PROJECT_COLORS = [
+	"rose",
+	"orange",
+	"amber",
+	"emerald",
+	"cyan",
+	"blue",
+	"violet",
+	"pink"
+];
+const browseDirectoryQuerySchema = z.object({
+	input: z.string().trim().min(1).max(4096),
+	hidden: z.enum(["true", "false"]).optional().default("false").transform((value) => value === "true")
+});
+const terminalCaptureQuerySchema = z.object({ lines: z.coerce.number().int().min(1).max(TERMINAL_CAPTURE_MAX_LINES).optional().default(200) });
+const registerProjectSchema = z.object({
+	path: z.string().trim().min(1),
+	name: z.string().trim().min(1).max(120).optional()
+});
+const updateProjectSchema = z.object({ color: z.enum(PROJECT_COLORS).nullable() });
+const terminalNameSchema = z.string().trim().min(1).max(120);
+const terminalArgvSchema = z.array(z.string()).min(1).max(128);
+const terminalPresetArgumentSchema = z.string().max(TERMINAL_ARGUMENT_MAX_LENGTH);
+const terminalPresetFields = {
+	name: terminalNameSchema,
+	executable: z.string().min(1).max(TERMINAL_EXECUTABLE_MAX_LENGTH).refine((value) => value.trim().length > 0, { message: "Executable cannot be blank" }),
+	args: z.array(terminalPresetArgumentSchema).max(127),
+	closeOnSuccess: z.boolean().default(false)
+};
+const terminalPresetRevisionSchema = z.string().min(1).max(64);
+const initialTerminalSchema = z.object({
+	name: terminalNameSchema,
+	argv: terminalArgvSchema.optional(),
+	returnToShell: z.boolean().optional(),
+	initialSize: terminalSizeSchema.optional()
+});
+const createWorktreeSchema = z.object({
+	name: z.string().trim().min(1).max(120),
+	base: z.enum(["default", "current"]).default("default"),
+	sourceWorktreeId: z.string().min(1).optional(),
+	initialTerminal: initialTerminalSchema.optional()
+}).superRefine((value, context) => {
+	if (value.base === "current" && !value.sourceWorktreeId) context.addIssue({
+		code: "custom",
+		path: ["sourceWorktreeId"],
+		message: "A source worktree is required when starting from current"
+	});
+});
+const createTerminalSchema = z.object({
+	name: terminalNameSchema,
+	argv: terminalArgvSchema.optional(),
+	returnToShell: z.boolean().optional(),
+	closeOnSuccess: z.boolean().optional(),
+	initialSize: terminalSizeSchema.optional()
+}).refine((value) => !(value.returnToShell && value.closeOnSuccess), { message: "A terminal cannot return to a shell and close on success" });
+const updateTerminalSchema = z.object({ name: terminalNameSchema });
+const createTerminalPresetSchema = z.object(terminalPresetFields);
+const updateTerminalPresetSchema = z.object({
+	...terminalPresetFields,
+	closeOnSuccess: z.boolean().optional(),
+	expectedUpdatedAt: terminalPresetRevisionSchema
+});
+const deleteTerminalPresetSchema = z.object({ expectedUpdatedAt: terminalPresetRevisionSchema });
+const removeWorktreeSchema = z.object({
+	confirmationToken: z.string().length(64),
+	confirmDestructive: z.boolean()
+});
+const spawnSchema = z.object({
+	project: z.string().min(1),
+	worktreeName: z.string().trim().min(1).max(120),
+	name: terminalNameSchema,
+	argv: terminalArgvSchema.optional(),
+	base: z.enum(["default", "current"]).default("default"),
+	sourceWorktreeId: z.string().min(1).optional()
+}).superRefine((value, context) => {
+	if (value.base === "current" && !value.sourceWorktreeId) context.addIssue({
+		code: "custom",
+		path: ["sourceWorktreeId"],
+		message: "A source worktree is required when starting from current"
+	});
+});
+//#endregion
+export { terminalLegacyTakeControlSchema as A, TERMINAL_OUTPUT_STALL_TIMEOUT_MS as C, terminalBellAcknowledgementSchema as D, parseTerminalRuntimeMetadata as E, terminalResizeSchema as M, terminalSizeSchema as N, terminalBinarySchema as O, terminalTakeControlSchema as P, TERMINAL_OUTPUT_LOW_WATERMARK as S, parseTerminalProgress as T, SOCKET_IO_PATH as _, createTerminalSchema as a, TERMINAL_MAX_INPUT_BYTES as b, registerProjectSchema as c, terminalCaptureQuerySchema as d, updateProjectSchema as f, parseProductEvent as g, parseEventsSnapshot as h, createTerminalPresetSchema as i, terminalOutputAckSchema as j, terminalInputSchema as k, removeWorktreeSchema as l, updateTerminalSchema as m, TERMINAL_MAX_UPLOAD_BYTES as n, createWorktreeSchema as o, updateTerminalPresetSchema as p, browseDirectoryQuerySchema as r, deleteTerminalPresetSchema as s, TERMINAL_CAPTURE_MAX_LINES as t, spawnSchema as u, TERMINAL_CONTROLLER_GRACE_MS as v, parseTerminalAuth as w, TERMINAL_OUTPUT_HIGH_WATERMARK as x, TERMINAL_MAX_CLIENT_MESSAGE_BYTES as y };