start-command 0.39.2 → 0.40.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # start-command
 
+## 0.40.0
+
+### Minor Changes
+
+- 47a9dd8: Upgrade every dependency to its latest release, and let CI reject pull requests that fall behind (#253).
+
+  - **Upgrades:** `@link-foundation/sensitive-data-sanitizer` 0.12.2, `command-stream` 2.6.0, `lino-objects-codec` 0.9.3, the lint tools, the GitHub Actions, the runners (`ubuntu-26.04`, `macos-26`) and the .NET 10 SDK that clink 4.x needs.
+  - **Store format:** the execution store is now written in lino-objects-codec 0.9's readable format. Stores written by older releases are still read, but older releases of start cannot read a store written by this one.
+  - **Links database:** the store had stayed empty, because clink 4.x rejected every query it sent. It now writes one record-scoped link per property and verifies the writes. The existing `recordToLinksNotation()` helper remains available with the corrected format.
+  - **`--use-command-stream`:** command output is appended to the log again. command-stream 2.x returns it as snapshots.
+  - **Sanitizer:** start's own `Authorization` masking pass is gone, because the sanitizer now masks only the scheme and token itself. A NUL byte in a log no longer blocks the upload (`--allow-binary`).
+  - **Dependency fixes:** preserve Authorization placeholders, bracketed tokens and following control bytes; avoid quadratic scanning of dense credentials. Load command-stream's lightweight `core` entry for command execution.
+  - **CI:** `scripts/check-dependency-freshness.mjs` fails a pull request when any npm package, crate, action, CI tool, runtime, runner or translator pin is not its latest release. The one exception is a version that links an open blocking issue.
+
 ## 0.39.2
 
 ### Patch Changes

package/eslint.config.mjs

@@ -80,6 +80,7 @@ export default [
         // Web-standard globals Node exposes; used by the repository-level
         // scripts/ directory, which the root config lints (issue #168).
         AbortController: 'readonly',
+        AbortSignal: 'readonly',
         URL: 'readonly',
         setTimeout: 'readonly',
         clearTimeout: 'readonly',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.39.2",
+  "version": "0.40.0",
   "description": "Gamification of coding, execute any command with ability to auto-report issues on GitHub",
   "main": "src/bin/cli.js",
   "exports": {
@@ -49,12 +49,12 @@
   "devDependencies": {
     "@changesets/cli": "^3.0.3",
     "@eslint/js": "^10.0.1",
-    "eslint": "^10.3.0",
+    "eslint": "^10.13.0",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-prettier": "^5.5.7",
     "husky": "^9.1.7",
-    "lint-staged": "^17.0.4",
-    "prettier": "^3.8.3"
+    "lint-staged": "^17.6.0",
+    "prettier": "^3.9.10"
   },
   "lint-staged": {
     "*.{js,mjs,cjs}": [
@@ -68,13 +68,12 @@
     ]
   },
   "dependencies": {
-    "@link-foundation/sensitive-data-sanitizer": "^0.12.0",
-    "command-stream": "^0.9.4",
-    "lino-objects-codec": "^0.4.0"
+    "@link-foundation/sensitive-data-sanitizer": "^0.12.2",
+    "command-stream": "^2.6.0",
+    "lino-objects-codec": "^0.9.3"
   },
   "overrides": {
     "brace-expansion": "^5.0.12",
-    "flatted": "^3.4.2",
-    "js-yaml": "^4.3.2"
+    "flatted": "^3.4.4"
   }
 }

package/src/bin/cli.js

@@ -814,7 +814,7 @@ async function runDirectWithCommandStream(
   sessionId
 ) {
   // Lazy load command-stream
-  const { getCommandStream } = require('../lib/command-stream');
+  const { getCommandStream, outputText } = require('../lib/command-stream');
   const { $, raw } = await getCommandStream();
 
   // Get the command name (first word of the actual command to execute)
@@ -921,11 +921,13 @@ async function runDirectWithCommandStream(
     }
 
     // Collect output for log
-    if (result.stdout) {
-      appendLogFile(logFilePath, result.stdout);
+    const stdout = outputText(result.stdout);
+    const stderr = outputText(result.stderr);
+    if (stdout) {
+      appendLogFile(logFilePath, stdout);
     }
-    if (result.stderr) {
-      appendLogFile(logFilePath, result.stderr);
+    if (stderr) {
+      appendLogFile(logFilePath, stderr);
     }
   } catch (err) {
     exitCode = err.code || 1;

package/src/lib/command-stream.js

@@ -26,11 +26,24 @@ let commandStream = null;
  */
 async function getCommandStream() {
   if (!commandStream) {
-    commandStream = await import('command-stream');
+    // Execution needs no compatibility layers, terminal renderers or REPL.
+    commandStream = await import('command-stream/core');
   }
   return commandStream;
 }
 
+/**
+ * Text of a completed command's stdout or stderr. Since command-stream 2.x
+ * these are readable stream snapshots rather than strings, and an empty one
+ * is still truthy (#253).
+ *
+ * @param {unknown} output - result.stdout or result.stderr
+ * @returns {string}
+ */
+function outputText(output) {
+  return output === undefined || output === null ? '' : String(output);
+}
+
 /**
  * Execute a shell command synchronously and return the result
  * Uses command-stream's $ function with .sync() for blocking execution.
@@ -54,8 +67,8 @@ async function execCommand(command, options = {}) {
     const result = $cmd`${command}`.sync();
 
     return {
-      stdout: (result.stdout || '').trim(),
-      stderr: (result.stderr || '').trim(),
+      stdout: outputText(result.stdout).trim(),
+      stderr: outputText(result.stderr).trim(),
       code: resolveChildExitCode(result.code),
     };
   } catch (err) {
@@ -91,8 +104,8 @@ async function execCommandAsync(command, options = {}) {
     const result = await $cmd`${command}`;
 
     return {
-      stdout: (result.stdout || '').trim(),
-      stderr: (result.stderr || '').trim(),
+      stdout: outputText(result.stdout).trim(),
+      stderr: outputText(result.stderr).trim(),
       code: resolveChildExitCode(result.code),
     };
   } catch (err) {
@@ -250,6 +263,7 @@ async function runWithHandlers(command, handlers = {}, options = {}) {
 
 module.exports = {
   getCommandStream,
+  outputText,
   execCommand,
   execCommandAsync,
   commandExists,

package/src/lib/execution-chain.js

@@ -21,7 +21,7 @@ const { executionAliases, hasUserNames } = require('./execution-identity');
 function buildChain(records, record) {
   const seen = new Set([record.uuid]);
   const chain = [record];
-  for (let cur = record; cur.continues; ) {
+  for (let cur = record; cur.continues;) {
     const prev = records.find((r) => r.uuid === cur.continues);
     if (!prev || seen.has(prev.uuid)) {
       break;
@@ -30,7 +30,7 @@ function buildChain(records, record) {
     chain.unshift(prev);
     cur = prev;
   }
-  for (let cur = record; ; ) {
+  for (let cur = record; ;) {
     const next = records
       .filter((r) => r.continues === cur.uuid && !seen.has(r.uuid))
       .sort((a, b) => Date.parse(b.startTime) - Date.parse(a.startTime))[0];

package/src/lib/execution-store.js

@@ -245,6 +245,16 @@ class ExecutionRecord {
   }
 }
 
+/**
+ * Quote text as a clink reference: `"..."` with inner quotes doubled.
+ * clink 4.x rejects backslash escapes inside references.
+ * @param {string} text
+ * @returns {string}
+ */
+function clinkReference(text) {
+  return `"${text.replaceAll('"', '""')}"`;
+}
+
 /**
  * Check if clink is installed
  * @returns {boolean}
@@ -343,70 +353,69 @@ class ExecutionStore {
   }
 
   /**
-   * Convert execution record to clink links notation format
-   * Uses string aliases for readable IDs
+   * Convert a record's properties to clink links notation.
+   *
+   * The record is one link `(uuid: ExecutionRecord uuid)` plus one link per
+   * property, `(uuid.key: uuid "key=value")`. Property links have the record
+   * as their source, so two records that share a value (both `executing`) are
+   * still distinct links: doublets are deduplicated by (source, target), and a
+   * shared `(status executing)` link would carry only one record's name. The
+   * `key=` prefix keeps the target from being a bare number, which clink 4.x
+   * reads as a link address even when quoted (issue #253).
    * @param {ExecutionRecord} record
    * @returns {string}
    */
   recordToLinksNotation(record) {
-    // Using clink's string alias feature for readable identifiers
-    // Format: (uuid: uuid-value) (pid: pid-value) etc.
     const obj = record.toObject();
-    const parts = [];
+    const links = [];
 
     for (const [key, value] of Object.entries(obj)) {
       if (value !== null && value !== undefined) {
-        // Escape value properly for links notation
-        const escapedValue =
+        const text =
           typeof value === 'object' ? JSON.stringify(value) : String(value);
-        parts.push(`(${record.uuid}.${key}: ${key} "${escapedValue}")`);
+        links.push(
+          `(${record.uuid}.${key}: ${record.uuid} ${clinkReference(`${key}=${text}`)})`
+        );
       }
     }
 
-    return parts.join(' ');
+    return links.join(' ');
+  }
+
+  /** Build the create query using the same property notation as the public helper. */
+  buildClinkCreateQuery(record) {
+    return `() ((${record.uuid}: ExecutionRecord ${record.uuid}) ${this.recordToLinksNotation(record)})`;
   }
 
   /**
-   * Build clink query for creating/updating a record
-   * @param {ExecutionRecord} record
+   * Build clink query deleting every property link of a record
+   * @param {string} uuid
    * @returns {string}
    */
-  buildClinkCreateQuery(record) {
-    const obj = record.toObject();
-    const links = [];
-
-    // Create main record link
-    links.push(`(${record.uuid}: ExecutionRecord ${record.uuid})`);
-
-    // Create property links
-    for (const [key, value] of Object.entries(obj)) {
-      if (value !== null && value !== undefined) {
-        const escapedValue =
-          typeof value === 'object' ? JSON.stringify(value) : String(value);
-        // Using format: (uuid.property: property "value")
-        links.push(`(${record.uuid}.${key}: ${key} "${escapedValue}")`);
-      }
-    }
-
-    // Format: () ((links)) - creates new links
-    return `() ((${links.join(') (')}))`;
+  buildClinkDeletePropertiesQuery(uuid) {
+    return `(($id: ${uuid} $value)) ()`;
   }
 
   /**
    * Execute clink command
    * @param {string} query
+   * @param {string[]} [extraArgs] - flags appended after `--db <path>`
    * @returns {{success: boolean, output: string}}
    */
-  execClink(query) {
+  execClink(query, extraArgs = []) {
     try {
       // The query embeds record values verbatim; a shell string would let a
       // single quote in any of them break out of the argument
       // (CodeQL js/shell-command-constructed-from-input, issue #168).
-      const result = execFileSync('clink', [query, '--db', this.linksDbPath], {
-        encoding: 'utf8',
-        timeout: 10000,
-        stdio: ['pipe', 'pipe', 'pipe'],
-      });
+      const result = execFileSync(
+        'clink',
+        [query, '--db', this.linksDbPath, ...extraArgs],
+        {
+          encoding: 'utf8',
+          timeout: 10000,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        }
+      );
       return { success: true, output: result };
     } catch (err) {
       this.log(`Clink error: ${err.message}`);
@@ -417,15 +426,22 @@ class ExecutionStore {
   /**
    * Write a record to the links database using clink
    * @param {ExecutionRecord} record
+   * @param {{isNew?: boolean}} [options] - isNew skips dropping old links
    * @returns {boolean}
    */
-  writeLinksRecord(record) {
+  writeLinksRecord(record, { isNew = false } = {}) {
     if (!this.useLinks) {
       return false;
     }
 
-    const query = this.buildClinkCreateQuery(record);
-    const result = this.execClink(query);
+    // Replace, not merge: drop the previous property links first. clink
+    // reports an error when the record has no links yet, which is harmless.
+    if (!isNew) {
+      this.execClink(this.buildClinkDeletePropertiesQuery(record.uuid));
+    }
+    const result = this.execClink(this.buildClinkCreateQuery(record), [
+      '--auto-create-missing-references',
+    ]);
 
     if (result.success) {
       this.log(`Wrote record ${record.uuid} to links database`);
@@ -444,9 +460,8 @@ class ExecutionStore {
       return false;
     }
 
-    // Delete all links with this UUID prefix
-    const query = `(($id: ${uuid} $any)) ()`;
-    const result = this.execClink(query);
+    this.execClink(this.buildClinkDeletePropertiesQuery(uuid));
+    const result = this.execClink(`((${uuid}: ExecutionRecord ${uuid})) ()`);
     return result.success;
   }
 
@@ -492,7 +507,7 @@ class ExecutionStore {
 
       // Also write to links database if available
       if (this.useLinks) {
-        this.writeLinksRecord(record);
+        this.writeLinksRecord(record, { isNew: existingIndex < 0 });
       }
 
       return true;
@@ -810,8 +825,10 @@ class ExecutionStore {
 
     // Query links database for all ExecutionRecord links
     try {
+      // Without --changes clink prints nothing for a read-only match
       const queryResult = this.execClink(
-        `((($id: ExecutionRecord $uuid)) (($id: ExecutionRecord $uuid)))`
+        `((($id: ExecutionRecord $uuid)) (($id: ExecutionRecord $uuid)))`,
+        ['--changes']
       );
 
       if (queryResult.success) {
@@ -928,6 +945,7 @@ module.exports = {
   ExecutionStatus,
   LockManager,
   isClinkInstalled,
+  clinkReference,
   DEFAULT_APP_FOLDER,
   LINO_DB_FILE,
   LINKS_DB_FILE,

package/src/lib/log-sanitizer.js

@@ -8,11 +8,10 @@
  * local gh hosts.yml (--gh-config). It streams the log from stdin, keeps
  * invalid UTF-8 bytes and writes a new private file atomically (--output).
  *
- * One rule stays here: the library masks an unquoted or single-quoted
- * `Authorization: <scheme> <value>` to the end of the line, which drops the
- * rest of a logged one-line JSON prompt (issue #249). The pre-pass below masks
- * only the scheme and its token first; the library keeps values that already
- * start with [REDACTED]. Remove it with sensitive-data-sanitizer#45.
+ * Since 0.12.1 the library masks only the scheme and token of an
+ * `Authorization: <scheme> <value>` header, so a logged one-line JSON prompt
+ * keeps the rest of its line (issue #249, sensitive-data-sanitizer#45); the
+ * pre-pass that did this here is gone (issue #253).
  */
 
 const fs = require('fs');
@@ -27,89 +26,6 @@ const COMMAND = 'sensitive-data-sanitizer';
 const OVERRIDE = 'START_SENSITIVE_DATA_SANITIZER';
 const OPTIONS = ['--credentials-only', '--env-secrets', '--gh-config'];
 
-// The longest header and scheme prefix is 122 bytes.
-const HOLDBACK = 160;
-const HEADER =
-  /((?:Proxy-)?Authorization[ \t]{0,32}:[ \t]{0,32})(?:Bearer|Basic|Digest|token)[ \t]{1,32}/gi;
-// Shell expressions, placeholders and masked values are not credentials.
-const NOT_A_VALUE = '$<[{';
-
-function isValueByte(code) {
-  return (
-    code > 0x20 &&
-    code !== 0x22 &&
-    code !== 0x27 &&
-    code !== 0x2c &&
-    code !== 0x5c
-  );
-}
-
-function valueEnd(text, start) {
-  let end = start;
-  while (end < text.length && isValueByte(text.charCodeAt(end))) {
-    end++;
-  }
-  return end;
-}
-
-/**
- * Masks `Authorization: <scheme> <token>` as `Authorization: [REDACTED]`.
- * It works on bytes (latin1 maps each byte to one character), so invalid
- * UTF-8 passes through unchanged, and holds at most HOLDBACK pending bytes.
- */
-class AuthorizationHeaderMask {
-  constructor() {
-    this.pending = '';
-    this.inValue = false;
-    this.redactions = 0;
-  }
-
-  push(block, final = false) {
-    const text = this.pending + block.toString('latin1');
-    this.pending = '';
-    let output = '';
-    let offset = 0;
-    if (this.inValue) {
-      offset = valueEnd(text, 0);
-      if (offset === text.length && !final) {
-        return Buffer.alloc(0);
-      }
-      this.inValue = false;
-    }
-    HEADER.lastIndex = offset;
-    let match;
-    while ((match = HEADER.exec(text))) {
-      const valueStart = match.index + match[0].length;
-      if (valueStart === text.length && !final) {
-        output += text.slice(offset, match.index);
-        this.pending = text.slice(match.index);
-        return Buffer.from(output, 'latin1');
-      }
-      if (
-        valueStart === text.length ||
-        !isValueByte(text.charCodeAt(valueStart)) ||
-        NOT_A_VALUE.includes(text[valueStart])
-      ) {
-        continue;
-      }
-      output += text.slice(offset, match.index + match[1].length) + MARKER;
-      this.redactions++;
-      offset = valueEnd(text, valueStart);
-      if (offset === text.length && !final) {
-        this.inValue = true;
-        return Buffer.from(output, 'latin1');
-      }
-      HEADER.lastIndex = offset;
-    }
-    const safeEnd = final
-      ? text.length
-      : Math.max(offset, text.length - HOLDBACK);
-    output += text.slice(offset, safeEnd);
-    this.pending = text.slice(safeEnd);
-    return Buffer.from(output, 'latin1');
-  }
-}
-
 /** Value-free failure: `code` is a fixed ERR_* name, never log content. */
 class SanitizationError extends Error {
   constructor(code, subject = 'Log') {
@@ -195,10 +111,9 @@ function runSanitizer(args, options, subject) {
  * @returns {string}
  */
 function sanitizeText(text, options = {}) {
-  const input = new AuthorizationHeaderMask().push(Buffer.from(text), true);
   const result = runSanitizer(
     ['redact', '-', ...OPTIONS],
-    { ...options, input },
+    { ...options, input: text },
     'Text'
   );
   return result.stdout.toString();
@@ -230,46 +145,6 @@ function countMarkers(filePath) {
   }
 }
 
-function createPrivateFile(filePath) {
-  const descriptor = fs.openSync(filePath, 'wx', 0o600);
-  if (process.platform !== 'win32') {
-    fs.fchmodSync(descriptor, 0o600);
-  }
-  return descriptor;
-}
-
-function maskAuthorizationHeaders(sourcePath, stagePath) {
-  const source = fs.openSync(sourcePath, 'r');
-  let stage;
-  try {
-    if (!fs.fstatSync(source).isFile()) {
-      throw new SanitizationError('ERR_SOURCE');
-    }
-    stage = createPrivateFile(stagePath);
-    const mask = new AuthorizationHeaderMask();
-    const buffer = Buffer.alloc(BLOCK_SIZE);
-    let bytes = 0;
-    for (;;) {
-      const length = fs.readSync(source, buffer, 0, BLOCK_SIZE, null);
-      const output = mask.push(buffer.subarray(0, length), length === 0);
-      if (output.length) {
-        fs.writeSync(stage, output);
-      }
-      if (length === 0) {
-        break;
-      }
-      bytes += length;
-    }
-    fs.fsyncSync(stage);
-    return bytes;
-  } finally {
-    fs.closeSync(source);
-    if (stage !== undefined) {
-      fs.closeSync(stage);
-    }
-  }
-}
-
 /**
  * Create a private sanitized copy of a log. The source is never modified;
  * any failure removes the copy and throws a value-free SanitizationError.
@@ -288,19 +163,25 @@ function sanitizeLogToTemp(sourcePath, options = {}) {
     if (process.platform !== 'win32') {
       fs.chmodSync(directory, 0o700);
     }
-    const stagePath = path.join(directory, 'authorization-masked.log');
     const target = path.join(directory, 'execution.log');
     code = 'ERR_SOURCE';
-    const bytes = maskAuthorizationHeaders(sourcePath, stagePath);
-    code = 'ERR_PRIVATE_FILE';
-    const input = fs.openSync(stagePath, 'r');
+    const input = fs.openSync(sourcePath, 'r');
+    let bytes;
     try {
-      const size = Math.max(1, fs.fstatSync(input).size);
+      const source = fs.fstatSync(input);
+      if (!source.isFile()) {
+        throw new SanitizationError('ERR_SOURCE');
+      }
+      bytes = source.size;
+      const size = Math.max(1, bytes);
+      code = 'ERR_PRIVATE_FILE';
       runSanitizer(
         [
           'redact',
           '-',
           '--stream',
+          // A NUL byte in a terminal transcript must not block the upload.
+          '--allow-binary',
           ...OPTIONS,
           '--max-bytes',
           String(size),
@@ -326,7 +207,6 @@ function sanitizeLogToTemp(sourcePath, options = {}) {
         `Prepared private sanitized log: ${bytes} bytes scanned, ${Math.max(0, redactions)} redactions.`
       );
     }
-    fs.rmSync(stagePath, { force: true });
     return { path: target, cleanup };
   } catch (error) {
     cleanup();
@@ -341,7 +221,6 @@ function sanitizeLogToTemp(sourcePath, options = {}) {
 }
 
 module.exports = {
-  AuthorizationHeaderMask,
   BLOCK_SIZE,
   SanitizationError,
   resolveSanitizerCommand,

package/test/ci-workflow-invariants.js

@@ -504,6 +504,24 @@ describe('CI workflow invariants', () => {
     assert.match(lint.body, /cargo metadata --locked/);
   });
 
+  it('gates pull requests on every dependency being its latest release', () => {
+    // Obsolete dependencies, sensitive-data-sanitizer among them, stayed in
+    // use unnoticed (issue #253).
+    const jsJobs = parseJobs(readWorkflow('js.yml'));
+    const freshness = jsJobs.find((job) => job.name === 'dependency-freshness');
+    assert.ok(freshness, 'js.yml has no dependency-freshness job');
+    assert.match(
+      freshness.body,
+      /scripts\/check-dependency-freshness\.mjs --lockfiles\n/
+    );
+    const status = jsJobs.find((job) => job.name === 'pipeline-status');
+    assert.ok(parseNeeds(status.body).includes('dependency-freshness'));
+    const lint = parseJobs(readWorkflow('rust.yml')).find(
+      (job) => job.name === 'lint'
+    );
+    assert.match(lint.body, /cargo update --dry-run/);
+  });
+
   it('reports a failed Rust test as a failed test, not low coverage', () => {
     // Without pipefail a failing test reached the threshold check as an empty
     // value: "Coverage % is below the 50% threshold" (issue #234).

package/test/command-stream-log.js

@@ -0,0 +1,85 @@
+/**
+ * Issue #253: command-stream 2.x returns completed `stdout` and `stderr` as
+ * readable stream snapshots instead of strings. `--use-command-stream` must
+ * still write the command's output to its log file.
+ */
+const { describe, it, expect } = require('bun:test');
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { pathToFileURL } = require('url');
+
+const CLI = path.join(__dirname, '../src/bin/cli.js');
+
+describe('--use-command-stream log (#253)', () => {
+  it('loads execution without compatibility and terminal modules', () => {
+    const wrapper = pathToFileURL(
+      path.join(__dirname, '../src/lib/command-stream.js')
+    ).href;
+    const result = spawnSync(
+      'node',
+      [
+        '--input-type=module',
+        '-e',
+        `import { registerHooks } from 'node:module';
+         import assert from 'node:assert/strict';
+         const extras = [];
+         registerHooks({ load(url, context, next) {
+           if (/command-stream\\/src\\/(shelljs|terminal|rust-repl)/.test(url)) extras.push(url);
+           return next(url, context);
+         }});
+         const { default: wrapper } = await import(${JSON.stringify(wrapper)});
+         const core = await wrapper.getCommandStream();
+         assert.equal(typeof core.$, 'function');
+         assert.equal(typeof core.ProcessRunner, 'function');
+         assert.deepEqual(extras, []);`,
+      ],
+      { encoding: 'utf8', timeout: 30000 }
+    );
+    expect(result.error).toBeUndefined();
+    expect(result.stderr).toBe('');
+    expect(result.status).toBe(0);
+  });
+
+  it.skipIf(process.platform === 'win32')(
+    'writes stdout and stderr to the log file',
+    () => {
+      const root = fs.mkdtempSync(path.join(os.tmpdir(), 'start-253-'));
+      try {
+        const result = spawnSync(
+          process.execPath,
+          [
+            CLI,
+            '--use-command-stream',
+            '--',
+            'sh',
+            '-c',
+            'echo out-253; echo err-253 >&2',
+          ],
+          {
+            env: {
+              ...process.env,
+              START_APP_FOLDER: path.join(root, 'app'),
+              START_LOG_DIR: path.join(root, 'logs'),
+              START_DISABLE_AUTO_ISSUE: '1',
+              START_DISABLE_LOG_UPLOAD: '1',
+            },
+            encoding: 'utf8',
+            timeout: 30000,
+          }
+        );
+        expect(result.status).toBe(0);
+        expect(result.stderr).not.toContain('Could not append log file');
+        const logDir = path.join(root, 'logs', 'direct');
+        const [logName] = fs.readdirSync(logDir);
+        const log = fs.readFileSync(path.join(logDir, logName), 'utf8');
+        expect(log).toContain('out-253\n');
+        expect(log).toContain('err-253\n');
+      } finally {
+        fs.rmSync(root, { recursive: true, force: true });
+      }
+    },
+    40000
+  );
+});