@prover-coder-ai/docker-git 1.0.46 → 1.0.48

package/dist/src/docker-git/main.js

@@ -1426,7 +1426,15 @@ var findDockerGitConfigPaths = (fs, path, rootDir) => Effect.gen(function* (_) {
 //#endregion
 //#region ../lib/src/usecases/projects-core.ts
 var sshOptions = "-tt -Y -o LogLevel=ERROR -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null";
-var buildSshCommand = (config, sshKey) => sshKey === null ? `ssh ${sshOptions} -p ${config.sshPort} ${config.sshUser}@localhost` : `ssh -i ${sshKey} ${sshOptions} -p ${config.sshPort} ${config.sshUser}@localhost`;
+var buildSshCommand = (config, sshKey, ipAddress) => {
+	const host = ipAddress ?? "localhost";
+	const port = ipAddress ? 22 : config.sshPort;
+	return sshKey === null ? `ssh ${sshOptions} -p ${port} ${config.sshUser}@${host}` : `ssh -i ${sshKey} ${sshOptions} -p ${port} ${config.sshUser}@${host}`;
+};
+var getContainerIpIfInsideContainer = (fs, projectDir, containerName) => Effect.gen(function* (_) {
+	if (!(yield* _(fs.exists("/.dockerenv")))) return;
+	return yield* _(runDockerInspectContainerIp(projectDir, containerName).pipe(Effect.orElse(() => Effect.succeed("")), Effect.map((ip) => ip.length > 0 ? ip : void 0)));
+});
 var loadProjectBase = (configPath) => Effect.gen(function* (_) {
 	const { fs, path, resolved } = yield* _(resolveBaseDir(configPath));
 	const projectDir = path.dirname(resolved);
@@ -1440,12 +1448,14 @@ var loadProjectBase = (configPath) => Effect.gen(function* (_) {
 var findProjectConfigPaths = (projectsRoot) => withFsPathContext(({ fs, path }) => findDockerGitConfigPaths(fs, path, path.resolve(projectsRoot)));
 var loadProjectSummary = (configPath, sshKey) => Effect.gen(function* (_) {
 	const { config, fs, path, projectDir } = yield* _(loadProjectBase(configPath));
+	const ipAddress = yield* _(getContainerIpIfInsideContainer(fs, projectDir, config.template.containerName));
 	const resolvedAuthorizedKeys = resolveAuthorizedKeysPath(path, projectDir, config.template.authorizedKeysPath);
 	const authExists = yield* _(fs.exists(resolvedAuthorizedKeys));
 	return {
 		projectDir,
 		config,
-		sshCommand: buildSshCommand(config.template, sshKey),
+		sshCommand: buildSshCommand(config.template, sshKey, ipAddress),
+		ipAddress,
 		authorizedKeysPath: resolvedAuthorizedKeys,
 		authorizedKeysExists: authExists
 	};
@@ -1466,9 +1476,10 @@ var formatDisplayName = (repoUrl) => {
 var loadProjectItem = (configPath, sshKey) => Effect.gen(function* (_) {
 	const { config, fs, path, projectDir } = yield* _(loadProjectBase(configPath));
 	const template = config.template;
+	const ipAddress = yield* _(getContainerIpIfInsideContainer(fs, projectDir, template.containerName));
 	const resolvedAuthorizedKeys = resolveAuthorizedKeysPath(path, projectDir, template.authorizedKeysPath);
 	const authExists = yield* _(fs.exists(resolvedAuthorizedKeys));
-	const sshCommand = buildSshCommand(template, sshKey);
+	const sshCommand = buildSshCommand(template, sshKey, ipAddress);
 	return {
 		projectDir,
 		displayName: formatDisplayName(template.repoUrl),
@@ -1480,6 +1491,7 @@ var loadProjectItem = (configPath, sshKey) => Effect.gen(function* (_) {
 		sshPort: template.sshPort,
 		targetDir: template.targetDir,
 		sshCommand,
+		ipAddress,
 		sshKeyPath: sshKey,
 		authorizedKeysPath: resolvedAuthorizedKeys,
 		authorizedKeysExists: authExists,
@@ -3064,6 +3076,62 @@ docker_git_refresh_gemini_env() {
 
 docker_git_refresh_gemini_env`;
 var renderGeminiAuthConfig = (config) => geminiAuthConfigTemplate.replaceAll("__GEMINI_AUTH_ROOT__", geminiAuthRootContainerPath(config.sshUser)).replaceAll("__GEMINI_HOME_DIR__", config.geminiHome);
+var geminiSettingsJsonTemplate = `{
+  "model": {
+    "name": "gemini-3.1-pro-preview-yolo",
+    "compressionThreshold": 0.9,
+    "disableLoopDetection": true
+  },
+  "modelConfigs": {
+    "customAliases": {
+      "yolo-ultra": {
+        "modelConfig": {
+          "model": "gemini-3.1-pro-preview-yolo",
+          "generateContentConfig": {
+            "tools": [
+              {
+                "googleSearch": {}
+              },
+              {
+                "urlContext": {}
+              }
+            ]
+          }
+        }
+      }
+    }
+  },
+  "general": {
+    "defaultApprovalMode": "auto_edit"
+  },
+  "tools": {
+    "allowed": [
+      "run_shell_command",
+      "write_file",
+      "googleSearch",
+      "urlContext"
+    ]
+  },
+  "sandbox": {
+    "enabled": false
+  },
+  "security": {
+    "folderTrust": {
+      "enabled": false
+    },
+    "auth": {
+      "selectedType": "oauth-personal"
+    },
+    "disableYoloMode": false
+  },
+  "mcpServers": {
+    "playwright": {
+      "command": "docker-git-playwright-mcp",
+      "args": [],
+      "trust": true
+    }
+  }
+}`;
 var renderGeminiPermissionSettingsConfig = (config) => String.raw`# Gemini CLI: keep trust settings in sync with docker-git defaults
 GEMINI_SETTINGS_DIR="${config.geminiHome}"
 GEMINI_TRUST_SETTINGS_FILE="$GEMINI_SETTINGS_DIR/trustedFolders.json"
@@ -3073,18 +3141,9 @@ GEMINI_CONFIG_SETTINGS_FILE="$GEMINI_SETTINGS_DIR/settings.json"
 mkdir -p "$GEMINI_SETTINGS_DIR" || true
 
 # Disable folder trust prompt and enable auto-approval in settings.json
-if [[ ! -f "$GEMINI_CONFIG_SETTINGS_FILE" ]]; then
-  cat <<'EOF' > "$GEMINI_CONFIG_SETTINGS_FILE"
-{
-  "security": {
-    "folderTrust": {
-      "enabled": false
-    },
-    "approvalPolicy": "never"
-  }
-}
+cat <<'EOF' > "$GEMINI_CONFIG_SETTINGS_FILE"
+${geminiSettingsJsonTemplate}
 EOF
-fi
 
 # Pre-trust important directories in trustedFolders.json
 # Use flat mapping as required by recent Gemini CLI versions
@@ -5521,18 +5580,24 @@ var runDockerComposeUpWithPortCheck = (projectDir) => Effect.gen(function* (_) {
 //#endregion
 //#region ../lib/src/usecases/projects-ssh.ts
 var buildSshArgs$1 = (item) => {
+	const host = item.ipAddress ?? "localhost";
+	const port = item.ipAddress ? 22 : item.sshPort;
 	const args = [];
 	if (item.sshKeyPath !== null) args.push("-i", item.sshKeyPath);
-	args.push("-tt", "-Y", "-o", "LogLevel=ERROR", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null", "-p", String(item.sshPort), `${item.sshUser}@localhost`);
+	args.push("-tt", "-Y", "-o", "LogLevel=ERROR", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null", "-p", String(port), `${item.sshUser}@${host}`);
 	return args;
 };
 var buildSshProbeArgs = (item) => {
+	const host = item.ipAddress ?? "localhost";
+	const port = item.ipAddress ? 22 : item.sshPort;
 	const args = [];
 	if (item.sshKeyPath !== null) args.push("-i", item.sshKeyPath);
-	args.push("-T", "-o", "BatchMode=yes", "-o", "ConnectTimeout=2", "-o", "ConnectionAttempts=1", "-o", "LogLevel=ERROR", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null", "-p", String(item.sshPort), `${item.sshUser}@localhost`, "true");
+	args.push("-T", "-o", "BatchMode=yes", "-o", "ConnectTimeout=2", "-o", "ConnectionAttempts=1", "-o", "LogLevel=ERROR", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null", "-p", String(port), `${item.sshUser}@${host}`, "true");
 	return args;
 };
 var waitForSshReady = (item) => {
+	const host = item.ipAddress ?? "localhost";
+	const port = item.ipAddress ? 22 : item.sshPort;
 	const probe = Effect.gen(function* (_) {
 		const exitCode = yield* _(runCommandExitCode({
 			cwd: process.cwd(),
@@ -5544,7 +5609,7 @@ var waitForSshReady = (item) => {
 			exitCode
 		})));
 	});
-	return pipe(Effect.log(`Waiting for SSH on localhost:${item.sshPort} ...`), Effect.zipRight(Effect.retry(probe, pipe(Schedule.spaced(Duration.seconds(2)), Schedule.intersect(Schedule.recurs(30))))), Effect.tap(() => Effect.log("SSH is ready.")));
+	return pipe(Effect.log(`Waiting for SSH on ${host}:${port} ...`), Effect.zipRight(Effect.retry(probe, pipe(Schedule.spaced(Duration.seconds(2)), Schedule.intersect(Schedule.recurs(30))))), Effect.tap(() => Effect.log("SSH is ready.")));
 };
 var connectProjectSsh = (item) => pipe(ensureTerminalCursorVisible(), Effect.zipRight(runCommandWithExitCodes({
 	cwd: process.cwd(),
@@ -5554,14 +5619,34 @@ var connectProjectSsh = (item) => pipe(ensureTerminalCursorVisible(), Effect.zip
 	command: "ssh",
 	exitCode
 }))), Effect.ensuring(ensureTerminalCursorVisible()));
-var connectProjectSshWithUp = (item) => pipe(Effect.log(`Starting docker compose for ${item.displayName} ...`), Effect.zipRight(runDockerComposeUpWithPortCheck(item.projectDir)), Effect.map((template) => ({
-	...item,
-	sshPort: template.sshPort
-})), Effect.tap((updated) => waitForSshReady(updated)), Effect.flatMap((updated) => connectProjectSsh(updated)));
-var listProjectStatus = Effect.asVoid(withProjectIndexAndSsh((index, sshKey) => forEachProjectStatus(index.configPaths, (status) => pipe(Effect.log(renderProjectStatusHeader(status)), Effect.zipRight(Effect.log(`SSH access: ${buildSshCommand(status.config.template, sshKey)}`)), Effect.zipRight(runDockerComposePsFormatted(status.projectDir).pipe(Effect.map((raw) => parseComposePsOutput(raw)), Effect.map((rows) => formatComposeRows(rows)), Effect.flatMap((text) => Effect.log(text)), Effect.matchEffect({
+var connectProjectSshWithUp = (item) => Effect.gen(function* (_) {
+	const fs = yield* _(FileSystem.FileSystem);
+	yield* _(Effect.log(`Starting docker compose for ${item.displayName} ...`));
+	const template = yield* _(runDockerComposeUpWithPortCheck(item.projectDir));
+	const isInsideContainer = yield* _(fs.exists("/.dockerenv"));
+	let ipAddress;
+	if (isInsideContainer) {
+		const containerIp = yield* _(runDockerInspectContainerIp(item.projectDir, template.containerName).pipe(Effect.orElse(() => Effect.succeed(""))));
+		if (containerIp.length > 0) ipAddress = containerIp;
+	}
+	const updated = {
+		...item,
+		sshPort: template.sshPort,
+		ipAddress
+	};
+	yield* _(waitForSshReady(updated));
+	yield* _(connectProjectSsh(updated));
+});
+var listProjectStatus = withProjectIndexAndSsh((index, sshKey) => forEachProjectStatus(index.configPaths, (status) => Effect.gen(function* (_) {
+	const ipAddress = yield* _(getContainerIpIfInsideContainer(yield* _(FileSystem.FileSystem), status.projectDir, status.config.template.containerName));
+	yield* _(Effect.log(renderProjectStatusHeader(status)));
+	yield* _(Effect.log(`SSH access: ${buildSshCommand(status.config.template, sshKey, ipAddress)}`));
+	const text = formatComposeRows(parseComposePsOutput(yield* _(runDockerComposePsFormatted(status.projectDir))));
+	yield* _(Effect.log(text));
+}).pipe(Effect.matchEffect({
 	onFailure: (error) => Effect.logWarning(`docker compose ps failed for ${status.projectDir}: ${renderError(error)}`),
 	onSuccess: () => Effect.void
-})))))));
+})))).pipe(Effect.asVoid);
 //#endregion
 //#region ../lib/src/usecases/actions/docker-up.ts
 var clonePollInterval = Duration.seconds(1);
@@ -5573,9 +5658,15 @@ var agentFailPath = "/run/docker-git/agent.failed";
 var logSshAccess = (baseDir, config) => Effect.gen(function* (_) {
 	const fs = yield* _(FileSystem.FileSystem);
 	const path = yield* _(Path.Path);
+	const isInsideContainer = yield* _(fs.exists("/.dockerenv"));
+	let ipAddress;
+	if (isInsideContainer) {
+		const containerIp = yield* _(runDockerInspectContainerIp(baseDir, config.containerName).pipe(Effect.orElse(() => Effect.succeed(""))));
+		if (containerIp.length > 0) ipAddress = containerIp;
+	}
 	const resolvedAuthorizedKeys = resolveAuthorizedKeysPath(path, baseDir, config.authorizedKeysPath);
 	const authExists = yield* _(fs.exists(resolvedAuthorizedKeys));
-	const sshCommand = buildSshCommand(config, yield* _(findSshPrivateKey(fs, path, process.cwd())));
+	const sshCommand = buildSshCommand(config, yield* _(findSshPrivateKey(fs, path, process.cwd())), ipAddress);
 	yield* _(Effect.log(`SSH access: ${sshCommand}`));
 	if (!authExists) yield* _(Effect.logWarning(`Authorized keys file missing: ${resolvedAuthorizedKeys} (SSH may fail without a matching key).`));
 });
@@ -5818,23 +5909,28 @@ var formatStateSyncLabel = (repoUrl) => {
 	return repoPath.length > 0 ? repoPath : repoUrl;
 };
 var isInteractiveTty = () => process.stdin.isTTY && process.stdout.isTTY;
-var buildSshArgs = (config, sshKeyPath, remoteCommand) => {
+var buildSshArgs = (config, sshKeyPath, remoteCommand, ipAddress) => {
+	const host = ipAddress ?? "localhost";
+	const port = ipAddress ? 22 : config.sshPort;
 	const args = [];
 	if (sshKeyPath !== null) args.push("-i", sshKeyPath);
-	args.push("-tt", "-Y", "-o", "LogLevel=ERROR", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null", "-p", String(config.sshPort), `${config.sshUser}@localhost`);
+	args.push("-tt", "-Y", "-o", "LogLevel=ERROR", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null", "-p", String(port), `${config.sshUser}@${host}`);
 	if (remoteCommand !== void 0) args.push(remoteCommand);
 	return args;
 };
 var openSshBestEffort = (template, remoteCommand) => Effect.gen(function* (_) {
-	const sshKey = yield* _(findSshPrivateKey(yield* _(FileSystem.FileSystem), yield* _(Path.Path), process.cwd()));
-	const sshCommand = buildSshCommand(template, sshKey);
+	const fs = yield* _(FileSystem.FileSystem);
+	const path = yield* _(Path.Path);
+	const ipAddress = yield* _(getContainerIpIfInsideContainer(fs, process.cwd(), template.containerName).pipe(Effect.orElse(() => Effect.succeed(""))));
+	const sshKey = yield* _(findSshPrivateKey(fs, path, process.cwd()));
+	const sshCommand = buildSshCommand(template, sshKey, ipAddress);
 	const remoteCommandLabel = remoteCommand === void 0 ? "" : ` (${remoteCommand})`;
 	yield* _(Effect.log(`Opening SSH: ${sshCommand}${remoteCommandLabel}`));
 	yield* _(ensureTerminalCursorVisible());
 	yield* _(runCommandWithExitCodes({
 		cwd: process.cwd(),
 		command: "ssh",
-		args: buildSshArgs(template, sshKey, remoteCommand)
+		args: buildSshArgs(template, sshKey, remoteCommand, ipAddress)
 	}, [0, 130], (exitCode) => new CommandFailedError({
 		command: "ssh",
 		exitCode
@@ -6685,23 +6781,38 @@ var prepareGeminiCredentialsDir = (cwd, accountPath, fs) => Effect.gen(function*
 	}).pipe(Effect.orElse(() => Effect.succeed(0))));
 	return credentialsDir;
 });
+var defaultGeminiSettings = {
+	model: {
+		name: "gemini-3.1-pro-preview-yolo",
+		compressionThreshold: .9,
+		disableLoopDetection: true
+	},
+	modelConfigs: { customAliases: { "yolo-ultra": { "modelConfig": {
+		"model": "gemini-3.1-pro-preview-yolo",
+		"generateContentConfig": { "tools": [{ "googleSearch": {} }, { "urlContext": {} }] }
+	} } } },
+	general: { defaultApprovalMode: "auto_edit" },
+	tools: { allowed: [
+		"run_shell_command",
+		"write_file",
+		"googleSearch",
+		"urlContext"
+	] },
+	sandbox: { enabled: false },
+	security: {
+		folderTrust: { enabled: false },
+		auth: { selectedType: "oauth-personal" },
+		disableYoloMode: false
+	},
+	mcpServers: { playwright: {
+		command: "docker-git-playwright-mcp",
+		args: [],
+		trust: true
+	} }
+};
 var writeInitialSettings = (credentialsDir, fs) => Effect.gen(function* (_) {
 	const settingsPath = `${credentialsDir}/settings.json`;
-	yield* _(fs.writeFileString(settingsPath, JSON.stringify({
-		model: {
-			name: "gemini-2.0-flash",
-			compressionThreshold: .9,
-			disableLoopDetection: true
-		},
-		general: { defaultApprovalMode: "auto_edit" },
-		yolo: true,
-		sandbox: { enabled: false },
-		security: {
-			folderTrust: { enabled: false },
-			auth: { selectedType: "oauth-personal" },
-			approvalPolicy: "never"
-		}
-	}, null, 2)));
+	yield* _(fs.writeFileString(settingsPath, JSON.stringify(defaultGeminiSettings, null, 2) + "\n"));
 	const trustedFoldersPath = `${credentialsDir}/trustedFolders.json`;
 	yield* _(fs.writeFileString(trustedFoldersPath, JSON.stringify({
 		"/": "TRUST_FOLDER",
@@ -6882,6 +6993,30 @@ var runGeminiOauthLoginWithPrompt = (cwd, accountPath, options) => Effect.scoped
 	return yield* _(resolveGeminiLoginResult(resultBox.value, exitCode));
 }));
 //#endregion
+//#region ../lib/src/usecases/auth-gemini-logout.ts
+var authGeminiLogout = (command) => Effect.gen(function* (_) {
+	const accountLabel = normalizeAccountLabel(command.label, "default");
+	yield* _(withGeminiAuth(command, ({ accountPath, fs }) => Effect.gen(function* (_) {
+		yield* _(fs.remove(geminiApiKeyPath(accountPath), { force: true }));
+		yield* _(fs.remove(geminiEnvFilePath(accountPath), { force: true }));
+		yield* _(fs.remove(geminiCredentialsPath(accountPath), {
+			recursive: true,
+			force: true
+		}));
+	})));
+	yield* _(autoSyncState(`chore(state): auth gemini logout ${accountLabel}`));
+}).pipe(Effect.asVoid);
+//#endregion
+//#region ../lib/src/usecases/auth-gemini-status.ts
+var authGeminiStatus = (command) => withGeminiAuth(command, ({ accountLabel, accountPath, fs }) => Effect.gen(function* (_) {
+	const authMethod = yield* _(resolveGeminiAuthMethod(fs, accountPath));
+	if (authMethod === "none") {
+		yield* _(Effect.log(`Gemini not connected (${accountLabel}).`));
+		return;
+	}
+	yield* _(Effect.log(`Gemini connected (${accountLabel}, ${authMethod}).`));
+}));
+//#endregion
 //#region ../lib/src/usecases/auth-gemini.ts
 var authGeminiLogin = (command, apiKey) => {
 	const accountLabel = normalizeAccountLabel(command.label, "default");
@@ -6889,6 +7024,10 @@ var authGeminiLogin = (command, apiKey) => {
 		const apiKeyFilePath = geminiApiKeyPath(accountPath);
 		yield* _(fs.writeFileString(apiKeyFilePath, `${apiKey.trim()}\n`));
 		yield* _(fs.chmod(apiKeyFilePath, 384), Effect.orElseSucceed(() => void 0));
+		const credentialsDir = geminiCredentialsPath(accountPath);
+		yield* _(fs.makeDirectory(credentialsDir, { recursive: true }));
+		const settingsPath = `${credentialsDir}/settings.json`;
+		yield* _(fs.writeFileString(settingsPath, JSON.stringify(defaultGeminiSettings, null, 2) + "\n"));
 	})).pipe(Effect.zipRight(autoSyncState(`chore(state): auth gemini ${accountLabel}`)));
 };
 var authGeminiLoginCli = (_command) => Effect.gen(function* (_) {
@@ -6911,33 +7050,9 @@ var authGeminiLoginOauth = (command) => {
 			image: geminiImageName,
 			containerPath: geminiContainerHomeDir
 		}));
-		yield* _(fs.writeFileString(settingsPath, JSON.stringify({ security: {
-			folderTrust: { enabled: false },
-			auth: { selectedType: "oauth-personal" },
-			approvalPolicy: "never"
-		} }, null, 2) + "\n"));
+		yield* _(fs.writeFileString(settingsPath, JSON.stringify(defaultGeminiSettings, null, 2) + "\n"));
 	}), { buildImage: true }).pipe(Effect.zipRight(autoSyncState(`chore(state): auth gemini oauth ${accountLabel}`)));
 };
-var authGeminiStatus = (command) => withGeminiAuth(command, ({ accountLabel, accountPath, fs }) => Effect.gen(function* (_) {
-	const authMethod = yield* _(resolveGeminiAuthMethod(fs, accountPath));
-	if (authMethod === "none") {
-		yield* _(Effect.log(`Gemini not connected (${accountLabel}).`));
-		return;
-	}
-	yield* _(Effect.log(`Gemini connected (${accountLabel}, ${authMethod}).`));
-}));
-var authGeminiLogout = (command) => Effect.gen(function* (_) {
-	const accountLabel = normalizeAccountLabel(command.label, "default");
-	yield* _(withGeminiAuth(command, ({ accountPath, fs }) => Effect.gen(function* (_) {
-		yield* _(fs.remove(geminiApiKeyPath(accountPath), { force: true }));
-		yield* _(fs.remove(geminiEnvFilePath(accountPath), { force: true }));
-		yield* _(fs.remove(geminiCredentialsPath(accountPath), {
-			recursive: true,
-			force: true
-		}));
-	})));
-	yield* _(autoSyncState(`chore(state): auth gemini logout ${accountLabel}`));
-}).pipe(Effect.asVoid);
 //#endregion
 //#region ../lib/src/usecases/state-repo-github.ts
 var dotDockerGitRepoName = ".docker-git";