@quantiya/codevibe-codex-plugin 2.0.10 → 2.0.13

package/libexec/codex-hook-config.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const fs = require('fs');
+
+const OUR_HOOK_FILES = new Set([
+  'session-start.sh',
+  'user-prompt.sh',
+  'pre-tool-use.sh',
+  'permission-request.sh',
+  'post-tool-use.sh',
+  'stop.sh',
+]);
+
+function hookScriptPath(command) {
+  if (typeof command !== 'string') return null;
+  const match = command.trim().match(/^bash\s+(?:"([^"]+)"|'([^']+)'|(\S+))$/);
+  return match ? (match[1] || match[2] || match[3]) : null;
+}
+
+function isOurCommand(command) {
+  const scriptPath = hookScriptPath(command);
+  if (!scriptPath) return false;
+
+  const filename = scriptPath.slice(scriptPath.lastIndexOf('/') + 1);
+  if (!OUR_HOOK_FILES.has(filename) || !scriptPath.endsWith(`/hooks/${filename}`)) {
+    return false;
+  }
+
+  if (scriptPath.includes('/codevibe-codex-plugin/hooks/')) {
+    return true;
+  }
+
+  // Development links can use task-specific repository names rather than the
+  // canonical package directory. Keep this deliberately limited to CodeVibe's
+  // agent-worktree layout so an unrelated hook with the same filename survives.
+  return /\/\.agent-worktrees\/[^/]+\/codevibe-codex-[^/]+\/hooks\/[^/]+$/.test(scriptPath);
+}
+
+function stripOurHooksFromEntry(entry) {
+  if (!entry || typeof entry !== 'object' || !Array.isArray(entry.hooks)) {
+    return entry;
+  }
+  const filtered = entry.hooks.filter((hook) => !(hook && isOurCommand(hook.command)));
+  if (filtered.length === entry.hooks.length) return entry;
+  if (filtered.length === 0) return null;
+  return { ...entry, hooks: filtered };
+}
+
+function ownedCommands(entries) {
+  return entries
+    .flatMap((entry) => entry && typeof entry === 'object' && Array.isArray(entry.hooks)
+      ? entry.hooks
+      : [])
+    .map((hook) => hook && hook.command)
+    .filter(isOurCommand)
+    .sort();
+}
+
+function mergeHookConfig(existingObj, nextObj, existed = true) {
+  const existingHooks = existingObj && typeof existingObj === 'object'
+    && existingObj.hooks && typeof existingObj.hooks === 'object'
+    ? existingObj.hooks
+    : {};
+  const nextHooks = nextObj && typeof nextObj === 'object'
+    && nextObj.hooks && typeof nextObj.hooks === 'object'
+    ? nextObj.hooks
+    : {};
+
+  let allPresent = existed;
+  for (const key of Object.keys(nextHooks)) {
+    const existingEntries = Array.isArray(existingHooks[key]) ? existingHooks[key] : [];
+    const nextEntries = Array.isArray(nextHooks[key]) ? nextHooks[key] : [];
+    if (JSON.stringify(ownedCommands(existingEntries)) !== JSON.stringify(ownedCommands(nextEntries))) {
+      allPresent = false;
+      break;
+    }
+  }
+  if (allPresent) {
+    return { outcome: 'already_installed', config: existingObj };
+  }
+
+  const mergedHooks = { ...existingHooks };
+  for (const key of Object.keys(nextHooks)) {
+    const existingEntries = Array.isArray(existingHooks[key]) ? existingHooks[key] : [];
+    const cleanedExisting = existingEntries
+      .map(stripOurHooksFromEntry)
+      .filter((entry) => entry !== null && entry !== undefined);
+    const nextEntries = Array.isArray(nextHooks[key]) ? nextHooks[key] : [];
+    mergedHooks[key] = [...cleanedExisting, ...nextEntries];
+  }
+
+  return {
+    outcome: existed ? 'merged' : 'fresh_install',
+    config: existingObj && typeof existingObj === 'object'
+      ? { ...existingObj, hooks: mergedHooks }
+      : { hooks: mergedHooks },
+  };
+}
+
+function cleanHookConfig(existingObj) {
+  if (!existingObj || typeof existingObj !== 'object'
+    || !existingObj.hooks || typeof existingObj.hooks !== 'object') {
+    return existingObj;
+  }
+
+  const hooks = { ...existingObj.hooks };
+  for (const key of Object.keys(hooks)) {
+    if (!Array.isArray(hooks[key])) continue;
+    hooks[key] = hooks[key]
+      .map(stripOurHooksFromEntry)
+      .filter((entry) => entry !== null && entry !== undefined);
+  }
+  return { ...existingObj, hooks };
+}
+
+function writeAtomic(target, value) {
+  const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(value, null, 2));
+    fs.renameSync(temporary, target);
+  } catch (error) {
+    try { fs.unlinkSync(temporary); } catch {}
+    throw error;
+  }
+}
+
+function runMerge() {
+  const target = process.env.CV_EXISTING;
+  let existingObj = null;
+  let existed = false;
+  try {
+    if (fs.existsSync(target)) {
+      existed = true;
+      existingObj = JSON.parse(fs.readFileSync(target, 'utf8'));
+    }
+  } catch (error) {
+    process.stderr.write(`PARSE_EXISTING_FAILED:${error.message || String(error)}`);
+    return 2;
+  }
+
+  let nextObj;
+  try {
+    nextObj = JSON.parse(process.env.CV_NEW);
+  } catch (error) {
+    process.stderr.write(`PARSE_NEW_FAILED:${error.message || String(error)}`);
+    return 3;
+  }
+
+  const result = mergeHookConfig(existingObj, nextObj, existed);
+  if (result.outcome !== 'already_installed') {
+    try {
+      writeAtomic(target, result.config);
+    } catch (error) {
+      process.stderr.write(`WRITE_FAILED:${error.message || String(error)}`);
+      return 4;
+    }
+  }
+  process.stdout.write(`OUTCOME:${result.outcome}\n`);
+  return 0;
+}
+
+function runCleanup() {
+  const target = process.env.CV_HOOKS_FILE;
+  try {
+    const existingObj = JSON.parse(fs.readFileSync(target, 'utf8'));
+    writeAtomic(target, cleanHookConfig(existingObj));
+    return 0;
+  } catch (error) {
+    process.stderr.write(`CLEAN_FAILED:${error.message || String(error)}`);
+    return 1;
+  }
+}
+
+if (require.main === module) {
+  const action = process.argv[2];
+  const exitCode = action === 'merge'
+    ? runMerge()
+    : action === 'cleanup'
+      ? runCleanup()
+      : 64;
+  process.exit(exitCode);
+}
+
+module.exports = {
+  cleanHookConfig,
+  isOurCommand,
+  mergeHookConfig,
+};

