@nowcrew/daemon 0.6.73 → 0.6.75

package/README.md

@@ -11,6 +11,13 @@ For a temporary foreground connection, run:
 npx @nowcrew/daemon@latest --server-url https://nowwork.example --api-key sk_machine_...
 ```
 
+The package has two release channels. The `in` environment consumes stable `x.y.z` releases through
+the `latest` tag; the `dev` environment consumes `x.y.z-beta.n` prereleases through the `beta` tag.
+The parser also accepts the historical `x.y.z-beta-n` spelling and normalizes it for ordering; new
+published versions should use the dotted SemVer form.
+Never use `latest` for a dev installation or `beta` for an in installation. See the
+[Daemon Release Runbook](../docs/releases/daemon-release-runbook.md) for release and rollback procedures.
+
 This compatibility form stays resident in the current terminal and reconnects with backoff. New
 **Add Computer** commands use the managed automatic installation described below. For local development, run
 `pnpm --filter @nowcrew/daemon daemon`. `crew-daemon run --agent <handle> --channel <id>` is the legacy
@@ -22,7 +29,7 @@ Persist a named connection without putting its machine token in shell history or
 
 ```bash
 printf '%s' "$CREW_MACHINE_TOKEN" | crew-daemon profile save work \
-  --server-url https://nowwork.example --token-stdin
+  --server-url https://nowwork.example --release-tag latest --token-stdin
 crew-daemon profile list
 crew-daemon profile show work        # reports configured=true; never prints the token
 crew-daemon serve --profile work
@@ -36,8 +43,9 @@ The connection command generated by **Add Computer** installs the package into a
 saves the private profile, installs the native user service, starts it, and verifies that it is running:
 
 ```bash
-npx -y --registry https://registry.npmjs.org @nowcrew/daemon@latest install \
-  --server-url https://nowwork-dev.nowcoder.com --api-key sk_machine_...
+npx -y --registry https://registry.npmjs.org @nowcrew/daemon@beta install \
+  --server-url https://nowwork-dev.nowcoder.com --api-key sk_machine_... \
+  --release-tag beta --registry https://registry.npmjs.org
 ```
 
 The installer selects the fixed `in` layout for `nowwork-in.nowcoder.com` and the fixed `dev` layout for
@@ -45,8 +53,8 @@ The installer selects the fixed `in` layout for `nowwork-in.nowcoder.com` and th
 An unknown hostname is rejected before any write and reports how to retry with an explicit custom profile:
 
 ```bash
-npx -y --registry https://registry.npmjs.org @nowcrew/daemon@latest install \
-  --server-url https://lab.example.com --api-key sk_machine_... --profile lab
+npx -y --registry https://registry.npmjs.org @nowcrew/daemon@beta install \
+  --server-url https://lab.example.com --api-key sk_machine_... --profile lab --release-tag beta
 ```
 
 Custom profiles use `~/.crew/daemon-<profile>`, `~/.crew/agents-<profile>`, and
@@ -95,13 +103,16 @@ Upgrade the global daemon package, optionally restarting one installed profile a
 ```bash
 crew-daemon upgrade
 crew-daemon upgrade --profile work
+crew-daemon upgrade --profile work --release-tag beta
 ```
 
 With `--profile`, upgrade validates isolation, stops the native service, acquires the installation lease,
 replaces only the entrypoint-derived npm prefix, releases the lease, and starts the service. If package
 replacement fails, it still attempts to start the previous installation. Without `--profile`, upgrade
-refuses to replace a prefix currently leased by a running daemon; use the profile form for a managed
-service.
+refuses to replace a prefix currently leased by a running daemon; it also permits only the currently
+installed daemon's release channel. Cross-channel upgrades (for example installing `beta` from a stable
+global package) require `--profile`, so the target server environment and profile isolation are verified.
+Use the profile form for any managed service.
 
 ## Managed Self-Update
 
@@ -171,7 +182,7 @@ daemon home also contributes a stable hash to the native service ID, so equal pr
 
 Before replacing files, the daemon refuses new work, requires zero local active or queued work, and
 non-blockingly acquires every host execution slot. It then installs only the server-selected exact
-`x.y.z` version with npm using the prefix derived from the running global entrypoint, verifies the installed
+exact `x.y.z` or `x.y.z-beta.n` version with npm using the prefix derived from the running global entrypoint, verifies the installed
 package version, and schedules the existing native service restart from a detached helper. macOS uses
 `launchctl kickstart -k` to avoid the `bootout`/`bootstrap` race; Linux uses `systemctl --user --no-block
 restart`. The helper reports manager failure over IPC. A failed handoff releases both execution barriers and
