@pushary/agent-hooks 0.89.11 → 0.89.13

package/CHANGELOG.md

@@ -1,5 +1,60 @@
 # Changelog
 
+## 0.89.13
+
+### Synced transcripts survive large turns and restarts safely
+
+Oversized file reads and diffs are shortened before encryption instead of being
+rejected by the server, with the removed UTF-8 byte count recorded in the turn.
+Stable HMAC identifiers prevent transcript contents leaking through record ids,
+and a resumed session reuses its persisted encryption key rather than conflicting
+with the key already registered for that session.
+
+Transcript recipients are now pinned on first use and later key changes stop sync
+until the user explicitly runs `pushary transcripts trust --rotate`. First use
+also fails closed when that pin cannot be stored, so no session key is wrapped to
+an unrecorded recipient. New sessions can independently wrap their key for the
+owner's phone and an optional audited compliance-recovery recipient; installations
+without one remain compatible.
+
+## 0.89.12
+
+### Phone control installs as a native service, without a VM
+
+Fresh setup enables phone-start when a supported provider and the operating
+system's own per-user service manager are available: launchd on macOS, systemd
+on Linux, and Task Scheduler on Windows. Existing installs keep their stored
+choice. Service replacement is transactional, verifies the new process before
+committing, and restores the previous running or stopped state on failure.
+
+Claude Code, Codex and Gemini sessions started from the phone now use the same
+supervised control path. Setup checks both the local heartbeat and the server's
+view of the machine before calling control ready.
+
+### Fresh and partial installs repair themselves
+
+Setup now verifies every global command, its local JavaScript imports, and the
+Cursor and VS Code runtime assets before reusing an installed version. A
+same-version package missing any of them is reinstalled instead of failing the
+same setup forever. Fresh installs also cover Codex on Windows and recover from
+partially configured providers without disturbing unrelated settings.
+
+### The CLI and macOS app keep their own wiring
+
+Cursor setup writes one gate per event even when the other installer ran first.
+`pushary clean` removes the CLI gate while preserving the app's bridge, and
+`pushary doctor` validates the MCP entry from the installer that actually wired
+Cursor. This keeps mixed CLI/app machines working and avoids false repair
+failures on app-only installs.
+
+### Transcript control works in every shell
+
+Setup discloses encrypted transcript sync and its audited compliance-recovery
+path before enabling it for a new install; older installs remain off until setup
+runs again. `pushary setup --transcripts on|off` now provides the same persistent
+choice in POSIX shells, PowerShell and Command Prompt. The existing
+`PUSHARY_TRANSCRIPTS` environment override remains compatible.
+
 ## 0.89.11
 
 ### Phone-spawned Codex and Gemini sessions record their conversation again

package/README.md

