chainlesschain 0.164.0 → 0.165.2

package/src/runtime/headless-runner.js

@@ -1460,6 +1460,8 @@ async function runAgentHeadlessInWorkspace(
   if (!hermeticExecution) {
     try {
       approvalGate = await getApprovalGate();
+      approvalGate =
+        approvalGate?.createSessionScope?.(sessionId) || approvalGate;
       if (approvalGate && (options.permissionMode || "default") === "auto") {
         // autoMode.decisions: user-configured riskLevel → allow/ask/deny
         // classifier. Only wrap when settings actually customize the map so the
@@ -1483,6 +1485,7 @@ async function runAgentHeadlessInWorkspace(
         }
       }
       if (approvalGate) {
+        approvalGate.setAuthorizationConsumer?.(null);
         if (typeof approvalGate.setSessionPolicy === "function") {
           approvalGate.setSessionPolicy(sessionId, perm.sessionPolicy);
         }
@@ -1980,6 +1983,18 @@ async function runAgentHeadlessInWorkspace(
     !options.permissionPromptTool
   ) {
     try {
+      if (
+        !approvalGate ||
+        typeof approvalGate.setConfirmer !== "function" ||
+        typeof approvalGate.setAuthorizationConsumer !== "function" ||
+        typeof approvalGate.consumeAuthorization !== "function"
+      ) {
+        const error = new Error(
+          "installed session-core cannot bind and consume durable remote approval",
+        );
+        error.code = "CC_REMOTE_APPROVAL_GATE_UNAVAILABLE";
+        throw error;
+      }
       const { startHeadlessRemoteApproval } =
         await import("../lib/remote-approval-bridge.js");
       _remoteApproval = await (
@@ -1989,11 +2004,12 @@ async function runAgentHeadlessInWorkspace(
         writeErr,
         isText,
       });
-      if (approvalGate && typeof approvalGate.setConfirmer === "function") {
-        approvalGate.setConfirmer(
-          _bgPhase.wrapConfirmer(_remoteApproval.confirmer),
-        );
-      }
+      approvalGate.setConfirmer(
+        _bgPhase.wrapConfirmer(_remoteApproval.confirmer),
+      );
+      approvalGate.setAuthorizationConsumer(
+        _remoteApproval.consumeAuthorization,
+      );
     } catch (err) {
       // Remote approval could not come up → keep headless fail-closed rather
       // than running un-gated; say why so the user can fix pairing.
@@ -3274,6 +3290,7 @@ async function runAgentHeadlessInWorkspace(
     await cleanupDeadline.run("remote-approval", () =>
       _remoteApproval?.close?.(),
     );
+    approvalGate?.setAuthorizationConsumer?.(null);
     // settings.json Stop + SessionEnd hooks when the run finishes. Stop is the
     // canonical async-hook trigger ("run the test suite at turn end"); fire its
     // async hooks fire-and-forget, then settle so a fast background check can

package/src/runtime/headless-stream.js

@@ -2059,6 +2059,8 @@ async function runAgentHeadlessStreamInWorkspace(
   let approvalGate = null;
   try {
     approvalGate = await getApprovalGate();
+    approvalGate =
+      approvalGate?.createSessionScope?.(sessionId) || approvalGate;
     if (approvalGate && (options.permissionMode || "default") === "auto") {
       // autoMode.decisions: user-configured riskLevel → allow/ask/deny
       // classifier (same wiring as headless-runner). Only wrap when settings
@@ -2082,6 +2084,7 @@ async function runAgentHeadlessStreamInWorkspace(
       }
     }
     if (approvalGate) {
+      approvalGate.setAuthorizationConsumer?.(null);
       approvalGate.setSessionPolicy?.(sessionId, perm.sessionPolicy);
       approvalGate.setConfirmer?.(
         interactive && perm.allowInteractiveApprovals
@@ -2742,6 +2745,18 @@ async function runAgentHeadlessStreamInWorkspace(
     options.interactiveApprovals !== true
   ) {
     try {
+      if (
+        !approvalGate ||
+        typeof approvalGate.setConfirmer !== "function" ||
+        typeof approvalGate.setAuthorizationConsumer !== "function" ||
+        typeof approvalGate.consumeAuthorization !== "function"
+      ) {
+        const error = new Error(
+          "installed session-core cannot bind and consume durable remote approval",
+        );
+        error.code = "CC_REMOTE_APPROVAL_GATE_UNAVAILABLE";
+        throw error;
+      }
       const startRemoteApproval =
         deps.startHeadlessRemoteApproval ||
         (await import("../lib/remote-approval-bridge.js"))
@@ -2757,9 +2772,10 @@ async function runAgentHeadlessStreamInWorkspace(
         remote_session_id: _remoteApproval.pairing.remoteSessionId,
         expires_at: _remoteApproval.pairing.expiresAt,
       });
-      if (approvalGate && typeof approvalGate.setConfirmer === "function") {
-        approvalGate.setConfirmer(_remoteApproval.confirmer);
-      }
+      approvalGate.setConfirmer(_remoteApproval.confirmer);
+      approvalGate.setAuthorizationConsumer(
+        _remoteApproval.consumeAuthorization,
+      );
     } catch (err) {
       emit({
         type: "remote_control",

package/src/workers/background-agent-keeper.js

@@ -27,11 +27,15 @@ import {
   BACKGROUND_AGENT_KEEPER_ARMED,
   BACKGROUND_AGENT_KEEPER_CLEANUP_CONFIRM_TIMEOUT_MS,
   BACKGROUND_AGENT_KEEPER_HELLO,
+  BACKGROUND_AGENT_KEEPER_HEARTBEAT,
+  BACKGROUND_AGENT_KEEPER_HEARTBEAT_TIMEOUT_MS,
+  BACKGROUND_AGENT_KEEPER_PERSIST_RETRY_TIMEOUT_MS,
   BACKGROUND_AGENT_KEEPER_PROTOCOL_VERSION,
   BACKGROUND_AGENT_KEEPER_READY,
   BACKGROUND_AGENT_KEEPER_RETIRE,
   BACKGROUND_AGENT_KEEPER_RETIRED,
   BACKGROUND_AGENT_KEEPER_STATE_LOCK_TIMEOUT_MS,
+  cleanupBackgroundAgentKeeperPipeDirectory,
   createBackgroundAgentKeeperMessage,
   normalizeBackgroundAgentKeeperHello,
   normalizeBackgroundAgentKeeperTurn,
@@ -40,6 +44,50 @@ import {
 
 const STARTUP_TIMEOUT_MS = 30_000;
 const HEARTBEAT_INTERVAL_MS = 1_000;
+const KEEPER_PERSIST_RETRY_DELAY_MS = 50;
+
+function delay(ms) {
+  return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
+
+/**
+ * Retry a cleanup-critical state mutation after a worker is hard-killed.
+ *
+ * A worker can disappear while it owns the cross-process state lock. Windows
+ * may keep that terminated PID observable briefly, so the strict lock cannot
+ * immediately prove the owner dead and correctly fails closed. The keeper is
+ * the only remaining owner of the armed turn; it must wait for that transient
+ * fence instead of turning a lock exception into an unhandled rejection and
+ * exiting with the durable projection still `armed`.
+ */
+export async function retryKeeperPersistence(operation, options = {}) {
+  const now = options.now || Date.now;
+  const sleep = options.sleep || delay;
+  const timeoutMs = Math.max(
+    0,
+    Number(
+      options.timeoutMs ?? BACKGROUND_AGENT_KEEPER_PERSIST_RETRY_TIMEOUT_MS,
+    ),
+  );
+  const retryDelayMs = Math.max(
+    1,
+    Number(options.retryDelayMs ?? KEEPER_PERSIST_RETRY_DELAY_MS),
+  );
+  const deadline = now() + timeoutMs;
+  let attempts = 0;
+  let error = null;
+  for (;;) {
+    attempts += 1;
+    try {
+      return { result: operation(), error: null, attempts };
+    } catch (cause) {
+      error = cause;
+    }
+    const remaining = deadline - now();
+    if (remaining <= 0) return { result: null, error, attempts };
+    await sleep(Math.min(retryDelayMs, remaining));
+  }
+}
 
 function writeMessage(socket, message) {
   if (!socket || socket.destroyed) return false;
@@ -59,6 +107,71 @@ export function keeperWorkerIdentityAlive(
   return probe(Number(workerPid), Number(workerStartedAt));
 }
 
+function reportKeeperPersistenceFailure(stage, error) {
+  try {
+    writeSync(
+      2,
+      `[background-agent-keeper] ${stage} persistence failed: ${error?.stack || error?.message || String(error)}\n`,
+    );
+  } catch {
+    // The inherited diagnostic handle may already be closed.
+  }
+}
+
+export function runBackgroundAgentKeeperHeartbeat({
+  finishing,
+  workerSocket,
+  authenticatedHello,
+  authenticatedWorkerStartedAt,
+  workerHeartbeatAt,
+  armedTurn,
+  persistKeeper,
+  finishForWorkerDisconnect,
+  now = Date.now,
+  workerIdentityAlive = keeperWorkerIdentityAlive,
+  reportPersistenceFailure = reportKeeperPersistenceFailure,
+}) {
+  if (finishing) return false;
+  const currentTime = now();
+  const workerHeartbeatExpired =
+    workerSocket &&
+    authenticatedHello &&
+    Number.isFinite(workerHeartbeatAt) &&
+    currentTime - workerHeartbeatAt >
+      BACKGROUND_AGENT_KEEPER_HEARTBEAT_TIMEOUT_MS;
+  if (
+    workerSocket &&
+    authenticatedHello &&
+    (workerHeartbeatExpired ||
+      (armedTurn &&
+        !workerIdentityAlive(
+          authenticatedHello.workerPid,
+          authenticatedWorkerStartedAt,
+        )))
+  ) {
+    // A Windows named-pipe handle and process object can remain observable
+    // after its worker dies if a platform helper retained a duplicate.
+    // Socket EOF and PID visibility are therefore not sufficient lifetime
+    // signals. The authenticated application heartbeat provides an
+    // independent bounded fence, while the PID/start anchor remains the
+    // immediate path on platforms that report death promptly.
+    finishForWorkerDisconnect();
+    workerSocket.destroy();
+    return false;
+  }
+  try {
+    persistKeeper({ keeperHeartbeatAt: currentTime });
+    return true;
+  } catch (error) {
+    try {
+      reportPersistenceFailure("heartbeat", error);
+    } catch {
+      // Diagnostics are best effort and must not escape the timer callback.
+    }
+    return false;
+  }
+}
+
 function stateOwnsTurn(state, turn) {
   return Boolean(
     state &&
@@ -90,35 +203,77 @@ function persistKeeperTurn(job, turn, patch) {
   );
 }
 
+export function stopBackgroundAgentKeeperTurnTrees(targets, options = {}) {
+  const platform = options.platform || process.platform;
+  const processAlive = options.isProcessAlive || isProcessAlive;
+  const processTreeExecutionAlive =
+    options.isProcessTreeExecutionAlive ||
+    isBackgroundProcessTreeExecutionAlive;
+  const stopTree = options.stopProcessTree || stopBackgroundAgentChildTree;
+  const failures = [];
+  let precedingTreeStopSucceeded = false;
+  for (const target of targets) {
+    // On Windows the wrapper's taskkill /T also retires its runtime child.
+    // Avoid starting a second bounded taskkill for a target the first tree
+    // operation already proved absent; under 20-way churn that redundant
+    // command can consume the keeper's entire cleanup SLO. Never skip the
+    // first root merely because its leader exited: POSIX descendants can keep
+    // executing in the leader's process group and still require a group kill.
+    if (precedingTreeStopSucceeded && !processAlive(target.pid)) continue;
+    try {
+      stopTree(target.pid, {
+        signal: "SIGKILL",
+        expectedStartedAt: target.startedAt,
+        processGroup: target.processGroup,
+        strictIdentity: true,
+        allowDirectFallback: false,
+      });
+      precedingTreeStopSucceeded = true;
+    } catch (error) {
+      // A detached POSIX group can keep executing after its leader exits. Do
+      // not discard the strict stop failure from a leader-only liveness probe;
+      // the group-aware residual check preserves the actionable identity
+      // reason while descendants remain executable.
+      const leaderAlive = processAlive(target.pid);
+      const residualAlive =
+        leaderAlive ||
+        (platform !== "win32" &&
+          target.processGroup === true &&
+          processTreeExecutionAlive(target.pid, target.startedAt));
+      if (residualAlive) {
+        failures.push(error?.message || String(error));
+      }
+    }
+  }
+  return failures;
+}
+
 async function cleanupTurn(job, turn, reason) {
   const requestedAt = Date.now();
-  persistKeeperTurn(job, turn, {
-    turnKeeperStatus: "cleanup-requested",
-    turnKeeperCleanupReason: reason,
-    turnKeeperCleanupRequestedAt: requestedAt,
-  });
+  const requestedPersistence = await retryKeeperPersistence(() =>
+    persistKeeperTurn(job, turn, {
+      turnKeeperStatus: "cleanup-requested",
+      turnKeeperCleanupReason: reason,
+      turnKeeperCleanupRequestedAt: requestedAt,
+    }),
+  );
 
   const targets = [
-    { pid: turn.agentPid, startedAt: turn.agentStartedAt },
+    {
+      pid: turn.agentPid,
+      startedAt: turn.agentStartedAt,
+      processGroup: true,
+    },
     {
       pid: turn.agentRuntimePid,
       startedAt: turn.agentRuntimeStartedAt,
+      processGroup: false,
     },
   ].filter(
     (target, index, values) =>
       values.findIndex((candidate) => candidate.pid === target.pid) === index,
   );
-  const failures = [];
-  for (const target of targets) {
-    try {
-      stopBackgroundAgentChildTree(target.pid, { signal: "SIGKILL" });
-    } catch (error) {
-      // A preceding wrapper/group signal may already have retired this root.
-      if (isProcessAlive(target.pid)) {
-        failures.push(error?.message || String(error));
-      }
-    }
-  }
+  const failures = stopBackgroundAgentKeeperTurnTrees(targets);
 
   const deadline =
     Date.now() + BACKGROUND_AGENT_KEEPER_CLEANUP_CONFIRM_TIMEOUT_MS;
@@ -132,19 +287,37 @@ async function cleanupTurn(job, turn, reason) {
     );
   }
   const confirmed = alive.length === 0 && failures.length === 0;
-  persistKeeperTurn(job, turn, {
-    turnKeeperStatus: confirmed ? "retired" : "cleanup-unconfirmed",
-    turnKeeperCleanupReason: reason,
-    turnKeeperCleanupRequestedAt: requestedAt,
-    turnKeeperCleanupConfirmedAt: confirmed ? Date.now() : null,
-    turnKeeperCleanupError:
-      failures.length > 0
-        ? failures.join("; ").slice(0, 1_000)
-        : alive.length > 0
-          ? `process tree still executable: ${alive.map(({ pid }) => pid).join(",")}`
-          : null,
+  let finalPersistenceAttempts = 0;
+  const finalPersistence = await retryKeeperPersistence(() => {
+    finalPersistenceAttempts += 1;
+    return persistKeeperTurn(job, turn, {
+      turnKeeperStatus: confirmed ? "retired" : "cleanup-unconfirmed",
+      turnKeeperCleanupReason: reason,
+      turnKeeperCleanupRequestedAt: requestedAt,
+      turnKeeperCleanupConfirmedAt: confirmed ? Date.now() : null,
+      turnKeeperCleanupError:
+        failures.length > 0
+          ? failures.join("; ").slice(0, 1_000)
+          : alive.length > 0
+            ? `process tree still executable: ${alive.map(({ pid }) => pid).join(",")}`
+            : null,
+      turnKeeperPersistenceRetries:
+        Math.max(0, requestedPersistence.attempts - 1) +
+        Math.max(0, finalPersistenceAttempts - 1),
+    });
   });
-  return { confirmed, failures, alive };
+  const persistenceError = finalPersistence.error
+    ? finalPersistence.error?.message || String(finalPersistence.error)
+    : finalPersistence.result?.applied === false
+      ? "keeper cleanup state no longer owned"
+      : null;
+  if (persistenceError) failures.push(persistenceError);
+  return {
+    confirmed: confirmed && !persistenceError,
+    failures,
+    alive,
+    persistenceError,
+  };
 }
 
 export async function runBackgroundAgentKeeper(jobFile, options = {}) {
@@ -182,6 +355,7 @@ export async function runBackgroundAgentKeeper(jobFile, options = {}) {
   let candidateSocket = null;
   let authenticatedHello = null;
   let authenticatedWorkerStartedAt = null;
+  let workerHeartbeatAt = null;
   let armedTurn = null;
   let finishing = false;
   let finishResolve;
@@ -206,17 +380,50 @@ export async function runBackgroundAgentKeeper(jobFile, options = {}) {
     if (finishing) return false;
     finishing = true;
     const active = armedTurn;
-    void (
-      active
-        ? cleanupTurn(job, active, "worker-disconnected")
-        : Promise.resolve({ confirmed: true })
-    ).finally(() => {
-      persistKeeper({
-        keeperStatus: active ? "worker-disconnected" : "closed",
-        keeperEndedAt: Date.now(),
-      });
+    void (async () => {
+      let cleanup;
+      try {
+        cleanup = active
+          ? await cleanupTurn(job, active, "worker-disconnected")
+          : { confirmed: true, failures: [], alive: [] };
+      } catch (error) {
+        cleanup = {
+          confirmed: false,
+          failures: [error?.message || String(error)],
+          alive: [],
+        };
+      }
+      // Closing the keeper must never be skipped because one final metadata
+      // update throws. Retry the critical status write, retain the failure in
+      // the log, and always settle the server promise without an unhandled
+      // rejection.
+      const persisted = await retryKeeperPersistence(() =>
+        persistKeeper({
+          keeperStatus: active
+            ? cleanup.confirmed
+              ? "worker-disconnected"
+              : "cleanup-unconfirmed"
+            : "closed",
+          keeperEndedAt: Date.now(),
+          ...(cleanup.failures.length > 0
+            ? {
+                keeperError: cleanup.failures.join("; ").slice(0, 1_000),
+              }
+            : {}),
+        }),
+      );
+      if (persisted.error) {
+        try {
+          writeSync(
+            2,
+            `[background-agent-keeper] final state persistence failed: ${persisted.error?.stack || persisted.error?.message || String(persisted.error)}\n`,
+          );
+        } catch {
+          // The inherited diagnostic handle may already be closed.
+        }
+      }
       server.close(() => finishResolve({ status: "closed" }));
-    });
+    })();
     return true;
   };
 
@@ -267,6 +474,7 @@ export async function runBackgroundAgentKeeper(jobFile, options = {}) {
             authenticated = true;
             authenticatedHello = hello;
             authenticatedWorkerStartedAt = Number(current.startedAt);
+            workerHeartbeatAt = Date.now();
             workerSocket = socket;
             clearTimeout(helloTimer);
             persistKeeper({ keeperStatus: "ready", keeperReadyAt: Date.now() });
@@ -284,6 +492,20 @@ export async function runBackgroundAgentKeeper(jobFile, options = {}) {
             return;
           }
 
+          if (message.type === BACKGROUND_AGENT_KEEPER_HEARTBEAT) {
+            if (
+              message.id !== authenticatedHello.id ||
+              message.workerGeneration !==
+                authenticatedHello.workerGeneration ||
+              Number(message.workerPid) !== authenticatedHello.workerPid
+            ) {
+              socket.destroy();
+              return;
+            }
+            workerHeartbeatAt = Date.now();
+            return;
+          }
+
           if (
             message.type !== BACKGROUND_AGENT_KEEPER_ARM &&
             message.type !== BACKGROUND_AGENT_KEEPER_RETIRE
@@ -413,26 +635,20 @@ export async function runBackgroundAgentKeeper(jobFile, options = {}) {
     socket.once("error", disconnected);
   });
 
-  const heartbeat = setInterval(() => {
-    if (
-      workerSocket &&
-      authenticatedHello &&
-      armedTurn &&
-      !keeperWorkerIdentityAlive(
-        authenticatedHello.workerPid,
+  const heartbeat = setInterval(
+    () =>
+      runBackgroundAgentKeeperHeartbeat({
+        finishing,
+        workerSocket,
+        authenticatedHello,
         authenticatedWorkerStartedAt,
-      )
-    ) {
-      // A Windows named-pipe handle can remain open after its worker dies if a
-      // platform helper retained a duplicate. Socket EOF alone is therefore
-      // not a sufficient lifetime signal. The generation-bound worker PID and
-      // its durable launch anchor provide an independent identity fence.
-      finishForWorkerDisconnect();
-      workerSocket.destroy();
-      return;
-    }
-    persistKeeper({ keeperHeartbeatAt: Date.now() });
-  }, HEARTBEAT_INTERVAL_MS);
+        workerHeartbeatAt,
+        armedTurn,
+        persistKeeper,
+        finishForWorkerDisconnect,
+      }),
+    HEARTBEAT_INTERVAL_MS,
+  );
   heartbeat.unref?.();
   const startupTimer = setTimeout(
     () => {
@@ -464,6 +680,11 @@ export async function runBackgroundAgentKeeper(jobFile, options = {}) {
     } catch {
       // Already removed or never materialized.
     }
+    try {
+      cleanupBackgroundAgentKeeperPipeDirectory(job.pipePath);
+    } catch {
+      // Another keeper can still own a sibling socket in the shared namespace.
+    }
   }
   return {
     ...result,

package/src/workers/background-agent-worker.js

@@ -1472,6 +1472,13 @@ async function main() {
       },
       onStop: () => {
         if (!child) return;
+        // An explicit stop owns this turn's termination. Detach the bootstrap
+        // release callback before killing the child so a late IPC EPIPE cannot
+        // reclassify the intentional stop as a post-spawn launch failure. The
+        // child termination settlement remains attached and advances any
+        // queued follow-up turn after the tree is confirmed closed.
+        detachTurnBootstrapHandler?.();
+        detachTurnBootstrapHandler = null;
         // The agent child is detached into its own group on POSIX; Windows
         // requires brokered taskkill /T /F so tool grandchildren cannot
         // survive an attached-session stop.

package/src/workers/background-turn-bootstrap.js

@@ -14,6 +14,7 @@ import {
   BACKGROUND_TURN_BOOTSTRAP_RELEASE,
   backgroundTurnBootstrapBindingFromEnvironment,
   clearBackgroundTurnBootstrapEnvironment,
+  containReleasedBackgroundTurnDisconnect,
   createBackgroundTurnBootstrapMessage,
   matchesBackgroundTurnBootstrapMessage,
   removeBackgroundTurnBootstrapImport,
@@ -31,12 +32,16 @@ function releaseTimeoutMs() {
   return Math.max(10, Math.min(TEST_RELEASE_TIMEOUT_MAX_MS, requested));
 }
 
-function failClosed(message) {
+function reportFailure(message) {
   try {
     writeSync(2, `[background-turn-bootstrap] ${message}\n`);
   } catch {
     // The inherited diagnostic handle may already be closed.
   }
+}
+
+function failClosed(message) {
+  reportFailure(message);
   process.exit(1);
 }
 
@@ -68,6 +73,28 @@ await new Promise((resolve) => {
     failClosed(message);
   };
 
+  const containDisconnectOnce = (message) => {
+    if (failed) return;
+    failed = true;
+    if (timer) clearTimeout(timer);
+    if (readyTimer) clearInterval(readyTimer);
+    // Emit the original diagnostic before SIGSTOP freezes this process and
+    // every descendant in its detached POSIX group. If the stop fails (or a
+    // later SIGCONT lets the helper's fail-safe SIGKILL fail), retain the
+    // historical single-process fail-closed exit.
+    reportFailure(message);
+    if (
+      containReleasedBackgroundTurnDisconnect({
+        released,
+        currentPid: binding.pid,
+        onResumedKillFailure: () => process.exit(1),
+      })
+    ) {
+      return;
+    }
+    process.exit(1);
+  };
+
   const onMessage = (message) => {
     if (message?.type !== BACKGROUND_TURN_BOOTSTRAP_RELEASE) return;
     if (released) {
@@ -109,7 +136,7 @@ await new Promise((resolve) => {
   // supervising worker remains fail-closed even after the real CLI starts.
   process.on("message", onMessage);
   process.once("disconnect", () =>
-    failOnce("worker IPC disconnected before turn completion"),
+    containDisconnectOnce("worker IPC disconnected before turn completion"),
   );
   timer = setTimeout(
     () => failOnce("timed out waiting for durable turn release"),

package/src/assets/web-panel/assets/MarkdownRenderer-GmB6DOr6.js

@@ -1 +0,0 @@
-import{P as c,J as p,b as s}from"./vendor-Bn1JzzAn.js";import{r as a}from"./markdown-Yo_c6Krv.js";import{_ as d}from"./index-BQ3DXBtD.js";const _={__name:"MarkdownRenderer",props:{content:{type:String,default:""}},setup(t,{expose:o}){o();const e=t,r=s(()=>a(e.content||"")),n={props:e,rendered:r,computed:s,get renderMarkdown(){return a}};return Object.defineProperty(n,"__isScriptSetup",{enumerable:!1,value:!0}),n}},i=["innerHTML"];function m(t,o,e,r,n,u){return c(),p("div",{class:"markdown-content",innerHTML:r.rendered},null,8,i)}const M=d(_,[["render",m],["__scopeId","data-v-0b0b9f63"],["__file","/tmp/cc-web-panel-J6U3Mt/repo/packages/web-panel/src/components/MarkdownRenderer.vue"]]);export{M};

package/src/assets/web-panel/assets/MobileProjects-BL0Czcoj.js

@@ -1 +0,0 @@
-import{I as n,J as g,c as l,K as r,N as u,P as h,U as o,R as t,Q as b}from"./vendor-Bn1JzzAn.js";import{_ as v,b as m}from"./index-BQ3DXBtD.js";import{a8 as M,M as y}from"./icons-DG5UD-6K.js";const B={__name:"MobileProjects",setup(p,{expose:i}){i();const c=u(),{t:e}=m();function a(){c.push("/projects")}function _(){c.push("/mobile-bridge")}const s={router:c,t:e,goToProjects:a,goToMobileBridge:_,get useRouter(){return u},get useI18n(){return m},get MobileOutlined(){return y},get FolderOutlined(){return M}};return Object.defineProperty(s,"__isScriptSetup",{enumerable:!1,value:!0}),s}},x={class:"mobile-projects-placeholder"},O={class:"title"},k={class:"subtitle"},w={class:"explainer"};function T(p,i,c,e,a,_){const s=n("a-alert"),d=n("a-button"),f=n("a-space"),P=n("a-empty"),j=n("a-card");return h(),g("div",x,[l(j,null,{default:r(()=>[l(P,{description:!1},{image:r(()=>[l(e.MobileOutlined,{style:{fontSize:"64px",color:"#bfbfbf"}})]),default:r(()=>[o("h2",O,t(e.t("mobileProjects.title")),1),o("p",k,t(e.t("mobileProjects.subtitle")),1),l(s,{message:e.t("mobileProjects.v02Banner"),type:"info","show-icon":"",class:"banner"},null,8,["message"]),o("div",w,[o("h3",null,t(e.t("mobileProjects.currentDirection")),1),o("p",null,t(e.t("mobileProjects.currentDirectionBody")),1),o("ul",null,[o("li",null,t(e.t("mobileProjects.stepPhone")),1),o("li",null,t(e.t("mobileProjects.stepTap")),1),o("li",null,t(e.t("mobileProjects.stepPull")),1)]),o("h3",null,t(e.t("mobileProjects.reverseDirection")),1),o("p",null,t(e.t("mobileProjects.reverseDirectionBody")),1)]),l(f,{class:"actions"},{default:r(()=>[l(d,{type:"primary",onClick:e.goToProjects},{default:r(()=>[l(e.FolderOutlined),b(" "+t(e.t("mobileProjects.viewLocalProjects")),1)]),_:1}),l(d,{onClick:e.goToMobileBridge},{default:r(()=>[l(e.MobileOutlined),b(" "+t(e.t("mobileProjects.checkBridge")),1)]),_:1})]),_:1})]),_:1})]),_:1})])}const N=v(B,[["render",T],["__scopeId","data-v-9262cc45"],["__file","/tmp/cc-web-panel-J6U3Mt/repo/packages/web-panel/src/views/MobileProjects.vue"]]);export{N as default};