@@ -195,11 +206,11 @@ Failures are recoverable and keep a bounded code in the machine record:
 | `update_in_progress` | wait for the active request to reach a terminal state |
 | `update_timeout` | inspect `crew-daemon status --profile work`, restart if needed, then retry |
 
-Remote downgrade is intentionally unsupported. To roll back, install a known exact release and restart
-the service manually:
+The Web UI supports owner/admin rollback to an exact release in the configured channel. When the managed
+control plane is unavailable, install a known exact release and restart the service manually:
 
 ```bash
-npm install --global --prefix <environment-prefix> --ignore-scripts --no-audit --no-fund @nowcrew/daemon@<previous-x.y.z>
+npm install --global --prefix <environment-prefix> --ignore-scripts --no-audit --no-fund @nowcrew/daemon@<previous-release>
 crew-daemon restart --profile work
 crew-daemon status --profile work
 ```

package/dist/automatic-daemon-installer.js

@@ -8,6 +8,9 @@ import { ManagedServiceConflictError, managedServiceConflict, managedServiceIden
 import { resolveAutomaticInstallTarget, } from "./automatic-install-target.js";
 import { acquireDaemonInstallationLease, } from "./daemon-installation-lease.js";
 import { daemonVersion } from "./machine-info.js";
+import { daemonReleaseProvenance } from "./release-provenance.js";
+import { daemonReleaseChannel, isDaemonReleaseVersion } from "./daemon-release-version.js";
+import { normalizeDaemonNpmRegistry } from "./npm-registry.js";
 import { discoverExactLegacyService, } from "./automatic-service-migration.js";
 function profileStorage(platform, userHome, runner) {
     return {
@@ -175,7 +178,7 @@ export function stableDaemonEntry(target, platform) {
         ? paths.join(target.npmPrefix, "node_modules", "@nowcrew", "daemon", "dist", "main.js")
         : paths.join(target.npmPrefix, "lib", "node_modules", "@nowcrew", "daemon", "dist", "main.js");
 }
-export async function installExactDaemonPackage(npmPrefix, version, platform, runner) {
+export async function installExactDaemonPackage(npmPrefix, version, platform, runner, registryUrl) {
     const command = platform === "win32" ? "npm.cmd" : "npm";
     const result = await runner(command, [
         "install",
@@ -185,6 +188,9 @@ export async function installExactDaemonPackage(npmPrefix, version, platform, ru
         "--ignore-scripts",
         "--no-audit",
         "--no-fund",
+        ...(registryUrl === undefined ? [] : ["--registry", normalizeDaemonNpmRegistry(registryUrl, {
+                allowLoopbackHttp: daemonReleaseChannel(version) === "beta",
+            })]),
         `@nowcrew/daemon@${version}`,
     ]);
     if (result.exitCode !== 0) {
@@ -217,9 +223,18 @@ export async function installDaemonAutomatically(input, dependencies = defaultDe
     const target = resolveAutomaticInstallTarget({
         serverUrl: input.serverUrl,
         ...(input.requestedProfile === undefined ? {} : { requestedProfile: input.requestedProfile }),
+        ...(input.requestedReleaseTag === undefined ? {} : { requestedReleaseTag: input.requestedReleaseTag }),
+        ...(input.requestedRegistryUrl === undefined ? {} : { requestedRegistryUrl: input.requestedRegistryUrl }),
         userHome: dependencies.userHome,
         platform: dependencies.platform,
     });
+    if (!isDaemonReleaseVersion(dependencies.version)) {
+        throw new Error(`Invoking daemon package has an invalid release version '${dependencies.version}'`);
+    }
+    const invokingTag = daemonReleaseProvenance(dependencies.version).releaseTag;
+    if (invokingTag !== target.releaseTag) {
+        throw new Error(`Invoking daemon release tag '${invokingTag}' does not match target '${target.releaseTag}'`);
+    }
     const spec = buildServiceSpec({
         platform: dependencies.platform,
         profile: target.profile,
@@ -251,7 +266,7 @@ export async function installDaemonAutomatically(input, dependencies = defaultDe
         const lease = await dependencies.acquireInstallationLease(target.npmPrefix);
         let installFailure;
         try {
-            await dependencies.installPackage(target.npmPrefix, dependencies.version, dependencies.platform, dependencies.runner);
+            await dependencies.installPackage(target.npmPrefix, dependencies.version, dependencies.platform, dependencies.runner, target.registryUrl);
         }
         catch (error) {
             installFailure = error;
@@ -280,6 +295,8 @@ export async function installDaemonAutomatically(input, dependencies = defaultDe
             serverUrl: target.serverUrl,
             machineToken,
             agentsRoot: target.agentsRoot,
+            releaseTag: target.releaseTag,
+            ...(target.registryUrl === undefined ? {} : { registryUrl: target.registryUrl }),
             ...(dependencies.runtimePath === undefined ? {} : { runtimePath: dependencies.runtimePath }),
         }, target.daemonHome);
         serviceReplacementStarted = true;

package/dist/automatic-install-target.js

@@ -1,5 +1,6 @@
 import { posix, win32 } from "node:path";
 import { profileLayout, validateLocalInstanceName } from "./profile-layout.js";
+import { normalizeDaemonNpmRegistry } from "./npm-registry.js";
 const PROFILE_NAME = /^[a-z0-9][a-z0-9_-]{0,47}$/;
 const KNOWN_TARGETS = {
     "nowwork-in.nowcoder.com": {
@@ -13,6 +14,23 @@ const KNOWN_TARGETS = {
         agentsDirectory: "agents-dev",
     },
 };
+export function releaseTagForServerUrl(serverUrl) {
+    const parsed = parseServerUrl(serverUrl);
+    const known = KNOWN_TARGETS[parsed.hostname.toLowerCase()];
+    return known?.environment === "dev" ? "beta" : "latest";
+}
+export function assertReleaseTagForServerUrl(serverUrl, requested) {
+    if (requested === undefined)
+        return;
+    const parsed = parseServerUrl(serverUrl);
+    const known = KNOWN_TARGETS[parsed.hostname.toLowerCase()];
+    if (known === undefined)
+        return;
+    const expected = known.environment === "dev" ? "beta" : "latest";
+    if (requested !== expected) {
+        throw new Error(`Server hostname '${parsed.hostname}' requires release tag '${expected}'`);
+    }
+}
 function parseServerUrl(value) {
     let parsed;
     try {
@@ -52,6 +70,7 @@ function knownTargetForProfile(environment, requestedProfile, input, parsed) {
     // Keep the no-flag target readable by old daemons; any workspace-scoped profile below
     // uses the canonical environment token (production, never in).
     const legacyProfile = environment === "production" ? "in" : environment;
+    assertReleaseTagForServerUrl(input.serverUrl, input.requestedReleaseTag);
     if (requestedProfile === undefined || requestedProfile === legacyProfile) {
         return Object.freeze({
             kind: "known",
@@ -60,6 +79,7 @@ function knownTargetForProfile(environment, requestedProfile, input, parsed) {
             daemonHome: paths.join(input.userHome, ".crew", environment === "production" ? "daemon" : "daemon-dev"),
             agentsRoot: paths.join(input.userHome, ".crew", environment === "production" ? "agents" : "agents-dev"),
             npmPrefix: paths.join(input.userHome, ".crew", "daemon-runtimes", legacyProfile),
+            releaseTag: environment === "dev" ? "beta" : "latest",
         });
     }
     if (requestedProfile === "in" || requestedProfile === "dev") {
@@ -88,6 +108,7 @@ function knownTargetForProfile(environment, requestedProfile, input, parsed) {
         daemonHome: layout.daemonHome,
         agentsRoot: layout.agentsRoot,
         npmPrefix: layout.npmPrefix,
+        releaseTag: environment === "dev" ? "beta" : "latest",
     });
 }
 export function resolveAutomaticInstallTarget(input) {
@@ -95,8 +116,15 @@ export function resolveAutomaticInstallTarget(input) {
     const hostname = parsed.hostname.toLowerCase();
     const paths = input.platform === "win32" ? win32 : posix;
     const known = KNOWN_TARGETS[hostname];
+    const targetReleaseTag = known?.environment === "dev"
+        ? "beta"
+        : input.requestedReleaseTag ?? "latest";
+    const registryUrl = input.requestedRegistryUrl === undefined
+        ? undefined
+        : normalizeDaemonNpmRegistry(input.requestedRegistryUrl, { allowLoopbackHttp: targetReleaseTag === "beta" });
     if (known !== undefined) {
-        return knownTargetForProfile(known.environment, input.requestedProfile, input, parsed);
+        const target = knownTargetForProfile(known.environment, input.requestedProfile, input, parsed);
+        return registryUrl === undefined ? target : Object.freeze({ ...target, registryUrl });
     }
     const profile = requireCustomProfile(hostname, input.requestedProfile);
     return Object.freeze({
@@ -106,5 +134,7 @@ export function resolveAutomaticInstallTarget(input) {
         daemonHome: paths.join(input.userHome, ".crew", `daemon-${profile}`),
         agentsRoot: paths.join(input.userHome, ".crew", `agents-${profile}`),
         npmPrefix: paths.join(input.userHome, ".crew", "daemon-runtimes", profile),
+        releaseTag: input.requestedReleaseTag ?? "latest",
+        ...(registryUrl === undefined ? {} : { registryUrl }),
     });
 }

package/dist/computer-cli.js

@@ -4,10 +4,14 @@ import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { assertProfileAgentsRootUnique, daemonHome, inspectProfileAgentsRoot, listProfiles, loadProfile, PROFILE_AGENTS_ROOT_CONFLICT_MESSAGE, ProfileAgentsRootConflictError, profileIsPrivate, profilePath, publicProfile, removeProfile, resolveAgentsRoot, saveProfile, windowsDpapiProtector, } from "./computer-profile.js";
 import { buildServiceSpec, doctorService, hardenWindowsProfile, installService, readServiceDescriptor, serviceAction, serviceStatus, systemCommandRunner, uninstallService, upgradeDaemon, windowsProfileIsPrivate, } from "./computer-service.js";
+import { releaseTagForServerUrl, assertReleaseTagForServerUrl } from "./automatic-install-target.js";
+import { normalizeDaemonNpmRegistry } from "./npm-registry.js";
 import { defaultProcessController } from "./execution-journal.js";
 import { inspectJournalLock } from "./execution-journal-lock.js";
 import { detectDaemonLang, formatDaemonText } from "./i18n.js";
 import { daemonGlobalInstallation } from "./daemon-installation.js";
+import { daemonVersion } from "./machine-info.js";
+import { daemonReleaseProvenance } from "./release-provenance.js";
 import { acquireDaemonInstallationLease, } from "./daemon-installation-lease.js";
 import { assertManagedServiceIdentity, buildManagedServiceRecord, installManagedService, uninstallUnregisteredManagedService, uninstallManagedService, } from "./managed-service-lifecycle.js";
 import { inspectManagedServiceDiagnostics } from "./managed-service-diagnostics.js";
@@ -57,11 +61,11 @@ export function isGlobalDaemonEntry(entryPath, globalNodeModules) {
 function usage(td) {
     return [
         td("Computer lifecycle:"),
-        "  crew-daemon profile save <name> --server-url <url> [--agents-root <path>] [--token-stdin]",
+        "  crew-daemon profile save <name> --server-url <url> [--release-tag <latest|beta>] [--registry <https-url>] [--agents-root <path>] [--token-stdin]",
         "  crew-daemon profile list|show|remove [<name>]",
-        "  crew-daemon install --server-url <url> --api-key <sk_machine_*> [--profile <custom-name>]",
+        "  crew-daemon install --server-url <url> --api-key <sk_machine_*> [--profile <custom-name>] [--release-tag <latest|beta>] [--registry <https-url>]",
         "  crew-daemon doctor|install|uninstall|start|stop|restart|status --profile <name>",
-        "  crew-daemon upgrade [--profile <name>]",
+        "  crew-daemon upgrade [--profile <name>] [--release-tag <latest|beta>] [--registry <https-url>]",
         "",
         td("profile save reads the machine token from CREW_MACHINE_TOKEN, or stdin with --token-stdin."),
     ].join("\n") + "\n";
@@ -105,6 +109,8 @@ export async function runComputerCommand(argv, overrides = {}) {
             options: {
                 profile: { type: "string" },
                 "server-url": { type: "string" },
+                "release-tag": { type: "string" },
+                registry: { type: "string" },
                 "agents-root": { type: "string" },
                 "token-stdin": { type: "boolean", default: false },
                 "api-key": { type: "string" },
@@ -118,6 +124,14 @@ export async function runComputerCommand(argv, overrides = {}) {
         }
         const [, action, positionalName] = parsed.positionals;
         const profileName = parsed.values.profile;
+        const requestedReleaseTag = parsed.values["release-tag"];
+        const requestedRegistryUrl = parsed.values.registry;
+        const configuredRegistryUrl = requestedRegistryUrl === undefined
+            ? deps.env.CREW_NPM_REGISTRY?.trim() || undefined
+            : requestedRegistryUrl;
+        if (requestedReleaseTag !== undefined && requestedReleaseTag !== "latest" && requestedReleaseTag !== "beta") {
+            throw new Error(td("Invalid release tag; expected latest or beta"));
+        }
         const automaticInstall = command === "install" && parsed.values["server-url"] !== undefined;
         const tokenOption = parsed.values["api-key"] !== undefined
             ? "--api-key"
@@ -143,6 +157,10 @@ export async function runComputerCommand(argv, overrides = {}) {
                 serverUrl: parsed.values["server-url"],
                 machineToken,
                 ...(profileName === undefined ? {} : { requestedProfile: profileName }),
+                ...(requestedReleaseTag === undefined ? {} : { requestedReleaseTag }),
+                ...(configuredRegistryUrl === undefined
+                    ? {}
+                    : { requestedRegistryUrl: configuredRegistryUrl }),
             });
             deps.stdout(`${td("Installed daemon {{version}} for profile '{{profile}}'; service '{{service}}' is running.", { version: result.version, profile: result.profile, service: result.serviceId })}\n`);
             return 0;
@@ -187,10 +205,19 @@ export async function runComputerCommand(argv, overrides = {}) {
             const machineToken = (fromStdin ? await deps.readStdin() : deps.env.CREW_MACHINE_TOKEN)?.trim();
             if (!machineToken)
                 throw new Error(td("Missing machine token; use CREW_MACHINE_TOKEN or --token-stdin"));
+            const serverUrl = requireValue(parsed.values["server-url"], "--server-url", td);
+            assertReleaseTagForServerUrl(serverUrl, requestedReleaseTag);
+            const profileReleaseTag = requestedReleaseTag ?? releaseTagForServerUrl(serverUrl);
             const profile = {
                 name,
-                serverUrl: requireValue(parsed.values["server-url"], "--server-url", td),
+                serverUrl,
                 machineToken,
+                releaseTag: profileReleaseTag,
+                ...(configuredRegistryUrl === undefined ? {} : {
+                    registryUrl: normalizeDaemonNpmRegistry(configuredRegistryUrl, {
+                        allowLoopbackHttp: profileReleaseTag === "beta",
+                    }),
+                }),
                 ...(parsed.values["agents-root"]
                     ? { agentsRoot: resolveAgentsRoot(parsed.values["agents-root"], deps.userHome, deps.platform) }
                     : {}),
@@ -205,6 +232,19 @@ export async function runComputerCommand(argv, overrides = {}) {
             const restartProfile = profileName
                 ? await loadProfile(profileName, home, profileStorage)
                 : null;
+            if (!restartProfile && requestedReleaseTag !== undefined) {
+                const installedReleaseTag = daemonReleaseProvenance(daemonVersion(), deps.env).releaseTag;
+                if (requestedReleaseTag !== installedReleaseTag) {
+                    throw new Error(td("Cross-channel daemon upgrade requires --profile so the server environment can be verified"));
+                }
+            }
+            const releaseTag = requestedReleaseTag
+                ?? restartProfile?.releaseTag
+                ?? (restartProfile === null
+                    ? daemonReleaseProvenance(daemonVersion(), deps.env).releaseTag
+                    : releaseTagForServerUrl(restartProfile.serverUrl));
+            if (restartProfile)
+                assertReleaseTagForServerUrl(restartProfile.serverUrl, releaseTag);
             const spec = restartProfile
                 ? buildServiceSpec({
                     ...deps,
@@ -215,7 +255,7 @@ export async function runComputerCommand(argv, overrides = {}) {
                 : null;
             if (spec && restartProfile) {
                 if (installation === null && !isGlobalDaemonEntry(deps.entryPath, await deps.resolveGlobalNodeModules())) {
-                    throw new Error(td("Service lifecycle requires a global @nowcrew/daemon install; run npm install --global @nowcrew/daemon@latest"));
+                    throw new Error(td("Service lifecycle requires a global @nowcrew/daemon install; run npm install --global @nowcrew/daemon@{{tag}}", { tag: releaseTag }));
                 }
                 const before = await serviceStatus(spec, deps.runner);
                 if (!before.installed)
@@ -236,7 +276,10 @@ export async function runComputerCommand(argv, overrides = {}) {
                 installationLease = installation === null
                     ? null
                     : await deps.acquireInstallationLease(installation.npmPrefix, { userHome: deps.userHome });
-                await upgradeDaemon(deps.platform, deps.runner, installation?.npmPrefix);
+                await upgradeDaemon(deps.platform, deps.runner, installation?.npmPrefix, releaseTag, configuredRegistryUrl === undefined
+                    ? restartProfile?.registryUrl
+                        ?? configuredRegistryUrl
+                    : normalizeDaemonNpmRegistry(configuredRegistryUrl, { allowLoopbackHttp: releaseTag === "beta" }));
             }
             catch (error) {
                 upgradeError = error;
@@ -274,6 +317,14 @@ export async function runComputerCommand(argv, overrides = {}) {
         }
         const name = requireValue(profileName, "--profile", td);
         const profile = await loadProfile(name, home, profileStorage);
+        const profileReleaseTag = requestedReleaseTag ?? profile.releaseTag ?? releaseTagForServerUrl(profile.serverUrl);
+        if (command === "install") {
+            assertReleaseTagForServerUrl(profile.serverUrl, profileReleaseTag);
+            const installedReleaseTag = daemonReleaseProvenance(daemonVersion(), deps.env).releaseTag;
+            if (installedReleaseTag !== profileReleaseTag) {
+                throw new Error(td("Installed daemon release tag '{{installed}}' does not match profile '{{profile}}' release tag '{{target}}'", { installed: installedReleaseTag, profile: name, target: profileReleaseTag }));
+            }
+        }
         if (command === "install" || command === "start" || command === "restart") {
             await assertProfileAgentsRootUnique(profile, home, deps.userHome, profileStorage);
         }
@@ -296,7 +347,8 @@ export async function runComputerCommand(argv, overrides = {}) {
             : null;
         if (command === "install") {
             if (installation === null && !isGlobalDaemonEntry(deps.entryPath, await deps.resolveGlobalNodeModules())) {
-                throw new Error(td("Service lifecycle requires a global @nowcrew/daemon install; run npm install --global @nowcrew/daemon@latest"));
+                const releaseTag = requestedReleaseTag ?? profile.releaseTag ?? releaseTagForServerUrl(profile.serverUrl);
+                throw new Error(td("Service lifecycle requires a global @nowcrew/daemon install; run npm install --global @nowcrew/daemon@{{tag}}", { tag: releaseTag }));
             }
             if (managedRecord === null)
                 await installService(spec, deps.runner);

package/dist/computer-profile.js

@@ -8,33 +8,57 @@ import { z } from "zod";
 import { acquireProfileSaveLock, } from "./computer-profile-lock.js";
 import { formatDaemonText } from "./i18n.js";
 import { atomicPrivateWrite } from "./atomic-private-write.js";
+import { normalizeDaemonNpmRegistry } from "./npm-registry.js";
 const PROFILE_NAME = /^[a-z0-9][a-z0-9_-]{0,47}$/;
 export const MachineTokenSchema = z.string().startsWith("sk_machine_").max(4096);
 const ServerUrlSchema = z.string().url().max(2048).refine((value) => {
     const url = new URL(value);
     return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password;
 }, "serverUrl must be an HTTP(S) URL without embedded credentials");
-const ProfileSchema = z.object({
+const ProfileFields = z.object({
     version: z.literal(1),
     name: z.string().regex(PROFILE_NAME),
     serverUrl: ServerUrlSchema,
     machineToken: MachineTokenSchema,
     agentsRoot: z.string().min(1).optional(),
     runtimePath: z.string().min(1).max(32768).refine((value) => !value.includes("\0") && !value.includes("\n") && !value.includes("\r"), "runtimePath must be a single line").optional(),
+    releaseTag: z.enum(["latest", "beta"]).optional(),
+    registryUrl: z.string().url().optional(),
     codexHomeMode: z.enum(["shared", "private"]).optional(),
 }).strict();
-const ProfileAgentsRootCandidateSchema = ProfileSchema.pick({
+function validateProfileRegistry(value, context) {
+    const fields = value;
+    if (fields.registryUrl === undefined)
+        return;
+    try {
+        const normalized = normalizeDaemonNpmRegistry(fields.registryUrl, {
+            allowLoopbackHttp: fields.releaseTag === "beta",
+        });
+        if (normalized !== fields.registryUrl) {
+            context.addIssue({ code: z.ZodIssueCode.custom, path: ["registryUrl"], message: "registryUrl must be normalized" });
+        }
+    }
+    catch (error) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["registryUrl"],
+            message: error instanceof Error ? error.message : "registryUrl must be HTTPS",
+        });
+    }
+}
+const ProfileSchema = ProfileFields.superRefine(validateProfileRegistry);
+const ProfileAgentsRootCandidateSchema = ProfileFields.pick({
     name: true,
     serverUrl: true,
     agentsRoot: true,
 }).strict();
 const StoredPlainProfileSchema = ProfileSchema;
-const StoredProtectedProfileSchema = ProfileSchema.omit({ machineToken: true }).extend({
+const StoredProtectedProfileSchema = ProfileFields.omit({ machineToken: true }).extend({
     machineTokenProtected: z.object({
         scheme: z.literal("dpapi-current-user"),
         ciphertext: z.string().min(1).max(16384),
     }).strict(),
-}).strict();
+}).strict().superRefine(validateProfileRegistry);
 const StoredProfileSchema = z.union([StoredPlainProfileSchema, StoredProtectedProfileSchema]);
 export const PROFILE_AGENTS_ROOT_CONFLICT_MESSAGE = "Profile '{{profile}}' conflicts with profile '{{conflict}}': both resolve to agents root '{{agentsRoot}}'. Save it with a unique root, for example: {{command}}";
 export class ProfileAgentsRootConflictError extends Error {
@@ -218,6 +242,8 @@ export async function saveProfile(input, home = daemonHome(), options = {}) {
                 serverUrl: profile.serverUrl,
                 ...(profile.agentsRoot ? { agentsRoot: profile.agentsRoot } : {}),
                 ...(profile.runtimePath ? { runtimePath: profile.runtimePath } : {}),
+                ...(profile.releaseTag === undefined ? {} : { releaseTag: profile.releaseTag }),
+                ...(profile.registryUrl === undefined ? {} : { registryUrl: profile.registryUrl }),
                 ...(profile.codexHomeMode === undefined ? {} : { codexHomeMode: profile.codexHomeMode }),
                 machineTokenProtected: { scheme: "dpapi-current-user", ciphertext },
             });
@@ -261,6 +287,8 @@ export async function loadProfile(name, home = daemonHome(), options = {}) {
                 serverUrl: stored.serverUrl,
                 ...(stored.agentsRoot ? { agentsRoot: stored.agentsRoot } : {}),
                 ...(stored.runtimePath ? { runtimePath: stored.runtimePath } : {}),
+                ...(stored.releaseTag === undefined ? {} : { releaseTag: stored.releaseTag }),
+                ...(stored.registryUrl === undefined ? {} : { registryUrl: stored.registryUrl }),
                 machineToken: await configured.protector.unprotect(stored.machineTokenProtected.ciphertext),
             });
         }
@@ -355,5 +383,13 @@ export function applyProfileToEnv(profile, env) {
         delete env.CREW_AGENTS_ROOT;
     if (profile.runtimePath)
         env.PATH = profile.runtimePath;
+    if (profile.releaseTag)
+        env.CREW_DAEMON_RELEASE_TAG = profile.releaseTag;
+    else
+        delete env.CREW_DAEMON_RELEASE_TAG;
+    if (profile.registryUrl)
+        env.CREW_NPM_REGISTRY = profile.registryUrl;
+    else
+        delete env.CREW_NPM_REGISTRY;
     env.CREW_CODEX_HOME_MODE = profile.codexHomeMode ?? "shared";
 }

package/dist/computer-service.js

@@ -4,6 +4,7 @@ import { execFile, spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { promisify } from "node:util";
 import { dirname, resolve } from "node:path";
+import { normalizeDaemonNpmRegistry } from "./npm-registry.js";
 const execFileAsync = promisify(execFile);
 const WINDOWS_STOP_TIMEOUT_MS = 5_000;
 const WINDOWS_STOP_POLL_MS = 100;
@@ -541,19 +542,23 @@ export async function doctorService(spec, profilePrivate, runner = systemCommand
         { name: "service-running", ok: status.running === true, detail: status.running ? "running" : "not running" },
     ];
 }
-export function buildUpgradeCommand(platform, npmPrefix) {
+export function buildUpgradeCommand(platform, npmPrefix, releaseTag = "latest", registryUrl) {
     return [
         platform === "win32" ? "npm.cmd" : "npm",
         [
             "install",
             "--global",
+            "--ignore-scripts",
+            "--no-audit",
+            "--no-fund",
             ...(npmPrefix === undefined ? [] : ["--prefix", npmPrefix]),
-            "@nowcrew/daemon@latest",
+            ...(registryUrl === undefined ? [] : ["--registry", normalizeDaemonNpmRegistry(registryUrl, { allowLoopbackHttp: releaseTag === "beta" })]),
+            `@nowcrew/daemon@${releaseTag}`,
         ],
     ];
 }
-export async function upgradeDaemon(platform, runner = systemCommandRunner, npmPrefix) {
-    const [command, args] = buildUpgradeCommand(platform, npmPrefix);
+export async function upgradeDaemon(platform, runner = systemCommandRunner, npmPrefix, releaseTag = "latest", registryUrl) {
+    const [command, args] = buildUpgradeCommand(platform, npmPrefix, releaseTag, registryUrl);
     await checked(runner, command, args, "Daemon upgrade");
 }
 const WINDOWS_SID_SCRIPT = "[System.Security.Principal.WindowsIdentity]::GetCurrent().User.Value";

package/dist/daemon-migration-controller.js

@@ -119,10 +119,12 @@ export function createDaemonMigrationController(input) {
             let currentSpec;
             let currentService;
             let managedRecord = null;
+            let currentRegistryUrl;
             try {
                 const currentProfile = await (input.loadCurrentProfile ?? loadProfile)(input.profileName, input.currentDaemonHome);
                 if (currentProfile.machineToken !== input.machineToken)
                     throw new Error("active profile token does not match this daemon");
+                currentRegistryUrl = currentProfile.registryUrl;
                 const target = resolveAutomaticInstallTarget({ serverUrl: input.serverUrl, requestedProfile: message.targetProfile, userHome, platform });
                 if (!isAbsolute(message.targetDaemonHome) || !isAbsolute(message.targetAgentsRoot)
                     || resolve(message.targetDaemonHome) !== resolve(target.daemonHome)
@@ -165,6 +167,7 @@ export function createDaemonMigrationController(input) {
                     serverUrl: input.serverUrl,
                     machineToken: input.machineToken,
                     requestedProfile: message.targetProfile,
+                    ...(currentRegistryUrl === undefined ? {} : { requestedRegistryUrl: currentRegistryUrl }),
                 });
                 if (result.profile !== message.targetProfile || result.serviceId.length === 0) {
                     throw new Error("target service identity did not match the requested profile");

package/dist/daemon-release-version.js

@@ -0,0 +1,22 @@
+import { compare, prerelease, valid } from "semver";
+const CANONICAL_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-beta(?:\.|-)(0|[1-9]\d*))?$/u;
+function normalizedVersion(input) {
+    return input.replace(/-beta-(0|[1-9]\d*)$/u, "-beta.$1");
+}
+export function isDaemonReleaseVersion(input) {
+    const raw = input.trim();
+    if (raw !== input || !CANONICAL_VERSION.test(raw) || valid(raw) !== raw)
+        return false;
+    const parts = prerelease(raw);
+    return parts === null || normalizedVersion(raw).includes("-beta.");
+}
+export function daemonReleaseChannel(version) {
+    if (!isDaemonReleaseVersion(version))
+        return null;
+    return prerelease(version) === null ? "stable" : "beta";
+}
+export function compareDaemonReleaseVersions(left, right) {
+    return isDaemonReleaseVersion(left) && isDaemonReleaseVersion(right)
+        ? compare(normalizedVersion(left), normalizedVersion(right))
+        : 0;
+}

package/dist/daemon-update-controller.js

@@ -1,13 +1,14 @@
 import { z } from "zod";
+import { isDaemonReleaseVersion } from "./daemon-release-version.js";
 const DaemonUpdateMessageSchema = z.object({
     type: z.literal("daemon:update"),
     updateId: z.string().uuid(),
-    targetVersion: z.string().regex(/^\d+\.\d+\.\d+$/),
+    targetVersion: z.string().refine(isDaemonReleaseVersion, "invalid daemon release version"),
 }).strict();
 const DaemonRestartMessageSchema = z.object({
     type: z.literal("daemon:restart"),
     updateId: z.string().uuid(),
-    targetVersion: z.string().regex(/^\d+\.\d+\.\d+$/),
+    targetVersion: z.string().refine(isDaemonReleaseVersion, "invalid daemon release version"),
 }).strict();
 const DaemonControlMessageSchema = z.union([DaemonUpdateMessageSchema, DaemonRestartMessageSchema]);
 export function createDaemonUpdateController(deps) {