@@ -4,7 +4,7 @@
 [![npm downloads](https://img.shields.io/npm/dm/@pushary/agent-hooks.svg)](https://www.npmjs.com/package/@pushary/agent-hooks)
 [![license](https://img.shields.io/npm/l/@pushary/agent-hooks.svg)](./LICENSE)
 
-Push notifications, questions, and permission approvals for AI coding agents. Get a push when your agent finishes work, answer its questions from your phone, and approve risky commands before they run. Works with Claude Code, Codex, Cursor, VS Code, Gemini CLI, and Hermes.
+Push notifications, questions, and permission approvals for AI agents. Get a push when your agent finishes work, answer its questions from your phone, and approve risky commands before they run. Works with Claude Code, Codex, Cursor, VS Code, OpenCode, Gemini CLI, and Hermes.
 
 Your agent froze waiting for a yes. This is how it reaches you.
 
@@ -110,6 +110,7 @@ npx @pushary/agent-hooks@latest doctor
 | Gemini CLI | yes | yes | yes |
 | Hermes | yes | yes | yes |
 | VS Code | yes | yes | yes |
+| OpenCode | yes | yes | yes |
 
 Any other MCP client can use notify and ask by pointing at the Pushary MCP endpoint directly.
 
@@ -182,7 +183,7 @@ failing closed would let one malformed download silence every hook on the machin
      asserts this list matches it. Do not edit one without the other. -->
 
 ```
-setup        Configure Claude Code, Codex, Gemini CLI, Hermes, Cursor, or VS Code with Pushary
+setup        Configure Claude Code, Codex, Gemini CLI, Hermes, Cursor, VS Code, or OpenCode with Pushary
 claude       Run Claude Code through Pushary, reachable from your phone even when idle
 daemon       Keep this machine reachable so your phone can START a new session
 status       One screen: which key is in force, whether the server accepts it, what can receive an approval
@@ -199,6 +200,7 @@ stats        Show the approval moments your agents hit while not connected
 suggestions  List rules mined from your own approvals
 upgrade      Update the globally installed hooks to the latest version
 hook         Run as a PreToolUse hook (reads stdin, writes stdout)
+transcripts  Show or re-trust the keys this machine seals transcripts to
 ```
 
 Run `pushary <command> --help` for one command's options.

package/dist/bin/pushary-bell-hook.js

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import {
   handleBell
-} from "../chunk-TRVIRETT.js";
+} from "../chunk-C56VHSXU.js";
 import {
   readHookInput
 } from "../chunk-6CUUA7HO.js";
-import "../chunk-3CUDMTL4.js";
+import "../chunk-NBDU3R3G.js";
 import "../chunk-BC3VCZ3E.js";
-import "../chunk-IUWRVTQK.js";
-import "../chunk-XX2V4QS5.js";
+import "../chunk-ANMHIZZY.js";
+import "../chunk-4LL6LG5X.js";
 import "../chunk-2UMNXADU.js";
-import "../chunk-X6RXX2NF.js";
+import "../chunk-QINYXLA5.js";
 
 // bin/pushary-bell-hook.ts
 var main = async () => {

package/dist/bin/pushary-bell.js

@@ -5,38 +5,38 @@ import {
   liveAgentCount,
   ring,
   upgradeThreshold
-} from "../chunk-TRVIRETT.js";
+} from "../chunk-C56VHSXU.js";
 import {
   guardBinary
-} from "../chunk-SYUIXXQW.js";
-import "../chunk-X4ZUUFKV.js";
+} from "../chunk-VF3RTVWY.js";
+import "../chunk-L4ZCFMWW.js";
 import {
   claudeSettings
-} from "../chunk-QA72MKIT.js";
+} from "../chunk-3YGGEDJK.js";
 import {
   createIo
 } from "../chunk-5RUIFDTP.js";
-import "../chunk-3CUDMTL4.js";
 import {
   parseFlags
 } from "../chunk-GMXKITVA.js";
 import {
   exitOnHelpFlag
-} from "../chunk-LURY4WNF.js";
-import "../chunk-3XTFX4CL.js";
-import "../chunk-BC3VCZ3E.js";
+} from "../chunk-WHDSJ6PD.js";
+import "../chunk-GMJDQDXU.js";
 import "../chunk-DINDL2CF.js";
-import "../chunk-IUWRVTQK.js";
+import "../chunk-NBDU3R3G.js";
+import "../chunk-BC3VCZ3E.js";
 import "../chunk-7QLSKOSU.js";
 import {
   EXIT
 } from "../chunk-KZERVKTD.js";
+import "../chunk-ANMHIZZY.js";
 import {
   readJsonSafe,
   writeJsonAtomic
-} from "../chunk-XX2V4QS5.js";
+} from "../chunk-4LL6LG5X.js";
 import "../chunk-2UMNXADU.js";
-import "../chunk-X6RXX2NF.js";
+import "../chunk-QINYXLA5.js";
 
 // src/bell/install.ts
 import { join } from "path";

package/dist/bin/pushary-claude.js

@@ -1,24 +1,35 @@
 #!/usr/bin/env node
