@skrr-ai/cli 0.1.105 → 0.1.106

package/dist/commands/daemon/logs.d.ts

@@ -124,6 +124,13 @@ export declare const LIVE_LOG_RESOLUTION_RUNTIME_VERSION = "0.8.119";
  * that file and its rotated siblings itself.
  */
 export declare const ROTATED_LOGS_RUNTIME_VERSION = "0.8.120";
+/**
+ * The first runtime whose `logs --rotated --lines N` says where a window that
+ * cut older lines starts, and whose `logs --path` names the rotated siblings
+ * on stderr (OSK-16228). 0.8.120 knows `--rotated` but says neither, so for it
+ * the CLI reads the files itself, exactly as it does for an older runtime.
+ */
+export declare const ROTATED_WINDOW_NOTE_RUNTIME_VERSION = "0.8.121";
 /**
  * Rotated siblings of a log, OLDEST FIRST (OSK-16214). The daemon's logger
  * renames `daemon.app.log` to `daemon.app.1.log`, `.1` to `.2` and so on at
@@ -146,6 +153,31 @@ export declare function readLastLines(filePath: string, maxLines: number): strin
  * file. A file renamed away between the listing and the read is skipped.
  */
 export declare function readLastLinesAcross(files: readonly string[], maxLines: number): string[];
+/**
+ * Where a `--rotated --lines N` window began when it left older lines out
+ * (OSK-16228). `startLine` is 1-based within `file`; `totalLines` counts the
+ * whole set. A copy of `daemon/src/rotated-log-files.ts`, like the helpers above.
+ */
+export interface LogWindowCut {
+    file: string;
+    startLine: number;
+    totalLines: number;
+}
+/** Lines in a file, split as `readLastLines` splits them; read in chunks. */
+export declare function countLines(filePath: string): number;
+/**
+ * `readLastLinesAcross`, plus where the window began when it cut older lines.
+ * Without it, `--rotated --lines 20000 | grep <id>` for an id 90k lines back
+ * printed nothing and said nothing, which reads as "never logged". Lines are
+ * counted only once the window is full, and only from the file it stopped in
+ * back.
+ */
+export declare function readLogWindow(files: readonly string[], maxLines: number): {
+    lines: string[];
+    cut: LogWindowCut | null;
+};
+/** The stderr sentence for a window that left older lines out. */
+export declare function describeLogWindowCut(cut: LogWindowCut, shown: number): string;
 /** Every byte of `files`, in order, to `out` — streamed, honouring back-pressure. */
 export declare function streamLogFiles(files: readonly string[], out: NodeJS.WritableStream): Promise<void>;
 /** `x.y.z` from a version string, or null. A prerelease suffix is ignored. */

package/dist/commands/daemon/logs.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STDERR_FLAG_DESCRIPTION = exports.ROTATED_LOGS_RUNTIME_VERSION = exports.LIVE_LOG_RESOLUTION_RUNTIME_VERSION = void 0;
+exports.STDERR_FLAG_DESCRIPTION = exports.ROTATED_WINDOW_NOTE_RUNTIME_VERSION = exports.ROTATED_LOGS_RUNTIME_VERSION = exports.LIVE_LOG_RESOLUTION_RUNTIME_VERSION = void 0;
 exports.describeLogAge = describeLogAge;
 exports.resolveLegacyDaemonLogPath = resolveLegacyDaemonLogPath;
 exports.resolveDaemonLogsProfile = resolveDaemonLogsProfile;
@@ -15,6 +15,9 @@ exports.rotatedLogSiblings = rotatedLogSiblings;
 exports.describeRotatedSiblings = describeRotatedSiblings;
 exports.readLastLines = readLastLines;
 exports.readLastLinesAcross = readLastLinesAcross;
+exports.countLines = countLines;
+exports.readLogWindow = readLogWindow;
+exports.describeLogWindowCut = describeLogWindowCut;
 exports.streamLogFiles = streamLogFiles;
 exports.parseRuntimeVersion = parseRuntimeVersion;
 exports.runtimeVersionAtLeast = runtimeVersionAtLeast;
@@ -228,6 +231,13 @@ exports.LIVE_LOG_RESOLUTION_RUNTIME_VERSION = '0.8.119';
  * that file and its rotated siblings itself.
  */
 exports.ROTATED_LOGS_RUNTIME_VERSION = '0.8.120';
