harnery 0.45.2 → 0.46.1

package/src/lib/docs-metadata-sync.ts

@@ -118,6 +118,33 @@ function addDays(value: string, days: number): string {
   return date.toISOString().replace(".000Z", "Z");
 }
 
+/** Allowance for clock skew between machines before a timestamp counts as future. */
+const FUTURE_SKEW_MS = 10 * 60 * 1000;
+
+/** Lifecycle timestamps record events that already happened, so none may be later than now. */
+const PAST_TIMESTAMP_FIELDS = [
+  "created_at",
+  "updated_at",
+  "status_changed_at",
+  "resolved_at",
+  "reviewed_at",
+] as const;
+
+function inFuture(value: unknown, now: string): boolean {
+  if (typeof value !== "string") return false;
+  const time = Date.parse(value);
+  return Number.isFinite(time) && time > Date.parse(now) + FUTURE_SKEW_MS;
+}
+
+/**
+ * While a status is unchanged its status_changed_at is pinned to the committed
+ * value. A committed value later than now cannot be true, so a correction to a
+ * time that has already passed is accepted instead of being reverted.
+ */
+function correctsFutureStatusTime(committed: unknown, current: unknown, now: string): boolean {
+  return inFuture(committed, now) && typeof current === "string" && !inFuture(current, now);
+}
+
 export async function runDocsMetadataSync(
   opts: DocsMetadataSyncOpts,
 ): Promise<DocsMetadataSyncRow[]> {
@@ -171,7 +198,8 @@ export async function runDocsMetadataSync(
       if (
         !statusChanged &&
         beforeV2 &&
-        current.data.status_changed_at !== beforeV2.status_changed_at
+        current.data.status_changed_at !== beforeV2.status_changed_at &&
+        !correctsFutureStatusTime(beforeV2.status_changed_at, current.data.status_changed_at, now)
       ) {
         expected.status_changed_at = beforeV2.status_changed_at;
         fields.push("status_changed_at");
@@ -203,6 +231,19 @@ export async function runDocsMetadataSync(
         continue;
       }
       if (opts.check) {
+        const future = PAST_TIMESTAMP_FIELDS.filter((field) => inFuture(current.data[field], now));
+        if (future.length > 0) {
+          rows.push({
+            repo: target.name,
+            path,
+            status: "invalid",
+            fields: [...future],
+            message: future
+              .map((field) => `${field}: cannot be later than the current time`)
+              .join("; "),
+          });
+          continue;
+        }
         const validation = validateDocsMetadataV2(current.data);
         if (!validation.valid) {
           rows.push({
@@ -238,7 +279,8 @@ export async function runDocsMetadataSync(
         if (
           beforeV2 &&
           !statusChanged &&
-          current.data.status_changed_at !== beforeV2.status_changed_at
+          current.data.status_changed_at !== beforeV2.status_changed_at &&
+          !correctsFutureStatusTime(beforeV2.status_changed_at, current.data.status_changed_at, now)
         ) {
           drift.push("status_changed_at");
         }

package/src/lib/durable-job.ts

@@ -63,6 +63,11 @@ export interface DurableJobDocument {
   /** Directory the wrapped command runs in. */
   cwd: string;
   created_at: string;
+  /**
+   * Wait while Linux memory pressure is above this before queueing, as the
+   * foreground run does. The client resolves it from the resource's project config at launch.
+   */
+  defer_on_pressure?: { psi_full_avg10: number; max_wait_seconds: number };
 }
 
 export interface DurableJobStatus {
@@ -208,9 +213,19 @@ export function readJobDocument(jobDir: string): DurableJobDocument | null {
       : [],
     cwd: typeof parsed.cwd === "string" ? parsed.cwd : "",
     created_at: typeof parsed.created_at === "string" ? parsed.created_at : "",
+    ...readDeferOnPressure(parsed.defer_on_pressure),
   };
 }
 
+function readDeferOnPressure(value: unknown): Pick<DurableJobDocument, "defer_on_pressure"> {
+  if (!isRecord(value)) return {};
+  const threshold = value.psi_full_avg10;
+  const maxWait = value.max_wait_seconds;
+  return typeof threshold === "number" && typeof maxWait === "number" && maxWait > 0
+    ? { defer_on_pressure: { psi_full_avg10: threshold, max_wait_seconds: maxWait } }
+    : {};
+}
+
 /** Read the status document, or null when it is missing or unusable. */
 export function readJobStatus(jobDir: string): DurableJobStatus | null {
   const path = join(resolve(jobDir), DURABLE_JOB_STATUS_FILENAME);

package/src/lib/http/client.ts

@@ -2,7 +2,9 @@ import {
   applyExtraCookies,
   type Cookie,
   type CookieJar,
+  domainMatches,
   type ExtraCookies,
+  violatesCookiePrefix,
 } from "../cookies/index.ts";
 
 /**
@@ -52,6 +54,15 @@ export interface FetchOptions<TResponseType extends FetchResponseType = "text">
   extraCookies?: ExtraCookies;
   /** Response body representation. Default `text`; use `bytes` for lossless file output. */
   responseType?: TResponseType;
+  /**
+   * With `redirect: "follow"`, follow redirects in this client instead of the
+   * runtime's fetch. Every hop then gets its own cookie header, `extraHeaders`
+   * call, and Set-Cookie persistence, so a caller that inspects those can stop
+   * a chain between hops. Credential headers are dropped on a cross-origin hop.
+   * Default: on whenever a `jar` is passed (host-only cookies must follow the
+   * jar's exact-host rule on every hop), off without one.
+   */
+  clientRedirects?: boolean;
 }
 
 type FetchBody<TResponseType extends FetchResponseType> = TResponseType extends "bytes"
@@ -76,9 +87,55 @@ export interface FetchResult<TBody = string> {
  * Streams aren't supported; this is a CLI helper, not a streaming HTTP
  * client. Use Bun's `fetch` directly for streaming workloads.
  */
+const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+const MAX_CLIENT_REDIRECTS = 20;
+
 export async function fetchWithJar<TResponseType extends FetchResponseType = "text">(
   url: string,
   opts: FetchOptions<TResponseType> = {},
+): Promise<FetchResult<FetchBody<TResponseType>>> {
+  // With a jar, redirects are followed here so every hop gets its own Cookie
+  // header from the jar (exact-host for host-only cookies) and its own
+  // Set-Cookie persistence; the runtime would otherwise carry or drop the
+  // first hop's header on its own rules. Pass `clientRedirects: false` to opt out.
+  const clientRedirects = opts.clientRedirects ?? Boolean(opts.jar);
+  if (!clientRedirects || (opts.redirect ?? "follow") !== "follow") return fetchOnce(url, opts);
+
+  let current = url;
+  let method = opts.method ?? "GET";
+  let body = opts.body;
+  let headers = opts.headers;
+  let cookiesSaved = 0;
+  for (let hop = 0; ; hop++) {
+    const result = await fetchOnce(current, { ...opts, method, body, headers, redirect: "manual" });
+    cookiesSaved += result.cookiesSaved;
+    const location = result.headers.location;
+    if (!REDIRECT_STATUSES.has(result.status) || !location) return { ...result, cookiesSaved };
+    if (hop >= MAX_CLIENT_REDIRECTS) {
+      throw new Error(`Too many redirects (more than ${MAX_CLIENT_REDIRECTS}) starting at ${url}`);
+    }
+    const next = new URL(location, current);
+    if (
+      result.status === 303 ||
+      ((result.status === 301 || result.status === 302) && method !== "GET" && method !== "HEAD")
+    ) {
+      method = "GET";
+      body = undefined;
+    }
+    if (next.origin !== new URL(current).origin && headers) {
+      headers = Object.fromEntries(
+        Object.entries(headers).filter(
+          ([name]) => !["authorization", "cookie"].includes(name.toLowerCase()),
+        ),
+      );
+    }
+    current = next.href;
+  }
+}
+
+async function fetchOnce<TResponseType extends FetchResponseType = "text">(
+  url: string,
+  opts: FetchOptions<TResponseType> = {},
 ): Promise<FetchResult<FetchBody<TResponseType>>> {
   const headers: Record<string, string> = { ...(opts.headers ?? {}) };
 
@@ -229,7 +286,9 @@ function parseSetCookie(raw: string, defaultDomain: string): Cookie | null {
   for (const attr of parts.slice(1)) {
     const lower = attr.toLowerCase();
     if (lower.startsWith("domain=")) {
-      const d = attr.slice(7).trim();
+      const d = attr.slice(7).trim().toLowerCase();
+      // A server may only scope a cookie to its own host or a parent domain.
+      if (!d || !domainMatches(d, defaultDomain)) return null;
       cookie.domain = d.startsWith(".") ? d : `.${d}`;
     } else if (lower.startsWith("path=")) {
       cookie.path = attr.slice(5).trim() || "/";
@@ -255,5 +314,8 @@ function parseSetCookie(raw: string, defaultDomain: string): Cookie | null {
     }
   }
 
+  // A cookie that breaks its name prefix is dropped, as a browser would.
+  if (violatesCookiePrefix(cookie)) return null;
+
   return cookie;
 }

package/src/lib/instructions/templates.ts

@@ -133,10 +133,10 @@ carries a reason instead of \`(no intent)\`; the [tool-intent
 guide](https://harnery.com/guides/tool-intent/) owns the details.
 
 **Messaging another agent.** \`${b} agents ping <name> "<message>"\` reaches an
-agent by name whether or not they are running: a live agent sees it on their next
-prompt, and a dormant name holds it until a session of that name next starts.
-Send it as your first and only step. Do not check who is live first, and do not
-hunt for somewhere else to leave it. Only a never-used name is refused.
+agent by name, running or not, here or on another machine sharing this origin:
+a live agent sees it on their next prompt (after a fetch, if remote), and a
+dormant name holds it until that session next starts. Send it as your only step;
+do not check who is live first or hunt elsewhere. Only an unused name is refused.
 
 **Journal.** \`${b} journal add <category> "<text>"\` (category = ${journalCats})
 leaves breadcrumbs that survive context compaction;