Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

fix(desktop): sync plan mode both ways with web, off by default (#126086)

Shy Alter95938f64f72c
diff --git a/products/desktop/packages/ui/src/features/settings/serverTaskDefaults.contribution.test.ts b/products/desktop/packages/ui/src/features/settings/serverTaskDefaults.contribution.test.ts
index 86ac5d76e186..0a2270de43d9 100644
--- a/products/desktop/packages/ui/src/features/settings/serverTaskDefaults.contribution.test.ts
+++ b/products/desktop/packages/ui/src/features/settings/serverTaskDefaults.contribution.test.ts
@@ -44,7 +44,7 @@ const openProject = (projectId: number) =>
describe("ServerTaskDefaultsContribution", () => {
it("does not carry a project's value into the next project when the person switches mid-sync", async () => {
- const inSync = { autoPublishCloudRuns: true, planModeOffered: true };
+ const inSync = { autoPublishCloudRuns: true, startInPlanMode: true };
useSettingsStore.setState({
_hasHydrated: true,
autoPublishCloudRuns: true,
@@ -80,4 +80,41 @@ describe("ServerTaskDefaultsContribution", () => {
expect(useSettingsStore.getState().autoPublishCloudRuns).toBe(true);
expect(setMyTaskDefaults).not.toHaveBeenCalledWith(2, expect.anything());
});
+
+ it("does not upload plan mode it took from another project when the person switches back", async () => {
+ setMyTaskDefaults.mockClear();
+ const off = { autoPublishCloudRuns: true, startInPlanMode: false };
+ useSettingsStore.setState({
+ _hasHydrated: true,
+ autoPublishCloudRuns: true,
+ defaultInitialTaskMode: "last_used",
+ taskDefaultsOnServer: { "3": off, "4": off },
+ });
+ getMyTaskRunConfig.mockImplementation((projectId: number) =>
+ Promise.resolve({
+ taskDefaults: {
+ start_in_plan_mode: projectId === 3,
+ auto_publish_cloud_runs: true,
+ },
+ }),
+ );
+ openProject(3);
+
+ new ServerTaskDefaultsContribution({} as HostTrpcClient).start();
+ await flush();
+ await flush();
+ expect(useSettingsStore.getState().defaultInitialTaskMode).toBe("plan");
+
+ openProject(4);
+ await flush();
+ await flush();
+
+ expect(useSettingsStore.getState().defaultInitialTaskMode).toBe(
+ "last_used",
+ );
+ expect(setMyTaskDefaults).not.toHaveBeenCalledWith(
+ 4,
+ expect.objectContaining({ start_in_plan_mode: true }),
+ );
+ });
});
diff --git a/products/desktop/packages/ui/src/features/settings/serverTaskDefaults.contribution.ts b/products/desktop/packages/ui/src/features/settings/serverTaskDefaults.contribution.ts
index 96061cd0e793..bb406bdbf9f6 100644
--- a/products/desktop/packages/ui/src/features/settings/serverTaskDefaults.contribution.ts
+++ b/products/desktop/packages/ui/src/features/settings/serverTaskDefaults.contribution.ts
@@ -39,7 +39,8 @@ export class ServerTaskDefaultsContribution implements Contribution {
useSettingsStore.subscribe((state, prev) => {
if (
state._hasHydrated !== prev._hasHydrated ||
- state.autoPublishCloudRuns !== prev.autoPublishCloudRuns
+ state.autoPublishCloudRuns !== prev.autoPublishCloudRuns ||
+ state.defaultInitialTaskMode !== prev.defaultInitialTaskMode
) {
void this.reconcile(false);
}
@@ -56,10 +57,11 @@ export class ServerTaskDefaultsContribution implements Contribution {
if (!settings._hasHydrated || projectId == null) return;
const synced = settings.taskDefaultsOnServer[String(projectId)];
const local = settings.autoPublishCloudRuns;
+ const localMode = settings.defaultInitialTaskMode;
if (
!fetchAlways &&
- synced?.planModeOffered &&
- synced.autoPublishCloudRuns === local
+ synced?.autoPublishCloudRuns === local &&
+ synced.startInPlanMode === (localMode === "plan")
) {
return;
}
@@ -86,7 +88,7 @@ export class ServerTaskDefaultsContribution implements Contribution {
const sync = nextTaskDefaultsSync({
server: taskDefaults,
localAutoPublishCloudRuns: local,
- localInitialTaskMode: settings.defaultInitialTaskMode,
+ localInitialTaskMode: localMode,
synced,
});
if (Object.keys(sync.upload).length > 0) {
@@ -99,13 +101,17 @@ export class ServerTaskDefaultsContribution implements Contribution {
return;
}
const store = useSettingsStore.getState();
- if (store.autoPublishCloudRuns !== local) {
+ if (
+ store.autoPublishCloudRuns !== local ||
+ store.defaultInitialTaskMode !== localMode
+ ) {
// The person changed the setting while the request ran. The rerun
// sends that change.
this.rerun.add(projectId);
store.setTaskDefaultsOnServer(projectId, {
...sync.synced,
autoPublishCloudRuns: local,
+ startInPlanMode: localMode === "plan",
});
return;
}
@@ -115,6 +121,23 @@ export class ServerTaskDefaultsContribution implements Contribution {
if (sync.pullAutoPublishCloudRuns !== null) {
store.setAutoPublishCloudRuns(sync.pullAutoPublishCloudRuns);
}
+ if (sync.pullInitialTaskMode !== null) {
+ const pulledPlan = sync.pullInitialTaskMode === "plan";
+ for (const [otherId, other] of Object.entries(
+ store.taskDefaultsOnServer,
+ )) {
+ if (
+ otherId !== String(projectId) &&
+ other.startInPlanMode !== undefined
+ ) {
+ store.setTaskDefaultsOnServer(Number(otherId), {
+ ...other,
+ startInPlanMode: pulledPlan,
+ });
+ }
+ }
+ store.setDefaultInitialTaskMode(sync.pullInitialTaskMode);
+ }
} catch (err) {
log.warn("Failed to sync task defaults with the server", err);
} finally {
diff --git a/products/desktop/packages/ui/src/features/settings/serverTaskDefaults.test.ts b/products/desktop/packages/ui/src/features/settings/serverTaskDefaults.test.ts
index a73410ee39bc..7dbf7f8b18a0 100644
--- a/products/desktop/packages/ui/src/features/settings/serverTaskDefaults.test.ts
+++ b/products/desktop/packages/ui/src/features/settings/serverTaskDefaults.test.ts
@@ -1,85 +1,172 @@
import { describe, expect, it } from "vitest";
import { nextTaskDefaultsSync } from "./serverTaskDefaults";
+import type { DefaultInitialTaskMode } from "./settingsStore";
const UNSET = { start_in_plan_mode: null, auto_publish_cloud_runs: null };
+const OFF = { start_in_plan_mode: false, auto_publish_cloud_runs: false };
+const ON = { start_in_plan_mode: true, auto_publish_cloud_runs: true };
+
+interface Case {
+ server: {
+ start_in_plan_mode: boolean | null;
+ auto_publish_cloud_runs: boolean | null;
+ };
+ autoPublish: boolean;
+ mode: DefaultInitialTaskMode;
+ synced:
+ | { autoPublishCloudRuns: boolean; startInPlanMode?: boolean }
+ | undefined;
+ upload: Record<string, boolean>;
+ pullAutoPublish: boolean | null;
+ pullMode: DefaultInitialTaskMode | null;
+ agreed: { autoPublishCloudRuns: boolean; startInPlanMode: boolean };
+}
describe("serverTaskDefaults", () => {
- it.each([
+ it.each<[string, Case]>([
+ [
+ "first sync, nothing set on the server: pull requests move up, plan mode reads as off and Desktop follows",
+ {
+ server: UNSET,
+ autoPublish: true,
+ mode: "plan",
+ synced: undefined,
+ upload: { auto_publish_cloud_runs: true },
+ pullAutoPublish: null,
+ pullMode: "last_used",
+ agreed: { autoPublishCloudRuns: true, startInPlanMode: false },
+ },
+ ],
+ [
+ "first sync, nothing set on the server, Desktop on Last used: nothing changes for plan mode",
+ {
+ server: UNSET,
+ autoPublish: false,
+ mode: "last_used",
+ synced: undefined,
+ upload: { auto_publish_cloud_runs: false },
+ pullAutoPublish: null,
+ pullMode: null,
+ agreed: { autoPublishCloudRuns: false, startInPlanMode: false },
+ },
+ ],
[
- "nothing set on the server: Desktop values move up",
- UNSET,
- true,
- "plan",
- undefined,
- { start_in_plan_mode: true, auto_publish_cloud_runs: true },
- null,
- true,
+ "first sync, values off on web: web wins",
+ {
+ server: OFF,
+ autoPublish: true,
+ mode: "plan",
+ synced: undefined,
+ upload: {},
+ pullAutoPublish: false,
+ pullMode: "last_used",
+ agreed: { autoPublishCloudRuns: false, startInPlanMode: false },
+ },
],
[
- "'Last used' is not offered to the server",
- UNSET,
- false,
- "last_used",
- undefined,
- { auto_publish_cloud_runs: false },
- null,
- false,
+ "first sync, values on on web: web wins",
+ {
+ server: ON,
+ autoPublish: false,
+ mode: "last_used",
+ synced: undefined,
+ upload: {},
+ pullAutoPublish: true,
+ pullMode: "plan",
+ agreed: { autoPublishCloudRuns: true, startInPlanMode: true },
+ },
],
[
- "values chosen on web win on the first sync",
- { start_in_plan_mode: false, auto_publish_cloud_runs: false },
- true,
- "plan",
- undefined,
- {},
- false,
- false,
+ "state saved before plan mode synced: the plan mode sync starts as a first sync",
+ {
+ server: OFF,
+ autoPublish: false,
+ mode: "plan",
+ synced: { autoPublishCloudRuns: false },
+ upload: {},
+ pullAutoPublish: null,
+ pullMode: "last_used",
+ agreed: { autoPublishCloudRuns: false, startInPlanMode: false },
+ },
],
[
"a Desktop change since the last sync moves up",
- { start_in_plan_mode: true, auto_publish_cloud_runs: true },
- false,
- "plan",
- { autoPublishCloudRuns: true, planModeOffered: true },
- { auto_publish_cloud_runs: false },
- null,
- false,
+ {
+ server: ON,
+ autoPublish: false,
+ mode: "last_used",
+ synced: { autoPublishCloudRuns: true, startInPlanMode: true },
+ upload: { auto_publish_cloud_runs: false, start_in_plan_mode: false },
+ pullAutoPublish: null,
+ pullMode: null,
+ agreed: { autoPublishCloudRuns: false, startInPlanMode: false },
+ },
+ ],
+ [
+ "a Desktop change to Plan moves up over an unset server value",
+ {
+ server: UNSET,
+ autoPublish: true,
+ mode: "plan",
+ synced: { autoPublishCloudRuns: true, startInPlanMode: false },
+ upload: { auto_publish_cloud_runs: true, start_in_plan_mode: true },
+ pullAutoPublish: null,
+ pullMode: null,
+ agreed: { autoPublishCloudRuns: true, startInPlanMode: true },
+ },
],
[
"a web change since the last sync comes down",
- { start_in_plan_mode: true, auto_publish_cloud_runs: false },
- true,
- "plan",
- { autoPublishCloudRuns: true, planModeOffered: true },
- {},
- false,
- false,
+ {
+ server: OFF,
+ autoPublish: true,
+ mode: "plan",
+ synced: { autoPublishCloudRuns: true, startInPlanMode: true },
+ upload: {},
+ pullAutoPublish: false,
+ pullMode: "last_used",
+ agreed: { autoPublishCloudRuns: false, startInPlanMode: false },
+ },
+ ],
+ [
+ "both sides changed: Desktop wins",
+ {
+ server: OFF,
+ autoPublish: false,
+ mode: "last_used",
+ synced: { autoPublishCloudRuns: true, startInPlanMode: true },
+ upload: { auto_publish_cloud_runs: false, start_in_plan_mode: false },
+ pullAutoPublish: null,
+ pullMode: null,
+ agreed: { autoPublishCloudRuns: false, startInPlanMode: false },
+ },
],
[
"in step: nothing to do",
- { start_in_plan_mode: null, auto_publish_cloud_runs: true },
- true,
- "plan",
- { autoPublishCloudRuns: true, planModeOffered: true },
- {},
- null,
- true,
+ {
+ server: ON,
+ autoPublish: true,
+ mode: "plan",
+ synced: { autoPublishCloudRuns: true, startInPlanMode: true },
+ upload: {},
+ pullAutoPublish: null,
+ pullMode: null,
+ agreed: { autoPublishCloudRuns: true, startInPlanMode: true },
+ },
],
- ] as const)(
- "%s",
- (_case, server, local, mode, synced, upload, pull, agreed) => {
- expect(
- nextTaskDefaultsSync({
- server,
- localAutoPublishCloudRuns: local,
- localInitialTaskMode: mode,
- synced,
- }),
- ).toEqual({
- upload,
- pullAutoPublishCloudRuns: pull,
- synced: { autoPublishCloudRuns: agreed, planModeOffered: true },
- });
- },
- );
+ ])("%s", (_case, c) => {
+ expect(
+ nextTaskDefaultsSync({
+ server: c.server,
+ localAutoPublishCloudRuns: c.autoPublish,
+ localInitialTaskMode: c.mode,
+ synced: c.synced,
+ }),
+ ).toEqual({
+ upload: c.upload,
+ pullAutoPublishCloudRuns: c.pullAutoPublish,
+ pullInitialTaskMode: c.pullMode,
+ synced: c.agreed,
+ });
+ });
});
diff --git a/products/desktop/packages/ui/src/features/settings/serverTaskDefaults.ts b/products/desktop/packages/ui/src/features/settings/serverTaskDefaults.ts
index a9623eec2f69..bdf0d2657a6c 100644
--- a/products/desktop/packages/ui/src/features/settings/serverTaskDefaults.ts
+++ b/products/desktop/packages/ui/src/features/settings/serverTaskDefaults.ts
@@ -8,15 +8,16 @@ export interface TaskDefaultsSync {
upload: Partial<Record<keyof TaskDefaults, boolean>>;
// Set when the server holds a newer "always create pull requests" value.
pullAutoPublishCloudRuns: boolean | null;
+ pullInitialTaskMode: DefaultInitialTaskMode | null;
synced: TaskDefaultsSyncState;
}
/**
* What to sync between Desktop and the task defaults on the server for one
- * project. A value nobody set on the server takes the Desktop value, so Desktop
- * users keep what they have. "Start in" is offered once and stays local after.
- * "Always create pull requests" stays in step both ways: the side that changed
- * since the last sync wins.
+ * project. Both values stay in step both ways: the side that changed since the
+ * last sync wins, and on the first sync the server wins. An unset "always
+ * create pull requests" takes the Desktop value. An unset "Start in plan mode"
+ * reads as off, so plan mode stays off until a person turns it on.
*/
export function nextTaskDefaultsSync(input: {
server: TaskDefaults;
@@ -24,37 +25,66 @@ export function nextTaskDefaultsSync(input: {
localInitialTaskMode: DefaultInitialTaskMode;
synced: TaskDefaultsSyncState | undefined;
}): TaskDefaultsSync {
- const { server, localAutoPublishCloudRuns: local, synced } = input;
+ const { server, localAutoPublishCloudRuns, localInitialTaskMode, synced } =
+ input;
const upload: TaskDefaultsSync["upload"] = {};
- if (
- !synced?.planModeOffered &&
- server.start_in_plan_mode === null &&
- input.localInitialTaskMode === "plan"
- ) {
- upload.start_in_plan_mode = true;
+ const autoPublish = syncFlag({
+ remote: server.auto_publish_cloud_runs,
+ local: localAutoPublishCloudRuns,
+ last: synced?.autoPublishCloudRuns,
+ unsetRemote: "upload",
+ });
+ if (autoPublish.upload !== undefined) {
+ upload.auto_publish_cloud_runs = autoPublish.upload;
}
- let agreed = local;
- let pull: boolean | null = null;
- const remote = server.auto_publish_cloud_runs;
- if (remote === null) {
- upload.auto_publish_cloud_runs = local;
- } else if (synced === undefined) {
- // First sync on this device: a value already on the server was chosen on purpose.
- agreed = remote;
- } else if (local !== synced.autoPublishCloudRuns) {
- upload.auto_publish_cloud_runs = local;
- } else {
- agreed = remote;
- }
- if (agreed !== local) {
- pull = agreed;
+ const localPlan = localInitialTaskMode === "plan";
+ const planMode = syncFlag({
+ remote: server.start_in_plan_mode,
+ local: localPlan,
+ last: synced?.startInPlanMode,
+ unsetRemote: "off",
+ });
+ if (planMode.upload !== undefined) {
+ upload.start_in_plan_mode = planMode.upload;
}
return {
upload,
- pullAutoPublishCloudRuns: pull,
- synced: { autoPublishCloudRuns: agreed, planModeOffered: true },
+ pullAutoPublishCloudRuns:
+ autoPublish.agreed !== localAutoPublishCloudRuns
+ ? autoPublish.agreed
+ : null,
+ pullInitialTaskMode:
+ planMode.agreed !== localPlan
+ ? planMode.agreed
+ ? "plan"
+ : "last_used"
+ : null,
+ synced: {
+ autoPublishCloudRuns: autoPublish.agreed,
+ startInPlanMode: planMode.agreed,
+ },
};
}
+
+function syncFlag(input: {
+ remote: boolean | null;
+ local: boolean;
+ last: boolean | undefined;
+ unsetRemote: "upload" | "off";
+}): { upload?: boolean; agreed: boolean } {
+ const { local, last } = input;
+ if (input.remote === null && input.unsetRemote === "upload") {
+ return { upload: local, agreed: local };
+ }
+ const remote = input.remote ?? false;
+ if (last === undefined) {
+ return { agreed: remote };
+ }
+ if (local !== last) {
+ return { upload: local, agreed: local };
+ }
+ return { agreed: remote };
+}
diff --git a/products/desktop/packages/ui/src/features/settings/settingsStore.ts b/products/desktop/packages/ui/src/features/settings/settingsStore.ts
index 1585389cb72d..7d7910e19eb0 100644
--- a/products/desktop/packages/ui/src/features/settings/settingsStore.ts
+++ b/products/desktop/packages/ui/src/features/settings/settingsStore.ts
@@ -131,8 +131,7 @@ export function countRetiredHints(hints: Record<string, HintState>): number {
export interface TaskDefaultsSyncState {
// The "always create pull requests" value Desktop and the server last agreed on.
autoPublishCloudRuns: boolean;
- // The local "Start in" choice was offered to the server once.
- planModeOffered: boolean;
+ startInPlanMode?: boolean;
}
export interface SyncedCustomInstructions {