@skrr-ai/cli 0.1.102 → 0.1.104

package/dist/commands/daemon/logs.js

@@ -3,10 +3,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIVE_LOG_RESOLUTION_RUNTIME_VERSION = void 0;
 exports.describeLogAge = describeLogAge;
 exports.resolveLegacyDaemonLogPath = resolveLegacyDaemonLogPath;
+exports.resolveDaemonLogsProfile = resolveDaemonLogsProfile;
+exports.installedServiceLogDestinations = installedServiceLogDestinations;
+exports.installedServiceLogCandidates = installedServiceLogCandidates;
+exports.chooseLegacyFallbackLog = chooseLegacyFallbackLog;
+exports.resolveForwardedLogPath = resolveForwardedLogPath;
+exports.parseRuntimeVersion = parseRuntimeVersion;
+exports.runtimeVersionAtLeast = runtimeVersionAtLeast;
+exports.probeRuntimeVersion = probeRuntimeVersion;
+exports.probeStatusLogPath = probeStatusLogPath;
+exports.planDaemonLogs = planDaemonLogs;
 exports.readDaemonLogTail = readDaemonLogTail;
-exports.buildOverskyLogsArgs = buildOverskyLogsArgs;
+exports.buildDaemonLogsArgs = buildDaemonLogsArgs;
 const core_1 = require("@oclif/core");
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
@@ -62,6 +73,11 @@ function describeLogAge(mtimeMs, now = Date.now()) {
     };
 }
 function resolveLegacyDaemonLogPath(flags, options = {}) {
+    const home = options.home ?? (0, node_os_1.homedir)();
+    return node_path_1.default.join(home, '.skrr', 'profiles', resolveDaemonLogsProfile(flags, options), 'logs', flags.stderr ? 'daemon.err.log' : 'daemon.log');
+}
+/** The profile `logs` addresses: --profile, then the profile environment variable, then the pin. */
+function resolveDaemonLogsProfile(flags, options = {}) {
     const home = options.home ?? (0, node_os_1.homedir)();
     const env = options.env ?? process.env;
     // An explicit --profile outranks the environment, as it does everywhere else.
@@ -81,7 +97,259 @@ function resolveLegacyDaemonLogPath(flags, options = {}) {
             // An absent/corrupt sticky selector must match the daemon's default.
         }
     }
