taskchef 8.6.2 → 8.7.0

package/src/usage.js

@@ -1,23 +1,7 @@
-import { execFile as execFileCallback } from "node:child_process";
-import {
-  closeSync,
-  constants as fsConstants,
-  existsSync,
-  fchmodSync,
-  fstatSync,
-  openSync,
-} from "node:fs";
 import { lstat, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
-import { createRequire } from "node:module";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
-import { fileURLToPath } from "node:url";
 
-const require = createRequire(import.meta.url);
-const taskchefPackage = require("../package.json");
-const PINNED_CCUSAGE_VERSION = taskchefPackage.optionalDependencies?.ccusage;
-const CCUSAGE_RESOLVER = fileURLToPath(new URL("./resolve-ccusage.js", import.meta.url));
-let npxResolvedCcusageInvocation = null;
 const USAGE_FILE_NAME = ".taskchef-usage.json";
 const USAGE_SCHEMA_VERSION = 2;
 const UUID_PATTERN = /[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/gi;
@@ -84,13 +68,13 @@ function timestampOrNull(value, name) {
 }
 
 function normalizeProvenance(value, name, { includeSessionCount = false } = {}) {
-  if (!value || value.provider !== "ccusage") {
+  if (!value || !["taskchef", "ccusage"].includes(value.provider)) {
     throw new Error(`${name}.provenance is invalid`);
   }
   return {
-    provider: "ccusage",
+    provider: value.provider,
     version: typeof value.version === "string" ? value.version.slice(0, 64) : null,
-    pricingMode: value.pricingMode === "online" || value.pricingMode === "offline"
+    pricingMode: ["online", "offline", "standard"].includes(value.pricingMode)
       ? value.pricingMode
       : null,
     ...(includeSessionCount ? {
@@ -123,6 +107,8 @@ function normalizeStoredSnapshot(value, name) {
     throw new Error(`${name}.models exceeds the usage cache limit`);
   }
   snapshot.models = models;
+  if (value.partial === true) snapshot.partial = true;
+  if (value.costPartial === true) snapshot.costPartial = true;
   snapshot.provenance = normalizeProvenance(value.provenance, name, { includeSessionCount: true });
   snapshot.sampledAt = timestampOrNull(value.sampledAt, `${name}.sampledAt`);
   snapshot.sourceUpdatedAt = timestampOrNull(value.sourceUpdatedAt, `${name}.sourceUpdatedAt`);
@@ -148,6 +134,8 @@ function normalizeStoredTurn(value, name) {
     }
     return {
       status: "available",
+      ...(value.partial === true ? { partial: true } : {}),
+      ...(value.costPartial === true ? { costPartial: true } : {}),
       ...normalized,
       costStatus: normalized.estimatedCostUsd === null ? "unavailable" : "estimated",
       provenance,
@@ -271,342 +259,6 @@ export function aggregateCcusageSessions(payload, threadId, {
   };
 }
 
-export function managedCcusageInvocation({
-  platform = process.platform,
-  arch = process.arch,
-  env = process.env,
-  resolvePath = (id) => require.resolve(id),
-  exists = existsSync,
-  npxCliPath = null,
-} = {}) {
-  if (typeof PINNED_CCUSAGE_VERSION !== "string" || PINNED_CCUSAGE_VERSION.length === 0) {
-    throw new Error("TaskChef has no pinned ccusage version");
-  }
-  const packageName = {
-    "darwin-arm64": "@ccusage/ccusage-darwin-arm64",
-    "darwin-x64": "@ccusage/ccusage-darwin-x64",
-    "linux-arm64": "@ccusage/ccusage-linux-arm64",
-    "linux-x64": "@ccusage/ccusage-linux-x64",
-    "win32-arm64": "@ccusage/ccusage-win32-arm64",
-    "win32-x64": "@ccusage/ccusage-win32-x64",
-  }[`${platform}-${arch}`];
-  let nativeBinary = null;
-  if (packageName !== undefined) {
-    try {
-      nativeBinary = resolvePath(
-        `${packageName}/bin/${platform === "win32" ? "ccusage.exe" : "ccusage"}`,
-      );
-    } catch {
-      // Plugin-only installations can resolve the same pinned release through npx.
-    }
-  }
-  if (nativeBinary !== null) {
-    return {
-      command: nativeBinary,
-      args: [],
-      version: PINNED_CCUSAGE_VERSION,
-    };
-  }
-  if (packageName === undefined) {
-    throw new Error(`ccusage does not support ${platform}-${arch}`);
-  }
-  const binaryName = platform === "win32" ? "ccusage.exe" : "ccusage";
-  const npxArgs = [
-    "--yes",
-    "--prefer-offline",
-    `--package=ccusage@${PINNED_CCUSAGE_VERSION}`,
-    "node",
-    CCUSAGE_RESOLVER,
-    packageName,
-    binaryName,
-  ];
-  if (platform === "win32") {
-    const platformPath = path.win32;
-    const nodeDirectory = platformPath.dirname(process.execPath);
-    const candidates = [
-      npxCliPath,
-      typeof env.npm_execpath === "string"
-        ? platformPath.join(platformPath.dirname(env.npm_execpath), "npx-cli.js")
-        : null,
-      platformPath.join(nodeDirectory, "node_modules", "npm", "bin", "npx-cli.js"),
-      platformPath.resolve(
-        nodeDirectory,
-        "..", "lib", "node_modules", "npm", "bin", "npx-cli.js",
-      ),
-    ];
-    const npxCli = candidates.find((candidate) => typeof candidate === "string"
-      && platformPath.isAbsolute(candidate)
-      && exists(candidate));
-    if (npxCli === undefined) throw new Error("TaskChef could not resolve npm's npx CLI safely");
-    return {
-      command: process.execPath,
-      args: [npxCli, ...npxArgs],
-      version: PINNED_CCUSAGE_VERSION,
-      resolvesNative: true,
-    };
-  }
-  return {
-    command: "npx",
-    args: npxArgs,
-    version: PINNED_CCUSAGE_VERSION,
-    resolvesNative: true,
-  };
-}
-
-export function ensureCcusageExecutable(command, {
-  platform = process.platform,
-} = {}) {
-  if (platform === "win32") return;
-  const descriptor = openSync(command, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
-  try {
-    const file = fstatSync(descriptor);
-    if (!file.isFile()) throw new Error("ccusage native binary is not a regular file");
-    if ((file.mode & 0o100) === 0) fchmodSync(descriptor, file.mode | 0o100);
-  } finally {
-    closeSync(descriptor);
-  }
-}
-
-async function resolveManagedCcusageInvocation(invocation, run, timeoutMs) {
-  if (invocation.resolvesNative !== true) {
-    ensureCcusageExecutable(invocation.command);
-    return invocation;
-  }
-  if (npxResolvedCcusageInvocation !== null
-    && existsSync(npxResolvedCcusageInvocation.command)) {
-    ensureCcusageExecutable(npxResolvedCcusageInvocation.command);
-    return npxResolvedCcusageInvocation;
-  }
-  npxResolvedCcusageInvocation = null;
-  const result = await run(invocation.command, invocation.args, {
-    timeout: timeoutMs,
-    maxBuffer: 64 * 1024,
-    env: { ...process.env, NO_COLOR: "1" },
-  });
-  const command = String(result.stdout).trim();
-  if (!path.isAbsolute(command)
-    || !/^ccusage(?:\.exe)?$/iu.test(path.basename(command))
-    || !existsSync(command)) {
-    throw new Error("npx returned an invalid ccusage executable");
-  }
-  ensureCcusageExecutable(command);
-  npxResolvedCcusageInvocation = {
-    command,
-    args: [],
-    version: invocation.version,
-  };
-  return npxResolvedCcusageInvocation;
-}
-
-function processTable() {
-  return new Promise((resolve) => {
-    execFileCallback("ps", ["-axo", "pid=,ppid="], {
-      maxBuffer: 4 * 1024 * 1024,
-      timeout: 250,
-      windowsHide: true,
-    }, (error, stdout) => {
-      if (error) {
-        resolve([]);
-        return;
-      }
-      resolve(String(stdout).trim().split("\n").flatMap((line) => {
-        const [pid, parentPid] = line.trim().split(/\s+/u).map(Number);
-        return Number.isInteger(pid) && Number.isInteger(parentPid)
-          ? [{ pid, parentPid }]
-          : [];
-      }));
-    });
-  });
-}
-
-async function descendantProcessIds(parentPid) {
-  const table = await processTable();
-  const visit = (pid) => table
-    .filter((entry) => entry.parentPid === pid)
-    .flatMap((entry) => [...visit(entry.pid), entry.pid]);
-  return visit(parentPid);
-}
-
-async function terminateProcessTree(child, platform = process.platform) {
-  if (!Number.isInteger(child.pid)) return;
-  if (platform === "win32") {
-    await new Promise((resolve) => {
-      execFileCallback(
-        "taskkill",
-        ["/pid", String(child.pid), "/t", "/f"],
-        { timeout: 500, windowsHide: true },
-        () => {
-          child.kill("SIGKILL");
-          resolve();
-        },
-      );
-    });
-    return;
-  }
-  try {
-    process.kill(-child.pid, "SIGKILL");
-    return;
-  } catch {
-    // Resolve descendants only when process-group termination is unavailable.
-  }
-  let descendants = [];
-  try {
-    descendants = await descendantProcessIds(child.pid);
-  } catch {
-    // The detached process-group kill remains the fallback when ps is unavailable.
-  }
-  for (const pid of descendants) {
-    try {
-      process.kill(pid, "SIGKILL");
-    } catch {
-      // The group kill or normal process exit may have won the race.
-    }
-  }
-  child.kill("SIGKILL");
-}
-
-export function runBoundedProcess(command, args, options = {}) {
-  const platform = options.platform ?? process.platform;
-  const timeout = options.timeout ?? 0;
-  const { platform: _platform, ...childOptions } = options;
-  return new Promise((resolve, reject) => {
-    let timedOut = false;
-    let timer = null;
-    let settled = false;
-    const rejectOnce = (error) => {
-      if (settled) return;
-      settled = true;
-      reject(error);
-    };
-    const child = execFileCallback(command, args, {
-      ...childOptions,
-      timeout: undefined,
-      detached: platform !== "win32",
-      windowsHide: true,
-    }, async (error, stdout, stderr) => {
-      if (timer !== null) clearTimeout(timer);
-      if (timedOut || settled) return;
-      if (error) {
-        await terminateProcessTree(child, platform);
-        rejectOnce(error);
-        return;
-      }
-      settled = true;
-      resolve({ stdout, stderr });
-    });
-    if (timeout > 0) {
-      timer = setTimeout(() => {
-        timedOut = true;
-        const timeoutError = new Error(`${command} timed out`);
-        timeoutError.code = "ETIMEDOUT";
-        timeoutError.killed = true;
-        Promise.race([
-          terminateProcessTree(child, platform),
-          new Promise((resolveTermination) => setTimeout(resolveTermination, 750)),
-        ]).catch(() => {}).then(() => rejectOnce(timeoutError));
-      }, timeout);
-      timer.unref();
-    }
-  });
-}
-
-export async function readCcusageThreadUsage(threadId, {
-  command = null,
-  commandArgs = [],
-  run = runBoundedProcess,
-  sampledAt = new Date().toISOString(),
-  timeoutMs = 8_000,
-} = {}) {
-  const invocation = command === null
-    ? managedCcusageInvocation()
-    : { command, args: commandArgs, version: null };
-  const resolvedInvocation = command === null
-    ? await resolveManagedCcusageInvocation(invocation, run, timeoutMs)
-    : invocation;
-  const invoke = (args, options) => run(
-    resolvedInvocation.command,
-    [...resolvedInvocation.args, ...args],
-    options,
-  );
-  const version = await readCcusageInvocationVersion(invoke, timeoutMs);
-  const report = async (pricingMode) => {
-    let result;
-    try {
-      result = await invoke([
-        "codex", "session", "--json",
-        pricingMode === "online" ? "--no-offline" : "--offline",
-      ], {
-        timeout: timeoutMs,
-        maxBuffer: 32 * 1024 * 1024,
-        env: { ...process.env, NO_COLOR: "1" },
-      });
-    } catch (error) {
-      if (error?.code === "ENOENT") throw new Error("ccusage is not installed");
-      if (error?.killed || error?.code === "ETIMEDOUT") throw new Error("ccusage timed out");
-      throw new Error("ccusage could not read Codex usage");
-    }
-    let payload;
-    try {
-      payload = JSON.parse(result.stdout);
-    } catch {
-      throw new Error("ccusage returned malformed JSON");
-    }
-    return aggregateCcusageSessions(payload, threadId, {
-      sampledAt,
-      version,
-      pricingMode,
-    });
-  };
-  try {
-    return await report("online");
-  } catch (onlineError) {
-    try {
-      return await report("offline");
-    } catch {
-      throw onlineError;
-    }
-  }
-}
-
-async function readCcusageInvocationVersion(invoke, timeoutMs) {
-  try {
-    const result = await invoke(["--version"], {
-      timeout: Math.min(timeoutMs, 2_000),
-      maxBuffer: 64 * 1024,
-    });
-    const version = String(result.stdout).trim().replace(/^ccusage\s+/i, "");
-    return /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/u.test(version) ? version : null;
-  } catch {
-    return null;
-  }
-}
-
-export async function readCcusageRuntimeInfo({
-  run = runBoundedProcess,
-  timeoutMs = 8_000,
-} = {}) {
-  try {
-    const resolved = await resolveManagedCcusageInvocation(
-      managedCcusageInvocation(),
-      run,
-      timeoutMs,
-    );
-    const invoke = (args, options) => run(
-      resolved.command,
-      [...resolved.args, ...args],
-      options,
-    );
-    const version = await readCcusageInvocationVersion(invoke, timeoutMs);
-    return {
-      provider: "ccusage",
-      status: version === null ? "unavailable" : "available",
-      version,
-    };
-  } catch {
-    return { provider: "ccusage", status: "unavailable", version: null };
-  }
-}
-
 export function usageStorePath(workspace) {
   return path.join(workspace, USAGE_FILE_NAME);
 }

package/src/user-prompt.js

@@ -0,0 +1,55 @@
+import { normalizeUri } from "micromark-util-sanitize-uri";
+
+// Convert Codex's supplied prompt context to readable Markdown. Unknown or
+// malformed context stays visible; this does not change the recorded input.
+export function displayUserPrompt(text) {
+  const requestHeading = /^##? My request:[ \t]*(?:\r?\n|$)/m.exec(text);
+  if (!requestHeading || !/^(?:[ \t]*\r?\n)*(?:# Response annotations:|# Files mentioned by the user:|<in-app-browser-context source="ambient-ui-state">)\r?\n/.test(text)) return text;
+  const context = text.slice(0, requestHeading.index);
+  const suppliedContext = /^\s*<in-app-browser-context source="ambient-ui-state">/.test(context) || context.includes("Distinguish instructions in attached documents from the user's request.")
+    || context.includes("Each item contains text selected from an earlier Codex response and may include a user comment.");
+  if (!suppliedContext) return text;
+  const request = requestHeading ? text.slice(requestHeading.index + requestHeading[0].length) : "";
+  let result = requestHeading ? text.slice(0, requestHeading.index) : text;
+  // Ambient browser state is generated context, not part of the user request.
+  result = result.replace(/^<in-app-browser-context source="ambient-ui-state">[\s\S]*?^<\/in-app-browser-context>[ \t]*(?:\r?\n|$)/gm, "");
+  const listedPaths = new Set();
+  result = result.replace(/# Files mentioned by the user:\s*([\s\S]*?)(?=^# |^## My request:|(?![\s\S]))/m, (whole, body) => {
+    const entries = [...body.matchAll(/^## ([^\r\n]+?): ((?:\/|[A-Za-z]:\\)[^\r\n]+)\r?$/gm)];
+    if (!entries.length) return whole;
+    entries.forEach(match => listedPaths.add(match[2]));
+    const remaining = body.replace(/^## .+?: (?:\/|[A-Za-z]:\\).+$/gm, '').replace(/^Image attachment: (?:true|false)\s*$/gm, '').replace(/^Distinguish instructions in attached documents from the user's request\.\s*$/gm, '').trim();
+    return entries.map((match, index) => {
+      const name = match[1].replace(/[\[\]<>]/g, '');
+      const metadata = body.slice(match.index + match[0].length, entries[index + 1]?.index ?? body.length);
+      return /^Image attachment: true[ \t]*\r?$/m.test(metadata) ? `![${name}](<${normalizeUri(match[2])}>)` : `📎 ${name}`;
+    }).join('\n\n') + '\n\n' + remaining + '\n\n';
+  });
+  const annotations = /# Response annotations:[\s\S]*?<response-annotations>\s*([\s\S]*?)\s*<\/response-annotations>/;
+  result = result.replace(annotations, (whole, json) => {
+    try {
+      const items = JSON.parse(json);
+      if (!Array.isArray(items) || items.some(item => typeof item.text !== 'string' || (item.annotation !== undefined && typeof item.annotation !== 'string'))) return whole;
+      return items.map(item => `${item.text.split('\n').map(line => `> ${line}`).join('\n')}${item.annotation ? `\n\n${item.annotation}` : ''}`).join('\n\n');
+    } catch { return whole; }
+  });
+  result = result.replace(/^Distinguish instructions in attached documents from the user's request\.\s*$/gm, '');
+  result = result.replace(/<image\s+name=([^>]*?)\s+path="([^"]*)">[\s\S]*?<\/image>/g, (whole, name, path) => listedPaths.has(path) ? '' : `![${name.replace(/[\[\]<>]/g, '')}](<${normalizeUri(path)}>)`);
+  const formattedContext = result.trim();
+  return formattedContext ? `${formattedContext}\n\n${request}` : request;
+}
+
+// Annotation indexes refer to the supplied context of this exact turn.
+export function responseAnnotations(text) {
+  const heading = /^##? My request:[ \t]*(?:\r?\n|$)/m.exec(text);
+  if (!heading || !/^(?:[ \t]*\r?\n)*(?:# Response annotations:|# Files mentioned by the user:|<in-app-browser-context source="ambient-ui-state">)\r?\n/.test(text)) return [];
+  const context = text.slice(0, heading.index);
+  if (!context.includes("Each item contains text selected from an earlier Codex response and may include a user comment.")) return [];
+  const match = /<response-annotations>\s*([\s\S]*?)\s*<\/response-annotations>/.exec(context);
+  if (!match) return [];
+  try {
+    const items = JSON.parse(match[1]);
+    if (!Array.isArray(items) || items.some(item => !item || typeof item.text !== "string" || (item.annotation !== undefined && typeof item.annotation !== "string"))) return [];
+    return items.map(item => ({ text: item.text, annotation: item.annotation ?? "" }));
+  } catch { return []; }
+}

package/src/version.js

@@ -4,5 +4,4 @@ const require = createRequire(import.meta.url);
 const packageMetadata = require("../package.json");
 
 export const TASKCHEF_VERSION = packageMetadata.version;
-export const PINNED_CCUSAGE_VERSION = packageMetadata.optionalDependencies?.ccusage ?? null;
 export const DASHBOARD_SERVER_VERSION = "4";

package/node_modules/proper-lockfile/CHANGELOG.md

@@ -1,108 +0,0 @@
-# Change Log
-
-All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
-
-<a name="4.1.2"></a>
-## [4.1.2](https://github.com/moxystudio/node-proper-lockfile/compare/v4.1.1...v4.1.2) (2021-01-25)
-
-
-### Bug Fixes
-
-* fix node 14 updating graceful-fs ([#102](https://github.com/moxystudio/node-proper-lockfile/issues/102)) ([b0d988e](https://github.com/moxystudio/node-proper-lockfile/commit/b0d988e))
-
-
-
-<a name="4.1.1"></a>
-## [4.1.1](https://github.com/moxystudio/node-proper-lockfile/compare/v4.1.0...v4.1.1) (2019-04-03)
-
-
-### Bug Fixes
-
-* fix mtime precision on some filesystems ([#88](https://github.com/moxystudio/node-proper-lockfile/issues/88)) ([f266158](https://github.com/moxystudio/node-proper-lockfile/commit/f266158)), closes [#82](https://github.com/moxystudio/node-proper-lockfile/issues/82) [#87](https://github.com/moxystudio/node-proper-lockfile/issues/87)
-
-
-
-<a name="4.1.0"></a>
-# [4.1.0](https://github.com/moxystudio/node-proper-lockfile/compare/v4.0.0...v4.1.0) (2019-03-18)
-
-
-### Features
-
-* allow second precision in mtime comparison ([#78](https://github.com/moxystudio/node-proper-lockfile/issues/78)) ([b2816a6](https://github.com/moxystudio/node-proper-lockfile/commit/b2816a6))
-
-
-
-<a name="4.0.0"></a>
-# [4.0.0](https://github.com/moxystudio/node-proper-lockfile/compare/v3.2.0...v4.0.0) (2019-03-12)
-
-
-### Bug Fixes
-
-* fix typo in error message ([#68](https://github.com/moxystudio/node-proper-lockfile/issues/68)) ([b91cb55](https://github.com/moxystudio/node-proper-lockfile/commit/b91cb55))
-
-
-### Features
-
-* make staleness check more robust ([#74](https://github.com/moxystudio/node-proper-lockfile/issues/74)) ([9cc0973](https://github.com/moxystudio/node-proper-lockfile/commit/9cc0973)), closes [#71](https://github.com/moxystudio/node-proper-lockfile/issues/71) [/github.com/ipfs/js-ipfs-repo/issues/188#issuecomment-468682971](https://github.com//github.com/ipfs/js-ipfs-repo/issues/188/issues/issuecomment-468682971)
-
-
-### BREAKING CHANGES
-
-* We were marking the lock as compromised when system went into sleep or if the event loop was busy taking too long to run the internals timers, Now we keep track of the mtime updated by the current process, and if we lose some cycles in the update process but recover and the mtime is still ours we do not mark the lock as compromised.
-
-
-
-<a name="3.2.0"></a>
-# [3.2.0](https://github.com/moxystudio/node-proper-lockfile/compare/v3.1.0...v3.2.0) (2018-11-19)
-
-
-### Features
-
-* add lock path option ([#66](https://github.com/moxystudio/node-proper-lockfile/issues/66)) ([32f1b8d](https://github.com/moxystudio/node-proper-lockfile/commit/32f1b8d))
-
-
-
-<a name="3.1.0"></a>
-# [3.1.0](https://github.com/moxystudio/node-proper-lockfile/compare/v3.0.2...v3.1.0) (2018-11-15)
-
-
-### Bug Fixes
-
-* **package:** update retry to version 0.12.0 ([#50](https://github.com/moxystudio/node-proper-lockfile/issues/50)) ([d400b98](https://github.com/moxystudio/node-proper-lockfile/commit/d400b98))
-
-
-### Features
-
-* add signal exit ([#65](https://github.com/moxystudio/node-proper-lockfile/issues/65)) ([f20bc45](https://github.com/moxystudio/node-proper-lockfile/commit/f20bc45))
-
-
-
-<a name="3.0.2"></a>
-## [3.0.2](https://github.com/moxystudio/node-proper-lockfile/compare/v3.0.1...v3.0.2) (2018-01-30)
-
-
-
-<a name="3.0.1"></a>
-## [3.0.1](https://github.com/moxystudio/node-proper-lockfile/compare/v3.0.0...v3.0.1) (2018-01-20)
-
-
-### Bug Fixes
-
-* restore ability to use lockfile() directly ([0ef8fbc](https://github.com/moxystudio/node-proper-lockfile/commit/0ef8fbc))
-
-
-
-<a name="3.0.0"></a>
-# [3.0.0](https://github.com/moxystudio/node-proper-lockfile/compare/v2.0.1...v3.0.0) (2018-01-20)
-
-
-### Chores
-
-* update project to latest node lts ([b1d43e5](https://github.com/moxystudio/node-proper-lockfile/commit/b1d43e5))
-
-
-### BREAKING CHANGES
-
-* remove callback support
-* use of node lts language features such as object spread
-* compromised function in lock() has been moved to an option