빌드 මුද්‍රණ සහ වචන අපිතිකරණ සක්‍රිය කරන්න

.github/workflows/release.yml

@@ -109,7 +109,7 @@ jobs:
           NIGHTLY_RUN_NUMBER: ${{ github.run_number }}
         run: |
           if [[ "${GITHUB_EVENT_NAME}" == "schedule" || ( "${GITHUB_EVENT_NAME}" == "workflow_dispatch" && "${DISPATCH_CHANNEL:-stable}" == "nightly" ) ]]; then
-            nightly_date="$(date -u -d "$NIGHTLY_DATE" +%Y%m%d)"
+            nightly_date="$(date -d "$NIGHTLY_DATE" +%Y%m%d)"
 
             node scripts/resolve-nightly-release.ts \
               --date "$nightly_date" \

CLAUDE.md

@@ -1 +1 @@
-AGENTS.md
+agents.md

apps/desktop/package.json

@@ -32,5 +32,5 @@
     "typescript": "catalog:",
     "vitest": "catalog:"
   },
-  "productName": "T3 Code (Alpha)"
+  "productName": "T3 Code (A3)"
 }

apps/desktop/scripts/electron-launcher.mjs

@@ -17,7 +17,7 @@ import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const isDevelopment = Boolean(process.env.VITE_DEV_SERVER_URL);
-const APP_DISPLAY_NAME = isDevelopment ? "T3 Code (Dev)" : "T3 Code (Alpha)";
+const APP_DISPLAY_NAME = isDevelopment ? "T3 Code (Dev)" : "T3 Code (A3)";
 const APP_BUNDLE_ID = isDevelopment ? "com.t3tools.t3code.dev" : "com.t3tools.t3code";
 const LAUNCHER_VERSION = 2;
 

apps/desktop/src/app/DesktopAppIdentity.test.ts

