@p4code/cli 0.0.37 → 0.0.39

package/dist/bin.mjs

@@ -54,6 +54,9 @@ import * as Exit from "effect/Exit";
 import * as SchemaGetter from "effect/SchemaGetter";
 import * as Config from "effect/Config";
 import * as NodeReadline from "node:readline";
+import * as Scope from "effect/Scope";
+import * as ChildProcess$1 from "effect/unstable/process/ChildProcess";
+import * as ChildProcessSpawner$1 from "effect/unstable/process/ChildProcessSpawner";
 import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
 import * as Clock from "effect/Clock";
 import * as Deferred from "effect/Deferred";
@@ -63,9 +66,6 @@ import { cast, dual } from "effect/Function";
 import Mime from "@effect/platform-node/Mime";
 import * as Arr from "effect/Array";
 import * as Cache from "effect/Cache";
-import * as Scope from "effect/Scope";
-import * as ChildProcess$1 from "effect/unstable/process/ChildProcess";
-import * as ChildProcessSpawner$1 from "effect/unstable/process/ChildProcessSpawner";
 import * as Semaphore from "effect/Semaphore";
 import * as Equal from "effect/Equal";
 import * as HttpClient$1 from "effect/unstable/http/HttpClient";
@@ -232,7 +232,7 @@ const make$67 = () => {
 const layer$62 = Layer.sync(NetService, make$67);
 //#endregion
 //#region package.json
-var version = "0.0.37";
+var version = "0.0.39";
 //#endregion
 //#region src/config.ts
 /**
@@ -10840,7 +10840,7 @@ Layer.effectDiscard(runMigrations());
 //#region src/persistence/Layers/Sqlite.ts
 const defaultSqliteClientLoaders = {
 	bun: () => import("@effect/sql-sqlite-bun/SqliteClient"),
-	node: () => import("./NodeSqliteClient-BUlNQAY0.mjs")
+	node: () => import("./NodeSqliteClient-Dq296EBh.mjs")
 };
 const makeRuntimeSqliteLayer = Effect.fn("makeRuntimeSqliteLayer")(function* (config) {
 	const runtime = process.versions.bun !== void 0 ? "bun" : "node";
@@ -12035,6 +12035,422 @@ const sessionCommand = Command.make("session").pipe(Command.withDescription("Man
 ]));
 const authCommand = Command.make("auth").pipe(Command.withDescription("Manage the local auth control plane for headless deployments."), Command.withSubcommands([pairingCommand, sessionCommand]));
 //#endregion
+//#region src/stream/collectUint8StreamText.ts
+const collectUint8StreamText = (input) => {
+	const maxBytes = input.maxBytes ?? Number.POSITIVE_INFINITY;
+	const truncatedMarker = input.truncatedMarker ?? "";
+	return input.stream.pipe(Stream.runFold(() => ({
+		chunks: [],
+		bytes: 0,
+		truncated: false
+	}), (state, chunk) => {
+		if (state.truncated) return state;
+		const remainingBytes = maxBytes - state.bytes;
+		if (remainingBytes <= 0) return {
+			...state,
+			truncated: true
+		};
+		const nextChunk = chunk.byteLength > remainingBytes ? chunk.slice(0, remainingBytes) : chunk;
+		state.chunks.push(nextChunk);
+		const bytes = state.bytes + nextChunk.byteLength;
+		const truncated = chunk.byteLength > remainingBytes;
+		return {
+			chunks: state.chunks,
+			bytes,
+			truncated
+		};
+	}), Effect.map((state) => {
+		const text = Buffer.concat(state.chunks, state.bytes).toString("utf8");
+		return {
+			text: state.truncated && truncatedMarker.length > 0 ? `${text}${truncatedMarker}` : text,
+			bytes: state.bytes,
+			truncated: state.truncated
+		};
+	}));
+};
+//#endregion
+//#region src/processRunner.ts
+const ProcessInvocationFields = {
+	command: Schema$1.String,
+	argumentCount: Schema$1.Number,
+	cwd: Schema$1.optional(Schema$1.String),
+	spawnCwd: Schema$1.optional(Schema$1.String)
+};
+const formatProcessInvocation = (input) => {
+	const executionCwd = input.spawnCwd ?? input.cwd;
+	return executionCwd === void 0 ? `'${input.command}'` : `'${input.command}' in '${executionCwd}'`;
+};
+var ProcessSpawnError = class extends Schema$1.TaggedErrorClass()("ProcessSpawnError", {
+	...ProcessInvocationFields,
+	resolvedCommand: Schema$1.optional(Schema$1.String),
+	resolvedArgumentCount: Schema$1.optional(Schema$1.Number),
+	shell: Schema$1.optional(Schema$1.Boolean),
+	cause: Schema$1.Defect()
+}) {
+	get message() {
+		return `Failed to spawn process ${formatProcessInvocation(this)}`;
+	}
+};
+var ProcessStdinError = class extends Schema$1.TaggedErrorClass()("ProcessStdinError", {
+	...ProcessInvocationFields,
+	stdinBytes: Schema$1.Number,
+	cause: Schema$1.Defect()
+}) {
+	get message() {
+		return `Failed to write stdin for process ${formatProcessInvocation(this)}`;
+	}
+};
+var ProcessOutputLimitError = class extends Schema$1.TaggedErrorClass()("ProcessOutputLimitError", {
+	...ProcessInvocationFields,
+	stream: Schema$1.Literals(["stdout", "stderr"]),
+	maxBytes: Schema$1.Number,
+	observedBytes: Schema$1.Number
+}) {
+	get message() {
+		return `Process ${formatProcessInvocation(this)} ${this.stream} produced ${this.observedBytes} bytes, exceeding the ${this.maxBytes} byte limit`;
+	}
+};
+var ProcessReadError = class extends Schema$1.TaggedErrorClass()("ProcessReadError", {
+	...ProcessInvocationFields,
+	stream: Schema$1.Literals([
+		"stdout",
+		"stderr",
+		"exitCode"
+	]),
+	cause: Schema$1.Defect()
+}) {
+	get message() {
+		return `Failed to read ${this.stream} for process ${formatProcessInvocation(this)}`;
+	}
+};
+var ProcessTimeoutError = class extends Schema$1.TaggedErrorClass()("ProcessTimeoutError", {
+	...ProcessInvocationFields,
+	timeoutMs: Schema$1.Number
+}) {
+	get message() {
+		return `Process ${formatProcessInvocation(this)} timed out after ${this.timeoutMs}ms`;
+	}
+};
+Schema$1.Union([
+	ProcessSpawnError,
+	ProcessStdinError,
+	ProcessOutputLimitError,
+	ProcessReadError,
+	ProcessTimeoutError
+]);
+var ProcessRunner = class extends Context.Service()("@p4code/cli/processRunner") {};
+const DEFAULT_TIMEOUT = "60 seconds";
+const DEFAULT_MAX_OUTPUT_BYTES$2 = 8 * 1024 * 1024;
+const WINDOWS_COMMAND_NOT_FOUND_PATTERNS = [
+	/is not recognized as an internal or external command/i,
+	/n.o . reconhecido como um comando interno/i,
+	/non . riconosciuto come comando interno o esterno/i,
+	/n.est pas reconnu en tant que commande interne/i,
+	/no se reconoce como un comando interno o externo/i,
+	/wird nicht als interner oder externer befehl/i
+];
+function hasWindowsCommandNotFoundMessage(output) {
+	return WINDOWS_COMMAND_NOT_FOUND_PATTERNS.some((pattern) => pattern.test(output));
+}
+const isWindowsCommandNotFound = Effect.fn("processRunner.isWindowsCommandNotFound")(function* (code, stderr) {
+	if ((yield* HostProcessPlatform) !== "win32") return false;
+	if (code === 9009) return true;
+	return hasWindowsCommandNotFoundMessage(stderr);
+});
+const collectText = Effect.fn("processRunner.collectText")(function* (input) {
+	const stream = input.stream.pipe(Stream.mapError((cause) => new ProcessReadError({
+		command: input.command,
+		argumentCount: input.args.length,
+		cwd: input.cwd,
+		spawnCwd: input.spawnCwd,
+		stream: input.streamName,
+		cause
+	})));
+	if (input.outputMode === "truncate") return yield* collectUint8StreamText({
+		stream,
+		maxBytes: input.maxOutputBytes,
+		truncatedMarker: input.truncatedMarker
+	});
+	return yield* stream.pipe(Stream.runFoldEffect(() => ({
+		chunks: [],
+		bytes: 0
+	}), (state, chunk) => {
+		const remainingBytes = input.maxOutputBytes - state.bytes;
+		if (chunk.byteLength > remainingBytes) return Effect.fail(new ProcessOutputLimitError({
+			command: input.command,
+			argumentCount: input.args.length,
+			cwd: input.cwd,
+			spawnCwd: input.spawnCwd,
+			stream: input.streamName,
+			maxBytes: input.maxOutputBytes,
+			observedBytes: state.bytes + chunk.byteLength
+		}));
+		state.chunks.push(chunk);
+		return Effect.succeed({
+			chunks: state.chunks,
+			bytes: state.bytes + chunk.byteLength
+		});
+	}), Effect.map((state) => ({
+		text: Buffer.concat(state.chunks, state.bytes).toString("utf8"),
+		bytes: state.bytes,
+		truncated: false
+	})));
+});
+function finalizeRunProcess(effect, input) {
+	const timeout = Duration.fromInputUnsafe(input.timeout ?? DEFAULT_TIMEOUT);
+	const timeoutBehavior = input.timeoutBehavior ?? "error";
+	return effect.pipe(Effect.scoped, Effect.timeoutOption(timeout), Effect.flatMap((result) => {
+		if (Option.isSome(result)) return Effect.succeed(result.value);
+		if (timeoutBehavior === "timedOutResult") return Effect.succeed({
+			stdout: "",
+			stderr: "",
+			code: null,
+			timedOut: true,
+			stdoutTruncated: false,
+			stderrTruncated: false
+		});
+		return Effect.fail(new ProcessTimeoutError({
+			command: input.command,
+			argumentCount: input.args.length,
+			cwd: input.cwd,
+			spawnCwd: input.spawnCwd,
+			timeoutMs: Duration.toMillis(timeout)
+		}));
+	}));
+}
+const runProcessCore = Effect.fn("processRunner.runProcessCore")(function* (spawner, input) {
+	const maxOutputBytes = input.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES$2;
+	const outputMode = input.outputMode ?? "error";
+	const truncatedMarker = input.truncatedMarker ?? "";
+	const extendEnv = input.env !== void 0;
+	const spawnCommand = yield* resolveSpawnCommand(input.command, input.args, input.env === void 0 ? {} : {
+		env: input.env,
+		extendEnv
+	});
+	const child = yield* spawner.spawn(ChildProcess$1.make(spawnCommand.command, spawnCommand.args, {
+		...input.spawnCwd ?? input.cwd ? { cwd: input.spawnCwd ?? input.cwd } : {},
+		...input.env !== void 0 ? {
+			env: input.env,
+			extendEnv
+		} : {},
+		shell: spawnCommand.shell
+	})).pipe(Effect.mapError((cause) => new ProcessSpawnError({
+		command: input.command,
+		argumentCount: input.args.length,
+		cwd: input.cwd,
+		spawnCwd: input.spawnCwd,
+		resolvedCommand: spawnCommand.command,
+		resolvedArgumentCount: spawnCommand.args.length,
+		shell: spawnCommand.shell,
+		cause
+	})));
+	const stdin = input.stdin;
+	const writeStdin = stdin === void 0 ? Effect.void : Stream.run(Stream.encodeText(Stream.make(stdin)), child.stdin).pipe(Effect.mapError((cause) => new ProcessStdinError({
+		command: input.command,
+		argumentCount: input.args.length,
+		cwd: input.cwd,
+		spawnCwd: input.spawnCwd,
+		stdinBytes: Buffer.byteLength(stdin),
+		cause
+	})));
+	const [stdout, stderr] = yield* Effect.all([
+		collectText({
+			command: input.command,
+			args: input.args,
+			cwd: input.cwd,
+			spawnCwd: input.spawnCwd,
+			streamName: "stdout",
+			stream: child.stdout,
+			maxOutputBytes,
+			outputMode,
+			truncatedMarker
+		}),
+		collectText({
+			command: input.command,
+			args: input.args,
+			cwd: input.cwd,
+			spawnCwd: input.spawnCwd,
+			streamName: "stderr",
+			stream: child.stderr,
+			maxOutputBytes,
+			outputMode,
+			truncatedMarker
+		}),
+		writeStdin
+	], { concurrency: "unbounded" });
+	const exitCode = yield* child.exitCode.pipe(Effect.mapError((cause) => new ProcessReadError({
+		command: input.command,
+		argumentCount: input.args.length,
+		cwd: input.cwd,
+		spawnCwd: input.spawnCwd,
+		stream: "exitCode",
+		cause
+	})));
+	return {
+		stdout: stdout.text,
+		stderr: stderr.text,
+		code: exitCode,
+		timedOut: false,
+		stdoutTruncated: stdout.truncated,
+		stderrTruncated: stderr.truncated
+	};
+});
+const make$58 = Effect.fn("ProcessRunner.make")(function* () {
+	const spawner = yield* ChildProcessSpawner$1.ChildProcessSpawner;
+	const run = (input) => finalizeRunProcess(runProcessCore(spawner, input), input);
+	return ProcessRunner.of({ run });
+});
+const layer$53 = Layer.effect(ProcessRunner, make$58());
+//#endregion
+//#region src/cli/completions.ts
+/**
+* Installs the zsh completion script for the `p4` command.
+*
+* zsh ships `_perforce` with `#compdef p4 p4d`, so out of the box tabbing
+* through our subcommands prints "unhandled perforce command: …" from its
+* fallback message. `compinit` resolves duplicate `#compdef` claims by fpath
+* order — first match wins — and `_perforce` lives in the *last* fpath entry
+* (`/usr/share/zsh/<ver>/functions`). Writing our own `_p4` into any earlier
+* directory therefore replaces it outright, with no shell-config edit.
+*/
+const COMPLETION_FILE = "_p4";
+const GENERATE_TIMEOUT_MS = 1e4;
+/**
+* Ordered by how reliably zsh actually scans them.
+*
+* oh-my-zsh comes first and is created on demand: it adds
+* `custom/completions` to fpath unconditionally, it is user-owned so
+* `compinit -i` never skips it as insecure, and it does not depend on a package
+* manager's prefix. The Homebrew and /usr/local directories are only used when
+* they already exist, and even then are not guaranteed to be on fpath —
+* `brew shellenv` contributes Homebrew's, and a plugin that rebuilds fpath can
+* drop it, which is exactly how a completion file lands somewhere zsh never
+* reads.
+*/
+function candidateDirectories(input) {
+	return [
+		{
+			dir: input.join(input.homeDir, ".oh-my-zsh", "custom", "completions"),
+			createWhenPresent: input.join(input.homeDir, ".oh-my-zsh")
+		},
+		{ dir: "/opt/homebrew/share/zsh/site-functions" },
+		{ dir: "/usr/local/share/zsh/site-functions" },
+		{
+			dir: input.join(input.homeDir, ".zfunc"),
+			requiresFpathEntry: true
+		}
+	];
+}
+/**
+* Asks the running CLI for its own completion script rather than rendering one
+* here, so the output cannot drift from what `--completions` produces.
+*/
+const generateZshCompletionScript = Effect.fn("cli.completions.generate")(function* () {
+	const runner = yield* ProcessRunner;
+	const execPath = yield* HostProcessExecutablePath;
+	const entryPath = (yield* HostProcessArguments)[1] ?? "";
+	if (entryPath === "") return null;
+	const result = yield* runner.run({
+		command: execPath,
+		args: [
+			entryPath,
+			"--completions",
+			"zsh"
+		],
+		timeout: GENERATE_TIMEOUT_MS
+	});
+	if (result.code !== 0) return null;
+	const script = result.stdout.trim();
+	return script.length === 0 ? null : `${script}\n`;
+});
+/**
+* Best-effort: returns null when completions are not applicable (Windows, no
+* writable directory) rather than failing the command that asked for them.
+* Installing completions is never the reason an install should fail.
+*/
+const installZshCompletion = Effect.fn("cli.completions.install")(function* () {
+	if ((yield* HostProcessPlatform) === "win32") return null;
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const homeDir = (yield* HostProcessEnvironment).HOME ?? "";
+	if (homeDir === "") return null;
+	const script = yield* generateZshCompletionScript();
+	if (script === null) return null;
+	for (const candidate of candidateDirectories({
+		homeDir,
+		join: path.join
+	})) {
+		if (candidate.requiresFpathEntry === true || candidate.createWhenPresent !== void 0 && (yield* fs.exists(candidate.createWhenPresent).pipe(Effect.orElseSucceed(() => false)))) {
+			if (!(yield* fs.makeDirectory(candidate.dir, { recursive: true }).pipe(Effect.as(true), Effect.orElseSucceed(() => false)))) continue;
+		} else if (!(yield* fs.exists(candidate.dir).pipe(Effect.orElseSucceed(() => false)))) continue;
+		const target = path.join(candidate.dir, COMPLETION_FILE);
+		if (!(yield* fs.writeFileString(target, script).pipe(Effect.as(true), Effect.orElseSucceed(() => false)))) continue;
+		return {
+			path: target,
+			requiresFpathEntry: candidate.requiresFpathEntry === true
+		};
+	}
+	return null;
+});
+const HINT_MARKER_FILE = "completions-hint";
+const HINT_INTERVAL_MS = 1440 * 60 * 1e3;
+const COMPLETIONS_HINT = "Shell completions are not installed, so tab completion shows Perforce's. Run `p4 completions install`.";
+/**
+* A hint when no `_p4` is on the fpath, at most once a day.
+*
+* A stat of a few directories, deliberately not the install itself: generating
+* the script spawns a subprocess, which is far too much to do on every command
+* just in case. Throttled through a marker file so an unactioned hint does not
+* become noise on every invocation.
+*/
+const resolveMissingCompletionsHint = Effect.fn("cli.completions.hint")(function* (input) {
+	if ((yield* HostProcessPlatform) === "win32") return null;
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const homeDir = (yield* HostProcessEnvironment).HOME ?? "";
+	if (homeDir === "") return null;
+	for (const candidate of candidateDirectories({
+		homeDir,
+		join: path.join
+	})) if (yield* fs.exists(path.join(candidate.dir, COMPLETION_FILE)).pipe(Effect.orElseSucceed(() => false))) return null;
+	const markerPath = path.join(input.stateDir, HINT_MARKER_FILE);
+	const marker = yield* fs.stat(markerPath).pipe(Effect.asSome, Effect.orElseSucceed(() => null));
+	const nowMs = DateTime.toEpochMillis(yield* DateTime.now);
+	if (marker !== null && Option.isSome(marker)) {
+		const mtime = marker.value.mtime;
+		if (Option.isSome(mtime) && nowMs - mtime.value.getTime() < HINT_INTERVAL_MS) return null;
+	}
+	yield* fs.makeDirectory(input.stateDir, { recursive: true }).pipe(Effect.ignore);
+	yield* fs.writeFileString(markerPath, "").pipe(Effect.ignore);
+	return COMPLETIONS_HINT;
+});
+/**
+* Standalone so completions never depend on the service. A laptop that only
+* runs clients has no service to install, and a host whose `service install`
+* fails still deserves working completions.
+*/
+const completionsCommand = Command.make("completions").pipe(Command.withDescription("Manage shell completions for the p4 command."), Command.withSubcommands([Command.make("install").pipe(Command.withDescription("Install zsh completions, replacing the Perforce completion that claims `p4`."), Command.withHandler(() => Effect.gen(function* () {
+	const install = yield* installZshCompletion();
+	if (install === null) {
+		yield* Console.error([
+			"Could not install completions automatically.",
+			"Write them yourself with:",
+			"  p4 --completions zsh > <a directory on your fpath>/_p4"
+		].join("\n"));
+		return;
+	}
+	yield* Console.log(formatZshCompletionInstall(install));
+}).pipe(Effect.provide(layer$53))))]));
+function formatZshCompletionInstall(install) {
+	const installed = `Installed zsh completions at ${install.path}.`;
+	if (!install.requiresFpathEntry) return `${installed} Open a new shell to use them.`;
+	return [
+		installed,
+		`Add this to ~/.zshrc before compinit runs, then open a new shell:`,
+		`  fpath=(${install.path.replace(/\/[^/]+$/u, "")} $fpath)`
+	].join("\n");
+}
+//#endregion
 //#region src/orchestration/Services/OrchestrationEngine.ts
 /**
 * OrchestrationEngineService - Service tag for orchestration engine access.
@@ -16548,273 +16964,6 @@ function mergeGitStatusParts(local, remote) {
 	};
 }
 //#endregion
-//#region src/stream/collectUint8StreamText.ts
-const collectUint8StreamText = (input) => {
-	const maxBytes = input.maxBytes ?? Number.POSITIVE_INFINITY;
-	const truncatedMarker = input.truncatedMarker ?? "";
-	return input.stream.pipe(Stream.runFold(() => ({
-		chunks: [],
-		bytes: 0,
-		truncated: false
-	}), (state, chunk) => {
-		if (state.truncated) return state;
-		const remainingBytes = maxBytes - state.bytes;
-		if (remainingBytes <= 0) return {
-			...state,
-			truncated: true
-		};
-		const nextChunk = chunk.byteLength > remainingBytes ? chunk.slice(0, remainingBytes) : chunk;
-		state.chunks.push(nextChunk);
-		const bytes = state.bytes + nextChunk.byteLength;
-		const truncated = chunk.byteLength > remainingBytes;
-		return {
-			chunks: state.chunks,
-			bytes,
-			truncated
-		};
-	}), Effect.map((state) => {
-		const text = Buffer.concat(state.chunks, state.bytes).toString("utf8");
-		return {
-			text: state.truncated && truncatedMarker.length > 0 ? `${text}${truncatedMarker}` : text,
-			bytes: state.bytes,
-			truncated: state.truncated
-		};
-	}));
-};
-//#endregion
-//#region src/processRunner.ts
-const ProcessInvocationFields = {
-	command: Schema$1.String,
-	argumentCount: Schema$1.Number,
-	cwd: Schema$1.optional(Schema$1.String),
-	spawnCwd: Schema$1.optional(Schema$1.String)
-};
-const formatProcessInvocation = (input) => {
-	const executionCwd = input.spawnCwd ?? input.cwd;
-	return executionCwd === void 0 ? `'${input.command}'` : `'${input.command}' in '${executionCwd}'`;
-};
-var ProcessSpawnError = class extends Schema$1.TaggedErrorClass()("ProcessSpawnError", {
-	...ProcessInvocationFields,
-	resolvedCommand: Schema$1.optional(Schema$1.String),
-	resolvedArgumentCount: Schema$1.optional(Schema$1.Number),
-	shell: Schema$1.optional(Schema$1.Boolean),
-	cause: Schema$1.Defect()
-}) {
-	get message() {
-		return `Failed to spawn process ${formatProcessInvocation(this)}`;
-	}
-};
-var ProcessStdinError = class extends Schema$1.TaggedErrorClass()("ProcessStdinError", {
-	...ProcessInvocationFields,
-	stdinBytes: Schema$1.Number,
-	cause: Schema$1.Defect()
-}) {
-	get message() {
-		return `Failed to write stdin for process ${formatProcessInvocation(this)}`;
-	}
-};
-var ProcessOutputLimitError = class extends Schema$1.TaggedErrorClass()("ProcessOutputLimitError", {
-	...ProcessInvocationFields,
-	stream: Schema$1.Literals(["stdout", "stderr"]),
-	maxBytes: Schema$1.Number,
-	observedBytes: Schema$1.Number
-}) {
-	get message() {
-		return `Process ${formatProcessInvocation(this)} ${this.stream} produced ${this.observedBytes} bytes, exceeding the ${this.maxBytes} byte limit`;
-	}
-};
-var ProcessReadError = class extends Schema$1.TaggedErrorClass()("ProcessReadError", {
-	...ProcessInvocationFields,
-	stream: Schema$1.Literals([
-		"stdout",
-		"stderr",
-		"exitCode"
-	]),
-	cause: Schema$1.Defect()
-}) {
-	get message() {
-		return `Failed to read ${this.stream} for process ${formatProcessInvocation(this)}`;
-	}
-};
-var ProcessTimeoutError = class extends Schema$1.TaggedErrorClass()("ProcessTimeoutError", {
-	...ProcessInvocationFields,
-	timeoutMs: Schema$1.Number
-}) {
-	get message() {
-		return `Process ${formatProcessInvocation(this)} timed out after ${this.timeoutMs}ms`;
-	}
-};
-Schema$1.Union([
-	ProcessSpawnError,
-	ProcessStdinError,
-	ProcessOutputLimitError,
-	ProcessReadError,
-	ProcessTimeoutError
-]);
-var ProcessRunner = class extends Context.Service()("@p4code/cli/processRunner") {};
-const DEFAULT_TIMEOUT = "60 seconds";
-const DEFAULT_MAX_OUTPUT_BYTES$2 = 8 * 1024 * 1024;
-const WINDOWS_COMMAND_NOT_FOUND_PATTERNS = [
-	/is not recognized as an internal or external command/i,
-	/n.o . reconhecido como um comando interno/i,
-	/non . riconosciuto come comando interno o esterno/i,
-	/n.est pas reconnu en tant que commande interne/i,
-	/no se reconoce como un comando interno o externo/i,
-	/wird nicht als interner oder externer befehl/i
-];
-function hasWindowsCommandNotFoundMessage(output) {
-	return WINDOWS_COMMAND_NOT_FOUND_PATTERNS.some((pattern) => pattern.test(output));
-}
-const isWindowsCommandNotFound = Effect.fn("processRunner.isWindowsCommandNotFound")(function* (code, stderr) {
-	if ((yield* HostProcessPlatform) !== "win32") return false;
-	if (code === 9009) return true;
-	return hasWindowsCommandNotFoundMessage(stderr);
-});
-const collectText = Effect.fn("processRunner.collectText")(function* (input) {
-	const stream = input.stream.pipe(Stream.mapError((cause) => new ProcessReadError({
-		command: input.command,
-		argumentCount: input.args.length,
-		cwd: input.cwd,
-		spawnCwd: input.spawnCwd,
-		stream: input.streamName,
-		cause
-	})));
-	if (input.outputMode === "truncate") return yield* collectUint8StreamText({
-		stream,
-		maxBytes: input.maxOutputBytes,
-		truncatedMarker: input.truncatedMarker
-	});
-	return yield* stream.pipe(Stream.runFoldEffect(() => ({
-		chunks: [],
-		bytes: 0
-	}), (state, chunk) => {
-		const remainingBytes = input.maxOutputBytes - state.bytes;
-		if (chunk.byteLength > remainingBytes) return Effect.fail(new ProcessOutputLimitError({
-			command: input.command,
-			argumentCount: input.args.length,
-			cwd: input.cwd,
-			spawnCwd: input.spawnCwd,
-			stream: input.streamName,
-			maxBytes: input.maxOutputBytes,
-			observedBytes: state.bytes + chunk.byteLength
-		}));
-		state.chunks.push(chunk);
-		return Effect.succeed({
-			chunks: state.chunks,
-			bytes: state.bytes + chunk.byteLength
-		});
-	}), Effect.map((state) => ({
-		text: Buffer.concat(state.chunks, state.bytes).toString("utf8"),
-		bytes: state.bytes,
-		truncated: false
-	})));
-});
-function finalizeRunProcess(effect, input) {
-	const timeout = Duration.fromInputUnsafe(input.timeout ?? DEFAULT_TIMEOUT);
-	const timeoutBehavior = input.timeoutBehavior ?? "error";
-	return effect.pipe(Effect.scoped, Effect.timeoutOption(timeout), Effect.flatMap((result) => {
-		if (Option.isSome(result)) return Effect.succeed(result.value);
-		if (timeoutBehavior === "timedOutResult") return Effect.succeed({
-			stdout: "",
-			stderr: "",
-			code: null,
-			timedOut: true,
-			stdoutTruncated: false,
-			stderrTruncated: false
-		});
-		return Effect.fail(new ProcessTimeoutError({
-			command: input.command,
-			argumentCount: input.args.length,
-			cwd: input.cwd,
-			spawnCwd: input.spawnCwd,
-			timeoutMs: Duration.toMillis(timeout)
-		}));
-	}));
-}
-const runProcessCore = Effect.fn("processRunner.runProcessCore")(function* (spawner, input) {
-	const maxOutputBytes = input.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES$2;
-	const outputMode = input.outputMode ?? "error";
-	const truncatedMarker = input.truncatedMarker ?? "";
-	const extendEnv = input.env !== void 0;
-	const spawnCommand = yield* resolveSpawnCommand(input.command, input.args, input.env === void 0 ? {} : {
-		env: input.env,
-		extendEnv
-	});
-	const child = yield* spawner.spawn(ChildProcess$1.make(spawnCommand.command, spawnCommand.args, {
-		...input.spawnCwd ?? input.cwd ? { cwd: input.spawnCwd ?? input.cwd } : {},
-		...input.env !== void 0 ? {
-			env: input.env,
-			extendEnv
-		} : {},
-		shell: spawnCommand.shell
-	})).pipe(Effect.mapError((cause) => new ProcessSpawnError({
-		command: input.command,
-		argumentCount: input.args.length,
-		cwd: input.cwd,
-		spawnCwd: input.spawnCwd,
-		resolvedCommand: spawnCommand.command,
-		resolvedArgumentCount: spawnCommand.args.length,
-		shell: spawnCommand.shell,
-		cause
-	})));
-	const stdin = input.stdin;
-	const writeStdin = stdin === void 0 ? Effect.void : Stream.run(Stream.encodeText(Stream.make(stdin)), child.stdin).pipe(Effect.mapError((cause) => new ProcessStdinError({
-		command: input.command,
-		argumentCount: input.args.length,
-		cwd: input.cwd,
-		spawnCwd: input.spawnCwd,
-		stdinBytes: Buffer.byteLength(stdin),
-		cause
-	})));
-	const [stdout, stderr] = yield* Effect.all([
-		collectText({
-			command: input.command,
-			args: input.args,
-			cwd: input.cwd,
-			spawnCwd: input.spawnCwd,
-			streamName: "stdout",
-			stream: child.stdout,
-			maxOutputBytes,
-			outputMode,
-			truncatedMarker
-		}),
-		collectText({
-			command: input.command,
-			args: input.args,
-			cwd: input.cwd,
-			spawnCwd: input.spawnCwd,
-			streamName: "stderr",
-			stream: child.stderr,
-			maxOutputBytes,
-			outputMode,
-			truncatedMarker
-		}),
-		writeStdin
-	], { concurrency: "unbounded" });
-	const exitCode = yield* child.exitCode.pipe(Effect.mapError((cause) => new ProcessReadError({
-		command: input.command,
-		argumentCount: input.args.length,
-		cwd: input.cwd,
-		spawnCwd: input.spawnCwd,
-		stream: "exitCode",
-		cause
-	})));
-	return {
-		stdout: stdout.text,
-		stderr: stderr.text,
-		code: exitCode,
-		timedOut: false,
-		stdoutTruncated: stdout.truncated,
-		stderrTruncated: stderr.truncated
-	};
-});
-const make$58 = Effect.fn("ProcessRunner.make")(function* () {
-	const spawner = yield* ChildProcessSpawner$1.ChildProcessSpawner;
-	const run = (input) => finalizeRunProcess(runProcessCore(spawner, input), input);
-	return ProcessRunner.of({ run });
-});
-const layer$53 = Layer.effect(ProcessRunner, make$58());
-//#endregion
 //#region src/project/RepositoryIdentityResolver.ts
 const DEFAULT_REPOSITORY_IDENTITY_CACHE_CAPACITY = 512;
 const DEFAULT_POSITIVE_CACHE_TTL = Duration.minutes(1);
@@ -78248,104 +78397,6 @@ const serveCommand = Command.make("serve", { ...sharedServerCommandFlags }).pipe
 	forceAutoBootstrapProjectFromCwd: false
 })));
 //#endregion
-//#region src/cli/completions.ts
-/**
-* Installs the zsh completion script for the `p4` command.
-*
-* zsh ships `_perforce` with `#compdef p4 p4d`, so out of the box tabbing
-* through our subcommands prints "unhandled perforce command: …" from its
-* fallback message. `compinit` resolves duplicate `#compdef` claims by fpath
-* order — first match wins — and `_perforce` lives in the *last* fpath entry
-* (`/usr/share/zsh/<ver>/functions`). Writing our own `_p4` into any earlier
-* directory therefore replaces it outright, with no shell-config edit.
-*/
-const COMPLETION_FILE = "_p4";
-const GENERATE_TIMEOUT_MS = 1e4;
-/**
-* Directories ahead of `/usr/share/zsh/*` in a default fpath, most specific
-* first. `~/.zfunc` is the fallback and is the only one needing an fpath line.
-*/
-function candidateDirectories(input) {
-	return [
-		{
-			dir: input.join(input.homeDir, ".oh-my-zsh", "custom", "completions"),
-			requiresFpathEntry: false
-		},
-		{
-			dir: "/opt/homebrew/share/zsh/site-functions",
-			requiresFpathEntry: false
-		},
-		{
-			dir: "/usr/local/share/zsh/site-functions",
-			requiresFpathEntry: false
-		},
-		{
-			dir: input.join(input.homeDir, ".zfunc"),
-			requiresFpathEntry: true
-		}
-	];
-}
-/**
-* Asks the running CLI for its own completion script rather than rendering one
-* here, so the output cannot drift from what `--completions` produces.
-*/
-const generateZshCompletionScript = Effect.fn("cli.completions.generate")(function* () {
-	const runner = yield* ProcessRunner;
-	const execPath = yield* HostProcessExecutablePath;
-	const entryPath = (yield* HostProcessArguments)[1] ?? "";
-	if (entryPath === "") return null;
-	const result = yield* runner.run({
-		command: execPath,
-		args: [
-			entryPath,
-			"--completions",
-			"zsh"
-		],
-		timeout: GENERATE_TIMEOUT_MS
-	});
-	if (result.code !== 0) return null;
-	const script = result.stdout.trim();
-	return script.length === 0 ? null : `${script}\n`;
-});
-/**
-* Best-effort: returns null when completions are not applicable (Windows, no
-* writable directory) rather than failing the command that asked for them.
-* Installing completions is never the reason an install should fail.
-*/
-const installZshCompletion = Effect.fn("cli.completions.install")(function* () {
-	if ((yield* HostProcessPlatform) === "win32") return null;
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const homeDir = (yield* HostProcessEnvironment).HOME ?? "";
-	if (homeDir === "") return null;
-	const script = yield* generateZshCompletionScript();
-	if (script === null) return null;
-	for (const candidate of candidateDirectories({
-		homeDir,
-		join: path.join
-	})) {
-		if (candidate.requiresFpathEntry) {
-			if (!(yield* fs.makeDirectory(candidate.dir, { recursive: true }).pipe(Effect.as(true), Effect.orElseSucceed(() => false)))) continue;
-		} else if (!(yield* fs.exists(candidate.dir).pipe(Effect.orElseSucceed(() => false)))) continue;
-		const target = path.join(candidate.dir, COMPLETION_FILE);
-		if (!(yield* fs.writeFileString(target, script).pipe(Effect.as(true), Effect.orElseSucceed(() => false)))) continue;
-		return {
-			path: target,
-			requiresFpathEntry: candidate.requiresFpathEntry
-		};
-	}
-	return null;
-});
-function formatZshCompletionInstall(install) {
-	const installed = `Installed zsh completions at ${install.path}.`;
-	if (!install.requiresFpathEntry) return `${installed} Open a new shell to use them.`;
-	return [
-		installed,
-		`Add this to ~/.zshrc before compinit runs, then open a new shell:`,
-		`  fpath=(${install.path.replace(/\/[^/]+$/u, "")} $fpath)`
-	].join("\n");
-}
-//#endregion
 //#region src/cli/service.ts
 const isBootServiceCommandError = Schema$1.is(BootServiceCommandError);
 const bootServiceLayer = (config) => layer$46({
@@ -78400,10 +78451,21 @@ const runServiceCommand = Effect.fn("cli.service.run")(function* (flags, run) {
 	if (baseDirNotice !== null) yield* Console.error(baseDirNotice);
 	return yield* run.pipe(Effect.tapError((error) => isBootServiceCommandError(error) ? BootService.pipe(Effect.flatMap((service) => Console.error(`Details: ${service.logPath}`))) : Effect.void), Effect.provide(bootServiceLayer(config)), Effect.provide(layer$53));
 });
+/**
+* Runs on every `service install` and `service update`, including the
+* already-current paths. Gating it on "the unit changed" meant a host whose
+* service was already installed — the common case after the first setup — never
+* got completions at all.
+*/
+const reportZshCompletionInstall = Effect.gen(function* () {
+	const completion = yield* installZshCompletion().pipe(Effect.orElseSucceed(() => null));
+	if (completion !== null) yield* Console.log(formatZshCompletionInstall(completion));
+});
 const serviceInstallCommand = Command.make("install", projectLocationFlags).pipe(Command.withDescription("Install P4Code as a background service for this user."), Command.withHandler((flags) => runServiceCommand(flags, Effect.gen(function* () {
 	const result = yield* reconcileService();
 	if (!result.changed) {
 		yield* Console.log(`P4Code service is already installed with @p4code/cli@${version}.`);
+		yield* reportZshCompletionInstall;
 		return;
 	}
 	yield* Console.log(formatReconcileSuccess({
@@ -78412,14 +78474,14 @@ const serviceInstallCommand = Command.make("install", projectLocationFlags).pipe
 		cliVersion: version,
 		platform: yield* HostProcessPlatform
 	}));
-	const completion = yield* installZshCompletion().pipe(Effect.orElseSucceed(() => null));
-	if (completion !== null) yield* Console.log(formatZshCompletionInstall(completion));
+	yield* reportZshCompletionInstall;
 }))));
 const serviceUpdateCommand = Command.make("update", projectLocationFlags).pipe(Command.withDescription("Update or repair the background service so it runs this CLI build, then restart it."), Command.withHandler((flags) => runServiceCommand(flags, Effect.gen(function* () {
 	const result = yield* reconcileService();
 	if (!result.changed) {
 		yield* (yield* BootService).restart;
 		yield* Console.log(`Restarted the P4Code service on @p4code/cli@${version}.`);
+		yield* reportZshCompletionInstall;
 		return;
 	}
 	yield* Console.log(formatReconcileSuccess({
@@ -78428,6 +78490,7 @@ const serviceUpdateCommand = Command.make("update", projectLocationFlags).pipe(C
 		cliVersion: version,
 		platform: yield* HostProcessPlatform
 	}));
+	yield* reportZshCompletionInstall;
 }))));
 const serviceUninstallCommand = Command.make("uninstall", projectLocationFlags).pipe(Command.withDescription("Stop and remove the P4Code background service."), Command.withHandler((flags) => runServiceCommand(flags, Effect.gen(function* () {
 	const removed = yield* (yield* BootService).uninstall;
@@ -78476,11 +78539,14 @@ const reportUpdateAvailable = Effect.gen(function* () {
 		stateDir: paths.stateDir
 	});
 	if (reminder !== null) yield* Console.error(reminder);
+	const completionsHint = yield* resolveMissingCompletionsHint({ stateDir: paths.stateDir });
+	if (completionsHint !== null) yield* Console.error(completionsHint);
 }).pipe(Effect.ignore);
 const makeCli = () => Command.make("p4", { ...sharedServerCommandFlags }).pipe(Command.withDescription("Run the P4Code server."), Command.withHandler((flags) => runServerCommand(flags)), Command.withSubcommands([
 	startCommand,
 	serveCommand,
 	authCommand,
+	completionsCommand,
 	projectCommand,
 	serviceCommand
 ]));