t3code-cli 0.13.0 → 0.14.0

package/dist/rpc.js

@@ -1,2 +1,2 @@
-import { $ as T3RpcOperationsLive, Q as T3RpcOperations, et as makeT3RpcOperations, h as makeT3RpcLayer, m as T3RpcLive, nt as RpcError, tt as T3Rpc } from "./shared.js";
+import { Gi as T3RpcOperations, Gn as T3RpcLive, Ji as T3Rpc, Ki as T3RpcOperationsLive, Kn as makeT3RpcLayer, Yi as RpcError, qi as makeT3RpcOperations } from "./shared.js";
 export { RpcError, T3Rpc, T3RpcLive, T3RpcOperations, T3RpcOperationsLive, makeT3RpcLayer, makeT3RpcOperations };

package/dist/runtime.d.ts

@@ -0,0 +1,2 @@
+import { An as T3LocalAuthTokenLayer, Cn as BaseAppLayer, Dn as T3AuthTransportLayer, En as T3AuthPairingLayer, Mn as T3PreviewAutomationLayer, On as T3LocalAuthLayer, Sn as AuthAppLayer, Tn as T3AuthLayer, jn as T3OrchestrationLayer, kn as T3LocalAuthOriginLayer, wn as BaseAuthAppLayer, xn as AppLayer } from "./shared.js";
+export { AppLayer, AuthAppLayer, BaseAppLayer, BaseAuthAppLayer, T3AuthLayer, T3AuthPairingLayer, T3AuthTransportLayer, T3LocalAuthLayer, T3LocalAuthOriginLayer, T3LocalAuthTokenLayer, T3OrchestrationLayer, T3PreviewAutomationLayer };

package/dist/runtime.js

@@ -1,2 +1,2 @@
-import { a as BaseAppLayer, c as T3AuthPairingLayer, d as T3LocalAuthOriginLayer, f as T3LocalAuthTokenLayer, i as AuthAppLayer, l as T3AuthTransportLayer, o as BaseAuthAppLayer, p as T3OrchestrationLayer, r as AppLayer, s as T3AuthLayer, u as T3LocalAuthLayer } from "./shared.js";
-export { AppLayer, AuthAppLayer, BaseAppLayer, BaseAuthAppLayer, T3AuthLayer, T3AuthPairingLayer, T3AuthTransportLayer, T3LocalAuthLayer, T3LocalAuthOriginLayer, T3LocalAuthTokenLayer, T3OrchestrationLayer };
+import { Bn as T3LocalAuthLayer, Fn as BaseAppLayer, Hn as T3LocalAuthTokenLayer, In as BaseAuthAppLayer, Ln as T3AuthLayer, Nn as AppLayer, Pn as AuthAppLayer, Rn as T3AuthPairingLayer, Un as T3OrchestrationLayer, Vn as T3LocalAuthOriginLayer, Wn as T3PreviewAutomationLayer, zn as T3AuthTransportLayer } from "./shared.js";
+export { AppLayer, AuthAppLayer, BaseAppLayer, BaseAuthAppLayer, T3AuthLayer, T3AuthPairingLayer, T3AuthTransportLayer, T3LocalAuthLayer, T3LocalAuthOriginLayer, T3LocalAuthTokenLayer, T3OrchestrationLayer, T3PreviewAutomationLayer };

package/dist/shared/DrainableWorker.d.ts

@@ -0,0 +1,28 @@
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+//#region upstream-t3code/packages/shared/src/DrainableWorker.d.ts
+interface DrainableWorker<A> {
+  /**
+   * Enqueue a work item and track it for `drain()`.
+   *
+   * This wraps `Queue.offer` so drain state is updated atomically with the
+   * enqueue path instead of inferring it from queue internals.
+   */
+  readonly enqueue: (item: A) => Effect.Effect<void>;
+  /**
+   * Resolves when the queue is empty and the worker is idle (not processing).
+   */
+  readonly drain: Effect.Effect<void>;
+}
+/**
+ * Create a drainable worker that processes items from an unbounded queue.
+ *
+ * The worker is forked into the current scope and will be interrupted when
+ * the scope closes. A finalizer shuts down the queue.
+ *
+ * @param process - The effect to run for each queued item.
+ * @returns A `DrainableWorker` with `queue` and `drain`.
+ */
+declare const makeDrainableWorker: <A, E, R>(process: (item: A) => Effect.Effect<void, E, R>) => Effect.Effect<DrainableWorker<A>, never, Scope.Scope | R>;
+//#endregion
+export { DrainableWorker, makeDrainableWorker };

