@indigoai-us/hq-cli 5.345.155 → 5.345.156

package/dist/lib/index-render/index.js

@@ -1,4 +1,6 @@
-import { renderCompanies } from "./companies.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { CompanyIndexUserError, renderCompanies } from "./companies.js";
 import { renderCompanyKnowledge } from "./company-knowledge.js";
 import { renderOrchestrator } from "./orchestrator.js";
 import { renderProjects } from "./projects.js";
@@ -8,12 +10,51 @@ import { renderSocialDrafts } from "./social-drafts.js";
 import { renderThreads } from "./threads.js";
 import { renderWorkers } from "./workers.js";
 const allOrder = ["threads", "orchestrator", "companies", "projects", "company-knowledge", "public-knowledge", "workers", "reports", "social-drafts"];
+function companyScope(target, context, args) {
+    let company;
+    for (let i = 0; i < args.length; i += 1) {
+        let value = args[i];
+        if (value === "--company")
+            value = args[++i] ?? "";
+        else if (value.startsWith("--company="))
+            value = value.slice("--company=".length);
+        if (!value || value.startsWith("-"))
+            throw new CompanyIndexUserError(`rebuild-index ${target}: expected a company slug; unknown or incomplete option`);
+        if (company !== undefined)
+            throw new CompanyIndexUserError(`rebuild-index ${target}: supply only one company slug`);
+        if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(value))
+            throw new CompanyIndexUserError(`rebuild-index ${target}: invalid company slug`);
+        company = value;
+    }
+    if (company !== undefined) {
+        const directory = path.join(context.root, "companies", company);
+        try {
+            if (!fs.lstatSync(directory).isDirectory())
+                throw new CompanyIndexUserError(`rebuild-index ${target}: company must be a real directory`);
+            const contentDirectory = path.join(directory, target === "projects" ? "projects" : "knowledge");
+            if (fs.existsSync(contentDirectory) && !fs.lstatSync(contentDirectory).isDirectory())
+                throw new CompanyIndexUserError(`rebuild-index ${target}: content must be a real directory`);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                throw new CompanyIndexUserError(`rebuild-index ${target}: no company directory named "${company}"`);
+            throw error;
+        }
+    }
+    return company;
+}
 export function renderIndexTarget(target, context, args = []) {
+    if (target === "company-knowledge" || target === "projects") {
+        if (args.some((arg) => arg === "--help" || arg === "-h")) {
+            (context.output ?? ((message) => process.stdout.write(message)))(`Usage: hq core rebuild-index ${target} [<company> | --company <company>] [--accept]\n\nWith a company, rebuild only that company's index. Without a company, retain the all-company rebuild. Help performs no writes.\n`);
+            return { written: [] };
+        }
+        const company = companyScope(target, context, args);
+        return target === "projects" ? renderProjects(context, company) : renderCompanyKnowledge(context, company);
+    }
     switch (target) {
         case "companies": return renderCompanies(context, args);
-        case "company-knowledge": return renderCompanyKnowledge(context);
         case "orchestrator": return renderOrchestrator(context);
-        case "projects": return renderProjects(context);
         case "public-knowledge": return renderPublicKnowledge(context);
         case "reports": return renderReports(context);
         case "social-drafts": return renderSocialDrafts(context);

package/dist/lib/index-render/projects.d.ts

@@ -1,3 +1,3 @@
 import { RenderContext, RenderResult } from "./shared.js";
-export declare function renderProjects(context: RenderContext): RenderResult;
+export declare function renderProjects(context: RenderContext, selectedCompany?: string): RenderResult;
 //# sourceMappingURL=projects.d.ts.map

package/dist/lib/index-render/projects.js

@@ -64,9 +64,9 @@ function renderCompanyProjects(context, company, projectRoot) {
     log(context, `rebuild-projects-index: wrote ${output}`);
     return written;
 }
-export function renderProjects(context) {
+export function renderProjects(context, selectedCompany) {
     const written = [];
-    const companyDirectories = immediateEntries(context.root, "companies", "dir");
+    const companyDirectories = selectedCompany === undefined ? immediateEntries(context.root, "companies", "dir") : [at(context.root, `companies/${selectedCompany}`)];
     for (const companyDirectory of companyDirectories) {
         const company = basename(companyDirectory);
         if (company.startsWith("_") || isHidden(company))
@@ -76,6 +76,8 @@ export function renderProjects(context) {
             written.push(...renderCompanyProjects(context, company, projectRoot));
         }
     }
+    if (selectedCompany !== undefined)
+        return { written };
     const base = "personal/projects";
     if (!exists(context.root, base)) {
         log(context, "rebuild-projects-index: personal/projects/ missing, skipping");

package/dist/sentry-before-send.js

@@ -192,6 +192,7 @@ export function beforeSend(event, _hint) {
             "core-version-unavailable",
             "core-update-available",
             "no-local-tree",
+            "company-not-resolved",
             "legacy-personal-journal",
             "never-synced",
             "invalid-last-sync",

package/dist/utils/access-denied-hint.js

@@ -31,6 +31,12 @@ function errMessage(err) {
 export function isAccessDeniedError(err) {
     const rec = errRecord(err);
     if (rec) {
+        // A presigned storage download that failed AFTER the API authorized the
+        // key (createCompanyPresignClient). The ACL already passed, so pointing
+        // the caller at `hq access` would loop. Checked before the message regex
+        // because the message names the HTTP status.
+        if (rec.code === "FILES_STORAGE_DOWNLOAD_FAILED")
+            return false;
         if (rec.status === 403)
             return true;
         const meta = rec.$metadata;

package/dist/utils/client-health.d.ts

@@ -64,6 +64,17 @@ export declare const CLIENT_HEALTH_OBSERVATION_FILE = "cli-client-health.observa
  * always re-observe — they have opened the store anyway, so it costs nothing.
  */
 export declare const JOURNAL_OBSERVATION_TTL_MS: number;
+/**
+ * V8 old-space cap, in MB, for the child process that enumerates journals on
+ * behalf of a plain invocation. `listJournals()` materializes every area of
+ * the local sync state store; on a large store that took a short-lived
+ * command such as `hq secrets exec` to 2.5-4 GB RSS (feedback_d70e9d63). The
+ * child either finishes inside this cap or dies, and the command never holds
+ * that memory itself.
+ */
+export declare const JOURNAL_OBSERVER_HEAP_MB = 512;
+/** Wall-clock bound for the isolated journal observer. */
+export declare const JOURNAL_OBSERVER_TIMEOUT_MS = 20000;
 export interface CliClientHealthState {
     /** Stable random installation identity — regenerated only if invalid. */
     installationId: string;
@@ -120,6 +131,24 @@ interface JournalLike {
  * contract ISO-UTC. Null when nothing has ever synced.
  */
 export declare function latestJournalSyncTime(journals: readonly JournalLike[]): string | null;
+/**
+ * The isolated observer could not produce a value (heap cap, timeout, crash or
+ * unreadable output). The caller stamps the observation so the next attempt
+ * waits a full TTL instead of re-running a read already known to fail here.
+ */
+export declare class JournalObservationUnavailableError extends Error {
+    constructor(message: string);
+}
+/**
+ * Run `listJournals()` in a heap-capped child process and return only the
+ * `lastSync` values. Used for plain invocations so the full store
+ * materialization never lands in the invoking command's own memory.
+ */
+export declare function observeJournalsIsolated(opts?: {
+    engineUrl?: string;
+    heapMb?: number;
+    timeoutMs?: number;
+}): JournalLike[];
 /**
  * True when this event kind must pay for a fresh `listJournals()` read.
  *
@@ -167,6 +196,11 @@ export interface ClientHealthDeps {
     expiring?: typeof isExpiring;
     versions?: () => VersionInfo;
     journals?: () => readonly JournalLike[];
+    /**
+     * Journal source for plain invocations when `journals` is not set. Defaults
+     * to {@link observeJournalsIsolated}; sync events read in-process.
+     */
+    isolatedJournals?: () => readonly JournalLike[];
     post?: HeartbeatPoster;
     timeoutMs?: number;
     /** US-016: overridable for tests; defaults to {@link collectLocalFilesOverview}. */

package/dist/utils/client-health.js

@@ -33,6 +33,9 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { randomBytes } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
 import { getStateDir, listJournals } from "@indigoai-us/hq-cloud";
 import { isExpiring, isMachineIdentity, loadCachedTokens, } from "./cognito-session.js";
 import { vaultApiFetch } from "./vault-api.js";
@@ -73,6 +76,17 @@ export const CLIENT_HEALTH_OBSERVATION_FILE = "cli-client-health.observation.jso
  * always re-observe — they have opened the store anyway, so it costs nothing.
  */
 export const JOURNAL_OBSERVATION_TTL_MS = 15 * 60_000;
+/**
+ * V8 old-space cap, in MB, for the child process that enumerates journals on
+ * behalf of a plain invocation. `listJournals()` materializes every area of
+ * the local sync state store; on a large store that took a short-lived
+ * command such as `hq secrets exec` to 2.5-4 GB RSS (feedback_d70e9d63). The
+ * child either finishes inside this cap or dies, and the command never holds
+ * that memory itself.
+ */
+export const JOURNAL_OBSERVER_HEAP_MB = 512;
+/** Wall-clock bound for the isolated journal observer. */
+export const JOURNAL_OBSERVER_TIMEOUT_MS = 20_000;
 /** An observation lock older than this is treated as abandoned. */
 const JOURNAL_OBSERVATION_LOCK_STALE_MS = 5 * 60_000;
 /**
@@ -234,6 +248,66 @@ export function latestJournalSyncTime(journals) {
     }
     return latest === null ? null : new Date(latest).toISOString();
 }
+/**
+ * The isolated observer could not produce a value (heap cap, timeout, crash or
+ * unreadable output). The caller stamps the observation so the next attempt
+ * waits a full TTL instead of re-running a read already known to fail here.
+ */
+export class JournalObservationUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "JournalObservationUnavailableError";
+    }
+}
+const JOURNAL_OBSERVER_SOURCE = [
+    "const engine = await import(process.argv[1]);",
+    "const out = [];",
+    "for (const entry of engine.listJournals()) {",
+    "  const value = entry && entry.journal ? entry.journal.lastSync : undefined;",
+    "  if (typeof value === 'string') out.push(value);",
+    "}",
+    "process.stdout.write(JSON.stringify(out));",
+].join("\n");
+function defaultJournalEngineUrl() {
+    return pathToFileURL(createRequire(import.meta.url).resolve("@indigoai-us/hq-cloud")).href;
+}
+/**
+ * Run `listJournals()` in a heap-capped child process and return only the
+ * `lastSync` values. Used for plain invocations so the full store
+ * materialization never lands in the invoking command's own memory.
+ */
+export function observeJournalsIsolated(opts = {}) {
+    const engineUrl = opts.engineUrl ?? defaultJournalEngineUrl();
+    const result = spawnSync(process.execPath, [
+        `--max-old-space-size=${opts.heapMb ?? JOURNAL_OBSERVER_HEAP_MB}`,
+        "--input-type=module",
+        "-e",
+        JOURNAL_OBSERVER_SOURCE,
+        engineUrl,
+    ], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: opts.timeoutMs ?? JOURNAL_OBSERVER_TIMEOUT_MS,
+        maxBuffer: 1024 * 1024,
+        windowsHide: true,
+    });
+    if (result.error || result.status !== 0 || result.signal) {
+        throw new JournalObservationUnavailableError(`journal observer failed (status ${String(result.status)}, signal ${String(result.signal)})`);
+    }
+    let values;
+    try {
+        values = JSON.parse(result.stdout);
+    }
+    catch {
+        throw new JournalObservationUnavailableError("journal observer output was not JSON");
+    }
+    if (!Array.isArray(values)) {
+        throw new JournalObservationUnavailableError("journal observer output was not a list");
+    }
+    return values
+        .filter((value) => typeof value === "string")
+        .map((lastSync) => ({ journal: { lastSync } }));
+}
 /**
  * True when this event kind must pay for a fresh `listJournals()` read.
  *
@@ -527,7 +601,14 @@ async function contributeClientHealthUnbounded(kind, deps, failureReason) {
             }
             else {
                 try {
-                    const observed = latestJournalSyncTime((deps.journals ?? listJournals)());
+                    // A plain invocation (any command, `hq secrets exec` included) reads
+                    // the store in a heap-capped child. Sync commands have the store open
+                    // already and read in-process.
+                    const source = deps.journals ??
+                        (kind === "invocation"
+                            ? (deps.isolatedJournals ?? observeJournalsIsolated)
+                            : listJournals);
+                    const observed = latestJournalSyncTime(source());
                     if (observed !== null) {
                         journalLastSyncAt = observed;
                         observation.lastSyncAt = observed;
@@ -543,8 +624,20 @@ async function contributeClientHealthUnbounded(kind, deps, failureReason) {
                     observation.observedAt = now.toISOString();
                     persistJournalObservation(stateDir, observation);
                 }
-                catch {
-                    // Journal enumeration is best effort.
+                catch (error) {
+                    // Journal enumeration is best effort. When the isolated observer hit
+                    // its heap or time cap, keep the previous value but stamp the attempt
+                    // so the next invocation waits a full TTL instead of retrying a read
+                    // already known to fail on this machine.
+                    if (error instanceof JournalObservationUnavailableError) {
+                        observation.observedAt = now.toISOString();
+                        try {
+                            persistJournalObservation(stateDir, observation);
+                        }
+                        catch {
+                            // Best effort.
+                        }
+                    }
                 }
                 finally {
                     release();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.155",
+  "version": "5.345.156",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -114,11 +114,11 @@
     "*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}": "eslint --cache --no-error-on-unmatched-pattern"
   },
   "optionalDependencies": {
-    "@indigoai-us/hq-hook-win32-x64": "5.345.155",
-    "@indigoai-us/hq-hook-win32-arm64": "5.345.155",
-    "@indigoai-us/hq-hook-darwin-x64": "5.345.155",
-    "@indigoai-us/hq-hook-darwin-arm64": "5.345.155",
-    "@indigoai-us/hq-hook-linux-x64": "5.345.155",
-    "@indigoai-us/hq-hook-linux-arm64": "5.345.155"
+    "@indigoai-us/hq-hook-win32-x64": "5.345.156",
+    "@indigoai-us/hq-hook-win32-arm64": "5.345.156",
+    "@indigoai-us/hq-hook-darwin-x64": "5.345.156",
+    "@indigoai-us/hq-hook-darwin-arm64": "5.345.156",
+    "@indigoai-us/hq-hook-linux-x64": "5.345.156",
+    "@indigoai-us/hq-hook-linux-arm64": "5.345.156"
   }
 }