localdeck 1.5.0 → 1.6.2

package/dist/index.js

@@ -4,6 +4,7 @@ import {
   HOME_DIR,
   VERSION,
   __require,
+  applyProfiles,
   chooseUpstream,
   connectHost,
   dashboardDir,
@@ -31,7 +32,7 @@ import {
   unreachableListenerMessage,
   waitForReadiness,
   wrapper_default
-} from "./index-tv699dzb.js";
+} from "./index-xsyz4cc9.js";
 
 // src/index.ts
 import { spawn as spawn2 } from "node:child_process";
@@ -155,7 +156,8 @@ async function startService(opts, overrides = {}) {
         upstreamPort,
         upstreamSource: opts.upstreamPort === undefined ? "assigned" : "manual",
         cwd,
-        command: opts.displayCommand ?? opts.command.join(" ")
+        command: opts.displayCommand ?? opts.command.join(" "),
+        ...opts.project ? { profiles: opts.profiles ?? [] } : {}
       });
     });
     ws.on("message", (raw) => {
@@ -849,7 +851,7 @@ ${c.bold("Usage")}
   localdeck run <name> [--port 4000] [--upstream 5173] [--] <command...>
   localdeck <name>                  run a command from the project's .localdeck file
   localdeck up [tag|name...]        run every .localdeck command (or just the tagged/named ones) in one terminal
-  localdeck up --profile <name>   run a saved profile and its prerequisites
+  localdeck profile [on|off <name...>|clear]  list or switch this project's profiles
   localdeck init [--dry-run] [--force]  preview/create/replace the project configuration
   localdeck init --name web --command 'your command'
   localdeck commands              list configured services (alias: cmds)
@@ -915,13 +917,16 @@ async function main(argv, overrides = {}) {
     case "--update":
       if (rest.length)
         throw new Error("Usage: localdeck --update");
-      return (await import("./update-a6z3akjx.js")).updateLocalDeck();
+      return (await import("./update-hvkw7mkw.js")).updateLocalDeck();
     case "up":
       return cmdUp(rest, dependencies);
+    case "profile":
+    case "profiles":
+      return cmdProfile(rest, dependencies);
     case "init":
       return cmdInit(rest, dependencies);
     case "mcp":
-      return (await import("./mcp-c138pjc5.js")).runMcp(rest);
+      return (await import("./mcp-210n1fxv.js")).runMcp(rest);
     case "doctor":
       return cmdDoctor(rest);
     case "forward":
@@ -961,10 +966,12 @@ async function main(argv, overrides = {}) {
       const found = project && findProjectCommand(project, cmd);
       if (found) {
         const remembered = await rememberProject(project, dependencies);
+        const launch = await resolveLaunch(project, remembered, dependencies);
         const selected = startupLayers(project.commands, [found.name]).flat();
-        return dependencies.runForeground(selected.map((command, index) => toRunOptions(command, project, remembered, {
+        return dependencies.runForeground(selected.map((command, index) => toRunOptions(launch.effective(command), project, remembered, {
           prefix: selected.length > 1,
-          color: PALETTE[index % PALETTE.length]
+          color: PALETTE[index % PALETTE.length],
+          ...launch.options
         })));
       }
       const hint = project ? ` Commands in ${path3.basename(project.file)}: ${project.commands.map((p) => p.name).join(", ") || "(none)"}` : "";
@@ -1006,6 +1013,32 @@ async function rememberProject(project, dependencies) {
     return;
   }
 }
+async function resolveLaunch(project, remembered, dependencies) {
+  let active = [];
+  if (project.profiles?.length && remembered) {
+    try {
+      const daemon = await dependencies.ensureDaemon();
+      active = (await dependencies.createApi(daemon.apiPort).profiles(remembered.id)).active;
+    } catch (error) {
+      dependencies.warn(`LocalDeck: could not read active profiles, running without them: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  let resolved;
+  try {
+    resolved = applyProfiles(project, active);
+  } catch (error) {
+    fail(error instanceof Error ? error.message : String(error));
+  }
+  if (resolved.active.length)
+    dependencies.log(c.dim(`Profiles: ${resolved.active.join(" + ")}`));
+  for (const clash of resolved.clashes)
+    dependencies.warn(`LocalDeck: ${clash.profiles.join(" and ")} both set ${clash.service} ${clash.field}; ${clash.winner} wins because it is listed later.`);
+  const byName = new Map(resolved.commands.map((command) => [command.name, command]));
+  return {
+    effective: (command) => byName.get(command.name) ?? command,
+    options: remembered ? { profiles: resolved.active } : {}
+  };
+}
 async function printProjectCommands(failIfNone, dependencies) {
   const project = tryLoadProject(dependencies);
   if (!project) {
@@ -1017,6 +1050,9 @@ async function printProjectCommands(failIfNone, dependencies) {
   console.log(`${c.bold("Project commands")} ${c.dim(`(${path3.relative(process.cwd(), project.file) || path3.basename(project.file)})`)}`);
   const rows = project.commands.map((p) => [c.cyan(p.name), p.port ? String(p.port) : c.dim("auto"), p.after.join(",") || "", p.tags.join(",") || "", c.dim(p.run)]);
   console.log(table(rows, ["NAME", "PORT", "AFTER", "TAGS", "RUN"]));
+  if (project.profiles?.length)
+    console.log(`
+${c.bold("Profiles")} ${project.profiles.map((profile) => profile.name).join(", ")} ${c.dim("· localdeck profile")}`);
   console.log(c.dim(`
 run one: localdeck <name>   ·   run all: localdeck up   ·   by tag: localdeck up <tag>`));
 }
@@ -1033,12 +1069,16 @@ async function cmdUp(args, dependencies) {
       fail("--profile needs a profile name");
     args = args.filter((_, i) => i !== profileIndex && i !== profileIndex + 1);
   }
-  const profiles = project.profiles;
-  if (profile && (!profiles || !Object.prototype.hasOwnProperty.call(profiles, profile)))
-    fail(`unknown profile "${profile}". Available profiles: ${Object.keys(profiles ?? {}).join(", ") || "(none)"}`);
+  const legacy = project.legacyProfiles;
+  if (profile && project.profiles?.some((candidate) => candidate.name === profile))
+    fail(`"${profile}" is a profile you turn on, not a group to start: localdeck profile on ${profile}`);
+  if (profile && (!legacy || !Object.prototype.hasOwnProperty.call(legacy, profile)))
+    fail(`unknown profile "${profile}". Group services with tags and run: localdeck up <tag>`);
+  if (profile)
+    dependencies.warn(`LocalDeck: --profile is deprecated. "${profile}" is now a tag; run: localdeck up ${profile}`);
   let selected = project.commands;
   if (profile) {
-    const names = new Set(profiles[profile]);
+    const names = new Set(legacy[profile]);
     selected = project.commands.filter((command) => names.has(command.name));
     if (!selected.length)
       fail(`profile "${profile}" selects no configured services`);
@@ -1058,7 +1098,50 @@ async function cmdUp(args, dependencies) {
     fail("nothing to run");
   selected = startupLayers(project.commands, selected.map((command) => command.name)).flat();
   const remembered = await rememberProject(project, dependencies);
-  await dependencies.runForeground(selected.map((p, i) => toRunOptions(p, project, remembered, { prefix: selected.length > 1, color: PALETTE[i % PALETTE.length] })));
+  const launch = await resolveLaunch(project, remembered, dependencies);
+  await dependencies.runForeground(selected.map((p, i) => toRunOptions(launch.effective(p), project, remembered, { prefix: selected.length > 1, color: PALETTE[i % PALETTE.length], ...launch.options })));
+}
+async function cmdProfile(args, dependencies) {
+  const project = tryLoadProject(dependencies);
+  if (!project)
+    fail("no .localdeck file found here or in a parent folder. Create one with: localdeck init");
+  const [action = "list", ...names] = args;
+  if (!["list", "ls", "on", "off", "clear"].includes(action))
+    fail(`unknown profile action "${action}". Usage: localdeck profile [on|off <name...>|clear]`);
+  if ((action === "on" || action === "off") && !names.length)
+    fail(`localdeck profile ${action} needs at least one profile name`);
+  if (!project.profiles?.length) {
+    if (action === "list" || action === "ls") {
+      dependencies.log(`No profiles in ${path3.basename(project.file)}. Add a "profiles" object to run services differently, for example against staging.`);
+      return;
+    }
+    fail(`${path3.basename(project.file)} defines no profiles`);
+  }
+  const remembered = await rememberProject(project, dependencies);
+  if (!remembered)
+    fail("the LocalDeck daemon is needed to switch profiles");
+  const daemon = await dependencies.ensureDaemon();
+  const api = dependencies.createApi(daemon.apiPort);
+  let current = await api.profiles(remembered.id);
+  if (action === "on" || action === "off" || action === "clear") {
+    const wanted = names.map((name) => name.toLowerCase());
+    const unknown = wanted.filter((name) => !current.profiles.some((candidate) => candidate.name === name));
+    if (unknown.length)
+      fail(`unknown profile ${unknown.map((name) => `"${name}"`).join(", ")}. Available profiles: ${current.profiles.map((candidate) => candidate.name).join(", ")}`);
+    const next = action === "clear" ? [] : action === "on" ? [...new Set([...current.active, ...wanted])] : current.active.filter((name) => !wanted.includes(name));
+    current = await api.setActiveProfiles(remembered.id, next);
+    dependencies.log(current.active.length ? `Profiles on: ${c.cyan(current.active.join(" + "))}` : "No profiles on · running base services");
+    dependencies.log(c.dim("Running services keep their settings until restarted."));
+  } else {
+    const rows = current.profiles.map((candidate) => [candidate.active ? c.green("on") : c.dim("off"), c.cyan(candidate.name), candidate.services.join(","), candidate.description ?? ""]);
+    dependencies.log(table(rows, ["", "PROFILE", "CHANGES", "DESCRIPTION"]));
+    dependencies.log(c.dim(`
+turn on: localdeck profile on <name>   ·   off: localdeck profile off <name>   ·   all off: localdeck profile clear`));
+  }
+  for (const clash of current.clashes)
+    dependencies.warn(`LocalDeck: ${clash.profiles.join(" and ")} both set ${clash.service} ${clash.field}; ${clash.winner} wins because it is listed later.`);
+  if (current.error)
+    dependencies.warn(`LocalDeck: ${current.error}`);
 }
 async function cmdInit(args, dependencies) {
   const root = findPackageRoot() ?? process.cwd();
@@ -1185,10 +1268,12 @@ async function cmdRun(args, dependencies) {
     const found = project && name ? findProjectCommand(project, name) : undefined;
     if (found) {
       const remembered = await rememberProject(project, dependencies);
+      const launch = await resolveLaunch(project, remembered, dependencies);
       const selected = startupLayers(project.commands, [found.name]).flat();
-      return dependencies.runForeground(selected.map((command2, index) => toRunOptions(command2, project, remembered, {
+      return dependencies.runForeground(selected.map((command2, index) => toRunOptions(launch.effective(command2), project, remembered, {
         prefix: selected.length > 1,
         color: PALETTE[index % PALETTE.length],
+        ...launch.options,
         ...command2.name === found.name ? { stablePort: opts.port ?? found.port, upstreamPort: opts.upstream ?? found.upstream } : {}
       })));
     }

package/dist/{mcp-c138pjc5.js → mcp-210n1fxv.js}

@@ -9,7 +9,7 @@ import {
   listProjectSecrets,
   redactDiagnostic,
   resolveProjectSecrets
-} from "./index-tv699dzb.js";
+} from "./index-xsyz4cc9.js";
 
 // ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS((exports) => {
@@ -34043,6 +34043,14 @@ function createMcpServer(options) {
       throw new Error("Unknown service key; use list_services");
     return { projectId, name, details, runtime };
   }
+  function profileState(details, name, runtime) {
+    const current = details?.fingerprints?.[name];
+    const running = runtime && runtime.status !== "stopped";
+    return {
+      ...running ? { profiles: runtime.profiles ?? [] } : {},
+      ...running && runtime.configFingerprint && current ? { restartNeeded: runtime.configFingerprint !== current } : {}
+    };
+  }
   tool("list_projects", "List remembered projects, their exact IDs and configuration availability.", { limit }, false, async (args, api2) => {
     const all = (await api2.projects()).filter((p) => !options.projectId || p.id === options.projectId);
     return { data: { items: all.slice(0, args.limit), truncated: all.length > args.limit } };
@@ -34063,14 +34071,34 @@ function createMcpServer(options) {
       const details = await project(api2, summary.id, secrets);
       for (const c of details.commands) {
         const serviceKey = `${summary.id}:${c.name}`;
-        items.set(serviceKey, { key: serviceKey, projectId: summary.id, projectName: summary.name, name: c.name, status: "stopped", managedBy: "daemon", configured: true, ...items.get(serviceKey) });
+        const existing = items.get(serviceKey);
+        items.set(serviceKey, { key: serviceKey, projectId: summary.id, projectName: summary.name, name: c.name, status: "stopped", managedBy: "daemon", configured: true, ...existing, ...profileState(details, c.name, existing && "upstreamPort" in existing ? existing : undefined) });
       }
     }
     return { data: { items: [...items.values()].slice(0, args.limit), truncated: items.size > args.limit, unavailable } };
   });
   tool("get_service", "Inspect a registered or configured service. Ports and counters appear after its first start.", serviceInput, false, async (args, api2, secrets) => {
     const target = await service(api2, args.serviceKey, secrets);
-    return { data: { service: target.runtime ?? { key: args.serviceKey, projectId: target.projectId, name: target.name, status: "stopped", configured: true, managedBy: "daemon" }, notice } };
+    const command = target.details?.commands.find((c) => c.name === target.name);
+    const origin = target.details?.provenance?.[target.name];
+    return { data: {
+      service: { ...target.runtime ?? { key: args.serviceKey, projectId: target.projectId, name: target.name, status: "stopped", configured: true, managedBy: "daemon" }, ...profileState(target.details, target.name, target.runtime) },
+      ...command ? { configuration: {
+        run: command.run,
+        cwd: command.cwd ?? ".",
+        activeProfiles: target.details?.activeProfiles ?? [],
+        ...origin ? { sources: { run: origin.run, cwd: origin.cwd, envNames: origin.env, secretNames: origin.secrets } } : {}
+      } } : {},
+      notice
+    } };
+  });
+  tool("list_profiles", "List a project's profiles: overlays that change how services run (command, env, secrets, cwd) on this computer. Shows which are on and any clashes. Does not start anything.", { projectId: id }, false, async (args, api2, secrets) => {
+    await project(api2, args.projectId, secrets);
+    return { data: { ...await api2.profiles(args.projectId) } };
+  });
+  tool("set_profiles", "Replace the list of profiles turned on for a project on this computer. Never starts, stops or restarts services; running services keep their settings until restarted (list_services shows restartNeeded).", { projectId: id, profiles: exports_external.array(exports_external.string().regex(/^[a-z0-9][a-z0-9_-]{0,40}$/i)).max(64) }, true, async (args, api2, secrets) => {
+    await project(api2, args.projectId, secrets);
+    return { data: { ...await api2.setActiveProfiles(args.projectId, args.profiles.map((name) => name.toLowerCase())) } };
   });
   tool("get_logs", "Read recent logs. Filters apply to the last 200 retained records. No live follow.", { ...serviceInput, limit, stream: exports_external.enum(["stdout", "stderr", "system"]).optional() }, false, async (args, api2, secrets) => {
     await service(api2, args.serviceKey, secrets);

package/dist/{update-a6z3akjx.js → update-hvkw7mkw.js}

@@ -3,7 +3,7 @@ import {
   STATE_FILE,
   assertUserRuntime,
   findDaemon
-} from "./index-tv699dzb.js";
+} from "./index-xsyz4cc9.js";
 
 // src/update.ts
 import { spawn } from "node:child_process";

package/docs/commands.md

@@ -29,11 +29,24 @@ Initialization uses the nearest `package.json` directory, or the current folder
 | `localdeck web` | Runs the configured `web` service and its transitive prerequisites in the terminal. |
 | `localdeck up` | Runs all configured services, starting each after its own prerequisites become ready. |
 | `localdeck up frontend api` | Runs services matching any supplied name or tag, plus their prerequisites. |
-| `localdeck up --profile app` | Runs the names in the saved `app` profile and their prerequisites. Additional name/tag selectors must stay within the profile. |
+| `localdeck up --profile app` | Deprecated. Runs a pre-1.6 list-style profile, now converted to the tag `app`; use `localdeck up app`. |
 | `localdeck run web` | Runs the configured `web` service; an alternative to `localdeck web`. |
 | `localdeck run api -- node server.js` | Runs a one-off command without requiring a configuration. |
 | `localdeck run api --port 4000 --upstream 8787 -- node server.js` | Reserves stable port 4000 and explicitly proxies to upstream port 8787. Omit these flags for automatic allocation and detection. |
 
+Terminal runs use the profiles turned on for the project and print them first, for example `Profiles: staging`.
+
+## Profiles
+
+| Command | What it does |
+| --- | --- |
+| `localdeck profile` | Lists the project's profiles, which services each changes, and which are on. Alias: `profiles`. |
+| `localdeck profile on staging debug` | Turns on one or more profiles for this project on this computer. |
+| `localdeck profile off debug` | Turns profiles off. |
+| `localdeck profile clear` | Turns every profile off, so services run as defined in the base configuration. |
+
+Profile commands never start, stop or restart services. Running services keep their settings until restarted. See [profiles](configuration.md#profiles).
+
 `run` accepts `-p` for `--port`, `-u` for `--upstream`, and `--port=4000`/`--upstream=8787`. Ports must be integers from 1 to 65535. Put LocalDeck options before the application command; `--` separates the two. `localdeck run web --port 4000` overrides the configured web service's stable port for that terminal run.
 
 `{port}` inside a configured command expands to the assigned **upstream** port in both terminal and dashboard launches. `$PORT` also contains that port. The stable port is held by LocalDeck, so avoid assigning it the same port your tool insists on using.
@@ -87,7 +100,7 @@ Normal startup handles clean URLs automatically where supported. Manual `forward
 | `NO_COLOR` | Disables CLI colors. |
 | `CI` | Suppresses interactive clean-URL preparation when set. |
 
-Child services receive `PORT` (upstream), `LOCALDECK_PORT` (stable/published port), and `LOCALDECK_SERVICE` (service name). HTTP services also receive `LOCALDECK_URL`, using a stable numeric localhost URL. These names and other `LOCALDECK_*` names are reserved in configuration `env`; see [environment wiring](configuration.md#profiles-and-environment-wiring).
+Child services receive `PORT` (upstream), `LOCALDECK_PORT` (stable/published port), and `LOCALDECK_SERVICE` (service name). HTTP services also receive `LOCALDECK_URL`, using a stable numeric localhost URL. These names and other `LOCALDECK_*` names are reserved in configuration `env`; see [environment wiring](configuration.md#environment-wiring).
 
 ## MCP client connection
 

package/docs/configuration.md

@@ -47,22 +47,58 @@ For Docker Compose databases, set `upstream` to the host-published database port
 
 Native database presets are `ready: "postgres"` (requires `pg_isready`) and `ready: "redis"` (requires `redis-cli`). The matching `serviceType` selects this check by default. Compose checks use tools inside the named container: `{ "type": "compose", "service": "redis", "engine": "redis" }`. Compose service names and engines are validated; the host still needs Docker. **Listening** means TCP connections are accepted; **ready** means the configured readiness contract passed. Custom HTTP/command checks also run for services with no dependents.
 
-### Profiles and environment wiring
+### Environment wiring
 
-Use the object format when defining startup profiles:
+Use `env` with `{service:NAME:url}` or `{service:NAME:port}` to hand one service the address of another it starts after:
 
 ```json
 {
   "services": [
     { "name": "api", "run": "npm run api", "ready": "/health" },
-    { "name": "web", "run": "npm run web", "after": "api", "env": { "PUBLIC_API_URL": "{service:api:url}" } },
-    { "name": "docs", "run": "npm run docs" }
+    { "name": "web", "run": "npm run web", "after": "api", "env": { "PUBLIC_API_URL": "{service:api:url}" } }
+  ]
+}
+```
+
+Variable names such as `PUBLIC_API_URL` must match what your framework actually reads; LocalDeck does not rewrite application code or `.env` files.
+
+### Profiles
+
+A profile changes how services run without renaming them. `web` stays `web`, with the same port, link and startup order, while a `staging` profile swaps its command and environment. With no profile on, services run exactly as defined above; that is your local setup.
+
+```json
+{
+  "services": [
+    { "name": "api", "run": "npm run api", "env": { "LOG_LEVEL": "info" } },
+    { "name": "web", "run": "npm run dev", "after": "api", "env": { "API_URL": "{service:api:url}" } }
   ],
-  "profiles": { "app": ["web"], "everything": ["web", "docs"] }
+  "profiles": {
+    "staging": {
+      "description": "Frontend talks to the staging API",
+      "services": {
+        "web": {
+          "run": "npm run dev:staging",
+          "env": { "API_URL": "https://api.staging.example.com" },
+          "secrets": ["STAGING_TOKEN"]
+        }
+      }
+    },
+    "debug": {
+      "description": "Attach the Node inspector to the API",
+      "services": { "api": { "env": { "NODE_OPTIONS": "--inspect", "LOG_LEVEL": "debug" } } }
+    }
+  }
 }
 ```
 
-`localdeck up --profile app` starts web and its API prerequisite. Profiles are also selectable in the dashboard. Variable names such as `PUBLIC_API_URL` must match what your framework actually reads; LocalDeck does not rewrite application code or `.env` files.
+- A profile may change a service's `run`, `cwd`, `env` and `secrets`. Name, ports, `after`, readiness and service type always come from the base service, so links and startup order never change.
+- `env` merges key by key: `debug` above keeps `api`'s other variables and replaces `LOG_LEVEL`. `secrets` are added to the base list. The same reserved-name rules apply as for base services.
+- Several profiles can be on at once. They apply in the order they are listed in the file. When two of them set the same command, directory or variable, the one listed later wins, and the dashboard and CLI say so.
+- Which profiles are on is stored **on this computer only**, in `~/.localdeck/projects.json` (or `$LOCALDECK_HOME`). It is never written to `.localdeck`, so turning on `staging` does not change the file for your teammates.
+- Turn profiles on with `localdeck profile on staging`, the Profiles menu at the top of the project page, or the MCP `set_profiles` tool. Switching never starts, stops or restarts anything. A running service keeps its settings and is marked **Restart to apply** until you restart it.
+- Profile names use lowercase letters, numbers, `-` and `_`. An unknown service, or a field a profile cannot change, is rejected when the file loads.
+
+**Older list-style profiles.** Before 1.6, `"profiles": { "app": ["web"] }` named a group of services to start. That form still loads: each listed service is tagged `app`, so run the group with `localdeck up app`. `localdeck up --profile app` keeps working for now with a notice. A file cannot mix service lists and profile objects under `profiles`.
 
 Keys are forgiving (`command`/`value`/`cmd` work too), and `{ "web": "npm run dev" }` shorthand is accepted. LocalDeck looks for `.localdeck`, `.localdeck.json` or `localdeck.json`, walking up from the current folder, so it works from anywhere inside a monorepo.
 

package/docs/dashboard.md

@@ -6,39 +6,59 @@ Open the dashboard with `localdeck open`. It runs on `http://localhost:7777` by
 
 ## Command palette
 
-Press **⌘K** on macOS or **Ctrl+K** on Windows/Linux, or click **Search commands** in the sidebar. Search by action, project, or service name; words can appear in any order, such as `logs web my-app`. Use **↑/↓** to select, **Enter** to run, and **Escape** to close. Closing returns focus to the previous control.
+Press **⌘K** on macOS or **Ctrl+K** on Windows/Linux, or click **Search** in the sidebar. Search by action, project, or service name; words can appear in any order, such as `logs web my-app`. Use **↑/↓** to select, **Enter** to run, and **Escape** to close. Closing returns focus to the previous control.
 
-Commands open projects, Settings, running app URLs, logs, and requests, and start, stop, or restart individual services through the existing dashboard controls. Start is available for configured stopped services; restart is available for configured daemon-owned services. Controls are unavailable while disconnected or while that service is starting, stopping, or restarting. Failed actions stay visible in the palette. Project loading failures show a Retry control.
+Commands open projects, project and global Settings, running app URLs, and each service's logs, requests or configuration page, and start, stop, or restart individual services. Start is available for configured stopped services; restart is available for configured daemon-owned services. Controls are unavailable while disconnected or while that service is starting, stopping, or restarting. Failed actions stay visible in the palette. Project loading failures show a Retry control.
 
-## Pages and projects
+## Layout and navigation
 
-- **Projects** (`/projects`) lists projects remembered through the CLI. Selecting one opens `/projects/<id>`.
-- **All Services** (`/services`) lists configured and running services across projects, with search, Start/Stop, Share, View logs, and View requests controls.
-- **Settings** (`/settings`) contains Clean URLs and the log display limit.
-- **About** (`/about`) contains setup and command information.
-- **Changelog** (`/changelog`) lists release features and changes.
+The sidebar holds **Search**, **Projects**, **All services**, and your projects with a status dot and running count. Its footer shows the daemon status; the ⚙ menu opens **Settings**, **About**, and **Changelog**. Collapse the sidebar to icons with the button beside the logo, or drag its edge (arrow keys and Home/End also work) to resize it. On phones it opens as an overlay and closes after you navigate.
 
-Routes support refresh, direct links, and browser Back/Forward. LocalDeck remembers registered project files; it does not scan your disk. Missing or invalid projects remain visible with recovery actions until fixed or forgotten.
+Every view has its own address, so refresh, direct links, middle-click and browser Back/Forward all work. Back and Forward return to where you were on the page. Search boxes keep their text in the address (`?q=`).
 
-Project pages expose individual Start/Stop, View logs, View requests, and Share controls, plus Start all and Stop all. Start includes prerequisites and waits for readiness; Stop all reverses dependency order. Local and shared URLs appear below each service. Failed services keep their own errors so other services remain usable.
+| Address | Page |
+| --- | --- |
+| `/projects` | Projects you've remembered through the CLI |
+| `/projects/<id>` | A project's **Overview**; tabs for **Activity**, **Checks**, **Secrets** and **Settings** follow the same address |
+| `/projects/<id>/services/<name>` | A service's page: **Logs**, **Requests** (`…/requests`) and **Config** (`…/config`) tabs |
+| `/services` | All services across projects |
+| `/settings`, `/about`, `/changelog` | App settings, setup and command reference, release notes |
 
-Dashboard-started services run in the background under the daemon. Terminal services stay attached to their original CLI session; stopping them is supported, but restart them from their terminal. Unexpected process exits trigger up to three automatic restarts, each after a three-second delay. Logs show the attempt number; after the third failed retry, start the service manually to try again. The retry budget lasts until the next manual start. Stop, Stop all, Ctrl-C, and daemon shutdown cancel pending retries. Shutting down the daemon stops its services and shares.
+LocalDeck remembers registered project files; it does not scan your disk. Missing or invalid projects remain visible with Retry and Forget until fixed or forgotten.
+
+## Projects and services
+
+The project header shows the project name and status, the **Environment** (Git worktree) and **Profiles** menus, the tabs, and **Start project** / **Start remaining**, **Stop project** and **Open app**. Start includes prerequisites and waits for readiness; Stop reverses dependency order.
+
+Each service row shows its address, ports, share link and status, with Start, Stop (and Restart when its configuration changed) and an options menu: **View logs**, **View requests**, **Configure**, **Watch in panel**, **Copy address**, and **Share…** or **Stop sharing**. Select a service's name to open its page. Failed services keep their own errors so other services remain usable.
+
+Dashboard-started services run in the background under the daemon. Terminal services stay attached to their original CLI session; stopping them is supported, but restart them from their terminal (the service page says so). Unexpected process exits trigger up to three automatic restarts, each after a three-second delay. Logs show the attempt number; after the third failed retry, start the service manually to try again. The retry budget lasts until the next manual start. Stop, Stop project, Ctrl-C, and daemon shutdown cancel pending retries. Shutting down the daemon stops its services and shares.
+
+## Feedback and confirmations
+
+Saving shows a short confirmation in the bottom-right corner and closes whatever opened the form. Errors stay on screen until you dismiss them, and the field that caused one is marked. Actions that delete something ask first: forgetting a project, removing a secret, deleting a check, clearing logs or requests, and removing the Clean URLs forwarder. Press **Escape** to close the topmost menu, dialog or inspector.
+
+## Profiles
+
+When `.localdeck` defines [profiles](configuration.md#profiles), a **Profiles** menu appears beside Environment at the top of the project page. Tick profiles to turn them on or off for this project on this computer; **Turn all off** clears them. Each entry shows its description and which services it changes. If two active profiles change the same setting, the menu says which one wins.
+
+The active profiles appear next to the project status, and each service they change gets a small profile tag. Switching never starts, stops or restarts services. A running service whose settings changed shows **Restart to apply profile changes** with a Restart button. Terminal-owned services say to restart them in their terminal instead. The same notice appears after hand-editing a running service's command, directory, environment or secret names in `.localdeck`.
 
 ## Project settings
 
-Use **Settings** beside the project name to edit its nickname and service configuration. The nickname is saved to `.localdeck`; an unchanged nickname disables Save, and a blank nickname removes it.
+Open the **Settings** tab (`/projects/<project-id>/settings`) for the project's nickname, service configuration, profiles, diagnostics and **Forget project** (under Danger zone). The nickname is saved to `.localdeck`; an unchanged nickname disables Save, and a blank nickname removes it.
 
 A nickname such as `platform` produces `http://platform.web.localhost:7777`. Without one, a unique service may use `http://web.localhost:7777`. Ambiguous short names are rejected rather than routed to the wrong project. Qualified aliases and stable numeric URLs remain available.
 
-Service configuration fills the available width. Edit stable and upstream ports, TCP or HTTP readiness, timing, and startup dependencies. Changes are validated and saved atomically, and apply to running services after restart. Commands, working directories, environment values, and command-based readiness remain file-edited.
+Each service links to its **Config** tab, which shows **What it will run**: its command, working directory, environment variables and secret names with active profiles applied, and whether each came from the base service or a profile. Secret values are never shown. Edit stable and upstream ports, TCP or HTTP readiness, timing, and startup dependencies. Changes are validated and saved atomically, and apply to running services after restart. Commands, working directories, environment values, and command-based readiness remain file-edited. The **Profiles** section lists each profile, whether it is on, and what it changes; profiles are also edited in `.localdeck`.
 
-The Secrets button beside Settings on the project page opens a dedicated Secrets page at `/projects/<project-id>/secrets`. It lists declared names and whether each value is configured. Use Add secret, Replace, or Set value to open the editor popover; click outside or press Escape to dismiss it. Remove deletes a saved value. Password fields start empty; saved values are never shown again. Secrets are stored in plaintext on this computer, outside your project. They are not encrypted. Anyone with access to the file can read them. Changes apply when the service next starts. Secret values are per machine and must be configured separately on each machine.
+The **Secrets** tab (`/projects/<project-id>/secrets`) lists declared names and whether each value is configured. **Add secret**, **Replace** and **Set value** open a dialog; saving closes it. **Remove** asks before deleting a saved value. Password fields start empty; saved values are never shown again. Secrets are stored in plaintext on this computer, outside your project. They are not encrypted. Anyone with access to the file can read them. Changes apply when the service next starts. Secret values are per machine and must be configured separately on each machine.
 
 ## Logs
 
-Choose **Logs** or **View logs** to open that service's tab in the bottom panel. Select additional sources from the Services menu; **All selected** combines their output chronologically. Filter retained output or follow new lines. Use the trash icon beside a service tab to clear that service’s logs. Clearing keeps the service running and new output continues to appear.
+Each service page has **Logs** and **Requests** tabs for that service. To watch several services at once, open the panel at the bottom: select **Logs** or **Requests** in the bar at the bottom of the window, press **⌘J** (**Ctrl+J**), or choose **Watch in panel** from a service's menu. Pick sources from the **Services** menu; **All selected** combines their output chronologically. Filter retained output or follow new lines. Use the trash icon beside a source to clear its logs or requests after confirming. Clearing keeps the service running and new output continues to appear.
 
-Drag the panel's top edge to resize it, or focus the edge and use the arrow keys or Home/End. Its height is saved in the browser. The panel stays available when navigating between pages.
+Drag the panel's top edge to resize it, or focus the edge and use the arrow keys or Home/End. Its height is saved in the browser. The panel stays open while you move between pages.
 
 **Settings → Logs** sets the display limit from 100 to 5,000 lines, default 1,000. Values above 5,000 are clamped. This controls the dashboard buffer and view; the daemon retains a bounded history of its own, so increasing the setting cannot recover discarded output.
 
@@ -46,17 +66,17 @@ Tunnel requests and sharing events have a **SHARE** label and distinct color. Re
 
 ## Public sharing
 
-Install [cloudflared](https://developers.cloudflare.com/tunnel/downloads/) separately. Start an HTTP service, choose **Share**, enter an optional password, and submit. Leaving the password blank generates one; reveal it with **Show** next to the link. To share without a password, tick **Public link** explicitly. Database services cannot be shared over HTTP.
+Install [cloudflared](https://developers.cloudflare.com/tunnel/downloads/) separately. Start an HTTP service, choose **Share…** from its options menu, enter an optional password, and select **Create link**. Leaving the password blank generates one; reveal it with **Show** next to the link. To share without a password, tick **Public link** explicitly. Database services cannot be shared over HTTP.
 
-The menu closes on submission. The generated URL appears below the local URL with a spinner until verified. At one minute, a hint suggests opening it manually; a request reaching the public tunnel can confirm readiness even when the daemon's DNS probe fails. Startup has a two-minute limit. Failure closes the tunnel and shows an inline error with retry guidance.
+The dialog closes on submission. The generated URL appears below the local URL with a spinner until verified. At one minute, a hint suggests opening it manually; a request reaching the public tunnel can confirm readiness even when the daemon's DNS probe fails. Startup has a two-minute limit. Failure closes the tunnel and shows an inline error with retry guidance.
 
-Pending state, the generated URL, and startup failures live in the daemon and survive dashboard refresh. They are not restored after daemon shutdown. Active protected links display a masked password with Show/Hide; the password is fetched on demand and is not included in service listings or events. The Share menu also provides Copy link and Stop sharing.
+Pending state, the generated URL, and startup failures live in the daemon and survive dashboard refresh. They are not restored after daemon shutdown. Active protected links display a masked password with Show/Hide; the password is fetched on demand and is not included in service listings or events. Copy the link with the button beside it; **Stop sharing** is in the service's options menu.
 
 Quick Tunnel URLs are temporary and depend on Cloudflare DNS and connectivity. Stop sharing, service stop/restart, terminal disconnect, and daemon shutdown end the link. Named tunnels and custom public domains are not configured in v1.
 
 ## Clean URLs
 
-Enable **Clean URLs** in Settings or through the prompt above Local runtime. LocalDeck verifies its own response through port 80 before displaying links without `:7777`. Keep the dashboard itself on its original port.
+Enable **Clean URLs** in Settings or through the notice at the bottom of the sidebar. LocalDeck verifies its own response through port 80 before displaying links without `:7777`. Keep the dashboard itself on its original port.
 
 On macOS, installation may request administrator approval for a localhost-only system forwarder. It runs Apple's `nc` as the normal user and survives reboot. The daemon and application processes remain unprivileged. Cancellation retains the normal URLs; retry from Settings when needed.
 

package/docs/mcp.md

@@ -51,8 +51,8 @@ A protocol connection alone starts no apps. The first tool call starts the daemo
 | Tool | What it does |
 | --- | --- |
 | `list_projects` | List remembered projects, IDs and configuration availability. |
-| `list_services` | List registered and configured services, including ones that have never run. Optional `projectId` filter. |
-| `get_service` | Read a configured or registered service's state; ports, URLs and counters appear after its first start. |
+| `list_services` | List registered and configured services, including ones that have never run. Optional `projectId` filter. Running services include the `profiles` they started with and `restartNeeded`. |
+| `get_service` | Read a configured or registered service's state; ports, URLs and counters appear after its first start. `configuration` shows the resolved command and where each setting came from (base or a profile); environment and secret values are not returned. |
 | `get_logs` | Read recent logs, optionally filtered by `stream`: stdout, stderr or system. |
 | `get_requests` | Read HTTP request records, captured headers, and body previews when available, optionally filtered by exact `status`, `method`, or a `path` substring. |
 | `get_response` | Read a cached response body using the exact service key and request ID from `get_requests`; does not replay the request. |
@@ -66,7 +66,9 @@ A protocol connection alone starts no apps. The first tool call starts the daemo
 | `save_check` | Save a recorded GET/HEAD using `projectId`, `serviceKey`, `requestId`, `name`, and `expectedStatus` (100–599), without running it. |
 | `list_checks` | Read a project's saved checks and retained results. |
 | `run_check` | Explicitly execute one saved `checkId` against its current local service. Even GET can have side effects. |
-| `start_service` | Start a configured service and prerequisites in the background, using the daemon supervisor. |
+| `list_profiles` | Read a project's profiles, which services each changes, which are on, and any clashes. |
+| `set_profiles` | Replace the list of profiles turned on for `projectId` on this computer. Never starts, stops or restarts services; running services report `restartNeeded` until restarted. |
+| `start_service` | Start a configured service and prerequisites in the background, using the daemon supervisor. Uses the project's active profiles. |
 | `stop_service` | Stop a registered service and its share. Terminal services receive the existing stop request. |
 | `restart_service` | Restart a configured daemon-owned service. Active terminal services must be restarted in their original terminal. |
 | `replay_request` | Resend a recorded GET/HEAD, selected by `requestId`, to that service's current local upstream. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "localdeck",
-  "version": "1.5.0",
+  "version": "1.6.2",
   "type": "module",
   "description": "Stable ports, shareable HTTPS links and request logs for your local dev servers",
   "bin": {