package/dist/shared/DrainableWorker.js

@@ -0,0 +1,24 @@
+import { FO as tx, IO as txRetry, LD as acquireRelease, RO as void_, ZD as ensuring, _v as unbounded, aO as gen, gv as take, hv as shutdown, iO as forkScoped, kO as tap, mv as offer, rO as forever, vv as get, xv as update, yv as make } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/DrainableWorker.ts
+/**
+* Create a drainable worker that processes items from an unbounded queue.
+*
+* The worker is forked into the current scope and will be interrupted when
+* the scope closes. A finalizer shuts down the queue.
+*
+* @param process - The effect to run for each queued item.
+* @returns A `DrainableWorker` with `queue` and `drain`.
+*/
+const makeDrainableWorker = (process) => gen(function* () {
+	const queue = yield* acquireRelease(unbounded(), shutdown);
+	const outstanding = yield* make(0);
+	yield* take(queue).pipe(tap((a) => ensuring(process(a), update(outstanding, (n) => n - 1))), forever, forkScoped);
+	const drain = get(outstanding).pipe(tap((n) => n > 0 ? txRetry : void_), tx);
+	const enqueue = (element) => offer(queue, element).pipe(tap(() => update(outstanding, (n) => n + 1)), tx);
+	return {
+		enqueue,
+		drain
+	};
+});
+//#endregion
+export { makeDrainableWorker };

package/dist/shared/KeyedCoalescingWorker.d.ts

@@ -0,0 +1,13 @@
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+//#region upstream-t3code/packages/shared/src/KeyedCoalescingWorker.d.ts
+interface KeyedCoalescingWorker<K, V> {
+  readonly enqueue: (key: K, value: V) => Effect.Effect<void>;
+  readonly drainKey: (key: K) => Effect.Effect<void>;
+}
+declare const makeKeyedCoalescingWorker: <K, V, E, R>(options: {
+  readonly merge: (current: V, next: V) => V;
+  readonly process: (key: K, value: V) => Effect.Effect<void, E, R>;
+}) => Effect.Effect<KeyedCoalescingWorker<K, V>, never, Scope.Scope | R>;
+//#endregion
+export { KeyedCoalescingWorker, makeKeyedCoalescingWorker };

package/dist/shared/KeyedCoalescingWorker.js

