// @effect-diagnostics nodeBuiltinImport:off - CLI integration exercises the filesystem boundary.import * as NodeFS from "node:fs";import * as NodeOS from "node:os";import * as NodePath from "node:path"; import * as NodeServices from "@effect/platform-node/NodeServices";import * as ConfigProvider from "effect/ConfigProvider";import * as NetService from "@t3tools/shared/Net";import { assert, describe, it } from "@effect/vitest";import * as Effect from "effect/Effect";import * as Layer from "effect/Layer";import * as TestConsole from "effect/testing/TestConsole";import { Command } from "effect/unstable/cli"; import { cli } from "../bin.ts";import { symlinksSupported } from "@t3tools/shared/testing/symlinks";import { HostProcessPlatform } from "@t3tools/shared/hostProcess"; // These force a failure with chmod, which Windows ignores for directories and// cannot use to make a file unreadable, so the failure never happens there.const windowsHost = HostProcessPlatform.defaultValue() === "win32"; const runCli = (args: ReadonlyArray<string>) =>  Command.runWith(cli, { version: "0.0.0" })(args).pipe(    Effect.provide(Layer.mergeAll(NodeServices.layer, NetService.layer, TestConsole.layer)),  ); const makeBaseDir = () => NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3code-theme-cli-")); const settingsPathFor = (baseDir: string) => NodePath.join(baseDir, "userdata", "settings.json"); const NIGHTFALL_THEME_JSON = `${JSON.stringify({  name: "Nightfall",  appearance: "dark",  canvas: "#1a1b26",  accent: "#7aa2f7",})}\n`;const JUNK_THEME_JSON = `${JSON.stringify({ name: "Junk" })}\n`; const readSettings = (baseDir: string): Record<string, unknown> => {  const raw = NodeFS.readFileSync(settingsPathFor(baseDir), "utf8");  return JSON.parse(raw) as Record<string, unknown>;}; const writeSettings = (baseDir: string, settings: Record<string, unknown>) => {  NodeFS.mkdirSync(NodePath.dirname(settingsPathFor(baseDir)), { recursive: true });  NodeFS.writeFileSync(settingsPathFor(baseDir), `${JSON.stringify(settings, null, 2)}\n`);}; describe("t3 theme", () => {  it.effect("writes a default theme when no settings file exists yet", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      yield* runCli(["theme", "set", "ocean", "--base-dir", baseDir]);      assert.equal(readSettings(baseDir).defaultTheme, "ocean");    }),  );   // A provisioning command runs against settings written by whatever version  // happens to be installed, so it must not drop what it cannot interpret.  it.effect("preserves settings it does not recognise", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      writeSettings(baseDir, {        enableProviderUpdateChecks: false,        somethingFromANewerBuild: { nested: true },      });       yield* runCli(["theme", "set", "ocean", "--base-dir", baseDir]);       const settings = readSettings(baseDir);      assert.equal(settings.defaultTheme, "ocean");      assert.equal(settings.enableProviderUpdateChecks, false);      assert.deepEqual(settings.somethingFromANewerBuild, { nested: true });    }),  );   it.effect("clears the default back to leaving fresh clients alone", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      writeSettings(baseDir, { enableProviderUpdateChecks: false });       yield* runCli(["theme", "set", "ocean", "--base-dir", baseDir]);      yield* runCli(["theme", "clear", "--base-dir", baseDir]);       const settings = readSettings(baseDir);      assert.equal(Object.hasOwn(settings, "defaultTheme"), false);      assert.equal(settings.enableProviderUpdateChecks, false);    }),  );   // Publishing a file and pointing at it are one step, so an integration  // (a desktop's theme hook) needs no knowledge of the themes directory.  it.effect("publishes a theme file under its filename and sets it", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      const themeFile = NodePath.join(baseDir, "nightfall.json");      NodeFS.writeFileSync(themeFile, NIGHTFALL_THEME_JSON);       yield* runCli(["theme", "set", themeFile, "--base-dir", baseDir]);       const published = NodePath.join(baseDir, "userdata", "themes", "nightfall.json");      assert.equal(NodeFS.existsSync(published), true);      assert.equal(readSettings(baseDir).defaultTheme, "nightfall");      // No rollback or staging residue after a successful set.      const residue = NodeFS.readdirSync(NodePath.dirname(published)).filter(        (entry) => !entry.endsWith(".json"),      );      assert.deepEqual(residue, []);    }),  );   it.effect("publishes a theme file under an explicit id", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      const themeFile = NodePath.join(baseDir, "t3code.json");      NodeFS.writeFileSync(themeFile, NIGHTFALL_THEME_JSON);       yield* runCli(["theme", "set", "--id", "nightfall", themeFile, "--base-dir", baseDir]);       assert.equal(        NodeFS.existsSync(NodePath.join(baseDir, "userdata", "themes", "nightfall.json")),        true,      );      assert.equal(readSettings(baseDir).defaultTheme, "nightfall");    }),  );   it.effect("rejects a file that is not a theme and sets nothing", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      const themeFile = NodePath.join(baseDir, "junk.json");      NodeFS.writeFileSync(themeFile, JUNK_THEME_JSON);       const failure = yield* runCli(["theme", "set", themeFile, "--base-dir", baseDir]).pipe(        Effect.flip,      );       assert.include(String(failure), "not a valid theme file");      assert.equal(NodeFS.existsSync(NodePath.join(baseDir, "userdata", "themes")), false);      assert.equal(NodeFS.existsSync(settingsPathFor(baseDir)), false);    }),  );   // Publish and set are one command, so a settings file the set step cannot  // use must fail it before the themes directory is mutated -- not after,  // with a half-applied publish left behind.  it.effect("publishes nothing when the settings file cannot be used", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      NodeFS.mkdirSync(NodePath.dirname(settingsPathFor(baseDir)), { recursive: true });      NodeFS.writeFileSync(settingsPathFor(baseDir), "{ not json");      const themeFile = NodePath.join(baseDir, "nightfall.json");      NodeFS.writeFileSync(themeFile, NIGHTFALL_THEME_JSON);       const failure = yield* runCli(["theme", "set", themeFile, "--base-dir", baseDir]).pipe(        Effect.flip,      );       assert.include(String(failure), "not a JSON object");      assert.equal(NodeFS.existsSync(NodePath.join(baseDir, "userdata", "themes")), false);    }),  );   // set means set: a publish that rode along with a failed default write is  // rolled back rather than left mutating the environment's theme set. The  // userdata directory is made read-only while themes stays writable, so the  // failure lands after the publish -- the case the rollback exists for.  it.effect.skipIf(windowsHost)("rolls back a publish when the default cannot be written", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      writeSettings(baseDir, {});      const userdataDir = NodePath.dirname(settingsPathFor(baseDir));      const themesDir = NodePath.join(userdataDir, "themes");      NodeFS.mkdirSync(themesDir, { recursive: true });      const themeFile = NodePath.join(baseDir, "nightfall.json");      NodeFS.writeFileSync(themeFile, NIGHTFALL_THEME_JSON);       NodeFS.chmodSync(userdataDir, 0o555);      try {        const failure = yield* runCli(["theme", "set", themeFile, "--base-dir", baseDir]).pipe(          Effect.flip,        );        assert.include(String(failure), "Could not write");        assert.equal(NodeFS.existsSync(NodePath.join(themesDir, "nightfall.json")), false);      } finally {        NodeFS.chmodSync(userdataDir, 0o755);      }    }),  );   // A symlink is a normal way to hand this command a theme -- desktop hooks  // symlink the current palette -- so the source is resolved, not refused.  it.effect.skipIf(!symlinksSupported)(    "publishes a theme file through a symlinked source path",    () =>      Effect.gen(function* () {        const baseDir = makeBaseDir();        const realFile = NodePath.join(baseDir, "real-nightfall.json");        NodeFS.writeFileSync(realFile, NIGHTFALL_THEME_JSON);        const linkPath = NodePath.join(baseDir, "nightfall.json");        NodeFS.symlinkSync(realFile, linkPath);         yield* runCli(["theme", "set", linkPath, "--base-dir", baseDir]);         assert.equal(          NodeFS.existsSync(NodePath.join(baseDir, "userdata", "themes", "nightfall.json")),          true,        );        assert.equal(readSettings(baseDir).defaultTheme, "nightfall");      }),  );   // The staging entry is created fresh with O_EXCL, so a symlink planted at  // its predictable name is cleared, never followed and written through.  it.effect.skipIf(!symlinksSupported)("never writes through a symlink at the staging path", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      const themesDir = NodePath.join(baseDir, "userdata", "themes");      NodeFS.mkdirSync(themesDir, { recursive: true });      const victim = NodePath.join(baseDir, "victim.txt");      NodeFS.writeFileSync(victim, "precious");      NodeFS.symlinkSync(victim, NodePath.join(themesDir, `nightfall.json.staging-${process.pid}`));      const themeFile = NodePath.join(baseDir, "nightfall.json");      NodeFS.writeFileSync(themeFile, NIGHTFALL_THEME_JSON);       yield* runCli(["theme", "set", themeFile, "--base-dir", baseDir]);       assert.equal(NodeFS.readFileSync(victim, "utf8"), "precious");      assert.equal(readSettings(baseDir).defaultTheme, "nightfall");    }),  );   // Rollback moves the previous directory entry aside and back, so even an  // entry the watcher would never publish -- here a symlink -- comes back  // exactly as it was when the set fails.  it.effect.skipIf(!symlinksSupported || windowsHost)(    "restores a non-theme destination entry when the set fails",    () =>      Effect.gen(function* () {        const baseDir = makeBaseDir();        writeSettings(baseDir, {});        const userdataDir = NodePath.dirname(settingsPathFor(baseDir));        const themesDir = NodePath.join(userdataDir, "themes");        NodeFS.mkdirSync(themesDir, { recursive: true });        const outside = NodePath.join(baseDir, "outside.json");        NodeFS.writeFileSync(outside, NIGHTFALL_THEME_JSON);        const destination = NodePath.join(themesDir, "nightfall.json");        NodeFS.symlinkSync(outside, destination);        const themeFile = NodePath.join(baseDir, "nightfall.json");        NodeFS.writeFileSync(themeFile, NIGHTFALL_THEME_JSON);         NodeFS.chmodSync(userdataDir, 0o555);        try {          yield* runCli(["theme", "set", themeFile, "--base-dir", baseDir]).pipe(Effect.flip);          assert.equal(NodeFS.lstatSync(destination).isSymbolicLink(), true);        } finally {          NodeFS.chmodSync(userdataDir, 0o755);        }      }),  );   it.effect.skipIf(windowsHost)("restores the previous theme when a re-publish fails to set", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      writeSettings(baseDir, {});      const userdataDir = NodePath.dirname(settingsPathFor(baseDir));      const themesDir = NodePath.join(userdataDir, "themes");      NodeFS.mkdirSync(themesDir, { recursive: true });      const publishedPath = NodePath.join(themesDir, "nightfall.json");      const previous =        '{ "name": "Old Nightfall", "appearance": "dark", "canvas": "#000000", "accent": "#ffffff" }\n';      NodeFS.writeFileSync(publishedPath, previous);      const themeFile = NodePath.join(baseDir, "nightfall.json");      NodeFS.writeFileSync(themeFile, NIGHTFALL_THEME_JSON);       NodeFS.chmodSync(userdataDir, 0o555);      try {        yield* runCli(["theme", "set", themeFile, "--base-dir", baseDir]).pipe(Effect.flip);        assert.equal(NodeFS.readFileSync(publishedPath, "utf8"), previous);      } finally {        NodeFS.chmodSync(userdataDir, 0o755);      }    }),  );   // A typo'd id written as the theme would silently never resolve anywhere;  // the id branch is as strict as the filename rule.  it.effect("rejects an id no client could resolve", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      const failure = yield* runCli(["theme", "set", "Nightfall", "--base-dir", baseDir]).pipe(        Effect.flip,      );      assert.include(String(failure), "not a valid theme id");      assert.equal(NodeFS.existsSync(settingsPathFor(baseDir)), false);    }),  );   it.effect("rejects a path that does not exist instead of storing it as an id", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      const failure = yield* runCli([        "theme",        "set",        `${baseDir}/missing.json`,        "--base-dir",        baseDir,      ]).pipe(Effect.flip);      assert.include(String(failure), "Could not read");    }),  );   // File-ness is decided by existence, not extension, so a generated file  // named for its target app still publishes.  it.effect("publishes an extensionless file", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      const themeFile = NodePath.join(baseDir, "brand");      NodeFS.writeFileSync(themeFile, NIGHTFALL_THEME_JSON);       yield* runCli(["theme", "set", themeFile, "--base-dir", baseDir]);       assert.equal(        NodeFS.existsSync(NodePath.join(baseDir, "userdata", "themes", "brand.json")),        true,      );      assert.equal(readSettings(baseDir).defaultTheme, "brand");    }),  );   it.effect("records a set generation and clears it with the theme", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      yield* runCli(["theme", "set", "ocean", "--base-dir", baseDir]);      const setAt = readSettings(baseDir).defaultThemeSetAt;      assert.equal(typeof setAt, "string");       yield* runCli(["theme", "clear", "--base-dir", baseDir]);      const cleared = readSettings(baseDir);      assert.equal(Object.hasOwn(cleared, "defaultTheme"), false);      assert.equal(Object.hasOwn(cleared, "defaultThemeSetAt"), false);    }),  );   it.effect("honors T3CODE_HOME like the rest of the CLI", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      yield* runCli(["theme", "set", "ocean"]).pipe(        Effect.provide(          ConfigProvider.layer(ConfigProvider.fromEnv({ env: { T3CODE_HOME: baseDir } })),        ),      );      assert.equal(readSettings(baseDir).defaultTheme, "ocean");    }),  );   // An unreadable settings file must never read as "no settings": writing a  // fresh sparse file over it would discard every key the user had.  it.effect.skipIf(windowsHost)("refuses to write when the settings file cannot be read", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      writeSettings(baseDir, { enableProviderUpdateChecks: false });      NodeFS.chmodSync(settingsPathFor(baseDir), 0o000);       const failure = yield* runCli(["theme", "set", "ocean", "--base-dir", baseDir]).pipe(        Effect.flip,      );       NodeFS.chmodSync(settingsPathFor(baseDir), 0o644);      assert.include(String(failure), "Could not read");      assert.equal(readSettings(baseDir).enableProviderUpdateChecks, false);      assert.equal(Object.hasOwn(readSettings(baseDir), "defaultTheme"), false);    }),  );   // A typo is syntactically a valid id, so shape validation alone would write  // a theme no client can resolve and report success.  it.effect("rejects an id that names no theme", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      const failure = yield* runCli(["theme", "set", "ocian", "--base-dir", baseDir]).pipe(        Effect.flip,      );      assert.include(String(failure), "No theme named");      assert.equal(NodeFS.existsSync(settingsPathFor(baseDir)), false);    }),  );   it.effect("accepts an id a published file provides", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      const themeFile = NodePath.join(baseDir, "nightfall.json");      NodeFS.writeFileSync(themeFile, NIGHTFALL_THEME_JSON);      yield* runCli(["theme", "set", themeFile, "--base-dir", baseDir]);       // Now resolvable by bare id, because the file published it.      yield* runCli(["theme", "clear", "--base-dir", baseDir]);      yield* runCli(["theme", "set", "nightfall", "--base-dir", baseDir]);      assert.equal(readSettings(baseDir).defaultTheme, "nightfall");    }),  );   // The watcher skips files it cannot use, so accepting their filename would  // set a theme no client ever receives.  it.effect("rejects an id whose published file the watcher would skip", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      const themesDir = NodePath.join(baseDir, "userdata", "themes");      NodeFS.mkdirSync(themesDir, { recursive: true });      NodeFS.writeFileSync(NodePath.join(themesDir, "broken.json"), "{ not json\n");       const failure = yield* runCli(["theme", "set", "broken", "--base-dir", baseDir]).pipe(        Effect.flip,      );      assert.include(String(failure), "No theme named");    }),  );   // Web and desktop cannot resolve the mobile default, and mobile does not  // follow this setting, so naming it would be a silent no-op.  it.effect("rejects the mobile default theme id", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      const failure = yield* runCli(["theme", "set", "t3-code", "--base-dir", baseDir]).pipe(        Effect.flip,      );      assert.include(String(failure), "No theme named");    }),  );   // Deciding on existence alone would publish ./ocean instead of selecting the  // built-in, purely because of what happens to be in the working directory.  it.effect("treats a bare id as an id even when a file shares its name", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      const cwdFile = NodePath.join(baseDir, "ocean");      NodeFS.writeFileSync(cwdFile, NIGHTFALL_THEME_JSON);       const previous = process.cwd();      process.chdir(baseDir);      try {        yield* runCli(["theme", "set", "ocean", "--base-dir", baseDir]);      } finally {        process.chdir(previous);      }       assert.equal(readSettings(baseDir).defaultTheme, "ocean");      assert.equal(        NodeFS.existsSync(NodePath.join(baseDir, "userdata", "themes", "ocean.json")),        false,      );    }),  );   // The watcher would skip an oversized file, so publishing one must not  // report success for a theme no client receives.  it.effect("rejects a theme file larger than the watcher will read", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      const themeFile = NodePath.join(baseDir, "huge.json");      const padding = "x".repeat(40 * 1024);      NodeFS.writeFileSync(        themeFile,        `{ "name": "Huge", "appearance": "dark", "canvas": "#1a1b26", "accent": "#7aa2f7", "note": "${padding}" }\n`,      );       const failure = yield* runCli(["theme", "set", themeFile, "--base-dir", baseDir]).pipe(        Effect.flip,      );      assert.include(String(failure), "larger than");    }),  );   it.effect("refuses a settings file that is not a JSON object", () =>    Effect.gen(function* () {      const baseDir = makeBaseDir();      NodeFS.mkdirSync(NodePath.dirname(settingsPathFor(baseDir)), { recursive: true });      NodeFS.writeFileSync(settingsPathFor(baseDir), "[1, 2, 3]\n");       const failure = yield* runCli(["theme", "set", "ocean", "--base-dir", baseDir]).pipe(        Effect.flip,      );       assert.include(String(failure), "not a JSON object");    }),  );});