+import {
+  changedRecipientsMessage,
+  loadPin,
+  savePin,
+  verifyRecipients
+} from "../chunk-YKLCWWEI.js";
 import {
   ensureDaemonRunning
-} from "../chunk-3SQYKLBW.js";
+} from "../chunk-7JZCADBR.js";
 import {
   buildTranscriptRecords,
   decodePublicKey,
-  fetchAccountPublicKey,
   generateSessionKey,
-  uploadTranscriptRecords,
   wrapSessionKey
-} from "../chunk-IUN6VOKV.js";
+} from "../chunk-4IPSMEGT.js";
+import {
+  fetchTranscriptRecipients,
+  uploadTranscriptRecords
+} from "../chunk-QZCFVWA7.js";
+import {
+  transcriptsEnabled
+} from "../chunk-M3UABYRT.js";
 import {
   startProcessOwnership,
   withSpawnProcessOwnership
-} from "../chunk-TEZ2FZD6.js";
+} from "../chunk-CBGGUEKE.js";
 import {
   needsShell,
   spawnClaude
 } from "../chunk-XHKBHWLX.js";
-import "../chunk-X4ZUUFKV.js";
+import "../chunk-L4ZCFMWW.js";
 import {
   isDeferAnswer
 } from "../chunk-YHG74UFF.js";
@@ -27,7 +38,7 @@ import {
   getPolicy,
   repoKeyFor,
   reportEvent
-} from "../chunk-FXIL7RCL.js";
+} from "../chunk-OX35BSPV.js";
 import {
   DEFAULT_SESSION,
   askUser,
@@ -41,21 +52,24 @@ import {
   waitForAnswer
 } from "../chunk-JHJHCMAF.js";
 import {
+  UNNAMED_ACTION,
   deriveToolTarget,
   describeToolCall,
   scopePathFor
-} from "../chunk-TG3T3M4K.js";
+} from "../chunk-N4QJ3CLX.js";
 import {
   getMachineId
-} from "../chunk-DKWM5T3P.js";
-import "../chunk-QA72MKIT.js";
+} from "../chunk-JTBDBKHU.js";
+import "../chunk-3YGGEDJK.js";
 import "../chunk-DINDL2CF.js";
+import "../chunk-NBDU3R3G.js";
+import "../chunk-BC3VCZ3E.js";
 import "../chunk-BSZYIAZL.js";
 import "../chunk-SAF6HGAA.js";
-import "../chunk-IUWRVTQK.js";
 import "../chunk-7QLSKOSU.js";
 import "../chunk-KZERVKTD.js";