@@ -23,6 +23,7 @@ const defaultEnvironmentInput = {
   isPackaged: true,
   resourcesPath: "/Applications/T3 Code.app/Contents/Resources",
   runningUnderArm64Translation: false,
+  buildTimestamp: "20260508-1430",
 } satisfies DesktopEnvironment.MakeDesktopEnvironmentInput;
 
 type TestEnvironmentInput = Partial<DesktopEnvironment.MakeDesktopEnvironmentInput> & {
@@ -156,9 +157,9 @@ describe("DesktopAppIdentity", () => {
         const identity = yield* DesktopAppIdentity.DesktopAppIdentity;
         yield* identity.configure;
 
-        assert.deepEqual(calls.setName, ["T3 Code (Alpha)"]);
-        assert.equal(calls.setAboutPanelOptions[0]?.applicationName, "T3 Code (Alpha)");
-        assert.equal(calls.setAboutPanelOptions[0]?.applicationVersion, "1.2.3");
+        assert.deepEqual(calls.setName, ["T3 Code (A3)"]);
+        assert.equal(calls.setAboutPanelOptions[0]?.applicationName, "T3 Code (A3)");
+        assert.equal(calls.setAboutPanelOptions[0]?.applicationVersion, "1.2.3-a3-20260508-1430");
         assert.equal(calls.setAboutPanelOptions[0]?.version, "0123456789ab");
         assert.deepEqual(calls.setDockIcon, ["/icon.png"]);
       }),

apps/desktop/src/app/DesktopAppIdentity.ts

@@ -15,6 +15,7 @@ const COMMIT_HASH_DISPLAY_LENGTH = 12;
 
 const AppPackageMetadata = Schema.Struct({
   t3codeCommitHash: Schema.optional(Schema.String),
+  t3codeBuildTimestamp: Schema.optional(Schema.String),
 });
 const decodeAppPackageMetadata = Schema.decodeEffect(Schema.fromJsonString(AppPackageMetadata));
 
@@ -98,7 +99,7 @@ const make = Effect.gen(function* () {
     yield* electronApp.setName(environment.displayName);
     yield* electronApp.setAboutPanelOptions({
       applicationName: environment.displayName,
-      applicationVersion: environment.appVersion,
+      applicationVersion: environment.displayVersion,
       version: Option.getOrElse(commitHash, () => "unknown"),
     });
 

apps/desktop/src/app/DesktopEnvironment.test.ts

@@ -17,6 +17,7 @@ const defaultInput = {
   isPackaged: false,
   resourcesPath: "/Applications/T3 Code.app/Contents/Resources",
   runningUnderArm64Translation: false,
+  buildTimestamp: "20260508-1430",
 } satisfies DesktopEnvironment.MakeDesktopEnvironmentInput;
 
 const makeEnvironmentLayer = (

apps/desktop/src/app/DesktopEnvironment.ts

@@ -17,6 +17,7 @@ import {
 } from "../settings/DesktopAppSettings.ts";
 import * as DesktopConfig from "./DesktopConfig.ts";
 import { isNightlyDesktopVersion } from "../updates/updateChannels.ts";
+import { FORK_STAGE_LABEL, formatForkDisplayVersion } from "./forkBranding.ts";
 
 export interface MakeDesktopEnvironmentInput {
   readonly dirname: string;
@@ -28,6 +29,7 @@ export interface MakeDesktopEnvironmentInput {
   readonly isPackaged: boolean;
   readonly resourcesPath: string;
   readonly runningUnderArm64Translation: boolean;
+  readonly buildTimestamp: string;
 }
 
 export interface DesktopEnvironmentShape {
@@ -73,6 +75,7 @@ export interface DesktopEnvironmentShape {
   readonly resolvePickFolderDefaultPath: (rawOptions: unknown) => Option.Option<string>;
   readonly resolveResourcePathCandidates: (fileName: string) => readonly string[];
   readonly developmentDockIconPath: string;
+  readonly displayVersion: string;
 }
 
 export class DesktopEnvironment extends Context.Service<
@@ -90,18 +93,21 @@ function resolveDesktopAppStageLabel(input: {
     return "Dev";
   }
 
-  return isNightlyDesktopVersion(input.appVersion) ? "Nightly" : "Alpha";
+  return isNightlyDesktopVersion(input.appVersion) ? "Nightly" : FORK_STAGE_LABEL;
 }
 
 function resolveDesktopAppBranding(input: {
   readonly isDevelopment: boolean;
   readonly appVersion: string;
+  readonly displayVersion: string;
 }): DesktopAppBranding {
   const stageLabel = resolveDesktopAppStageLabel(input);
   return {
     baseName: APP_BASE_NAME,
     stageLabel,
     displayName: `${APP_BASE_NAME} (${stageLabel})`,
+    displayVersion: input.displayVersion,
+    appVersion: input.appVersion,
   };
 }
 
@@ -154,9 +160,11 @@ const makeDesktopEnvironment = Effect.fn("desktop.environment.make")(function* (
   const baseDir = Option.getOrElse(config.t3Home, () => path.join(homeDirectory, ".t3"));
   const rootDir = path.resolve(input.dirname, "../../..");
   const appRoot = input.isPackaged ? input.appPath : rootDir;
+  const displayVersion = formatForkDisplayVersion(input.appVersion, input.buildTimestamp);
   const branding = resolveDesktopAppBranding({
     isDevelopment,
     appVersion: input.appVersion,
+    displayVersion,
   });
   const displayName = branding.displayName;
   const stateDir = path.join(baseDir, isDevelopment ? "dev" : "userdata");
@@ -242,6 +250,7 @@ const makeDesktopEnvironment = Effect.fn("desktop.environment.make")(function* (
       path.join(resourcesPath, fileName),
     ],
     developmentDockIconPath: path.join(rootDir, "assets", "dev", "blueprint-macos-1024.png"),
+    displayVersion,
   });
 });
 

apps/desktop/src/app/DesktopLifecycle.ts

@@ -6,6 +6,10 @@ import * as Layer from "effect/Layer";
 import * as Ref from "effect/Ref";
 import * as Scope from "effect/Scope";
 
+// @effect-diagnostics nodeBuiltinImport:off globalTimers:off
+import * as NodeTimers from "node:timers";
+
+import { app as electronAppModule, type Event as ElectronEvent } from "electron";
 import type * as Electron from "electron";
 
 import * as DesktopEnvironment from "./DesktopEnvironment.ts";
@@ -97,40 +101,49 @@ const requestDesktopShutdownAndWait = Effect.fn("desktop.lifecycle.requestShutdo
   },
 );
 
+const SHUTDOWN_EXIT_TIMEOUT_MS = 5000;
+
 function handleBeforeQuit(
-  event: Electron.Event,
+  event: ElectronEvent,
   runEffect: <A, E>(effect: Effect.Effect<A, E, DesktopLifecycleRuntimeServices>) => Promise<A>,
-  allowQuit: () => boolean,
-  markQuitAllowed: () => void,
+  getShutdownPromise: () => Promise<void> | null,
+  setShutdownPromise: (promise: Promise<void>) => void,
 ): void {
-  if (allowQuit()) {
-    void runEffect(
-      Effect.gen(function* () {
-        const state = yield* DesktopState.DesktopState;
-        yield* Ref.set(state.quitting, true);
-        yield* logLifecycleInfo("before-quit received");
-      }).pipe(Effect.withSpan("desktop.lifecycle.beforeQuit")),
-    );
+  if (getShutdownPromise() !== null) {
+    event.preventDefault();
     return;
   }
 
   event.preventDefault();
-  void runEffect(
+
+  const shutdownEffect = runEffect(
     Effect.gen(function* () {
       const state = yield* DesktopState.DesktopState;
       yield* Ref.set(state.quitting, true);
       yield* logLifecycleInfo("before-quit received");
       yield* requestDesktopShutdownAndWait();
     }).pipe(Effect.withSpan("desktop.lifecycle.beforeQuit")),
-  ).finally(() => {
-    markQuitAllowed();
-    void runEffect(
-      Effect.gen(function* () {
-        const electronApp = yield* ElectronApp.ElectronApp;
-        yield* electronApp.quit;
-      }).pipe(Effect.withSpan("desktop.lifecycle.quitAfterShutdown")),
-    );
+  );
+
+  let timeoutHandle: ReturnType<typeof NodeTimers.setTimeout> | null = null;
+  const timeoutPromise = new Promise<void>((resolve) => {
+    timeoutHandle = NodeTimers.setTimeout(resolve, SHUTDOWN_EXIT_TIMEOUT_MS);
   });
+
+  const racePromise = Promise.race([
+    shutdownEffect.then(
+      () => undefined,
+      () => undefined,
+    ),
+    timeoutPromise,
+  ]).finally(() => {
+    if (timeoutHandle !== null) {
+      NodeTimers.clearTimeout(timeoutHandle);
+    }
+    electronAppModule.exit(0);
+  });
+
+  setShutdownPromise(racePromise);
 }
 
 function quitFromSignal(
@@ -189,7 +202,7 @@ export const layer = Layer.succeed(
       const environment = yield* DesktopEnvironment.DesktopEnvironment;
       const context = yield* Effect.context<DesktopLifecycleRuntimeServices>();
       const runEffect = Effect.runPromiseWith(context);
-      let quitAllowed = false;
+      let shutdownPromise: Promise<void> | null = null;
       yield* electronTheme.onUpdated(() => {
         void runEffect(
           desktopWindow.syncAppearance.pipe(Effect.withSpan("desktop.lifecycle.themeUpdated")),
@@ -199,9 +212,9 @@ export const layer = Layer.succeed(
         handleBeforeQuit(
           event,
           runEffect,
-          () => quitAllowed,
-          () => {
-            quitAllowed = true;
+          () => shutdownPromise,
+          (promise) => {
+            shutdownPromise = promise;
           },
         );
       });

apps/desktop/src/app/DesktopObservability.test.ts

@@ -47,6 +47,7 @@ const environmentInput = (baseDir: string) =>
     isPackaged: false,
     resourcesPath: "/repo/resources",
     runningUnderArm64Translation: false,
+    buildTimestamp: "20260508-1430",
   }) satisfies DesktopEnvironment.MakeDesktopEnvironmentInput;
 
 const makeEnvironmentLayer = (baseDir: string) =>

apps/desktop/src/app/forkBranding.ts

@@ -0,0 +1,8 @@
+import type { DesktopAppStageLabel } from "@t3tools/contracts";
+
+export const FORK_TAG = "a3";
+export const FORK_STAGE_LABEL: DesktopAppStageLabel = "A3";
+
+export function formatForkDisplayVersion(pkgVersion: string, buildTimestamp: string): string {
+  return `${pkgVersion}-${FORK_TAG}-${buildTimestamp}`;
+}

apps/desktop/src/backend/DesktopBackendConfiguration.test.ts

@@ -53,6 +53,7 @@ function makeEnvironmentLayer(
     isPackaged: options?.isPackaged ?? true,
     resourcesPath: "/missing/resources",
     runningUnderArm64Translation: false,
+    buildTimestamp: "20260508-1430",
   }).pipe(
     Layer.provide(
       Layer.mergeAll(

apps/desktop/src/backend/DesktopServerExposure.test.ts

@@ -75,6 +75,7 @@ function makeEnvironmentLayer(baseDir: string, env: Record<string, string | unde
     isPackaged: true,
     resourcesPath: "/missing/resources",
     runningUnderArm64Translation: false,
+    buildTimestamp: "20260508-1430",
   }).pipe(
     Layer.provide(
       Layer.mergeAll(NodeServices.layer, DesktopConfig.layerTest({ T3CODE_HOME: baseDir, ...env })),

apps/desktop/src/electron.d.ts

@@ -0,0 +1,14 @@
+declare namespace Electron {
+  interface Session {
+    setPermissionRequestHandler(
+      handler:
+        | ((
+            webContents: WebContents,
+            permission: "local-fonts" | "clipboard-sanitized-write" | "clipboard-read",
+            callback: (permissionGranted: boolean) => void,
+            details: PermissionRequest,
+          ) => void)
+        | null,
+    ): void;
+  }
+}

apps/desktop/src/electron/ElectronPermissions.ts

@@ -0,0 +1,34 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import * as Electron from "electron";
+
+import * as ElectronApp from "./ElectronApp.ts";
+
+const ALLOWED_PERMISSIONS = new Set<string>([
+  "clipboard-sanitized-write",
+  "clipboard-read",
+  "local-fonts",
+]);
+
+const install = Effect.acquireRelease(
+  Effect.sync(() => {
+    Electron.session.defaultSession.setPermissionRequestHandler(
+      (_webContents, permission, callback) => {
+        callback(ALLOWED_PERMISSIONS.has(permission));
+      },
+    );
+  }),
+  () =>
+    Effect.sync(() => {
+      Electron.session.defaultSession.setPermissionRequestHandler(null);
+    }),
+);
+
+export const layer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const app = yield* ElectronApp.ElectronApp;
+    yield* app.whenReady;
+    yield* install;
+  }),
+);

apps/desktop/src/main.ts

@@ -3,10 +3,13 @@ import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import * as NodeOS from "node:os";
 import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
+import * as Path from "effect/Path";
 
 import * as Electron from "electron";
+import { formatBuildTimestamp } from "@t3tools/shared/buildTimestamp";
 
 import * as NetService from "@t3tools/shared/Net";
 import { resolveRemoteT3CliPackageSpec } from "@t3tools/ssh/command";
@@ -18,6 +21,7 @@ import * as DesktopIpc from "./ipc/DesktopIpc.ts";
 import * as ElectronApp from "./electron/ElectronApp.ts";
 import * as ElectronDialog from "./electron/ElectronDialog.ts";
 import * as ElectronMenu from "./electron/ElectronMenu.ts";
+import * as ElectronPermissions from "./electron/ElectronPermissions.ts";
 import * as ElectronProtocol from "./electron/ElectronProtocol.ts";
 import * as DesktopSecretStorage from "./electron/ElectronSafeStorage.ts";
 import * as ElectronShell from "./electron/ElectronShell.ts";
@@ -47,14 +51,33 @@ import * as DesktopWindow from "./window/DesktopWindow.ts";
 
 const desktopEnvironmentLayer = Layer.unwrap(
   Effect.gen(function* () {
-    const metadata = yield* Effect.service(ElectronApp.ElectronApp).pipe(
-      Effect.flatMap((app) => app.metadata),
-    );
+    const electronApp = yield* Effect.service(ElectronApp.ElectronApp);
+    const metadata = yield* electronApp.metadata;
+    let buildTimestamp = process.env.T3CODE_BUILD_TIMESTAMP;
+    if (!buildTimestamp && metadata.isPackaged) {
+      const path = yield* Path.Path;
+      const fs = yield* FileSystem.FileSystem;
+      const packagePath = path.join(metadata.appPath, "package.json");
+      const fileContent = yield* fs.readFileString(packagePath).pipe(Effect.option);
+      if (Option.isSome(fileContent)) {
+        // @effect-diagnostics-next-line tryCatchInEffectGen:off
+        try {
+          // @effect-diagnostics-next-line preferSchemaOverJson:off
+          const packageJson = JSON.parse(fileContent.value);
+          if (typeof packageJson?.t3codeBuildTimestamp === "string") {
+            buildTimestamp = packageJson.t3codeBuildTimestamp;
+          }
+        } catch {}
+      }
+    }
+    // @effect-diagnostics-next-line globalDateInEffect:off
+    buildTimestamp = buildTimestamp || formatBuildTimestamp(new Date());
     return DesktopEnvironment.layer({
       dirname: __dirname,
       homeDirectory: NodeOS.homedir(),
       platform: process.platform,
       processArch: process.arch,
+      buildTimestamp,
       ...metadata,
     });
   }),
@@ -137,6 +160,7 @@ const desktopApplicationLayer = Layer.mergeAll(
   DesktopLifecycle.layer,
   DesktopApplicationMenu.layer,
   DesktopShellEnvironment.layer,
+  ElectronPermissions.layer,
   desktopSshLayer,
 ).pipe(Layer.provideMerge(DesktopUpdates.layer), Layer.provideMerge(desktopBackendLayer));