@@ -0,0 +1,89 @@
+import { $D as flatMap, FO as tx, GD as catchCause, IO as txRetry, LD as acquireRelease, RO as void_, UD as asVoid, _v as unbounded, aO as gen, bv as modify, gv as take, hv as shutdown, iO as forkScoped, kO as tap, mv as offer, rO as forever, vv as get, yv as make } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/KeyedCoalescingWorker.ts
+const makeKeyedCoalescingWorker = (options) => gen(function* () {
+	const queue = yield* acquireRelease(unbounded(), shutdown);
+	const stateRef = yield* make({
+		latestByKey: /* @__PURE__ */ new Map(),
+		queuedKeys: /* @__PURE__ */ new Set(),
+		activeKeys: /* @__PURE__ */ new Set()
+	});
+	const processKey = (key, value) => options.process(key, value).pipe(flatMap(() => modify(stateRef, (state) => {
+		const nextValue = state.latestByKey.get(key);
+		if (nextValue === void 0) {
+			const activeKeys = new Set(state.activeKeys);
+			activeKeys.delete(key);
+			return [null, {
+				...state,
+				activeKeys
+			}];
+		}
+		const latestByKey = new Map(state.latestByKey);
+		latestByKey.delete(key);
+		return [nextValue, {
+			...state,
+			latestByKey
+		}];
+	}).pipe(tx)), flatMap((nextValue) => nextValue === null ? void_ : processKey(key, nextValue)));
+	const cleanupFailedKey = (key) => modify(stateRef, (state) => {
+		const activeKeys = new Set(state.activeKeys);
+		activeKeys.delete(key);
+		if (state.latestByKey.has(key) && !state.queuedKeys.has(key)) {
+			const queuedKeys = new Set(state.queuedKeys);
+			queuedKeys.add(key);
+			return [true, {
+				...state,
+				activeKeys,
+				queuedKeys
+			}];
+		}
+		return [false, {
+			...state,
+			activeKeys
+		}];
+	}).pipe(tx, flatMap((shouldRequeue) => shouldRequeue ? offer(queue, key) : void_));
+	yield* take(queue).pipe(flatMap((key) => modify(stateRef, (state) => {
+		const queuedKeys = new Set(state.queuedKeys);
+		queuedKeys.delete(key);
+		const value = state.latestByKey.get(key);
+		if (value === void 0) return [null, {
+			...state,
+			queuedKeys
+		}];
+		const latestByKey = new Map(state.latestByKey);
+		latestByKey.delete(key);
+		const activeKeys = new Set(state.activeKeys);
+		activeKeys.add(key);
+		return [{
+			key,
+			value
+		}, {
+			...state,
+			latestByKey,
+			queuedKeys,
+			activeKeys
+		}];
+	}).pipe(tx)), flatMap((item) => item === null ? void_ : processKey(item.key, item.value).pipe(catchCause(() => cleanupFailedKey(item.key)))), forever, forkScoped);
+	const enqueue = (key, value) => modify(stateRef, (state) => {
+		const latestByKey = new Map(state.latestByKey);
+		const existing = latestByKey.get(key);
+		latestByKey.set(key, existing === void 0 ? value : options.merge(existing, value));
+		if (state.queuedKeys.has(key) || state.activeKeys.has(key)) return [false, {
+			...state,
+			latestByKey
+		}];
+		const queuedKeys = new Set(state.queuedKeys);
+		queuedKeys.add(key);
+		return [true, {
+			...state,
+			latestByKey,
+			queuedKeys
+		}];
+	}).pipe(flatMap((shouldOffer) => shouldOffer ? offer(queue, key) : void_), tx, asVoid);
+	const drainKey = (key) => get(stateRef).pipe(tap((state) => state.latestByKey.has(key) || state.queuedKeys.has(key) || state.activeKeys.has(key) ? txRetry : void_), asVoid, tx);
+	return {
+		enqueue,
+		drainKey
+	};
+});
+//#endregion
+export { makeKeyedCoalescingWorker };

package/dist/shared/Net.d.ts

@@ -0,0 +1,43 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+//#region upstream-t3code/packages/shared/src/Net.d.ts
+declare const NetError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "NetError";
+} & Readonly<A>;
+declare class NetError extends NetError_base<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+interface NetServiceShape {
+  /**
+   * Returns true when a TCP server can bind to {host, port}.
+   */
+  readonly canListenOnHost: (port: number, host: string) => Effect.Effect<boolean>;
+  /**
+   * Checks loopback availability on both IPv4 and IPv6 localhost addresses.
+   */
+  readonly isPortAvailableOnLoopback: (port: number) => Effect.Effect<boolean>;
+  /**
+   * Reserve an ephemeral loopback port and release it immediately.
+   */
+  readonly reserveLoopbackPort: (host?: string) => Effect.Effect<number, NetError>;
+  /**
+   * Resolve an available listening port, preferring the provided port first.
+   */
+  readonly findAvailablePort: (preferred: number) => Effect.Effect<number, NetError>;
+}
+declare const NetService_base: Context.ServiceClass<NetService, "@t3tools/shared/Net/NetService", NetServiceShape>;
+/**
+ * NetService - Service tag for startup networking helpers.
+ */
+declare class NetService extends NetService_base {}
+declare const make: () => {
+  canListenOnHost: (port: number, host: string) => Effect.Effect<boolean>;
+  isPortAvailableOnLoopback: (port: number) => Effect.Effect<boolean>;
+  reserveLoopbackPort: (host?: string) => Effect.Effect<number, NetError>;
+  findAvailablePort: (preferred: number) => Effect.Effect<number, NetError, never>;
+};
+declare const layer: Layer.Layer<NetService, never, never>;
+//#endregion
+export { NetError, NetService, NetServiceShape, layer, make };

