@treeport/treeport 0.1.0 → 0.2.2

package/README.md

@@ -4,9 +4,12 @@ Treeport is a worktree-first terminal driver for persistent development workspac
 
 ```sh
 npm install --global @treeport/treeport
-treeport up
+cd /path/to/repository
+treeport .
 ```
 
+Treeport starts its backend if needed, registers the repository and its worktrees, and opens the current worktree in the desktop app or browser. Run `treeport up` to start only the backend.
+
 Treeport supports macOS and Linux and requires Node.js 24 or newer, Git, and tmux 3.2 or newer.
 
 Documentation: <https://treeport.app>

package/dist/loopback-4XVZbAD1.js

@@ -0,0 +1,407 @@
+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 TERMINAL_SCROLL_EXIT_SEQUENCE = "\x1B[9000~";
+const TERMINAL_SELECTION_START_SEQUENCE = "\x1B[9001~";
+const TERMINAL_SELECTION_STOP_SEQUENCE = "\x1B[9002~";
+const TERMINAL_SELECTION_CLEAR_SEQUENCE = "\x1B[9003~";
+const TERMINAL_SELECTION_RESTORE_SEQUENCE = "\x1B[9004~";
+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 terminalProgramSchema = z.enum([
+	"pi",
+	"claude",
+	"codex"
+]);
+const terminalRuntimeMetadataSchema = z.strictObject({
+	terminalId: z.string().min(1),
+	title: z.string().max(256).nullable(),
+	program: terminalProgramSchema.nullable().default(null),
+	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 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({ viewing: z.boolean() });
+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 identifierSchema = z.string().min(1).max(128);
+const eventEnvelope = (type, data) => z.strictObject({
+	id: identifierSchema,
+	type: z.literal(type),
+	at: z.string().datetime(),
+	data
+});
+const projectEventDataSchema = z.strictObject({
+	projectId: identifierSchema,
+	worktreeId: z.null()
+});
+const worktreeEventDataSchema = z.strictObject({ worktreeId: identifierSchema });
+const projectWorktreeEventDataSchema = z.strictObject({
+	projectId: identifierSchema,
+	worktreeId: identifierSchema
+});
+const operationEventDataSchema = z.strictObject({
+	operationId: identifierSchema,
+	worktreeId: identifierSchema
+});
+const productEventSchema = z.discriminatedUnion("type", [
+	eventEnvelope("project.created", projectEventDataSchema),
+	eventEnvelope("project.updated", projectEventDataSchema),
+	eventEnvelope("project.removed", projectEventDataSchema),
+	eventEnvelope("worktree.created", projectWorktreeEventDataSchema),
+	eventEnvelope("worktree.updated", worktreeEventDataSchema),
+	eventEnvelope("worktree.removed", projectWorktreeEventDataSchema),
+	eventEnvelope("create.started", z.strictObject({
+		projectId: identifierSchema,
+		operationId: identifierSchema,
+		worktreeId: z.null()
+	})),
+	eventEnvelope("create.completed", z.strictObject({
+		projectId: identifierSchema,
+		operationId: identifierSchema,
+		worktreeId: identifierSchema
+	})),
+	eventEnvelope("create.failed", z.strictObject({
+		projectId: identifierSchema,
+		operationId: identifierSchema,
+		worktreeId: z.null()
+	})),
+	eventEnvelope("terminal.created", z.strictObject({
+		projectId: identifierSchema.optional(),
+		worktreeId: identifierSchema,
+		terminalId: identifierSchema
+	})),
+	eventEnvelope("terminal.updated", z.strictObject({
+		worktreeId: identifierSchema,
+		terminalId: identifierSchema
+	})),
+	eventEnvelope("terminal.removed", z.strictObject({
+		worktreeId: identifierSchema,
+		terminalId: identifierSchema
+	})),
+	eventEnvelope("terminal.metadata", terminalRuntimeMetadataSchema.extend({ worktreeId: z.null() })),
+	eventEnvelope("terminal.controller_changed", z.strictObject({
+		terminalId: identifierSchema,
+		controlled: z.boolean(),
+		worktreeId: z.null()
+	})),
+	eventEnvelope("panel.created", z.strictObject({
+		worktreeId: identifierSchema,
+		panelId: identifierSchema
+	})),
+	eventEnvelope("panel.updated", z.strictObject({
+		worktreeId: identifierSchema,
+		panelId: identifierSchema
+	})),
+	eventEnvelope("panel.open_requested", z.strictObject({
+		worktreeId: identifierSchema,
+		panelId: identifierSchema,
+		sourceTerminalId: identifierSchema.nullable()
+	})),
+	eventEnvelope("panel.removed", z.strictObject({
+		worktreeId: identifierSchema,
+		panelId: identifierSchema
+	})),
+	eventEnvelope("remove.started", operationEventDataSchema.extend({ kind: z.literal("remove") })),
+	eventEnvelope("remove.completed", operationEventDataSchema),
+	eventEnvelope("remove.failed", operationEventDataSchema.extend({ error: z.string() }))
+]);
+const webPanelSnapshotSchema = z.strictObject({
+	id: z.string().min(1),
+	kind: z.literal("web"),
+	worktreeId: z.string().min(1),
+	definitionId: z.string().min(1),
+	title: z.string().min(1),
+	launch: z.strictObject({
+		input: z.record(z.string(), z.json()).nullable(),
+		cwd: z.string().nullable()
+	}),
+	sandbox: z.strictObject({ allowSameOrigin: z.boolean() }),
+	createdAt: z.string(),
+	updatedAt: z.string()
+});
+const eventsSnapshotSchema = z.strictObject({
+	at: z.string().datetime(),
+	terminalMetadata: z.array(terminalRuntimeMetadataSchema),
+	webPanels: z.array(webPanelSnapshotSchema)
+});
+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 WEB_PANEL_INPUT_MAX_BYTES = 64 * 1024;
+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 repositoryTerminalPresetSchema = z.strictObject(terminalPresetFields);
+const repositoryTerminalPresetIdSchema = z.string().regex(/^[a-z0-9][a-z0-9._-]{0,119}$/, { message: "Preset IDs must contain only lowercase letters, numbers, dots, underscores, and hyphens" });
+const repositoryTerminalPresetsFileSchema = z.strictObject({
+	version: z.literal(1),
+	presets: z.record(repositoryTerminalPresetIdSchema, z.unknown())
+});
+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 terminalCwdSchema = z.string().min(1).max(4096).refine((value) => value.trim().length > 0 && !value.includes("\0"), { message: "Working directory cannot be blank or contain NUL" });
+const terminalEnvironmentKeySchema = z.string().min(1).max(256).refine((value) => !value.includes("=") && !value.includes("\0"), { message: "Environment keys cannot contain equals or NUL" });
+const terminalEnvironmentSchema = z.record(terminalEnvironmentKeySchema, z.string().max(TERMINAL_ARGUMENT_MAX_LENGTH).refine((value) => !value.includes("\0"), { message: "Environment values cannot contain NUL" })).refine((value) => Object.keys(value).length <= 128, { message: "Environment cannot contain more than 128 variables" });
+const createTerminalSchema = z.object({
+	name: terminalNameSchema,
+	argv: terminalArgvSchema.optional(),
+	cwd: terminalCwdSchema.optional(),
+	env: terminalEnvironmentSchema.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 webPanelInputSchema = z.record(z.string(), z.json());
+const createWebPanelSchema = z.object({
+	definitionId: z.string().min(1).max(256),
+	input: webPanelInputSchema.nullable().optional(),
+	launchCwd: z.string().max(4096).nullable().optional()
+});
+const openWebPanelSchema = createWebPanelSchema.extend({
+	newInstance: z.boolean().optional(),
+	sourceTerminalId: z.string().min(1).max(128).nullable().optional()
+});
+const webPanelStorageKeySchema = z.string().min(1).max(128);
+const getWebPanelStorageSchema = z.object({ key: webPanelStorageKeySchema });
+const setWebPanelStorageSchema = z.object({
+	key: webPanelStorageKeySchema,
+	value: z.json()
+});
+const deleteWebPanelStorageSchema = z.object({ key: webPanelStorageKeySchema });
+const createTerminalPresetSchema = z.object(terminalPresetFields);
+const updateTerminalPresetSchema = z.object({
+	...terminalPresetFields,
+	closeOnSuccess: z.boolean().optional(),
+	expectedUpdatedAt: terminalPresetRevisionSchema
+});
+const deleteTerminalPresetSchema = z.object({ expectedUpdatedAt: terminalPresetRevisionSchema });
+const packageProjectQuerySchema = z.object({ path: z.string().trim().min(1).max(4096) });
+const packageInstallSchema = z.object({
+	source: z.string().trim().min(1).max(4096),
+	projectId: z.string().min(1).optional()
+});
+const packageRemoveSchema = z.object({
+	source: z.string().trim().min(1).max(4096),
+	projectId: z.string().min(1).optional()
+});
+const packageUpdateSchema = z.object({ source: z.string().trim().min(1).max(4096).optional() });
+const packageReloadSchema = z.object({ projectId: z.string().min(1).optional() });
+const removeWorktreeSchema = z.object({
+	confirmationToken: z.string().length(64),
+	confirmDestructive: z.boolean()
+});
+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
+//#region src/duration.ts
+const DURATION_UNITS = {
+	ms: 1,
+	s: 1e3,
+	m: 6e4,
+	h: 36e5
+};
+const MAX_DURATION_MS = 2147483647;
+function parseDurationMs(value) {
+	const match = /^(\d+)(ms|s|m|h)$/.exec(value);
+	if (!match) throw new Error("Timeout must be a positive duration such as 500ms, 30s, 5m, or 1h");
+	const timeoutMs = Number(match[1]) * DURATION_UNITS[match[2]];
+	if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_DURATION_MS) throw new Error("Timeout must be between 1ms and 2147483647ms");
+	return timeoutMs;
+}
+//#endregion
+//#region src/server/core/loopback.ts
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
+	"127.0.0.1",
+	"::1",
+	"localhost"
+]);
+function isLoopbackHost(host) {
+	return LOOPBACK_HOSTS.has(host.trim().toLowerCase());
+}
+function assertLoopbackHost(host) {
+	if (isLoopbackHost(host)) return;
+	throw new Error("Treeport supports only loopback listeners. Run `treeport up --host 127.0.0.1`, then use `treeport remote enable` for private remote access.");
+}
+//#endregion
+export { parseProductEvent as A, TERMINAL_SELECTION_RESTORE_SEQUENCE as B, repositoryTerminalPresetsFileSchema as C, updateTerminalPresetSchema as D, updateProjectSchema as E, TERMINAL_OUTPUT_HIGH_WATERMARK as F, terminalBellAcknowledgementSchema as G, TERMINAL_SELECTION_STOP_SEQUENCE as H, TERMINAL_OUTPUT_LOW_WATERMARK as I, terminalLegacyTakeControlSchema as J, terminalBinarySchema as K, TERMINAL_OUTPUT_STALL_TIMEOUT_MS as L, TERMINAL_CONTROLLER_GRACE_MS as M, TERMINAL_MAX_CLIENT_MESSAGE_BYTES as N, updateTerminalSchema as O, TERMINAL_MAX_INPUT_BYTES as P, terminalTakeControlSchema as Q, TERMINAL_SCROLL_EXIT_SEQUENCE as R, repositoryTerminalPresetSchema as S, terminalCaptureQuerySchema as T, parseTerminalAuth as U, TERMINAL_SELECTION_START_SEQUENCE as V, parseTerminalProgress as W, terminalResizeSchema as X, terminalOutputAckSchema as Y, terminalSizeSchema as Z, packageReloadSchema as _, WEB_PANEL_INPUT_MAX_BYTES as a, registerProjectSchema as b, createTerminalSchema as c, deleteTerminalPresetSchema as d, deleteWebPanelStorageSchema as f, packageProjectQuerySchema as g, packageInstallSchema as h, TERMINAL_MAX_UPLOAD_BYTES as i, SOCKET_IO_PATH as j, parseEventsSnapshot as k, createWebPanelSchema as l, openWebPanelSchema as m, parseDurationMs as n, browseDirectoryQuerySchema as o, getWebPanelStorageSchema as p, terminalInputSchema as q, TERMINAL_CAPTURE_MAX_LINES as r, createTerminalPresetSchema as s, assertLoopbackHost as t, createWorktreeSchema as u, packageRemoveSchema as v, setWebPanelStorageSchema as w, removeWorktreeSchema as x, packageUpdateSchema as y, TERMINAL_SELECTION_CLEAR_SEQUENCE as z };