package/libexec/companion-launcher

@@ -259,55 +259,10 @@ cleanup() {
         # Only remove if no other codevibe-codex sessions are running
         if [ "$(pgrep -f 'codevibe-codex' | wc -l)" -le 1 ]; then
             log "Removing CodeVibe hooks from $HOME/.codex/hooks.json"
-            # Cleanup mirrors install: same ownership predicate + the
-            # same INNER-hooks[] split so a matcher entry mixing user
-            # hooks with ours keeps the user hook. Same per-process
-            # tmp suffix avoids two concurrent cleanups racing.
-            if CV_HOOKS_FILE="$HOME/.codex/hooks.json" node -e '
-              const fs = require("fs");
-              const OUR_HOOK_FILES = new Set([
-                "session-start.sh",
-                "user-prompt.sh",
-                "pre-tool-use.sh",
-                "post-tool-use.sh",
-                "stop.sh",
-              ]);
-              const OWN_PATH_MARKER = "codevibe-codex-plugin/hooks/";
-              const isOurCommand = (command) => {
-                if (typeof command !== "string") return false;
-                if (command.indexOf(OWN_PATH_MARKER) === -1) return false;
-                for (const f of OUR_HOOK_FILES) {
-                  if (command.endsWith("/" + f)) return true;
-                }
-                return false;
-              };
-              const stripOurHooksFromEntry = (entry) => {
-                if (!entry || typeof entry !== "object" || !Array.isArray(entry.hooks)) return entry;
-                const filtered = entry.hooks.filter((h) => !(h && isOurCommand(h.command)));
-                if (filtered.length === entry.hooks.length) return entry;
-                if (filtered.length === 0) return null;
-                return { ...entry, hooks: filtered };
-              };
-              try {
-                const target = process.env.CV_HOOKS_FILE;
-                const data = JSON.parse(fs.readFileSync(target, "utf8"));
-                if (data && typeof data === "object" && data.hooks && typeof data.hooks === "object") {
-                  for (const k of Object.keys(data.hooks)) {
-                    if (Array.isArray(data.hooks[k])) {
-                      data.hooks[k] = data.hooks[k]
-                        .map(stripOurHooksFromEntry)
-                        .filter((entry) => entry !== null && entry !== undefined);
-                    }
-                  }
-                }
-                const tmp = target + "." + process.pid + "." + Date.now() + ".tmp";
-                fs.writeFileSync(tmp, JSON.stringify(data, null, 2));
-                fs.renameSync(tmp, target);
-              } catch (e) {
-                process.stderr.write("CLEAN_FAILED:" + (e && e.message ? e.message : String(e)));
-                process.exit(1);
-              }
-            ' 2>>"$LOG_FILE"; then
+            # The shared helper keeps install and cleanup ownership rules in
+            # lockstep, including task-named CodeVibe agent worktrees.
+            if CV_HOOKS_FILE="$HOME/.codex/hooks.json" \
+              node "$PLUGIN_DIR/libexec/codex-hook-config.js" cleanup 2>>"$LOG_FILE"; then
               :
             else
               log "WARN: failed to clean CodeVibe hooks from hooks.json (left as-is)"
@@ -539,9 +494,9 @@ _CV_HOOKS_REASON=""
 #    keeps the user hook (only the CodeVibe hooks get stripped, not
 #    the surrounding entry).
 #
-#  - Ownership predicate: path-prefix `codevibe-codex-plugin/hooks/`
-#    AND filename tail in the allow-list of our hook script names.
-#    Rejects user paths like /Users/codevibe-codex/foo.sh.
+#  - Ownership predicate: canonical package paths or CodeVibe's strict
+#    `.agent-worktrees/<agent>/codevibe-codex-*/hooks/` layout, plus a
+#    filename allowlist. Rejects unrelated user hook paths.
 #
 #  - Per-process tmp file (.<pid>.<time>.tmp): two concurrent installs
 #    won't clobber each other's intermediate state. Final rename is
@@ -555,112 +510,8 @@ _CV_HOOKS_REASON=""
 GENERATED_HOOKS=$(generate_hooks_json)
 if INSTALLER_OUTPUT=$(CV_EXISTING="$CODEX_HOOKS_FILE" \
                      CV_NEW="$GENERATED_HOOKS" \
-                     node -e '
-  const fs = require("fs");
-  const OUR_HOOK_FILES = new Set([
-    "session-start.sh",
-    "user-prompt.sh",
-    "pre-tool-use.sh",
-    "permission-request.sh",
-    "post-tool-use.sh",
-    "stop.sh",
-  ]);
-  const OWN_PATH_MARKER = "codevibe-codex-plugin/hooks/";
-  const isOurCommand = (command) => {
-    if (typeof command !== "string") return false;
-    if (command.indexOf(OWN_PATH_MARKER) === -1) return false;
-    for (const f of OUR_HOOK_FILES) {
-      if (command.endsWith("/" + f)) return true;
-    }
-    return false;
-  };
-  // Strip our hooks from a single matcher entrys inner hooks[] array.
-  // Returns null if NO non-owned hooks remain (whole entry should be
-  // dropped); otherwise returns a new entry with only the user-owned
-  // hooks. Returns the original entry unchanged if it contains none of
-  // ours (preserves identity for unrelated entries).
-  const stripOurHooksFromEntry = (entry) => {
-    if (!entry || typeof entry !== "object" || !Array.isArray(entry.hooks)) {
-      return entry;
-    }
-    const filtered = entry.hooks.filter((h) => !(h && isOurCommand(h.command)));
-    if (filtered.length === entry.hooks.length) return entry;
-    if (filtered.length === 0) return null;
-    return { ...entry, hooks: filtered };
-  };
-  const ownedCommands = (entries) => entries
-    .flatMap((entry) => entry && typeof entry === "object" && Array.isArray(entry.hooks)
-      ? entry.hooks
-      : [])
-    .map((hook) => hook && hook.command)
-    .filter(isOurCommand)
-    .sort();
-
-  let existingObj = null;
-  let existed = false;
-  try {
-    if (fs.existsSync(process.env.CV_EXISTING)) {
-      existed = true;
-      existingObj = JSON.parse(fs.readFileSync(process.env.CV_EXISTING, "utf8"));
-    }
-  } catch (e) {
-    process.stderr.write("PARSE_EXISTING_FAILED:" + (e && e.message ? e.message : String(e)));
-    process.exit(2);
-  }
-  let nextObj;
-  try {
-    nextObj = JSON.parse(process.env.CV_NEW);
-  } catch (e) {
-    process.stderr.write("PARSE_NEW_FAILED:" + (e && e.message ? e.message : String(e)));
-    process.exit(3);
-  }
-
-  const existingHooks = (existingObj && typeof existingObj === "object" &&
-    existingObj.hooks && typeof existingObj.hooks === "object") ? existingObj.hooks : {};
-  const nextHooks = (nextObj && typeof nextObj === "object" &&
-    nextObj.hooks && typeof nextObj.hooks === "object") ? nextObj.hooks : {};
-  let allPresent = existed;
-  for (const k of Object.keys(nextHooks)) {
-    const existingArr = Array.isArray(existingHooks[k]) ? existingHooks[k] : [];
-    const nextArr = Array.isArray(nextHooks[k]) ? nextHooks[k] : [];
-    if (JSON.stringify(ownedCommands(existingArr)) !== JSON.stringify(ownedCommands(nextArr))) {
-      allPresent = false;
-      break;
-    }
-  }
-  if (allPresent) {
-    process.stdout.write("OUTCOME:already_installed\n");
-    process.exit(0);
-  }
-
-  const mergedHooks = { ...existingHooks };
-  for (const k of Object.keys(nextHooks)) {
-    const existingArr = Array.isArray(existingHooks[k]) ? existingHooks[k] : [];
-    const cleanedExisting = existingArr
-      .map(stripOurHooksFromEntry)
-      .filter((entry) => entry !== null && entry !== undefined);
-    const nextArr = Array.isArray(nextHooks[k]) ? nextHooks[k] : [];
-    mergedHooks[k] = [...cleanedExisting, ...nextArr];
-  }
-
-  const out = (existingObj && typeof existingObj === "object")
-    ? { ...existingObj, hooks: mergedHooks }
-    : { hooks: mergedHooks };
-  const outcome = existed ? "merged" : "fresh_install";
-  const target = process.env.CV_EXISTING;
-  // Per-process tmp suffix avoids two concurrent installs both writing
-  // ${target}.tmp and one mvs the others half-written file.
-  const tmp = target + "." + process.pid + "." + Date.now() + ".tmp";
-  try {
-    fs.writeFileSync(tmp, JSON.stringify(out, null, 2));
-    fs.renameSync(tmp, target);
-  } catch (e) {
-    try { fs.unlinkSync(tmp); } catch {}
-    process.stderr.write("WRITE_FAILED:" + (e && e.message ? e.message : String(e)));
-    process.exit(4);
-  }
-  process.stdout.write("OUTCOME:" + outcome + "\n");
-' 2>>"$LOG_FILE"); then
+                     node "$PLUGIN_DIR/libexec/codex-hook-config.js" merge \
+                     2>>"$LOG_FILE"); then
   INSTALLER_RC=0
 else
   INSTALLER_RC=$?

package/node_modules/@quantiya/codevibe-core/dist/appsync/__tests__/appsync-client-flag-locator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@quantiya/codevibe-core/dist/appsync/__tests__/dispose-watcher-socket.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@quantiya/codevibe-core/dist/appsync/appsync-client.d.ts

@@ -1,8 +1,30 @@
+import WebSocket from 'ws';
 import { CreateEventInput, CreateSessionInput, UpdateSessionInput, UpdateEventStatusInput, Event, Session, EventSource, DeviceKey, GrantSessionKeyInput, UpdateReviewerPolicyInput, UserReviewerPolicySnapshot } from '../types';
 import type { PostDecisionAction } from '../orchestration-shell/types';
+import type { InvocationUsageSnapshot } from '../reviewer/token-usage';
 import type { CreateTaskGroupInput, CreateTaskGroupResult, SubmitMergeGateVerdictInput, SubmitMergeGateVerdictResult, SubmitTrackVerificationOutcomeInput, SubmitTrackVerificationOutcomeResult, ClaimGroupDecisionInput, ClaimGroupDecisionResult } from '../local-executor/task-group-types';
 import type { ReviewerVerdict, ReviewerRole, AgentKind as ReviewerAgentKind } from '../reviewer/types';
 import type { PlannerDecision } from '../planner/types';
+/**
+ * Dispose a watcher/subscription WebSocket without crashing the process
+ * (#657 D-1 fix-forward — the clean-quit session/admission leak).
+ *
+ * `ws.close()` on a still-CONNECTING socket aborts the handshake and emits an
+ * ASYNC 'error' ("WebSocket was closed before the connection was established")
+ * on a LATER tick. Every prior disposal site paired `close(1000)` with
+ * `removeAllListeners()` — in either order — so that late emission always
+ * found a listener-less socket and crashed Node with an unhandled 'error'
+ * mid-teardown, BEFORE `retireHostedSession` could land the session INACTIVE
+ * mutation. Net effect: every clean `/quit` whose Class B watcher (or any
+ * other watcher) was mid-(re)connect leaked an ACTIVE session row AND an
+ * `activeSessionAdmissionCount` slot (#101 class), hard-capping the
+ * 19-scenario GA baseline after exactly the free headroom.
+ *
+ * Order is load-bearing: strip stale handlers FIRST, re-arm a swallow-all
+ * 'error' handler, THEN close. Exported for the regression test only — not
+ * part of the public SDK surface.
+ */
+export declare function disposeWatcherSocket(ws: WebSocket, subscriptionId?: string): void;
 /**
  * One assigned reviewer seat returned by `getInReviewAssignments`. Mirrors the
  * engine `InReviewAssignment` serde (camelCase) in
@@ -101,6 +123,24 @@ export interface RecordExecutionEventInput {
     /** Free-form JSON; encrypted before crossing AppSync. */
     payload: unknown;
     dedupKeyHex: string;
+    /**
+     * O1 C1 (#652) §3.1 item 3 — the plaintext flag-target locator, REQUIRED
+     * when `kind = 'FLAG_BAD_APPROVAL'` and absent otherwise (non-flag events
+     * stay byte-identical to the pre-O1-C1 wire). Row COORDINATES only — zero
+     * content. Field names mirror the Rust handler DTO
+     * (`RecordExecutionEventInput` in core-rs `types.rs`, camelCase serde) —
+     * the wire-shape source of truth. The server rejects a request whose
+     * `taskId` ≠ `flaggedTaskId` (the per-task dedup-partition pin).
+     */
+    flaggedTaskId?: string;
+    /**
+     * The flagged row's audit-table sort key — the zero-padded 16-digit
+     * `seqNum` string exactly as surfaced by `queryAudit`'s additive
+     * `AuditEntryWireRow.seqNum` projection.
+     */
+    flaggedSeqNum?: string;
+    /** The flagged entry's `entry_id` (also the dedup-key derivation input). */
+    flaggedEntryId?: string;
 }
 /**
  * PHASE-CP-1-F.1 Part A (LOCK L2) — tolerant `AWSJSON!` object read.
@@ -180,8 +220,29 @@ export interface TaskReviewSummaryDurations {
 }
 export interface TaskReviewSummaryTokenUsage {
     knownTotal?: number;
+    knownInput?: number;
+    knownOutput?: number;
+    knownCachedInput?: number;
     availability: string;
     unavailableRoles: string[];
+    invocations?: TaskReviewSummaryTokenInvocation[];
+}
+export interface TaskReviewSummaryTokenInvocation {
+    role: string;
+    agent: string;
+    taskId?: string;
+    trackIndex?: number;
+    round?: number;
+    gateId?: string;
+    seatId?: number;
+    reviewerRole?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedInputTokens?: number;
+    totalTokens?: number;
+    elapsedMs?: number;
+    availability: string;
+    unavailableReason?: string;
 }
 /** One round in the per-round summary (decrypted). */
 export interface TaskReviewSummaryRound {
@@ -862,6 +923,7 @@ export declare class AppSyncClient {
         sessionId: string;
         roundNumber: number;
         rawOutput: string;
+        usage?: InvocationUsageSnapshot;
     }, sessionKeyBase64: string): Promise<{
         gateId: string;
         workflowState: string;

package/node_modules/@quantiya/codevibe-core/dist/auth/__tests__/keychain-cli-nudge.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@quantiya/codevibe-core/dist/auth/keychain-cli.d.ts

@@ -4,3 +4,11 @@
  * the raw process argv (node, script, "keychain", subcommand, flags…).
  */
 export declare function runKeychainCli(argv: string[]): Promise<number>;
+/**
+ * Advisory nudge for `codevibe login` / `codevibe status` (GA follow-up to #642):
+ * when this machine still holds file-backed credentials, has NOT migrated, and the
+ * OS keyring is actually usable, print the `keychain migrate` suggestion. Purely
+ * additive output — never throws, never mutates state, silent on any ambiguity
+ * (see migrate-nudge.ts invariants).
+ */
+export declare function maybePrintKeychainMigrationNudge(print?: (line: string) => void): Promise<void>;