package/dist/shared/Net.js

@@ -0,0 +1,126 @@
+import { $k as hasProperty, BO as zipWith, EO as succeed, KO as TaggedError, OO as sync, QD as fail, WD as callback, aO as gen, iA as isString, kk as Service, rA as isObject, rk as sync$1 } from "../shared.js";
+import * as NodeNet from "node:net";
+//#region upstream-t3code/packages/shared/src/Net.ts
+var NetError = class extends TaggedError("NetError") {};
+const isErrnoExceptionWithCode = (cause) => isObject(cause) && hasProperty(cause, "code") && isString(cause.code);
+const closeServer = (server) => {
+	try {
+		server.close();
+	} catch {}
+};
+/**
+* NetService - Service tag for startup networking helpers.
+*/
+var NetService = class extends Service()("@t3tools/shared/Net/NetService") {};
+const make = () => {
+	/**
+	* Returns true when a TCP server can bind to {host, port}.
+	* `EADDRNOTAVAIL` is treated as available so IPv6-absent hosts don't fail
+	* loopback availability checks.
+	*/
+	const canListenOnHost = (port, host) => callback((resume) => {
+		const server = NodeNet.createServer();
+		let settled = false;
+		const settle = (value) => {
+			if (settled) return;
+			settled = true;
+			resume(succeed(value));
+		};
+		server.unref();
+		server.once("error", (cause) => {
+			if (isErrnoExceptionWithCode(cause) && cause.code === "EADDRNOTAVAIL") {
+				settle(true);
+				return;
+			}
+			settle(false);
+		});
+		server.once("listening", () => {
+			server.close(() => {
+				settle(true);
+			});
+		});
+		server.listen({
+			host,
+			port
+		});
+		return sync(() => {
+			closeServer(server);
+		});
+	});
+	const hasListenerOnHost = (port, host) => callback((resume) => {
+		const socket = NodeNet.createConnection({
+			host,
+			port
+		});
+		let settled = false;
+		const settle = (value) => {
+			if (settled) return;
+			settled = true;
+			socket.destroy();
+			resume(succeed(value));
+		};
+		socket.unref();
+		socket.setTimeout(250);
+		socket.once("connect", () => {
+			settle(true);
+		});
+		socket.once("error", () => {
+			settle(false);
+		});
+		socket.once("timeout", () => {
+			settle(false);
+		});
+		return sync(() => {
+			socket.destroy();
+		});
+	});
+	const isPortAvailableOnLoopback = (port) => gen(function* () {
+		if (yield* zipWith(hasListenerOnHost(port, "127.0.0.1"), hasListenerOnHost(port, "::1"), (ipv4, ipv6) => ipv4 || ipv6)) return false;
+		return yield* zipWith(canListenOnHost(port, "127.0.0.1"), canListenOnHost(port, "::1"), (ipv4, ipv6) => ipv4 && ipv6);
+	});
+	/**
+	* Reserve an ephemeral loopback port and release it immediately.
+	* Returns the reserved port number.
+	*/
+	const reserveLoopbackPort = (host = "127.0.0.1") => callback((resume) => {
+		const probe = NodeNet.createServer();
+		let settled = false;
+		const settle = (effect) => {
+			if (settled) return;
+			settled = true;
+			resume(effect);
+		};
+		probe.once("error", (cause) => {
+			settle(fail(new NetError({
+				message: "Failed to reserve loopback port",
+				cause
+			})));
+		});
+		probe.listen(0, host, () => {
+			const address = probe.address();
+			const port = typeof address === "object" && address !== null ? address.port : 0;
+			probe.close(() => {
+				if (port > 0) {
+					settle(succeed(port));
+					return;
+				}
+				settle(fail(new NetError({ message: "Failed to reserve loopback port" })));
+			});
+		});
+		return sync(() => {
+			closeServer(probe);
+		});
+	});
+	return {
+		canListenOnHost,
+		isPortAvailableOnLoopback,
+		reserveLoopbackPort,
+		findAvailablePort: (preferred) => gen(function* () {
+			if (preferred > 0 && (yield* isPortAvailableOnLoopback(preferred))) return preferred;
+			return yield* reserveLoopbackPort();
+		})
+	};
+};
+const layer = sync$1(NetService, make);
+//#endregion
+export { NetError, NetService, layer, make };

