}

}

export type ShellEnvFallbackResult =

type ShellEnvFallbackResult =

| { ok: true; applied: string[]; skippedReason?: never }

| { ok: true; applied: []; skippedReason: "already-has-keys" | "disabled" }

| { ok: false; error: string; applied: [] };

export type ShellEnvFallbackOptions = {

type ShellEnvFallbackOptions = {

enabled: boolean;

env: NodeJS.ProcessEnv;

expectedKeys: string[];

{ kind: "powershell", names: POWERSHELL_WRAPPER_CANONICAL },

];

export type ShellWrapperCommand = {

type ShellWrapperCommand = {

isWrapper: boolean;

command: string | null;

};

return null;

}

export type ShellMultiplexerUnwrapResult =

type ShellMultiplexerUnwrapResult =

| { kind: "not-wrapper" }

| { kind: "blocked"; wrapper: string }

| { kind: "unwrapped"; wrapper: string; argv: string[] };

ts: number;

};

export type SystemPresenceUpdate = {

type SystemPresenceUpdate = {

key: string;

previous?: SystemPresence;

next: SystemPresence;

resolveInlineCommandMatch,

} from "./shell-inline-command.js";

export type SystemRunCommandValidation =

type SystemRunCommandValidation =

| {

ok: true;

shellPayload: string | null;

details?: Record<string, unknown>;

};

export type ResolvedSystemRunCommand =

type ResolvedSystemRunCommand =

| {

ok: true;

argv: string[];

import { isIpInCidr } from "../shared/net/ip.js";

import { listExternalInterfaceAddresses, readNetworkInterfaces } from "./network-interfaces.js";

export type TailnetAddresses = {

type TailnetAddresses = {

ipv4: string[];

ipv6: string[];

};

return null;

}

export async function getTailscaleBinary(): Promise<string> {

async function getTailscaleBinary(): Promise<string> {

const forcedBinary = getTestTailscaleBinaryOverride();

if (forcedBinary) {

cachedTailscaleBinary = forcedBinary;

export { resolvePreferredOpenClawTmpDir } from "./tmp-openclaw-dir.js";

export type TempDownloadTarget = {

type TempDownloadTarget = {

dir: string;

path: string;

cleanup: () => Promise<void>;

options: { timeoutMs: number; cwd?: string; env?: NodeJS.ProcessEnv },

) => Promise<{ stdout: string; stderr: string; code: number | null }>;

export type ResolvedGlobalInstallCommand = {

type ResolvedGlobalInstallCommand = {

manager: GlobalInstallManager;

command: string;

};

import { detectPackageManager as detectPackageManagerImpl } from "./detect-package-manager.js";

import { applyPathPrepend } from "./path-prepend.js";

export type BuildManager = "pnpm" | "bun" | "npm";

type BuildManager = "pnpm" | "bun" | "npm";

export type UpdatePackageManagerRequirement = "allow-fallback" | "require-preferred";

type UpdatePackageManagerRequirement = "allow-fallback" | "require-preferred";

export type UpdatePackageManagerFailureReason =

| "preferred-manager-unavailable"

options: { timeoutMs: number; env?: NodeJS.ProcessEnv },

) => Promise<{ stdout: string; stderr: string; code: number | null }>;

export type ResolvedBuildManager =

type ResolvedBuildManager =

| {

kind: "resolved";

manager: BuildManager;

reason: UpdatePackageManagerFailureReason;

};

export async function detectBuildManager(root: string): Promise<BuildManager> {

async function detectBuildManager(root: string): Promise<BuildManager> {

return (await detectPackageManagerImpl(root)) ?? "npm";

}

} from "../routing/session-key.js";

import { createAsyncLock, readJsonFile, writeJsonAtomic } from "./json-files.js";

export type VoiceWakeRouteTarget =

type VoiceWakeRouteTarget =

| { mode: "current"; agentId?: undefined; sessionKey?: undefined }

| { agentId: string; sessionKey?: undefined; mode?: undefined }

| { sessionKey: string; agentId?: undefined; mode?: undefined };

export type VoiceWakeRouteRule = {

type VoiceWakeRouteRule = {

trigger: string;

target: VoiceWakeRouteTarget;

};

});

}

export type VoiceWakeResolvedRoute =

| { mode: "current" }

| { agentId: string }

| { sessionKey: string };

type VoiceWakeResolvedRoute = { mode: "current" } | { agentId: string } | { sessionKey: string };

export function resolveVoiceWakeRouteTarget(

function resolveVoiceWakeRouteTarget(

routeTarget: VoiceWakeRouteTarget | undefined,

): VoiceWakeResolvedRoute {

if (!routeTarget || ("mode" in routeTarget && routeTarget.mode === "current")) {