+/**
+ * The first runtime whose `logs --rotated --lines N` says where a window that
+ * cut older lines starts, and whose `logs --path` names the rotated siblings
+ * on stderr (OSK-16228). 0.8.120 knows `--rotated` but says neither, so for it
+ * the CLI reads the files itself, exactly as it does for an older runtime.
+ */
+exports.ROTATED_WINDOW_NOTE_RUNTIME_VERSION = '0.8.121';
 /**
  * Rotated siblings of a log, OLDEST FIRST (OSK-16214). The daemon's logger
  * renames `daemon.app.log` to `daemon.app.1.log`, `.1` to `.2` and so on at
@@ -304,19 +314,90 @@ function readLastLines(filePath, maxLines) {
  * file. A file renamed away between the listing and the read is skipped.
  */
 function readLastLinesAcross(files, maxLines) {
+    return readLogWindow(files, maxLines).lines;
+}
+/** Lines in a file, split as `readLastLines` splits them; read in chunks. */
+function countLines(filePath) {
+    const descriptor = (0, node_fs_1.openSync)(filePath, 'r');
+    try {
+        const buffer = Buffer.alloc(64 * 1024);
+        let count = 0;
+        let last = -1;
+        let position = 0;
+        for (;;) {
+            const read = (0, node_fs_1.readSync)(descriptor, buffer, 0, buffer.length, position);
+            if (read === 0)
+                break;
+            position += read;
+            for (let i = 0; i < read; i += 1)
+                if (buffer[i] === 0x0a)
+                    count += 1;
+            last = buffer[read - 1];
+        }
+        return last === -1 || last === 0x0a ? count : count + 1;
+    }
+    finally {
+        (0, node_fs_1.closeSync)(descriptor);
+    }
+}
+/**
+ * `readLastLinesAcross`, plus where the window began when it cut older lines.
+ * Without it, `--rotated --lines 20000 | grep <id>` for an id 90k lines back
+ * printed nothing and said nothing, which reads as "never logged". Lines are
+ * counted only once the window is full, and only from the file it stopped in
+ * back.
+ */
+function readLogWindow(files, maxLines) {
     const collected = [];
     let remaining = maxLines;
+    let boundary = null;
     for (let i = files.length - 1; i >= 0 && remaining > 0; i -= 1) {
         try {
             const lines = readLastLines(files[i], remaining);
             collected.unshift(lines);
             remaining -= lines.length;
+            if (remaining <= 0)
+                boundary = { index: i, taken: lines.length };
         }
         catch {
             // Rotated away mid-read; the rest are still worth showing.
         }
     }
-    return collected.flat();
+    const lines = collected.flat();
+    if (boundary === null)
+        return { lines, cut: null };
+    let boundaryLines;
+    try {
+        boundaryLines = countLines(files[boundary.index]);
+    }
+    catch {
+        return { lines, cut: null };
+    }
+    let olderLines = 0;
+    for (const file of files.slice(0, boundary.index)) {
+        try {
+            olderLines += countLines(file);
+        }
+        catch {
+            // Rotated away since the read; it is not in the window either way.
+        }
+    }
+    const startLine = Math.max(1, boundaryLines - boundary.taken + 1);
+    if (startLine === 1 && olderLines === 0)
+        return { lines, cut: null };
+    return {
+        lines,
+        cut: {
+            file: files[boundary.index],
+            startLine,
+            totalLines: olderLines + (startLine - 1) + lines.length,
+        },
+    };
+}
+/** The stderr sentence for a window that left older lines out. */
+function describeLogWindowCut(cut, shown) {
+    return (`Showing the last ${shown} of ${cut.totalLines} lines; the window starts at line ` +
+        `${cut.startLine} of ${node_path_1.default.basename(cut.file)}. Drop --lines to read the full history.`);
 }
 /** Every byte of `files`, in order, to `out` — streamed, honouring back-pressure. */
 async function streamLogFiles(files, out) {
@@ -623,30 +704,46 @@ class DaemonLogs extends core_1.Command {
             const runtimeKnowsRotated = plan.kind === 'forward' &&
                 plan.runtimeVersion !== null &&
                 runtimeVersionAtLeast(plan.runtimeVersion, exports.ROTATED_LOGS_RUNTIME_VERSION) === true;
-            if (plan.kind === 'forward' && flags.rotated && !runtimeKnowsRotated) {
+            // OSK-16228: a `--rotated --lines N` window that cuts older lines, and
+            // `--path` with rotated siblings beside it, are said on stderr only from
+            // ROTATED_WINDOW_NOTE_RUNTIME_VERSION. Below it, read the files here.
+            const runtimeSaysWindow = plan.kind === 'forward' &&
+                plan.runtimeVersion !== null &&
+                runtimeVersionAtLeast(plan.runtimeVersion, exports.ROTATED_WINDOW_NOTE_RUNTIME_VERSION) === true;
+            if (plan.kind === 'forward' && !runtimeSaysWindow && (flags.rotated || flags.path)) {
                 const resolved = await resolveForwardedLogPath(flags);
-                if (!resolved) {
+                if (resolved) {
+                    plan = {
+                        kind: 'read',
+                        path: resolved,
+                        note: null,
+                        missingHint: 'The live daemon has not written it yet; `skrr daemon status` shows whether one is running.',
+                    };
+                }
+                else if (flags.rotated && !runtimeKnowsRotated) {
                     this.error(`The installed runtime${plan.runtimeVersion ? ` (${plan.runtimeVersion})` : ''} predates ` +
                         `--rotated (${exports.ROTATED_LOGS_RUNTIME_VERSION}) and did not name its log file, so its ` +
                         'rotated files cannot be found. Upgrade it (`skrr daemon update`), or list the ' +
                         'directory `skrr daemon logs --path` prints.', { exit: 1 });
                 }
-                plan = {
-                    kind: 'read',
-                    path: resolved,
-                    note: null,
-                    missingHint: 'The live daemon has not written it yet; `skrr daemon status` shows whether one is running.',
-                };
+                // Otherwise forward: the runtime still answers, just without the note.
             }
             if (plan.kind === 'read') {
                 const logPath = plan.path;
                 const siblings = rotatedLogSiblings(logPath);
-                // `--path` prints the one path and nothing else, on either stream —
-                // under --rotated, every file oldest first, the current one last.
+                // `--path` prints the one path and nothing else on stdout — under
+                // --rotated, every file oldest first, the current one last. Without
+                // --rotated, stderr names the siblings a grep of that path would miss
+                // (OSK-16228).
                 if (flags.path) {
                     for (const file of flags.rotated ? siblings : [])
                         this.log(file);
                     this.log(logPath);
+                    if (!flags.rotated) {
+                        const hint = describeRotatedSiblings(logPath, siblings);
+                        if (hint)
+                            this.logToStderr(hint);
+                    }
                     return;
                 }
                 if (plan.note)
@@ -668,11 +765,16 @@ class DaemonLogs extends core_1.Command {
                     await streamLogFiles([...siblings, logPath], process.stdout);
                 }
                 else {
-                    const lines = flags.rotated
-                        ? readLastLinesAcross([...siblings, logPath], flags.lines ?? 200)
-                        : readDaemonLogTail(logPath, flags.lines ?? 200);
+                    const window = flags.rotated
+                        ? readLogWindow([...siblings, logPath], flags.lines ?? 200)
+                        : null;
+                    const lines = window ? window.lines : readDaemonLogTail(logPath, flags.lines ?? 200);
                     if (lines.length > 0)
                         this.log(lines.join('\n'));
+                    // OSK-16228: after the content, so it is the last thing a terminal
+                    // shows, and on stderr, so a grep over stdout is unchanged.
+                    if (window?.cut)
+                        this.logToStderr(describeLogWindowCut(window.cut, lines.length));
                 }
                 if (flags.follow) {
                     let position = (0, node_fs_1.statSync)(logPath).size;

package/dist/commands/tasks/retry-schedule.js

@@ -40,7 +40,17 @@ class TasksRetrySchedule extends base_command_1.BaseCommand {
         const t = result;
         const ref = t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '');
         const when = flags.at ?? t.scheduledFor ?? '(server default)';
-        this.log(`Re-armed schedule for task ${t.id ?? t._id ?? taskRef}${ref ? ` (${ref})` : ''} → ${when}`);
+        const retry = t.scheduleRetry;
+        const subject = `task ${t.id ?? t._id ?? taskRef}${ref ? ` (${ref})` : ''}`;
+        if (retry?.changed === false) {
+            this.log(`Schedule for ${subject} is already armed for ${when}; nothing changed.`);
+        }
+        else if (retry?.armedFirstSchedule) {
+            this.log(`Armed a first schedule for ${subject} → ${when} (it had none; \`tasks schedule\` is the command for that).`);
+        }
+        else {
+            this.log(`Re-armed schedule for ${subject} → ${when}`);
+        }
     }
 }
 exports.default = TasksRetrySchedule;

package/oclif.manifest.json

@@ -132497,5 +132497,5 @@
       ]
     }
   },
-  "version": "0.1.105"
+  "version": "0.1.106"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skrr-ai/cli",
-  "version": "0.1.105",
+  "version": "0.1.106",
   "description": "Command-line interface for skrr",
   "license": "ISC",
   "author": "skrr",