package/dist/shared/String.d.ts

@@ -0,0 +1,4 @@
+//#region upstream-t3code/packages/shared/src/String.d.ts
+declare function truncate(text: string, maxLength?: number): string;
+//#endregion
+export { truncate };

package/dist/shared/String.js

@@ -0,0 +1,8 @@
+//#region upstream-t3code/packages/shared/src/String.ts
+function truncate(text, maxLength = 50) {
+	const trimmed = text.trim();
+	if (trimmed.length <= maxLength) return trimmed;
+	return `${trimmed.slice(0, maxLength)}...`;
+}
+//#endregion
+export { truncate };

package/dist/shared/Struct.d.ts

@@ -0,0 +1,5 @@
+//#region upstream-t3code/packages/shared/src/Struct.d.ts
+type DeepPartial<T> = T extends readonly (infer U)[] ? readonly DeepPartial<U>[] : T extends object ? { [K in keyof T]?: DeepPartial<T[K]>; } : T;
+declare function deepMerge<T extends Record<string, unknown>>(current: T, patch: DeepPartial<T>): T;
+//#endregion
+export { DeepPartial, deepMerge };

package/dist/shared/Struct.js

@@ -0,0 +1,2 @@
+import { u as deepMerge } from "../shared.js";
+export { deepMerge };

package/dist/shared/advertisedEndpoint.d.ts

@@ -0,0 +1,2 @@
+import { _n as classifyHostedHttpsCompatibility, bn as normalizeHttpBaseUrl, gn as CreateAdvertisedEndpointInput, vn as createAdvertisedEndpoint, yn as deriveWsBaseUrl } from "../shared.js";
+export { CreateAdvertisedEndpointInput, classifyHostedHttpsCompatibility, createAdvertisedEndpoint, deriveWsBaseUrl, normalizeHttpBaseUrl };

package/dist/shared/advertisedEndpoint.js

@@ -0,0 +1,2 @@
+import { Bo as normalizeHttpBaseUrl, Lo as classifyHostedHttpsCompatibility, Ro as createAdvertisedEndpoint, zo as deriveWsBaseUrl } from "../shared.js";
+export { classifyHostedHttpsCompatibility, createAdvertisedEndpoint, deriveWsBaseUrl, normalizeHttpBaseUrl };

package/dist/shared/agentAwareness.d.ts

@@ -0,0 +1,27 @@
+import { $T as ThreadId, _v as OrchestrationThreadShell, tv as OrchestrationProjectShell, zT as EnvironmentId } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/agentAwareness.d.ts
+type AgentAwarenessPhase = "starting" | "running" | "waiting_for_approval" | "waiting_for_input" | "completed" | "failed" | "stale";
+interface AgentAwarenessState {
+  readonly environmentId: EnvironmentId;
+  readonly threadId: ThreadId;
+  readonly projectTitle: string;
+  readonly threadTitle: string;
+  readonly phase: AgentAwarenessPhase;
+  readonly headline: string;
+  readonly detail?: string;
+  readonly modelTitle: string;
+  readonly updatedAt: string;
+  readonly deepLink: string;
+}
+interface ProjectThreadAwarenessInput {
+  readonly environmentId: EnvironmentId;
+  readonly project: Pick<OrchestrationProjectShell, "title">;
+  readonly thread: Pick<OrchestrationThreadShell, "id" | "title" | "modelSelection" | "session" | "latestTurn" | "updatedAt" | "hasPendingApprovals" | "hasPendingUserInput">;
+}
+declare function buildAgentAwarenessDeepLink(input: {
+  readonly environmentId: EnvironmentId;
+  readonly threadId: ThreadId;
+}): string;
+declare function projectThreadAwareness(input: ProjectThreadAwarenessInput): AgentAwarenessState | null;
+//#endregion
+export { AgentAwarenessPhase, AgentAwarenessState, ProjectThreadAwarenessInput, buildAgentAwarenessDeepLink, projectThreadAwareness };

