shioricode 0.5.1 → 0.5.3

package/dist/bin.cjs

@@ -72458,42 +72458,112 @@ var RemoteStateStore = class {
 const execFile$10 = (0, node_util.promisify)(node_child_process.execFile);
 const SERVICE_PORT = 3773;
 const RECOVERY_USERNAME = "recovery";
+const SERVICE_LAYOUT_VERSION = 1;
+function invokingUsername() {
+	const sudoUser = process.env.SUDO_USER?.trim();
+	if (sudoUser && sudoUser !== "root") return sudoUser;
+	return node_os.default.userInfo().username;
+}
+function invokingUid() {
+	const sudoUid = Number(process.env.SUDO_UID);
+	if (Number.isInteger(sudoUid) && sudoUid >= 0) return sudoUid;
+	return typeof process.getuid === "function" ? process.getuid() : 0;
+}
+function defaultAccount(platform) {
+	if (platform === "darwin") return "_shioricode";
+	if (platform === "linux") return "shioricode";
+	return "ShioriCode";
+}
+function defaultExistingHomeDir(platform, account) {
+	if (account === node_os.default.userInfo().username) return node_os.default.homedir();
+	if (platform === "darwin") return node_path.default.join("/Users", account);
+	if (platform === "linux") return account === "root" ? "/root" : node_path.default.join("/home", account);
+	return process.env.USERPROFILE || node_os.default.homedir();
+}
+function defaultServicePath(platform) {
+	if (platform === "darwin") return "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin";
+	if (platform === "linux") return "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
+	return process.env.Path ?? process.env.PATH ?? "";
+}
+function validateServiceAccount(account) {
+	if (!/^[A-Za-z_][A-Za-z0-9._-]*\$?$/.test(account)) throw new Error(`Invalid service username: ${account}`);
+}
+function validateServiceLayout(layout) {
+	const isAbsolute = layout.platform === "win32" ? node_path.default.win32.isAbsolute : node_path.default.isAbsolute;
+	for (const [label, value] of [
+		["home directory", layout.homeDir],
+		["state directory", layout.stateDir],
+		["workspace directory", layout.workspaceDir],
+		["service definition", layout.definitionPath],
+		["log file", layout.logPath]
+	]) if (!isAbsolute(value) || /[\0\r\n]/.test(value)) throw new Error(`The ${label} must be an absolute path without control characters`);
+	if (/\0|\r|\n/.test(layout.servicePath)) throw new Error("The service PATH cannot contain control characters");
+	if (!Number.isInteger(layout.port) || layout.port < 1 || layout.port > 65535) throw new Error(`Invalid service port: ${layout.port}`);
+	return layout;
+}
 function supportedPlatform(platform) {
 	if (platform === "linux" || platform === "darwin" || platform === "win32") return platform;
 	throw new Error(`ShioriCode services are not supported on ${platform} yet`);
 }
-function serviceLayout(platform) {
+function serviceLayout(platform, options = {}) {
+	const accountMode = options.accountMode ?? "dedicated";
+	const account = options.account?.trim() || (accountMode === "current" ? invokingUsername() : defaultAccount(platform));
+	validateServiceAccount(account);
 	switch (platform) {
-		case "linux": return {
-			platform,
-			account: "shioricode",
-			stateDir: "/var/lib/shioricode",
-			workspaceDir: "/var/lib/shioricode/workspaces",
-			definitionPath: "/etc/systemd/system/shioricode.service",
-			logPath: "/var/log/shioricode/server.log",
-			serviceId: "shioricode.service"
-		};
-		case "darwin": return {
-			platform,
-			account: "_shioricode",
-			stateDir: "/Library/Application Support/ShioriCode",
-			workspaceDir: "/Users/Shared/ShioriCode/Workspaces",
-			definitionPath: "/Library/LaunchDaemons/codes.shiori.shioricode.plist",
-			logPath: "/Library/Logs/ShioriCode/server.log",
-			serviceId: "codes.shiori.shioricode"
-		};
+		case "linux": {
+			const dedicatedStateDir = "/var/lib/shioricode";
+			const homeDir = options.homeDir ?? (accountMode === "dedicated" ? dedicatedStateDir : defaultExistingHomeDir(platform, account));
+			const stateDir = options.stateDir ?? (accountMode === "dedicated" ? dedicatedStateDir : node_path.default.join(homeDir, ".shioricode-service"));
+			return validateServiceLayout({
+				platform,
+				accountMode,
+				account,
+				homeDir,
+				stateDir,
+				workspaceDir: options.workspaceDir ?? node_path.default.join(stateDir, "workspaces"),
+				definitionPath: accountMode === "dedicated" ? "/etc/systemd/system/shioricode.service" : node_path.default.join(homeDir, ".config/systemd/user/shioricode.service"),
+				logPath: options.logPath ?? (accountMode === "dedicated" ? "/var/log/shioricode/server.log" : node_path.default.join(stateDir, "server.log")),
+				servicePath: options.servicePath ?? defaultServicePath(platform),
+				serviceId: "shioricode.service",
+				port: options.port ?? SERVICE_PORT
+			});
+		}
+		case "darwin": {
+			const dedicatedStateDir = "/Library/Application Support/ShioriCode";
+			const homeDir = options.homeDir ?? (accountMode === "dedicated" ? dedicatedStateDir : defaultExistingHomeDir(platform, account));
+			const stateDir = options.stateDir ?? (accountMode === "dedicated" ? dedicatedStateDir : node_path.default.join(homeDir, ".shioricode-service"));
+			return validateServiceLayout({
+				platform,
+				accountMode,
+				account,
+				homeDir,
+				stateDir,
+				workspaceDir: options.workspaceDir ?? (accountMode === "dedicated" ? "/Users/Shared/ShioriCode/Workspaces" : node_path.default.join(stateDir, "workspaces")),
+				definitionPath: accountMode === "dedicated" ? "/Library/LaunchDaemons/codes.shiori.shioricode.plist" : node_path.default.join(homeDir, "Library/LaunchAgents/codes.shiori.shioricode.plist"),
+				logPath: options.logPath ?? (accountMode === "dedicated" ? "/Library/Logs/ShioriCode/server.log" : node_path.default.join(stateDir, "server.log")),
+				servicePath: options.servicePath ?? defaultServicePath(platform),
+				serviceId: "codes.shiori.shioricode",
+				port: options.port ?? SERVICE_PORT
+			});
+		}
 		case "win32": {
 			const programData = process.env.ProgramData || "C:\\ProgramData";
-			const stateDir = node_path.default.win32.join(programData, "ShioriCode");
-			return {
+			const dedicatedStateDir = node_path.default.win32.join(programData, "ShioriCode");
+			const homeDir = options.homeDir ?? (accountMode === "dedicated" ? dedicatedStateDir : defaultExistingHomeDir(platform, account));
+			const stateDir = options.stateDir ?? (accountMode === "dedicated" ? dedicatedStateDir : node_path.default.win32.join(homeDir, ".shioricode-service"));
+			return validateServiceLayout({
 				platform,
-				account: "ShioriCode",
+				accountMode,
+				account,
+				homeDir,
 				stateDir,
-				workspaceDir: node_path.default.win32.join(stateDir, "workspaces"),
+				workspaceDir: options.workspaceDir ?? node_path.default.win32.join(stateDir, "workspaces"),
 				definitionPath: node_path.default.win32.join(stateDir, "service.cmd"),
-				logPath: node_path.default.win32.join(stateDir, "server.log"),
-				serviceId: "ShioriCode"
-			};
+				logPath: options.logPath ?? node_path.default.win32.join(stateDir, "server.log"),
+				servicePath: options.servicePath ?? defaultServicePath(platform),
+				serviceId: "ShioriCode",
+				port: options.port ?? SERVICE_PORT
+			});
 		}
 	}
 }
@@ -72506,20 +72576,21 @@ function xmlEscape(value) {
 function windowsBatchQuote(value) {
 	return `"${value.replaceAll("\"", "\"\"")}"`;
 }
-function serviceArguments(layout) {
-	return [
+function serviceArguments(layout, requireAuth) {
+	const args = [
 		"serve",
 		"--mode",
 		"web",
 		"--host",
 		"127.0.0.1",
 		"--port",
-		String(SERVICE_PORT),
+		String(layout.port),
 		"--base-dir",
 		layout.stateDir,
-		"--remote",
 		"--no-browser"
 	];
+	if (requireAuth) args.splice(-1, 0, "--remote");
+	return args;
 }
 function serviceRuntimeRoot(layout) {
 	return node_path.default.join(layout.stateDir, "runtime");
@@ -72532,7 +72603,6 @@ function stageServiceRuntime(deps, layout) {
 	const runtimeRoot = serviceRuntimeRoot(layout);
 	const runtimeDir = node_path.default.join(runtimeRoot, `${Date.now()}-${(0, node_crypto.randomBytes)(6).toString("hex")}`);
 	const packageTarget = node_path.default.join(runtimeDir, "package");
-	const nodeTarget = node_path.default.join(runtimeDir, layout.platform === "win32" ? "node.exe" : "node");
 	node_fs.default.mkdirSync(runtimeDir, {
 		recursive: true,
 		mode: 488
@@ -72542,8 +72612,6 @@ function stageServiceRuntime(deps, layout) {
 			recursive: true,
 			dereference: true
 		});
-		node_fs.default.copyFileSync(deps.execPath, nodeTarget, node_fs.default.constants.COPYFILE_FICLONE);
-		if (layout.platform !== "win32") node_fs.default.chmodSync(nodeTarget, 493);
 	} catch (error) {
 		node_fs.default.rmSync(runtimeDir, {
 			recursive: true,
@@ -72555,7 +72623,6 @@ function stageServiceRuntime(deps, layout) {
 		runtimeDir,
 		dependencies: {
 			...deps,
-			execPath: nodeTarget,
 			cliPath: node_path.default.join(packageTarget, "dist", "bin.mjs")
 		}
 	};
@@ -72580,6 +72647,14 @@ function pruneStagedServiceRuntimes(layout, activeRuntimeDir) {
 	}
 }
 async function protectStagedServiceRuntime(deps, layout) {
+	if (layout.accountMode === "current") {
+		if (layout.platform !== "win32") await deps.run("chmod", [
+			"-R",
+			"u+rX",
+			serviceRuntimeRoot(layout)
+		]);
+		return;
+	}
 	const runtimeRoot = serviceRuntimeRoot(layout);
 	if (layout.platform === "win32") {
 		await deps.run("icacls.exe", [
@@ -72605,11 +72680,14 @@ async function protectStagedServiceRuntime(deps, layout) {
 }
 function renderSystemdUnit(input) {
 	const { layout } = input;
+	const hasRecoveryLogin = input.recoveryUsername !== null && input.recoveryPassword !== null;
 	const command = [
 		input.execPath,
 		input.cliPath,
-		...serviceArguments(layout)
+		...serviceArguments(layout, hasRecoveryLogin)
 	].map(systemdQuote).join(" ");
+	const account = layout.accountMode === "dedicated" ? `User=${layout.account}\nGroup=${layout.account}\n` : "";
+	const recoveryLogin = hasRecoveryLogin ? `Environment=${systemdQuote(`SHIORICODE_USERNAME=${input.recoveryUsername}`)}\nEnvironment=${systemdQuote(`SHIORICODE_PASSWORD=${input.recoveryPassword}`)}\n` : "";
 	return `[Unit]
 Description=ShioriCode headless server
 After=network-online.target
@@ -72617,45 +72695,40 @@ Wants=network-online.target
 
 [Service]
 Type=simple
-User=${layout.account}
-Group=${layout.account}
-WorkingDirectory=${layout.workspaceDir}
-Environment=HOME=${layout.stateDir}
+${account}WorkingDirectory=${systemdQuote(layout.workspaceDir)}
+Environment=${systemdQuote(`HOME=${layout.homeDir}`)}
 Environment=NODE_ENV=production
 Environment=SHIORICODE_SERVICE=1
 Environment=SHIORICODE_AUTO_BOOTSTRAP_PROJECT_FROM_CWD=false
-Environment=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
-Environment=SHIORICODE_USERNAME=${RECOVERY_USERNAME}
-Environment=SHIORICODE_PASSWORD=${input.recoveryPassword}
-ExecStart=${command}
+Environment=${systemdQuote(`PATH=${layout.servicePath}`)}
+${recoveryLogin}ExecStart=${command}
 Restart=on-failure
 RestartSec=3
 SuccessExitStatus=130 143
 LimitNOFILE=65535
-StandardOutput=append:${layout.logPath}
-StandardError=append:${layout.logPath}
+StandardOutput=${systemdQuote(`append:${layout.logPath}`)}
+StandardError=${systemdQuote(`append:${layout.logPath}`)}
 
 [Install]
 WantedBy=multi-user.target
 `;
 }
 function renderLaunchDaemon(input) {
+	const hasRecoveryLogin = input.recoveryUsername !== null && input.recoveryPassword !== null;
 	const args = [
 		input.execPath,
 		input.cliPath,
-		...serviceArguments(input.layout)
+		...serviceArguments(input.layout, hasRecoveryLogin)
 	].map((value) => `    <string>${xmlEscape(value)}</string>`).join("\n");
+	const account = input.layout.accountMode === "dedicated" ? `  <key>UserName</key>\n  <string>${input.layout.account}</string>\n  <key>GroupName</key>\n  <string>${input.layout.account}</string>\n` : "";
+	const recoveryLogin = hasRecoveryLogin ? `    <key>SHIORICODE_USERNAME</key><string>${xmlEscape(input.recoveryUsername)}</string>\n    <key>SHIORICODE_PASSWORD</key><string>${xmlEscape(input.recoveryPassword)}</string>\n` : "";
 	return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
   <key>Label</key>
   <string>${input.layout.serviceId}</string>
-  <key>UserName</key>
-  <string>${input.layout.account}</string>
-  <key>GroupName</key>
-  <string>${input.layout.account}</string>
-  <key>WorkingDirectory</key>
+${account}  <key>WorkingDirectory</key>
   <string>${xmlEscape(input.layout.workspaceDir)}</string>
   <key>ProgramArguments</key>
   <array>
@@ -72663,14 +72736,12 @@ ${args}
   </array>
   <key>EnvironmentVariables</key>
   <dict>
-    <key>HOME</key><string>${xmlEscape(input.layout.stateDir)}</string>
+    <key>HOME</key><string>${xmlEscape(input.layout.homeDir)}</string>
     <key>NODE_ENV</key><string>production</string>
     <key>SHIORICODE_SERVICE</key><string>1</string>
     <key>SHIORICODE_AUTO_BOOTSTRAP_PROJECT_FROM_CWD</key><string>false</string>
-    <key>PATH</key><string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
-    <key>SHIORICODE_USERNAME</key><string>${RECOVERY_USERNAME}</string>
-    <key>SHIORICODE_PASSWORD</key><string>${xmlEscape(input.recoveryPassword)}</string>
-  </dict>
+    <key>PATH</key><string>${xmlEscape(input.layout.servicePath)}</string>
+${recoveryLogin}  </dict>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><true/>
   <key>ThrottleInterval</key><integer>3</integer>
@@ -72681,19 +72752,20 @@ ${args}
 `;
 }
 function renderWindowsServiceScript(input) {
+	const hasRecoveryLogin = input.recoveryUsername !== null && input.recoveryPassword !== null;
 	const command = [
 		input.execPath,
 		input.cliPath,
-		...serviceArguments(input.layout)
+		...serviceArguments(input.layout, hasRecoveryLogin)
 	].map(windowsBatchQuote).join(" ");
+	const recoveryLogin = hasRecoveryLogin ? `set "SHIORICODE_USERNAME=${input.recoveryUsername}"\r\nset "SHIORICODE_PASSWORD=${input.recoveryPassword}"\r\n` : "";
 	return `@echo off\r
-set "HOME=${input.layout.stateDir}"\r
+set "HOME=${input.layout.homeDir}"\r
 set "NODE_ENV=production"\r
 set "SHIORICODE_SERVICE=1"\r
 set "SHIORICODE_AUTO_BOOTSTRAP_PROJECT_FROM_CWD=false"\r
-set "SHIORICODE_USERNAME=${RECOVERY_USERNAME}"\r
-set "SHIORICODE_PASSWORD=${input.recoveryPassword}"\r
-cd /d ${windowsBatchQuote(input.layout.workspaceDir)}\r
+set "PATH=${input.layout.servicePath}"\r
+${recoveryLogin}cd /d ${windowsBatchQuote(input.layout.workspaceDir)}\r
 ${command} >> ${windowsBatchQuote(input.layout.logPath)} 2>&1\r
 `;
 }
@@ -72709,11 +72781,24 @@ function defaultDependencies$2() {
 	if (!cliArg) throw new Error("Could not resolve the ShioriCode executable path");
 	return {
 		platform: supportedPlatform(process.platform),
-		execPath: node_fs.default.realpathSync(process.execPath),
+		execPath: stableNodeExecutable(),
 		cliPath: node_fs.default.realpathSync(cliArg),
 		run: runDefault
 	};
 }
+function stableNodeExecutable() {
+	if (process.platform === "win32") return process.execPath;
+	const pathEntries = (process.env.PATH ?? "").split(node_path.default.delimiter);
+	for (const entry of pathEntries) {
+		if (!entry) continue;
+		const candidate = node_path.default.join(entry, "node");
+		try {
+			node_fs.default.accessSync(candidate, node_fs.default.constants.X_OK);
+			return candidate;
+		} catch {}
+	}
+	return process.execPath;
+}
 function requireAdministrator(platform) {
 	if (platform !== "win32" && typeof process.getuid === "function" && process.getuid() !== 0) throw new Error("Service installation requires administrator privileges. Re-run with sudo.");
 }
@@ -72726,7 +72811,9 @@ async function commandExists$1(run, file, args) {
 	}
 }
 async function ensureLinuxAccount(deps, layout) {
-	if (!await commandExists$1(deps.run, "id", ["-u", layout.account])) await deps.run("useradd", [
+	const accountExists = await commandExists$1(deps.run, "id", ["-u", layout.account]);
+	if (!accountExists && layout.accountMode === "current") throw new Error(`The requested existing service user ${layout.account} does not exist`);
+	if (!accountExists) await deps.run("useradd", [
 		"--system",
 		"--home-dir",
 		layout.stateDir,
@@ -72735,6 +72822,10 @@ async function ensureLinuxAccount(deps, layout) {
 		"/usr/sbin/nologin",
 		layout.account
 	]);
+	node_fs.default.mkdirSync(layout.stateDir, {
+		recursive: true,
+		mode: 488
+	});
 	node_fs.default.mkdirSync(layout.workspaceDir, {
 		recursive: true,
 		mode: 488
@@ -72743,14 +72834,15 @@ async function ensureLinuxAccount(deps, layout) {
 		recursive: true,
 		mode: 488
 	});
+	if (layout.accountMode === "current") return;
 	await deps.run("chown", [
 		"-R",
-		`${layout.account}:${layout.account}`,
+		layout.account,
 		layout.stateDir
 	]);
 	await deps.run("chown", [
 		"-R",
-		`${layout.account}:${layout.account}`,
+		layout.account,
 		node_path.default.dirname(layout.logPath)
 	]);
 }
@@ -72785,6 +72877,22 @@ async function readMacNumericAttribute(deps, record, attribute) {
 	}
 }
 async function ensureMacAccount(deps, layout) {
+	if (layout.accountMode === "current") {
+		if (!await commandExists$1(deps.run, "id", ["-u", layout.account])) throw new Error(`The requested existing service user ${layout.account} does not exist`);
+		node_fs.default.mkdirSync(layout.stateDir, {
+			recursive: true,
+			mode: 488
+		});
+		node_fs.default.mkdirSync(layout.workspaceDir, {
+			recursive: true,
+			mode: 488
+		});
+		node_fs.default.mkdirSync(node_path.default.dirname(layout.logPath), {
+			recursive: true,
+			mode: 488
+		});
+		return;
+	}
 	const userRecord = `/Users/${layout.account}`;
 	const groupRecord = `/Groups/${layout.account}`;
 	const existingUid = await readMacNumericAttribute(deps, userRecord, "UniqueID");
@@ -72894,58 +73002,80 @@ async function ensureMacAccount(deps, layout) {
 		node_path.default.dirname(layout.logPath)
 	]);
 }
-async function installLinux(deps, layout, recoveryPassword) {
+async function installLinux(deps, layout, recoveryUsername, recoveryPassword) {
 	await ensureLinuxAccount(deps, layout);
 	const staged = stageServiceRuntime(deps, layout);
 	await protectStagedServiceRuntime(deps, layout);
+	node_fs.default.mkdirSync(node_path.default.dirname(layout.definitionPath), {
+		recursive: true,
+		mode: 493
+	});
 	node_fs.default.writeFileSync(layout.definitionPath, renderSystemdUnit({
 		...staged.dependencies,
 		layout,
+		recoveryUsername,
 		recoveryPassword
 	}), { mode: 384 });
-	await deps.run("systemctl", ["daemon-reload"]);
-	await deps.run("systemctl", ["enable", layout.serviceId]);
-	await deps.run("systemctl", ["restart", layout.serviceId]);
+	const systemctl = layout.accountMode === "current" ? ["--user"] : [];
+	await deps.run("systemctl", [...systemctl, "daemon-reload"]);
+	await deps.run("systemctl", [
+		...systemctl,
+		"enable",
+		layout.serviceId
+	]);
+	await deps.run("systemctl", [
+		...systemctl,
+		"restart",
+		layout.serviceId
+	]);
 	pruneStagedServiceRuntimes(layout, staged.runtimeDir);
 }
-async function installMac(deps, layout, recoveryPassword) {
+async function installMac(deps, layout, recoveryUsername, recoveryPassword) {
 	await ensureMacAccount(deps, layout);
 	const staged = stageServiceRuntime(deps, layout);
 	await protectStagedServiceRuntime(deps, layout);
+	node_fs.default.mkdirSync(node_path.default.dirname(layout.definitionPath), {
+		recursive: true,
+		mode: 493
+	});
 	node_fs.default.writeFileSync(layout.definitionPath, renderLaunchDaemon({
 		...staged.dependencies,
 		layout,
+		recoveryUsername,
 		recoveryPassword
 	}), { mode: 384 });
+	const domain = layout.accountMode === "dedicated" ? "system" : `gui/${invokingUid()}`;
 	await deps.run("launchctl", [
 		"bootout",
-		"system",
+		domain,
 		layout.definitionPath
 	]).catch(() => {});
 	await deps.run("launchctl", [
 		"bootstrap",
-		"system",
+		domain,
 		layout.definitionPath
 	]);
-	await deps.run("launchctl", ["enable", `system/${layout.serviceId}`]);
+	await deps.run("launchctl", ["enable", `${domain}/${layout.serviceId}`]);
 	await deps.run("launchctl", [
 		"kickstart",
 		"-k",
-		`system/${layout.serviceId}`
+		`${domain}/${layout.serviceId}`
 	]);
 	pruneStagedServiceRuntimes(layout, staged.runtimeDir);
 }
-async function installWindows(deps, layout, recoveryPassword) {
-	const accountPassword = (0, node_crypto.randomBytes)(32).toString("base64url");
-	const ps = renderWindowsAccountScript(layout.account, accountPassword);
-	await deps.run("powershell.exe", [
-		"-NoProfile",
-		"-NonInteractive",
-		"-Command",
-		ps
-	]);
+async function installWindows(deps, layout, recoveryUsername, recoveryPassword) {
+	const accountPassword = layout.accountMode === "dedicated" ? (0, node_crypto.randomBytes)(32).toString("base64url") : null;
+	if (accountPassword) {
+		const ps = renderWindowsAccountScript(layout.account, accountPassword);
+		await deps.run("powershell.exe", [
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			ps
+		]);
+	}
 	node_fs.default.mkdirSync(layout.workspaceDir, { recursive: true });
-	await deps.run("icacls.exe", [
+	if (layout.accountMode === "dedicated") await deps.run("icacls.exe", [
 		layout.stateDir,
 		"/inheritance:r",
 		"/grant:r",
@@ -72958,6 +73088,7 @@ async function installWindows(deps, layout, recoveryPassword) {
 	node_fs.default.writeFileSync(layout.definitionPath, renderWindowsServiceScript({
 		...staged.dependencies,
 		layout,
+		recoveryUsername,
 		recoveryPassword
 	}), "utf8");
 	await deps.run("schtasks.exe", [
@@ -72965,16 +73096,23 @@ async function installWindows(deps, layout, recoveryPassword) {
 		"/TN",
 		layout.serviceId
 	]).catch(() => {});
+	const accountArguments = accountPassword ? [
+		"/RU",
+		`.\\${layout.account}`,
+		"/RP",
+		accountPassword
+	] : [
+		"/RU",
+		layout.account,
+		"/NP"
+	];
 	await deps.run("schtasks.exe", [
 		"/Create",
 		"/TN",
 		layout.serviceId,
 		"/SC",
-		"ONSTART",
-		"/RU",
-		`.\\${layout.account}`,
-		"/RP",
-		accountPassword,
+		layout.accountMode === "dedicated" ? "ONSTART" : "ONLOGON",
+		...accountArguments,
 		"/TR",
 		layout.definitionPath,
 		"/F"
@@ -72998,21 +73136,90 @@ $userList='HKLM:\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon\\Spe
 New-Item -Path $userList -Force | Out-Null
 New-ItemProperty -Path $userList -Name $name -PropertyType DWord -Value 0 -Force | Out-Null`;
 }
-async function installService(overrides = {}) {
+function systemServiceLayoutMetadataPath(platform) {
+	if (platform === "linux") return "/etc/shioricode/service-layout.json";
+	if (platform === "darwin") return "/Library/Preferences/codes.shiori.shioricode.service-layout.json";
+	const programData = process.env.ProgramData || "C:\\ProgramData";
+	return node_path.default.win32.join(programData, "ShioriCodeService", "service-layout.json");
+}
+function serviceLayoutMetadataPath(layout) {
+	if (layout.accountMode === "dedicated") return systemServiceLayoutMetadataPath(layout.platform);
+	const metadataHome = defaultExistingHomeDir(layout.platform, invokingUsername());
+	if (layout.platform === "linux") return node_path.default.join(metadataHome, ".config/shioricode/service-layout.json");
+	if (layout.platform === "darwin") return node_path.default.join(metadataHome, "Library/Application Support/ShioriCode Service/service-layout.json");
+	return node_path.default.win32.join(process.env.LOCALAPPDATA || node_path.default.win32.join(metadataHome, "AppData", "Local"), "ShioriCodeService", "service-layout.json");
+}
+function writeServiceLayout(layout) {
+	const metadataPath = serviceLayoutMetadataPath(layout);
+	node_fs.default.mkdirSync(node_path.default.dirname(metadataPath), {
+		recursive: true,
+		mode: 493
+	});
+	node_fs.default.writeFileSync(metadataPath, `${JSON.stringify({
+		version: SERVICE_LAYOUT_VERSION,
+		layout
+	}, null, 2)}\n`, { mode: 384 });
+	if (layout.accountMode === "dedicated" && layout.platform !== "win32") {
+		node_fs.default.chownSync(metadataPath, 0, 0);
+		node_fs.default.chmodSync(metadataPath, 384);
+	}
+}
+function readServiceLayout(metadataPath, platform) {
+	try {
+		const parsed = JSON.parse(node_fs.default.readFileSync(metadataPath, "utf8"));
+		const layout = parsed.layout;
+		if (parsed.version !== SERVICE_LAYOUT_VERSION || layout?.platform !== platform || layout.accountMode !== "dedicated" && layout.accountMode !== "current" || typeof layout.account !== "string" || typeof layout.homeDir !== "string" || typeof layout.stateDir !== "string" || typeof layout.workspaceDir !== "string" || typeof layout.definitionPath !== "string" || typeof layout.logPath !== "string" || typeof layout.servicePath !== "string" || typeof layout.serviceId !== "string" || typeof layout.port !== "number") return null;
+		return layout;
+	} catch {
+		return null;
+	}
+}
+function readInstalledServiceLayout(platform) {
+	const currentLayout = readServiceLayout(serviceLayoutMetadataPath(serviceLayout(platform, { accountMode: "current" })), platform);
+	if (currentLayout && node_fs.default.existsSync(currentLayout.definitionPath)) return currentLayout;
+	const systemLayout = readServiceLayout(systemServiceLayoutMetadataPath(platform), platform);
+	if (systemLayout && node_fs.default.existsSync(systemLayout.definitionPath)) return systemLayout;
+	const legacy = serviceLayout(platform);
+	return node_fs.default.existsSync(legacy.definitionPath) ? legacy : null;
+}
+function recoveryPasswordFromOptions(options) {
+	if (!options.recoveryPasswordFile) return {
+		password: (0, node_crypto.randomBytes)(32).toString("base64url"),
+		generated: true
+	};
+	const password = node_fs.default.readFileSync(options.recoveryPasswordFile, "utf8").replace(/\r?\n$/, "");
+	if (!password) throw new Error("The recovery password file is empty");
+	if (/[\0\r\n]/.test(password)) throw new Error("The recovery password file must contain exactly one password line");
+	return {
+		password,
+		generated: false
+	};
+}
+async function installService(options = {}, overrides = {}) {
 	const deps = {
 		...defaultDependencies$2(),
 		...overrides
 	};
-	const layout = serviceLayout(deps.platform);
-	requireAdministrator(deps.platform);
-	const recoveryPassword = (0, node_crypto.randomBytes)(32).toString("base64url");
-	if (deps.platform === "linux") await installLinux(deps, layout, recoveryPassword);
-	if (deps.platform === "darwin") await installMac(deps, layout, recoveryPassword);
-	if (deps.platform === "win32") await installWindows(deps, layout, recoveryPassword);
+	const layout = serviceLayout(deps.platform, options);
+	if (layout.accountMode === "current" && layout.account !== invokingUsername()) throw new Error("Current-account services must run as the invoking OS user");
+	if (layout.accountMode === "dedicated") requireAdministrator(deps.platform);
+	if (options.disableRecoveryLogin && (options.recoveryUsername || options.recoveryPasswordFile)) throw new Error("--no-recovery-login cannot be combined with recovery username/password options");
+	const recoveryUsername = options.disableRecoveryLogin ? null : options.recoveryUsername?.trim() || RECOVERY_USERNAME;
+	if (recoveryUsername !== null && !/^[A-Za-z0-9._@-]{1,128}$/.test(recoveryUsername)) throw new Error("The recovery username contains unsupported characters");
+	const recoveryPassword = options.disableRecoveryLogin ? {
+		password: null,
+		generated: false
+	} : recoveryPasswordFromOptions(options);
+	if (deps.platform === "win32" && recoveryPassword.password !== null && /[%"]/.test(recoveryPassword.password)) throw new Error("Windows recovery passwords cannot contain `%` or `\"`");
+	if (deps.platform === "linux") await installLinux(deps, layout, recoveryUsername, recoveryPassword.password);
+	if (deps.platform === "darwin") await installMac(deps, layout, recoveryUsername, recoveryPassword.password);
+	if (deps.platform === "win32") await installWindows(deps, layout, recoveryUsername, recoveryPassword.password);
+	writeServiceLayout(layout);
 	return {
 		layout,
-		recoveryUsername: RECOVERY_USERNAME,
-		recoveryPassword
+		recoveryUsername,
+		recoveryPassword: recoveryPassword.password,
+		recoveryPasswordGenerated: recoveryPassword.generated
 	};
 }
 async function readLog(logPath) {
@@ -73028,37 +73235,47 @@ async function controlService(action, overrides = {}) {
 		...defaultDependencies$2(),
 		...overrides
 	};
-	const layout = serviceLayout(deps.platform);
-	requireAdministrator(deps.platform);
+	const layout = readInstalledServiceLayout(deps.platform) ?? serviceLayout(deps.platform);
+	if (layout.accountMode === "dedicated") requireAdministrator(deps.platform);
 	if (action === "logs") return await readLog(layout.logPath);
 	if (deps.platform === "linux") {
+		const systemctl = layout.accountMode === "current" ? ["--user"] : [];
 		if (action === "uninstall") {
 			await deps.run("systemctl", [
+				...systemctl,
 				"disable",
 				"--now",
 				layout.serviceId
 			]).catch(() => {});
 			node_fs.default.rmSync(layout.definitionPath, { force: true });
-			await deps.run("systemctl", ["daemon-reload"]);
+			await deps.run("systemctl", [...systemctl, "daemon-reload"]);
+			node_fs.default.rmSync(serviceLayoutMetadataPath(layout), { force: true });
 			return "Removed the systemd service. ShioriCode data and the service account were preserved.";
 		}
 		if (action === "status") return (await deps.run("systemctl", [
+			...systemctl,
 			"show",
 			layout.serviceId,
 			"--no-pager",
 			"--property=LoadState,UnitFileState,ActiveState,SubState,MainPID,ExecMainStatus"
 		])).stdout.trim();
-		return (await deps.run("systemctl", [action, layout.serviceId])).stdout.trim() || `Service ${action} complete.`;
+		return (await deps.run("systemctl", [
+			...systemctl,
+			action,
+			layout.serviceId
+		])).stdout.trim() || `Service ${action} complete.`;
 	}
 	if (deps.platform === "darwin") {
-		const target = `system/${layout.serviceId}`;
+		const domain = layout.accountMode === "dedicated" ? "system" : `gui/${invokingUid()}`;
+		const target = `${domain}/${layout.serviceId}`;
 		if (action === "uninstall") {
 			await deps.run("launchctl", [
 				"bootout",
-				"system",
+				domain,
 				layout.definitionPath
 			]).catch(() => {});
 			node_fs.default.rmSync(layout.definitionPath, { force: true });
+			node_fs.default.rmSync(serviceLayoutMetadataPath(layout), { force: true });
 			return "Removed the launch daemon. ShioriCode data and the service account were preserved.";
 		}
 		if (action === "status") try {
@@ -73069,20 +73286,20 @@ async function controlService(action, overrides = {}) {
 		if (action === "stop") {
 			await deps.run("launchctl", [
 				"bootout",
-				"system",
+				domain,
 				layout.definitionPath
 			]);
 			return "Service stop complete.";
 		}
 		if (action === "restart") await deps.run("launchctl", [
 			"bootout",
-			"system",
+			domain,
 			layout.definitionPath
 		]).catch(() => {});
 		if (action === "start" || action === "restart") {
 			await deps.run("launchctl", [
 				"bootstrap",
-				"system",
+				domain,
 				layout.definitionPath
 			]).catch(() => {});
 			await deps.run("launchctl", ["enable", target]);
@@ -73106,6 +73323,7 @@ async function controlService(action, overrides = {}) {
 			layout.serviceId,
 			"/F"
 		]);
+		node_fs.default.rmSync(serviceLayoutMetadataPath(layout), { force: true });
 		return "Removed the Windows background task. ShioriCode data and the service account were preserved.";
 	}
 	if (action === "status") return (await deps.run("schtasks.exe", [
@@ -73144,11 +73362,13 @@ function serviceSummary(layout = serviceLayout(supportedPlatform(process.platfor
 	return [
 		`Platform: ${layout.platform}`,
 		`Service: ${layout.serviceId}`,
-		`Account: ${layout.account}`,
+		`Account: ${layout.account} (${layout.accountMode})`,
+		`Home: ${layout.homeDir}`,
 		`Data: ${layout.stateDir}`,
 		`Workspaces: ${layout.workspaceDir}`,
 		`Logs: ${layout.logPath}`,
-		`Host: http://127.0.0.1:${SERVICE_PORT}`
+		`PATH: ${layout.servicePath}`,
+		`Host: http://127.0.0.1:${layout.port}`
 	].join("\n");
 }
 const currentServicePlatform = () => supportedPlatform(node_os.default.platform());
@@ -73157,8 +73377,7 @@ function requireServiceAdministrator(platform = currentServicePlatform()) {
 	return platform;
 }
 function findInstalledServiceLayout() {
-	const layout = serviceLayout(currentServicePlatform());
-	return node_fs.default.existsSync(layout.definitionPath) ? layout : null;
+	return readInstalledServiceLayout(currentServicePlatform());
 }
 function installedServiceLayout() {
 	const layout = findInstalledServiceLayout();
@@ -73169,14 +73388,13 @@ function linkServiceStateDir(layout = installedServiceLayout()) {
 	return node_path.default.join(layout.stateDir, "userdata");
 }
 async function repairServiceStateOwnership(layout = installedServiceLayout()) {
-	if (layout.platform === "win32") return;
-	const owner = `${layout.account}:${layout.account}`;
-	await runDefault("chown", [owner, layout.stateDir]);
+	if (layout.platform === "win32" || layout.accountMode === "current") return;
+	await runDefault("chown", [layout.account, layout.stateDir]);
 	for (const entry of node_fs.default.readdirSync(layout.stateDir, { withFileTypes: true })) {
 		if (entry.name === "runtime") continue;
 		await runDefault("chown", [
 			"-R",
-			owner,
+			layout.account,
 			node_path.default.join(layout.stateDir, entry.name)
 		]);
 	}
@@ -73257,9 +73475,8 @@ async function waitForDeviceAuthorization(input) {
 	throw new Error("The GitHub authorization code expired");
 }
 function serviceLinkContext() {
-	const platform = requireServiceAdministrator();
 	const layout = installedServiceLayout();
-	if (layout.platform !== platform) throw new Error("Service platform changed unexpectedly");
+	if (layout.accountMode === "dedicated") requireServiceAdministrator(layout.platform);
 	const store = new LinkRemoteStore({ stateDir: linkServiceStateDir(layout) });
 	return {
 		layout,
@@ -73425,18 +73642,13 @@ const PROVIDERS = [
 		credentialPaths: [".kimi"]
 	}
 ];
-function servicePath(platform) {
-	if (platform === "darwin") return "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin";
-	if (platform === "linux") return "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
-	return process.env.Path ?? process.env.PATH ?? "";
-}
-async function binaryVersion(binary, home) {
+async function binaryVersion(binary, home, configuredPath) {
 	try {
 		const result = await execFile$8(binary, ["--version"], {
 			env: {
 				...process.env,
 				HOME: home,
-				PATH: servicePath(process.platform)
+				PATH: configuredPath
 			},
 			timeout: 5e3,
 			windowsHide: true
@@ -73450,26 +73662,27 @@ function hasCredentials(home, candidates) {
 	return candidates.some((candidate) => node_fs.default.existsSync(node_path.default.join(home, candidate)));
 }
 function serviceAccountCommand(command) {
-	const layout = serviceLayout(currentServicePlatform());
+	const layout = findInstalledServiceLayout() ?? serviceLayout(currentServicePlatform());
+	if (layout.accountMode === "current") return command;
 	if (layout.platform === "linux") return `sudo -u ${layout.account} -H ${command}`;
 	if (layout.platform === "darwin") return `sudo -u ${layout.account} -H env PATH=/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin ${command}`;
 	return `${command} (run it for the ${layout.account} service account)`;
 }
 async function providerDoctor() {
-	const layout = serviceLayout(currentServicePlatform());
+	const layout = findInstalledServiceLayout() ?? serviceLayout(currentServicePlatform());
 	const lines = [
 		`Service account: ${layout.account}`,
-		`Service home: ${layout.stateDir}`,
+		`Service home: ${layout.homeDir}`,
 		""
 	];
 	for (const provider of PROVIDERS) {
-		const version = await binaryVersion(provider.binary, layout.stateDir);
+		const version = await binaryVersion(provider.binary, layout.homeDir, layout.servicePath);
 		if (!version) {
 			lines.push(`✗ ${provider.name}: not found in the service PATH`);
 			lines.push(`  Install: ${provider.installHint}`);
 			continue;
 		}
-		const authenticated = hasCredentials(layout.stateDir, provider.credentialPaths);
+		const authenticated = hasCredentials(layout.homeDir, provider.credentialPaths);
 		lines.push(`✓ ${provider.name}: ${version}`);
 		lines.push(authenticated ? "  Credentials detected in the service home" : `  Sign in: ${serviceAccountCommand(provider.authHint)}`);
 	}
@@ -83766,7 +83979,7 @@ function resolveTarget(baseDir, deps) {
 }
 async function withRemoteRpc(target, deps, run) {
 	if (!target.service) return await deps.withLocalRpc(target.baseDir, run);
-	deps.requireAdministrator(target.service.platform);
+	if (target.service.accountMode === "dedicated") deps.requireAdministrator(target.service.platform);
 	const connection = await deps.connectService(target.service.stateDir);
 	if (!connection) throw new Error("The ShioriCode service is installed but not reachable. Run `shioricode service start`, then retry.");
 	try {
@@ -216801,18 +217014,21 @@ function builtInShioriMcpServers(input) {
 	return servers.map((server) => Object.assign({}, server, { providers: [provider] }));
 }
 function makeBuiltInStdioMcpServerEntry(name, subcommand, env) {
-	const entry = {
+	return {
 		name,
 		transport: "stdio",
 		command: process.execPath,
 		args: [...serverEntrypointArgs(), subcommand],
 		enabled: true,
-		providers: []
+		providers: [],
+		env: makeBuiltInStdioMcpEnvironment(env)
+	};
+}
+function makeBuiltInStdioMcpEnvironment(env) {
+	return {
+		...env,
+		ELECTRON_RUN_AS_NODE: "1"
 	};
-	return env ? {
-		...entry,
-		env
-	} : entry;
 }
 function threadGoalMcpServerEntry(input) {
 	return makeBuiltInStdioMcpServerEntry(THREAD_GOAL_MCP_SERVER_NAME, "thread-goal-mcp", {
@@ -219726,7 +219942,7 @@ const getTelemetryIdentifier = gen$5(function* () {
 
 //#endregion
 //#region package.json
-var version$1 = "0.5.1";
+var version$1 = "0.5.3";
 
 //#endregion
 //#region src/telemetry/Layers/AnalyticsService.ts
@@ -703212,14 +703428,42 @@ const serveCommand = make$166("serve", commandFlags).pipe(withDescription$3("Run
 const serviceActionCommand = (action, description) => make$166(action).pipe(withDescription$3(description), withHandler(() => promise$5(async () => {
 	console.log(await controlService(action));
 })));
+const serviceInstallFlags = {
+	accountMode: choice$2("account", ["dedicated", "current"]).pipe(withDescription$4("OS account strategy: create/reuse a dedicated service user, or run as the invoking user."), withDefault$2("dedicated")),
+	account: string$10("user").pipe(withDescription$4("Override the OS username. Dedicated mode creates it when missing; current mode requires it to exist."), optional$3),
+	homeDir: string$10("home-dir").pipe(withDescription$4("HOME exposed to provider CLIs in the service process."), optional$3),
+	stateDir: string$10("state-dir").pipe(withDescription$4("ShioriCode service data directory."), optional$3),
+	workspaceDir: string$10("workspace-dir").pipe(withDescription$4("Default working directory for the service."), optional$3),
+	logPath: string$10("log-file").pipe(withDescription$4("Log file for stdout and stderr from the background service."), optional$3),
+	servicePath: string$10("service-path").pipe(withDescription$4("PATH used to discover provider CLIs such as codex, claude, and kimi in the service."), optional$3),
+	port: integer$4("port").pipe(withSchema(PortSchema), withDescription$4("Loopback port for the background service."), optional$3),
+	recoveryUsername: string$10("recovery-username").pipe(withDescription$4("Username for direct recovery login. Defaults to `recovery`."), optional$3),
+	recoveryPasswordFile: string$10("recovery-password-file").pipe(withDescription$4("Read the direct recovery password from a local file instead of generating one. The file must not be empty."), optional$3),
+	disableRecoveryLogin: boolean$8("no-recovery-login").pipe(withDescription$4("Disable direct username/password recovery login. ShioriCode Link remains GitHub-only."), withDefault$2(false))
+};
 const serviceCommand = make$166("service").pipe(withDescription$3("Install and control the OS background service."), withSubcommands([
-	make$166("install").pipe(withDescription$3("Install and start ShioriCode under a dedicated OS account."), withHandler(() => promise$5(async () => {
-		const result = await installService();
+	make$166("install", serviceInstallFlags).pipe(withDescription$3("Install and start ShioriCode as a dedicated or existing OS user."), withHandler((flags) => promise$5(async () => {
+		const result = await installService({
+			accountMode: flags.accountMode,
+			account: getOrUndefined$3(flags.account),
+			homeDir: getOrUndefined$3(flags.homeDir),
+			stateDir: getOrUndefined$3(flags.stateDir),
+			workspaceDir: getOrUndefined$3(flags.workspaceDir),
+			logPath: getOrUndefined$3(flags.logPath),
+			servicePath: getOrUndefined$3(flags.servicePath),
+			port: getOrUndefined$3(flags.port),
+			recoveryUsername: getOrUndefined$3(flags.recoveryUsername),
+			recoveryPasswordFile: getOrUndefined$3(flags.recoveryPasswordFile),
+			disableRecoveryLogin: flags.disableRecoveryLogin
+		});
 		console.log("ShioriCode service installed and started.\n");
 		console.log(serviceSummary(result.layout));
-		console.log("\nLocal recovery credentials (store these securely):");
-		console.log(`Username: ${result.recoveryUsername}`);
-		console.log(`Password: ${result.recoveryPassword}`);
+		console.log("\nLocal recovery login:");
+		if (result.recoveryUsername === null || result.recoveryPassword === null) console.log("Disabled. Hosted access uses GitHub through ShioriCode Link.");
+		else {
+			console.log(`Username: ${result.recoveryUsername}`);
+			console.log(result.recoveryPasswordGenerated ? `Generated password: ${result.recoveryPassword}\nStore it securely; it is shown once.` : "Password: loaded from --recovery-password-file (not echoed)");
+		}
 		console.log("\nNext: shioricode link connect");
 	}))),
 	serviceActionCommand("start", "Start the ShioriCode service."),