-import "../chunk-XX2V4QS5.js";
+import "../chunk-ANMHIZZY.js";
+import "../chunk-4LL6LG5X.js";
 import {
   getApiKey,
   getBaseUrl
@@ -63,7 +77,7 @@ import {
 import {
   KILL_REASON,
   resolveGate
-} from "../chunk-X6RXX2NF.js";
+} from "../chunk-QINYXLA5.js";
 
 // src/wrapper/claudeBinary.ts
 import { statSync } from "fs";
@@ -139,18 +153,88 @@ var runLocalPassthrough = (binary, args2) => {
 import { basename } from "path";
 
 // src/transcript-sync.ts
+import { homedir as homedir2 } from "os";
+import { join as join3, resolve } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+
+// src/transcript-session-key.ts
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync as statSync2, writeFileSync } from "fs";
 import { homedir } from "os";
-import { join as join2, resolve } from "path";
-import { existsSync, readFileSync } from "fs";
-var transcriptsEnabled = () => process.env.PUSHARY_TRANSCRIPTS === "1";
+import { join as join2 } from "path";
+var sessionDir = () => process.env.PUSHARY_SESSION_KEY_DIR?.trim() || join2(homedir(), ".pushary", "sessions");
+var SESSION_KEY_TTL_MS = 48 * 60 * 60 * 1e3;
+var SAFE_SESSION_ID = /^[A-Za-z0-9._-]{1,128}$/;
+var fileFor = (sessionId) => SAFE_SESSION_ID.test(sessionId) ? join2(sessionDir(), `${sessionId}.json`) : null;
+var loadSessionKey = (sessionId) => {
+  const path = fileFor(sessionId);
+  if (!path || !existsSync(path)) return null;
+  try {
+    if (Date.now() - statSync2(path).mtimeMs > SESSION_KEY_TTL_MS) return null;
+    const raw = JSON.parse(readFileSync(path, "utf-8"));
+    const key = typeof raw.sessionKey === "string" ? Buffer.from(raw.sessionKey, "base64") : null;
+    if (!key || key.length !== 32) return null;
+    return {
+      sessionKey: new Uint8Array(key),
+      wrappedKey: typeof raw.wrappedKey === "string" ? raw.wrappedKey : null,
+      providerWrappedKey: typeof raw.providerWrappedKey === "string" ? raw.providerWrappedKey : null,
+      providerKeyId: typeof raw.providerKeyId === "string" ? raw.providerKeyId : null,
+      keyUploaded: raw.keyUploaded === true
+    };
+  } catch {
+    return null;
+  }
+};
+var saveSessionKey = (sessionId, value) => {
+  const path = fileFor(sessionId);
+  if (!path) return;
+  try {
+    mkdirSync(sessionDir(), { recursive: true, mode: 448 });
+    writeFileSync(
+      path,
+      JSON.stringify({
+        sessionKey: Buffer.from(value.sessionKey).toString("base64"),
+        wrappedKey: value.wrappedKey,
+        providerWrappedKey: value.providerWrappedKey,
+        providerKeyId: value.providerKeyId,
+        keyUploaded: value.keyUploaded
+      }),
+      { mode: 384 }
+    );
+  } catch {
+  }
+};
+var sweepStaleSessionKeys = (now = Date.now()) => {
+  const dir = sessionDir();
+  if (!existsSync(dir)) return 0;
+  let removed = 0;
+  try {
+    for (const name of readdirSync(dir)) {
+      if (!name.endsWith(".json")) continue;
+      const path = join2(dir, name);
+      try {
+        if (now - statSync2(path).mtimeMs <= SESSION_KEY_TTL_MS) continue;
+        rmSync(path, { force: true });
+        removed += 1;
+      } catch {
+      }
+    }
+  } catch {
+    return removed;
+  }
+  return removed;
+};
+
+// src/transcript-sync.ts
 var claudeTranscriptPath = (cwd, sessionId) => {
   const projectId = resolve(cwd).replace(/[^a-zA-Z0-9-]/g, "-");
-  const configDir = process.env.CLAUDE_CONFIG_DIR || join2(homedir(), ".claude");
-  return join2(configDir, "projects", projectId, `${sessionId}.jsonl`);
+  const configDir = process.env.CLAUDE_CONFIG_DIR || join3(homedir2(), ".claude");
+  return join3(configDir, "projects", projectId, `${sessionId}.jsonl`);
 };
 var createSyncState = () => ({
   sessionKey: null,
   wrappedKey: null,
+  providerWrappedKey: null,
+  providerKeyId: null,
   seen: /* @__PURE__ */ new Set(),
   keyUploaded: false,
   keyRejected: false
@@ -159,70 +243,163 @@ var syncTick = async (lines, state, uploader, sessionId, machineId) => {
   if (state.keyRejected) return state;
   let sessionKey = state.sessionKey;
   let wrappedKey = state.wrappedKey;
+  let providerWrappedKey = state.providerWrappedKey;
+  let providerKeyId = state.providerKeyId;
   if (!sessionKey) {
-    const publicKey = await uploader.fetchAccountPublicKey();
-    if (!publicKey) return state;
+    const recipients = await uploader.fetchTranscriptRecipients();
+    if (!recipients) return state;
     sessionKey = generateSessionKey();
-    wrappedKey = wrapSessionKey(sessionKey, decodePublicKey(publicKey));
+    wrappedKey = wrapSessionKey(sessionKey, decodePublicKey(recipients.phonePublicKey));
+    if (recipients.provider) {
+      providerWrappedKey = wrapSessionKey(sessionKey, decodePublicKey(recipients.provider.publicKey));
+      providerKeyId = recipients.provider.keyId;
+    }
   }
   const built = buildTranscriptRecords(lines, sessionKey, state.seen);
   if (built.records.length === 0) {
-    return { ...state, sessionKey, wrappedKey, seen: built.seen };
+    return { ...state, sessionKey, wrappedKey, providerWrappedKey, providerKeyId, seen: built.seen };
+  }
+  const seen = new Set(state.seen);
+  let keyUploaded = state.keyUploaded;
+  let keyRejected = false;
+  let rejected = 0;
+  for (const chunk of chunkRecords(built.records)) {
+    const result = await uploader.uploadRecords({
+      sessionId,
+      machineId,
+      dataEncryptionKey: keyUploaded ? void 0 : wrappedKey ?? void 0,
+      providerWrappedSessionKey: keyUploaded ? void 0 : providerWrappedKey ?? void 0,
+      providerKeyId: keyUploaded ? void 0 : providerKeyId ?? void 0,
+      records: chunk
+    });
+    keyUploaded = keyUploaded || result.keyRegistered;
+    if (result.keyConflict) {
+      keyRejected = true;
+      break;
+    }
+    if (!result.ok) break;
+    for (const id of result.settledIds ?? chunk.map((r) => r.localId)) seen.add(id);
+    rejected += result.rejectedIds.length;
+  }
+  if (rejected > 0) {
+    process.stderr.write(`[pushary] transcript: ${rejected} record${rejected === 1 ? "" : "s"} could not be stored and will not be retried.
+`);
   }
-  const result = await uploader.uploadRecords({
-    sessionId,
-    machineId,
-    dataEncryptionKey: state.keyUploaded ? void 0 : wrappedKey ?? void 0,
-    records: built.records
-  });
   return {
     sessionKey,
     wrappedKey,
-    seen: result.ok ? built.seen : state.seen,
-    keyUploaded: state.keyUploaded || result.keyRegistered,
-    keyRejected: result.keyConflict
+    providerWrappedKey,
+    providerKeyId,
+    seen,
+    keyUploaded,
+    keyRejected
   };
 };
+var MAX_RECORDS_PER_BATCH = 200;
+var MAX_BATCH_BYTES = 3e6;
+var chunkRecords = (records) => {
+  const chunks = [];
+  let current = [];
+  let bytes = 0;
+  for (const record of records) {
+    const size = record.content.length;
+    if (current.length > 0 && (current.length >= MAX_RECORDS_PER_BATCH || bytes + size > MAX_BATCH_BYTES)) {
+      chunks.push(current);
+      current = [];
+      bytes = 0;
+    }
+    current.push(record);
+    bytes += size;
+  }
+  if (current.length > 0) chunks.push(current);
+  return chunks;
+};
 var readLines = (path) => {
   try {
-    return existsSync(path) ? readFileSync(path, "utf-8").split("\n") : [];
+    return existsSync2(path) ? readFileSync2(path, "utf-8").split("\n") : [];
   } catch {
     return [];
   }
 };
+var IDLE_CEILING_MS = 6e4;
+var nextInterval = (previousMs, idle, baseMs, maxMs) => idle ? Math.min(previousMs * 2, maxMs) : baseMs;
 var startTranscriptSync = (opts) => {
+  let warnedAboutRecipients = false;
+  const fetchPinnedRecipients = async () => {
+    const offer = await fetchTranscriptRecipients(opts.apiKey);
+    if (!offer) return null;
+    const verdict = verifyRecipients(offer, loadPin());
+    if (verdict.kind === "first-use" && !savePin(verdict.pin)) return null;
+    if (verdict.kind === "changed") {
+      if (!warnedAboutRecipients) {
+        warnedAboutRecipients = true;
+        process.stderr.write(`${changedRecipientsMessage(verdict, offer)}
+`);
+      }
+      return null;
+    }
+    return offer;
+  };
   const uploader = {
-    fetchAccountPublicKey: () => fetchAccountPublicKey(opts.apiKey),
+    fetchTranscriptRecipients: fetchPinnedRecipients,
     uploadRecords: (params) => uploadTranscriptRecords(opts.apiKey, params)
   };
   const path = claudeTranscriptPath(opts.cwd, opts.sessionId);
-  let state = createSyncState();
+  const persisted = loadSessionKey(opts.sessionId);
+  let state = persisted ? { ...createSyncState(), ...persisted } : createSyncState();
+  sweepStaleSessionKeys();
+  let persistedUploaded = persisted?.keyUploaded ?? false;
   let running = true;
   let inFlight = false;
   const tick = async () => {
     if (!running || inFlight) return;
     inFlight = true;
     try {
+      const before = state.sessionKey;
       state = await syncTick(readLines(path), state, uploader, opts.sessionId, opts.machineId);
+      if (state.sessionKey && (before !== state.sessionKey || state.keyUploaded !== persistedUploaded)) {
+        persistedUploaded = state.keyUploaded;
+        saveSessionKey(opts.sessionId, {
+          sessionKey: state.sessionKey,
+          wrappedKey: state.wrappedKey,
+          providerWrappedKey: state.providerWrappedKey,
+          providerKeyId: state.providerKeyId,
+          keyUploaded: state.keyUploaded
+        });
+      }
     } catch {
     } finally {
       inFlight = false;
     }
   };
-  const timer = setInterval(() => void tick(), opts.intervalMs ?? 3e3);
-  if (typeof timer.unref === "function") timer.unref();
+  const baseIntervalMs = opts.intervalMs ?? 3e3;
+  const maxIntervalMs = Math.max(baseIntervalMs, IDLE_CEILING_MS);
+  let timer;
+  const schedule = (delayMs) => {
+    if (!running) return;
+    timer = setTimeout(() => {
+      void (async () => {
+        const before = state.sessionKey;
+        await tick();
+        const idle = state.sessionKey === null && before === null;
+        schedule(nextInterval(delayMs, idle, baseIntervalMs, maxIntervalMs));
+      })();
+    }, delayMs);
+    if (typeof timer.unref === "function") timer.unref();
+  };
   void tick();
+  schedule(baseIntervalMs);
   return () => {
     running = false;
-    clearInterval(timer);
+    if (timer) clearTimeout(timer);
   };
 };
 
 // src/wrapper/sdkLoader.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
 import { pathToFileURL } from "url";
 var userMessage = (text) => ({
   type: "user",
@@ -232,8 +409,8 @@ var userMessage = (text) => ({
 var SDK_VERSION = "0.3.207";
 var SDK_PACKAGE = "@anthropic-ai/claude-agent-sdk";
 var SDK_SPEC = `${SDK_PACKAGE}@${SDK_VERSION}`;
-var sdkCacheDir = () => process.env.PUSHARY_REMOTE_SDK_DIR?.trim() || join3(homedir2(), ".pushary", "remote-sdk");
-var cachedSdkEntry = () => join3(sdkCacheDir(), "node_modules", "@anthropic-ai", "claude-agent-sdk", "sdk.mjs");
+var sdkCacheDir = () => process.env.PUSHARY_REMOTE_SDK_DIR?.trim() || join4(homedir3(), ".pushary", "remote-sdk");
+var cachedSdkEntry = () => join4(sdkCacheDir(), "node_modules", "@anthropic-ai", "claude-agent-sdk", "sdk.mjs");
 var importSdk = async (specifierOrUrl) => {
   try {
     const mod = await import(specifierOrUrl);
@@ -248,7 +425,7 @@ var loadClaudeSdk = async () => {
   const fromResolution = await importSdk(SDK_PACKAGE);
   if (fromResolution) return fromResolution;
   const entry = cachedSdkEntry();
-  if (existsSync2(entry)) return importSdk(pathToFileURL(entry).href);
+  if (existsSync3(entry)) return importSdk(pathToFileURL(entry).href);
   return null;
 };
 var ensureClaudeSdk = async (log) => {
@@ -256,10 +433,10 @@ var ensureClaudeSdk = async (log) => {
   if (present) return present;
   const dir = sdkCacheDir();
   try {
-    mkdirSync(dir, { recursive: true });
-    const pkgJson = join3(dir, "package.json");
-    if (!existsSync2(pkgJson)) {
-      writeFileSync(pkgJson, `${JSON.stringify({ name: "pushary-remote-sdk", private: true })}
+    mkdirSync2(dir, { recursive: true });
+    const pkgJson = join4(dir, "package.json");
+    if (!existsSync3(pkgJson)) {
+      writeFileSync2(pkgJson, `${JSON.stringify({ name: "pushary-remote-sdk", private: true })}
 `);
     }
   } catch {
@@ -486,7 +663,7 @@ var createRemoteApprover = (deps) => {
       let question;
       try {
         question = await askUser2(deps.apiKey, {
-          question: `Allow ${description}?`,
+          question: `Allow ${description || UNNAMED_ACTION}?`,
           type: "confirm",
           context: `Your agent wants to run this in ${deps.projectName} (you are away)`,
           agentName: `Claude Code - ${deps.projectName}`,