package/dist/shared/agentAwareness.js

@@ -0,0 +1,54 @@
+//#region upstream-t3code/packages/shared/src/agentAwareness.ts
+function buildAgentAwarenessDeepLink(input) {
+	return `/threads/${encodeURIComponent(input.environmentId)}/${encodeURIComponent(input.threadId)}`;
+}
+function projectThreadAwareness(input) {
+	const { environmentId, project, thread } = input;
+	const phase = resolveThreadAwarenessPhase(thread);
+	if (!phase) return null;
+	const detail = detailForPhase(phase, thread);
+	return {
+		environmentId,
+		threadId: thread.id,
+		projectTitle: project.title,
+		threadTitle: thread.title,
+		phase,
+		headline: headlineForPhase(phase),
+		...detail === void 0 ? {} : { detail },
+		modelTitle: thread.modelSelection.model,
+		updatedAt: thread.updatedAt,
+		deepLink: buildAgentAwarenessDeepLink({
+			environmentId,
+			threadId: thread.id
+		})
+	};
+}
+function resolveThreadAwarenessPhase(thread) {
+	if (thread.hasPendingApprovals) return "waiting_for_approval";
+	if (thread.hasPendingUserInput) return "waiting_for_input";
+	if (thread.session?.status === "error" || thread.latestTurn?.state === "error") return "failed";
+	if (thread.session?.status === "starting") return "starting";
+	if (thread.session?.status === "running" || thread.latestTurn?.state === "running") return "running";
+	if (thread.latestTurn?.state === "completed") return "completed";
+	if (thread.latestTurn?.state === "interrupted" && thread.latestTurn.completedAt !== null) return "completed";
+	if (thread.session?.status === "ready" || thread.session?.status === "idle") return "completed";
+	return null;
+}
+function headlineForPhase(phase) {
+	switch (phase) {
+		case "starting": return "Starting agent";
+		case "running": return "Agent is working";
+		case "waiting_for_approval": return "Approval needed";
+		case "waiting_for_input": return "Waiting for input";
+		case "completed": return "Agent finished";
+		case "failed": return "Agent failed";
+		case "stale": return "Update delayed";
+	}
+}
+function detailForPhase(phase, thread) {
+	if (phase === "failed") return thread.session?.lastError ?? void 0;
+	if (phase === "completed") return "Review the completed task.";
+	if (phase === "running" && thread.session?.providerName) return `${thread.session.providerName} is active.`;
+}
+//#endregion
+export { buildAgentAwarenessDeepLink, projectThreadAwareness };

package/dist/shared/backgroundActivitySettings.d.ts

@@ -0,0 +1,23 @@
+import { Sg as BackgroundActivitySettings, bg as BackgroundActivityProfile, i_ as ServerSettings } from "../shared.js";
+import * as Duration from "effect/Duration";
+//#region upstream-t3code/packages/shared/src/backgroundActivitySettings.d.ts
+interface ResolvedBackgroundActivitySettings {
+  readonly profile: BackgroundActivityProfile;
+  readonly automaticGitFetchInterval: Duration.Duration;
+  readonly providerHealthRefreshInterval: Duration.Duration;
+  readonly hostPowerMonitorActiveInterval: Duration.Duration;
+  readonly hostPowerMonitorIdleInterval: Duration.Duration;
+  readonly idleClientTtl: Duration.Duration;
+  readonly pauseWhenHostLocked: boolean;
+  readonly pauseWhenHostLowPower: boolean;
+  readonly pauseWhenClientLowPower: boolean;
+  readonly pauseWhenOnBattery: boolean;
+}
+declare function getBackgroundActivityPresetSettings(profile: BackgroundActivityProfile): ResolvedBackgroundActivitySettings;
+declare function getBackgroundActivityBaseProfile(backgroundActivity: BackgroundActivitySettings): BackgroundActivityProfile;
+declare function resolveBackgroundActivitySettings(backgroundActivity: BackgroundActivitySettings): ResolvedBackgroundActivitySettings;
+declare function normalizeBackgroundActivitySettings(backgroundActivity: BackgroundActivitySettings): BackgroundActivitySettings;
+declare function resolveServerBackgroundActivitySettings(settings: ServerSettings): ResolvedBackgroundActivitySettings;
+declare function normalizeServerBackgroundActivitySettings(settings: ServerSettings): BackgroundActivitySettings;
+//#endregion
+export { ResolvedBackgroundActivitySettings, getBackgroundActivityBaseProfile, getBackgroundActivityPresetSettings, normalizeBackgroundActivitySettings, normalizeServerBackgroundActivitySettings, resolveBackgroundActivitySettings, resolveServerBackgroundActivitySettings };

