@cydm/happy-elves 0.1.0-beta.271 → 0.1.0-beta.273

package/apps/cli/dist/commands/app.js

@@ -9,6 +9,7 @@ import { handleLoop } from "./loop.js";
 import { handleMachine } from "./machine.js";
 import { handleMemory } from "./memory.js";
 import { handleRelay } from "./relay.js";
+import { handleRelease } from "./release.js";
 import { handleSchedule } from "./schedule.js";
 import { handleRemote } from "./remote.js";
 import { handleSession } from "./session.js";
@@ -26,6 +27,7 @@ const domainHandlers = [
     handleLoop,
     handleDaemon,
     handleRelay,
+    handleRelease,
     handleMachine,
     handleMemory,
     handleSchedule,

package/apps/cli/dist/commands/lib/args.js

@@ -67,7 +67,18 @@ const valueFlags = new Set([
     "source",
     "stop-on",
     "tail",
+    "tag",
     "tags",
+    "release-tag",
+    "release-tags",
+    "reviewer-tag",
+    "reviewer-tags",
+    "dogfood-tag",
+    "dogfood-tags",
+    "target-machine",
+    "target-machines",
+    "expected-commit",
+    "profile",
     "text",
     "text-file",
     "timeout",
@@ -110,6 +121,8 @@ const booleanFlags = new Set([
     "wait",
     "hidden",
     "manual",
+    "copy-tags",
+    "no-daemon-update",
 ]);
 const knownFlags = new Set([...valueFlags, ...booleanFlags]);
 const dashPrefixedValueFlags = new Set(["secret"]);

package/apps/cli/dist/commands/lib/paths.d.ts

@@ -8,3 +8,4 @@ export declare const daemonPidPath: string;
 export declare const loopStorePath: string;
 export declare const loopStoreLockPath: string;
 export declare const gatewayStorePath: string;
+export declare const releaseProfilesPath: string;

package/apps/cli/dist/commands/lib/paths.js

@@ -12,4 +12,5 @@ export const daemonPidPath = path.join(configDir, "daemon.pid");
 export const loopStorePath = path.join(configDir, "loops.json");
 export const loopStoreLockPath = path.join(configDir, "loops.json.lock");
 export const gatewayStorePath = path.join(configDir, "gateway.json");
+export const releaseProfilesPath = path.join(configDir, "release-profiles.json");
 //# sourceMappingURL=paths.js.map

package/apps/cli/dist/commands/lib/session-view.d.ts

@@ -25,6 +25,7 @@ export declare function structuredSessionProjection(client: ControllerClient, se
     sourceSessionId?: string;
     sourceCheckpointId?: string;
     capabilities: SessionSnapshot["capabilities"];
+    tags: string[];
     orchestration: OrchestrationSummary;
 }>;
 export declare function compactSessionListItem(client: ControllerClient, session: SessionSnapshot, options?: {
@@ -40,6 +41,7 @@ export declare function compactSessionListItem(client: ControllerClient, session
     machineId?: string;
     machineName?: string;
     cwdName?: string;
+    tags: string[];
 }>;
 export declare function conciseSessionSummary(client: ControllerClient, session: SessionSnapshot): Promise<{
     sessionId: string;
@@ -50,6 +52,7 @@ export declare function conciseSessionSummary(client: ControllerClient, session:
     status: SessionSnapshot["status"];
     state: OrchestrationState;
     updatedAt: number;
+    tags: string[];
 }>;
 export declare function requireProjectedSession(client: ControllerClient, sessionId: string, action: string): Promise<SessionSnapshot>;
 export declare function machineSessionOverview(client: ControllerClient, sessions: SessionSnapshot[], machineId: string): Promise<{

package/apps/cli/dist/commands/lib/session-view.js

@@ -117,6 +117,7 @@ export async function structuredSessionProjection(client, session, events = [])
         sourceSessionId: session.sourceSessionId,
         sourceCheckpointId: session.sourceCheckpointId,
         capabilities: session.capabilities,
+        tags: Array.isArray(metadata.tags) ? metadata.tags.filter((tag) => typeof tag === "string") : [],
         orchestration,
     };
 }
@@ -135,6 +136,7 @@ export async function compactSessionListItem(client, session, options = {}) {
         state: orchestration.state,
         agent: metadata.agent ?? session.agent,
         updatedAt: session.updatedAt,
+        tags: Array.isArray(metadata.tags) ? metadata.tags.filter((tag) => typeof tag === "string") : [],
         ...(options.includeMachine ? { machineId: session.machineId, machineName: options.machineName } : {}),
         ...(options.includeCwd ? { cwdName: cwdDisplayName(metadata.cwd ?? session.cwd) } : {}),
     };
@@ -151,6 +153,7 @@ export async function conciseSessionSummary(client, session) {
         status: session.status,
         state: orchestration.state,
         updatedAt: session.updatedAt,
+        tags: Array.isArray(metadata.tags) ? metadata.tags.filter((tag) => typeof tag === "string") : [],
     };
 }
 export async function requireProjectedSession(client, sessionId, action) {

package/apps/cli/dist/commands/lib/types.d.ts

@@ -29,6 +29,8 @@ export type SessionMetadata = {
     cwd?: string;
     name?: string;
     requestedRuntimeName?: string;
+    tags?: string[];
+    tagKeys?: string[];
     runtime?: unknown;
 };
 export declare const idleSessionStatuses: SessionSnapshot["status"][];

package/apps/cli/dist/commands/lib/usage.js

@@ -50,8 +50,11 @@ Check local controller config, relay reachability, and daemon state.
   file preview is read-only and limited to files inside --root.
 `,
     session: `Usage:
-  happy-elves session create --machine <machineId> [--agent codex] [--cwd <path>] [--name <name>] [--permission-mode <mode>] [--hidden] [--source dogfood] --json
-  happy-elves session list [--machine <machineId>] [--agent <agent>] [--cwd <cwd>] [--name <name>] [--limit n] [--all] [--verbose] [--json]
+  happy-elves session create --machine <machineId> [--agent codex] [--cwd <path>] [--name <name>] [--permission-mode <mode>] [--hidden] [--source dogfood] [--tag <tag>] --json
+  happy-elves session list [--machine <machineId>] [--agent <agent>] [--cwd <cwd>] [--name <name>] [--tag <tag>] [--limit n] [--all] [--verbose] [--json]
+  happy-elves session tag add <sessionId> --tag <tag> --json
+  happy-elves session tag remove <sessionId> --tag <tag> --json
+  happy-elves session tag list <sessionId> --json
   happy-elves session history --machine <machineId> [--cwd <path>] [--agent <agent>] [--include-archived] [--limit 20] --json
   happy-elves session continue <runtimeSessionId> --machine <machineId> [--name <name>] --json
   happy-elves session status <sessionId> [--verbose] [--json]
@@ -73,6 +76,7 @@ Session management:
   repair-binding imports the matching runtime history row as a new loaded
   session and closes the empty/stale source session unless --keep-source is set.
   close archives a loaded session. There is no separate archive command.
+  tags are encrypted session metadata used for release/reviewer/dogfood routing.
 `,
     turn: `Usage:
   happy-elves turn list <sessionId> [--limit 10] [--verbose] [--json]
@@ -81,10 +85,10 @@ Session management:
   happy-elves turn run <sessionId> (--text <prompt> | --text-file <path>) [--detach] [--timeout 1000s] [--inactivity-timeout 1000s] [--permission-mode approve-reads|approve-all|deny-all] [--memory off|readonly|readwrite] [--memory-project <key>] [--memory-top-n 3] [--json]
   happy-elves turn wait <sessionId> <turnId> [--timeout 1000s] --json
   happy-elves turn reconcile <sessionId> [turnId] --json
-  happy-elves turn recover <sessionId> [turnId] --text <continuation> --confirm-risk [--detach] --json
+  happy-elves turn recover <sessionId> [turnId] --text <continuation> --confirm-risk [--copy-tags] [--detach] --json
   happy-elves turn cancel <sessionId> <turnId> [--reason <reason>] --json
   happy-elves turn rewind <sessionId> <turn-or-checkpoint-id> --json
-  happy-elves turn fork <sessionId> <turn-or-checkpoint-id> --name <name> --json
+  happy-elves turn fork <sessionId> <turn-or-checkpoint-id> --name <name> [--copy-tags] --json
 
 Turn management:
   run starts one agent execution. It waits by default; use --detach for
@@ -113,6 +117,19 @@ Turn management:
 
 Workspace sync records account-level UI/library state shared across devices:
 session stars, recent sessions, pinned workspaces, and current project defaults.
+`,
+    release: `Usage:
+  happy-elves release profile list --json
+  happy-elves release profile show [--profile <name>] --json
+  happy-elves release profile set <name> --release-tag <tag> [--release-tag <tag>] [--reviewer-tag <tag>] [--dogfood-tag <tag>] [--no-daemon-update] --json
+  happy-elves release resolve [--profile happy-elves] --json
+  happy-elves release start [--profile happy-elves] [--expected-commit <sha>] [--target-machine <machineId>] [--no-daemon-update] [--wait] --json
+  happy-elves release status [jobId] [--machine <machineId>] --json
+  happy-elves release logs [jobId] [--machine <machineId>] [--tail 200] --json
+
+Release profiles resolve target sessions by encrypted session tags. The built-in
+happy-elves profile uses Happy Elves + Release Session for the release target.
+Release start runs a fixed daemon-local runner; it does not accept arbitrary shell.
 `,
     gateway: `Usage:
   happy-elves gateway enable [<channelId>] --channel lark --machine <machineId> (--cwd <cwd> | --session <sessionId>) [--agent codex] [--model <model>] --json
@@ -210,7 +227,9 @@ Core commands:
   machine directory <machineId> [--path <path>] [--json]
 
   session list [--machine <machineId>] [--cwd <path>] [--limit 20] [--json]
-  session create --machine <machineId> [--agent codex] [--cwd <path>] [--name <name>] [--hidden] --json
+  session create --machine <machineId> [--agent codex] [--cwd <path>] [--name <name>] [--hidden] [--tag <tag>] --json
+  session tag add <sessionId> --tag <tag> --json
+  session tag remove <sessionId> --tag <tag> --json
   session history --machine <machineId> [--cwd <path>] [--limit 20] --json
   session continue <runtimeSessionId> --machine <machineId> --json
   session repair-binding <sessionId> [--runtime-session <runtimeSessionId>] --json
@@ -224,10 +243,10 @@ Core commands:
   turn wait <sessionId> <turnId> [--timeout 1000s] [--json]
   turn result <sessionId> [<turnId>] [--json]
   turn reconcile <sessionId> [turnId] --json
-  turn recover <sessionId> [turnId] --text <continuation> --confirm-risk [--json]
+  turn recover <sessionId> [turnId] --text <continuation> --confirm-risk [--copy-tags] [--json]
   turn cancel <sessionId> <turnId> [--reason <reason>] --json
   turn rewind <sessionId> <turn-or-checkpoint-id> --json
-  turn fork <sessionId> <turn-or-checkpoint-id> --name <name> --json
+  turn fork <sessionId> <turn-or-checkpoint-id> --name <name> [--copy-tags] --json
 
   remote status --json
   remote devices [--json]
@@ -238,8 +257,11 @@ Core commands:
   workspace star <sessionId> --json
   workspace pin-cwd --machine <machineId> --cwd <cwd> --json
 
+  release resolve --profile happy-elves --json
+  release start --profile happy-elves --json
+
   gateway status --json
-  gateway enable --channel fake --machine <machineId> --cwd <cwd> --json  # debug only
+  gateway enable --channel lark --machine <machineId> --cwd <cwd> --json
   gateway test --conversation <id> --message-id <id> --text <prompt> --json
 
   memory save --project <key> --text <fact> --json
@@ -261,12 +283,12 @@ Common flows:
   Discover: machine list --json; session list --machine <machineId> --json
   Continue: session history --machine <machineId> --json; session continue <runtimeSessionId> --machine <machineId> --json
   Execute: turn run <sessionId> --text <prompt> --json; turn result <sessionId> <turnId> --json
-  Branch: turn rewind <sessionId> <turnId> --json; turn fork <sessionId> <turnId> --name <name> --json
+  Branch: turn rewind <sessionId> <turnId> --json; turn fork <sessionId> <turnId> --name <name> [--copy-tags] --json
 
 More:
   happy-elves --skill
   happy-elves <domain> --help
-  start, status, doctor, collect, config, account, daemon, relay, token, workspace, gateway, memory, schedule, loop.
+  start, status, doctor, collect, config, account, daemon, relay, token, workspace, release, gateway, memory, schedule, loop.
 `;
 }
 export function skillText() {
@@ -292,6 +314,17 @@ Recommended agent workflow:
   6. turn wait <sessionId> <turnId> --json
   7. turn result <sessionId> <turnId> --json
 
+Release / reviewer / dogfood workflow:
+  1. Tag the release session once:
+     session tag add <sessionId> --tag "Happy Elves" --json
+     session tag add <sessionId> --tag "Release Session" --json
+  2. Resolve before acting:
+     release resolve --profile happy-elves --json
+  3. Start release only when the release target is exactly one session:
+     release start --profile happy-elves --json
+  4. Use hidden sessions for temporary dogfood:
+     session create --hidden --source dogfood --tag "Happy Elves" --tag "Dogfood" ...
+
 Concepts:
   Loaded session: a Happy Elves control-plane session that can be operated by
   this CLI.

package/apps/cli/dist/commands/release.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleRelease({ domain, action, positional, flags }: CommandInput): Promise<boolean>;

package/apps/cli/dist/commands/release.js

@@ -0,0 +1,299 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { normalizeSessionTags } from "../../../../packages/shared/dist/index.js";
+import { CliError, ControllerClient, compactText, ok, parseDurationMs, readConfig, releaseProfilesPath, requirePositional, wantsJson, } from "./lib/index.js";
+const defaultReleaseProfile = {
+    name: "happy-elves",
+    releaseSessionTags: ["Happy Elves", "Release Session"],
+    reviewerSessionTags: ["Happy Elves", "Reviewer"],
+    dogfoodSessionTags: ["Happy Elves", "Dogfood"],
+    targetDaemonPolicy: "all-online-lifecycle",
+    notifyOnStart: false,
+    notifyOnSuccess: true,
+    notifyOnFailure: true,
+};
+export async function handleRelease({ domain, action, positional, flags }) {
+    if (domain !== "release")
+        return false;
+    if (action === "profile") {
+        const subaction = requirePositional(positional[0], "profile action");
+        if (subaction === "list") {
+            const store = await readReleaseProfileStore();
+            printReleaseOutput("release.profile.list", { profiles: store.profiles, defaultProfile: defaultReleaseProfile.name }, flags);
+            return true;
+        }
+        if (subaction === "show") {
+            const name = positional[1] || profileNameFromFlags(flags);
+            const { profile } = await loadProfile(name);
+            printReleaseOutput("release.profile.show", { profile }, flags);
+            return true;
+        }
+        if (subaction === "set") {
+            const name = positional[1] || profileNameFromFlags(flags);
+            const profile = profileFromFlags(name, flags);
+            const store = await readReleaseProfileStore();
+            const profiles = store.profiles.filter((item) => item.name !== profile.name);
+            profiles.push(profile);
+            await writeReleaseProfileStore({ ...store, profiles: profiles.sort((left, right) => left.name.localeCompare(right.name)) });
+            printReleaseOutput("release.profile.set", { profile }, flags);
+            return true;
+        }
+        throw new CliError(`Unsupported release profile action: ${subaction}`, "USAGE");
+    }
+    if (action === "resolve") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const { profile } = await loadProfile(profileNameFromFlags(flags));
+        const resolved = await resolveReleaseTargets(client, profile, flags);
+        printReleaseOutput("release.resolve", resolved, flags);
+        return true;
+    }
+    if (action === "start") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const { profile } = await loadProfile(profileNameFromFlags(flags));
+        const resolved = await resolveReleaseTargets(client, profile, flags);
+        if (resolved.errors.length > 0) {
+            throw new CliError(resolved.errors[0]?.message ?? "Release target resolution failed", resolved.errors[0]?.code ?? "TAG_TARGET_NOT_FOUND");
+        }
+        const targetMachineIds = targetMachineIdsForRelease(resolved, flags);
+        const expectedCommit = typeof flags["expected-commit"] === "string" && flags["expected-commit"].trim() ? flags["expected-commit"].trim() : undefined;
+        const result = await client.releaseJob({
+            machineId: resolved.releaseTarget.machineId,
+            action: "start",
+            release: {
+                profile,
+                releaseTarget: resolved.releaseTarget,
+                ...(resolved.reviewerTarget ? { reviewerTarget: resolved.reviewerTarget } : {}),
+                ...(resolved.dogfoodTarget ? { dogfoodTarget: resolved.dogfoodTarget } : {}),
+                ...(targetMachineIds.length > 0 ? { targetMachineIds } : {}),
+                ...(expectedCommit ? { expectedCommit } : {}),
+            },
+            waitTimeoutMs: parseDurationMs(flags["wait-timeout"] ?? flags.timeout, 45_000),
+        });
+        await rememberReleaseJob(profile.name, result.jobId ?? result.requestId, result.machineId);
+        if (flags.wait === true && result.jobId) {
+            const waited = await waitForReleaseJob(client, result.machineId, result.jobId, parseDurationMs(flags.timeout, 30 * 60 * 1000));
+            printReleaseOutput("release.start", { ...result, waited }, flags);
+        }
+        else {
+            printReleaseOutput("release.start", result, flags);
+        }
+        return true;
+    }
+    if (action === "status" || action === "logs") {
+        const jobId = positional[0];
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const machineId = await releaseJobMachineId(jobId, flags);
+        const result = await client.releaseJob({
+            machineId,
+            action,
+            ...(jobId ? { jobId } : {}),
+            tail: parseTail(flags),
+            waitTimeoutMs: parseDurationMs(flags["wait-timeout"] ?? flags.timeout, 45_000),
+        });
+        printReleaseOutput(`release.${action}`, result, flags);
+        return true;
+    }
+    return false;
+}
+function profileNameFromFlags(flags) {
+    return typeof flags.profile === "string" && flags.profile.trim() ? flags.profile.trim() : defaultReleaseProfile.name;
+}
+function profileFromFlags(name, flags) {
+    const releaseSessionTags = tagsFromFlags(flags, "release-tag", "release-tags");
+    if (releaseSessionTags.length === 0)
+        throw new CliError("Missing --release-tag", "MISSING_ARGUMENT");
+    const reviewerSessionTags = tagsFromFlags(flags, "reviewer-tag", "reviewer-tags");
+    const dogfoodSessionTags = tagsFromFlags(flags, "dogfood-tag", "dogfood-tags");
+    return {
+        name,
+        releaseSessionTags,
+        ...(reviewerSessionTags.length > 0 ? { reviewerSessionTags } : {}),
+        ...(dogfoodSessionTags.length > 0 ? { dogfoodSessionTags } : {}),
+        targetDaemonPolicy: flags["no-daemon-update"] === true ? "none" : "all-online-lifecycle",
+        notifyOnStart: false,
+        notifyOnSuccess: true,
+        notifyOnFailure: true,
+    };
+}
+function tagsFromFlags(flags, single, plural) {
+    return normalizeSessionTags([
+        ...tagsFromFlagValue(flags[single]),
+        ...tagsFromFlagValue(flags[plural]),
+    ]);
+}
+function tagsFromFlagValue(value) {
+    if (typeof value !== "string")
+        return [];
+    return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+async function loadProfile(name) {
+    const store = await readReleaseProfileStore();
+    return { profile: store.profiles.find((profile) => profile.name === name) ?? defaultReleaseProfile, store };
+}
+async function readReleaseProfileStore() {
+    try {
+        const parsed = JSON.parse(await fs.readFile(releaseProfilesPath, "utf8"));
+        const profiles = Array.isArray(parsed.profiles) ? parsed.profiles.filter(isReleaseProfile) : [];
+        const hasDefault = profiles.some((profile) => profile.name === defaultReleaseProfile.name);
+        return {
+            version: 1,
+            profiles: hasDefault ? profiles : [defaultReleaseProfile, ...profiles],
+            lastJobs: parsed.lastJobs && typeof parsed.lastJobs === "object" && !Array.isArray(parsed.lastJobs) ? parsed.lastJobs : {},
+        };
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        return { version: 1, profiles: [defaultReleaseProfile], lastJobs: {} };
+    }
+}
+function isReleaseProfile(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return typeof candidate.name === "string" && Array.isArray(candidate.releaseSessionTags);
+}
+async function writeReleaseProfileStore(store) {
+    await fs.mkdir(path.dirname(releaseProfilesPath), { recursive: true });
+    const tempPath = `${releaseProfilesPath}.${process.pid}.${Date.now()}.tmp`;
+    await fs.writeFile(tempPath, `${JSON.stringify(store, null, 2)}\n`, { mode: 0o600 });
+    await fs.rename(tempPath, releaseProfilesPath);
+}
+async function resolveReleaseTargets(client, profile, flags) {
+    const warnings = [];
+    const errors = [];
+    const release = await resolveTaggedSession(client, profile.releaseSessionTags);
+    if (release.kind === "missing")
+        errors.push({ code: "TAG_TARGET_NOT_FOUND", message: `No release session matches tags: ${profile.releaseSessionTags.join(", ")}` });
+    if (release.kind === "ambiguous")
+        errors.push({ code: "TAG_TARGET_AMBIGUOUS", message: `Multiple release sessions match tags: ${profile.releaseSessionTags.join(", ")}`, candidates: release.candidates });
+    const reviewer = profile.reviewerSessionTags?.length ? await resolveTaggedSession(client, profile.reviewerSessionTags) : { kind: "skipped" };
+    if (reviewer.kind === "ambiguous")
+        errors.push({ code: "TAG_TARGET_AMBIGUOUS", message: `Multiple reviewer sessions match tags: ${profile.reviewerSessionTags?.join(", ")}`, candidates: reviewer.candidates });
+    if (reviewer.kind === "missing")
+        warnings.push({ code: "TAG_TARGET_NOT_FOUND", message: `No reviewer session matches tags: ${profile.reviewerSessionTags?.join(", ")}` });
+    const dogfood = profile.dogfoodSessionTags?.length ? await resolveTaggedSession(client, profile.dogfoodSessionTags) : { kind: "skipped" };
+    if (dogfood.kind === "ambiguous")
+        errors.push({ code: "TAG_TARGET_AMBIGUOUS", message: `Multiple dogfood sessions match tags: ${profile.dogfoodSessionTags?.join(", ")}`, candidates: dogfood.candidates });
+    if (dogfood.kind === "missing")
+        warnings.push({ code: "TAG_TARGET_NOT_FOUND", message: `No dogfood session matches tags: ${profile.dogfoodSessionTags?.join(", ")}` });
+    const targetMachineIds = targetMachineIdsForPolicy(await client.listMachines(), profile, flags);
+    return {
+        profile,
+        releaseTarget: release.kind === "found" ? release.session : emptyReleaseTarget(),
+        ...(reviewer.kind === "found" ? { reviewerTarget: reviewer.session } : {}),
+        ...(dogfood.kind === "found" ? { dogfoodTarget: dogfood.session } : {}),
+        targetMachineIds,
+        warnings,
+        errors,
+    };
+}
+async function resolveTaggedSession(client, tags) {
+    const sessions = (await client.listSessions({ tags }))
+        .filter((session) => session.status !== "closed");
+    const summaries = await Promise.all(sessions.map(async (session) => {
+        const metadata = await client.decodeSessionMetadata(session);
+        const sessionTags = normalizeSessionTags(Array.isArray(metadata.tags) ? metadata.tags : []);
+        return {
+            sessionId: session.id,
+            machineId: session.machineId,
+            agent: metadata.agent ?? session.agent,
+            cwd: metadata.cwd ?? session.cwd,
+            name: metadata.name ?? session.name,
+            tags: sessionTags,
+        };
+    }));
+    if (summaries.length === 0)
+        return { kind: "missing" };
+    if (summaries.length > 1)
+        return { kind: "ambiguous", candidates: summaries };
+    return { kind: "found", session: summaries[0] };
+}
+function emptyReleaseTarget() {
+    return { sessionId: "", machineId: "", agent: "", cwd: "", name: "", tags: [] };
+}
+function targetMachineIdsForPolicy(machines, profile, flags) {
+    const explicit = normalizeSessionTags([
+        ...tagsFromFlagValue(flags["target-machine"]),
+        ...tagsFromFlagValue(flags["target-machines"]),
+    ]);
+    if (explicit.length > 0)
+        return explicit;
+    if (flags["no-daemon-update"] === true || profile.targetDaemonPolicy === "none")
+        return [];
+    return machines
+        .filter((machine) => machine.online && machine.capabilities.daemonLifecycle === true)
+        .map((machine) => machine.id);
+}
+function targetMachineIdsForRelease(resolved, flags) {
+    if (flags["no-daemon-update"] === true)
+        return [];
+    return resolved.targetMachineIds;
+}
+async function rememberReleaseJob(profileName, jobId, machineId) {
+    const store = await readReleaseProfileStore();
+    const entry = { jobId, machineId, profileName, startedAt: new Date().toISOString() };
+    await writeReleaseProfileStore({
+        ...store,
+        lastJobs: {
+            ...store.lastJobs,
+            [profileName]: entry,
+            [jobId]: entry,
+        },
+    });
+}
+async function releaseJobMachineId(jobId, flags) {
+    if (typeof flags.machine === "string" && flags.machine.trim())
+        return flags.machine.trim();
+    const profile = profileNameFromFlags(flags);
+    const store = await readReleaseProfileStore();
+    const entry = jobId ? store.lastJobs[jobId] : store.lastJobs[profile];
+    if (!entry?.machineId)
+        throw new CliError("Missing --machine and no remembered release job machine is available", "MISSING_ARGUMENT");
+    return entry.machineId;
+}
+async function waitForReleaseJob(client, machineId, jobId, timeoutMs) {
+    const deadline = Date.now() + (timeoutMs ?? 30 * 60 * 1000);
+    let last = await client.releaseJob({ machineId, action: "status", jobId });
+    while (Date.now() < deadline && !isTerminalReleaseStatus(last.status)) {
+        await new Promise((resolve) => setTimeout(resolve, 2_000));
+        last = await client.releaseJob({ machineId, action: "status", jobId });
+    }
+    return last;
+}
+function isTerminalReleaseStatus(status) {
+    return status === "gate_failed" || status === "deploy_failed" || status === "verify_failed" || status === "update_failed" || status === "notify_failed" || status === "dogfood_failed" || status === "succeeded" || status === "failed";
+}
+function parseTail(flags) {
+    if (typeof flags.tail !== "string")
+        return undefined;
+    const value = Number(flags.tail);
+    if (!Number.isInteger(value) || value <= 0)
+        throw new CliError(`Invalid --tail: ${flags.tail}`, "INVALID_ARGUMENT");
+    return value;
+}
+function printReleaseOutput(type, data, flags) {
+    if (wantsJson(flags)) {
+        ok(type, data);
+        return;
+    }
+    if (type === "release.resolve") {
+        const resolved = data;
+        console.log(`Profile: ${resolved.profile.name}`);
+        console.log(`Release: ${resolved.releaseTarget.sessionId || "not found"}  ${compactText(resolved.releaseTarget.name || "-", 64)}`);
+        if (resolved.reviewerTarget)
+            console.log(`Reviewer: ${resolved.reviewerTarget.sessionId}  ${compactText(resolved.reviewerTarget.name, 64)}`);
+        if (resolved.dogfoodTarget)
+            console.log(`Dogfood: ${resolved.dogfoodTarget.sessionId}  ${compactText(resolved.dogfoodTarget.name, 64)}`);
+        for (const warning of resolved.warnings)
+            console.log(`Warning: ${warning.code} ${warning.message}`);
+        for (const error of resolved.errors)
+            console.log(`Error: ${error.code} ${error.message}`);
+        return;
+    }
+    console.log(JSON.stringify(data, null, 2));
+}
+//# sourceMappingURL=release.js.map

package/apps/cli/dist/commands/remote.js

@@ -199,7 +199,8 @@ export async function handleRemote({ domain, action, positional, flags }) {
     return false;
 }
 function printDaemonLifecycle(type, result, flags) {
-    const success = result.accepted !== false && result.updateState?.status !== "failed";
+    const isReadOnlyAction = result.action === "status" || result.action === "logs";
+    const success = result.accepted !== false && (isReadOnlyAction || result.updateState?.status !== "failed");
     if (wantsJson(flags)) {
         ok(type, result, { requestId: result.requestId, machineId: result.machineId }, success);
         return;
@@ -255,7 +256,10 @@ async function waitForDaemonLifecycle(client, machineId, requestId, action, opti
         catch (error) {
             lastError = error;
             const code = errorCode(error);
-            if (code !== "MACHINE_OFFLINE" && code !== "COMMAND_TIMEOUT" && code !== "RELAY_CONNECT_TIMEOUT")
+            if (code !== "MACHINE_OFFLINE" &&
+                code !== "COMMAND_TIMEOUT" &&
+                code !== "RELAY_CONNECT_TIMEOUT" &&
+                code !== "RELAY_WEBSOCKET_ERROR")
                 throw error;
         }
         await sleep(1000);