-    return node_path_1.default.join(home, '.skrr', 'profiles', profile ?? 'default', 'logs', flags.stderr ? 'daemon.err.log' : 'daemon.log');
+    return profile ?? 'default';
+}
+/**
+ * Read the installed launchd definition's log destinations (OSK-15993). The
+ * desktop supervisor starts the daemon with
+ * `--log-file ~/Library/Logs/Skrr/daemon.app.log` and redirects stderr to
+ * `daemon.stderr.log`, so the profile's `logs/` directory can hold a file
+ * nobody has written for a week. Read-only: the plist is parsed, never loaded.
+ */
+function installedServiceLogDestinations(profile, options = {}) {
+    if ((options.platform ?? process.platform) !== 'darwin')
+        return null;
+    const plist = node_path_1.default.join(options.home ?? (0, node_os_1.homedir)(), 'Library', 'LaunchAgents', `ai.skrr.daemon.${profile}.plist`);
+    let xml;
+    try {
+        xml = (0, node_fs_1.readFileSync)(plist, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const unescape = (v) => v
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&amp;/g, '&');
+    const stringFor = (key) => {
+        const m = new RegExp(`<key>\\s*${key}\\s*</key>\\s*<string>([\\s\\S]*?)</string>`).exec(xml);
+        return m?.[1]?.trim() ? unescape(m[1].trim()) : null;
+    };
+    let logFile = null;
+    const array = /<key>\s*ProgramArguments\s*<\/key>\s*<array>([\s\S]*?)<\/array>/.exec(xml);
+    if (array?.[1]) {
+        const args = [...array[1].matchAll(/<string>([\s\S]*?)<\/string>/g)].map((m) => unescape(m[1].trim()));
+        const at = args.lastIndexOf('--log-file');
+        if (at >= 0 && args[at + 1] && !args[at + 1].startsWith('-'))
+            logFile = args[at + 1];
+    }
+    return {
+        logFile,
+        stdoutPath: stringFor('StandardOutPath'),
+        stderrPath: stringFor('StandardErrorPath'),
+    };
+}
+/** The installed service's log files for the main log, or for `--stderr`. */
+function installedServiceLogCandidates(profile, stderr, options = {}) {
+    const dest = installedServiceLogDestinations(profile, options);
+    if (!dest)
+        return [];
+    if (stderr)
+        return dest.stderrPath ? [dest.stderrPath] : [];
+    return [dest.logFile, dest.stdoutPath].filter((p) => Boolean(p));
+}
+/**
+ * Pick the file the legacy fallback reads. An old daemon cannot say which file
+ * it writes, so the most recently written of the profile log and the installed
+ * service's logs is the best evidence of the live one — and whenever that is
+ * not the profile log, the choice is said out loud rather than made silently.
+ */
+function chooseLegacyFallbackLog(args) {
+    const profileMtime = args.mtimeOf(args.profilePath);
+    let best = null;
+    for (const file of args.serviceCandidates) {
+        if (node_path_1.default.resolve(file) === node_path_1.default.resolve(args.profilePath))
+            continue;
+        const mtime = args.mtimeOf(file);
+        if (mtime === null)
+            continue;
+        if (!best || mtime > best.mtime)
+            best = { file, mtime };
+    }
+    if (!best || (profileMtime !== null && profileMtime >= best.mtime)) {
+        return { path: args.profilePath, note: null };
+    }
+    return {
+        path: best.file,
+        note: `Showing ${best.file}, the installed service's log: it was written more recently than ` +
+            (profileMtime === null
+                ? `the profile log ${args.profilePath}, which does not exist.`
+                : `the profile log ${args.profilePath}, which has not been written since.`) +
+            ` ${args.reason ?? 'This daemon predates `logs`, so it cannot name its live log itself.'}`,
+    };
+}
+/**
+ * Ask the installed runtime which file `logs` will read — the same live-aware
+ * answer it uses itself — so the age banner describes the file actually shown.
+ * Null when the runtime cannot answer in time; the banner is then skipped
+ * rather than printed about a file that may not be the one shown.
+ */
+async function resolveForwardedLogPath(flags, capture = exec_runtime_binary_1.execRuntimeBinaryCapture) {
+    try {
+        const out = await capture(buildDaemonLogsArgs({ ...flags, path: true }), {
+            timeoutMs: 5_000,
+        });
+        if (out.code !== 0)
+            return null;
+        const lines = out.stdout
+            .split('\n')
+            .map((l) => l.trim())
+            .filter(Boolean);
+        const last = lines.at(-1);
+        return last && node_path_1.default.isAbsolute(last) ? last : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The first runtime whose own `logs` reads the LIVE daemon's `--log-file`
+ * (OSK-15993, `daemon/src/daemon-log-target.ts`). 0.8.112 through 0.8.118 have
+ * a `logs` subcommand, so the subcommand probe says "supported", but it reads
+ * the profile's `logs/daemon.log` unconditionally — with a desktop-managed
+ * daemon, a file nobody has written for a week. Forwarding to one of those is
+ * forwarding to the bug, so the CLI forwards only at or above this version.
+ */
+exports.LIVE_LOG_RESOLUTION_RUNTIME_VERSION = '0.8.119';
+/** `x.y.z` from a version string, or null. A prerelease suffix is ignored. */
+function parseRuntimeVersion(text) {
+    const m = /(\d+)\.(\d+)\.(\d+)/.exec(text);
+    return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+}
+/** Whether `version` is at least `floor`; null when either is not a version. */
+function runtimeVersionAtLeast(version, floor) {
+    const a = parseRuntimeVersion(version);
+    const b = parseRuntimeVersion(floor);
+    if (!a || !b)
+        return null;
+    for (let i = 0; i < 3; i += 1) {
+        if (a[i] !== b[i])
+            return a[i] > b[i];
+    }
+    return true;
+}
+/** The installed runtime's `--version`, or null when it cannot say in time. */
+async function probeRuntimeVersion(capture = exec_runtime_binary_1.execRuntimeBinaryCapture) {
+    try {
+        const out = await capture(['--version'], { timeoutMs: 5_000 });
+        if (out.code !== 0)
+            return null;
+        const parsed = parseRuntimeVersion(out.stdout);
+        return parsed ? parsed.join('.') : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The live daemon's log as the runtime's `status --json` reports it
+ * (`service.logs`). Status has named the live `--log-file` since before `logs`
+ * did, so on 0.8.117 status is right while logs is wrong. Null when status
+ * cannot answer, or answers with anything but an absolute path.
+ */
+async function probeStatusLogPath(flags, capture = exec_runtime_binary_1.execRuntimeBinaryCapture) {
+    try {
+        const out = await capture([...(flags.profile ? ['--profile', flags.profile] : []), 'status', '--json'], { timeoutMs: 15_000 });
+        // `status` exits non-zero when it reports problems; the JSON is still the answer.
+        const start = out.stdout.indexOf('{');
+        if (start < 0)
+            return null;
+        const parsed = JSON.parse(out.stdout.slice(start));
+        const logs = parsed?.service?.logs;
+        return typeof logs === 'string' && node_path_1.default.isAbsolute(logs) ? logs : null;
+    }
+    catch {
+        return null;
+    }
+}
+function sameLogFile(a, b) {
+    return Boolean(a && b && node_path_1.default.resolve(a) === node_path_1.default.resolve(b));
+}
+/**
+ * Decide which runtime, if any, `skrr daemon logs` may trust (OSK-15993).
+ *
+ * - No `logs` subcommand: the legacy fallback, as before.
+ * - A runtime at or above {@link LIVE_LOG_RESOLUTION_RUNTIME_VERSION}: forward.
+ * - An older runtime, or one whose version cannot be read: ask its `status`
+ *   which file the live daemon writes and read that file here. When status
+ *   cannot answer, an older runtime gets the legacy fallback (the newest of the
+ *   profile log and the installed service's logs); an unknown one is forwarded.
+ */
+async function planDaemonLogs(flags, deps) {
+    const legacy = (reason) => {
+        const chosen = chooseLegacyFallbackLog({
+            profilePath: deps.profilePath,
+            serviceCandidates: (flags.stderr
+                ? [deps.service?.stderrPath]
+                : [deps.service?.logFile, deps.service?.stdoutPath]).filter((p) => Boolean(p)),
+            mtimeOf: deps.mtimeOf,
+            reason,
+        });
+        return {
+            kind: 'read',
+            path: chosen.path,
+            note: chosen.note,
+            missingHint: 'The installed daemon predates `oversky logs`; start it or upgrade it, then retry.',
+        };
+    };
+    const supports = await deps.supportsLogs();
+    if (supports === false) {
+        return legacy('This daemon predates `logs`, so it cannot name its live log itself.');
+    }
+    // Help could not be read: nothing to go on, keep the old behaviour.
+    if (supports === null)
+        return { kind: 'forward' };
+    const version = await deps.runtimeVersion();
+    const current = version
+        ? runtimeVersionAtLeast(version, exports.LIVE_LOG_RESOLUTION_RUNTIME_VERSION)
+        : null;
+    if (current === true)
+        return { kind: 'forward' };
+    const live = await deps.statusLogPath();
+    const predates = version !== null
+        ? `The installed runtime (${version}) predates \`logs\` following the live daemon's ` +
+            `--log-file (${exports.LIVE_LOG_RESOLUTION_RUNTIME_VERSION}), so it would read ${deps.profilePath}.`
+        : `The installed runtime did not report its version, so its \`logs\` may read ` +
+            `${deps.profilePath} instead of the live log.`;
+    if (!live) {
+        if (current === null)
+            return { kind: 'forward' };
+        return legacy(`${predates} Its \`status\` did not name the live log either.`);
+    }
+    // The live daemon writes the profile log itself: the runtime's answer is right.
+    if (sameLogFile(live, node_path_1.default.join(node_path_1.default.dirname(deps.profilePath), 'daemon.log'))) {
+        return { kind: 'forward' };
+    }
+    const missingHint = 'The live daemon has not written it yet; `skrr daemon status` shows whether one is running.';
+    if (!flags.stderr) {
+        return {
+            kind: 'read',
+            path: live,
+            note: `Showing ${live}, the live daemon's log as \`skrrd status\` reports it. ${predates}`,
+            missingHint,
+        };
+    }
+    // --stderr: trust the installed definition's redirect only when it is the
+    // one that launched this daemon (its --log-file is the live one) — the same
+    // rule the runtime's own resolution applies.
+    if (deps.service?.stderrPath && sameLogFile(deps.service.logFile, live)) {
+        return {
+            kind: 'read',
+            path: deps.service.stderrPath,
+            note: `Showing ${deps.service.stderrPath}, the live daemon's stderr as its service definition ` +
+                `redirects it; its full log, WARN and ERROR included, is ${live}. ${predates}`,
+            missingHint,
+        };
+    }
+    return {
+        kind: 'read',
+        path: live,
+        note: `Showing ${live}, the live daemon's log as \`skrrd status\` reports it; it carries every ` +
+            `WARN and ERROR line. ${predates}`,
+        missingHint,
+    };
 }
 /** Read a bounded trailing window, so an unrotated legacy err log is safe. */
 function readDaemonLogTail(filePath, maxLines) {
@@ -114,7 +382,7 @@ function readDaemonLogTail(filePath, maxLines) {
  * `completeTaskDurably`. Every flag declared on the command must appear here,
  * or it parses successfully and is then silently dropped.
  */
-function buildOverskyLogsArgs(flags) {
+function buildDaemonLogsArgs(flags) {
     return [
         // The runtime's own global option, placed before the subcommand.
         ...(flags.profile ? ['--profile', flags.profile] : []),
@@ -174,33 +442,57 @@ class DaemonLogs extends core_1.Command {
     ];
     async run() {
         const { flags } = await this.parse(DaemonLogs);
-        const args = buildOverskyLogsArgs(flags);
-        // Before ANY log content, on stderr so it never pollutes a pipe. `--path`
-        // is exempt: its whole contract is one path on stdout.
-        if (!flags.path) {
+        const args = buildDaemonLogsArgs(flags);
+        const showAge = (filePath) => {
+            // Before ANY log content, on stderr so it never pollutes a pipe. `--path`
+            // is exempt: its whole contract is one path on stdout.
+            if (flags.path || !filePath)
+                return;
             try {
-                const candidate = resolveLegacyDaemonLogPath(flags);
-                if ((0, node_fs_1.existsSync)(candidate)) {
-                    const { line } = describeLogAge((0, node_fs_1.statSync)(candidate).mtimeMs);
-                    this.logToStderr(line);
+                if ((0, node_fs_1.existsSync)(filePath)) {
+                    this.logToStderr(`${filePath}: ${describeLogAge((0, node_fs_1.statSync)(filePath).mtimeMs).line}`);
                 }
             }
             catch {
                 // Never let the banner stop the logs from being shown.
             }
-        }
+        };
         try {
             // `oversky 0.2.x` has profiles and writes the same files, but has no
             // `logs` subcommand. Probe top-level help first so forwarding does not
             // print an unrelated "unknown option" error before the useful output.
-            if ((await (0, exec_runtime_binary_1.runtimeBinarySupportsSubcommand)('logs')) === false) {
-                const logPath = resolveLegacyDaemonLogPath(flags);
+            //
+            // OSK-15993: a runtime that HAS `logs` is not necessarily one to trust
+            // with it — 0.8.112–0.8.118 read the profile log even when the live
+            // daemon writes elsewhere. `planDaemonLogs` forwards only to a runtime
+            // that resolves the live log itself.
+            const plan = await planDaemonLogs(flags, {
+                supportsLogs: () => (0, exec_runtime_binary_1.runtimeBinarySupportsSubcommand)('logs'),
+                runtimeVersion: () => probeRuntimeVersion(),
+                statusLogPath: () => probeStatusLogPath(flags),
+                profilePath: resolveLegacyDaemonLogPath(flags),
+                service: installedServiceLogDestinations(resolveDaemonLogsProfile(flags)),
+                mtimeOf: (filePath) => {
+                    try {
+                        return (0, node_fs_1.statSync)(filePath).mtimeMs;
+                    }
+                    catch {
+                        return null;
+                    }
+                },
+            });
+            if (plan.kind === 'read') {
+                const logPath = plan.path;
+                // `--path` prints the one path and nothing else, on either stream.
                 if (flags.path) {
                     this.log(logPath);
                     return;
                 }
+                if (plan.note)
+                    this.logToStderr(plan.note);
+                showAge(logPath);
                 if (!(0, node_fs_1.existsSync)(logPath)) {
-                    this.error(`No daemon log at ${logPath}. The installed daemon predates \`oversky logs\`; start it or upgrade it, then retry.`, { exit: 1 });
+                    this.error(`No daemon log at ${logPath}. ${plan.missingHint}`, { exit: 1 });
                 }
                 const lines = readDaemonLogTail(logPath, flags.lines ?? 200);
                 if (lines.length > 0)
@@ -234,6 +526,10 @@ class DaemonLogs extends core_1.Command {
                 }
                 return;
             }
+            // The banner must describe the file the runtime will actually print —
+            // the live daemon's log (OSK-15993) — not the profile default.
+            if (!flags.path)
+                showAge(await resolveForwardedLogPath(flags));
             const code = await (0, exec_runtime_binary_1.execRuntimeBinary)(args);
             this.exit(code);
         }

package/dist/commands/followups/checkin.js

@@ -99,18 +99,32 @@ class FollowupsCheckin extends base_command_1.BaseCommand {
             this.handleApiError(err);
             return;
         }
+        const producer = agent.boundToSession ? 'agent_in_turn' : 'user_explicit';
+        // An explicit request from a person that arms nothing is a refusal, and a script reading the
+        // exit code must see it as one (OSK-15413). A check-in the AGENT chose to make is different:
+        // there, staying quiet when the budget is spent is the designed outcome.
+        if (response.dropped && producer === 'user_explicit') {
+            this.failWithCliError({
+                message: budgetRefusalMessage(agent.id, response.budget),
+                code: 'FOLLOWUP_BUDGET_EXHAUSTED',
+                exit: 1,
+                retryable: false,
+                details: { budget: response.budget ?? null, response },
+            });
+            return;
+        }
         if (flags.json) {
             this.log(JSON.stringify(response, null, 2));
             return;
         }
         const row = response.followup;
         if (response.reused) {
-            this.log(`Already armed: ${row?.id} — one pending check-in per conversation, and this is it.`);
+            this.log(reusedMessage(row, subject, flags.why));
             return;
         }
         if (response.dropped) {
-            // silent_drop is the check-in budget's contract: the answer to "one
-            // greeting too many" is quiet, not an error the caller can retry.
+            // silent_drop is the check-in budget's contract for an agent's own check-in: the answer to
+            // "one greeting too many" is quiet, not an error the caller can retry.
             this.log('Dropped by the daily check-in budget — staying quiet is the correct outcome.');
             return;
         }
@@ -118,3 +132,32 @@ class FollowupsCheckin extends base_command_1.BaseCommand {
     }
 }
 exports.default = FollowupsCheckin;
+/**
+ * What a reused answer means for the person who asked: a second check-in on a subject that already
+ * has one arms nothing and changes nothing, so the note and time they typed were NOT applied. Say
+ * so, show what is armed, and name the two ways forward (OSK-15411). Exit stays 0: the follow-up
+ * they wanted to exist does exist.
+ */
+function reusedMessage(row, subject, requestedWhy) {
+    const lines = [
+        `Already armed: ${row?.id} — one pending check-in per subject (${subject.type}:${subject.externalKey}), and this is it.`,
+        'Nothing in this request was applied: it armed no new check-in and changed neither the note nor the time.',
+    ];
+    if (row) {
+        const sameNote = row.why === requestedWhy;
+        lines.push(`Armed: ${row.why ? `"${row.why}"` : '(no note)'}, next ${row.nextRunAt ?? 'when its schedule says'}${sameNote ? ' (the same note you gave)' : ''}.`);
+    }
+    lines.push(`To change the time: skrr followups reschedule ${row?.id ?? '<id>'} --at <instant> or --in <offset>.`, "To change the note: cancel it and create it again (a cancelled check-in still counts against today's check-in budget).");
+    return lines.join('\n');
+}
+/** The refusal for an explicit check-in the daily budget will not take, with the number and the way to raise it. */
+function budgetRefusalMessage(agentId, budget) {
+    const { used, limit } = (budget && typeof budget === 'object' ? budget : {});
+    const spent = typeof used === 'number' && typeof limit === 'number'
+        ? `${agentId} has used ${used} of its ${limit} check-ins today`
+        : `${agentId} has used its daily check-in budget`;
+    return [
+        `No check-in was armed: ${spent}. The day resets at 00:00 UTC, and a cancelled check-in still counts.`,
+        `Raise the limit with: skrr agents triggers policy ${agentId} --followup-budget checkin=<count>`,
+    ].join(' ');
+}

package/dist/commands/tasks/approvals/resolve.d.ts

@@ -1,4 +1,16 @@
+import { type TaskApprovalResolveParams } from '@skrr-ai/data-provider';
 import { BaseCommand } from '../../../base-command';
+/**
+ * The request body for resolving an approval. The server's field is `comment`
+ * (`TaskApprovalResolveParams`); `--reason` is only the flag's name. It was sent
+ * as `reason` through an `as unknown as` cast, so the type checker could not see
+ * the mismatch and the server's non-strict schema dropped the key: the command
+ * succeeded and the reason was stored nowhere (OSK-15362).
+ */
+export declare function approvalResolutionBody(flags: {
+    status: 'approved' | 'rejected';
+    reason?: string;
+}): TaskApprovalResolveParams;
 export default class TasksApprovalsResolve extends BaseCommand {
     static description: string;
     static examples: string[];

package/dist/commands/tasks/approvals/resolve.js

@@ -1,8 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.approvalResolutionBody = approvalResolutionBody;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
+/**
+ * The request body for resolving an approval. The server's field is `comment`
+ * (`TaskApprovalResolveParams`); `--reason` is only the flag's name. It was sent
+ * as `reason` through an `as unknown as` cast, so the type checker could not see
+ * the mismatch and the server's non-strict schema dropped the key: the command
+ * succeeded and the reason was stored nowhere (OSK-15362).
+ */
+function approvalResolutionBody(flags) {
+    const body = { status: flags.status };
+    if (flags.reason)
+        body.comment = flags.reason;
+    return body;
+}
 class TasksApprovalsResolve extends base_command_1.BaseCommand {
     static description = 'Resolve (approve or reject) a task approval';
     static examples = [
@@ -27,15 +41,15 @@ class TasksApprovalsResolve extends base_command_1.BaseCommand {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksApprovalsResolve);
         const taskRef = await this.resolveEntityRef('task', args.id);
-        const data = { status: flags.status };
-        if (flags.reason)
-            data.reason = flags.reason;
         let result;
         try {
             result = await data_provider_1.dataService.resolveTaskApproval({
                 taskId: taskRef,
                 approvalId: args.approvalId,
-                data: data,
+                data: approvalResolutionBody({
+                    status: flags.status,
+                    reason: flags.reason,
+                }),
             });
         }
         catch (err) {
@@ -46,7 +60,9 @@ class TasksApprovalsResolve extends base_command_1.BaseCommand {
             return;
         }
         const a = result;
-        this.log(`Approval ${a.id ?? a._id ?? args.approvalId} → ${flags.status}`);
+        // Say what was recorded, so a reason that was not stored cannot pass unseen.
+        const recorded = typeof a.comment === 'string' && a.comment ? ` (reason: ${a.comment})` : '';
+        this.log(`Approval ${a.id ?? a._id ?? args.approvalId} → ${flags.status}${recorded}`);
     }
 }
 exports.default = TasksApprovalsResolve;

package/dist/commands/triggers/create.js

@@ -91,7 +91,9 @@ class TriggersCreate extends base_command_1.BaseCommand {
             multiple: true,
         }),
         timezone: core_1.Flags.string({ description: 'IANA timezone for schedule triggers' }),
-        'max-fires-per-day': core_1.Flags.integer({ description: 'Daily fire cap' }),
+        'max-fires-per-day': core_1.Flags.integer({
+            description: 'Daily fire cap (schedule, stochastic and self_scheduled triggers only)',
+        }),
         'max-runs': core_1.Flags.integer({ description: 'Lifetime fire cap for schedule triggers' }),
         'end-at': core_1.Flags.string({
             description: 'ISO-8601 datetime after which a schedule stops firing',
@@ -192,6 +194,9 @@ class TriggersCreate extends base_command_1.BaseCommand {
         let payload;
         try {
             payload = await (0, prompt_1.readJsonBody)(flags['from-json']);
+            // A flag for a kind other than --kind is refused, not dropped: the block it fills is not
+            // sent, so the caller would believe a limit was set that nothing holds (OSK-15491).
+            (0, triggers_1.assertKindFlagsApply)(flags.kind ?? payload.kind, flags);
             const refs = (0, triggers_1.parseKeyValueFlags)(flags.ref, '--ref', flags.scope ?? payload.scope?.kind);
             if (flags.scope || Object.keys(refs).length > 0) {
                 payload.scope = {
@@ -267,22 +272,8 @@ class TriggersCreate extends base_command_1.BaseCommand {
                 filterField: flags['filter-field'],
                 filterValues,
             });
-            (0, triggers_1.setDefined)(event, {
-                entityType: flags.entity,
-                eventType: flags.event,
-                filterMode: flags['filter-mode'],
-                filterField: flags['filter-field'],
-                filterValue: filterValues && filterValues.length > 1 ? filterValues : filterValues?.[0],
-                debounceMs: flags['debounce-ms'],
-                maxPerHour: flags['max-per-hour'],
-            });
-            const stochastic = {};
-            (0, triggers_1.setDefined)(stochastic, {
-                probability: flags.probability === undefined ? undefined : Number(flags.probability),
-                jitterMs: flags['jitter-ms'],
-                maxFiresPerDay: flags['max-fires-per-day'],
-                evalIntervalMinutes: flags['eval-interval-minutes'],
-            });
+            Object.assign(event, (0, triggers_1.buildEventConfigFromFlags)(flags, filterValues));
+            const stochastic = (0, triggers_1.buildStochasticConfigFromFlags)(flags);
             const selfScheduled = (0, triggers_1.buildSelfScheduledConfigFromFlags)(flags);
             const form = (0, triggers_1.buildFormConfigFromFlags)(flags);
             const chatMessage = (0, triggers_1.buildChatMessageConfigFromFlags)(flags);

package/dist/commands/triggers/fire.js

@@ -41,6 +41,9 @@ class TriggersFire extends base_command_1.BaseCommand {
             return;
         }
         this.log(`Fire requested: outcome=${String(result.outcome ?? '-')} reason=${String(result.reason ?? '-')}`);
+        const note = (0, triggers_1.describeScheduledFire)(result);
+        if (note)
+            this.log(note);
     }
 }
 exports.default = TriggersFire;