package/dist/shared/backgroundActivitySettings.js

@@ -0,0 +1,2 @@
+import { a as getBackgroundActivityPresetSettings, c as resolveBackgroundActivitySettings, i as getBackgroundActivityBaseProfile, l as resolveServerBackgroundActivitySettings, o as normalizeBackgroundActivitySettings, s as normalizeServerBackgroundActivitySettings } from "../shared.js";
+export { getBackgroundActivityBaseProfile, getBackgroundActivityPresetSettings, normalizeBackgroundActivitySettings, normalizeServerBackgroundActivitySettings, resolveBackgroundActivitySettings, resolveServerBackgroundActivitySettings };

package/dist/shared/chatList.d.ts

@@ -0,0 +1,12 @@
+//#region upstream-t3code/packages/shared/src/chatList.d.ts
+declare const CHAT_LIST_ANCHOR_OFFSET = 16;
+interface ChatListAnchoredEndSpace {
+  readonly anchorIndex: number;
+  readonly anchorOffset: number;
+}
+interface ChatListAnchorOptions {
+  readonly anchorOffset?: number;
+}
+declare function resolveChatListAnchoredEndSpace<Item, AnchorId>(items: ReadonlyArray<Item>, anchorId: AnchorId | null, getAnchorId: (item: Item) => AnchorId | null, options?: ChatListAnchorOptions): ChatListAnchoredEndSpace | undefined;
+//#endregion
+export { CHAT_LIST_ANCHOR_OFFSET, ChatListAnchorOptions, ChatListAnchoredEndSpace, resolveChatListAnchoredEndSpace };

package/dist/shared/chatList.js

@@ -0,0 +1,14 @@
+//#region upstream-t3code/packages/shared/src/chatList.ts
+const CHAT_LIST_ANCHOR_OFFSET = 16;
+function resolveChatListAnchoredEndSpace(items, anchorId, getAnchorId, options = {}) {
+	if (anchorId === null) return;
+	for (let index = items.length - 1; index >= 0; index -= 1) {
+		const item = items[index];
+		if (item !== void 0 && getAnchorId(item) === anchorId) return {
+			anchorIndex: index,
+			anchorOffset: options.anchorOffset ?? 16
+		};
+	}
+}
+//#endregion
+export { CHAT_LIST_ANCHOR_OFFSET, resolveChatListAnchoredEndSpace };

package/dist/shared/cliArgs.d.ts

@@ -0,0 +1,33 @@
+//#region upstream-t3code/packages/shared/src/cliArgs.d.ts
+interface ParsedCliArgs {
+  readonly flags: Record<string, string | null>;
+  readonly positionals: string[];
+}
+interface ParseCliArgsOptions {
+  readonly booleanFlags?: readonly string[];
+}
+declare function tokenizeCliArgs(args?: string): ReadonlyArray<string>;
+/**
+ * Parse CLI-style arguments into flags and positionals.
+ *
+ * Accepts a string (quote-aware tokenized) or a pre-split argv array.
+ * Supports `--key value`, `--key=value`, and `--flag` (boolean) syntax.
+ *
+ *   parseCliArgs("")
+ *     → { flags: {}, positionals: [] }
+ *
+ *   parseCliArgs("--chrome")
+ *     → { flags: { chrome: null }, positionals: [] }
+ *
+ *   parseCliArgs("--chrome --effort high")
+ *     → { flags: { chrome: null, effort: "high" }, positionals: [] }
+ *
+ *   parseCliArgs("--effort=high")
+ *     → { flags: { effort: "high" }, positionals: [] }
+ *
+ *   parseCliArgs(["1.2.3", "--root", "/path", "--github-output"], { booleanFlags: ["github-output"] })
+ *     → { flags: { root: "/path", "github-output": null }, positionals: ["1.2.3"] }
+ */
+declare function parseCliArgs(args: string | readonly string[], options?: ParseCliArgsOptions): ParsedCliArgs;
+//#endregion
+export { ParseCliArgsOptions, ParsedCliArgs, parseCliArgs, tokenizeCliArgs };

package/dist/shared/cliArgs.js

@@ -0,0 +1,103 @@
+//#region upstream-t3code/packages/shared/src/cliArgs.ts
+function tokenizeCliArgs(args) {
+	const input = args?.trim();
+	if (!input) return [];
+	const tokens = [];
+	let current = "";
+	let quote;
+	let quoted = false;
+	for (let index = 0; index < input.length; index++) {
+		const char = input[index];
+		if (char === void 0) continue;
+		if (quote) {
+			if (char === quote) {
+				quote = void 0;
+				quoted = true;
+			} else if (char === "\\" && quote === "\"") {
+				const next = input[index + 1];
+				if (next !== void 0 && [
+					"\"",
+					"\\",
+					"$",
+					"`"
+				].includes(next)) {
+					current += next;
+					index++;
+				} else current += char;
+			} else current += char;
+			continue;
+		}
+		if (char === "'" || char === "\"") {
+			quote = char;
+			quoted = true;
+		} else if (/\s/.test(char)) {
+			if (current || quoted) {
+				tokens.push(current);
+				current = "";
+				quoted = false;
+			}
+		} else if (char === "\\") {
+			const next = input[index + 1];
+			if (next !== void 0 && /\s/.test(next)) {
+				current += next;
+				index++;
+			} else current += char;
+		} else current += char;
+	}
+	if (current || quoted) tokens.push(current);
+	return tokens;
+}
+/**
+* Parse CLI-style arguments into flags and positionals.
+*
+* Accepts a string (quote-aware tokenized) or a pre-split argv array.
+* Supports `--key value`, `--key=value`, and `--flag` (boolean) syntax.
+*
+*   parseCliArgs("")
+*     → { flags: {}, positionals: [] }
+*
+*   parseCliArgs("--chrome")
+*     → { flags: { chrome: null }, positionals: [] }
+*
+*   parseCliArgs("--chrome --effort high")
+*     → { flags: { chrome: null, effort: "high" }, positionals: [] }
+*
+*   parseCliArgs("--effort=high")
+*     → { flags: { effort: "high" }, positionals: [] }
+*
+*   parseCliArgs(["1.2.3", "--root", "/path", "--github-output"], { booleanFlags: ["github-output"] })
+*     → { flags: { root: "/path", "github-output": null }, positionals: ["1.2.3"] }
+*/
+function parseCliArgs(args, options) {
+	const tokens = typeof args === "string" ? tokenizeCliArgs(args) : Array.from(args);
+	const booleanSet = options?.booleanFlags ? new Set(options.booleanFlags) : void 0;
+	const flags = {};
+	const positionals = [];
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token.startsWith("--")) {
+			const rest = token.slice(2);
+			if (!rest) continue;
+			const eqIndex = rest.indexOf("=");
+			if (eqIndex !== -1) {
+				flags[rest.slice(0, eqIndex)] = rest.slice(eqIndex + 1);
+				continue;
+			}
+			if (booleanSet?.has(rest)) {
+				flags[rest] = null;
+				continue;
+			}
+			const next = tokens[i + 1];
+			if (next !== void 0 && !next.startsWith("--")) {
+				flags[rest] = next;
+				i++;
+			} else flags[rest] = null;
+		} else positionals.push(token);
+	}
+	return {
+		flags,
+		positionals
+	};
+}
+//#endregion
+export { parseCliArgs, tokenizeCliArgs };